Gibt es eine Möglichkeit ein, ohne Auslösen den Beobachter Rückruf in Polymer

Question

Wie der Titel schon sagt, im Wert zu ändern beobachtet. Gibt es eine Möglichkeit, einen beobachteten Wert zu ändern, ohne den Beobachter-Rückruf in Polymer auszulösen?

Zum Beispiel

Polymer({ 
     is: 'my-component', 

     properties: { 
      aValue: { 
       type: Number, 
       value: 0, 
       observer: '_valueChanged', 
       notify: true 
      }, 
      ref: { 
       type: Object, 
       computed: '_computeRef(channel, channelNumber)' 
      } 
     }, 

     _computeRef: function(channel, channelNumber) { 

      var ref = new Firebase("/*link*/"); 
      ref.on("child_changed", function(data) { 
       this.aValue.setWithoutCallingObserver(data.val()); 
      }.bind(this)); 

      return ref; 
     }, 

     _valueChanged: function() { 
      var message = { aValue: this.aValue }; 
      if (this.ref) { 
       this.ref.set(message); 
      } 
     } 

    }); 

Dies wäre nützlich, weil ich jetzt liegt in dem folgende Szenario erlebe:

1. Anpassung aValue in einem Drittanbieter-App
2. Firebase-Updates alle Clients
3. Der .on Rückruf setzt den Wert und löst den Beobachter Rückruf
4. Verursacht ein .set
5. zurück zu 2.

Update Firebase: Die Frage ist nicht Feuerbasis verwendet. Ich glaube, die Lösung besteht darin, die Kontrolle darüber zu erlangen, wie Updates auf beobachtete Werte in Polymer angewendet werden. Zum Teil, weil Änderungen an den Werten im Firebase-Speicher auch von Anwendungen der 3. Partei (nicht notwendigerweise Web) vorgenommen werden können.

Answer 1

Ändern Sie einfach die _valueChangedMethod dieser

_valueChanged: function(newValue, oldValue) { 
     if(newValue == oldValue) return; 
     var message = { aValue: this.aValue }; 
     if (this.ref) { 
      this.ref.set(message); 
     } 
    } 

Dies wird der Beobachter seine Arbeit tun nur, wenn der Wert tatsächlich geändert werden.

Answer 2

Mein Wissen ist es nicht so gebaut einen Eigenschaftswert zu setzen, ohne es Beobachter auszulösen.

Sie haben keine Kontrolle darüber, wie/wann/mit welchen Argumenten der Beobachter genannt wird, aber Sie die Kontrolle über das Verfahren Körper haben und, zum Glück, werden Sie mit einem gemeinsamen Staat arbeiten (this).

So können Sie das Verhalten der auf eine Flagge basierte Funktion ändern, die innerhalb der Funktion zugegriffen werden kann, muss aber nicht in weitergegeben werden

. Zum Beispiel:

_valueChanged: function (new_val, old_val) { 
    if (this._observerLock) { return; } 

    var message = { aValue: this.aValue }; 
    if (this.ref) { 
     this.ref.set(message); 
    } 
    } 
}, 
... 

Dann

, können Sie die _setWithoutCallingObserver() Methode wie implementieren:

_setWithoutCallingObserver: function (value) { 
    this._observerLock = true; 
    this.aValue = value; 
    this._observerLock = false; 
}