javascript - pass - purecomputed knockout js

¿Por qué mi ko computable observable no actualiza los elementos de UI enlazados cuando cambia su valor?

Question

Estoy tratando de envolver una cookie en un observable computarizado (que luego me convertiré en un protectedObservable) y estoy teniendo algunos problemas con el observable computado. Estaba bajo la opinión de que los cambios en el observable calculado se transmitirían a cualquier elemento de UI que se haya vinculado a él.

He creado el siguiente violín.

JavaScript :

var viewModel = {};
// simulating a cookie store, this part isnt as important
var cookie = function () {
// simulating a value stored in cookies
var privateZipcode = "12345";
return {
''write'' : function (val) { privateZipcode = val; },
''read'': function () { return privateZipcode; }
}
}();
viewModel.zipcode = ko.computed({
read: function () {
return cookie.read();
},
write: function (value) {
cookie.write(value);
},
owner: viewModel
});
ko.applyBindings(viewModel);?

HTML :

zipcode:
<input type=''text'' data-bind="value: zipcode"> <br />
zipcode:
<span data-bind="text: zipcode"></span>?

No estoy usando un observable para almacenar privateZipcode ya que eso realmente va a estar en una cookie. Espero que ko.computed proporcione las notificaciones y la funcionalidad de enlace que necesito, aunque la mayoría de los ejemplos que he visto con ko.computed terminan usando un ko.observable debajo de las cubiertas.

¿El hecho de escribir el valor en mi observable computado no debería indicar los elementos de la IU que están vinculados a su valor? ¿No deberían estos solo actualizar?

Solución

Tengo una solución sencilla en la que simplemente uso un ko.observable junto a mi tienda de cookies y el uso activará las actualizaciones necesarias para mis elementos DOM, pero esto parece completamente innecesario, a menos que ko.computed carezca de la funcionalidad de tipo de señalización / dependencia que tiene ko.observable .

Mi solución temporal , notará que lo único que cambia es que agregué un servicio seperateObservable que no se usa como almacén, su único propósito es señalar a la interfaz de usuario que los datos subyacentes han cambiado.

// simulating a cookie store, this part isnt as important
var cookie = function () {
// simulating a value stored in cookies
var privateZipcode = "12345";
// extra observable that isnt really used as a store, just to trigger updates to the UI
var seperateObservable = ko.observable(privateZipcode);
return {
''write'' : function (val) {
privateZipcode = val;
seperateObservable(val);
},
''read'': function () {
seperateObservable();
return privateZipcode;
}
}
}();

Esto tiene sentido y funciona como lo esperaría porque viewModel.zipcode depende de viewModel.zipcode y las actualizaciones a las que debería (y lo hace) señalar a la interfaz de usuario que se actualizará. Lo que no entiendo es por qué una llamada a la función de write en mi ko.computed la interfaz de usuario que se actualice, ya que ese elemento está vinculado a ese ko.computed .

Sospeché que podría tener que usar algo en el nocaut para indicar manualmente que mi ko.computed se ha actualizado, y estoy de acuerdo con eso, eso tiene sentido. Simplemente no he podido encontrar una manera de lograr eso.

Answer 1

Trate de hacer su código privado interno un observable. Consulte aquí: http://jsfiddle.net/KodeKreachor/fAGes/9/

Answer 2

suspiro, encontré a alguien con mi mismo problema exacto

Si no pueden notificar a los suscriptores dependientes en escritura, ¿por qué se molestan en hacerlo en lectura? Se agregan a la lista de observables y se suscriben, pero nunca se activan las actualizaciones. Entonces, ¿cuál es el punto de suscribirse a ellos en absoluto?

Ryan Niemeyer responde:

Pienso que para su situación, dependerObservables puede no ser la herramienta adecuada para el trabajo. DependientesObservables se configuran para detectar dependencias en la función de lectura y reevaluar / notificar cuando cualquiera de esas dependencias cambie. En una Oficina de escritura dependiente, la función de escritura es en realidad solo un lugar para interceptar la escritura y le permite configurar los observables necesarios, de modo que su función de lectura devolverá el valor adecuado (escribir es normalmente el reverso de la lectura en la mayoría de los casos, a menos que están transformando el valor).

Para su caso, personalmente usaría un observable para representar el valor y luego una suscripción manual a ese observable para actualizar el valor original (sobre el cual puede que no tenga control).

Sería como: http://jsfiddle.net/rniemeyer/Nn5TH/

Así que parece que este violín sería una solución.

var viewModel = {};
// simulating a cookie store, this part isnt as important
var cookie = function () {
// simulating a value stored in cookies
var privateZipcode = "12345";
return {
''write'' : function (val) {
console.log("updated cookie value with: " + val);
privateZipcode = val;
},
''read'': function () {
return privateZipcode;
}
}
}();
viewModel.zipcode = ko.observable(cookie.read());
// manually update the cookie when the observable changes
viewModel.zipcode.subscribe(function(newValue) {
cookie.write(newValue);
});
ko.applyBindings(viewModel);​

Eso tiene sentido y es algo más fácil de usar. En general, no estoy seguro de qué tan buena idea es tratar una cookie como un elemento observable, ya que el servidor podría editarlo en una solicitud ajax, etc.