检查某事是否可迭代

Question

在 MDN 文档中：https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...of

for...of 构造被描述为能够迭代“可迭代”对象。但是有没有确定对象是否可迭代的好方法？

我试图找到数组、迭代器和生成器的通用属性，但一直没能做到。

除了在 try 块中执行 for ... of 并检查类型错误之外，是否有一种干净的方法来执行此操作？

Answer 1

如前所述，现在要测试 obj 是否可迭代

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

历史答案（不再有效）

for..of 结构是 ECMASCript 第 6 版语言规范草案的一部分。所以它可能会在最终版本之前改变。

在此草案中，iterable 对象必须具有函数 iterator 作为属性。

您可以像这样检查对象是否可迭代：

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

Answer 2

检查可迭代性的正确方法如下：

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

为什么会这样（深度可迭代协议）：https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Iteration_protocols

既然我们在谈论 for..of，我假设我们处于 ES6 思维模式。

此外，如果 obj 是字符串，则此函数返回 true 不要感到惊讶，因为字符串会遍历其字符。

Answer 3

为什么这么冗长？

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

Answer 4

作为旁注，注意关于iterable的定义。如果您来自其他语言，您会期望可以迭代的东西，例如，for 循环是iterable。恐怕这里 iterable 意味着实现iteration protocol 的东西不是这种情况。

为了使事情更清楚，上面的所有示例都在此对象 {a: 1, b: 2} 上返回 false，因为该对象未实现迭代协议。因此，您将无法使用 for...of 对其进行迭代但您仍然可以使用 for...in。

因此，如果您想避免痛苦的错误，请通过如下所示重命名您的方法来使您的代码更加具体：

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

Answer 5

最简单的解决方案其实是这样的：

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

Object 将把任何不是对象的东西包装在一个中，即使原始值不是对象，in 运算符也能工作。 null 和 undefined 被转换为空对象，因此不需要边缘情况检测，字符串被包装成可迭代的 String 对象。

Answer 6

对于 async 迭代器，您应该检查“Symbol.asyncIterator”而不是“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

Answer 7

如果您想检查变量是对象 ({key: value}) 还是数组 ([value, value])，您可以这样做：

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

Answer 8

我正在寻找for ... in 的支票并决定如下。

isIterable (value) {
  // add further checks here based on need.
  return Object.keys(Object(value)).length > 0
}

这将返回true 任何可迭代且至少有一个值的东西。 因此空字符串、空数组、空对象等将返回false。 但是{a: 'x', b:'y'} 会返回true。

Answer 9

如果对象具有属性Symbol.iterator，那么它是可迭代的。然后我们可以简单地检查obj是否像这样可迭代

打字稿

function isIterable(x: unknown): boolean {
  return !!x?.[Symbol.iterator];
}

或者作为箭头函数

const isIterable = (x: unknown): boolean => !!x?.[Symbol.iterator];

JavaScript

const isIterable = x => !!x?.[Symbol.iterator];

示例

isIterable(["hello", "world"]); // true
isIterable({}); // false
isIterable(null); // false
isIterable(undefined); // false
isIterable(1); // false
isIterable(true); // false
isIterable(Symbol("foo")); // false
isIterable(new Set()); // true
isIterable(new Map()); // true

Answer 10

2022 答案

如果您问的是“foo 是否可迭代”，那么您可能来自一种语言（PHP、Python），其中该问题只有一个答案。 在现代 Javascript 中，存在不同类型的可迭代对象。因此，您必须根据要对变量执行的操作来检查迭代能力。

TL;DR

• 测试使用 forEach() 和 !!foo.forEach 进行迭代的能力，在数组上返回 true。
• 测试使用 for..of 和 !!foo[Symbol.iterator] 进行迭代的能力，在数组或字符串上返回 true。
• 测试使用 for..in 和 !!Object.keys(Object(foo)).length 进行迭代的能力，在数组、字符串或对象上返回 true。

长答案

让我们定义一些变量：

const someNumber = 42;
42

const someArray = [1,2,3];
(3) [1, 2, 3]

const someString = "Hello";
"Hello, world!"

const someObject = {a:"A", b:"B"};
{a: "A", b: "B"}

使用forEach() 测试可迭代性

哪些类型可以用forEach()迭代，用!!foo.forEach测试：

someNumber.forEach(x=>console.log(x));
VM1526:1 Uncaught TypeError: someNumber.forEach is not a function at <anonymous>:1:12

someArray.forEach(x=>console.log(x));
VM916:1 1
VM916:1 2
VM916:1 3
undefined

someString.forEach(x=>console.log(x));
VM957:1 Uncaught TypeError: someString.forEach is not a function at <anonymous>:1:12

someObject.forEach(x=>console.log(x));
VM994:1 Uncaught TypeError: someObject.forEach is not a function at <anonymous>:1:12

似乎只有 Array 可以使用 forEach() 进行迭代。

使用for..of 测试可迭代性

哪些类型可以用for..of迭代，用!!foo[Symbol.iterator]测试：

for (x of someNumber) { console.log(x); }
VM21027:1 Uncaught TypeError: someNumber is not iterable at <anonymous>:1:11
    
for (x of someArray) { console.log(x); }
VM21047:1 1
VM21047:1 2
VM21047:1 3
undefined

for (x of someString) { console.log(x); }
VM21065:1 H
VM21065:1 e
VM21065:1 l
VM21065:1 l
VM21065:1 o
undefined

for (x of someObject) { console.log(x); }
VM21085:1 Uncaught TypeError: someObject is not iterable at <anonymous>:1:11

​Array 和 String 似乎可以用 for..of 进行迭代，但 Object 不是。并且 Number 和 Object 都抛出了错误。

使用for..in 测试可迭代性

哪些类型可以用for..in迭代，用!!Object.keys(Object(foo)).length测试：

for (x in someNumber) { console.log(x); }
undefined

for (x in someArray) { console.log(x); }
VM20918:1 0
VM20918:1 1
VM20918:1 2
undefined

for (x in someString) { console.log(x); }
VM20945:1 0
VM20945:1 1
VM20945:1 2
VM20945:1 3
VM20945:1 4
undefined

for (x in someObject) { console.log(x); }
VM20972:1 a
VM20972:1 b
undefined

​Array、String 和 Object 似乎都可以使用for..in 进行迭代。虽然它没有迭代，但 Number 没有抛出错误。

在现代 ES6 Javascript 中，我看到 forEach 的使用频率远高于 for..in 或 for..of。但是 Javascript 开发人员必须意识到这三种方法之间的差异，以及每种方法的不同行为。