相关疑难解决方法(0)

[1,2,3].forEach(function(el) {
    if(el === 1) break;
});

如何forEach在JavaScript中使用新方法执行此操作？我试过了return;,return false;而且break.break崩溃,return除了继续迭代之外什么都不做.

async在await循环中使用是否有任何问题？我正在尝试循环遍历文件数组和forEach每个文件的内容.

import fs from 'fs-promise'

async function printFiles () {
  const files = await getFilePaths() // Assume this works fine

  files.forEach(async (file) => {
    const contents = await fs.readFile(file, 'utf8')
    console.log(contents)
  })
}

printFiles()

这段代码确实有效,但这可能会出错吗？我有人告诉我你不应该使用await这样的高阶函数,所以我只是想问一下这是否有任何问题.

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

该for...of构造被描述为能够迭代"可迭代"对象.但有没有一种很好的方法来决定一个对象是否可迭代？

我试图找到数组,迭代器和生成器的公共属性,但一直无法这样做.

除了for ... of在try块中执行并检查类型错误之外,还有一种干净的方法吗？

我注意到@@在几 页中使用了关于新的ES6功能,但我不知道它究竟意味着什么(无论是实际语法还是某种文档约定).谷歌很难.有人可以解释一下吗？

此代码生成错误:

function *giveNumbers() {
    [1, 2, 3].forEach(function(item) {
        yield item;
    })
}

这可能是因为yield在一个不是生成器的函数内部.有一种优雅的方法来克服这个问题吗？我的意思是:

function *giveNumbers() {
    let list = [1, 2, 3];
    for (let i = 0; i < list.length; i++) {
        yield list[i];
    }
}

另外，这是样式问题还是功能问题？是偏好问题还是更好？我试图了解目的。

通常我用

let iterable = [10, 20, 30];

iterable.forEach((val) => {
   console.log(val);
})

但我看到这种新语法可用。

let iterable = [10, 20, 30];

for (let value of iterable) {
  console.log(value);
}

能否提供一个最佳用例的例子，当有人使用它时可能会有所启发？

迭代器与迭代器相同还是不同？

从规范来看，iterable似乎是一个对象，obj例如，obj[Symbol.iterator]引用一个函数，以便在调用时返回一个具有next可以返回{value: ___, done: ___}对象的方法的对象：

function foo() {
    let i = 0;
    const wah = {
        next: function() {
            if (i <= 2) return { value: (1 + 2 * i++), done: false }
            else return { value: undefined, done: true }
        }
    };
    return wah;     // wah is iterator
}

let bar = {}        // bar is iterable

bar[Symbol.iterator] = foo;

console.log([...bar]);             // [1, 3, 5]   
for (a of bar) …

我想知道使用@@iterator函数与Symbol.iterator一个函数实现迭代器是否存在特定的差异:

在MDN上,有一个页面Array.prototype.@@iterator,但在示例本身中,Symbol.iterator用作函数名称.这只是更新版本,@@iterator不再有效,或者两者都有效吗？

我曾在几个地方,对于-in循环比遍历数组......虽然我明白,在的sizeof前进相比,后面的场景无论发生什么事来遍历一个对象的关键点(类型)块是几乎不费吹灰之力慢阅读,我仍然很好奇,究竟是什么原因,它是如此缓慢......

它是否必须执行反向哈希函数来获取密钥,而且该过程是什么慢？

让我们假设一个具有已定义迭代器的对象的两个类似实现:一个使用生成器的迭代器,另一个使用迭代.这两个都可以使用Array.from,并且它们都可以迭代.这两种方法有哪些区别,哪一种更受欢迎,为什么？是否需要较小的方法？

class Foo {
  constructor( ...args ) {
    this.f = args;
  }
  [Symbol.iterator]() {
    let c = 0;

    const i = {

      next: () => {
        if ( c < this.f.length ) {
          return {value:this.f[c++], done: false};
        }
        else {
          return {value:undefined,done:true};
        }
      }

    };
    return i;
  }

};

class Bar {
  constructor( ...args ) {
    this.f = args;
  }
  *[Symbol.iterator]() {
    let c = 0;

    if ( c < this.f.length ) …