programming javascript

Biến javascript có thể là mảng không?

Trong JavaScript, mảng là một trong những kiểu dữ liệu được sử dụng phổ biến nhất. Nó lưu trữ nhiều giá trị và phần tử trong một biến

Các giá trị này có thể thuộc bất kỳ loại dữ liệu nào — nghĩa là bạn có thể lưu trữ một chuỗi, số, boolean và các loại dữ liệu khác trong một biến

Có hai cách tiêu chuẩn để khai báo một mảng trong JavaScript. Đây là thông qua hàm tạo mảng hoặc ký hiệu bằng chữ

Trong trường hợp bạn đang vội, đây là cách một mảng được khai báo theo cả hai cách

// Using array constructor
let array = new array["John Doe", 24, true];

// Using the literal notation
let array = ["John Doe", 24, true];

Bạn có thể tiếp tục đọc bài viết này để hiểu đúng các phương pháp này cùng với một số tùy chọn thú vị khác mà chúng sở hữu

Cách khai báo một mảng bằng ký hiệu chữ

Đây là cách phổ biến nhất và dễ nhất để tạo một mảng. Đó là cách khai báo mảng ngắn gọn và rõ ràng hơn

Để khai báo một mảng với ký hiệu bằng chữ, bạn chỉ cần xác định một mảng mới bằng cách sử dụng dấu ngoặc rỗng. Nó trông như thế này

let myArray = [];

Bạn sẽ đặt tất cả các phần tử trong dấu ngoặc vuông và phân tách từng mục hoặc phần tử bằng dấu phẩy

let myArray = ["John Doe", 24, true];

Mảng được lập chỉ mục bằng 0, nghĩa là bạn có thể truy cập từng phần tử bắt đầu từ 0 hoặc xuất toàn bộ mảng

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]

Cách khai báo một mảng với Array Constructor

Bạn cũng có thể sử dụng hàm tạo mảng để tạo hoặc khai báo một mảng. Có rất nhiều kỹ thuật để khai báo một mảng với hàm tạo 

let myArray = [];
0

Giống như bạn có thể lưu trữ nhiều giá trị với các kiểu dữ liệu đa dạng trong một biến bằng ký hiệu mảng, bạn có thể làm tương tự với hàm tạo mảng

let myArray = new Array[];
console.log[myArray]; // []

Ở trên sẽ tạo ra một mảng trống mới. Bạn có thể thêm các giá trị vào mảng mới bằng cách đặt chúng vào giữa các dấu ngoặc, cách nhau bởi dấu phẩy

let myArray = new Array["John Doe", 24, true];

Giống như bạn đã học trước đó, bạn có thể truy cập từng giá trị bằng cách sử dụng số chỉ mục của nó, bắt đầu từ số không [0]

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]

Khi khai báo mảng bằng phương thức khởi tạo mảng, điều quan trọng là phải ghi nhớ những điều sau

  • Khi bạn chuyển một chữ số vào hàm tạo mảng, nó sẽ lấp đầy mảng bằng số lượng giá trị trống mà bạn đã nhập
________số 8

Nhưng khi bạn chuyển một chuỗi hoặc bất kỳ loại dữ liệu nào khác, nó sẽ hoạt động tốt

let myArray = new Array[true];
console.log[myArray]; // [true]
  • Không bắt buộc phải thêm 
    let myArray = [];
    1, vì cả 
    let myArray = [];
    0 và 
    let myArray = [];
    3 đều thực hiện cùng một nhiệm vụ
let myArray = [];
3

kết thúc

Trong bài viết này, bạn đã học cách khai báo một mảng trong JavaScript. Điều quan trọng cần biết là hàm tạo mảng không thực sự được sử dụng, vì nó phức tạp hơn nhiều so với việc sử dụng ký hiệu mảng

Bạn có thể tìm hiểu thêm trong bài viết này về Mảng JavaScript - Cách tạo một mảng trong JavaScript của Jessica Wilkins

Chúc các bạn code vui vẻ

QUẢNG CÁO

QUẢNG CÁO

QUẢNG CÁO

Joel Olawanle

Nhà phát triển Frontend & Người viết kỹ thuật

Nếu bạn đọc đến đây, hãy tweet cho tác giả để cho họ thấy bạn quan tâm. Tweet một lời cảm ơn

Học cách viết mã miễn phí. Chương trình giảng dạy mã nguồn mở của freeCodeCamp đã giúp hơn 40.000 người có được việc làm với tư cách là nhà phát triển. Bắt đầu

JavaScript là một con thú tinh tế. Nó có thể là người bạn tốt nhất của chúng tôi trong một khoảnh khắc và kẻ thù tồi tệ nhất của chúng tôi tiếp theo. Mối quan hệ phức tạp này là một chuyến tàu lượn siêu tốc đầy cảm xúc, nhưng nó xứng đáng với những đặc quyền thú vị

