Überprüfen, ob etwas iterierbar ist

In den MDN-Dokumenten: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...of

Es for...ofwird beschrieben, dass das Konstrukt über "iterierbare" Objekte iterieren kann. Aber gibt es eine gute Möglichkeit zu entscheiden, ob ein Objekt iterierbar ist?

Ich habe versucht, gemeinsame Eigenschaften für Arrays, Iteratoren und Generatoren zu finden, konnte dies jedoch nicht.

Gibt for ... ofes eine saubere Möglichkeit, einen Try-Block auszuführen und nach Typfehlern zu suchen?

Der richtige Weg, um die Iterierbarkeit zu überprüfen, ist wie folgt:

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

Warum dies funktioniert (iterierbares Protokoll im Detail): https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Iteration_protocols

Ich gehe davon aus, dass wir uns in der ES6-Denkweise befinden.

Seien Sie auch nicht überrascht, dass diese Funktion zurückgegeben wird, truewenn objes sich um eine Zeichenfolge handelt, da Zeichenfolgen über ihre Zeichen iterieren.

Warum so ausführlich?

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

Die einfachste Lösung ist tatsächlich folgende:

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

Objectwird alles, was kein Objekt ist, in ein Objekt einschließen, sodass der inBediener auch dann arbeiten kann, wenn der ursprüngliche Wert kein Objekt ist. nullund undefinedwerden in leere Objekte umgewandelt, sodass keine Erkennung von Kantenfällen erforderlich ist, und Zeichenfolgen werden in iterierbare Zeichenfolgenobjekte eingeschlossen.

Achten Sie als Nebenbemerkung auf die Definition von iterable . Wenn Sie aus anderen Sprachen kommen, würden Sie erwarten, dass etwas, mit dem Sie beispielsweise eine forSchleife durchlaufen können, iterierbar ist . Ich fürchte, das ist hier nicht der Fall, wo iterable etwas bedeutet, das das Iterationsprotokoll implementiert .

Zur Verdeutlichung kehren alle obigen Beispiele falsezu diesem Objekt zurück, {a: 1, b: 2}da dieses Objekt das Iterationsprotokoll nicht implementiert. Sie werden also nicht in der Lage sein, mit einem for...of ABER darüber zu iterieren, aber Sie können es immer noch mit einem for...in.

Wenn Sie also schmerzhafte Fehler vermeiden möchten, machen Sie Ihren Code spezifischer, indem Sie Ihre Methode wie folgt umbenennen:

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

Heutzutage, wie bereits erwähnt, um zu testen, ob objes iterierbar ist, tun Sie es einfach

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

Historische Antwort (nicht mehr gültig)

Das for..ofKonstrukt ist Teil des ECMASCript 6th Edition Language Specification Draft. Es könnte sich also vor der endgültigen Version ändern.

In diesem Entwurf müssen iterierbare Objekte die Funktion iteratorals Eigenschaft haben.

Sie können überprüfen, ob ein Objekt wie folgt iterierbar ist:

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

Bei asynchronen Iteratoren sollten Sie nach 'Symbol.asyncIterator' anstelle von 'Symbol.iterator' suchen:

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

Wenn Sie tatsächlich überprüfen möchten, ob eine Variable ein Objekt ( {key: value}) oder ein Array ( [value, value]) ist, können Sie Folgendes tun:

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);
}