Quelle est la différence entre for et foreach dans es6-Questions et réponses frontales-php.cn

Différence : 1. forEach est un itérateur, qui est responsable du parcours des objets itérables (Array Set Map) ; tandis que for est un mécanisme de boucle, qui ne peut parcourir que des tableaux. 2. Certains comportements d'interruption sont utilisés dans la boucle for, ce qui est utile pour optimiser le parcours et la recherche de tableaux. Cependant, comme forEach est un itérateur et ne peut être parcouru que dans l'ordre, il ne prend pas en charge les comportements d'interruption. 3. Le point de départ de la boucle forEach ne peut être que 0, et une intervention humaine n'est pas possible contrairement à la boucle for, le point de départ de la boucle peut être contrôlé manuellement ;

Quelle est la différence entre for et foreach dans es6

L'environnement d'exploitation de ce tutoriel : système Windows 7, ECMAScript version 6, ordinateur Dell G3.

La différence essentielle entre la boucle for et la boucle forEach

La boucle for est une méthode de boucle qui existe depuis la proposition de js. for循环是js提出时就有的循环方法。

forEach是ES5提出的，挂载在可迭代对象原型上的方法，例如Array Set Map。

forEach是一个迭代器，负责遍历可迭代对象。

那么遍历，迭代，可迭代对象分别是什么呢。

遍历：指的对数据结构的每一个成员进行有规律的且为一次访问的行为。
迭代：迭代是递归的一种特殊形式，是迭代器提供的一种方法，默认情况下是按照一定顺序逐个访问数据结构成员。迭代也是一种遍历行为。
可迭代对象：ES6中引入了 iterable 类型，Array Set Map String arguments NodeList 都属于 iterable，他们特点就是都拥有 [Symbol.iterator] 方法，包含他的对象被认为是可迭代的 iterable。

forEach 其实是一个迭代器，他与 for 循环本质上的区别是 forEach 是负责遍历（Array Set Map）可迭代对象的，而 for 循环是一种循环机制，只是能通过它遍历出数组。

什么是迭代器，当它被调用时就会生成一个迭代器对象（Iterator Object），它有一个 .next()方法，每次调用返回一个对象{value:value,done:Boolean}，value返回的是 yield 后的返回值，当 yield 结束，done 变为 true，通过不断调用并依次的迭代访问内部的值。

迭代器是一种特殊对象。ES6规范中它的标志是返回对象的 next() 方法，迭代行为判断在 done 之中。在不暴露内部表示的情况下，迭代器实现了遍历。看代码

let arr = [1, 2, 3, 4]  // 可迭代对象
let iterator = arr[Symbol.iterator]()  // 调用 Symbol.iterator 后生成了迭代器对象
console.log(iterator.next()); // {value: 1, done: false}  访问迭代器对象的next方法
console.log(iterator.next()); // {value: 2, done: false}
console.log(iterator.next()); // {value: 3, done: false}
console.log(iterator.next()); // {value: 4, done: false}
console.log(iterator.next()); // {value: undefined, done: true}

Copier après la connexion

我们看到了。只要是可迭代对象，调用内部的 Symbol.iterator 都会提供一个迭代器，并根据迭代器返回的next 方法来访问内部，这也是 for...of 的实现原理。

let arr = [1, 2, 3, 4]
for (const item of arr) {
    console.log(item); // 1 2 3 4 
}

Copier après la connexion

把调用 next 方法返回对象的 value 值并保存在 item 中，直到 value 为 undefined 跳出循环，所有可迭代对象可供for...of消费。再来看看其他可迭代对象：

function num(params) {
    console.log(arguments); // Arguments(6) [1, 2, 3, 4, callee: ƒ, Symbol(Symbol.iterator): ƒ]
    let iterator = arguments[Symbol.iterator]()
    console.log(iterator.next()); // {value: 1, done: false}
    console.log(iterator.next()); // {value: 2, done: false}
    console.log(iterator.next()); // {value: 3, done: false}
    console.log(iterator.next()); // {value: 4, done: false}
    console.log(iterator.next()); // {value: undefined, done: true}
}
num(1, 2, 3, 4)

let set = new Set('1234')
set.forEach(item => {
    console.log(item); // 1 2 3 4
})
let iterator = set[Symbol.iterator]()
console.log(iterator.next()); // {value: 1, done: false}
console.log(iterator.next()); // {value: 2, done: false}
console.log(iterator.next()); // {value: 3, done: false}
console.log(iterator.next()); // {value: 4, done: false}
console.log(iterator.next()); // {value: undefined, done: true}

Copier après la connexion

所以可迭代对象中的 Symbol.iterator 属性被调用时都能生成迭代器，而 forEach 也是生成一个迭代器，在内部的回调函数中传递出每个元素的值

for循环和forEach的语法区别

了解了本质区别，在应用过程中，他们到底有什么语法区别呢？

forEach 的参数。
forEach 的中断。
forEach 删除自身元素，index不可被重置。
for 循环可以控制循环起点。