Đối tượng 

let myArray = [];
49, giống như mảng trong các ngôn ngữ lập trình khác, cho phép lưu trữ một tập hợp nhiều mục dưới một tên biến duy nhất và có các thành viên cho

Trong JavaScript, mảng không phải là nguyên thủy mà thay vào đó là đối tượng 

let myArray = [];
49 với các đặc điểm cốt lõi sau

  • Mảng JavaScript có thể thay đổi kích thước và có thể chứa kết hợp các loại dữ liệu khác nhau. [Khi những đặc điểm đó là không mong muốn, thay vào đó hãy sử dụng các mảng đã nhập. ]
  • Mảng JavaScript không phải là mảng kết hợp và do đó, không thể truy cập các phần tử mảng bằng cách sử dụng chuỗi tùy ý làm chỉ mục mà phải được truy cập bằng cách sử dụng số nguyên không âm [hoặc dạng chuỗi tương ứng của chúng] làm chỉ mục
  • Các mảng JavaScript không được lập chỉ mục. phần tử đầu tiên của một mảng nằm ở chỉ mục 
    let myArray = [];
    61, phần tử thứ hai ở chỉ mục 
    let myArray = [];
    62, v.v. — và phần tử cuối cùng ở giá trị của thuộc tính 
    let myArray = [];
    63 của mảng trừ đi 
    let myArray = [];
    62
  • JavaScript tạo bản sao nông. [Tất cả các thao tác sao chép tích hợp sẵn tiêu chuẩn với bất kỳ đối tượng JavaScript nào đều tạo ra các bản sao nông, thay vì các bản sao sâu]

Các đối tượng 

let myArray = [];
49 không thể sử dụng các chuỗi tùy ý làm chỉ mục phần tử [như trong một mảng kết hợp] mà 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]. Việc đặt hoặc truy cập thông qua các số không phải là số nguyên 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 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à không thể áp dụng các thuộc tính của mảng cho các thuộc tính đã đặ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 mà 

let myArray = [];
66 là một thuộc tính [tuy nhiên, để cụ thể, 
let myArray = [];
67 là một phương thức]. Tuy nhiên, cố gắng truy cập một phần tử của mảng như sau sẽ gây ra lỗi cú pháp vì tên thuộc tính không hợp lệ

let myArray = ["John Doe", 24, true];
3

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 cách sử dụng thay vì ký hiệu dấu chấm. Cũng có thể trích dẫn các chỉ số mảng [e. g. , 

let myArray = [];
68 thay vì 
let myArray = [];
69], mặc dù thường không cần thiết

let myArray = ["John Doe", 24, true];
60 trong 
let myArray = [];
69 được công cụ JavaScript ép buộc thành một chuỗi thông qua chuyển đổi ngầm định 
let myArray = [];
66. Kết quả là, 
let myArray = ["John Doe", 24, true];
63 và 
let myArray = ["John Doe", 24, true];
64 sẽ đề cập đến hai vị trí khác nhau trên đối tượng 
let myArray = ["John Doe", 24, true];
65 và ví dụ sau đây có thể là 
let myArray = ["John Doe", 24, true];
66

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
3

Chỉ 

let myArray = [];
68 là một chỉ số mảng thực tế. 
let myArray = ["John Doe", 24, true];
68 là một thuộc tính chuỗi tùy ý sẽ không được truy cập trong phép lặp mảng

Thuộc tính 

let myArray = [];
63 và thuộc tính số của một mảng JavaScript được kết nối

Một số phương thức mảng tích hợp sẵn [e. g. , 

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
70, 
console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
71, 
console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
72, v.v. ] tính đến giá trị của thuộc tính 
let myArray = [];
63 của mảng khi chúng được gọi

Các phương pháp khác [e. g. , 

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
74, 
console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
75, v.v. ] cũng dẫn đến cập nhật thuộc tính 
let myArray = [];
63 của mảng

let myArray = [];
4

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, công cụ sẽ cập nhật thuộc tính 

let myArray = [];
63 của mảng tương ứng

let myArray = [];
4

Tăng 

let myArray = [];
63

let myArray = [];
6

Tuy nhiên, việc giảm thuộc tính 

let myArray = [];
63 sẽ xóa các phần tử

let myArray = ["John Doe", 24, true];
6

Điều này được giải thích thêm trên trang 

let myArray = new Array[];
console.log[myArray]; // []
10

Các vị trí trống hoạt động không nhất quán giữa các phương thức mảng. Nói chung, các phương thức cũ hơn sẽ bỏ qua các vị trí trống, trong khi các phương thức mới hơn coi chúng là 

