Vérification si quelque chose est itérable

Question

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

La construction for...of est décrite comme capable d'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 n'ai pas réussi à le faire.

En dehors de faire un for ... of dans un bloc try et de vérifier les erreurs de type, y a-t-il un moyen propre de le faire ?

Answer 1

Pour les itérateurs async, 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

Answer 2

Si l'objet possède la propriété Symbol.iterator, alors il est itérable. Nous pouvons simplement vérifier si obj est itérable de cette manière

TypeScript

function isIterable(x: unknown): boolean {
  return !!x?.[Symbol.iterator];
}

Ou sous forme de fonction fléchée

const isIterable = (x: unknown): boolean => !!x?.[Symbol.iterator];

JavaScript

const isIterable = x => !!x?.[Symbol.iterator];

Exemples

isIterable(["hello", "world"]); // true
isIterable({}); // false
isIterable(null); // false
isIterable(undefined); // false
isIterable(1); // false
isIterable(true); // false
isIterable(Symbol("foo")); // false
isIterable(new Set()); // true
isIterable(new Map()); // true

Answer 3

De nos jours, comme déjà mentionné, pour tester si obj est itérable, il suffit de faire

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

Réponse historique (plus valide)

La structure for..of fait partie du brouillon de la spécification du langage de la 6ème édition de l'ECMASCript. Elle pourrait donc changer avant la version finale.

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

Vous pouvez vérifier si un objet est itérable de cette manière:

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

Answer 4

Si vous souhaitez vérifier si une variable est un objet ({clé: valeur}) ou un tableau ([valeur, valeur]), 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);
}

Answer 5

J'ai cherché une vérification pour for ... in et j'ai décidé du suivant.

isIterable (value) {
  // ajouter d'autres vérifications ici en fonction des besoins.
  return Object.keys(Object(value)).length > 0
}

Cela renverra true pour tout ce qui est itérable et a au moins une valeur. Par conséquent, les chaînes vides, les tableaux vides, les objets vides, etc. renverront false. Mais {a: 'x', b: 'y'} renverra true.