`forEach` 的参数

我们真正了解 forEach 的完整传参内容吗？它大概是这样：

arr.forEach((self,index,arr) =>{},this)

Copier après la connexion

self： 数组当前遍历的元素，默认从左往右依次获取数组元素。
index： 数组当前元素的索引，第一个元素索引为0，依次类推。
arr： 当前遍历的数组。
this： 回调函数中this指向。

let arr = [1, 2, 3, 4];
arr.forEach(function (self, index, arr) {
    console.log(`当前元素为${self}索引为${index},属于数组${arr}`);
}, person)

Copier après la connexion

我们可以利用 arr

forEach est une méthode proposée par ES5 et montée sur le prototype d'un objet itérable, tel que Array Set Map code >. 🎜🎜<code>forEach est un itérateur, chargé de parcourir les objets itérables. 🎜🎜Alors, que sont respectivement 🎜traversale🎜, 🎜itération🎜 et 🎜objet itérable🎜. 🎜

🎜🎜Traversal🎜 : fait référence à l'accès régulier et unique à chaque membre de la structure de données. 🎜
🎜🎜Itération🎜 : L'itération est une forme spéciale de récursivité et une méthode fournie par les itérateurs. Par défaut, elle accède aux membres de la structure de données un par un dans un certain ordre. L'itération est également un comportement de traversée. 🎜
🎜🎜Objets itérables🎜 : Le type iterable a été introduit dans ES6, Array Set Map <code>String arguments NodeList sont tous itérables, et leur caractéristique est qu'ils ont tous [ Symbol.iterator ], l'objet qui le contient est considéré comme un iterable itérable. 🎜

🎜forEach est en fait un itérateur. La différence essentielle entre celui-ci et la boucle for est que forEach est. responsable des objets itérables Traverse (Array Set Map), et la boucle for est un mécanisme de boucle qui ne peut que Parcourez le tableau. 🎜🎜Qu'est-ce qu'un 🎜Iterator🎜 ? Lorsqu'il est appelé, il génère un objet Iterator. Il a une méthode .next(), et chaque appel renvoie un objet {value:value ,done:Boolean}, value renvoie la valeur de retour après yield Lorsque yield se termine, done devient <code>true et la valeur interne est accessible via des appels continus et des itérations séquentielles. 🎜🎜🎜Iterator🎜 est un type particulier d'objet. Son symbole dans la spécification ES6 est la méthode next() qui renvoie l'objet, et le comportement de l'itération est jugé dans done. Les itérateurs implémentent le parcours sans exposer la représentation interne. En regardant le code 🎜

let arr1 = [1, 2, 1, 3, 1];
let arr2 = [];
arr1.forEach(function (self, index, arr) {
    arr.indexOf(self) === index ? arr2.push(self) : null;
});
console.log(arr2);   // [1,2,3]

Copier après la connexion

🎜 on le voit. Tant qu'il s'agit d'un objet itérable, l'appel du Symbol.iterator interne fournira un itérateur et accédera aux éléments internes selon la méthode next renvoyée par l'itérateur, qui est également le principe de mise en œuvre de for ...of. 🎜

let arr = [1, 2, 3, 4],
    i = 0,
    length = arr.length;
for (; i < length; i++) {
    console.log(arr[i]); //1,2
    if (arr[i] === 2) {
        break;
    };
};

arr.forEach((self,index) => {
    console.log(self);
    if (self === 2) {
        break; //报错
    };
});

arr.forEach((self,index) => {
    console.log(self);
    if (self === 2) {
        continue; //报错
    };
});

Copier après la connexion

🎜Appelez la méthode next pour renvoyer la valeur value de l'objet et enregistrez-la dans item jusqu'à value is undefined sort de la boucle et tous les objets itérables sont disponibles pour être consommés par for...of. Jetons un coup d'œil à d'autres objets itérables : 🎜

try {
    var arr = [1, 2, 3, 4];
    arr.forEach(function (item, index) {
        //跳出条件
        if (item === 3) {
            throw new Error("LoopTerminates");
        }
        //do something
        console.log(item);
    });
} catch (e) {
    if (e.message !== "LoopTerminates") throw e;
};

Copier après la connexion

🎜Ainsi, lorsque la propriété Symbol.iterator dans un objet itérable est appelée, elle peut générer un itérateur, et forEach génère également un itérateur La différence de syntaxe entre loop et 🎜🎜forEach🎜🎜🎜🎜🎜🎜 Maintenant que nous comprenons les différences essentielles, quelles sont les différences grammaticales entre eux lors de l'application ? 🎜

paramètres de 🎜forEach. 🎜
🎜L'interruption de forEach. 🎜
🎜forEach supprime son propre élément et l'index ne peut pas être réinitialisé. 🎜
🎜La boucle for peut contrôler le point de départ de la boucle. 🎜

🎜Paramètres de `forEach`🎜

🎜Nous comprenons vraiment l'exhaustivité de forEach Passer le contenu des paramètres ? Cela ressemble probablement à ceci : 🎜

