Perché il mio KnockoutJS personalizzato legame essere attivati?

Question

Ho una situazione strana. Fondamentalmente, ho due associazioni personalizzate che vengono utilizzati per animare l'elemento DOM ad esso di nuovo valore. Questi sono aWidth e rettamente, che animare rispettivamente giusti valori di larghezza e.

Ho implementato le associazioni in questo modo:

<div class='classname' data-bind="aRight: right, aWidth: containerWidth, style: { zIndex: zindex, left: (left() + 'px'), height: (containerHeight() + 'px') }">

... e le associazioni personalizzate simile a questa:

            ko.bindingHandlers.aWidth =
            {
                update: function (element, valueAccessor, allBindingsAccessor, context)
                {
                    // Get the value accessor
                    var value = valueAccessor();

                    // Get the new width and the duration of the animation
                    var newWidth = ko.utils.unwrapObservable(value);
                    var duration = 500;

                    $(element).animate({ width: newWidth }, duration, "swing");
                }
            };

            ko.bindingHandlers.aRight =
            {
                update: function (element, valueAccessor, allBindingsAccessor, context)
                {
                    // Get the value accessor
                    var value = valueAccessor();

                    // Get the new width and the duration of the animation
                    var newRight = ko.utils.unwrapObservable(value);
                    var duration = 500;

                    $(element).animate({ right: newRight }, duration, "swing");

                    console.log("aRight Called: newRight - " + newRight + ", duration - " + duration);
                }
            };

Quindi, il problema viene intorno quando cambiamo un'osservabile diverso da miei due osservabili personalizzati legato, per esempio zIndex.

Se si cambia la zIndex osservabile, il valore viene aggiornato correttamente nel DOM, ma per qualche ragione, il mio bene vincolante anche viene attivato! ...

Non ho alcun riferimento ad esso nella mia vincolante rettamente personalizzato quindi non c'è di certo non può essere una dipendenza?

vincolante anche il mio bene viene attivato quando il mio aWidth legame viene attivato troppo, che è anche un po '!' Strano

Qualcuno ha qualche idea su questo?

Grazie mille!

Andy.

Aggiorna

Questa è la parte del modello di visualizzazione che aggiorna l'indice, che quando provoca vincolante il mio bene personalizzato al fuoco (questo è molto psudo-code tra l'altro!):

    var page = function()
    {
        this.zindex = ko.observable(0);
        this.right = ko.observable(0);
        // and other observables....
    }

    var viewModel = function()
    {
        var pages = ko.oberservableArray();
        // populate the pages array etc...

        this.someMethod = function()
        {
            // Do some stuff...
            this.anotherMethod();
            // Do some other stuff
        }
        .bind(this);

        this.anotherMethod() = function
        {
            var pageCount = this.pages().length;
            for (var pageNum = 0; pageNum < pageCount; pageNum++)
            {
                var page = this.pages()[pageNum];
                page.zindex(/* a different value */); // This is what causes my aRight binding to fire...
            }
        }
        .bind(this);
    }

Aggiorna

Ho appena letto un post qui: http://groups.google.com/group/knockoutjs/browse_thread/thread/26a3157ae68c7aa5/44c96d1b748f63bb?lnk=gst&q=custom+binding+firing#44c96d1b748f63bb

dicendo:

Inoltre, un legame avrà la sua funzione corsa aggiornamento, se un'altra vincolante nello stesso attributo data-bind viene attivato pure.

Questo significa che quello che sto vedendo è che il mio legame personalizzato viene attivato quando qualsiasi altro legame della in attributo data-bind viene attivato (si dà il caso che forse zindex è il primo che vedo il cambiamento)? Non è forse questo un po 'strano / sbagliato? ...

Aggiorna

Ho una semplice violino che mi sembra praticamente riassume il mio problema. Sembra come ogni vincolante per lo stesso attributo data-bind quanto più vincolante personalizzato provoca l'aggiornamento!

http://jsfiddle.net/J6EPx/2/

Hmmm ... Immagino che dovrò lavorare intorno ad esso controllando manualmente nella mia abitudine vincolante se il valore è effettivamente cambiato o no !! Questo non è sconfiggere quel punto effettivo di un ???

vincolante

Ho anche inviato una domanda più precisa sul forum Knockout: http : //groups.google.com/group/knockoutjs/browse_thread/thread/d2290d96e33f1d5a

Answer 1

Questo è attualmente alla progettazione. Tutti gli attacchi in un data-bind vengono attivati ??quando qualsiasi di attacchi di fuoco. Questo è perché sono tutti avvolti in un singolo dependentObservable. In alcuni casi, attacchi hanno una dipendenza tra l'altro (se le opzioni sono aggiornati, poi le esigenze di valore per l'esecuzione al fine di garantire che sia ancora un valore valido). Tuttavia, in alcuni casi, questo non causare un problema.

C'è un modello diverso che è possibile utilizzare quando si crea un legame che aiuta a mitigare questo comportamento personalizzato. Invece di definire il coraggio della vostra funzionalità nella funzione "update", si sarebbe effettivamente creare il proprio dependentObservable nella funzione "init". Sarebbe simile:

ko.bindingHandlers.custBinding= {
    init: function(element, valueAccessor) {
        ko.dependentObservable({
            read: function() {
                ko.utils.unwrapObservable(valueAccessor());
                alert("custBinding triggered"); 
            },
            disposeWhenNodeIsRemoved: element
        });
    }
};

http://jsfiddle.net/rniemeyer/uKUfy/