Expliquer la mise en œuvre de la fonction d'assistance à la mémoire

La mémoisation est une fonction auxiliaire, ou on peut dire que c'est une technique qui améliore l'efficacité d'un programme en gardant une trace des valeurs qu'une fonction a calculées dans le passé. Dans cet article, nous discuterons de la fonctionnalité Memoization Helper à travers différents exemples et discuterons de tous les exemples en détail afin que nous puissions mieux comprendre la mémorisation.

Discutons maintenant en profondeur des fonctions d'assistance à la mémorisation dans les sections suivantes et voyons leur implémentation et leur explication.

Introduction aux fonctions de l'assistant de mémoire

La mémoisation est une technique de programmation utilisée pour améliorer la complexité temporelle et spatiale d'un programme en gardant une trace des valeurs qu'une fonction a calculées dans le passé. En enregistrant les résultats des appels de fonction dans le cache, les programmes deviennent plus efficaces. Nous perdons souvent du temps à exécuter à plusieurs reprises des fonctions avec les mêmes paramètres que ceux calculés précédemment. On peut ensuite mettre en cache la valeur calculée et la renvoyer lors de l'appel de la fonction avec les mêmes paramètres.

Mise en œuvre de la fonction auxiliaire de mémorisation

Ici, nous explorerons de nombreux exemples et explications pour vous aider à mieux comprendre les fonctions d'aide à la mémoire.

Exemple 1

Voyons comment fonctionne la fonction d'aide à la mémoire à travers cet exemple, dans cet exemple, nous discuterons du code, de la sortie et de l'explication pour mieux comprendre le concept -

function add(num1,num2){
   for(let i=0;i<100000;i++){
   }
   return num1+num2;
}
console.log(add(5,4));
console.log(add(5,4));

Ici, nous définissons la fonction add, en passant deux paramètres num1 et num2 pour effectuer l'addition des entiers num1 et num2. Dans cette fonction, nous exécutons une boucle for, après quoi nous devons renvoyer la somme de deux entiers.

Dans ce cas, nous avons appelé la fonction d'addition, mais notre fonction prend un certain temps à cause de la boucle for. Nous appelons la fonction encore et encore avec les mêmes paramètres. Donc, si nous utilisons la mémoire en stockant la valeur ajoutée afin de gagner du temps, alors nous renverrons la valeur mise en cache. Nous n'avons pas besoin de calculer des valeurs supplémentaires pour les mêmes paramètres.

Exemple 2

Voyons combien de temps il faut à notre fonction pour déterminer la valeur de add (5,4) à l'aide du code et de l'explication -

function add(num1,num2){
   for(let i=0;i<100000;i++){
   }
   return num1+num2;
}
console.time("Time taken");
console.log(add(5, 4));
console.timeEnd("Time taken");

Notre fonction a mis 14,441 ms pour additionner les entiers 5 et 4.

En utilisant des techniques de mémorisation, nous pouvons mettre en cache la valeur déjà calculée puis la renvoyer lors de l'appel de la fonction avec les mêmes paramètres, rendant ainsi la fonction plus efficace.

Exemple 3

Voyons maintenant comment utiliser les techniques de mémorisation pour réduire le temps nécessaire à l'exécution répétée d'une fonction avec les mêmes paramètres.

function memoizeFunction(func) {
   let storage = {};
   return function (val1, val2) {
      const val = val1.toString() + val2.toString();
      if (!storage[val]) {
         storage[val] = func(val1, val2);
      }
      return storage[val];
   }
}
function add(num1, num2) {
   for (let i = 0; i < 10000000; i++) {
   }
   return num1 + num2;
}
console.time("First time, time taken");

let func = memoizeFunction(add);
console.log(func(5, 4));
console.timeEnd("First time, time taken");
console.time("Second time, time taken");

func = memoizeFunction(add);
console.log(func(5, 4));
console.timeEnd("Second time, time taken");
console.time("Third time, time taken");

func = memoizeFunction(add);
console.log(func(5, 4));
console.timeEnd("Third time, time taken");

Remarque - La durée requise pour accomplir une tâche peut changer.

Dans ce cas, nous mettons en cache la valeur précédemment calculée grâce à la fonction mémoire. Lorsque nous utilisons initialement func(4,5), les arguments sont d'abord convertis sous forme de chaîne, puis enregistrés dans l'objet "stockage" avec la valeur calculée.

De plus, lorsque la fonction est appelée avec les mêmes paramètres, elle détermine d'abord si elle existe déjà dans l'objet "storage". Si elle a déjà été calculée, elle ne sera pas recalculée, mais seule la valeur contenue dans le « stockage » de l'objet sera renvoyée.

Comme vous pouvez le voir sur le résultat, l'ajout de 5 et 4 prend moins de temps à chaque fois que vous utilisez la fonction avec les mêmes paramètres.

Prenez votre temps à chaque fois -

98.885 ms
83.375 ms
13.071 ms

Ainsi, comme le montre le résultat, les techniques de mémorisation aident à réduire le temps nécessaire à chaque fois que nous appelons à plusieurs reprises une fonction avec les mêmes paramètres.

Exemple 4

Discutons d'un autre exemple de fonction d'assistance à la mémoire de séquence de Fibonacci.

function memoizeFunction(func) {
   let storage = {};
   return function (val) {
      const value = val.toString();
      if (!storage[value]) {
      storage[value] = func(val);
      }
      return storage[value];
   }
}
function fibonacci(num) {
   if (num === 0 || num === 1)
   return num;
   else
   return fibonacci(num - 1) + fibonacci(num - 2);
}
console.time("First time, time taken");

let func = memoizeFunction(fibonacci);
console.log(func(6));
console.timeEnd("First time, time taken");
console.time("Second time, time taken");

func = memoizeFunction(fibonacci);
console.log(func(6));
console.timeEnd("Second time, time taken");
console.time("Third time, time taken");

func = memoizeFunction(fibonacci);
console.log(func(6));
console.timeEnd("Third time, time taken");

Si toutes les étapes sont effectuées sans l'aide de techniques de mémoire, le temps d'exécution de la séquence de Fibonacci augmentera de façon exponentielle. En stockant les résultats précédents, nous pouvons obtenir des résultats prédéfinis, réduire la vérification supplémentaire des résultats de calcul et prendre des mesures pour les linéariser.

Conclusion

Dans cet article, nous avons appris que la mémorisation est une fonction d'assistance ou une technique qui améliore l'efficacité d'un programme en gardant une trace des valeurs qu'une fonction a calculées dans le passé. En enregistrant les résultats des appels de fonction dans le cache, les programmes deviennent plus efficaces. On peut ensuite mettre en cache la valeur calculée et la renvoyer lors de l'appel de la fonction avec les mêmes arguments.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!