Phương thức
0 thực thi một hàm được cung cấp một lần cho mỗi phần tử mảng.const ratings = [5, 4, 5];
let sum = 0;
const sumFunction = async [a, b] => a + b;
ratings.forEach[async [rating] => {
sum = await sumFunction[sum, rating];
}];
console.log[sum];
// Naively expected output: 14
// Actual output: 0
0 method executes a provided function once for each array element. const ratings = [5, 4, 5];
let sum = 0;
const sumFunction = async [a, b] => a + b;
ratings.forEach[async [rating] => {
sum = await sumFunction[sum, rating];
}];
console.log[sum];
// Naively expected output: 14
// Actual output: 0
Thử nó
Cú pháp
// Arrow function
forEach[[element] => { /* … */ }]
forEach[[element, index] => { /* … */ }]
forEach[[element, index, array] => { /* … */ }]
// Callback function
forEach[callbackFn]
forEach[callbackFn, thisArg]
// Inline callback function
forEach[function [element] { /* … */ }]
forEach[function [element, index] { /* … */ }]
forEach[function [element, index, array] { /* … */ }]
forEach[function [element, index, array] { /* … */ }, thisArg]
Thông số
const ratings = [5, 4, 5];
let sum = 0;
const sumFunction = async [a, b] => a + b;
ratings.forEach[async [rating] => {
sum = await sumFunction[sum, rating];
}];
console.log[sum];
// Naively expected output: 14
// Actual output: 0
1Một hàm để thực thi cho mỗi phần tử trong mảng. Giá trị trả lại của nó bị loại bỏ.
Hàm được gọi với các đối số sau:
const ratings = [5, 4, 5];
let sum = 0;
const sumFunction = async [a, b] => a + b;
ratings.forEach[async [rating] => {
sum = await sumFunction[sum, rating];
}];
console.log[sum];
// Naively expected output: 14
// Actual output: 0
2Phần tử hiện tại được xử lý trong mảng.
const ratings = [5, 4, 5];
let sum = 0;
const sumFunction = async [a, b] => a + b;
ratings.forEach[async [rating] => {
sum = await sumFunction[sum, rating];
}];
console.log[sum];
// Naively expected output: 14
// Actual output: 0
3Chỉ số của phần tử hiện tại được xử lý trong mảng.
const ratings = [5, 4, 5];
let sum = 0;
const sumFunction = async [a, b] => a + b;
ratings.forEach[async [rating] => {
sum = await sumFunction[sum, rating];
}];
console.log[sum];
// Naively expected output: 14
// Actual output: 0
4Mảng
const ratings = [5, 4, 5];
let sum = 0;
const sumFunction = async [a, b] => a + b;
ratings.forEach[async [rating] => {
sum = await sumFunction[sum, rating];
}];
console.log[sum];
// Naively expected output: 14
// Actual output: 0
0 đã được kêu gọi.const ratings = [5, 4, 5];
let sum = 0;
const sumFunction = async [a, b] => a + b;
ratings.forEach[async [rating] => {
sum = await sumFunction[sum, rating];
}];
console.log[sum];
// Naively expected output: 14
// Actual output: 0
6 Tùy chọnOptionalGiá trị để sử dụng là
const ratings = [5, 4, 5];
let sum = 0;
const sumFunction = async [a, b] => a + b;
ratings.forEach[async [rating] => {
sum = await sumFunction[sum, rating];
}];
console.log[sum];
// Naively expected output: 14
// Actual output: 0
7 khi thực hiện const ratings = [5, 4, 5];
let sum = 0;
const sumFunction = async [a, b] => a + b;
ratings.forEach[async [rating] => {
sum = await sumFunction[sum, rating];
}];
console.log[sum];
// Naively expected output: 14
// Actual output: 0
1. Xem phương pháp lặp.Giá trị trả lại
const ratings = [5, 4, 5];
let sum = 0;
const sumFunction = async [a, b] => a + b;
ratings.forEach[async [rating] => {
sum = await sumFunction[sum, rating];
}];
console.log[sum];
// Naively expected output: 14
// Actual output: 0
9.Sự mô tả
Phương pháp
const ratings = [5, 4, 5];
let sum = 0;
const sumFunction = async [a, b] => a + b;
ratings.forEach[async [rating] => {
sum = await sumFunction[sum, rating];
}];
console.log[sum];
// Naively expected output: 14
// Actual output: 0
0 là một phương pháp lặp. Nó gọi hàm const ratings = [5, 4, 5];
let sum = 0;
const sumFunction = async [a, b] => a + b;
ratings.forEach[async [rating] => {
sum = await sumFunction[sum, rating];
}];
console.log[sum];
// Naively expected output: 14
// Actual output: 0
1 được cung cấp một lần cho mỗi phần tử theo một mảng theo thứ tự chỉ số tăng dần. Không giống như const arraySparse = [1, 3, /* empty */, 7];
let numCallbackRuns = 0;
arraySparse.forEach[[element] => {
console.log[{ element }];
numCallbackRuns++;
}];
console.log[{ numCallbackRuns }];
// { element: 1 }
// { element: 3 }
// { element: 7 }
// { numCallbackRuns: 3 }
2, const ratings = [5, 4, 5];
let sum = 0;
const sumFunction = async [a, b] => a + b;
ratings.forEach[async [rating] => {
sum = await sumFunction[sum, rating];
}];
console.log[sum];
// Naively expected output: 14
// Actual output: 0
0 luôn trả về const ratings = [5, 4, 5];
let sum = 0;
const sumFunction = async [a, b] => a + b;
ratings.forEach[async [rating] => {
sum = await sumFunction[sum, rating];
}];
console.log[sum];
// Naively expected output: 14
// Actual output: 0
9 và không thể xích. Trường hợp sử dụng điển hình là thực hiện các tác dụng phụ ở cuối chuỗi.const ratings = [5, 4, 5];
let sum = 0;
const sumFunction = async [a, b] => a + b;
ratings.forEach[async [rating] => {
sum = await sumFunction[sum, rating];
}];
console.log[sum];
// Naively expected output: 14
// Actual output: 0
1 chỉ được gọi cho các chỉ mục mảng đã gán các giá trị. Nó không được gọi cho các khe trống trong các mảng thưa thớt.const ratings = [5, 4, 5];
let sum = 0;
const sumFunction = async [a, b] => a + b;
ratings.forEach[async [rating] => {
sum = await sumFunction[sum, rating];
}];
console.log[sum];
// Naively expected output: 14
// Actual output: 0
0 không làm biến đổi mảng mà nó được gọi, nhưng chức năng được cung cấp như const ratings = [5, 4, 5];
let sum = 0;
const sumFunction = async [a, b] => a + b;
ratings.forEach[async [rating] => {
sum = await sumFunction[sum, rating];
}];
console.log[sum];
// Naively expected output: 14
// Actual output: 0
1 có thể. Tuy nhiên, lưu ý rằng độ dài của mảng được lưu trước khi gọi đầu tiên của const ratings = [5, 4, 5];
let sum = 0;
const sumFunction = async [a, b] => a + b;
ratings.forEach[async [rating] => {
sum = await sumFunction[sum, rating];
}];
console.log[sum];
// Naively expected output: 14
// Actual output: 0
1. Vì vậy:
1 sẽ không truy cập bất kỳ yếu tố nào được thêm vào ngoài độ dài ban đầu của mảng khi cuộc gọi đếnconst ratings = [5, 4, 5]; let sum = 0; const sumFunction = async [a, b] => a + b; ratings.forEach[async [rating] => { sum = await sumFunction[sum, rating]; }]; console.log[sum]; // Naively expected output: 14 // Actual output: 0
0 bắt đầu.const items = ['item1', 'item2', 'item3']; const copyItems = []; // before for [let i = 0; i { copyItems.push[item]; }];
- Các thay đổi đối với các chỉ mục đã được truy cập không khiến
1 được gọi lại trên chúng.const ratings = [5, 4, 5]; let sum = 0; const sumFunction = async [a, b] => a + b; ratings.forEach[async [rating] => { sum = await sumFunction[sum, rating]; }]; console.log[sum]; // Naively expected output: 14 // Actual output: 0
- Nếu một phần tử hiện có, chưa được liên kết của mảng được thay đổi bởi
1, giá trị của nó được chuyển choconst ratings = [5, 4, 5]; let sum = 0; const sumFunction = async [a, b] => a + b; ratings.forEach[async [rating] => { sum = await sumFunction[sum, rating]; }]; console.log[sum]; // Naively expected output: 14 // Actual output: 0
1 sẽ là giá trị tại thời điểm phần tử đó được truy cập. Các yếu tố bị xóa không được truy cập.const ratings = [5, 4, 5]; let sum = 0; const sumFunction = async [a, b] => a + b; ratings.forEach[async [rating] => { sum = await sumFunction[sum, rating]; }]; console.log[sum]; // Naively expected output: 14 // Actual output: 0
CẢNH BÁO: Sửa đổi đồng thời của loại được mô tả ở trên thường xuyên dẫn đến mã khó hiểu và thường được tránh [ngoại trừ trong các trường hợp đặc biệt]. Concurrent modifications of the kind described above frequently lead to hard-to-understand code and are generally to be avoided [except in special cases].
Phương pháp
const ratings = [5, 4, 5];
let sum = 0;
const sumFunction = async [a, b] => a + b;
ratings.forEach[async [rating] => {
sum = await sumFunction[sum, rating];
}];
console.log[sum];
// Naively expected output: 14
// Actual output: 0
0 là chung chung. Nó chỉ mong đợi giá trị const ratings = [5, 4, 5];
let sum = 0;
const sumFunction = async [a, b] => a + b;
ratings.forEach[async [rating] => {
sum = await sumFunction[sum, rating];
}];
console.log[sum];
// Naively expected output: 14
// Actual output: 0
7 có thuộc tính const items = ['item1', 'item2', 'item3'];
const copyItems = [];
// before
for [let i = 0; i {
copyItems.push[item];
}];
6 và các thuộc tính được khóa.Không có cách nào để dừng hoặc phá vỡ vòng lặp
const ratings = [5, 4, 5];
let sum = 0;
const sumFunction = async [a, b] => a + b;
ratings.forEach[async [rating] => {
sum = await sumFunction[sum, rating];
}];
console.log[sum];
// Naively expected output: 14
// Actual output: 0
0 ngoài việc ném một ngoại lệ. Nếu bạn cần hành vi như vậy, phương thức const ratings = [5, 4, 5];
let sum = 0;
const sumFunction = async [a, b] => a + b;
ratings.forEach[async [rating] => {
sum = await sumFunction[sum, rating];
}];
console.log[sum];
// Naively expected output: 14
// Actual output: 0
0 là công cụ sai.Chấm dứt sớm có thể được thực hiện bằng các tuyên bố vòng lặp như
const items = ['item1', 'item2', 'item3'];
const copyItems = [];
// before
for [let i = 0; i {
copyItems.push[item];
}];
9, const logArrayElements = [element, index /*, array */] => {
console.log[`a[${index}] = ${element}`];
};
// Notice that index 2 is skipped, since there is no item at
// that position in the array.
[2, 5, , 9].forEach[logArrayElements];
// Logs:
// a[0] = 2
// a[1] = 5
// a[3] = 9
0 và const logArrayElements = [element, index /*, array */] => {
console.log[`a[${index}] = ${element}`];
};
// Notice that index 2 is skipped, since there is no item at
// that position in the array.
[2, 5, , 9].forEach[logArrayElements];
// Logs:
// a[0] = 2
// a[1] = 5
// a[3] = 9
1. Các phương pháp mảng như const items = ['item1', 'item2', 'item3'];
const copyItems = [];
// before
for [let i = 0; i {
copyItems.push[item];
}];
0, const logArrayElements = [element, index /*, array */] => {
console.log[`a[${index}] = ${element}`];
};
// Notice that index 2 is skipped, since there is no item at
// that position in the array.
[2, 5, , 9].forEach[logArrayElements];
// Logs:
// a[0] = 2
// a[1] = 5
// a[3] = 9
3, const logArrayElements = [element, index /*, array */] => {
console.log[`a[${index}] = ${element}`];
};
// Notice that index 2 is skipped, since there is no item at
// that position in the array.
[2, 5, , 9].forEach[logArrayElements];
// Logs:
// a[0] = 2
// a[1] = 5
// a[3] = 9
4 và const logArrayElements = [element, index /*, array */] => {
console.log[`a[${index}] = ${element}`];
};
// Notice that index 2 is skipped, since there is no item at
// that position in the array.
[2, 5, , 9].forEach[logArrayElements];
// Logs:
// a[0] = 2
// a[1] = 5
// a[3] = 9
5 cũng dừng lặp lại ngay lập tức khi không cần lặp thêm.const ratings = [5, 4, 5];
let sum = 0;
const sumFunction = async [a, b] => a + b;
ratings.forEach[async [rating] => {
sum = await sumFunction[sum, rating];
}];
console.log[sum];
// Naively expected output: 14
// Actual output: 0
0 mong đợi một chức năng đồng bộ - nó không chờ đợi lời hứa. Hãy chắc chắn rằng bạn nhận thức được các hàm ý trong khi sử dụng các lời hứa [hoặc các hàm async] như const logArrayElements = [element, index /*, array */] => {
console.log[`a[${index}] = ${element}`];
};
// Notice that index 2 is skipped, since there is no item at
// that position in the array.
[2, 5, , 9].forEach[logArrayElements];
// Logs:
// a[0] = 2
// a[1] = 5
// a[3] = 9
7 gọi lại.const ratings = [5, 4, 5];
let sum = 0;
const sumFunction = async [a, b] => a + b;
ratings.forEach[async [rating] => {
sum = await sumFunction[sum, rating];
}];
console.log[sum];
// Naively expected output: 14
// Actual output: 0
Để chạy một loạt các hoạt động không đồng bộ theo tuần tự hoặc đồng thời, hãy xem thành phần hứa hẹn.
Ví dụ
Sử dụng foreach [] trên các mảng thưa thớt
const arraySparse = [1, 3, /* empty */, 7];
let numCallbackRuns = 0;
arraySparse.forEach[[element] => {
console.log[{ element }];
numCallbackRuns++;
}];
console.log[{ numCallbackRuns }];
// { element: 1 }
// { element: 3 }
// { element: 7 }
// { numCallbackRuns: 3 }
Hàm gọi lại không được gọi cho giá trị còn thiếu tại INDEX 2.
Chuyển đổi một vòng lặp thành foreach
const items = ['item1', 'item2', 'item3'];
const copyItems = [];
// before
for [let i = 0; i {
copyItems.push[item];
}];
In nội dung của một mảng
Lưu ý: Để hiển thị nội dung của một mảng trong bảng điều khiển, bạn có thể sử dụng
8, in phiên bản được định dạng của mảng. In order to display the content of an array in the console, you can use const logArrayElements = [element, index /*, array */] => {
console.log[`a[${index}] = ${element}`];
};
// Notice that index 2 is skipped, since there is no item at
// that position in the array.
[2, 5, , 9].forEach[logArrayElements];
// Logs:
// a[0] = 2
// a[1] = 5
// a[3] = 9
const logArrayElements = [element, index /*, array */] => {
console.log[`a[${index}] = ${element}`];
};
// Notice that index 2 is skipped, since there is no item at
// that position in the array.
[2, 5, , 9].forEach[logArrayElements];
// Logs:
// a[0] = 2
// a[1] = 5
// a[3] = 9
8, which prints a formatted version of the array. Ví dụ sau đây minh họa một cách tiếp cận thay thế, sử dụng
const ratings = [5, 4, 5];
let sum = 0;
const sumFunction = async [a, b] => a + b;
ratings.forEach[async [rating] => {
sum = await sumFunction[sum, rating];
}];
console.log[sum];
// Naively expected output: 14
// Actual output: 0
0.Mã sau ghi một dòng cho mỗi phần tử trong một mảng:
const logArrayElements = [element, index /*, array */] => {
console.log[`a[${index}] = ${element}`];
};
// Notice that index 2 is skipped, since there is no item at
// that position in the array.
[2, 5, , 9].forEach[logArrayElements];
// Logs:
// a[0] = 2
// a[1] = 5
// a[3] = 9
Sử dụng này
Ví dụ sau [giả định] cập nhật các thuộc tính của một đối tượng từ mỗi mục trong mảng:
class Counter {
constructor[] {
this.sum = 0;
this.count = 0;
}
add[array] {
// Only function expressions will have its own this binding
array.forEach[function countEntry[entry] {
this.sum += entry;
++this.count;
}, this];
}
}
const obj = new Counter[];
obj.add[[2, 5, 9]];
console.log[obj.count]; // 3
console.log[obj.sum]; // 16
Vì tham số
const ratings = [5, 4, 5];
let sum = 0;
const sumFunction = async [a, b] => a + b;
ratings.forEach[async [rating] => {
sum = await sumFunction[sum, rating];
}];
console.log[sum];
// Naively expected output: 14
// Actual output: 0
6 [const ratings = [5, 4, 5];
let sum = 0;
const sumFunction = async [a, b] => a + b;
ratings.forEach[async [rating] => {
sum = await sumFunction[sum, rating];
}];
console.log[sum];
// Naively expected output: 14
// Actual output: 0
7] được cung cấp cho const ratings = [5, 4, 5];
let sum = 0;
const sumFunction = async [a, b] => a + b;
ratings.forEach[async [rating] => {
sum = await sumFunction[sum, rating];
}];
console.log[sum];
// Naively expected output: 14
// Actual output: 0
0, nó được chuyển sang class Counter {
constructor[] {
this.sum = 0;
this.count = 0;
}
add[array] {
// Only function expressions will have its own this binding
array.forEach[function countEntry[entry] {
this.sum += entry;
++this.count;
}, this];
}
}
const obj = new Counter[];
obj.add[[2, 5, 9]];
console.log[obj.count]; // 3
console.log[obj.sum]; // 16
3 mỗi khi nó được gọi. Cuộc gọi lại sử dụng nó làm giá trị const ratings = [5, 4, 5];
let sum = 0;
const sumFunction = async [a, b] => a + b;
ratings.forEach[async [rating] => {
sum = await sumFunction[sum, rating];
}];
console.log[sum];
// Naively expected output: 14
// Actual output: 0
7 của nó. LƯU Ý: Nếu truyền hàm gọi lại đã sử dụng biểu thức chức năng mũi tên, tham số
6 có thể được bỏ qua, vì tất cả các hàm mũi tên liên kết một cách đơn giản giá trị const ratings = [5, 4, 5];
let sum = 0;
const sumFunction = async [a, b] => a + b;
ratings.forEach[async [rating] => {
sum = await sumFunction[sum, rating];
}];
console.log[sum];
// Naively expected output: 14
// Actual output: 0
7. If passing the callback function used an arrow function expression, the const ratings = [5, 4, 5];
let sum = 0;
const sumFunction = async [a, b] => a + b;
ratings.forEach[async [rating] => {
sum = await sumFunction[sum, rating];
}];
console.log[sum];
// Naively expected output: 14
// Actual output: 0
const ratings = [5, 4, 5];
let sum = 0;
const sumFunction = async [a, b] => a + b;
ratings.forEach[async [rating] => {
sum = await sumFunction[sum, rating];
}];
console.log[sum];
// Naively expected output: 14
// Actual output: 0
6 parameter could be omitted, since all arrow functions lexically bind the const ratings = [5, 4, 5];
let sum = 0;
const sumFunction = async [a, b] => a + b;
ratings.forEach[async [rating] => {
sum = await sumFunction[sum, rating];
}];
console.log[sum];
// Naively expected output: 14
// Actual output: 0
7 value. Một hàm sao chép đối tượng
Mã sau đây tạo ra một bản sao của một đối tượng nhất định.
Có nhiều cách khác nhau để tạo một bản sao của một đối tượng. Sau đây chỉ là một cách và được trình bày để giải thích cách
class Counter {
constructor[] {
this.sum = 0;
this.count = 0;
}
add[array] {
// Only function expressions will have its own this binding
array.forEach[function countEntry[entry] {
this.sum += entry;
++this.count;
}, this];
}
}
const obj = new Counter[];
obj.add[[2, 5, 9]];
console.log[obj.count]; // 3
console.log[obj.sum]; // 16
7 hoạt động bằng cách sử dụng các chức năng tiện ích class Counter {
constructor[] {
this.sum = 0;
this.count = 0;
}
add[array] {
// Only function expressions will have its own this binding
array.forEach[function countEntry[entry] {
this.sum += entry;
++this.count;
}, this];
}
}
const obj = new Counter[];
obj.add[[2, 5, 9]];
console.log[obj.count]; // 3
console.log[obj.sum]; // 16
8.const copy = [obj] => {
const copy = Object.create[Object.getPrototypeOf[obj]];
const propNames = Object.getOwnPropertyNames[obj];
propNames.forEach[[name] => {
const desc = Object.getOwnPropertyDescriptor[obj, name];
Object.defineProperty[copy, name, desc];
}];
return copy;
};
const obj1 = { a: 1, b: 2 };
const obj2 = copy[obj1]; // obj2 looks like obj1 now
Sửa đổi mảng trong quá trình lặp
Ví dụ sau đây nhật ký
class Counter {
constructor[] {
this.sum = 0;
this.count = 0;
}
add[array] {
// Only function expressions will have its own this binding
array.forEach[function countEntry[entry] {
this.sum += entry;
++this.count;
}, this];
}
}
const obj = new Counter[];
obj.add[[2, 5, 9]];
console.log[obj.count]; // 3
console.log[obj.sum]; // 16
9, const copy = [obj] => {
const copy = Object.create[Object.getPrototypeOf[obj]];
const propNames = Object.getOwnPropertyNames[obj];
propNames.forEach[[name] => {
const desc = Object.getOwnPropertyDescriptor[obj, name];
Object.defineProperty[copy, name, desc];
}];
return copy;
};
const obj1 = { a: 1, b: 2 };
const obj2 = copy[obj1]; // obj2 looks like obj1 now
0, const copy = [obj] => {
const copy = Object.create[Object.getPrototypeOf[obj]];
const propNames = Object.getOwnPropertyNames[obj];
propNames.forEach[[name] => {
const desc = Object.getOwnPropertyDescriptor[obj, name];
Object.defineProperty[copy, name, desc];
}];
return copy;
};
const obj1 = { a: 1, b: 2 };
const obj2 = copy[obj1]; // obj2 looks like obj1 now
1.Khi mục nhập chứa giá trị
const copy = [obj] => {
const copy = Object.create[Object.getPrototypeOf[obj]];
const propNames = Object.getOwnPropertyNames[obj];
propNames.forEach[[name] => {
const desc = Object.getOwnPropertyDescriptor[obj, name];
Object.defineProperty[copy, name, desc];
}];
return copy;
};
const obj1 = { a: 1, b: 2 };
const obj2 = copy[obj1]; // obj2 looks like obj1 now
0 đạt được, mục nhập đầu tiên của toàn bộ mảng được chuyển khỏi các kết quả trong tất cả các mục còn lại di chuyển lên một vị trí. Bởi vì phần tử const copy = [obj] => {
const copy = Object.create[Object.getPrototypeOf[obj]];
const propNames = Object.getOwnPropertyNames[obj];
propNames.forEach[[name] => {
const desc = Object.getOwnPropertyDescriptor[obj, name];
Object.defineProperty[copy, name, desc];
}];
return copy;
};
const obj1 = { a: 1, b: 2 };
const obj2 = copy[obj1]; // obj2 looks like obj1 now
1 hiện đang ở vị trí sớm hơn trong mảng, const copy = [obj] => {
const copy = Object.create[Object.getPrototypeOf[obj]];
const propNames = Object.getOwnPropertyNames[obj];
propNames.forEach[[name] => {
const desc = Object.getOwnPropertyDescriptor[obj, name];
Object.defineProperty[copy, name, desc];
}];
return copy;
};
const obj1 = { a: 1, b: 2 };
const obj2 = copy[obj1]; // obj2 looks like obj1 now
4 sẽ bị bỏ qua.const ratings = [5, 4, 5];
let sum = 0;
const sumFunction = async [a, b] => a + b;
ratings.forEach[async [rating] => {
sum = await sumFunction[sum, rating];
}];
console.log[sum];
// Naively expected output: 14
// Actual output: 0
0 không tạo một bản sao của mảng trước khi lặp lại.const words = ['one', 'two', 'three', 'four'];
words.forEach[[word] => {
console.log[word];
if [word === 'two'] {
words.shift[]; //'one' will delete from array
}
}]; // one // two // four
console.log[words]; // ['two', 'three', 'four']
Làm phẳng một mảng
Ví dụ sau đây chỉ ở đây cho mục đích học tập. Nếu bạn muốn làm phẳng một mảng bằng các phương thức tích hợp, bạn có thể sử dụng
const copy = [obj] => {
const copy = Object.create[Object.getPrototypeOf[obj]];
const propNames = Object.getOwnPropertyNames[obj];
propNames.forEach[[name] => {
const desc = Object.getOwnPropertyDescriptor[obj, name];
Object.defineProperty[copy, name, desc];
}];
return copy;
};
const obj1 = { a: 1, b: 2 };
const obj2 = copy[obj1]; // obj2 looks like obj1 now
6.const flatten = [arr] => {
const result = [];
arr.forEach[[item] => {
if [Array.isArray[item]] {
result.push[...flatten[item]];
} else {
result.push[item];
}
}];
return result;
}
// Usage
const nested = [1, 2, 3, [4, 5, [6, 7], 8, 9]];
console.log[flatten[nested]]; // [1, 2, 3, 4, 5, 6, 7, 8, 9]
Gọi foreach [] trên các đối tượng không phải là
Phương thức
const ratings = [5, 4, 5];
let sum = 0;
const sumFunction = async [a, b] => a + b;
ratings.forEach[async [rating] => {
sum = await sumFunction[sum, rating];
}];
console.log[sum];
// Naively expected output: 14
// Actual output: 0
0 đọc thuộc tính const items = ['item1', 'item2', 'item3'];
const copyItems = [];
// before
for [let i = 0; i {
copyItems.push[item];
}];
6 của const ratings = [5, 4, 5];
let sum = 0;
const sumFunction = async [a, b] => a + b;
ratings.forEach[async [rating] => {
sum = await sumFunction[sum, rating];
}];
console.log[sum];
// Naively expected output: 14
// Actual output: 0
7 và sau đó truy cập vào từng chỉ mục số nguyên.const arrayLike = {
length: 3,
0: 2,
1: 3,
2: 4,
};
Array.prototype.forEach.call[arrayLike, [x] => console.log[x]];
// 2
// 3
// 4
Thông số kỹ thuật
Thông số kỹ thuật ngôn ngữ Ecmascript # sec-array.prototype.foreach # sec-array.prototype.foreach |
Tính tương thích của trình duyệt web
Bảng BCD chỉ tải trong trình duyệt