Verificare se qualcosa è iterabile

Nei documenti MDN: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...of

Il for...ofcostrutto è descritto per essere in grado di iterare su oggetti "iterabili". Ma c'è un buon modo per decidere se un oggetto è iterabile?

Ho provato a trovare proprietà comuni per array, iteratori e generatori, ma non sono stato in grado di farlo.

A parte l'esecuzione for ... ofdi un blocco try e il controllo degli errori di tipo, esiste un modo pulito per farlo?

Il modo corretto per verificare l'iterabilità è il seguente:

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

Perché funziona (protocollo iterabile in profondità): https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Iteration_protocols

Dato che stiamo parlando di per ... di, presumo, siamo nella mentalità ES6.

Inoltre, non sorprenderti se questa funzione restituisce trueif objè una stringa, poiché le stringhe ripetono i loro caratteri.

Perché così prolisso?

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

La soluzione più semplice è in realtà questa:

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

Objectavvolgerà tutto ciò che non è un oggetto in uno, consentendo inall'operatore di lavorare anche se il valore originale non è un oggetto. nulle undefinedvengono trasformati in oggetti vuoti, quindi non è necessario il rilevamento dei casi limite e le stringhe vengono racchiuse in oggetti String che sono iterabili.

Come nota a margine, FARE ATTENZIONE alla definizione di iterabile . Se vieni da altre lingue ti aspetteresti che qualcosa su cui puoi iterare, diciamo, un forciclo sia iterabile . Temo che non sia questo il caso in cui iterabile significa qualcosa che implementa il protocollo di iterazione .

Per rendere le cose più chiare, tutti gli esempi precedenti tornano falsesu questo oggetto {a: 1, b: 2}perché quell'oggetto non implementa il protocollo di iterazione. Quindi non sarai in grado di iterare su di esso con un for...of MA puoi ancora farlo con un file for...in.

Quindi, se vuoi evitare errori dolorosi, rendi il tuo codice più specifico rinominando il tuo metodo come mostrato di seguito:

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

Al giorno d'oggi, come già detto, per verificare se objè iterabile basta farlo

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

Risposta storica (non più valida)

Il for..ofcostrutto fa parte del progetto di specifica della lingua di ECMASCript 6a edizione. Quindi potrebbe cambiare prima della versione finale.

In questa bozza, gli oggetti iterabili devono avere la funzione iteratordi proprietà.

Puoi controllare se un oggetto è iterabile in questo modo:

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

Per gli iteratori asincroni dovresti controllare "Symbol.asyncIterator" invece di "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

Se volessi verificare in effetti se una variabile è un object ( {key: value}) o un array ( [value, value]), potresti farlo:

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