let myArray = new Array[];
console.log[myArray]; // []
11

Trong số các phương thức lặp qua nhiều phần tử, các phương thức sau đây thực hiện kiểm tra 

let myArray = new Array[];
console.log[myArray]; // []
12 trước khi truy cập chỉ mục và không kết hợp các vị trí trống với 
let myArray = new Array[];
console.log[myArray]; // []
11

  • let myArray = new Array[];
console.log[myArray]; // []
    14
  • let myArray = new Array[];
console.log[myArray]; // []
    15
  • let myArray = new Array[];
console.log[myArray]; // []
    16
  • let myArray = new Array[];
console.log[myArray]; // []
    17
  • let myArray = new Array[];
console.log[myArray]; // []
    18
  • let myArray = new Array[];
console.log[myArray]; // []
    19
  • let myArray = new Array["John Doe", 24, true];
    10
  • console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
    72
  • let myArray = new Array["John Doe", 24, true];
    12
  • let myArray = new Array["John Doe", 24, true];
    13
  • let myArray = new Array["John Doe", 24, true];
    14
  • let myArray = new Array["John Doe", 24, true];
    15
  • let myArray = new Array["John Doe", 24, true];
    16
  • console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
    71
  • let myArray = new Array["John Doe", 24, true];
    18
  • let myArray = new Array["John Doe", 24, true];
    19
  • console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
    75

Để biết chính xác cách họ xử lý các vị trí trống, hãy xem trang cho từng phương pháp

Các phương pháp này xử lý các vị trí trống như thể chúng là 

let myArray = new Array[];
console.log[myArray]; // []
11

  • console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
    32
  • console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
    33
  • console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
    34
  • console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
    35
  • console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
    36
  • console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
    37
  • console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
    38 Thử nghiệm
  • console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
    39 Thử nghiệm
  • console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
    300
  • console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
    70
  • console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
    302
  • console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
    303
  • console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
    304

Một số phương thức không thay đổi mảng hiện có mà phương thức được gọi, mà thay vào đó trả về một mảng mới. Họ làm như vậy bằng cách truy cập đầu tiên vào 

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
305 để xác định hàm tạo sẽ sử dụng cho mảng mới. Mảng mới được xây dựng sau đó được phổ biến với các phần tử. Sao chép luôn xảy ra một cách nông cạn — phương thức không bao giờ sao chép bất kỳ thứ gì ngoài mảng được tạo ban đầu. Các phần tử của [các] mảng ban đầu được sao chép vào mảng mới như sau

  • Các đối tượng. tham chiếu đối tượng được sao chép vào mảng mới. Cả mảng ban đầu và mảng mới đều đề cập đến cùng một đối tượng. Nghĩa là, nếu một đối tượng được tham chiếu được sửa đổi, các thay đổi sẽ hiển thị đối với cả mảng mới và mảng ban đầu
  • Các loại nguyên thủy như chuỗi, số và boolean [không phải đối tượng 
    console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
    306, 
    console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
    307 và 
    console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
    308]. giá trị của chúng được sao chép vào mảng mới

Các phương thức khác thay đổi mảng mà phương thức được gọi, trong trường hợp đó, giá trị trả về của chúng sẽ khác nhau tùy thuộc vào phương thức. đôi khi là tham chiếu đến cùng một mảng, đôi khi là độ dài của mảng mới

Các phương pháp sau tạo mảng mới với 

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
309

  • let myArray = new Array[];
console.log[myArray]; // []
    14
  • let myArray = new Array[];
console.log[myArray]; // []
    17
  • let myArray = new Array[];
console.log[myArray]; // []
    18
  • let myArray = new Array[];
console.log[myArray]; // []
    19
  • let myArray = new Array["John Doe", 24, true];
    13
  • console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
    71
  • console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
    75 [để xây dựng mảng các phần tử đã loại bỏ được trả về]

Lưu ý rằng 

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
38 và 
console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
39 không sử dụng 
console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
309 để tạo mảng mới cho mỗi mục nhập nhóm mà luôn sử dụng hàm tạo 
let myArray = [];
49 đơn giản. Về mặt khái niệm, chúng cũng không phải là phương pháp sao chép

Các phương pháp sau đây thay đổi mảng ban đầu

  • let myArray = new Array[];
console.log[myArray]; // []
    15
  • console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
    33
  • console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
    323
  • console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
    74
  • let myArray = new Array["John Doe", 24, true];
    16
  • console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
    326
  • let myArray = new Array["John Doe", 24, true];
    19
  • console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
    75
  • console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
    329

Nhiều phương thức mảng lấy hàm gọi lại làm đối số. Hàm gọi lại được gọi 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ả đều có chung chữ ký

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
7

Trường hợp 

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
330 có ba đối số

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
331

