Hướng dẫn for in loop array javascript - cho trong mảng vòng lặp javascript

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 đối tượng có thể lặp lại. Các đối tượng có thể lặp lại bao gồm các trường hợp tích hợp như

const iterable = [10, 20, 30];

for [let value of iterable] {
  value += 1;
  console.log[value];
}
// 11
// 21
// 31

const iterable = [10, 20, 30];

for [let value of iterable] {
  value += 1;
  console.log[value];
}
// 11
// 21
// 31

let async;
for [async of [1, 2, 3]]; // SyntaxError: The left-hand side of a for-of loop may not be 'async'.

let async;
for [async of [1, 2, 3]]; // SyntaxError: The left-hand side of a for-of loop may not be 'async'.

let async;
for [async of [1, 2, 3]]; // SyntaxError: The left-hand side of a for-of loop may not be 'async'.

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, các trình tạo được tạo ra bởi các chức năng của trình tạo và lặp đi lặp lại của người dùng.
const iterable = [10, 20, 30]; for [let value of iterable] { value += 1; console.log[value]; } // 11 // 21 // 31
7 statement executes a loop that operates on a sequence of values sourced from an iterable object. Iterable objects include instances of built-ins such as

const iterable = [10, 20, 30];

for [let value of iterable] {
  value += 1;
  console.log[value];
}
// 11
// 21
// 31

const iterable = [10, 20, 30];

for [let value of iterable] {
  value += 1;
  console.log[value];
}
// 11
// 21
// 31

let async;
for [async of [1, 2, 3]]; // SyntaxError: The left-hand side of a for-of loop may not be 'async'.

let async;
for [async of [1, 2, 3]]; // SyntaxError: The left-hand side of a for-of loop may not be 'async'.

let async;
for [async of [1, 2, 3]]; // SyntaxError: The left-hand side of a for-of loop may not be 'async'.

let async;
for [async of [1, 2, 3]]; // SyntaxError: The left-hand side of a for-of loop may not be 'async'.

3 [and other DOM collections], as well as the

let async;
for [async of [1, 2, 3]]; // SyntaxError: The left-hand side of a for-of loop may not be 'async'.

4 object, generators produced by generator functions, and user-defined iterables.

Thử nó

Cú pháp

for [variable of iterable]
  statement

let async;
for [async of [1, 2, 3]]; // SyntaxError: The left-hand side of a for-of loop may not be 'async'.

