Analyse des cas d'application de la fermeture frontale : quels sont ses scénarios d'application typiques ?-js tutoriel-php.cn

Analyse des cas d'application de la fermeture frontale : quels sont ses scénarios d'application typiques ?

WBOY

Libérer： 2024-01-13 12:05:07

original

985 Les gens l'ont consulté

Analyse des cas dapplication de la fermeture frontale : quels sont ses scénarios dapplication typiques ?

Analyse de cas d'application de la clôture frontale : dans quelles situations entre-t-elle généralement en jeu ?

Dans le développement front-end, la fermeture (Closure) est un concept très puissant et couramment utilisé. Il s'agit d'une fonction spéciale qui peut accéder à des variables extérieures à la fonction, et ces variables seront toujours conservées en mémoire. L'application de fermetures peut nous aider à résoudre certains problèmes courants, tels que la privatisation des données, le stockage de variables, etc. Alors, dans quelles situations les fermetures entrent-elles en jeu ? Ce qui suit sera analysé à travers des exemples de code spécifiques.

Privatisation des données

Les fermetures peuvent nous aider à privatiser les données, à éviter l'abus de variables globales et à améliorer la maintenabilité et la sécurité du code. Voici un exemple :

function createCounter() {
  let count = 0; // 私有变量

  function increment() {
    count++;
    console.log(count);
  }

  function decrement() {
    count--;
    console.log(count);
  }

  return {
    increment: increment,
    decrement: decrement
  };
}

let counter = createCounter();
counter.increment(); // 输出：1
counter.decrement(); // 输出：0

Copier après la connexion

Dans cet exemple, nous créons un compteur à l'aide d'une fermeture. La logique du compteur est encapsulée dans une fonction et est accessible en renvoyant un objet contenant des fonctions d'incrémentation et de décrémentation. Puisque la variable count est encapsulée à l'intérieur de la fermeture, elle n'est pas accessible directement de l'extérieur, assurant la privatisation de la variable. count变量被封装在闭包内部，外部无法直接访问，确保了变量的私有化。

记忆化计算

闭包还可以帮助我们实现记忆化计算，提高代码的执行效率。记忆化是一种将计算结果缓存起来，以便下次用到相同输入时，可以直接返回缓存的结果，避免重复计算的过程。以下是一个斐波那契数列的例子：

function memoize(f) {
  let cache = {};

  return function (n) {
    if (cache[n] !== undefined) {
      return cache[n];
    }

    let result = f(n);
    cache[n] = result;
    return result;
  };
}

let fibonacci = memoize(function (n) {
  if (n === 0 || n === 1) {
    return n;
  }
  return fibonacci(n - 1) + fibonacci(n - 2);
});

console.log(fibonacci(5)); // 输出：5

Copier après la connexion

在这个例子中，我们使用闭包创建了一个记忆化函数memoize。memoize接受一个函数f作为参数，并返回一个新的函数。新函数首先检查计算结果是否已经被缓存，如果有，则直接返回缓存结果；如果没有，则通过调用函数f

var module = (function () {
  var privateVariable = 10;

  function privateFunction() {
    console.log('私有函数执行');
  }

  return {
    publicVariable: 20,
    publicFunction: function () {
      console.log('公共函数执行');
      privateVariable++;
      privateFunction();
    }
  };
})();

console.log(module.publicVariable); // 输出：20
module.publicFunction(); // 输出：公共函数执行 私有函数执行

Copier après la connexion

Dans cet exemple, nous utilisons des fermetures pour créer une fonction memoize memoize. memoize accepte une fonction f comme paramètre et renvoie une nouvelle fonction. La nouvelle fonction vérifie d'abord si le résultat du calcul a été mis en cache. Si tel est le cas, elle renvoie directement le résultat mis en cache ; sinon, elle calcule le résultat en appelant la fonction f et met le résultat en cache. De cette manière, si la même entrée est rencontrée lors d'appels ultérieurs, les résultats mis en cache peuvent être renvoyés directement, évitant ainsi des calculs répétés.

Les fermetures peuvent également nous aider à mettre en œuvre le développement modulaire, à organiser le code par fonction et à améliorer la maintenabilité et la réutilisation du code. Voici un exemple simple de modularisation :

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!