Phần tử hiện tại đang được xử lý trong mảng

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
332

Chỉ số của phần tử hiện tại đang được xử lý trong mảng

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
333

Mảng mà phương thức được gọi

Giá trị mà 

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
330 dự kiến ​​sẽ trả về phụ thuộc vào phương thức mảng được gọi

Đối số 

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
335 [mặc định là 
let myArray = new Array[];
console.log[myArray]; // []
11] sẽ được sử dụng làm giá trị 
console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
337 khi gọi 
console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
330. Giá trị 
console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
337 cuối cùng có thể quan sát được bởi 
console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
330 được xác định theo các quy tắc thông thường. nếu 
console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
330 là , các giá trị nguyên thuỷ của 
console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
337 được bao bọc trong các đối tượng và 
let myArray = new Array[];
console.log[myArray]; // []
11/
console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
344 được thay thế bằng 
console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
345. Đối số 
console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
335 không liên quan đối với bất kỳ 
console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
330 nào được xác định bằng hàm mũi tên, vì các hàm mũi tên không có ràng buộc 
console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
337 của riêng chúng

Tất cả các phương thức lặp là và , mặc dù chúng hoạt động khác với

Các phương pháp sau đây là lặp đi lặp lại

  • let myArray = new Array[];
console.log[myArray]; // []
    16
  • let myArray = new Array[];
console.log[myArray]; // []
    17
  • console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
    34
  • console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
    35
  • console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
    36
  • console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
    37
  • let myArray = new Array[];
console.log[myArray]; // []
    19
  • let myArray = new Array["John Doe", 24, true];
    10
  • console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
    38
  • console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
    39
  • let myArray = new Array["John Doe", 24, true];
    13
  • let myArray = new Array["John Doe", 24, true];
    18

Đặc biệt, 

let myArray = new Array[];
console.log[myArray]; // []
16, 
console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
34, 
console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
35, 
console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
36, 
console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
37 và 
let myArray = new Array["John Doe", 24, true];
18 không phải lúc nào cũng gọi 
console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
330 trên mọi phần tử — chúng dừng lặp lại ngay khi giá trị trả về được xác định

Có hai phương thức khác nhận hàm gọi lại và chạy hàm đó nhiều nhất một lần cho mỗi phần tử trong mảng, nhưng chúng có các dấu hiệu hơi khác so với các phương thức lặp điển hình [ví dụ: chúng không chấp nhận 

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
335]

  • let myArray = new Array["John Doe", 24, true];
    14
  • let myArray = new Array["John Doe", 24, true];
    15

Phương thức 

let myArray = new Array["John Doe", 24, true];
19 cũng có chức năng gọi lại, nhưng nó không phải là phương thức lặp. Nó thay đổi mảng tại chỗ, không chấp nhận 
console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
335 và có thể gọi lại nhiều lần trên một chỉ mục

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 

let myArray = [];
63 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

let myArray = new Array[];
console.log[myArray]; // []
1

Chuẩn hóa thuộc tính độ dài

Thuộc tính 

let myArray = [];
63 được và sau đó được kẹp vào phạm vi từ 0 đến 253 - 1. 
console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
375 trở thành 
let myArray = [];
61, vì vậy ngay cả khi không có 
let myArray = [];
63 hoặc là 
let myArray = new Array[];
console.log[myArray]; // []
11, nó vẫn hoạt động như thể nó có giá trị 
let myArray = [];
61

let myArray = new Array["John Doe", 24, true];
1

Một số phương thức mảng thiết lập thuộc tính 

let myArray = [];
63 của đối tượng mảng. Họ luôn đặt giá trị sau khi chuẩn hóa, vì vậy, 
let myArray = [];
63 luôn kết thúc dưới dạng số nguyên

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
3

Các đối tượng giống như mảng

Thuật ngữ đề cập đến bất kỳ đối tượng nào không ném trong quá trình chuyển đổi 

let myArray = [];
63 được mô tả ở trên. Trong thực tế, đối tượng như vậy được cho là thực sự có thuộc tính 
let myArray = [];
63 và có các phần tử được lập chỉ mục trong phạm vi từ 
let myArray = [];
61 đến 
console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
385. [Nếu nó không có tất cả các chỉ số, nó sẽ có chức năng tương đương với một. ]

Nhiều đối tượng DOM giống như mảng — ví dụ: 

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
386 và 
console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
387. Đối tượng 
console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
388 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 bản thân chúng không có các phương thức này

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
30

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
389

Tạo một đối tượng 

let myArray = [];
49 mới

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
391

Trả về hàm tạo 

let myArray = [];
49

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
393

Tạo một thể hiện 

let myArray = [];
49 mới từ một đối tượng dạng mảng hoặc đối tượng có thể lặp lại

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
395

Trả về 

