Vérifier si quelque chose est itérable

Dans la documentation MDN: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...of

La for...ofconstruction est décrite pour pouvoir itérer sur des objets "itérables". Mais y a-t-il un bon moyen de décider si un objet est itérable?

J'ai essayé de trouver des propriétés communes pour les tableaux, les itérateurs et les générateurs, mais je n'ai pas pu le faire.

En plus de faire un for ... ofbloc d'essai et de vérifier les erreurs de type, existe-t-il un moyen propre de le faire?

La bonne façon de vérifier l'itérabilité est la suivante:

function isIterable(obj) {
  // checks for null and undefined
  if (obj == null) {
    return false;
  }
  return typeof obj[Symbol.iterator] === 'function';
}

Pourquoi cela fonctionne (protocole itératif en profondeur): https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Iteration_protocols

Puisque nous parlons de for..of, je suppose, nous sommes dans l'état d'esprit ES6.

De plus, ne soyez pas surpris que cette fonction retourne truesi objest une chaîne, car les chaînes parcourent leurs caractères.

Pourquoi si verbeux?

const isIterable = object =>
  object != null && typeof object[Symbol.iterator] === 'function'

La solution la plus simple est en fait la suivante:

function isIterable (value) {
  return Symbol.iterator in Object(value);
}

Objectenveloppera tout ce qui n'est pas un objet en un, permettant à l' inopérateur de travailler même si la valeur d'origine n'est pas un objet. nullet undefinedsont transformés en objets vides, il n'est donc pas nécessaire de détecter la casse des bords, et les chaînes sont enveloppées dans des objets String qui sont itérables.

En tant que sidenote, méfiez - vous de la définition de itérables . Si vous venez d'autres langues, vous vous attendez à ce que quelque chose sur lequel vous pouvez itérer, disons, une forboucle soit itérable . J'ai bien peur que ce ne soit pas le cas ici où iterable signifie quelque chose qui implémente le protocole d'itération .

Pour rendre les choses plus claires, tous les exemples ci-dessus retournent falsesur cet objet {a: 1, b: 2}car cet objet n'implémente pas le protocole d'itération. Vous ne pourrez donc pas le parcourir avec un for...of MAIS vous le pouvez toujours avec un for...in.

Donc, si vous voulez éviter des erreurs douloureuses, rendez votre code plus spécifique en renommant votre méthode comme indiqué ci-dessous:

/**
 * @param variable
 * @returns {boolean}
 */
const hasIterationProtocol = variable =>
    variable !== null && Symbol.iterator in Object(variable);

De nos jours, comme déjà indiqué, pour tester s'il objest itérable, faites simplement

obj != null && typeof obj[Symbol.iterator] === 'function' 

Réponse historique (pas plus valide)

La for..ofconstruction fait partie du projet de spécification du langage ECMASCript 6e édition. Cela pourrait donc changer avant la version finale.

Dans ce brouillon, les objets itérables doivent avoir la fonction en iteratortant que propriété.

Vous pouvez vérifier si un objet est itérable comme ceci:

function isIterable(obj){
   if(obj === undefined || obj === null){
      return false;
   }
   return obj.iterator !== undefined;
}

Pour les itérateurs asynchrones, vous devriez vérifier le 'Symbol.asyncIterator' au lieu de 'Symbol.iterator':

async function* doSomething(i) {
    yield 1;
    yield 2;
}

let obj = doSomething();

console.log(typeof obj[Symbol.iterator] === 'function');      // false
console.log(typeof obj[Symbol.asyncIterator] === 'function'); // true

Si vous vouliez vérifier en fait si une variable est un objet ( {key: value}) ou un tableau ( [value, value]), vous pouvez le faire:

const isArray = function (a) {
    return Array.isArray(a);
};

const isObject = function (o) {
    return o === Object(o) && !isArray(o) && typeof o !== 'function';
};

function isIterable(variable) {
    return isArray(variable) || isObject(variable);
}