Verificar se algo é iterável

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

A for...ofconstrução é descrita para ser capaz de iterar sobre objetos "iteráveis". Mas existe uma boa maneira de decidir se um objeto é iterável?

Tentei encontrar propriedades comuns para arrays, iteradores e geradores, mas não consegui.

Além de fazer um for ... ofbloco try e verificar erros de tipo, existe uma maneira limpa de fazer isso?

A maneira adequada de verificar a iterabilidade é a seguinte:

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

Por que isso funciona (protocolo iterável em profundidade): https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Iteration_protocols

Já que estamos falando sobre for..of, presumo, estamos na mentalidade ES6.

Além disso, não se surpreenda que esta função retorne truese objfor uma string, pois as strings iteram sobre seus caracteres.

Por que tão prolixo?

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

A solução mais simples é realmente esta:

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

Objectirá envolver qualquer coisa que não seja um objeto em um, permitindo que o inoperador trabalhe mesmo se o valor original não for um objeto. nulle undefinedsão transformados em objetos vazios, portanto, não há necessidade de detecção de casos extremos, e as strings são envolvidas em objetos String que são iteráveis.

Como nota lateral, CUIDADO com a definição de iterável . Se você estiver vindo de outras linguagens, poderá esperar que algo que possa iterar com, digamos, um forloop seja iterável . Infelizmente, esse não é o caso aqui, onde iterável significa algo que implementa o protocolo de iteração .

Para tornar as coisas mais claras, todos os exemplos acima retornam falsesobre esse objeto {a: 1, b: 2}porque esse objeto não implementa o protocolo de iteração. Portanto, você não será capaz de iterar sobre ele com um, for...of MAS ainda pode com um for...in.

Portanto, se você deseja evitar erros dolorosos, torne seu código mais específico renomeando seu método conforme mostrado abaixo:

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

Hoje em dia, como já foi dito, para testar se objé iterável basta fazer

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

Resposta histórica (não mais válida)

O for..ofconstructo é parte do ECMASCript 6ª edição do Language Specification Draft. Portanto, isso pode mudar antes da versão final.

Neste rascunho, os objetos iteráveis devem ter a função iteratorcomo uma propriedade.

Você pode verificar se um objeto é iterável assim:

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

Para iteradores assíncronos, você deve verificar o 'Symbol.asyncIterator' em vez 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

Se você quiser verificar de fato se uma variável é um objeto ( {key: value}) ou um array ( [value, value]), você pode fazer isso:

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