let myArray = ["John Doe", 24, true];
66 nếu đối số là một mảng hoặc 
console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
397 nếu không thì

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
398

Tạo một phiên bản 

let myArray = [];
49 mới với số lượng đối số thay đổi, bất kể số lượng hoặc loại đối số

let myArray = [];
400

Phản ánh số lượng phần tử trong một mảng

let myArray = [];
401

Chứa các tên thuộc tính không có trong tiêu chuẩn ECMAScript trước phiên bản ES2015 và được bỏ qua cho mục đích ràng buộc câu lệnh 

let myArray = [];
402

let myArray = [];
403

Trả về mục mảng tại chỉ mục đã cho. Chấp nhận số nguyên âm, đếm ngược từ mục cuối cùng

let myArray = [];
404

Trả về một mảng mới là mảng đang gọi được nối với [các] mảng và/hoặc [các] giá trị khác

let myArray = [];
405

Sao chép một chuỗi các phần tử mảng trong một mảng

let myArray = [];
406

Trả về một đối tượng trình 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

let myArray = [];
407

Trả về 

let myArray = ["John Doe", 24, true];
66 nếu mọi phần tử trong mảng đang gọi thỏa mãn chức năng kiểm tra

let myArray = [];
409

Đ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 đến chỉ mục kết thúc với một giá trị tĩnh

let myArray = [];
410

Trả về một mảng mới chứa tất cả các phần tử của mảng đang gọi mà hàm lọc được cung cấp trả về 

let myArray = ["John Doe", 24, true];
66

let myArray = [];
412

Trả về giá trị của phần tử đầu tiên trong mảng thỏa mãn chức năng kiểm tra được cung cấp hoặc 

let myArray = new Array[];
console.log[myArray]; // []
11 nếu không tìm thấy phần tử phù hợp

let myArray = [];
414

Trả về chỉ mục của phần tử đầu tiên trong mảng thỏa mãn chức năng kiểm tra được cung cấp hoặc 

let myArray = [];
415 nếu không tìm thấy phần tử phù hợp

let myArray = [];
416

Trả về giá trị của phần tử cuối cùng trong mảng thỏa mãn chức năng kiểm tra được cung cấp hoặc 

let myArray = new Array[];
console.log[myArray]; // []
11 nếu không tìm thấy phần tử phù hợp

let myArray = [];
418

Trả về chỉ mục của phần tử cuối cùng trong mảng thỏa mãn chức năng kiểm tra được cung cấp hoặc 

let myArray = [];
415 nếu không tìm thấy phần tử phù hợp

let myArray = [];
420

Trả về 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ó theo cách đệ quy cho đến độ sâu đã chỉ định

let myArray = [];
421

Trả về một mảng mới được hình thành bằng cách áp dụng hàm gọi lại đã cho cho từng phần tử của mảng đang gọi, sau đó làm phẳng kết quả theo một cấp

let myArray = [];
422

Gọi một hàm cho từng phần tử trong mảng gọi

______4423 Thử nghiệm

Nhó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 hàm kiểm tra

______4424 Thử nghiệm

Nhóm các phần tử của một mảng thành một 

let myArray = [];
425 theo các giá trị được trả về bởi hàm kiểm tra

let myArray = [];
426

Xác định xem mảng đang gọi có chứa giá trị hay không, trả về 

let myArray = ["John Doe", 24, true];
66 hoặc 
console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
397 nếu thích hợp

let myArray = [];
429

Trả về chỉ mục đầu tiên [ít nhất] mà tại đó có thể tìm thấy một phần tử đã cho trong mảng đang gọi

let myArray = [];
430

Nối tất cả các phần tử của một mảng thành một chuỗi

let myArray = [];
431

Trả về một trình vòng lặp mảng mới chứa các khóa cho mỗi chỉ mục trong mảng đang gọi

let myArray = [];
432

Trả về chỉ mục cuối cùng [lớn nhất] mà tại đó có thể tìm thấy một phần tử đã cho trong mảng đang gọi hoặc 

let myArray = [];
415 nếu không tìm thấy phần tử nào

let myArray = [];
434

Trả về một mảng mới chứa kết quả của việc gọi một hàm trên mọi phần tử trong mảng đang gọi

let myArray = [];
435

Loại bỏ phần tử cuối cùng khỏi một mảng và trả về phần tử đó

let myArray = [];
436

Thêm một hoặc nhiều phần tử vào cuối một mảng và trả về 

let myArray = [];
63 mới của mảng

let myArray = [];
438

Thực thi hàm gọi lại "reducer" do người dùng cung cấp trên từng phần tử của mảng [từ trái sang phải], để giảm nó thành một giá trị

let myArray = [];
439

