Angular.js regarde uniquement sur une propriété d'objet particulière

Fondamentalement, je veux que ce http://plnkr.co/edit/3yfXbo1c0llO40HZ8WNP?p=preview mais attention à ne pas le feu quand je change quelque chose..

Je sais que cela aurait fonctionné

$scope.$watch('stuff', function (newVal, oldVal) {
    console.log(oldVal, newVal);

}, true);

Mais puisque je veux faire un résumé à l'intérieur de montres et je ne veux pas inutilement loop thru ou re-somme des valeurs qui ne changent pas..

//edit -
notez que le plnkr exemple est juste une extraction à partir de l'application, où vous pouvez ajouter et supprimer des lignes et beaucoup plus, comme la modification du nombre total(somme des somethings et somethingelses) provenant d'un autre à l'extérieur de la ng-repeat..

source d'informationauteur fxck

  1. 6

    Je ne ferais pas une montre que selon la taille de votre tableau pourrait être, pourrait être très pénible. Au lieu de cela, je voudrais juste créer un filtre:

    HTML:

    Sum of something is: {{ stuff | sum:'something' }}<br/>
Sum of somethingelse is: {{ stuff | sum:'somethingelse' }}

    Javascript:

    .filter("sum", function(){
    return function(input, params){
        var totalSum = 0;
        for(var x = 0; x < input.length; x++){
            totalSum += input[x][params];
        }
        return totalSum;
    }
})

    plnkr: http://plnkr.co/edit/p6kM3ampSuMXnwqcteYd?p=preview

  2. 4

    Je suis souriante partout après je suis venu avec cette solution pour votre problème. Non seulement est-ce une solution pour regarder les objets, c'est aussi ne va pas faire une boucle complète par le reste des objets de la somme.

    http://plnkr.co/edit/oPWobcLLtJlxs5vjTYyc?p=preview

    app.controller('MainCtrl', function($scope) {
  $scope.stuff = STUFF;
  var i;
  $scope.sumOfSomething = 0;
  $scope.sumOfSomethingElse = 0;

  for(i=0;i < $scope.stuff.length;i++ ){
    $scope.$watch('stuff['+i+'].something', function (newVal,oldVal) {
      //happens when the watch is registered.
      if(oldVal === newVal){
        $scope.sumOfSomething += +newVal;
        return;
      }
      if(newVal){
        $scope.sumOfSomething += + (newVal - oldVal);
      }
    });

    $scope.$watch('stuff['+i+'].somethingelse', function (newVal,oldVal) {
      //happens when the watch is registered. 
      if(oldVal === newVal){
        $scope.sumOfSomethingElse += +newVal;
        return;
      }

      if(newVal){
        $scope.sumOfSomethingElse += + (newVal - oldVal);
      }

    });  
  }
});

    Par la façon dont je ne sais pas comment optimal cette solution va être si vous avez un grand nombre d'objets dans STUFF. Aussi, cela ne marchera pas comme si le nombre d'objets dans STUFF va changer. Ce que nous sommes essentiellement faire est d'utiliser le sale vérification de la boucle angulaire de faire de notre sommation pour nous.

    Également remarquer que l'ordre de newVal et oldVal dans la montre à l'écoute. Votre commande est incorrecte.

  3. 3

    Depuis $watch() prend angulaire expression vous pouvez utiliser une coutume de l'observateur de la fonction. Dans votre cas, la meilleure façon de surveiller les modifications apportées est simplement pour ajouter tous les champs qui vous intéresse puis de retour d'un numéro unique qui est agréable et efficace angulaire et votre somme sera prêt pour le rendu.

    var sumThings = function(obj, field) {
  var val = 0;
  obj.forEach(function(o) {
    val += parseInt(o[field]);
  });
  return val;
};

$scope.$watch(function() { return sumThings($scope.stuff, "something")}, function (newVal, oldVal) {    //console.log("watchExpression('something') fired!", oldVal, newVal);
  $scope.somethingSum = newVal;
});

$scope.$watch(function() { return sumThings($scope.stuff, "somethingelse")}, function (newVal, oldVal) {
  $scope.somethingelseSum = newVal;
});

    En gros, en faisant votre sommation vous faites votre propre sale de la vérification. Ça va être plus efficace que $watch(STUFF, true) si vos objets sont plus complexes que vous ai montré ici.

    Mise à jour de votre plnkr : http://plnkr.co/edit/d7CvERu3XGkub4l6f1yw?p=preview

  4. 1

    Bien, si je l'ai eu, vous voulez juste somme something avec somethingelse de l'intérieur des objets quand ils changent. Et vous ne voulez pas une boucle sur tous les autres objets internes si le changement est dans l'un d'eux.

    Bien, votre $watch n'est-ce pas de tir car il n'y a pas de stuff.propertyet il n'y a pas de modèles comme stuff.*.something.

    Si vous savez le moment où les objets est poussé ou tiré du tableau, que vous pouvez appliquer séparément $scope.$watch(object, function(){}, true) avant/après l'insertion de chacun dans le tableau. Si vous ne savez pas à ce moment, que vous aurez besoin de $watch l'ensemble de la matrice, et lorsqu'un changement se produit, tout exécuter à la révocation de l'enregistrement fonctions et $watch eux tous, un par un.

    De toute façon, une boucle de nos jours, les navigateurs est assez rapide, et sauf si vous faites beaucoup de calculs et vous avez des millions d'objets (ce qui aurait été un problème de mémoire déjà), vous allez probablement être bien avec elle. Ainsi, un effort pour $watch tous séparément, il est seulement nécessaire si vous avez vraiment lourds calculs, qui pourrait compromettre la performance du système.