Sprawdzanie, czy coś jest iterowalne

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

for...ofKonstrukcja jest opisana w stanie iteracyjnego „Iterable” obiektów. Ale czy istnieje dobry sposób decydowania, czy obiekt jest iterowalny?

Próbowałem znaleźć wspólne właściwości dla tablic, iteratorów i generatorów, ale nie mogłem tego zrobić.

Pomijając wykonanie for ... ofbloku try i sprawdzanie błędów typu, czy jest na to czysty sposób?

Właściwy sposób sprawdzenia iterowalności jest następujący:

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

Dlaczego to działa (dogłębnie iterowalny protokół): https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Iteration_protocols

Ponieważ mówimy o for..of, zakładam, że jesteśmy nastawieni na ES6.

Nie zdziw się również, że ta funkcja zwraca, truejeśli objjest łańcuchem, ponieważ ciągi iterują po swoich znakach.

Dlaczego taki gadatliwy?

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

Najprostsze rozwiązanie jest w rzeczywistości takie:

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

Objectzawinie wszystko, co nie jest obiektem, w jeden, umożliwiając inoperatorowi pracę, nawet jeśli oryginalna wartość nie jest obiektem. nulli undefinedsą zamieniane na puste obiekty, więc nie ma potrzeby wykrywania wielkości liter, a łańcuchy są zawijane w obiekty typu String, które są iterowalne.

Na marginesie, UWAŻAJ na definicję iterowalności . Jeśli pochodzisz z innych języków, spodziewasz się, że coś, po czym możesz iterować, powiedzmy, forpętla jest iterowalna . Obawiam się, że tak nie jest w tym przypadku, gdy iterowalność oznacza coś, co implementuje protokół iteracji .

Aby wszystko było jaśniejsze, wszystkie powyższe przykłady zwracają falsesię do tego obiektu, {a: 1, b: 2}ponieważ ten obiekt nie implementuje protokołu iteracji. Więc nie będziesz w stanie go iterować za pomocą for...of ALE nadal możesz z for...in.

Jeśli więc chcesz uniknąć bolesnych błędów, doprecyzuj swój kod, zmieniając nazwę metody, jak pokazano poniżej:

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

W przypadku iteratorów asynchronicznych należy sprawdzić „Symbol.asyncIterator” zamiast „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

W dzisiejszych czasach, jak już wspomniano, aby sprawdzić, czy objjest iterowalne, po prostu zrób

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

Historyczna odpowiedź (już nieaktualna)

Plik for..ofKonstrukt jest częścią ECMAScript 6. wydanie Language Specification Draft. Więc może się to zmienić przed ostateczną wersją.

W tej wersji roboczej iterowalne obiekty muszą mieć funkcjęiterator jako właściwość.

Możesz sprawdzić, czy obiekt jest iterowalny w następujący sposób:

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

Jeśli chcesz sprawdzić, czy zmienna jest obiektem ( {key: value}) czy tablicą ( [value, value]), możesz to zrobić:

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