Câu lệnh
const iterable = [10, 20, 30];
for [let value of iterable] {
value += 1;
console.log[value];
}
// 11
// 21
// 31
7 thực hiện một vòng lặp hoạt động trên một chuỗi các giá trị có nguồn gốc từ một. Các đối tượng có thể lặp lại bao gồm các phiên bản tích hợp sẵn như const iterable = [10, 20, 30];
for [let value of iterable] {
value += 1;
console.log[value];
}
// 11
// 21
// 31
8, const iterable = [10, 20, 30];
for [let value of iterable] {
value += 1;
console.log[value];
}
// 11
// 21
// 31
9, let async;
for [async of [1, 2, 3]]; // SyntaxError: The left-hand side of a for-of loop may not be 'async'.
0, let async;
for [async of [1, 2, 3]]; // SyntaxError: The left-hand side of a for-of loop may not be 'async'.
1, let async;
for [async of [1, 2, 3]]; // SyntaxError: The left-hand side of a for-of loop may not be 'async'.
2, let async;
for [async of [1, 2, 3]]; // SyntaxError: The left-hand side of a for-of loop may not be 'async'.
3 [và các bộ sưu tập DOM khác], cũng như đối tượng let async;
for [async of [1, 2, 3]]; // SyntaxError: The left-hand side of a for-of loop may not be 'async'.
4, trình tạo được tạo bởi các hàm trình tạo và các trình lặp do người dùng định nghĩa________số 8_______
let async;
for [async of [1, 2, 3]]; // SyntaxError: The left-hand side of a for-of loop may not be 'async'.
5Nhận một giá trị từ chuỗi trên mỗi lần lặp. Có thể là một tuyên bố với
let async;
for [async of [1, 2, 3]]; // SyntaxError: The left-hand side of a for-of loop may not be 'async'.
6, let async;
for [async of [1, 2, 3]]; // SyntaxError: The left-hand side of a for-of loop may not be 'async'.
7, hoặc let async;
for [async of [1, 2, 3]]; // SyntaxError: The left-hand side of a for-of loop may not be 'async'.
8, hoặc một mục tiêu chuyển nhượng [e. g. một biến được khai báo trước đó hoặc một thuộc tính đối tượng]let async;
for [async of [1, 2, 3]]; // SyntaxError: The left-hand side of a for-of loop may not be 'async'.
9Một đối tượng có thể lặp lại. Nguồn của chuỗi giá trị mà vòng lặp hoạt động
const iterable = [10, 20, 30];
for [const value of iterable] {
console.log[value];
}
// 10
// 20
// 30
0Một câu lệnh sẽ được thực hiện trên mỗi lần lặp. Có thể tham khảo
let async;
for [async of [1, 2, 3]]; // SyntaxError: The left-hand side of a for-of loop may not be 'async'.
5. Bạn có thể sử dụng một câu lệnh khối để thực thi nhiều câu lệnhMột vòng lặp
const iterable = [10, 20, 30];
for [let value of iterable] {
value += 1;
console.log[value];
}
// 11
// 21
// 31
7 hoạt động trên các giá trị có nguồn gốc từ một lần lặp từng cái một theo thứ tự tuần tự. Mỗi hoạt động của vòng lặp trên một giá trị được gọi là một lần lặp và vòng lặp được gọi là lặp qua lần lặp. Mỗi lần lặp thực hiện các câu lệnh có thể tham chiếu đến giá trị chuỗi hiện tạiKhi một vòng lặp
const iterable = [10, 20, 30];
for [let value of iterable] {
value += 1;
console.log[value];
}
// 11
// 21
// 31
7 lặp lại trên một vòng lặp có thể lặp lại, trước tiên, nó gọi phương thức const iterable = [10, 20, 30];
for [const value of iterable] {
console.log[value];
}
// 10
// 20
// 30
4 của vòng lặp đó, phương thức này trả về một , sau đó liên tục gọi phương thức của trình vòng lặp kết quả để tạo chuỗi giá trị được gán cho let async;
for [async of [1, 2, 3]]; // SyntaxError: The left-hand side of a for-of loop may not be 'async'.
5Một vòng lặp
const iterable = [10, 20, 30];
for [let value of iterable] {
value += 1;
console.log[value];
}
// 11
// 21
// 31
7 thoát khi trình vòng lặp hoàn thành [phương thức const iterable = [10, 20, 30];
for [const value of iterable] {
console.log[value];
}
// 10
// 20
// 30
5 của trình vòng lặp trả về một đối tượng chứa const iterable = [10, 20, 30];
for [const value of iterable] {
console.log[value];
}
// 10
// 20
// 30
9]. Bạn cũng có thể sử dụng các câu lệnh luồng điều khiển để thay đổi luồng điều khiển thông thường. const iterable = "boo";
for [const value of iterable] {
console.log[value];
}
// "b"
// "o"
// "o"
0 thoát khỏi vòng lặp và chuyển đến câu lệnh đầu tiên sau phần thân vòng lặp, trong khi const iterable = "boo";
for [const value of iterable] {
console.log[value];
}
// "b"
// "o"
// "o"
1 bỏ qua phần còn lại của các câu lệnh của lần lặp hiện tại và tiếp tục với lần lặp tiếp theoNếu vòng lặp
const iterable = [10, 20, 30];
for [let value of iterable] {
value += 1;
console.log[value];
}
// 11
// 21
// 31
7 thoát sớm [e. g. một câu lệnh const iterable = "boo";
for [const value of iterable] {
console.log[value];
}
// "b"
// "o"
// "o"
0 hoặc một lỗi được đưa ra], phương thức của trình vòng lặp được gọi để thực hiện bất kỳ thao tác dọn dẹp nàoPhần
let async;
for [async of [1, 2, 3]]; // SyntaxError: The left-hand side of a for-of loop may not be 'async'.
5 của const iterable = [10, 20, 30];
for [let value of iterable] {
value += 1;
console.log[value];
}
// 11
// 21
// 31
7 chấp nhận mọi thứ có thể đến trước toán tử const iterable = "boo";
for [const value of iterable] {
console.log[value];
}
// "b"
// "o"
// "o"
7. Bạn có thể sử dụng let async;
for [async of [1, 2, 3]]; // SyntaxError: The left-hand side of a for-of loop may not be 'async'.
6 để khai báo biến miễn là nó không được gán lại trong thân vòng lặp [nó có thể thay đổi giữa các lần lặp, vì đó là hai biến riêng biệt]. Nếu không, bạn có thể sử dụng let async;
for [async of [1, 2, 3]]; // SyntaxError: The left-hand side of a for-of loop may not be 'async'.
7const iterable = [10, 20, 30];
for [let value of iterable] {
value += 1;
console.log[value];
}
// 11
// 21
// 31
Ghi chú. Mỗi lần lặp tạo ra một biến mới. Việc gán lại biến bên trong thân vòng lặp không ảnh hưởng đến giá trị ban đầu trong lần lặp [trong trường hợp này là một mảng]
Bạn cũng có thể sử dụng hàm hủy hoặc thuộc tính đối tượng như
const iterable = new Uint8Array[[0x00, 0xff]];
for [const value of iterable] {
console.log[value];
}
// 0
// 255
0Tuy nhiên, một quy tắc đặc biệt cấm sử dụng
const iterable = new Uint8Array[[0x00, 0xff]];
for [const value of iterable] {
console.log[value];
}
// 0
// 255
1 làm tên biến. Đây là cú pháp không hợp lệlet async;
for [async of [1, 2, 3]]; // SyntaxError: The left-hand side of a for-of loop may not be 'async'.
Điều này là để tránh sự mơ hồ về cú pháp với mã hợp lệ
const iterable = new Uint8Array[[0x00, 0xff]];
for [const value of iterable] {
console.log[value];
}
// 0
// 255
2, là vòng lặp const iterable = new Uint8Array[[0x00, 0xff]];
for [const value of iterable] {
console.log[value];
}
// 0
// 255
3const iterable = [10, 20, 30];
for [const value of iterable] {
console.log[value];
}
// 10
// 20
// 30
Các chuỗi được lặp lại bằng các điểm mã Unicode
const iterable = "boo";
for [const value of iterable] {
console.log[value];
}
// "b"
// "o"
// "o"
const iterable = new Uint8Array[[0x00, 0xff]];
for [const value of iterable] {
console.log[value];
}
// 0
// 255
const iterable = new Map[[
["a", 1],
["b", 2],
["c", 3],
]];
for [const entry of iterable] {
console.log[entry];
}
// ['a', 1]
// ['b', 2]
// ['c', 3]
for [const [key, value] of iterable] {
console.log[value];
}
// 1
// 2
// 3
const iterable = new Set[[1, 1, 2, 2, 3, 3]];
for [const value of iterable] {
console.log[value];
}
// 1
// 2
// 3
Bạn có thể lặp lại đối tượng
let async;
for [async of [1, 2, 3]]; // SyntaxError: The left-hand side of a for-of loop may not be 'async'.
4 để kiểm tra tất cả các tham số được truyền vào một hàmfunction foo[] {
for [const value of arguments] {
console.log[value];
}
}
foo[1, 2, 3];
// 1
// 2
// 3
Ví dụ sau thêm một lớp
const iterable = new Uint8Array[[0x00, 0xff]];
for [const value of iterable] {
console.log[value];
}
// 0
// 255
5 vào các đoạn văn là hậu duệ trực tiếp của phần tử const iterable = new Uint8Array[[0x00, 0xff]];
for [const value of iterable] {
console.log[value];
}
// 0
// 255
6 bằng cách lặp qua bộ sưu tập DOM let async;
for [async of [1, 2, 3]]; // SyntaxError: The left-hand side of a for-of loop may not be 'async'.
3const articleParagraphs = document.querySelectorAll["article > p"];
for [const paragraph of articleParagraphs] {
paragraph.classList.add["read"];
}
Lặp lại một đối tượng bằng phương thức
const iterable = new Uint8Array[[0x00, 0xff]];
for [const value of iterable] {
console.log[value];
}
// 0
// 255
8 trả về một trình vòng lặp tùy chỉnhconst iterable = [10, 20, 30];
for [let value of iterable] {
value += 1;
console.log[value];
}
// 11
// 21
// 31
0Lặp lại một đối tượng bằng phương thức trình tạo
const iterable = new Uint8Array[[0x00, 0xff]];
for [const value of iterable] {
console.log[value];
}
// 0
// 255
8const iterable = [10, 20, 30];
for [let value of iterable] {
value += 1;
console.log[value];
}
// 11
// 21
// 31
1Trình vòng lặp có thể lặp lại [bộ lặp có phương thức
const iterable = [10, 20, 30];
for [const value of iterable] {
console.log[value];
}
// 10
// 20
// 30
4 trả về const iterable = new Map[[
["a", 1],
["b", 2],
["c", 3],
]];
for [const entry of iterable] {
console.log[entry];
}
// ['a', 1]
// ['b', 2]
// ['c', 3]
for [const [key, value] of iterable] {
console.log[value];
}
// 1
// 2
// 3
1] là một kỹ thuật khá phổ biến để làm cho trình vòng lặp có thể sử dụng được trong các cú pháp mong đợi có thể lặp lại, chẳng hạn như const iterable = [10, 20, 30];
for [let value of iterable] {
value += 1;
console.log[value];
}
// 11
// 21
// 31
7const iterable = [10, 20, 30];
for [let value of iterable] {
value += 1;
console.log[value];
}
// 11
// 21
// 31
2const iterable = [10, 20, 30];
for [let value of iterable] {
value += 1;
console.log[value];
}
// 11
// 21
// 31
3Việc thực thi câu lệnh
const iterable = "boo";
for [const value of iterable] {
console.log[value];
}
// "b"
// "o"
// "o"
0 trong vòng lặp đầu tiên khiến nó thoát sớm. Vòng lặp vẫn chưa kết thúc, vì vậy vòng lặp thứ hai sẽ tiếp tục từ nơi vòng lặp đầu tiên dừng lại ởconst iterable = [10, 20, 30];
for [let value of iterable] {
value += 1;
console.log[value];
}
// 11
// 21
// 31
4Trình tạo triển khai phương thức
const iterable = "boo";
for [const value of iterable] {
console.log[value];
}
// "b"
// "o"
// "o"
4, khiến hàm trình tạo quay trở lại sớm khi thoát khỏi vòng lặp. Điều này làm cho các trình tạo không thể tái sử dụng giữa các vòng lặpconst iterable = [10, 20, 30];
for [let value of iterable] {
value += 1;
console.log[value];
}
// 11
// 21
// 31
5Cả hai câu lệnh
const iterable = new Map[[
["a", 1],
["b", 2],
["c", 3],
]];
for [const entry of iterable] {
console.log[entry];
}
// ['a', 1]
// ['b', 2]
// ['c', 3]
for [const [key, value] of iterable] {
console.log[value];
}
// 1
// 2
// 3
5 và const iterable = [10, 20, 30];
for [let value of iterable] {
value += 1;
console.log[value];
}
// 11
// 21
// 31
7 đều lặp lại một điều gì đó. Sự khác biệt chính giữa chúng là ở những gì chúng lặp đi lặp lạiCâu lệnh
const iterable = new Map[[
["a", 1],
["b", 2],
["c", 3],
]];
for [const entry of iterable] {
console.log[entry];
}
// ['a', 1]
// ['b', 2]
// ['c', 3]
for [const [key, value] of iterable] {
console.log[value];
}
// 1
// 2
// 3
5 lặp qua vô số thuộc tính chuỗi của một đối tượng, trong khi câu lệnh const iterable = [10, 20, 30];
for [let value of iterable] {
value += 1;
console.log[value];
}
// 11
// 21
// 31
7 lặp lại các giá trị mà định nghĩa sẽ được lặp lạiVí dụ sau đây cho thấy sự khác biệt giữa vòng lặp
const iterable = [10, 20, 30];
for [let value of iterable] {
value += 1;
console.log[value];
}
// 11
// 21
// 31
7 và vòng lặp const iterable = new Map[[
["a", 1],
["b", 2],
["c", 3],
]];
for [const entry of iterable] {
console.log[entry];
}
// ['a', 1]
// ['b', 2]
// ['c', 3]
for [const [key, value] of iterable] {
console.log[value];
}
// 1
// 2
// 3
5 khi được sử dụng với vòng lặp const iterable = [10, 20, 30];
for [let value of iterable] {
value += 1;
console.log[value];
}
// 11
// 21
// 31
8const iterable = [10, 20, 30];
for [let value of iterable] {
value += 1;
console.log[value];
}
// 11
// 21
// 31
6Đối tượng
let async;
for [async of [1, 2, 3]]; // SyntaxError: The left-hand side of a for-of loop may not be 'async'.
9 kế thừa các thuộc tính const iterable = new Set[[1, 1, 2, 2, 3, 3]];
for [const value of iterable] {
console.log[value];
}
// 1
// 2
// 3
3 và const iterable = new Set[[1, 1, 2, 2, 3, 3]];
for [const value of iterable] {
console.log[value];
}
// 1
// 2
// 3
4 vì nó chứa cả const iterable = new Set[[1, 1, 2, 2, 3, 3]];
for [const value of iterable] {
console.log[value];
}
// 1
// 2
// 3
5 và const iterable = new Set[[1, 1, 2, 2, 3, 3]];
for [const value of iterable] {
console.log[value];
}
// 1
// 2
// 3
6 trong chuỗi nguyên mẫu của nóVòng lặp
const iterable = new Map[[
["a", 1],
["b", 2],
["c", 3],
]];
for [const entry of iterable] {
console.log[entry];
}
// ['a', 1]
// ['b', 2]
// ['c', 3]
for [const [key, value] of iterable] {
console.log[value];
}
// 1
// 2
// 3
5 chỉ ghi lại vô số thuộc tính của đối tượng let async;
for [async of [1, 2, 3]]; // SyntaxError: The left-hand side of a for-of loop may not be 'async'.
9. Nó không ghi nhật ký các phần tử mảng const iterable = new Set[[1, 1, 2, 2, 3, 3]];
for [const value of iterable] {
console.log[value];
}
// 1
// 2
// 3
9, function foo[] {
for [const value of arguments] {
console.log[value];
}
}
foo[1, 2, 3];
// 1
// 2
// 3
0, function foo[] {
for [const value of arguments] {
console.log[value];
}
}
foo[1, 2, 3];
// 1
// 2
// 3
1 hoặc function foo[] {
for [const value of arguments] {
console.log[value];
}
}
foo[1, 2, 3];
// 1
// 2
// 3
2 vì chúng không phải là thuộc tính — chúng là giá trị. Nó ghi lại các chỉ mục mảng cũng như const iterable = new Set[[1, 1, 2, 2, 3, 3]];
for [const value of iterable] {
console.log[value];
}
// 1
// 2
// 3
4 và const iterable = new Set[[1, 1, 2, 2, 3, 3]];
for [const value of iterable] {
console.log[value];
}
// 1
// 2
// 3
3, là các thuộc tính thực tế. Nếu bạn không chắc tại sao các thuộc tính này được lặp đi lặp lại, thì sẽ có phần giải thích kỹ lưỡng hơn về cách thức hoạt độngVòng lặp thứ hai tương tự như vòng lặp thứ nhất, nhưng nó sử dụng
function foo[] {
for [const value of arguments] {
console.log[value];
}
}
foo[1, 2, 3];
// 1
// 2
// 3
6 để kiểm tra xem thuộc tính liệt kê được tìm thấy có thuộc sở hữu của đối tượng hay không, i. e. không được thừa kế. Nếu có, thuộc tính được ghi lại. Thuộc tính function foo[] {
for [const value of arguments] {
console.log[value];
}
}
foo[1, 2, 3];
// 1
// 2
// 3
7, function foo[] {
for [const value of arguments] {
console.log[value];
}
}
foo[1, 2, 3];
// 1
// 2
// 3
8, function foo[] {
for [const value of arguments] {
console.log[value];
}
}
foo[1, 2, 3];
// 1
// 2
// 3
9 và const articleParagraphs = document.querySelectorAll["article > p"];
for [const paragraph of articleParagraphs] {
paragraph.classList.add["read"];
}
0 được ghi lại vì chúng là thuộc tính riêng. Các thuộc tính const iterable = new Set[[1, 1, 2, 2, 3, 3]];
for [const value of iterable] {
console.log[value];
}
// 1
// 2
// 3
4 và const iterable = new Set[[1, 1, 2, 2, 3, 3]];
for [const value of iterable] {
console.log[value];
}
// 1
// 2
// 3
3 không được ghi lại vì chúng được kế thừaVòng lặp
const iterable = [10, 20, 30];
for [let value of iterable] {
value += 1;
console.log[value];
}
// 11
// 21
// 31
7 lặp lại và ghi nhật ký các giá trị mà let async;
for [async of [1, 2, 3]]; // SyntaxError: The left-hand side of a for-of loop may not be 'async'.
9, dưới dạng một mảng [có thể lặp lại], xác định sẽ được lặp đi lặp lại. Các phần tử của đối tượng const iterable = new Set[[1, 1, 2, 2, 3, 3]];
for [const value of iterable] {
console.log[value];
}
// 1
// 2
// 3
9, function foo[] {
for [const value of arguments] {
console.log[value];
}
}
foo[1, 2, 3];
// 1
// 2
// 3
0, function foo[] {
for [const value of arguments] {
console.log[value];
}
}
foo[1, 2, 3];
// 1
// 2
// 3
1 được hiển thị, nhưng không có thuộc tính nào của đối tượng được hiển thị