Domaines d'application courants des fermetures

Quels sont les scénarios d'application des fermetures ? Des exemples de code spécifiques sont nécessaires

En programmation, les fermetures sont un concept puissant qui peut contrôler les fonctions externes en créant une autre fonction à l'intérieur d'une fonction et en la renvoyant l'accès et le contrôle des variables et des portées. . Les fermetures ont un large éventail de scénarios d'application. Ci-dessous, nous présenterons plusieurs scénarios d'application courants et fournirons des exemples de code spécifiques.

1. Compteur

Une fermeture peut être utilisée pour créer un compteur privé pour enregistrer le nombre de fois qu'un événement se produit. Voici un exemple de code pour implémenter un compteur :

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

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

  return increment;
}

// 创建计数器实例
var myCounter = counter();
myCounter();  // 输出: 1
myCounter();  // 输出: 2
myCounter();  // 输出: 3

2. Encapsulation des données

Les fermetures peuvent également être utilisées pour encapsuler des informations afin d'empêcher l'accès direct externe et la modification des variables internes. Voici un exemple de code qui encapsule les données :

function person() {
  let name = "John";
  let age = 30;

  // 公有方法
  function getName() {
    return name;
  }

  function getAge() {
    return age;
  }

  // 返回一个包含公有方法的对象
  return {
    getName: getName,
    getAge: getAge
  };
}

// 创建 person 实例
var myPerson = person();
console.log(myPerson.getName());  // 输出: "John"
console.log(myPerson.getAge());   // 输出: 30

3. Cache

Closures peut être utilisé pour implémenter des fonctions de mise en cache simples afin d'éviter des calculs répétés. Voici un exemple de code qui implémente la mise en cache de séquence de Fibonacci :

function fibonacci() {
  // 缓存结果
  let cache = {};

  function calc(n) {
    if (n <= 1) {
      return n;
    } else {
      // 检查缓存中是否有结果
      if (cache[n]) {
        return cache[n];
      } else {
        // 计算斐波那契数
        let result = calc(n - 1) + calc(n - 2);
        // 将计算结果缓存起来
        cache[n] = result;
        return result;
      }
    }
  }

  return calc;
}

// 创建斐波那契数列计算函数
var fibonacciSeq = fibonacci();

console.log(fibonacciSeq(5));  // 输出: 5
console.log(fibonacciSeq(10)); // 输出: 55
console.log(fibonacciSeq(5));  // 输出: 5 (从缓存中获取)

4. Propriétés et méthodes privées

Les fermetures peuvent être utilisées pour simuler des propriétés et des méthodes privées afin d'empêcher l'accès et la modification externes directs. Voici un exemple de code qui simule des propriétés et des méthodes privées :

function Counter() {
  let count = 0;  // 私有属性

  return {
    // 公有方法
    increment: function() {
      count++;
    },

    decrement: function() {
      count--;
    },

    getValue: function() {
      return count;
    }
  };
}

// 创建 Counter 实例
var myCounter = Counter();
console.log(myCounter.getValue());  // 输出: 0
myCounter.increment();
console.log(myCounter.getValue());  // 输出: 1
myCounter.decrement();
console.log(myCounter.getValue());  // 输出: 0

Ceux-ci ci-dessus présentent plusieurs scénarios d'application courants de fermetures. La puissance des fermetures réside dans leur capacité à encapsuler les données et la logique pour obtenir une programmation plus modulaire et plus efficace. Dans le développement réel, en fonction des besoins et des situations spécifiques, les fermetures peuvent être pleinement utilisées pour améliorer la fonctionnalité et la maintenabilité du code.

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!