Thực thi chức năng gọi lại "reducer" do người dùng cung cấp trên từng phần tử của mảng [từ phải sang trái], để giảm nó thành một giá trị

let myArray = [];
440

Đảo ngược thứ tự của các phần tử của một mảng tại chỗ. [Đầu tiên trở thành cuối cùng, cuối cùng trở thành đầu tiên. ]

let myArray = [];
441

Loại bỏ phần tử đầu tiên khỏi một mảng và trả về phần tử đó

let myArray = [];
442

Trích xuất một phần của mảng đang gọi và trả về một mảng mới

let myArray = [];
443

Trả về 

let myArray = ["John Doe", 24, true];
66 nếu ít nhất một phần tử trong mảng gọi đáp ứng chức năng kiểm tra được cung cấp

let myArray = [];
445

Sắp xếp các phần tử của một mảng tại chỗ và trả về mảng

let myArray = [];
446

Thêm và/hoặc xóa phần tử khỏi mảng

let myArray = [];
447

Trả về một chuỗi được bản địa hóa đại diện cho mảng đang gọi và các phần tử của nó. Ghi đè phương thức 

let myArray = [];
448

let myArray = [];
449

Trả về một chuỗi đại diện cho mảng đang gọi và các phần tử của nó. Ghi đè phương thức 

let myArray = [];
450

let myArray = [];
451

Thêm một hoặc nhiều phần tử vào phía trước của một mảng và trả về 

let myArray = [];
63 mới của mảng

let myArray = [];
453

Trả về một đối tượng trình lặp mảng mới chứa các giá trị cho từng chỉ mục trong mảng

let myArray = [];
454

Bí danh cho phương thức 

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
304 theo mặc định

Phần này cung cấp một số ví dụ về hoạt động mảng phổ biến trong JavaScript

Ghi chú. Nếu bạn chưa quen với kiến ​​thức cơ bản về mảng, trước tiên hãy cân nhắc đọc JavaScript First Steps. Mảng, which và bao gồm các ví dụ khác về hoạt động mảng phổ biến

Ví dụ này cho thấy ba cách để tạo mảng mới. đầu tiên sử dụng , sau đó sử dụng hàm tạo 

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
389 và cuối cùng sử dụng 
let myArray = [];
457 để tạo mảng từ một chuỗi

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
31

Ví dụ này sử dụng phương thức 

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
70 để tạo một chuỗi từ mảng 
let myArray = [];
459

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
32

Ví dụ này cho thấy cách truy cập các mục trong mảng 

let myArray = [];
459 bằng cách chỉ định số chỉ mục của vị trí của chúng trong mảng

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
33

Ví dụ này sử dụng phương thức 

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
72 để tìm vị trí [chỉ số] của chuỗi 
let myArray = [];
462 trong mảng 
let myArray = [];
459

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
34

Ví dụ này chỉ ra hai cách để kiểm tra xem mảng 

let myArray = [];
459 có chứa 
let myArray = [];
462 và 
let myArray = [];
466 hay không. đầu tiên với phương pháp 
console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
300, sau đó với phương pháp 
console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
72 để kiểm tra giá trị chỉ mục không phải là 
let myArray = [];
415

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
35

Ví dụ này sử dụng phương thức 

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
74 để nối một chuỗi mới vào mảng 
let myArray = [];
459

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
36

Ví dụ này sử dụng phương thức 

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
323 để xóa mục cuối cùng khỏi mảng 
let myArray = [];
459

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
37

Ghi chú. 

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
323 chỉ có thể được sử dụng để xóa mục cuối cùng khỏi một mảng. Để xóa nhiều mục khỏi phần cuối của một mảng, hãy xem ví dụ tiếp theo

Ví dụ này sử dụng phương pháp 

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
75 để xóa 3 mục cuối cùng khỏi mảng 
let myArray = [];
459

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
38

Ví dụ này sử dụng phương thức 

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
75 để cắt bớt mảng 
let myArray = [];
459 xuống chỉ còn 2 mục đầu tiên của nó

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
39

Ví dụ này sử dụng phương thức 

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
326 để xóa mục đầu tiên khỏi mảng 
let myArray = [];
459

let myArray = [];
40

Ghi chú. Chỉ có thể sử dụng 

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
326 để xóa mục đầu tiên khỏi mảng. Để xóa nhiều mục khỏi đầu một mảng, hãy xem ví dụ tiếp theo

Ví dụ này sử dụng phương thức 

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
75 để xóa 3 mục đầu tiên khỏi mảng 
let myArray = [];
459

let myArray = [];
41

Ví dụ này sử dụng phương thức 

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
329 để thêm, tại chỉ mục 
let myArray = [];
61, một mục mới vào mảng 
let myArray = [];
459 — biến nó thành mục đầu tiên mới trong mảng

let myArray = [];
42

