Estoy tratando de envolver una cookie en un calculada observable (la que me voy más tarde se convertirá en un protectedObservable) y estoy teniendo algunos problemas con la calculada observable. Yo tenía la opinión de que los cambios a la calculada observable serían transmitidos a cualquier elementos de interfaz de usuario que han sido enlazados 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>?

Que no voy a usar un observable para almacenar privateZipcode ya que realmente sólo va a ser en una cookie. Tengo la esperanza de que el ko.computed proporcionará las notificaciones y la funcionalidad de enlace que necesito, a pesar de que la mayoría de los los ejemplos que he visto con ko.computed terminar con un ko.observable debajo de las cubiertas.

No el acto de escribir el valor a mi calculada observables de la señal de la interfaz de usuario elementos que están obligados a su valor? No estas solo actualizar?

Solución

Tengo una solución simple, donde sólo tiene que utilizar una ko.observable a lo largo del lado de mi almacén de cookies y el uso que va a desencadenar las actualizaciones necesarias a mi de elementos del DOM, pero esto parece completamente innecesario, a menos que ko.computed carece de señalización /tipo de dependencia de la funcionalidad que ko.observable ha.

Mi solución violín, te darás cuenta de que la única cosa que cambia es que he añadido un seperateObservable que no se usa como una tienda, su único propósito es la señal de la interfaz de usuario que los datos subyacentes ha 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 se esperaba debido a que viewModel.zipcode depende de seperateObservable y actualizaciones que debe (y) de la señal de la interfaz de usuario de actualización. Lo que no entiendo, es por qué no una llamada a la write función en mi ko.computed de la señal de la interfaz de usuario de actualización, ya que ese elemento está vinculado a que ko.computed?

Yo sospechaba que voy a tener que usar algo en octavos de final manualmente la señal de que mi ko.computed ha sido actualizado, y estoy bien con eso, que tiene sentido. No he sido capaz de encontrar una manera de lograr eso.

InformationsquelleAutor Allen Rice | 2012-03-21

2 Comentarios

  1. 18

    suspiro, he encontrado a alguien con mi mismo problema

    Si dependentObservables no notifySubscribers en escribir, ¿por qué hacen
    incluso se molestan en hacerlo en la lectura? Que se añaden a la lista de características observables
    y suscrito, pero luego nunca se desencadenan en las actualizaciones. Entonces, ¿qué es
    el punto de suscribirse a ellos?

    Ryan Niemeyer respuestas:

    Creo que para el escenario dependentObservables no puede ser el
    herramienta correcta para el trabajo. dependentObservables está configurado para detectar
    dependencias en la función de lectura y re-evaluar/notificar cada vez que cualquier
    de esas dependencias cambio. En una escritura de la dependentObservable, el
    escribir la función en realidad es sólo un lugar para interceptar la escritura y permitir
    que para establecer cualquier observables necesario, de tal manera que su función de lectura
    devuelve el valor correcto (escribir normalmente es la inversa de leer
    en la mayoría de los casos, a menos que usted está transformando el valor).

    Para tu caso, yo personalmente uso un observable para representar la
    valor y, a continuación, un manual de suscripción para que los observables para la actualización de la
    valor original (el que no puede tener control sobre).

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

    Por lo que se ve como 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);​

    Que tiene sentido y que es algo más sencillo de usar. En general no estoy seguro de lo grande de una idea es tratar de una cookie como un observable desde el servidor podría modificar en una petición ajax, etc.

  2. 0

    Trate de hacer su interna privatezipcode de un observable. Ver aquí: http://jsfiddle.net/KodeKreachor/fAGes/9/

    • es realmente la escritura / lectura de ese valor a través de $.cookie.get() y $.cookie.set(), simulada a través de cookie en mi ejemplo. No tengo la capacidad de hacer que un observable, aparte de lo que yo estoy tratando de hacer en mi ko.computed observable en sí. La idea es que ko.computed podría encapsular la escritura / lectura de la cookie, que es por eso que yo no soy un gran fan de la utilización subscribe.
    • A la derecha, pero si la cookie objeto no tiene nada intrínseco a la misma que la cobertura de la dependencia sistema de seguimiento de la pista, a continuación, probablemente usted está fuera de suerte. Si usted acaba de hacer su interna privateZipcode de un observable, entonces usted debería ser capaz de ver el valor de actualización.
    • Así que la cookie objeto en sí mismo no es un observable, sólo contiene un observable de modo que se puede seguir cuando se escribe.
    • Esencialmente, usted está sugiriendo lo mismo que Niemeyer es, y voy a def +1 para que. Él da un paso más (y esto es lo que me estaba poniendo a) básicamente diciendo: «la guarda en un observables y suscribirse a él». Al hacer esto, se elimina completamente la necesidad de tener un ko.computed a todos. Esa es la única diferencia entre los dos enfoques.
    • Fresco, tiene sentido

Dejar respuesta

Please enter your comment!
Please enter your name here