Comprobando si algo es iterable

En los documentos de MDN: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...of

La for...ofconstrucción se describe para poder iterar sobre objetos "iterables". Pero, ¿existe una buena forma de decidir si un objeto es iterable?

Intenté encontrar propiedades comunes para matrices, iteradores y generadores, pero no pude hacerlo.

Aparte de hacer un for ... ofbloque de prueba y comprobar si hay errores de tipo, ¿hay una forma limpia de hacer esto?

La forma correcta de verificar la iterabilidad es la siguiente:

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

Por qué funciona esto (protocolo iterable en profundidad): https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Iteration_protocols

Ya que estamos hablando de ... de, supongo que estamos en la mentalidad de ES6.

Además, no se sorprenda de que esta función devuelva truesi objes una cadena, ya que las cadenas iteran sobre sus caracteres.

¿Por qué tan prolijo?

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

La solución más simple es en realidad esta:

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

Objectenvolverá todo lo que no sea un objeto en uno, lo que permitirá al inoperador trabajar incluso si el valor original no es un Objeto. nully undefinedse convierten en objetos vacíos, por lo que no hay necesidad de detección de casos de borde, y las cadenas se envuelven en objetos String que son iterables.

Como nota al margen, TENGA CUIDADO con la definición de iterable . Si viene de otros idiomas, esperaría que algo con lo que pueda iterar, por ejemplo, un forbucle sea iterable . Me temo que ese no es el caso aquí, donde iterable significa algo que implementa el protocolo de iteración .

Para aclarar las cosas, todos los ejemplos anteriores devuelven falseeste objeto {a: 1, b: 2}porque ese objeto no implementa el protocolo de iteración. Por lo tanto, no podrá iterar sobre él con un for...of PERO todavía puede hacerlo con un for...in.

Entonces, si desea evitar errores dolorosos, haga que su código sea más específico cambiando el nombre de su método como se muestra a continuación:

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

Hoy en día, como ya se dijo, para probar si objes iterable simplemente haga

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

Respuesta histórica (no más válida)

los for..of constructo es parte del borrador de especificación de idioma de la 6ª edición de ECMASCript. Entonces podría cambiar antes de la versión final.

En este borrador, los objetos iterables deben tener la funcióniterator como propiedad.

Puede verificar si un objeto es iterable como este:

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

Para iteradores asíncronos , debe buscar el 'Symbol.asyncIterator' en lugar 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 quisiera comprobar de hecho si una variable es un objeto ( {key: value}) o una matriz ( [value, value]), puede hacerlo:

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