Assista a vários atributos de escopo $

Existe uma maneira de se inscrever em eventos em vários objetos usando $watch

Por exemplo

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

A partir do AngularJS 1.3, existe um novo método chamado $watchGrouppara observar um conjunto de expressões.

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

A partir do AngularJS 1.1.4, você pode 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
});

Exemplo de Plunker aqui

Documentação aqui

$watch O primeiro parâmetro também pode ser uma função.

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

Se seus dois valores combinados forem simples, o primeiro parâmetro é apenas uma expressão angular normalmente. Por exemplo, nome e sobrenome:

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

Aqui está uma solução muito semelhante ao seu pseudo-código original que realmente funciona:

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

EDIT: Ok, acho que isso é ainda melhor:

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

Basicamente, estamos pulando a etapa json, que parecia idiota para começar, mas não estava funcionando sem ela. A chave é o terceiro parâmetro frequentemente omitido, que ativa a igualdade de objetos em oposição à igualdade de referência. Em seguida, as comparações entre nossos objetos de matriz criados realmente funcionam corretamente.

Você pode usar funções no $ watchGroup para selecionar os campos de um objeto no escopo.

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

Por que não simplesmente envolvê-lo em um forEach?

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

Trata-se da mesma sobrecarga de fornecer uma função para o valor combinado, sem precisar se preocupar com a composição do valor .

Uma solução um pouco mais segura para combinar valores pode ser o seguinte como sua $watchfunção:

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

ou

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

O primeiro parâmetro $ watch pode ser expressão ou função angular . Veja a documentação sobre $ scope. $ Watch . Ele contém muitas informações úteis sobre como o método $ watch funciona: quando watchExpression é chamado, como angular compara resultados, etc.

e quanto a:

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

Aqui, a função será chamada quando os valores de idade e nome forem alterados.

O Angular introduzido $watchGroupna versão 1.3, usando o qual podemos observar várias variáveis, com um único $watchGroupbloco $watchGroupassume o array como primeiro parâmetro no qual podemos incluir todas as nossas variáveis ​​a serem observadas.

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