Ví dụ này sử dụng phương thức 

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
75 để xóa chuỗi 
let myArray = [];
462 khỏi mảng 
let myArray = [];
459 — bằng cách chỉ định vị trí chỉ mục của 
let myArray = [];
462

let myArray = [];
43

Ví dụ này sử dụng phương pháp 

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
75 để xóa các chuỗi 
let myArray = [];
462 và 
let myArray = [];
493 khỏi mảng 
let myArray = [];
459 — bằng cách chỉ định vị trí chỉ mục của 
let myArray = [];
462, cùng với số lượng tổng số mục cần xóa

let myArray = [];
44

Ví dụ này sử dụng phương thức 

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
75 để thay thế 2 mục cuối cùng trong mảng 
let myArray = [];
459 bằng các mục mới

let myArray = [];
45

Ví dụ này sử dụng vòng lặp 

let myArray = [];
498 để lặp qua mảng 
let myArray = [];
459, ghi từng mục vào bảng điều khiển

let myArray = [];
46

Nhưng 

let myArray = [];
498 chỉ là một trong nhiều cách để lặp qua bất kỳ mảng nào;

Ví dụ này sử dụng phương thức 

let myArray = new Array["John Doe", 24, true];
10 để gọi một hàm trên từng phần tử trong mảng 
let myArray = [];
459; 

let myArray = [];
47

Ví dụ này sử dụng phương thức 

let myArray = new Array[];
console.log[myArray]; // []
14 để hợp nhất mảng 
let myArray = [];
459 với mảng 
let myArray = [];
412, để tạo ra mảng 
let myArray = [];
413 mới. Lưu ý rằng 
let myArray = [];
459 và 
let myArray = [];
412 không thay đổi

let myArray = [];
48

Ví dụ này cho thấy ba cách để tạo một mảng mới từ mảng 

let myArray = [];
459 hiện có. đầu tiên bằng cách sử dụng cú pháp trải rộng, sau đó bằng cách sử dụng phương pháp 
let myArray = [];
417, sau đó bằng cách sử dụng phương pháp 
console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
71

let myArray = [];
49

Tất cả các hoạt động sao chép mảng tích hợp [cú pháp trải rộng, 

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
393, 
let myArray = [];
442 và 
let myArray = [];
404] 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 
let myArray = [];
422 để chuyển đổi mảng thành chuỗi JSON, sau đó sử dụng 
let myArray = [];
423 để 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 ban đầu

let myArray = [];
40

Bạn cũng có thể tạo các bản sao sâu bằng cách sử dụng phương pháp 

let myArray = [];
424, phương pháp này có ưu điểm là cho phép các đối tượng có thể chuyển nhượng trong nguồn được chuyển sang bản sao mới, thay vì chỉ được sao chép

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 ban đầu; . Do đó, nếu bạn thực hiện bất kỳ thay đổi nào đối với giá trị của mảng ban đầu hoặc giá trị của biến mới, thì biến kia cũng sẽ thay đổi theo.

let myArray = [];
41

Các phương thức 

let myArray = [];
423 có thể được sử dụng để nhóm các phần tử của một mảng, sử dụng hàm kiểm tra trả về một chuỗi cho biết nhóm của phần tử hiện tại

Ở đây chúng ta có một mảng hàng tồn kho đơn giản chứa các đối tượng "thực phẩm" có 

let myArray = [];
426 và 
let myArray = [];
427

let myArray = [];
42

Để sử dụng 

console.log[myArray[0]]; // 'John Doe'
console.log[myArray[2]]; // true
console.log[myArray]; // ['John Doe', 24, true]
38, bạn cung cấp một hàm 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, đồng thời trả về một chuỗi cho biết nhóm của phần tử

Mã bên dưới sử dụng hàm mũi tên để trả về 

