Iterables et Iterators

1.1 Concepts de base

Les itérateurs et les objets itérables (iterables) en JavaScript sont des concepts fondamentaux qui permettent aux objets d'être parcoures. Ces concepts sont largement utilisés dans le JavaScript moderne, en particulier dans des constructions telles que les boucles for...of, l'opérateur de propagation (spread operator), la déstructuration et bien d'autres. Dans cette conférence, nous allons voir ce que sont les iterables et iterators, comment ils fonctionnent et comment les créer et les utiliser.

Iterables (Objets itérables)

Les objets itérables sont des objets qui implémentent le protocole d'itération. Ils doivent avoir une méthode spéciale avec la clé [Symbol.iterator], qui renvoie un objet-iterator.

Iterators (Itérateurs)

Un itérateur est un objet avec une méthode next(), qui renvoie un objet avec deux propriétés :

• value — la valeur de l'élément suivant dans la séquence
• done — une valeur booléenne indiquant si la séquence est terminée (true) ou non (false)

Voyons quelques exemples d'utilisation.

Objets itérables intégrés

JavaScript possède plusieurs objets itérables intégrés, y compris les tableaux, chaînes, objets Set et Map.

Exemple 1 : Itération d'un tableau

    
      const array = [1, 2, 3, 4, 5];

      for (const item of array) {
        console.log(item);
      }

      // Affichera : 1 2 3 4 5
    
  

Exemple 2 : Itération d'une chaîne

    
      const string = 'hello';

      for (const char of string) {
        console.log(char);
      }

      // Affichera : h e l l o
    
  

1.2 Créer ses propres itérateurs

Vous pouvez créer votre propre itérateur en implémentant le protocole d'itération — en créant une méthode next().

Exemple 1 : Création d'un itérateur

    
      function createIterator(array) {
        let index = 0;

        return {
          next: function() {
            if (index < array.length) {
              return { value: array[index++], done: false };
            } else {
              return { done: true };
            }
          }
        };
      }

      const myIterator = createIterator([1, 2, 3]);

      console.log(myIterator.next()); // { value: 1, done: false }
      console.log(myIterator.next()); // { value: 2, done: false }
      console.log(myIterator.next()); // { value: 3, done: false }
      console.log(myIterator.next()); // { done: true }
    
  

Créer des objets itérables

Pour qu'un objet devienne itérable, il doit implémenter la méthode [Symbol.iterator]. Oui, c'est un nom un peu complexe. Voici comment le créer.

Exemple 2 : Création d'un objet itérable

    
      const myIterable = {
        *[Symbol.iterator]() {
          yield 1;
          yield 2;
          yield 3;
        }
      };

      for (const value of myIterable) {
        console.log(value);
      }

      // Affichera : 1 2 3
    
  

1.3 Méthodes intégrées

Examinons les méthodes et opérateurs intégrés pour travailler avec des objets itérables.

Exemple 1 : Opérateur spread

L'opérateur spread (...) peut être utilisé pour copier ou combiner des objets itérables.

    
      const array = [1, 2, 3];
      const newArray = [...array, 4, 5, 6];

      console.log(newArray); // Affichera : [1, 2, 3, 4, 5, 6]
    
  

Exemple 2 : Déstructuration

La déstructuration permet d'extraire des valeurs d'objets itérables.

    
      const [first, second, third] = [1, 2, 3];

      console.log(first);  // Affichera : 1
      console.log(second); // Affichera : 2
      console.log(third);  // Affichera : 3
    
  

Exemple 3 : Méthodes Array.from et Array.of

La méthode Array.from() permet de créer un tableau à partir d'un objet itérable.

    
      const set = new Set([1, 2, 3, 4, 5]);
      const array = Array.from(set);

      console.log(array); // Affichera : [1, 2, 3, 4, 5]