Nhận được 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'.

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ục tiêu gán [ví dụ: biến được khai báo trước đó hoặc 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'.

Một đối tượng có thể đi được. Nguồn của chuỗi các 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

Một tuyên bố sẽ được thực thi trên mỗi lần lặp. Có thể tham chiếu

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 câu lệnh BLOCK để thực thi nhiều câu lệnh.

Sự mô tả

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 hoạt động trên các giá trị có nguồn gốc từ một thứ khác nhau 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 cho là lặp đi lặp lại. Mỗi lần lặp thực thi các câu lệnh có thể đề cập đến giá trị chuỗi hiện tại.

Khi 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 điều khác, nó gọi là phương thức ____34 của ITEBELBER, trả về một trình lặp, và sau đó gọi liên tục gọi phương thức

const iterable = [10, 20, 30];

for [const value of iterable] {
  console.log[value];
}
// 10
// 20
// 30

5 của iterator để tạo ra chuỗi các 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'.

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 thoát ra khi trình 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 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 báo cáo 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 ra khỏi vòng lặp và đi đến câu lệnh đầu tiên sau thân vòng, 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ến hành lần lặp tiếp theo.

Nế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 ra sớm [ví dụ: câu lệnh

const iterable = "boo";

for [const value of iterable] {
  console.log[value];
}
// "b"
// "o"
// "o"

0 gặp phải hoặc lỗi bị loại bỏ], phương thức

const iterable = "boo";

for [const value of iterable] {
  console.log[value];
}
// "b"
// "o"
// "o"

4 của iterator được gọi để thực hiện bất kỳ việc dọn dẹp nào.

Phầ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 bất cứ điều gì 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 chỉ định lại trong thân vòng lặp [nó có thể thay đổi giữa các lần lặp, bởi 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'.

const iterable = [10, 20, 30];

for [let value of iterable] {
  value += 1;
  console.log[value];
}
// 11
// 21
// 31

Lưu ý: Mỗi lần lặp tạo ra một biến mới. Việc chỉ định lại biến bên trong cơ thể vòng lặp không ảnh hưởng đến giá trị ban đầu trong ITEBLE [một mảng, trong trường hợp này]. Each iteration creates a new variable. Reassigning the variable inside the loop body does not affect the original value in the iterable [an array, in this case].

Bạn cũng có thể sử dụng phá 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

Tuy 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ồ của 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

Ví dụ

Lặp lại trên một mảng

const iterable = [10, 20, 30];

for [const value of iterable] {
  console.log[value];
}
// 10
// 20
// 30

Lặp lại trên một chuỗi

Chuỗi được lặp lại bởi các điểm mã Unicode.

const iterable = "boo";

for [const value of iterable] {
  console.log[value];
}
// "b"
// "o"
// "o"

Lặp lại trên một kiểu đánh máy

const iterable = new Uint8Array[[0x00, 0xff]];

for [const value of iterable] {
  console.log[value];
}
// 0
// 255

Lặp lại trên một bản đồ

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

Lặp lại trên một bộ

const iterable = new Set[[1, 1, 2, 2, 3, 3]];

for [const value of iterable] {
  console.log[value];
}
// 1
// 2
// 3

Lặp lại đối tượng đối số

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àm.

function foo[] {
  for [const value of arguments] {
    console.log[value];
  }
}

foo[1, 2, 3];
// 1
// 2
// 3

Lặp lại trên một cái gật đầu

Ví dụ sau đây 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 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 lại trong bộ sưu tập

let async;
for [async of [1, 2, 3]]; // SyntaxError: The left-hand side of a for-of loop may not be 'async'.

3 DOM.

const articleParagraphs = document.querySelectorAll["article > p"];
for [const paragraph of articleParagraphs] {
  paragraph.classList.add["read"];
}

Lặp đi lặp lại có thể xác định được do người dùng xác định

Lặp lại một đối tượng với phương thức

const iterable = new Uint8Array[[0x00, 0xff]];

for [const value of iterable] {
  console.log[value];
}
// 0
// 255

8 trả về trình lặp tùy chỉnh:

const iterable = [10, 20, 30];

for [let value of iterable] {
  value += 1;
  console.log[value];
}
// 11
// 21
// 31

Lặp lại một đối tượng với phương thức máy phát

const iterable = new Uint8Array[[0x00, 0xff]];

for [const value of iterable] {
  console.log[value];
}
// 0
// 255

const iterable = [10, 20, 30];

for [let value of iterable] {
  value += 1;
  console.log[value];
}
// 11
// 21
// 31

Có thể lặp lại được [trình lặp với phương pháp

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 các trình lặp có thể sử dụng được trong các cú pháp mong đợi các phép lặp, chẳng hạn như

const iterable = [10, 20, 30];

for [let value of iterable] {
  value += 1;
  console.log[value];
}
// 11
// 21
// 31

const iterable = [10, 20, 30];

for [let value of iterable] {
  value += 1;
  console.log[value];
}
// 11
// 21
// 31

Lặp lại một máy phát điện

const iterable = [10, 20, 30];

for [let value of iterable] {
  value += 1;
  console.log[value];
}
// 11
// 21
// 31

Thoát ra sớm

Việc thực hiện 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 ra sớm. Trình lặp vẫn chưa hoàn thành, vì vậy vòng lặp thứ hai sẽ tiếp tục từ nơi cái đầ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

Máy phát thực hiện phương thức

const iterable = "boo";

for [const value of iterable] {
  console.log[value];
}
// "b"
// "o"
// "o"

4, khiến hàm máy phát quay lại sớm khi vòng lặp thoát. Điều này làm cho máy phát điện không thể tái sử dụng giữa các vòng lặp.

const iterable = [10, 20, 30];

for [let value of iterable] {
  value += 1;
  console.log[value];
}
// 11
// 21
// 31

Sự khác biệt giữa ... của ... và cho ... trong

Cả hai câu

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 lặp lại một cái gì đó. Sự khác biệt chính giữa họ là trong những gì họ lặp lại.

Tuyên bố

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 lại các thuộc tính chuỗi có thể suy định 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à đối tượng có thể lặp lại được lặp lại.

Ví 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

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

const iterable = [10, 20, 30];

for [let value of iterable] {
  value += 1;
  console.log[value];
}
// 11
// 21
// 31

const iterable = [10, 20, 30];

for [let value of iterable] {
  value += 1;
  console.log[value];
}
// 11
// 21
// 31

Đố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 các thuộc tính có thể suy giảm 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 thành phần mảng

const iterable = new Set[[1, 1, 2, 2, 3, 3]];

for [const value of iterable] {
  console.log[value];
}
// 1
// 2
// 3

function foo[] {
  for [const value of arguments] {
    console.log[value];
  }
}

foo[1, 2, 3];
// 1
// 2
// 3

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ì đó không phải là thuộc tính - chúng là giá trị. Nó ghi nhật ký 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 lại, có một lời giải thích kỹ lưỡng hơn về cách lặp lại mảng và công việc

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

Vòng lặp thứ hai tương tự như thế giới đầu tiên, 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 có thể tìm thấy có phải là của riêng đối tượng hay không, tức là không được kế thừa. Nếu có, tài sản được ghi lại. Các thuộc tính

function foo[] {
  for [const value of arguments] {
    console.log[value];
  }
}

foo[1, 2, 3];
// 1
// 2
// 3

function foo[] {
  for [const value of arguments] {
    console.log[value];
  }
}

foo[1, 2, 3];
// 1
// 2
// 3

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à tài sản 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 thừa hưởng.

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 và ghi nhật ký các giá trị

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], được định nghĩa là được 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

function foo[] {
  for [const value of arguments] {
    console.log[value];
  }
}

foo[1, 2, 3];
// 1
// 2
// 3

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.

Thông số kỹ thuật

Sự chỉ rõ

Đặc tả ngôn ngữ Ecmascript # Sec-for-in-and-for-for-statements
# sec-for-in-and-for-of-statements

Tính tương thích của trình duyệt web

Bảng BCD chỉ tải trong trình duyệt

Xem thêm

Chúng ta có thể sử dụng cho trong vòng lặp cho mảng không?

Một vòng lặp cho vòng lặp có thể được sử dụng để truy cập vào mọi phần tử của một mảng.Mảng bắt đầu ở mức 0 và độ dài thuộc tính mảng được sử dụng để đặt đầu vòng lặp.. The array begins at zero, and the array property length is used to set the loop end.

Tại sao cho vòng lặp được sử dụng trong mảng?

A For Loop kiểm tra và lặp lại trên mọi phần tử mà mảng chứa một cách nhanh chóng, hiệu quả và có thể kiểm soát được hơn.Điều này hiệu quả hơn nhiều so với in từng giá trị riêng lẻ: bảng điều khiển.examines and iterates over every element the array contains in a fast, effective, and more controllable way. This is much more effective than printing each value individually: console.

Làm thế nào cho trong các hoạt động vòng lặp trong JavaScript?

A cho vòng lặp lặp lại cho đến khi một điều kiện được chỉ định đánh giá là sai.JavaScript cho vòng lặp tương tự như Java và C cho vòng lặp.Khi A For Loop thực thi, điều sau đây xảy ra: Biểu thức khởi tạo khởi động, nếu có, được thực thi.repeats until a specified condition evaluates to false. The JavaScript for loop is similar to the Java and C for loop. When a for loop executes, the following occurs: The initializing expression initialExpression , if any, is executed.

Sự khác biệt giữa forin và trong JavaScript là gì?

Sự khác biệt giữa cho ... của và cho ... trong câu lệnh cho ... trong câu lệnh lặp đi lặp lại các thuộc tính chuỗi có thể suy nghĩ của một đối tượng, trong khi câu lệnh cho ....The for...in statement iterates over the enumerable string properties of an object, while the for...of statement iterates over values that the iterable object defines to be iterated over.