let myArray = [];
427 của mỗi phần tử mảng [điều này sử dụng để giải nén phần tử 
let myArray = [];
427 khỏi đối tượng đã 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 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

let myArray = [];
43

Lưu ý rằng đối tượng được trả về tham chiếu các phần tử giống như mảng ban đầu [không phải bản sao sâu]. Việc thay đổi cấu trúc bên trong của các phần tử này sẽ được phản ánh trong cả mảng ban đầu và đối tượng được trả về

Ví dụ: nếu bạn không thể sử dụng một chuỗi làm khóa, nếu thông tin cần nhóm được liên kết với một đối tượng có thể thay đổi, thì bạn có thể sử dụng 

let myArray = [];
424 để thay thế. Điều này rất giống với 
let myArray = [];
432 ngoại trừ việc nó nhóm các phần tử của mảng thành một 
let myArray = [];
425 có thể sử dụng một giá trị tùy ý [đối tượng hoặc nguyên thủy] làm khóa

Sau đây tạo một bàn cờ dưới dạng một chuỗi hai chiều. Bước đầu tiên được thực hiện bằng cách sao chép 

let myArray = [];
434 trong 
let myArray = [];
435 sang 
let myArray = [];
436. Vị trí cũ tại 
let myArray = [];
437 được để trống

let myArray = [];
44

Đây là đầu ra

let myArray = [];
45

let myArray = [];
46

Kết quả trong

let myArray = [];
47

Kết quả của sự trùng khớp giữa một 

let myArray = [];
438 và một chuỗi có thể tạo ra một mảng JavaScript có các thuộc tính và thành phần cung cấp thông tin về sự trùng khớp. Một mảng như vậy được trả về bởi 
let myArray = [];
439 và 
let myArray = [];
440

Một biến có thể là một mảng không?

Biến mảng cung cấp giải pháp thay thế cho việc xác định nhiều biến để biểu thị nhiều giá trị . Định dạng của biến mảng có thể là danh sách các giá trị riêng lẻ [danh sách mảng] hoặc tập hợp một hoặc nhiều cặp tên-giá trị [mảng JSON].

Làm cách nào để tạo một mảng các biến trong JavaScript?

Có thể tạo một mảng bằng cách sử dụng cú pháp ký tự mảng hoặc hàm tạo mảng . Cú pháp mảng. var stringArray = ["một", "hai", "ba"]; . var numericArray = Mảng mới[3]; .

Bài Viết Liên Quan

Html in pdf
Trăn nguyên mẫu
Làm cách nào để thêm hình ảnh vào CSS?
Dòng in đậm trong Excel cho biết
Viết chương trình python để tìm chỉ mục của một mục trong bộ dữ liệu.
Boolean PHP
Viết chương trình html để hiển thị hồ sơ nhân viên bằng html
Làm cách nào để có được độ dài trung bình của các từ trong danh sách Python?
Tự động tạo biến javascript
Làm cách nào để xem mã html của trang web trong safari?
Ghi đè css bên ngoài
Lịch học của Quận Hillsborough 2023 đến 2024
When Asia Cup start 2023?
Làm thế nào để bạn vẽ một giá trị trong python?
Gọi phương thức riêng tư PHP
Đường dẫn tệp động python
Mysql so với mysqli
Python chuyển đổi dấu thời gian thành ngày giờ
Ký tự thoát Excel
Chương trình dendrogram tròn python

Toplist mới

#1
Top 9 tập bản đồ lớp 8 bài 31 2023
6 tháng trước
#2
Top 6 kết quả thi hsg đà nẵng 2022 2023
6 tháng trước
#3
Top 9 tủ nhựa đài loan 4 cánh 3d 2023
6 tháng trước
#4
Top 9 chất khí có thể làm mất màu dung dịch nước brom là: a. so2. b. co2. c. o2. d. hcl. 2023
6 tháng trước
#5
Top 8 tìm việc làm tiện, phay bảo q7 2023
6 tháng trước
#6
Top 3 tôi xuyên thành tiểu kiều the của lão đại phản 2 2023
6 tháng trước
#7
Top 9 đổi mới phong cách, thái độ phục vụ của cán bộ y tế hướng tới sự hài lòng của người bệnh 2023
6 tháng trước
#8
Top 2 bài the dục phát triển chung lớp 6 2022 2023
6 tháng trước
#9
Top 3 bài giảng vũ điệu sắc màu (lớp 4) 2023
6 tháng trước

Bài mới nhất

Lý luận mác lênin có phải đã lỗi thời năm 2024
Bệnh viêm mô tế bào là gì năm 2024
Viết một đoạn văn tả cây bóng mát năm 2024
Giải bài 12 sbt toán 9 tập 1 trang 62 năm 2024
Bất tử khác với bất diệt ở chỗ nào năm 2024
Lỗi trùng chưng minh thư của người phụ thuộc năm 2024
Bài tập đệ quy quay lui trong c năm 2024
Vé máy bay từ buôn mê thuột đi thanh hóa năm 2024
Bài văn tưởng tượng biến thành con meo trong 3ngay năm 2024
Chất xơ hòa tan tan trong dung môi nào năm 2024

Chủ Đề

programming Hỏi Đáp Toplist Là gì Mẹo Hay Địa Điểm Hay Học Tốt mẹo hay Công Nghệ Nghĩa của từ Bao nhiêu Khỏe Đẹp đánh giá Top List bao nhieu bao nhiêu hướng dẫn Xây Đựng So Sánh Bài tập Tiếng anh So sánh Sản phẩm tốt Ngôn ngữ Bài Tập javascript Ở đâu Thế nào Hướng dẫn Dịch Máy tính Tại sao Đại học Món Ngon Khoa Học