let arr = [1, 2, 3, 4];

function find(array, num) {
    array.forEach((self, index) => {
        if (self === num) {
            return index;
        };
    });
};
let index = find(arr, 2);// undefined

Copier après la connexion

🎜🎜self : 🎜 Les éléments actuellement parcourus par le tableau Par défaut, les éléments du tableau sont obtenus de gauche à droite. droite. 🎜
🎜🎜index : 🎜 L'index de l'élément actuel du tableau, l'index du premier élément est 0, et ainsi de suite. 🎜
🎜🎜arr : 🎜 Le tableau actuellement parcouru. 🎜
🎜🎜this : 🎜 Cela pointe vers la fonction de rappel. 🎜

let arr = [1,2,3,4]
arr.forEach((item, index) => {
    console.log(item); // 1 2 3 4
    index++;
});

Copier après la connexion

🎜Nous pouvons utiliser arr pour réaliser la déduplication de tableau :🎜

let arr1 = [1, 2, 1, 3, 1];
let arr2 = [];
arr1.forEach(function (self, index, arr) {
    arr.indexOf(self) === index ? arr2.push(self) : null;
});
console.log(arr2);   // [1,2,3]

Copier après la connexion

`forEach` 的中断

在js中有break return continue 对函数进行中断或跳出循环的操作，我们在 for循环中会用到一些中断行为，对于优化数组遍历查找是很好的，但由于forEach属于迭代器，只能按序依次遍历完成，所以不支持上述的中断行为。

let arr = [1, 2, 3, 4],
    i = 0,
    length = arr.length;
for (; i < length; i++) {
    console.log(arr[i]); //1,2
    if (arr[i] === 2) {
        break;
    };
};

arr.forEach((self,index) => {
    console.log(self);
    if (self === 2) {
        break; //报错
    };
});

arr.forEach((self,index) => {
    console.log(self);
    if (self === 2) {
        continue; //报错
    };
});

Copier après la connexion

如果我一定要在 forEach 中跳出循环呢？其实是有办法的，借助try/catch：

try {
    var arr = [1, 2, 3, 4];
    arr.forEach(function (item, index) {
        //跳出条件
        if (item === 3) {
            throw new Error("LoopTerminates");
        }
        //do something
        console.log(item);
    });
} catch (e) {
    if (e.message !== "LoopTerminates") throw e;
};

Copier après la connexion

若遇到 return 并不会报错，但是不会生效

let arr = [1, 2, 3, 4];

function find(array, num) {
    array.forEach((self, index) => {
        if (self === num) {
            return index;
        };
    });
};
let index = find(arr, 2);// undefined

Copier après la connexion

`forEach` 删除自身元素，index不可被重置

在 forEach 中我们无法控制 index 的值，它只会无脑的自增直至大于数组的 length 跳出循环。所以也无法删除自身进行index重置，先看一个简单例子：

let arr = [1,2,3,4]
arr.forEach((item, index) => {
    console.log(item); // 1 2 3 4
    index++;
});

Copier après la connexion

index不会随着函数体内部对它的增减而发生变化。在实际开发中，遍历数组同时删除某项的操作十分常见，在使用forEach删除时要注意。

`for` 循环可以控制循环起点

如上文提到的 forEach 的循环起点只能为0不能进行人为干预，而for循环不同：

let arr = [1, 2, 3, 4],
    i = 1,
    length = arr.length;

for (; i < length; i++) {
    console.log(arr[i]) // 2 3 4
};

Copier après la connexion

那之前的数组遍历并删除滋生的操作就可以写成

let arr = [1, 2, 1],
    i = 0,
    length = arr.length;

for (; i < length; i++) {
    // 删除数组中所有的1
    if (arr[i] === 1) {
        arr.splice(i, 1);
        //重置i，否则i会跳一位
        i--;
    };
};
console.log(arr); // [2]
//等价于
var arr1 = arr.filter(index => index !== 1);
console.log(arr1) // [2]

Copier après la connexion

for循环和forEach的性能区别

在性能对比方面我们加入一个 map 迭代器，它与 filter 一样都是生成新数组。

对比 for forEach map 的性能在浏览器环境中都是什么样的：

性能比较：for > forEach > map 在chrome 62 和 Node.js v9.1.0环境下：for 循环比 forEach 快1倍，forEach 比 map 快20%左右。

原因分析for：for循环没有额外的函数调用栈和上下文，所以它的实现最为简单。

forEach：对于forEach来说，它的函数签名中包含了参数和上下文，所以性能会低于 for 循环。

map：map 最慢的原因是因为 map 会返回一个新的数组，数组的创建和赋值会导致分配内存空间，因此会带来较大的性能开销。

如果将map嵌套在一个循环中，便会带来更多不必要的内存消耗。

当大家使用迭代器遍历一个数组时，如果不需要返回一个新数组却使用 map 是违背设计初衷的。

【相关推荐：javascript视频教程、编程视频】

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!