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
1Chức năng để thực thi trên mỗi phần tử.
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
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
2 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
5Mả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
7 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
8 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.Giá trị trả về
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 }
0.Sự mô 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 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ử trong một mảng theo thứ tự chỉ mục tăng dầ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 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
1 được gọi với ba đối số:- giá trị của phần tử
- chỉ mục của phần tử
- đối tượng mảng đang đi qua
Nếu 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
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ó sẽ được sử dụng 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
8 của Callback. 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 cuối cùng có thể quan sát được bở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 được xác định theo các quy tắc thông thường để xác đị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
8 được nhìn thấy bởi một hàm.Phạm vi của các phần tử được xử lý bở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
0 được đặt 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. Các yếu tố được gán cho các chỉ mục đã được truy cập hoặc các chỉ mục bên ngoài phạm vi, sẽ không được truy cập bở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. Nếu các phần tử hiện tại của mảng bị thay đổi hoặc xóa, giá trị của chúng được chuyển đế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 sẽ là giá trị tại thời điể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 truy cập chúng; Các yếu tố bị xóa trước khi được truy cập không được truy cập. Nếu các phần tử đã được truy cập được xóa [ví dụ: sử dụng const items = ['item1', 'item2', 'item3'];
const copyItems = [];
// before
for [let i = 0; i {
copyItems.push[item];
}];
6] trong quá trình lặp, các phần tử sau sẽ bị bỏ qua. [Xem ví dụ này, bên dưới.]CẢNH BÁO: Sửa đổi đồng thời loại được mô tả trong đoạn trước thường xuyên dẫn đến mã khó hiểu và thường phải tránh [ngoại trừ trong các trường hợp đặc biệt]. Concurrent modification of the kind described in the previous paragraph frequently leads to hard-to-understand code and is generally to be avoided [except in special cases].
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 thực thi 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 một lần cho mỗi phần tử mảng; Không giống như const items = ['item1', 'item2', 'item3'];
const copyItems = [];
// before
for [let i = 0; i {
copyItems.push[item];
}];
9 hoặc 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, nó luôn trả về giá trị 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 }
0 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
0 không làm biến đổi mảng mà nó được gọi là. [Tuy nhiê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 có thể làm như vậy]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
8 có thuộc tí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
6 và các thuộc tính được khóa.Lưu ý:
7 mong đợi một hàm đồng bộ. 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
7 expects a synchronous function.
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 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
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
0, 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 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
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
0,
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
7 [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
8] đượ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
5 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
8 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ố
7 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
8. 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
7 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
8 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
9 hoạt động bằng cách sử dụng các chức năng tiện ích 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
Sửa đổi mảng trong quá trình lặp
Ví dụ sau đây nhật ký
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, 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
2, 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
3.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
2 đạ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
3 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
6 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
8.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 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
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
8 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