Mire múltiples atributos de $ scope

¿Hay alguna manera de suscribirse a eventos en múltiples objetos usando $watch

P.ej

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

A partir de AngularJS 1.3 hay un nuevo método llamado $watchGrouppara observar un conjunto de expresiones.

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

Comenzando con AngularJS 1.1.4 puede usar $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
});

Ejemplo de Plunker aquí

Documentación aquí

$watch El primer parámetro también puede ser una función.

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

Si sus dos valores combinados son simples, el primer parámetro es simplemente una expresión angular normalmente. Por ejemplo, nombre y apellido:

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

Aquí hay una solución muy similar a su pseudocódigo original que realmente funciona:

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

EDITAR: Bien, creo que esto es aún mejor:

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

Básicamente, estamos omitiendo el paso json, que parecía tonto al principio, pero no estaba funcionando sin él. La clave es el tercer parámetro a menudo omitido que activa la igualdad de objetos en lugar de la igualdad de referencia. Entonces, las comparaciones entre nuestros objetos de matriz creados realmente funcionan bien.

Puede usar funciones en $ watchGroup para seleccionar campos de un objeto en alcance.

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

¿Por qué no simplemente envolverlo en un forEach?

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

Se trata de la misma sobrecarga que proporcionar una función para el valor combinado, sin tener que preocuparse por la composición del valor .

Una solución un poco más segura para combinar valores podría ser usar lo siguiente como su $watchfunción:

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

o

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

El primer parámetro de $ watch puede ser una función o expresión angular . Consulte la documentación sobre $ scope. $ Watch . Contiene mucha información útil sobre cómo funciona el método $ watch: cuándo se llama a watchExpression, cómo angular compara resultados, etc.

qué tal si:

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

$scope.$watch('age + name', function () {
  //called when name or age changed
});

Aquí se llamará a la función cuando cambien tanto el valor de edad como el de nombre.

Angular se introdujo $watchGroupen la versión 1.3 con la que podemos ver múltiples variables, con un solo $watchGroupbloque $watchGrouptoma la matriz como primer parámetro en el que podemos incluir todas nuestras variables para ver.

$scope.$watchGroup(['var1','var2'],function(newVals,oldVals){
   console.log("new value of var1 = " newVals[0]);
   console.log("new value of var2 = " newVals[1]);
   console.log("old value of var1 = " oldVals[0]);
   console.log("old value of var2 = " oldVals[1]);
});