Pourquoi mon KnockoutJS liaison personnalisée déclenchées?

Question

J'ai une situation étrange. Au fond, j'ai deux liaisons personnalisées qui sont utilisées pour animer l'élément DOM à la nouvelle valeur de lui. Ce sont aWidth et aright, qui animent la largeur et à droite respectivement.

Je l'ai mis en œuvre les liaisons comme ceci:

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

... et les liaisons personnalisées ressemblent à ceci:

            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);
                }
            };

Le problème est là quand on change un autre observable que mes deux liés personnalisés observables, par exemple zindex.

Si nous changeons l'zindex observable, la valeur est mise à jour correctement dans les DOM, mais pour une raison quelconque, mon aright se liant également déclenché! ...

Je n'ai aucune référence dans ma aright mesure obligatoire donc il ne peut certainement pas une dépendance?

Mon aright contraignant obtient également déclenché quand mon aWidth liaison est trop déclenchée, ce qui est aussi un peu! Impair

Est-ce que quelqu'un a des idées à ce sujet?

Merci beaucoup!

Andy.

Mise à jour

Ceci est la partie du modèle de vue qui met à jour l'index, qui, lorsqu'il provoque ma aright liaison personnalisée au feu (ce qui est très psudo code de la route!):

    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);
    }

Mise à jour

Je viens de lire un message ici: http://groups.google.com/group/knockoutjs/browse_thread/thread/26a3157ae68c7aa5/44c96d1b748f63bb?lnk=gst&q=custom+binding+firing#44c96d1b748f63bb

En disant:

En outre, une fixation aura sa course fonction de mise à jour à nouveau, si une autre liaison dans le même attribut bind-données est déclenché aussi bien.

Est-ce que cela veut dire que ce que je vois est que mon habitude liaison est déclenchée lorsque toute autre liaison l'attribut de données dans BIND est déclenchée (il se trouve peut-être que zindex est la première que je vois le changement)? Est-ce pas un peu mal de / impair? ...

Mise à jour

J'ai simple violon que je pense que résume assez bien mon problème. Il semble que toute liaison sur le même attribut bind-données comme liant beaucoup plus personnalisée fera à jour!

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

Hmmm ... crois que je vais travailler autour d'elle en vérifiant manuellement dans ma liaison personnalisée pour savoir si la valeur a réellement changé ou non !! Est-ce pas la défaite ce point réel d'une liaison de ???

J'ai également posté une question plus précise sur les forums knock-out: http : //groups.google.com/group/knockoutjs/browse_thread/thread/d2290d96e33f1d5a

Answer 1

est en cours de conception. Toutes les fixations dans une liaison de données sont déclenchées lorsque l'un feu de fixations. En effet, ils sont tous enveloppés dans un seul dependentObservable. Dans certains cas, les liaisons ont une dépendance entre eux (si les options sont mises à jour, puis les besoins de valeur à courir pour vous assurer qu'il est toujours une valeur valide). Cependant, dans certains cas, cela ne pose un problème.

Il y a un autre motif que vous pouvez utiliser lors de la création d'une liaison personnalisée qui aide à atténuer ce comportement. Au lieu de définir le courage de votre fonctionnalité dans la fonction « mise à jour », vous réellement créer votre propre dependentObservable dans la fonction « init ». Il ressemblerait à ceci:

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/