Phương thức
1 trả về một đối tượng lặp mảng mới chứa các phím cho mỗi chỉ mục trong mảng.const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
1 method returns a new Array Iterator object that contains the keys for each index in the array.const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
Thử nó
Cú pháp
Giá trị trả về
Một đối tượng ingerator
const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
2 mới.Sự mô tả
Khi được sử dụng trên các mảng thưa thớt, phương pháp
const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
1 lặp lại các khe trống như thể chúng có giá trị const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
4.Phương pháp
const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
1 là chung chung. Nó chỉ mong đợi giá trị const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
6 sẽ có thuộc tính const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
7 và các thuộc tính được khóa.
Ví dụ
Sử dụng các khóa [] trên các mảng thưa thớt
Không giống như
const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
8, chỉ bao gồm các khóa thực sự tồn tại trong mảng, trình lặp const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
1 không bỏ qua các lỗ đại diện cho các thuộc tính bị thiếu.const arr = ['a', , 'c'];
const sparseKeys = Object.keys[arr];
const denseKeys = [...arr.keys[]];
console.log[sparseKeys]; // ['0', '2']
console.log[denseKeys]; // [0, 1, 2]
Gọi các khóa [] trên các đối tượng không phải là
Phương pháp
const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
1 đọc thuộc tính const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
7 của const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
6 và sau đó mang lại tất cả các chỉ số số nguyên trong khoảng từ 0 đến fruits[5] = 'mango';
console.log[fruits[5]]; // 'mango'
console.log[Object.keys[fruits]]; // ['0', '1', '2', '5']
console.log[fruits.length]; // 6
3. Không có quyền truy cập chỉ mục thực sự xảy ra.const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
Thông số kỹ thuật
Thông số kỹ thuật ngôn ngữ Ecmascript # sec-array.prototype.keys # sec-array.prototype.keys |
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
Trong JavaScript, các mảng không phải là nguyên thủy mà thay vào đó là các đối tượng Sự mô tả
2 với các đặc điểm cốt lõi sau:const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
- Các mảng JavaScript có thể thay thế được và có thể chứa hỗn hợp các loại dữ liệu khác nhau. [Khi các đặc điểm đó không mong muốn, thay vào đó, hãy sử dụng các mảng được đánh máy.] and can contain a mix of different data types. [When those characteristics are undesirable, use typed arrays instead.]
- Các mảng JavaScript không phải là mảng liên kết và do đó, các phần tử mảng không thể được truy cập bằng cách sử dụng các chuỗi tùy ý làm chỉ mục, nhưng phải được truy cập bằng các số nguyên không âm [hoặc dạng chuỗi tương ứng của chúng] làm chỉ mục. and so, array elements cannot be accessed using arbitrary strings as indexes, but must be accessed using nonnegative integers [or their respective string form] as indexes.
- Các mảng JavaScript không được chỉ định bằng 0: phần tử đầu tiên của một mảng là tại Index
5, phần thứ hai là tại Indexfruits[5] = 'mango'; console.log[fruits[5]]; // 'mango' console.log[Object.keys[fruits]]; // ['0', '1', '2', '5'] console.log[fruits.length]; // 6
6, v.v.-và phần tử cuối cùng là giá trị của thuộc tínhfruits[5] = 'mango'; console.log[fruits[5]]; // 'mango' console.log[Object.keys[fruits]]; // ['0', '1', '2', '5'] console.log[fruits.length]; // 6
7 của mảng trừconst fruits = []; fruits.push['banana', 'apple', 'peach']; console.log[fruits.length]; // 3
6.: the first element of an array is at indexfruits[5] = 'mango'; console.log[fruits[5]]; // 'mango' console.log[Object.keys[fruits]]; // ['0', '1', '2', '5'] console.log[fruits.length]; // 6
5, the second is at indexfruits[5] = 'mango'; console.log[fruits[5]]; // 'mango' console.log[Object.keys[fruits]]; // ['0', '1', '2', '5'] console.log[fruits.length]; // 6
6, and so on — and the last element is at the value of the array'sfruits[5] = 'mango'; console.log[fruits[5]]; // 'mango' console.log[Object.keys[fruits]]; // ['0', '1', '2', '5'] console.log[fruits.length]; // 6
7 property minusconst fruits = []; fruits.push['banana', 'apple', 'peach']; console.log[fruits.length]; // 3
6.fruits[5] = 'mango'; console.log[fruits[5]]; // 'mango' console.log[Object.keys[fruits]]; // ['0', '1', '2', '5'] console.log[fruits.length]; // 6
- Các hoạt động sao chép mảng JavaScript tạo các bản sao nông. [Tất cả các hoạt động sao chép tích hợp tiêu chuẩn với bất kỳ đối tượng JavaScript nào tạo các bản sao nông, thay vì các bản sao sâu].. [All standard built-in copy operations with any JavaScript objects create shallow copies, rather than deep copies].
Chỉ số mảng
const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
2 Các đối tượng không thể sử dụng các chuỗi tùy ý làm chỉ số phần tử [như trong một mảng kết hợp] nhưng phải sử dụng các số nguyên không âm [hoặc dạng chuỗi tương ứng của chúng]. Cài đặt hoặc truy cập thông qua những người không phải là thông tin sẽ không đặt hoặc truy xuất một phần tử từ chính danh sách mảng, nhưng sẽ đặt hoặc truy cập một biến được liên kết với bộ sưu tập thuộc tính đối tượng của mảng đó. Các thuộc tính đối tượng của mảng và danh sách các phần tử mảng là riêng biệt và các hoạt động di chuyển và đột biến của mảng không thể được áp dụng cho các thuộc tính được đặt tên này.Các phần tử mảng là các thuộc tính đối tượng giống như cách
fruits.length = 10;
console.log[fruits]; // ['banana', 'apple', 'peach', empty x 2, 'mango', empty x 4]
console.log[Object.keys[fruits]]; // ['0', '1', '2', '5']
console.log[fruits.length]; // 10
console.log[fruits[8]]; // undefined
0 là một thuộc tính [tuy nhiên, cụ thể, fruits.length = 10;
console.log[fruits]; // ['banana', 'apple', 'peach', empty x 2, 'mango', empty x 4]
console.log[Object.keys[fruits]]; // ['0', '1', '2', '5']
console.log[fruits.length]; // 10
console.log[fruits[8]]; // undefined
1 là một phương thức]. Tuy nhiên, cố gắng truy cập một phần tử của một mảng như sau đã ném lỗi cú pháp vì tên thuộc tính không hợp lệ:console.log[arr.0]; // a syntax error
Cú pháp JavaScript yêu cầu các thuộc tính bắt đầu bằng một chữ số được truy cập bằng ký hiệu khung thay vì ký hiệu DOT. Cũng có thể trích dẫn các chỉ số mảng [ví dụ:
fruits.length = 10;
console.log[fruits]; // ['banana', 'apple', 'peach', empty x 2, 'mango', empty x 4]
console.log[Object.keys[fruits]]; // ['0', '1', '2', '5']
console.log[fruits.length]; // 10
console.log[fruits[8]]; // undefined
2 thay vì fruits.length = 10;
console.log[fruits]; // ['banana', 'apple', 'peach', empty x 2, 'mango', empty x 4]
console.log[Object.keys[fruits]]; // ['0', '1', '2', '5']
console.log[fruits.length]; // 10
console.log[fruits[8]]; // undefined
3], mặc dù thường không cần thiết.fruits.length = 10;
console.log[fruits]; // ['banana', 'apple', 'peach', empty x 2, 'mango', empty x 4]
console.log[Object.keys[fruits]]; // ['0', '1', '2', '5']
console.log[fruits.length]; // 10
console.log[fruits[8]]; // undefined
4 trong fruits.length = 10;
console.log[fruits]; // ['banana', 'apple', 'peach', empty x 2, 'mango', empty x 4]
console.log[Object.keys[fruits]]; // ['0', '1', '2', '5']
console.log[fruits.length]; // 10
console.log[fruits[8]]; // undefined
3 được ép thành một chuỗi bởi công cụ JavaScript thông qua chuyển đổi fruits.length = 10;
console.log[fruits]; // ['banana', 'apple', 'peach', empty x 2, 'mango', empty x 4]
console.log[Object.keys[fruits]]; // ['0', '1', '2', '5']
console.log[fruits.length]; // 10
console.log[fruits[8]]; // undefined
0 ngầm. Do đó, fruits.length = 10;
console.log[fruits]; // ['banana', 'apple', 'peach', empty x 2, 'mango', empty x 4]
console.log[Object.keys[fruits]]; // ['0', '1', '2', '5']
console.log[fruits.length]; // 10
console.log[fruits[8]]; // undefined
7 và fruits.length = 10;
console.log[fruits]; // ['banana', 'apple', 'peach', empty x 2, 'mango', empty x 4]
console.log[Object.keys[fruits]]; // ['0', '1', '2', '5']
console.log[fruits.length]; // 10
console.log[fruits[8]]; // undefined
8 sẽ đề cập đến hai vị trí khác nhau trên đối tượng fruits.length = 10;
console.log[fruits]; // ['banana', 'apple', 'peach', empty x 2, 'mango', empty x 4]
console.log[Object.keys[fruits]]; // ['0', '1', '2', '5']
console.log[fruits.length]; // 10
console.log[fruits[8]]; // undefined
9 và ví dụ sau đây có thể là fruits.length = 2;
console.log[Object.keys[fruits]]; // ['0', '1']
console.log[fruits.length]; // 2
0:console.log[years['2'] !== years['02']];
Chỉ
fruits.length = 10;
console.log[fruits]; // ['banana', 'apple', 'peach', empty x 2, 'mango', empty x 4]
console.log[Object.keys[fruits]]; // ['0', '1', '2', '5']
console.log[fruits.length]; // 10
console.log[fruits[8]]; // undefined
2 là một chỉ số mảng thực tế. fruits.length = 2;
console.log[Object.keys[fruits]]; // ['0', '1']
console.log[fruits.length]; // 2
2 là một thuộc tính chuỗi tùy ý sẽ không được truy cập trong vòng lặp mảng.Mối quan hệ giữa độ dài và tính chất số
Thuộc tính
const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
7 của mảng JavaScript được kết nối.Một số phương thức mảng tích hợp [ví dụ:
fruits.length = 2;
console.log[Object.keys[fruits]]; // ['0', '1']
console.log[fruits.length]; // 2
4, fruits.length = 2;
console.log[Object.keys[fruits]]; // ['0', '1']
console.log[fruits.length]; // 2
5, fruits.length = 2;
console.log[Object.keys[fruits]]; // ['0', '1']
console.log[fruits.length]; // 2
6, v.v.] có tính đến giá trị của thuộc tính const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
7 của mảng khi chúng được gọi.Các phương thức khác [ví dụ:
fruits.length = 2;
console.log[Object.keys[fruits]]; // ['0', '1']
console.log[fruits.length]; // 2
8, fruits.length = 2;
console.log[Object.keys[fruits]]; // ['0', '1']
console.log[fruits.length]; // 2
9, v.v.] cũng dẫn đến các bản cập nhật cho thuộc tính const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
7 của mảng.const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
Khi đặt thuộc tính trên mảng JavaScript khi thuộc tính là chỉ mục mảng hợp lệ và chỉ mục đó nằm ngoài giới hạn hiện tại của mảng, động cơ sẽ cập nhật thuộc tính
const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
7 của mảng cho phù hợp:fruits[5] = 'mango';
console.log[fruits[5]]; // 'mango'
console.log[Object.keys[fruits]]; // ['0', '1', '2', '5']
console.log[fruits.length]; // 6
Tăng
const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
7.fruits.length = 10;
console.log[fruits]; // ['banana', 'apple', 'peach', empty x 2, 'mango', empty x 4]
console.log[Object.keys[fruits]]; // ['0', '1', '2', '5']
console.log[fruits.length]; // 10
console.log[fruits[8]]; // undefined
Giảm thuộc tính
const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
7, tuy nhiên, xóa các yếu tố.fruits.length = 2;
console.log[Object.keys[fruits]]; // ['0', '1']
console.log[fruits.length]; // 2
Điều này được giải thích thêm trên trang
method[callbackFn, thisArg]
4.Phương pháp mảng và các khe trống
Các khe trống trong các mảng thưa thớt cư xử không nhất quán giữa các phương thức mảng. Nói chung, các phương pháp cũ hơn sẽ bỏ qua các khe trống, trong khi các phương pháp mới hơn coi chúng là
const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
4.Trong số các phương pháp lặp qua nhiều yếu tố, sau đây thực hiện kiểm tra
method[callbackFn, thisArg]
6 trước khi truy cập chỉ mục và không kết hợp các khe trống với const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
4:
8method[callbackFn, thisArg]
9method[callbackFn, thisArg]
0const arrayLike = { 0: "a", 1: "b", length: 2, }; console.log[Array.prototype.join.call[arrayLike, "+"]]; // 'a+b'
1const arrayLike = { 0: "a", 1: "b", length: 2, }; console.log[Array.prototype.join.call[arrayLike, "+"]]; // 'a+b'
2const arrayLike = { 0: "a", 1: "b", length: 2, }; console.log[Array.prototype.join.call[arrayLike, "+"]]; // 'a+b'
3const arrayLike = { 0: "a", 1: "b", length: 2, }; console.log[Array.prototype.join.call[arrayLike, "+"]]; // 'a+b'
4const arrayLike = { 0: "a", 1: "b", length: 2, }; console.log[Array.prototype.join.call[arrayLike, "+"]]; // 'a+b'
6fruits.length = 2; console.log[Object.keys[fruits]]; // ['0', '1'] console.log[fruits.length]; // 2
6const arrayLike = { 0: "a", 1: "b", length: 2, }; console.log[Array.prototype.join.call[arrayLike, "+"]]; // 'a+b'
7const arrayLike = { 0: "a", 1: "b", length: 2, }; console.log[Array.prototype.join.call[arrayLike, "+"]]; // 'a+b'
8const arrayLike = { 0: "a", 1: "b", length: 2, }; console.log[Array.prototype.join.call[arrayLike, "+"]]; // 'a+b'
9const arrayLike = { 0: "a", 1: "b", length: 2, }; console.log[Array.prototype.join.call[arrayLike, "+"]]; // 'a+b'
00const arrayLike = { length: 3, }; for [const entry of Array.prototype.keys.call[arrayLike]] { console.log[entry]; } // 0 // 1 // 2
5fruits.length = 2; console.log[Object.keys[fruits]]; // ['0', '1'] console.log[fruits.length]; // 2
02const arrayLike = { length: 3, }; for [const entry of Array.prototype.keys.call[arrayLike]] { console.log[entry]; } // 0 // 1 // 2
03const arrayLike = { length: 3, }; for [const entry of Array.prototype.keys.call[arrayLike]] { console.log[entry]; } // 0 // 1 // 2
9fruits.length = 2; console.log[Object.keys[fruits]]; // ['0', '1'] console.log[fruits.length]; // 2
Để biết chính xác cách họ xử lý các khe trống, hãy xem trang cho mỗi phương thức.
Các phương pháp này xử lý các khe trống như thể chúng là
const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
4:
06const arrayLike = { length: 3, }; for [const entry of Array.prototype.keys.call[arrayLike]] { console.log[entry]; } // 0 // 1 // 2
07const arrayLike = { length: 3, }; for [const entry of Array.prototype.keys.call[arrayLike]] { console.log[entry]; } // 0 // 1 // 2
08const arrayLike = { length: 3, }; for [const entry of Array.prototype.keys.call[arrayLike]] { console.log[entry]; } // 0 // 1 // 2
09const arrayLike = { length: 3, }; for [const entry of Array.prototype.keys.call[arrayLike]] { console.log[entry]; } // 0 // 1 // 2
10const arrayLike = { length: 3, }; for [const entry of Array.prototype.keys.call[arrayLike]] { console.log[entry]; } // 0 // 1 // 2
11const arrayLike = { length: 3, }; for [const entry of Array.prototype.keys.call[arrayLike]] { console.log[entry]; } // 0 // 1 // 2
12 Thí nghiệmExperimentalconst arrayLike = { length: 3, }; for [const entry of Array.prototype.keys.call[arrayLike]] { console.log[entry]; } // 0 // 1 // 2
13 Thử nghiệmExperimentalconst arrayLike = { length: 3, }; for [const entry of Array.prototype.keys.call[arrayLike]] { console.log[entry]; } // 0 // 1 // 2
14const arrayLike = { length: 3, }; for [const entry of Array.prototype.keys.call[arrayLike]] { console.log[entry]; } // 0 // 1 // 2
4fruits.length = 2; console.log[Object.keys[fruits]]; // ['0', '1'] console.log[fruits.length]; // 2
1const fruits = []; fruits.push['banana', 'apple', 'peach']; console.log[fruits.length]; // 3
17const arrayLike = { length: 3, }; for [const entry of Array.prototype.keys.call[arrayLike]] { console.log[entry]; } // 0 // 1 // 2
18const arrayLike = { length: 3, }; for [const entry of Array.prototype.keys.call[arrayLike]] { console.log[entry]; } // 0 // 1 // 2
Sao chép phương pháp và phương pháp đột biến
Một số phương thức không làm thay đổi mảng hiện tại mà phương thức đã được gọi, mà thay vào đó lại trả về một mảng mới. Họ làm như vậy bằng cách trước tiên truy cập
const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
19 để xác định hàm tạo để sử dụng cho mảng mới. Mảng mới được xây dựng sau đó được điền với các yếu tố. Bản sao luôn xảy ra nông cạn - phương thức không bao giờ sao chép bất cứ thứ gì ngoài mảng được tạo ban đầu. Các phần tử của [các] mảng gốc được sao chép vào mảng mới như sau:- Đối tượng: Tham chiếu đối tượng được sao chép vào mảng mới. Cả mảng gốc và mảng mới đều đề cập đến cùng một đối tượng. Đó là, nếu một đối tượng được tham chiếu được sửa đổi, các thay đổi được hiển thị cho cả mảng mới và ban đầu.
- Các loại nguyên thủy như chuỗi, số và booleans [không phải
20,const arrayLike = { length: 3, }; for [const entry of Array.prototype.keys.call[arrayLike]] { console.log[entry]; } // 0 // 1 // 2
21 vàconst arrayLike = { length: 3, }; for [const entry of Array.prototype.keys.call[arrayLike]] { console.log[entry]; } // 0 // 1 // 2
22 đối tượng]: Giá trị của chúng được sao chép vào mảng mới.const arrayLike = { length: 3, }; for [const entry of Array.prototype.keys.call[arrayLike]] { console.log[entry]; } // 0 // 1 // 2
Các phương thức khác làm biến đổi mảng mà phương thức được gọi, trong trường hợp giá trị trả về của chúng khác nhau tùy thuộc vào phương thức: đôi khi một tham chiếu đến cùng một mảng, đôi khi độ dài của mảng mới.
Các phương thức sau tạo các mảng mới với
const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
23:
8method[callbackFn, thisArg]
1const arrayLike = { 0: "a", 1: "b", length: 2, }; console.log[Array.prototype.join.call[arrayLike, "+"]]; // 'a+b'
2const arrayLike = { 0: "a", 1: "b", length: 2, }; console.log[Array.prototype.join.call[arrayLike, "+"]]; // 'a+b'
3const arrayLike = { 0: "a", 1: "b", length: 2, }; console.log[Array.prototype.join.call[arrayLike, "+"]]; // 'a+b'
7const arrayLike = { 0: "a", 1: "b", length: 2, }; console.log[Array.prototype.join.call[arrayLike, "+"]]; // 'a+b'
5fruits.length = 2; console.log[Object.keys[fruits]]; // ['0', '1'] console.log[fruits.length]; // 2
9 [để xây dựng mảng các phần tử bị loại bỏ đã được trả về]fruits.length = 2; console.log[Object.keys[fruits]]; // ['0', '1'] console.log[fruits.length]; // 2
Lưu ý rằng
const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
12 và const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
13 không sử dụng const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
23 để tạo các mảng mới cho mỗi mục nhập nhóm, nhưng luôn sử dụng hàm tạo const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
2 trơn. Về mặt khái niệm, họ cũng không sao chép các phương pháp.Các phương pháp sau đây làm biến đổi mảng ban đầu:
9method[callbackFn, thisArg]
07const arrayLike = { length: 3, }; for [const entry of Array.prototype.keys.call[arrayLike]] { console.log[entry]; } // 0 // 1 // 2
37const arrayLike = { length: 3, }; for [const entry of Array.prototype.keys.call[arrayLike]] { console.log[entry]; } // 0 // 1 // 2
8fruits.length = 2; console.log[Object.keys[fruits]]; // ['0', '1'] console.log[fruits.length]; // 2
00const arrayLike = { length: 3, }; for [const entry of Array.prototype.keys.call[arrayLike]] { console.log[entry]; } // 0 // 1 // 2
40const arrayLike = { length: 3, }; for [const entry of Array.prototype.keys.call[arrayLike]] { console.log[entry]; } // 0 // 1 // 2
03const arrayLike = { length: 3, }; for [const entry of Array.prototype.keys.call[arrayLike]] { console.log[entry]; } // 0 // 1 // 2
9fruits.length = 2; console.log[Object.keys[fruits]]; // ['0', '1'] console.log[fruits.length]; // 2
43const arrayLike = { length: 3, }; for [const entry of Array.prototype.keys.call[arrayLike]] { console.log[entry]; } // 0 // 1 // 2
Phương pháp lặp
Nhiều phương thức mảng lấy chức năng gọi lại làm đối số. Hàm gọi lại được gọi là tuần tự và nhiều nhất một lần cho mỗi phần tử trong mảng và giá trị trả về của hàm gọi lại được sử dụng để xác định giá trị trả về của phương thức. Tất cả họ đều có chung chữ ký:
method[callbackFn, thisArg]
Trong đó
const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
44 lấy ba đối số:const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
45Phần tử hiện tại được xử lý trong mảng.
const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
46Chỉ số của phần tử hiện tại được xử lý trong mảng.
const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
47Mảng
const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
13 đã được kêu gọi.Những gì
const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
44 dự kiến sẽ trở lại phụ thuộc vào phương thức mảng được gọi.Đối số
const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
50 [mặc định là const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
4] sẽ được sử dụng làm giá trị const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
6 khi gọi const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
44. Giá trị const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
6 cuối cùng có thể quan sát được bởi const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
44 được xác định theo các quy tắc thông thường: nếu const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
44 không nghiêm ngặt, các giá trị const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
6 nguyên thủy được bọc thành các đối tượng và ________ 44/________ 159 được thay thế bằng const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
60. Đối số const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
50 không liên quan đến bất kỳ const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
44 được xác định với hàm mũi tên, vì các hàm mũi tên không có ràng buộc const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
6 riêng của chúng.Tất cả các phương pháp lặp là sao chép và chung chung, mặc dù chúng hoạt động khác nhau với các khe trống.
Các phương pháp sau là lặp đi lặp lại:
0const arrayLike = { 0: "a", 1: "b", length: 2, }; console.log[Array.prototype.join.call[arrayLike, "+"]]; // 'a+b'
1const arrayLike = { 0: "a", 1: "b", length: 2, }; console.log[Array.prototype.join.call[arrayLike, "+"]]; // 'a+b'
08const arrayLike = { length: 3, }; for [const entry of Array.prototype.keys.call[arrayLike]] { console.log[entry]; } // 0 // 1 // 2
09const arrayLike = { length: 3, }; for [const entry of Array.prototype.keys.call[arrayLike]] { console.log[entry]; } // 0 // 1 // 2
10const arrayLike = { length: 3, }; for [const entry of Array.prototype.keys.call[arrayLike]] { console.log[entry]; } // 0 // 1 // 2
11const arrayLike = { length: 3, }; for [const entry of Array.prototype.keys.call[arrayLike]] { console.log[entry]; } // 0 // 1 // 2
3const arrayLike = { 0: "a", 1: "b", length: 2, }; console.log[Array.prototype.join.call[arrayLike, "+"]]; // 'a+b'
4const arrayLike = { 0: "a", 1: "b", length: 2, }; console.log[Array.prototype.join.call[arrayLike, "+"]]; // 'a+b'
12const arrayLike = { length: 3, }; for [const entry of Array.prototype.keys.call[arrayLike]] { console.log[entry]; } // 0 // 1 // 2
13const arrayLike = { length: 3, }; for [const entry of Array.prototype.keys.call[arrayLike]] { console.log[entry]; } // 0 // 1 // 2
7const arrayLike = { 0: "a", 1: "b", length: 2, }; console.log[Array.prototype.join.call[arrayLike, "+"]]; // 'a+b'
02const arrayLike = { length: 3, }; for [const entry of Array.prototype.keys.call[arrayLike]] { console.log[entry]; } // 0 // 1 // 2
Cụ thể,
const arrayLike = {
0: "a",
1: "b",
length: 2,
};
console.log[Array.prototype.join.call[arrayLike, "+"]]; // 'a+b'
0, const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
08, const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
09, const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
10, const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
11 và const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
02 không phải lúc nào cũng gọi const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
44 trên mọi yếu tố - chúng dừng lặp lại ngay khi giá trị trả về được xác định.Có hai phương pháp khác có chức năng gọi lại và chạy nó nhiều nhất một lần cho mỗi phần tử trong mảng, nhưng chúng có chữ ký hơi khác nhau từ các phương thức lặp điển hình [ví dụ: chúng không chấp nhận
const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
50]:
8const arrayLike = { 0: "a", 1: "b", length: 2, }; console.log[Array.prototype.join.call[arrayLike, "+"]]; // 'a+b'
9const arrayLike = { 0: "a", 1: "b", length: 2, }; console.log[Array.prototype.join.call[arrayLike, "+"]]; // 'a+b'
Phương thức
const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
03 cũng có hàm gọi lại, nhưng nó không phải là phương thức lặp. Nó làm đột biến mảng tại chỗ, không chấp nhận const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
50 và có thể gọi cuộc gọi lại nhiều lần trên một chỉ mục.Phương pháp mảng chung
Các phương thức mảng luôn chung chung - chúng không truy cập bất kỳ dữ liệu nội bộ nào của đối tượng mảng. Họ chỉ truy cập các phần tử mảng thông qua thuộc tính
const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
7 và các phần tử được lập chỉ mục. Điều này có nghĩa là chúng cũng có thể được gọi trên các đối tượng giống như mảng.const arrayLike = {
0: "a",
1: "b",
length: 2,
};
console.log[Array.prototype.join.call[arrayLike, "+"]]; // 'a+b'
Bình thường hóa thuộc tính chiều dài
Thuộc tính
const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
7 được chuyển đổi thành một số, bị cắt thành một số nguyên và sau đó được kẹp theo phạm vi từ 0 đến 253 - 1. const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
90 trở thành fruits[5] = 'mango';
console.log[fruits[5]]; // 'mango'
console.log[Object.keys[fruits]]; // ['0', '1', '2', '5']
console.log[fruits.length]; // 6
5, vì vậy ngay cả khi const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
7 không có mặt hoặc là const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
4, nó hoạt động như thể nó có giá trị .const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
0Một số phương thức mảng đặt thuộc tính
const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
7 của đối tượng mảng. Họ luôn đặt giá trị sau khi chuẩn hóa, do đó const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
7 luôn kết thúc dưới dạng số nguyên.const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
1Các đối tượng giống như mảng
Thuật ngữ đối tượng giống như mảng đề cập đến bất kỳ đối tượng nào không ném trong quá trình chuyển đổi
const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
7 được mô tả ở trên. Trong thực tế, đối tượng như vậy dự kiến sẽ thực sự có thuộc tính const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
7 và có các phần tử được lập chỉ mục trong phạm vi fruits[5] = 'mango';
console.log[fruits[5]]; // 'mango'
console.log[Object.keys[fruits]]; // ['0', '1', '2', '5']
console.log[fruits.length]; // 6
5 đến fruits[5] = 'mango';
console.log[fruits[5]]; // 'mango'
console.log[Object.keys[fruits]]; // ['0', '1', '2', '5']
console.log[fruits.length]; // 6
3. [Nếu nó không có tất cả các chỉ số, nó sẽ tương đương về mặt chức năng với một mảng thưa thớt.]Nhiều đối tượng DOM giống như mảng-ví dụ:
console.log[arr.0]; // a syntax error
01 và console.log[arr.0]; // a syntax error
02. Đối tượng console.log[arr.0]; // a syntax error
03 cũng giống như mảng. Bạn có thể gọi các phương thức mảng trên chúng ngay cả khi chúng không có các phương thức này.const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
2Người xây dựng
console.log[arr.0]; // a syntax error
04Tạo một đối tượng
const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
2 mới.Tính chất tĩnh
console.log[arr.0]; // a syntax error
06Trả về hàm tạo
const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
2.
Phương pháp tĩnh
console.log[arr.0]; // a syntax error
08Tạo một thể hiện
const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
2 mới từ một đối tượng giống như mảng hoặc đối tượng có thể lặp lại.console.log[arr.0]; // a syntax error
10Trả về
fruits.length = 2;
console.log[Object.keys[fruits]]; // ['0', '1']
console.log[fruits.length]; // 2
0 nếu đối số là một mảng hoặc console.log[arr.0]; // a syntax error
12 khác.console.log[arr.0]; // a syntax error
13Tạo một thể hiện
const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
2 mới với một số lượng đối số thay đổi, bất kể số hoặc loại đối số.Thuộc tính thể hiện
console.log[arr.0]; // a syntax error
15Phản ánh số lượng các yếu tố trong một mảng.
console.log[arr.0]; // a syntax error
16Chứa các tên thuộc tính không được bao gồm trong tiêu chuẩn ECMAScript trước phiên bản ES2015 và bị bỏ qua cho các mục đích liên kết câu lệnh
console.log[arr.0]; // a syntax error
17.Phương pháp thể hiện
console.log[arr.0]; // a syntax error
18Trả về mục mảng tại chỉ mục đã cho. Chấp nhận số nguyên âm, được tính lại từ mục cuối cùng.
console.log[arr.0]; // a syntax error
19Trả về một mảng mới là mảng gọi được nối với [các] mảng khác và/hoặc giá trị.
console.log[arr.0]; // a syntax error
20Sao chép một chuỗi các phần tử mảng trong một mảng.
console.log[arr.0]; // a syntax error
21Trả về một đối tượng lặp mảng mới chứa các cặp khóa/giá trị cho mỗi chỉ mục trong một mảng.
console.log[arr.0]; // a syntax error
22Trả về
fruits.length = 2;
console.log[Object.keys[fruits]]; // ['0', '1']
console.log[fruits.length]; // 2
0 Nếu mọi phần tử trong mảng gọi thỏa mãn chức năng kiểm tra.console.log[arr.0]; // a syntax error
24Điền vào tất cả các phần tử của một mảng từ chỉ mục bắt đầu sang chỉ mục cuối với giá trị tĩnh.
console.log[arr.0]; // a syntax error
25Trả về một mảng mới chứa tất cả các phần tử của mảng gọi mà hàm lọc được cung cấp trả về
fruits.length = 2;
console.log[Object.keys[fruits]]; // ['0', '1']
console.log[fruits.length]; // 2
0.console.log[arr.0]; // a syntax error
27Trả về giá trị của phần tử đầu tiên trong mảng thỏa mãn chức năng thử nghiệm được cung cấp hoặc
const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
4 nếu không tìm thấy phần tử thích hợp.console.log[arr.0]; // a syntax error
29Trả về chỉ số của phần tử đầu tiên trong mảng thỏa mãn chức năng thử nghiệm được cung cấp hoặc
console.log[arr.0]; // a syntax error
30 nếu không tìm thấy phần tử thích hợp.console.log[arr.0]; // a syntax error
31Trả về giá trị của phần tử cuối cùng trong mảng thỏa mãn chức năng thử nghiệm được cung cấp hoặc
const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
4 nếu không tìm thấy phần tử thích hợp.console.log[arr.0]; // a syntax error
33Trả về chỉ số của phần tử cuối cùng trong mảng thỏa mãn chức năng thử nghiệm được cung cấp hoặc
console.log[arr.0]; // a syntax error
30 nếu không tìm thấy phần tử thích hợp.console.log[arr.0]; // a syntax error
35Trả về một mảng mới với tất cả các yếu tố mảng con được liên kết vào nó đệ quy lên đến độ sâu được chỉ định.
console.log[arr.0]; // a syntax error
36Trả về một mảng mới được hình thành bằng cách áp dụng một hàm gọi lại đã cho cho từng phần tử của mảng gọi, sau đó làm phẳng kết quả theo một cấp.
console.log[arr.0]; // a syntax error
37Gọi một hàm cho mỗi phần tử trong mảng gọi.
console.log[arr.0]; // a syntax error
38 Thí nghiệmExperimentalNhóm các phần tử của một mảng thành một đối tượng theo các chuỗi được trả về bởi một hàm thử nghiệm.
console.log[arr.0]; // a syntax error
39 Thí nghiệmExperimentalNhóm các phần tử của một mảng thành
console.log[arr.0]; // a syntax error
40 theo các giá trị được trả về bởi hàm thử nghiệm.console.log[arr.0]; // a syntax error
41Xác định xem mảng gọi có chứa giá trị hay không, trả về
fruits.length = 2;
console.log[Object.keys[fruits]]; // ['0', '1']
console.log[fruits.length]; // 2
0 hoặc console.log[arr.0]; // a syntax error
12 nếu thích hợp.console.log[arr.0]; // a syntax error
44Trả về chỉ mục đầu tiên [ít nhất] mà tại đó một phần tử nhất định có thể được tìm thấy trong mảng gọi.
console.log[arr.0]; // a syntax error
45Tham gia tất cả các yếu tố của một mảng thành một chuỗi.
console.log[arr.0]; // a syntax error
46Trả về một trình lặp mảng mới chứa các phím cho mỗi chỉ mục trong mảng gọi.
console.log[arr.0]; // a syntax error
47Trả về chỉ mục cuối cùng [lớn nhất] mà tại đó một phần tử nhất định có thể được tìm thấy trong mảng gọi hoặc
console.log[arr.0]; // a syntax error
30 nếu không tìm thấy.console.log[arr.0]; // a syntax error
49Trả về một mảng mới chứa kết quả gọi một hàm trên mọi phần tử trong mảng gọi.
console.log[arr.0]; // a syntax error
50Loại bỏ phần tử cuối cùng khỏi một mảng và trả về phần tử đó.
console.log[arr.0]; // a syntax error
51Thêm một hoặc nhiều phần tử vào cuối một mảng và trả về
const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
7 mới của mảng.console.log[arr.0]; // a syntax error
53Thực thi chức năng gọi lại "giảm" do người dùng cung cấp trên mỗi phần tử của mảng [từ trái sang phải], để giảm nó xuống một giá trị duy nhất.
console.log[arr.0]; // a syntax error
54Thực thi chức năng gọi lại "giảm" do người dùng cung cấp trên mỗi phần tử của mảng [từ phải sang trái], để giảm nó xuống một giá trị duy nhất.
console.log[arr.0]; // a syntax error
55Đảo ngược thứ tự của các yếu tố của một mảng tại chỗ. [Đầu tiên trở thành người cuối cùng, lần cuối cùng trở thành đầu tiên.]
console.log[arr.0]; // a syntax error
56Loại bỏ phần tử đầu tiên khỏi một mảng và trả về phần tử đó.
console.log[arr.0]; // a syntax error
57Trích xuất một phần của mảng gọi và trả về một mảng mới.
console.log[arr.0]; // a syntax error
58Trả về
fruits.length = 2;
console.log[Object.keys[fruits]]; // ['0', '1']
console.log[fruits.length]; // 2
0 Nếu ít nhất một phần tử trong mảng gọi thỏa mãn chức năng kiểm tra được cung cấp.console.log[arr.0]; // a syntax error
60Sắp xếp các phần tử của một mảng tại chỗ và trả về mảng.
console.log[arr.0]; // a syntax error
61Thêm và/hoặc loại bỏ các yếu tố khỏi một mảng.
console.log[arr.0]; // a syntax error
62Trả về một chuỗi cục bộ đại diện cho mảng gọi và các yếu tố của nó. Ghi đè phương thức
console.log[arr.0]; // a syntax error
63.console.log[arr.0]; // a syntax error
64Trả về một chuỗi đại diện cho mảng gọi và các phần tử của nó. Ghi đè phương thức
console.log[arr.0]; // a syntax error
65.console.log[arr.0]; // a syntax error
66Thêm một hoặc nhiều phần tử vào mặt trước của một mảng và trả về
const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
7 mới của mảng.console.log[arr.0]; // a syntax error
68Trả về một đối tượng lặp mảng mới chứa các giá trị cho mỗi chỉ mục trong mảng.
console.log[arr.0]; // a syntax error
69Một bí danh cho phương thức
const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
18 theo mặc định.Ví dụ
Phần này cung cấp một số ví dụ về các hoạt động mảng phổ biến trong JavaScript.
Tạo một mảng
Ví dụ này hiển thị ba cách để tạo mảng mới: đầu tiên sử dụng ký hiệu theo nghĩa đen của mảng, sau đó sử dụng hàm tạo
console.log[arr.0]; // a syntax error
04 và cuối cùng sử dụng console.log[arr.0]; // a syntax error
72 để xây dựng mảng từ một chuỗi.const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
3Tạo một chuỗi từ một mảng
Ví dụ này sử dụng phương thức
fruits.length = 2;
console.log[Object.keys[fruits]]; // ['0', '1']
console.log[fruits.length]; // 2
4 để tạo một chuỗi từ mảng console.log[arr.0]; // a syntax error
74.const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
4Truy cập một mục mảng theo chỉ mục của nó
Ví dụ này cho thấy cách truy cập các mục trong mảng
console.log[arr.0]; // a syntax error
74 bằng cách chỉ định số chỉ mục của vị trí của chúng trong mảng.const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
5
Tìm chỉ mục của một mục trong một mảng
Ví dụ này sử dụng phương thức
fruits.length = 2;
console.log[Object.keys[fruits]]; // ['0', '1']
console.log[fruits.length]; // 2
6 để tìm vị trí [chỉ mục] của chuỗi console.log[arr.0]; // a syntax error
77 trong mảng console.log[arr.0]; // a syntax error
74.const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
6Kiểm tra xem một mảng có chứa một mục nào đó không
Ví dụ này cho thấy hai cách để kiểm tra xem mảng
console.log[arr.0]; // a syntax error
74 có chứa console.log[arr.0]; // a syntax error
77 và console.log[arr.0]; // a syntax error
81: Đầu tiên với phương thức const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
14, sau đó với phương thức fruits.length = 2;
console.log[Object.keys[fruits]]; // ['0', '1']
console.log[fruits.length]; // 2
6 để kiểm tra giá trị chỉ mục không phải là console.log[arr.0]; // a syntax error
30.const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
7Nối một mục vào một mảng
Ví dụ này sử dụng phương thức
fruits.length = 2;
console.log[Object.keys[fruits]]; // ['0', '1']
console.log[fruits.length]; // 2
8 để nối một chuỗi mới vào mảng console.log[arr.0]; // a syntax error
74.const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
8Xóa mục cuối cùng khỏi một mảng
Ví dụ này sử dụng phương thức
const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
37 để xóa mục cuối cùng khỏi mảng console.log[arr.0]; // a syntax error
74.const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
9Lưu ý:
37 chỉ có thể được sử dụng để loại bỏ mục cuối cùng khỏi một mảng. Để loại bỏ nhiều mục từ cuối một mảng, hãy xem ví dụ tiếp theo. const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
37 can only be used to remove the last item from an array. To remove multiple items from the end of an array, see the next example.Xóa nhiều mục từ cuối một mảng
Ví dụ này sử dụng phương thức
fruits.length = 2;
console.log[Object.keys[fruits]]; // ['0', '1']
console.log[fruits.length]; // 2
9 để loại bỏ 3 mục cuối cùng khỏi mảng console.log[arr.0]; // a syntax error
74.console.log[arr.0]; // a syntax error
0Cắt ngắn một mảng xuống chỉ là n mục đầu tiên của nó
Ví dụ này sử dụng phương thức
fruits.length = 2;
console.log[Object.keys[fruits]]; // ['0', '1']
console.log[fruits.length]; // 2
9 để cắt giảm mảng console.log[arr.0]; // a syntax error
74 xuống chỉ còn 2 mục đầu tiên.console.log[arr.0]; // a syntax error
1Xóa mục đầu tiên khỏi một mảng
Ví dụ này sử dụng phương thức
const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
40 để xóa mục đầu tiên khỏi mảng console.log[arr.0]; // a syntax error
74.console.log[arr.0]; // a syntax error
2Lưu ý:
40 chỉ có thể được sử dụng để loại bỏ mục đầu tiên khỏi một mảng. Để loại bỏ nhiều mục từ đầu một mảng, hãy xem ví dụ tiếp theo.
const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
40 can only be used to remove the first item from an array. To remove multiple items from the beginning of an array, see the next example.Xóa nhiều mục từ đầu một mảng
Ví dụ này sử dụng phương thức
fruits.length = 2;
console.log[Object.keys[fruits]]; // ['0', '1']
console.log[fruits.length]; // 2
9 để loại bỏ 3 mục đầu tiên khỏi mảng console.log[arr.0]; // a syntax error
74.console.log[arr.0]; // a syntax error
3Thêm một mục đầu tiên mới vào một mảng
Ví dụ này sử dụng phương thức
const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
43 để thêm, tại Index fruits[5] = 'mango';
console.log[fruits[5]]; // 'mango'
console.log[Object.keys[fruits]]; // ['0', '1', '2', '5']
console.log[fruits.length]; // 6
5, một mục mới cho mảng console.log[arr.0]; // a syntax error
74 - biến nó thành mục đầu tiên mới trong mảng.console.log[arr.0]; // a syntax error
4Xóa một mục duy nhất bằng chỉ mục
Ví dụ này sử dụng phương thức
fruits.length = 2;
console.log[Object.keys[fruits]]; // ['0', '1']
console.log[fruits.length]; // 2
9 để xóa chuỗi console.log[arr.0]; // a syntax error
77 khỏi mảng console.log[arr.0]; // a syntax error
74 - bằng cách chỉ định vị trí chỉ mục của console.log[arr.0]; // a syntax error
77.console.log[arr.0]; // a syntax error
5Xóa nhiều mục bằng chỉ mục
Ví dụ này sử dụng phương thức
fruits.length = 2;
console.log[Object.keys[fruits]]; // ['0', '1']
console.log[fruits.length]; // 2
9 để loại bỏ các chuỗi console.log[arr.0]; // a syntax error
77 và console.log[years['2'] !== years['02']];
08 khỏi mảng console.log[arr.0]; // a syntax error
74 - bằng cách chỉ định vị trí chỉ mục của console.log[arr.0]; // a syntax error
77, cùng với số lượng tổng số mục để xóa.console.log[arr.0]; // a syntax error
6Thay thế nhiều mục trong một mảng
Ví dụ này sử dụng phương thức
fruits.length = 2;
console.log[Object.keys[fruits]]; // ['0', '1']
console.log[fruits.length]; // 2
9 để thay thế 2 mục cuối cùng trong mảng console.log[arr.0]; // a syntax error
74 bằng các mục mới.console.log[arr.0]; // a syntax error
7Lặp lại trên một mảng
Ví dụ này sử dụng vòng lặp
console.log[years['2'] !== years['02']];
13 để lặp qua mảng console.log[arr.0]; // a syntax error
74, đăng nhập từng mục vào bảng điều khiển.console.log[arr.0]; // a syntax error
8Nhưng
console.log[years['2'] !== years['02']];
13 chỉ là một trong nhiều cách để lặp lại bất kỳ mảng nào; Để biết thêm các cách, xem các vòng lặp và lặp lại, và xem tài liệu cho const arrayLike = {
0: "a",
1: "b",
length: 2,
};
console.log[Array.prototype.join.call[arrayLike, "+"]]; // 'a+b'
0, const arrayLike = {
0: "a",
1: "b",
length: 2,
};
console.log[Array.prototype.join.call[arrayLike, "+"]]; // 'a+b'
1, const arrayLike = {
0: "a",
1: "b",
length: 2,
};
console.log[Array.prototype.join.call[arrayLike, "+"]]; // 'a+b'
3, const arrayLike = {
0: "a",
1: "b",
length: 2,
};
console.log[Array.prototype.join.call[arrayLike, "+"]]; // 'a+b'
7, const arrayLike = {
0: "a",
1: "b",
length: 2,
};
console.log[Array.prototype.join.call[arrayLike, "+"]]; // 'a+b'
8 và const arrayLike = {
0: "a",
1: "b",
length: 2,
};
console.log[Array.prototype.join.call[arrayLike, "+"]]; // 'a+b'
9 - và xem ví dụ tiếp theo, sử dụng phương thức const arrayLike = {
0: "a",
1: "b",
length: 2,
};
console.log[Array.prototype.join.call[arrayLike, "+"]]; // 'a+b'
4.Gọi một hàm trên mỗi phần tử trong một mảng
Ví dụ này sử dụng phương thức
const arrayLike = {
0: "a",
1: "b",
length: 2,
};
console.log[Array.prototype.join.call[arrayLike, "+"]]; // 'a+b'
4 để gọi hàm trên mỗi phần tử trong mảng console.log[arr.0]; // a syntax error
74; Hàm làm cho mỗi mục được ghi vào bảng điều khiển, cùng với số chỉ mục của mục.console.log[arr.0]; // a syntax error
9Hợp nhất nhiều mảng với nhau
Ví dụ này sử dụng phương thức
method[callbackFn, thisArg]
8 để hợp nhất mảng console.log[arr.0]; // a syntax error
74 với mảng console.log[years['2'] !== years['02']];
27, để tạo ra một mảng console.log[years['2'] !== years['02']];
28 mới. Lưu ý rằng console.log[arr.0]; // a syntax error
74 và console.log[years['2'] !== years['02']];
27 vẫn không thay đổi.console.log[years['2'] !== years['02']];
0Sao chép một mảng
Ví dụ này cho thấy ba cách để tạo một mảng mới từ mảng
console.log[arr.0]; // a syntax error
74 hiện có: đầu tiên bằng cách sử dụng cú pháp lan truyền, sau đó bằng cách sử dụng phương thức console.log[years['2'] !== years['02']];
32, sau đó bằng cách sử dụng phương thức fruits.length = 2;
console.log[Object.keys[fruits]]; // ['0', '1']
console.log[fruits.length]; // 2
5.console.log[years['2'] !== years['02']];
1Tất cả các hoạt động sao chép mảng tích hợp [Cú pháp lan truyền,
console.log[arr.0]; // a syntax error
08, console.log[arr.0]; // a syntax error
57 và console.log[arr.0]; // a syntax error
19] tạo ra các bản sao nông. Thay vào đó, nếu bạn muốn có một bản sao sâu của một mảng, bạn có thể sử dụng console.log[years['2'] !== years['02']];
37 để chuyển đổi mảng thành chuỗi JSON và sau đó console.log[years['2'] !== years['02']];
38 để chuyển đổi chuỗi trở lại thành một mảng mới hoàn toàn độc lập với mảng gốc.console.log[years['2'] !== years['02']];
2Bạn cũng có thể tạo các bản sao sâu bằng phương pháp
console.log[years['2'] !== years['02']];
39, có lợi thế cho phép các đối tượng có thể chuyển được trong nguồn được chuyển sang bản sao mới, thay vì chỉ nhân bản.Cuối cùng, điều quan trọng là phải hiểu rằng việc gán một mảng hiện có cho một biến mới không tạo ra một bản sao của mảng hoặc các phần tử của nó. Thay vào đó, biến mới chỉ là một tham chiếu, hoặc bí danh, cho mảng gốc; Đó là, tên của mảng gốc và tên biến mới chỉ là hai tên cho cùng một đối tượng [và do đó sẽ luôn đánh giá là tương đương nghiêm ngặt]. Do đó, nếu bạn thực hiện bất kỳ thay đổi nào theo giá trị của mảng gốc hoặc với giá trị của biến mới, thì cũng sẽ thay đổi:
console.log[years['2'] !== years['02']];
3Nhóm các yếu tố của một mảng
Các phương thức
console.log[arr.0]; // a syntax error
38 có thể được sử dụng để nhóm các phần tử của mảng, sử dụng hàm thử nghiệm trả về một chuỗi biểu thị nhóm của phần tử hiện tại.Ở đây chúng tôi có một mảng hàng tồn kho đơn giản có chứa các đối tượng "thực phẩm" có
console.log[years['2'] !== years['02']];
41 và console.log[years['2'] !== years['02']];
42.console.log[years['2'] !== years['02']];
4Để sử dụng
const arrayLike = {
length: 3,
};
for [const entry of Array.prototype.keys.call[arrayLike]] {
console.log[entry];
}
// 0
// 1
// 2
12, bạn cung cấp chức năng gọi lại được gọi với phần tử hiện tại và tùy chọn chỉ mục và mảng hiện tại và trả về một chuỗi chỉ ra nhóm của phần tử.Mã bên dưới sử dụng hàm mũi tên để trả về
console.log[years['2'] !== years['02']];
42 của mỗi phần tử mảng [điều này sử dụng cú pháp phá hủy đối tượng cho các đối số chức năng để giải nén phần tử console.log[years['2'] !== years['02']];
42 khỏi đối tượng được truyền]. Kết quả là một đối tượng có các thuộc tính được đặt tên theo các chuỗi duy nhất được trả về bởi cuộc gọi lại. Mỗi thuộc tính được gán một mảng chứa các phần tử trong nhóm.console.log[years['2'] !== years['02']];
5
Lưu ý rằng đối tượng được trả về tham chiếu các phần tử giống như mảng gốc [không phải bản sao sâu]. Thay đổi cấu trúc bên trong của các yếu tố này sẽ được phản ánh trong cả mảng gốc và đối tượng được trả về.
Ví dụ, nếu bạn không thể sử dụng chuỗi làm khóa làm khóa, nếu thông tin đến nhóm được liên kết với một đối tượng có thể thay đổi, thì thay vào đó bạn có thể sử dụng
console.log[arr.0]; // a syntax error
39. Điều này rất giống với console.log[years['2'] !== years['02']];
47 ngoại trừ việc nó nhóm các phần tử của mảng thành console.log[arr.0]; // a syntax error
40 có thể sử dụng giá trị tùy ý [đối tượng hoặc nguyên thủy] làm khóa.Tạo một mảng hai chiều
Sau đây tạo ra một bàn cờ như một chuỗi hai chiều. Động thái đầu tiên được thực hiện bằng cách sao chép
console.log[years['2'] !== years['02']];
49 trong console.log[years['2'] !== years['02']];
50 lên console.log[years['2'] !== years['02']];
51. Vị trí cũ tại console.log[years['2'] !== years['02']];
52 được làm trống.console.log[years['2'] !== years['02']];
6Đây là đầu ra:
console.log[years['2'] !== years['02']];
7Sử dụng một mảng để lập bảng một tập hợp các giá trị
console.log[years['2'] !== years['02']];
8Kết quả trong
console.log[years['2'] !== years['02']];
9Tạo một mảng bằng kết quả của một trận đấu
Kết quả của một trận đấu giữa
console.log[years['2'] !== years['02']];
53 và một chuỗi có thể tạo ra một mảng JavaScript có thuộc tính và phần tử cung cấp thông tin về trận đấu. Một mảng như vậy được trả về bởi console.log[years['2'] !== years['02']];
54 và console.log[years['2'] !== years['02']];
55.Ví dụ:
const fruits = [];
fruits.push['banana', 'apple', 'peach'];
console.log[fruits.length]; // 3
0Để biết thêm thông tin về kết quả của một trận đấu, hãy xem trang
console.log[years['2'] !== years['02']];
54 và console.log[years['2'] !== years['02']];
55.Thông số kỹ thuật
Đặc tả ngôn ngữ Ecmascript # sec-marray-expects # sec-array-objects |
Tính tương thích của trình duyệt web
Bảng BCD chỉ tải trong trình duyệt