Nếu bạn có một danh sách các mục [ví dụ: danh sách tên ô tô], việc lưu trữ ô tô trong các biến đơn lẻ có thể trông như thế này
let car1 = "Saab";
let car2 = "Volvo";
let car3 = "BMW";
Tuy nhiên, nếu bạn muốn đi vòng qua các ô tô và tìm một ô tô cụ thể thì sao?
Giải pháp là một mảng
Một mảng có thể chứa nhiều giá trị dưới một tên duy nhất và bạn có thể truy cập các giá trị bằng cách tham chiếu đến một số chỉ mục
Tạo một mảng
Sử dụng một mảng chữ là cách dễ nhất để tạo một mảng JavaScript
cú pháp
const tên_mảng = [mục1,mục2,. ];
Một thực tế phổ biến là khai báo mảng với từ khóa const
Tìm hiểu thêm về const với mảng trong chương. Mảng JS Const
Dấu cách và ngắt dòng không quan trọng. Một khai báo có thể trải rộng trên nhiều dòng
Bạn cũng có thể tạo một mảng rồi cung cấp các phần tử
Ví dụ
const cars = [];
cars[0]= "Saab";
cars[1]= "Volvo";
cars[2]= "BMW";
Sử dụng Từ khóa JavaScript mới
Ví dụ sau cũng tạo một Array và gán giá trị cho nó
Hai ví dụ trên làm hoàn toàn giống nhau
Không cần sử dụng new Array[]
Để đơn giản, dễ đọc và tốc độ thực thi, hãy sử dụng phương thức ký tự mảng
Truy cập các phần tử mảng
Bạn truy cập một phần tử mảng bằng cách tham khảo số chỉ mục
Ghi chú. Chỉ mục mảng bắt đầu bằng 0
[0] là phần tử đầu tiên. [1] là phần tử thứ hai
Thay đổi một phần tử mảng
Câu lệnh này thay đổi giá trị của phần tử đầu tiên trong cars
Truy cập toàn bộ mảng
Với JavaScript, toàn bộ mảng có thể được truy cập bằng cách tham khảo tên mảng
Ví dụ
const cars = ["Saab", "Volvo", "BMW"];
tài liệu. getElementById["bản trình diễn"]. innerHTML = ô tô;
Mảng là đối tượng
Mảng là một loại đối tượng đặc biệt. Toán tử typeof
trong JavaScript trả về "đối tượng" cho mảng
Tuy nhiên, mảng JavaScript được mô tả tốt nhất là mảng
Mảng sử dụng số để truy cập "phần tử" của nó. Trong ví dụ này, person[0]
trả về John
Các đối tượng sử dụng tên để truy cập "thành viên" của nó. Trong ví dụ này, person.firstName
trả về John
Các phần tử mảng có thể là đối tượng
Biến JavaScript có thể là đối tượng. Mảng là loại đối tượng đặc biệt
Do đó, bạn có thể có các biến thuộc các loại khác nhau trong cùng một Mảng
Bạn có thể có các đối tượng trong một Mảng. Bạn có thể có các chức năng trong một Mảng. Bạn có thể có các mảng trong một Mảng
Bạn sẽ truy cập một mảng trong một mảng như thế nào?
var newArray=[[180,true,”mặt trước”],[360,false,”mặt sau”],[540,true,”đảo ngược”]]; . log[newArray[0] ]; . log[newArray[1] ]; . log[newArray[2] ];
/Làm cách nào để bạn truy cập các mảng trong các mảng? . log[newArray[2[0]] ];
Phương thức
const arr1 = [1, 2, [3, 4]];
arr1.flat[];
// [1, 2, 3, 4]
const arr2 = [1, 2, [3, 4, [5, 6]]];
arr2.flat[];
// [1, 2, 3, 4, [5, 6]]
const arr3 = [1, 2, [3, 4, [5, 6]]];
arr3.flat[2];
// [1, 2, 3, 4, 5, 6]
const arr4 = [1, 2, [3, 4, [5, 6, [7, 8, [9, 10]]]]];
arr4.flat[Infinity];
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
0 tạo một mảng mới với tất cả các phần tử của mảng con được nối vào nó một cách đệ quy đến độ sâu đã chỉ địnhThử nó
cú pháp
flat[]
flat[depth]
Thông số
const arr1 = [1, 2, [3, 4]];
arr1.flat[];
// [1, 2, 3, 4]
const arr2 = [1, 2, [3, 4, [5, 6]]];
arr2.flat[];
// [1, 2, 3, 4, [5, 6]]
const arr3 = [1, 2, [3, 4, [5, 6]]];
arr3.flat[2];
// [1, 2, 3, 4, 5, 6]
const arr4 = [1, 2, [3, 4, [5, 6, [7, 8, [9, 10]]]]];
arr4.flat[Infinity];
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
1 Tùy chọnMức độ sâu chỉ định độ sâu của cấu trúc mảng lồng nhau sẽ được làm phẳng. Mặc định là 1
Giá trị trả về
Một mảng mới với các phần tử của mảng con được nối vào nó
Sự miêu tả
Phương pháp
const arr1 = [1, 2, [3, 4]];
arr1.flat[];
// [1, 2, 3, 4]
const arr2 = [1, 2, [3, 4, [5, 6]]];
arr2.flat[];
// [1, 2, 3, 4, [5, 6]]
const arr3 = [1, 2, [3, 4, [5, 6]]];
arr3.flat[2];
// [1, 2, 3, 4, 5, 6]
const arr4 = [1, 2, [3, 4, [5, 6, [7, 8, [9, 10]]]]];
arr4.flat[Infinity];
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
0 là một phương pháp sao chép. Nó không thay đổi const arr1 = [1, 2, [3, 4]];
arr1.flat[];
// [1, 2, 3, 4]
const arr2 = [1, 2, [3, 4, [5, 6]]];
arr2.flat[];
// [1, 2, 3, 4, [5, 6]]
const arr3 = [1, 2, [3, 4, [5, 6]]];
arr3.flat[2];
// [1, 2, 3, 4, 5, 6]
const arr4 = [1, 2, [3, 4, [5, 6, [7, 8, [9, 10]]]]];
arr4.flat[Infinity];
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
3 mà thay vào đó trả về một bản sao nông chứa các phần tử giống như các phần tử từ mảng ban đầuPhương thức
const arr1 = [1, 2, [3, 4]];
arr1.flat[];
// [1, 2, 3, 4]
const arr2 = [1, 2, [3, 4, [5, 6]]];
arr2.flat[];
// [1, 2, 3, 4, [5, 6]]
const arr3 = [1, 2, [3, 4, [5, 6]]];
arr3.flat[2];
// [1, 2, 3, 4, 5, 6]
const arr4 = [1, 2, [3, 4, [5, 6, [7, 8, [9, 10]]]]];
arr4.flat[Infinity];
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
0 bỏ qua các vị trí trống nếu mảng được làm phẳng thưa thớt. Ví dụ: nếu const arr1 = [1, 2, [3, 4]];
arr1.flat[];
// [1, 2, 3, 4]
const arr2 = [1, 2, [3, 4, [5, 6]]];
arr2.flat[];
// [1, 2, 3, 4, [5, 6]]
const arr3 = [1, 2, [3, 4, [5, 6]]];
arr3.flat[2];
// [1, 2, 3, 4, 5, 6]
const arr4 = [1, 2, [3, 4, [5, 6, [7, 8, [9, 10]]]]];
arr4.flat[Infinity];
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
1 là 1, thì cả hai vị trí trống trong mảng gốc và ở cấp đầu tiên của các mảng lồng nhau đều bị bỏ qua, nhưng các vị trí trống trong các mảng lồng nhau tiếp theo được giữ nguyên cùng với chính các mảng đóPhương pháp
const arr1 = [1, 2, [3, 4]];
arr1.flat[];
// [1, 2, 3, 4]
const arr2 = [1, 2, [3, 4, [5, 6]]];
arr2.flat[];
// [1, 2, 3, 4, [5, 6]]
const arr3 = [1, 2, [3, 4, [5, 6]]];
arr3.flat[2];
// [1, 2, 3, 4, 5, 6]
const arr4 = [1, 2, [3, 4, [5, 6, [7, 8, [9, 10]]]]];
arr4.flat[Infinity];
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
0 là chung chung. Nó chỉ mong đợi giá trị const arr1 = [1, 2, [3, 4]];
arr1.flat[];
// [1, 2, 3, 4]
const arr2 = [1, 2, [3, 4, [5, 6]]];
arr2.flat[];
// [1, 2, 3, 4, [5, 6]]
const arr3 = [1, 2, [3, 4, [5, 6]]];
arr3.flat[2];
// [1, 2, 3, 4, 5, 6]
const arr4 = [1, 2, [3, 4, [5, 6, [7, 8, [9, 10]]]]];
arr4.flat[Infinity];
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
3 có thuộc tính const arr1 = [1, 2, [3, 4]];
arr1.flat[];
// [1, 2, 3, 4]
const arr2 = [1, 2, [3, 4, [5, 6]]];
arr2.flat[];
// [1, 2, 3, 4, [5, 6]]
const arr3 = [1, 2, [3, 4, [5, 6]]];
arr3.flat[2];
// [1, 2, 3, 4, 5, 6]
const arr4 = [1, 2, [3, 4, [5, 6, [7, 8, [9, 10]]]]];
arr4.flat[Infinity];
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
2 và các thuộc tính có khóa số nguyên. Tuy nhiên, các phần tử của nó phải là mảng nếu chúng được làm phẳngví dụ
Làm phẳng các mảng lồng nhau
const arr1 = [1, 2, [3, 4]];
arr1.flat[];
// [1, 2, 3, 4]
const arr2 = [1, 2, [3, 4, [5, 6]]];
arr2.flat[];
// [1, 2, 3, 4, [5, 6]]
const arr3 = [1, 2, [3, 4, [5, 6]]];
arr3.flat[2];
// [1, 2, 3, 4, 5, 6]
const arr4 = [1, 2, [3, 4, [5, 6, [7, 8, [9, 10]]]]];
arr4.flat[Infinity];
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Sử dụng phẳng[] trên các mảng thưa thớt
Phương thức
const arr1 = [1, 2, [3, 4]];
arr1.flat[];
// [1, 2, 3, 4]
const arr2 = [1, 2, [3, 4, [5, 6]]];
arr2.flat[];
// [1, 2, 3, 4, [5, 6]]
const arr3 = [1, 2, [3, 4, [5, 6]]];
arr3.flat[2];
// [1, 2, 3, 4, 5, 6]
const arr4 = [1, 2, [3, 4, [5, 6, [7, 8, [9, 10]]]]];
arr4.flat[Infinity];
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
0 loại bỏ các ô trống trong mảngconst arr5 = [1, 2, , 4, 5];
console.log[arr5.flat[]]; // [1, 2, 4, 5]
const array = [1, , 3, ["a", , "c"]];
console.log[array.flat[]]; // [ 1, 3, "a", "c" ]
const array2 = [1, , 3, ["a", , ["d", , "e"]]];
console.log[array2.flat[]]; // [ 1, 3, "a", ["d", empty, "e"] ]
console.log[array2.flat[2]]; // [ 1, 3, "a", "d", "e"]
Gọi phẳng[] trên các đối tượng không phải mảng
Phương thức
const arr1 = [1, 2, [3, 4]];
arr1.flat[];
// [1, 2, 3, 4]
const arr2 = [1, 2, [3, 4, [5, 6]]];
arr2.flat[];
// [1, 2, 3, 4, [5, 6]]
const arr3 = [1, 2, [3, 4, [5, 6]]];
arr3.flat[2];
// [1, 2, 3, 4, 5, 6]
const arr4 = [1, 2, [3, 4, [5, 6, [7, 8, [9, 10]]]]];
arr4.flat[Infinity];
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
0 đọc thuộc tính const arr1 = [1, 2, [3, 4]];
arr1.flat[];
// [1, 2, 3, 4]
const arr2 = [1, 2, [3, 4, [5, 6]]];
arr2.flat[];
// [1, 2, 3, 4, [5, 6]]
const arr3 = [1, 2, [3, 4, [5, 6]]];
arr3.flat[2];
// [1, 2, 3, 4, 5, 6]
const arr4 = [1, 2, [3, 4, [5, 6, [7, 8, [9, 10]]]]];
arr4.flat[Infinity];
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
2 của const arr1 = [1, 2, [3, 4]];
arr1.flat[];
// [1, 2, 3, 4]
const arr2 = [1, 2, [3, 4, [5, 6]]];
arr2.flat[];
// [1, 2, 3, 4, [5, 6]]
const arr3 = [1, 2, [3, 4, [5, 6]]];
arr3.flat[2];
// [1, 2, 3, 4, 5, 6]
const arr4 = [1, 2, [3, 4, [5, 6, [7, 8, [9, 10]]]]];
arr4.flat[Infinity];
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
3 và sau đó truy cập từng chỉ mục số nguyên. Nếu phần tử không phải là một mảng, nó sẽ được thêm trực tiếp vào kết quả. Nếu phần tử là một mảng, nó sẽ được làm phẳng theo tham số const arr1 = [1, 2, [3, 4]];
arr1.flat[];
// [1, 2, 3, 4]
const arr2 = [1, 2, [3, 4, [5, 6]]];
arr2.flat[];
// [1, 2, 3, 4, [5, 6]]
const arr3 = [1, 2, [3, 4, [5, 6]]];
arr3.flat[2];
// [1, 2, 3, 4, 5, 6]
const arr4 = [1, 2, [3, 4, [5, 6, [7, 8, [9, 10]]]]];
arr4.flat[Infinity];
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
1