javascript html - Beobachten Sie mehrere $ scope-Attribute




table bootstrap (10)

Gibt es eine Möglichkeit, Ereignisse für mehrere Objekte mit $watch zu abonnieren $watch

Z.B

$scope.$watch('item1, item2', function () { });

Answers

Hier ist eine Lösung, die Ihrem ursprünglichen Pseudocode sehr ähnlich ist:

$scope.$watch('[item1, item2] | json', function () { });

EDIT: Okay, ich denke das ist noch besser:

$scope.$watch('[item1, item2]', function () { }, true);

Im Grunde überspringen wir den JSON-Schritt, der anfangs dumm erschien, aber ohne ihn nicht funktionierte. Der Schlüssel ist der häufig weggelassene dritte Parameter, der die Objektgleichheit im Gegensatz zur Referenzgleichheit aktiviert. Dann funktionieren die Vergleiche zwischen unseren erstellten Array-Objekten tatsächlich richtig.


Sie können Funktionen in $ watchGroup verwenden, um Felder eines Objekts im Gültigkeitsbereich auszuwählen.

        $scope.$watchGroup(
        [function () { return _this.$scope.ViewModel.Monitor1Scale; },   
         function () { return _this.$scope.ViewModel.Monitor2Scale; }],  
         function (newVal, oldVal, scope) 
         {
             if (newVal != oldVal) {
                 _this.updateMonitorScales();
             }
         });

Ab AngularJS 1.1.4 können Sie $watchCollection :

$scope.$watchCollection('[item1, item2]', function(newValues, oldValues){
    // do stuff here
    // newValues and oldValues contain the new and respectively old value
    // of the observed collection array
});

Plunker Beispiel here

Dokumentation here


$ watch erster Parameter kann ein Winkelausdruck oder eine Funktion sein. Siehe Dokumentation zu $scope.$watch . Es enthält eine Menge nützlicher Informationen darüber, wie die $ watch-Methode funktioniert: Wenn watchExpression aufgerufen wird, wie Winkel Ergebnisse vergleicht usw.


$watch first parameter kann auch eine Funktion sein.

$scope.$watch(function watchBothItems() {
  return itemsCombinedValue();
}, function whenItemsChange() {
  //stuff
});

Wenn Ihre beiden kombinierten Werte einfach sind, ist der erste Parameter normalerweise nur ein Winkelausdruck. Zum Beispiel firstName und lastName:

$scope.$watch('firstName + lastName', function() {
  //stuff
});

wie wäre es mit:

scope.$watch(function() { 
   return { 
      a: thing-one, 
      b: thing-two, 
      c: red-fish, 
      d: blue-fish 
   }; 
}, listener...);

Ab AngularJS 1.3 gibt es eine neue Methode namens $watchGroup zum Beobachten einer Menge von Ausdrücken.

$scope.foo = 'foo';
$scope.bar = 'bar';

$scope.$watchGroup(['foo', 'bar'], function(newValues, oldValues, scope) {
  // newValues array contains the current values of the watch expressions
  // with the indexes matching those of the watchExpression array
  // i.e.
  // newValues[0] -> $scope.foo 
  // and 
  // newValues[1] -> $scope.bar 
});

Eine etwas sicherere Lösung zum Kombinieren von Werten könnte darin bestehen, Folgendes als Ihre $watch Funktion zu verwenden:

function() { return angular.toJson([item1, item2]) }

oder

$scope.$watch(
  function() {
    return angular.toJson([item1, item2]);
  },
  function() {
    // Stuff to do after either value changes
  });

Warum nicht einfach in ein forEach ?

angular.forEach(['a', 'b', 'c'], function (key) {
  scope.$watch(key, function (v) {
    changed();
  });
});

Es ist ungefähr der gleiche Overhead wie das Bereitstellen einer Funktion für den kombinierten Wert, ohne sich um die Wertezusammensetzung kümmern zu müssen .






javascript angularjs events angularjs-watch