web-dev-qa-db-fra.com

KnockoutJS: calculé vs pureComputed

Quelle est la différence entre computed et pureComputed dans KnockoutJS?

Puis-je utiliser pureComputed au lieu de computed en toute sécurité?

knockout.jsknockout-3.0
36
mehrandvd

Je suis d'accord avec le @Jeroen et je voudrais ajouter un court exemple de J. Munro's livre qui m'a beaucoup aidé, donc cela pourrait être utile pour les autres aussi.

Tout d'abord, les observables pureComputed sont assez similaires aux observables calculés avec plusieurs améliorations de performances et de mémoire. Le nom est emprunté au terme de programmation fonction pure et cela signifie que toute fonction qui utilise uniquement une variable locale est potentiellement pure, tandis que toute fonction qui utilise une variable non locale est potentiellement impure.

Les observables dans Knockout.js sont traités différemment. Ainsi, les observables pureComputed sont placés en mode veille (Knockout incline toutes les dépendances et réévalue le contenu après la lecture) et les observables calculés sont placés en mode écoute (Knockout vérifie constamment si la valeur est à jour avant le premier accès) .

Par conséquent, si vous devez exécuter un autre code, mieux vaut utiliser un observables calculés.

function ViewModel() {
     var self = this;

     self.firstName = ko.observable('Arshile');
     self.lastName = ko.observable('Gorky');
     self.pureComputedExecutions = 0;
     self.computedExecutions = 0;

     self.pureComputedFullName = ko.pureComputed(function() {
         // This is NOT recommended 
         self.pureComputedExecutions++;
         return 'Hello ' + self.firstName() + ' ' + self.lastName();
     });
     self.computedFullName = ko.computed(function() {
         self.computedExecutions++;

         return 'Hello ' + self.firstName() + ' ' + self.lastName();
     });
 };
 var viewModel = new ViewModel();
 ko.applyBindings(viewModel);

 alert('Pure computed executions: ' + viewModel.pureComputedExecutions);
 alert('Computed executions: ' + viewModel.computedExecutions);

Lorsque ce code est exécuté, deux messages d'alerte sont affichés qui indiquent le nombre d'appels des fonctions pureComputed et computed. Étant donné que pureComputed est en mode veille, la fonction n'a jamais été consultée et le compteur affichera 0. Contrairement à cela, la fonction calculée est automatiquement évaluée lors de la liaison de données, ce qui augmente le nombre et affiche 1 le compteur.

20
johannesMatevosyan

Ils sont très similaires. La différence est que pureComputed a des optimisations de performances et essaie d'empêcher les fuites de mémoire, en étant intelligent sur qui suit ses changements.

Vous pouvez remplacer en toute sécurité computed par pureComputed dans de nombreux cas. La fonction à l'intérieur du calculé devrait suivre ceci :

1.L'évaluation de l'observable calculé ne devrait entraîner aucun effet secondaire.

2.La valeur de l'observable calculée ne devrait pas varier en fonction du nombre d'évaluations ou d'autres informations "cachées". Sa valeur doit être basée uniquement sur les valeurs d'autres observables dans l'application, qui pour la définition de fonction pure, sont considérées comme ses paramètres.

Donc, en règle générale, tout observable calculé qui transforme simplement clairement certaines propriétés régulières de observable devrait être bien comme pureComputed, sinon restez avec computed.

La documentation a des explications décentes quand/pourquoi vous devriez ne pas utiliser pureComputed observables. Voici un extrait pertinent:

Vous ne devez pas utiliser la fonction pure pour un observable calculé destiné à effectuer une action lorsque ses dépendances changent.

La raison pour laquelle vous ne devez pas utiliser un calcul pur si l'évaluateur a des effets secondaires importants est simplement que l'évaluateur ne s'exécutera pas chaque fois que le calcul n'a pas d'abonnés actifs (et qu'il dort donc). S'il est important que l'évaluateur s'exécute toujours lorsque les dépendances changent, utilisez plutôt un calcul régulier.

26
Jeroen