Cách tạo mảng trong JavaScript minh họa bằng ví dụ?

Nhưng khá thường xuyên, chúng tôi thấy rằng chúng tôi cần một bộ sưu tập có thứ tự, trong đó chúng tôi có phần tử thứ 1, thứ 2, thứ 3, v.v. Ví dụ: chúng tôi cần điều đó để lưu trữ danh sách thứ gì đó. người dùng, hàng hóa, phần tử HTML, v.v.

Không thuận tiện khi sử dụng một đối tượng ở đây vì nó không cung cấp các phương thức để quản lý thứ tự các phần tử. Chúng tôi không thể chèn một thuộc tính mới “giữa” những thuộc tính hiện có. Các đối tượng không dành cho mục đích sử dụng đó

Tồn tại một cấu trúc dữ liệu đặc biệt tên là

fruits[2] = 'Pear'; // now ["Apple", "Orange", "Pear"]

5, để lưu trữ các bộ sưu tập có thứ tự

Có hai cú pháp để tạo một mảng trống

let arr = new Array[];
let arr = [];

Hầu như mọi lúc, cú pháp thứ hai được sử dụng. Chúng tôi có thể cung cấp các yếu tố ban đầu trong ngoặc

let fruits = ["Apple", "Orange", "Plum"];

Các phần tử mảng được đánh số, bắt đầu bằng số không

Chúng ta có thể lấy một phần tử theo số của nó trong ngoặc vuông

let fruits = ["Apple", "Orange", "Plum"];

alert[ fruits[0] ]; // Apple
alert[ fruits[1] ]; // Orange
alert[ fruits[2] ]; // Plum

Chúng ta có thể thay thế một phần tử

fruits[2] = 'Pear'; // now ["Apple", "Orange", "Pear"]

…Hoặc thêm một cái mới vào mảng

fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]

Tổng số phần tử trong mảng là

fruits[2] = 'Pear'; // now ["Apple", "Orange", "Pear"]

6 của nó

let fruits = ["Apple", "Orange", "Plum"];

alert[ fruits.length ]; // 3

Chúng ta cũng có thể sử dụng

fruits[2] = 'Pear'; // now ["Apple", "Orange", "Pear"]

7 để hiển thị toàn bộ mảng

let fruits = ["Apple", "Orange", "Plum"];

alert[ fruits ]; // Apple,Orange,Plum

Một mảng có thể lưu trữ các phần tử của bất kỳ loại nào

Ví dụ

let arr = new Array[];
let arr = [];

0

dấu phẩy sau

Một mảng, giống như một đối tượng, có thể kết thúc bằng dấu phẩy

let arr = new Array[];
let arr = [];

1

Kiểu “dấu phẩy ở cuối” giúp chèn/xóa các mục dễ dàng hơn vì tất cả các dòng đều giống nhau

Một bổ sung gần đây

Đây là một bổ sung gần đây cho ngôn ngữ. Các trình duyệt cũ có thể cần polyfill

Giả sử chúng ta muốn phần tử cuối cùng của mảng

Một số ngôn ngữ lập trình cho phép sử dụng chỉ mục phủ định cho cùng một mục đích, như

fruits[2] = 'Pear'; // now ["Apple", "Orange", "Pear"]

8

Mặc dù, trong JavaScript nó sẽ không hoạt động. Kết quả sẽ là

fruits[2] = 'Pear'; // now ["Apple", "Orange", "Pear"]

9, vì chỉ số trong ngoặc vuông được xử lý theo nghĩa đen

Chúng ta có thể tính toán chỉ số phần tử cuối cùng một cách rõ ràng và sau đó truy cập nó.

fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]

0

let arr = new Array[];
let arr = [];

5

Hơi rườm rà phải không?

May mắn thay, có một cú pháp ngắn hơn.

fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]

1

let fruits = ["Apple", "Orange", "Plum"];

0

Nói cách khác,

fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]

2

• hoàn toàn giống với

  fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]

  3, nếu

  fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]

  4
• đối với các giá trị âm của

  fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]

  5, nó lùi lại từ cuối mảng

Hàng đợi là một trong những cách sử dụng phổ biến nhất của mảng. Trong khoa học máy tính, điều này có nghĩa là một tập hợp các phần tử được sắp xếp theo thứ tự hỗ trợ hai thao tác

• fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]

  6 nối một phần tử vào cuối

• fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]

  7 lấy một phần tử ngay từ đầu, tăng hàng đợi, để phần tử thứ 2 trở thành phần tử thứ nhất

Mảng hỗ trợ cả hai hoạt động

Trong thực tế, chúng tôi cần nó rất thường xuyên. Ví dụ: một hàng thư cần được hiển thị trên màn hình

Có một trường hợp sử dụng khác cho mảng – cấu trúc dữ liệu có tên ngăn xếp

Nó hỗ trợ hai hoạt động

• fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]

  6 thêm một phần tử vào cuối

• fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]

  9 lấy một phần tử từ cuối

Vì vậy, các yếu tố mới được thêm vào hoặc lấy luôn từ “cuối cùng”

Một ngăn xếp thường được minh họa như một bộ bài. thẻ mới được thêm vào đầu hoặc lấy từ đầu

Đối với ngăn xếp, mục được đẩy mới nhất sẽ được nhận trước, đó còn được gọi là nguyên tắc LIFO [Last-In-First-Out]. Đối với hàng đợi, chúng tôi có FIFO [Nhập trước xuất trước]

Mảng trong JavaScript có thể hoạt động như một hàng đợi và ngăn xếp. Chúng cho phép bạn thêm/xóa các phần tử, cả vào/từ đầu hoặc cuối

Trong khoa học máy tính, cấu trúc dữ liệu cho phép điều này, được gọi là deque

Các phương thức hoạt động với phần cuối của mảng

fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]

9

Trích xuất phần tử cuối cùng của mảng và trả về nó

let fruits = ["Apple", "Orange", "Plum"];

1

Cả

let fruits = ["Apple", "Orange", "Plum"];

alert[ fruits.length ]; // 3

1 và

fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]

1 đều trả về phần tử cuối cùng của mảng, nhưng

let fruits = ["Apple", "Orange", "Plum"];

alert[ fruits.length ]; // 3

1 cũng sửa đổi mảng bằng cách loại bỏ nó

fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]

6

Nối phần tử vào cuối mảng

let fruits = ["Apple", "Orange", "Plum"];

2

Cuộc gọi

let fruits = ["Apple", "Orange", "Plum"];

alert[ fruits.length ]; // 3

5 bằng với

let fruits = ["Apple", "Orange", "Plum"];

alert[ fruits.length ]; // 3

6

Các phương thức hoạt động với phần đầu của mảng

fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]

7

Trích xuất phần tử đầu tiên của mảng và trả về nó

let fruits = ["Apple", "Orange", "Plum"];

3

let fruits = ["Apple", "Orange", "Plum"];

alert[ fruits.length ]; // 3

8

Thêm phần tử vào đầu mảng

let fruits = ["Apple", "Orange", "Plum"];

4

Các phương thức

fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]

6 và

let fruits = ["Apple", "Orange", "Plum"];

alert[ fruits.length ]; // 3

8 có thể thêm nhiều phần tử cùng một lúc

let fruits = ["Apple", "Orange", "Plum"];

5

Mảng là một loại đối tượng đặc biệt. Dấu ngoặc vuông được sử dụng để truy cập thuộc tính

let fruits = ["Apple", "Orange", "Plum"];

alert[ fruits ]; // Apple,Orange,Plum

1 thực sự đến từ cú pháp đối tượng. Điều đó về cơ bản giống như

let fruits = ["Apple", "Orange", "Plum"];

alert[ fruits ]; // Apple,Orange,Plum

2, trong đó

let fruits = ["Apple", "Orange", "Plum"];

alert[ fruits ]; // Apple,Orange,Plum

3 là đối tượng, trong khi các số được sử dụng làm khóa

Chúng mở rộng các đối tượng cung cấp các phương thức đặc biệt để làm việc với các bộ sưu tập dữ liệu được sắp xếp theo thứ tự và cả thuộc tính

fruits[2] = 'Pear'; // now ["Apple", "Orange", "Pear"]

6. Nhưng cốt lõi nó vẫn là một đối tượng

Hãy nhớ rằng, chỉ có tám loại dữ liệu cơ bản trong JavaScript [xem chương Kiểu dữ liệu để biết thêm thông tin]. Mảng là một đối tượng và do đó hoạt động như một đối tượng

Ví dụ, nó được sao chép bằng cách tham khảo

let fruits = ["Apple", "Orange", "Plum"];

6

…Nhưng điều làm cho mảng thực sự đặc biệt là sự thể hiện bên trong của chúng. Công cụ cố gắng lưu trữ các phần tử của nó trong vùng bộ nhớ liền kề, lần lượt, giống như được mô tả trên các hình minh họa trong chương này, và cũng có các tối ưu hóa khác, để làm cho các mảng hoạt động rất nhanh

Nhưng tất cả chúng đều bị hỏng nếu chúng ta ngừng làm việc với một mảng như với một “bộ sưu tập có thứ tự” và bắt đầu làm việc với nó như thể nó là một đối tượng thông thường

Ví dụ, về mặt kỹ thuật chúng ta có thể làm điều này

let fruits = ["Apple", "Orange", "Plum"];

7

Điều đó là có thể, bởi vì mảng là đối tượng ở cơ sở của chúng. Chúng ta có thể thêm bất kỳ thuộc tính nào vào chúng

Nhưng công cụ sẽ thấy rằng chúng ta đang làm việc với mảng như với một đối tượng thông thường. Tối ưu hóa theo mảng cụ thể không phù hợp với những trường hợp như vậy và sẽ bị tắt, lợi ích của chúng biến mất

Các cách để lạm dụng một mảng

• Thêm một thuộc tính không phải là số như

  let fruits = ["Apple", "Orange", "Plum"];
  
  alert[ fruits ]; // Apple,Orange,Plum

  5
• Tạo lỗ, như. thêm

  let fruits = ["Apple", "Orange", "Plum"];
  
  alert[ fruits ]; // Apple,Orange,Plum

  1 và sau đó là

  let fruits = ["Apple", "Orange", "Plum"];
  
  alert[ fruits ]; // Apple,Orange,Plum

  7 [và không có gì giữa chúng]
• Điền vào mảng theo thứ tự ngược lại, như

  let fruits = ["Apple", "Orange", "Plum"];
  
  alert[ fruits ]; // Apple,Orange,Plum

  7,

  let fruits = ["Apple", "Orange", "Plum"];
  
  alert[ fruits ]; // Apple,Orange,Plum

  9, v.v.

Vui lòng coi mảng là cấu trúc đặc biệt để làm việc với dữ liệu được sắp xếp. Họ cung cấp các phương pháp đặc biệt cho điều đó. Các mảng được điều chỉnh cẩn thận bên trong các công cụ JavaScript để hoạt động với dữ liệu được sắp xếp liền kề, vui lòng sử dụng chúng theo cách này. Và nếu bạn cần các khóa tùy ý, rất có thể bạn thực sự cần một đối tượng thông thường

let arr = new Array[];
let arr = [];

00

Các phương thức

let arr = new Array[];
let arr = [];

01 chạy nhanh, trong khi

let arr = new Array[];
let arr = [];

02 chạy chậm

Tại sao làm việc với phần cuối của một mảng nhanh hơn so với phần đầu của nó?

let fruits = ["Apple", "Orange", "Plum"];

8

Nó không đủ để lấy và loại bỏ phần tử có chỉ số

let arr = new Array[];
let arr = [];

03. Các yếu tố khác cũng cần được đánh số lại

Thao tác

fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]

7 phải thực hiện 3 việc

1. Xóa phần tử có chỉ số

   let arr = new Array[];
   let arr = [];

   03
2. Di chuyển tất cả các phần tử sang bên trái, đánh số lại chúng từ chỉ mục

   let arr = new Array[];
   let arr = [];

   06 đến

   let arr = new Array[];
   let arr = [];

   03, từ

   let arr = new Array[];
   let arr = [];

   08 đến

   let arr = new Array[];
   let arr = [];

   06, v.v.
3. Cập nhật thuộc tính

   fruits[2] = 'Pear'; // now ["Apple", "Orange", "Pear"]

   6

Càng nhiều phần tử trong mảng, càng có nhiều thời gian để di chuyển chúng, nhiều thao tác trong bộ nhớ hơn

Điều tương tự cũng xảy ra với

let fruits = ["Apple", "Orange", "Plum"];

alert[ fruits.length ]; // 3

8. để thêm một phần tử vào đầu mảng, trước tiên chúng ta cần di chuyển các phần tử hiện có sang bên phải, tăng chỉ số của chúng

Và chuyện gì xảy ra với

let arr = new Array[];
let arr = [];

01? . Để trích xuất một phần tử từ cuối, phương thức

fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]

9 làm sạch chỉ mục và rút ngắn

fruits[2] = 'Pear'; // now ["Apple", "Orange", "Pear"]

6

Các hành động cho hoạt động

fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]

9

let fruits = ["Apple", "Orange", "Plum"];

9

Phương thức

fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]

9 không cần di chuyển bất cứ thứ gì, vì các phần tử khác giữ nguyên chỉ mục của chúng. Đó là lý do tại sao nó nhanh như chớp

Điều tương tự với phương thức

fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]

6

Một trong những cách lâu đời nhất để quay vòng các mục mảng là vòng lặp

let arr = new Array[];
let arr = [];

18 trên các chỉ mục

let fruits = ["Apple", "Orange", "Plum"];

alert[ fruits[0] ]; // Apple
alert[ fruits[1] ]; // Orange
alert[ fruits[2] ]; // Plum

0

Nhưng đối với mảng, có một dạng vòng lặp khác,

let arr = new Array[];
let arr = [];

19

let fruits = ["Apple", "Orange", "Plum"];

alert[ fruits[0] ]; // Apple
alert[ fruits[1] ]; // Orange
alert[ fruits[2] ]; // Plum

1

let arr = new Array[];
let arr = [];

19 không cấp quyền truy cập vào số lượng của phần tử hiện tại, chỉ truy cập vào giá trị của nó, nhưng trong hầu hết các trường hợp, điều đó là đủ. Và nó ngắn hơn

Về mặt kỹ thuật, vì mảng là đối tượng nên cũng có thể sử dụng

let arr = new Array[];
let arr = [];

51

let fruits = ["Apple", "Orange", "Plum"];

alert[ fruits[0] ]; // Apple
alert[ fruits[1] ]; // Orange
alert[ fruits[2] ]; // Plum

2

Nhưng đó thực sự là một ý tưởng tồi. Có những vấn đề tiềm ẩn với nó

1. Vòng lặp

   let arr = new Array[];
   let arr = [];

   51 lặp lại trên tất cả các thuộc tính, không chỉ các thuộc tính số

   Có cái gọi là các đối tượng "giống như mảng" trong trình duyệt và trong các môi trường khác, trông giống như các mảng. Nghĩa là, chúng có các thuộc tính

   fruits[2] = 'Pear'; // now ["Apple", "Orange", "Pear"]

   6 và lập chỉ mục, nhưng chúng cũng có thể có các thuộc tính và phương thức không phải là số khác mà chúng ta thường không cần đến. Tuy nhiên, vòng lặp

   let arr = new Array[];
   let arr = [];

   51 sẽ liệt kê chúng. Vì vậy, nếu chúng ta cần làm việc với các đối tượng giống như mảng, thì các thuộc tính “phụ” này có thể trở thành một vấn đề

2. Vòng lặp

   let arr = new Array[];
   let arr = [];

   51 được tối ưu hóa cho các đối tượng chung, không phải mảng và do đó chậm hơn 10-100 lần. Tất nhiên, nó vẫn rất nhanh. Việc tăng tốc có thể chỉ quan trọng trong các nút cổ chai. Nhưng chúng ta vẫn nên nhận thức được sự khác biệt

Nói chung, chúng ta không nên sử dụng

let arr = new Array[];
let arr = [];

51 cho mảng

Thuộc tính

fruits[2] = 'Pear'; // now ["Apple", "Orange", "Pear"]

6 tự động cập nhật khi chúng ta sửa đổi mảng. Nói chính xác, nó thực sự không phải là số lượng giá trị trong mảng, mà là chỉ số lớn nhất cộng với một

Chẳng hạn, một phần tử có chỉ số lớn sẽ cho độ dài lớn

let fruits = ["Apple", "Orange", "Plum"];

alert[ fruits[0] ]; // Apple
alert[ fruits[1] ]; // Orange
alert[ fruits[2] ]; // Plum

3

Lưu ý rằng chúng ta thường không sử dụng các mảng như vậy

Một điều thú vị khác về thuộc tính

fruits[2] = 'Pear'; // now ["Apple", "Orange", "Pear"]

6 là nó có thể ghi

Nếu chúng tôi tăng nó theo cách thủ công, sẽ không có gì thú vị xảy ra. Nhưng nếu chúng ta giảm nó, mảng sẽ bị cắt bớt. Quá trình này là không thể đảo ngược, đây là ví dụ

let fruits = ["Apple", "Orange", "Plum"];

alert[ fruits[0] ]; // Apple
alert[ fruits[1] ]; // Orange
alert[ fruits[2] ]; // Plum

4

Vì vậy, cách đơn giản nhất để xóa mảng là.

let arr = new Array[];
let arr = [];

59

Còn một cú pháp nữa để tạo mảng

let fruits = ["Apple", "Orange", "Plum"];

alert[ fruits[0] ]; // Apple
alert[ fruits[1] ]; // Orange
alert[ fruits[2] ]; // Plum

5

Nó hiếm khi được sử dụng, vì dấu ngoặc vuông

let fruits = ["Apple", "Orange", "Plum"];

00 ngắn hơn. Ngoài ra, có một tính năng phức tạp với nó

Nếu

let fruits = ["Apple", "Orange", "Plum"];

01 được gọi với một đối số duy nhất là một số, thì nó sẽ tạo một mảng không có phần tử, nhưng có độ dài nhất định

Hãy xem làm thế nào một người có thể tự bắn vào chân mình

let fruits = ["Apple", "Orange", "Plum"];

alert[ fruits[0] ]; // Apple
alert[ fruits[1] ]; // Orange
alert[ fruits[2] ]; // Plum

6

Để tránh những bất ngờ như vậy, chúng tôi thường sử dụng dấu ngoặc vuông, trừ khi chúng tôi thực sự biết mình đang làm gì

Mảng có thể có các mục cũng là mảng. Chúng ta có thể sử dụng nó cho mảng nhiều chiều, ví dụ để lưu trữ ma trận

let fruits = ["Apple", "Orange", "Plum"];

alert[ fruits[0] ]; // Apple
alert[ fruits[1] ]; // Orange
alert[ fruits[2] ]; // Plum

7

Mảng có triển khai riêng của phương thức

let fruits = ["Apple", "Orange", "Plum"];

02 trả về danh sách các phần tử được phân tách bằng dấu phẩy

Ví dụ

let fruits = ["Apple", "Orange", "Plum"];

alert[ fruits[0] ]; // Apple
alert[ fruits[1] ]; // Orange
alert[ fruits[2] ]; // Plum

8

Ngoài ra, hãy thử điều này

let fruits = ["Apple", "Orange", "Plum"];

alert[ fruits[0] ]; // Apple
alert[ fruits[1] ]; // Orange
alert[ fruits[2] ]; // Plum

9

Mảng không có

let fruits = ["Apple", "Orange", "Plum"];

03, cũng không phải là

let fruits = ["Apple", "Orange", "Plum"];

04 khả thi, chúng chỉ thực hiện chuyển đổi

let fruits = ["Apple", "Orange", "Plum"];

02, vì vậy ở đây

let fruits = ["Apple", "Orange", "Plum"];

00 trở thành một chuỗi rỗng,

let fruits = ["Apple", "Orange", "Plum"];

07 trở thành

let fruits = ["Apple", "Orange", "Plum"];

08 và

let fruits = ["Apple", "Orange", "Plum"];

09 trở thành

let fruits = ["Apple", "Orange", "Plum"];

10

Khi toán tử nhị phân cộng

let fruits = ["Apple", "Orange", "Plum"];

11 thêm một thứ gì đó vào một chuỗi, nó cũng chuyển đổi nó thành một chuỗi, vì vậy bước tiếp theo sẽ như thế này

fruits[2] = 'Pear'; // now ["Apple", "Orange", "Pear"]

0

Mảng trong JavaScript, không giống như một số ngôn ngữ lập trình khác, không nên so sánh với toán tử

let fruits = ["Apple", "Orange", "Plum"];

12

Toán tử này không có cách xử lý đặc biệt nào đối với mảng, nó hoạt động với chúng như với bất kỳ đối tượng nào

Hãy nhắc lại các quy tắc

• Hai đối tượng chỉ bằng nhau

  let fruits = ["Apple", "Orange", "Plum"];

  12 nếu chúng tham chiếu đến cùng một đối tượng
• Nếu một trong các đối số của

  let fruits = ["Apple", "Orange", "Plum"];

  12 là đối tượng và đối số còn lại là đối số nguyên thủy, thì đối tượng sẽ được chuyển đổi thành nguyên thủy, như đã giải thích trong chương Chuyển đổi đối tượng thành nguyên thủy
• …Ngoại trừ

  let fruits = ["Apple", "Orange", "Plum"];

  15 và

  fruits[2] = 'Pear'; // now ["Apple", "Orange", "Pear"]

  9 bằng nhau

  let fruits = ["Apple", "Orange", "Plum"];

  12 và không có gì khác

So sánh nghiêm ngặt

let fruits = ["Apple", "Orange", "Plum"];

18 thậm chí còn đơn giản hơn vì nó không chuyển đổi các loại

Vì vậy, nếu chúng ta so sánh các mảng với

let fruits = ["Apple", "Orange", "Plum"];

12, chúng sẽ không bao giờ giống nhau, trừ khi chúng ta so sánh hai biến tham chiếu chính xác cùng một mảng

Ví dụ

fruits[2] = 'Pear'; // now ["Apple", "Orange", "Pear"]

1

Các mảng này là các đối tượng khác nhau về mặt kỹ thuật. Vì vậy, họ không bằng nhau. Toán tử

let fruits = ["Apple", "Orange", "Plum"];

12 không thực hiện so sánh từng mục

So sánh với nguyên thủy cũng có thể cho kết quả có vẻ kỳ lạ

fruits[2] = 'Pear'; // now ["Apple", "Orange", "Pear"]

2

Ở đây, trong cả hai trường hợp, chúng ta so sánh một đối tượng nguyên thủy với một đối tượng mảng. Vì vậy, mảng

let fruits = ["Apple", "Orange", "Plum"];

00 được chuyển đổi thành nguyên thủy với mục đích so sánh và trở thành một chuỗi rỗng

let fruits = ["Apple", "Orange", "Plum"];

22

Sau đó, quá trình so sánh tiếp tục với các nguyên thủy, như được mô tả trong chương Chuyển đổi loại

fruits[2] = 'Pear'; // now ["Apple", "Orange", "Pear"]

3

Vì vậy, làm thế nào để so sánh các mảng?

Điều đó thật đơn giản. không sử dụng toán tử

let fruits = ["Apple", "Orange", "Plum"];

12. Thay vào đó, hãy so sánh chúng theo từng mục trong một vòng lặp hoặc sử dụng các phương pháp lặp được giải thích trong chương tiếp theo

Mảng là một loại đối tượng đặc biệt, thích hợp để lưu trữ và quản lý các mục dữ liệu có thứ tự

Khai báo

fruits[2] = 'Pear'; // now ["Apple", "Orange", "Pear"]

4

Cuộc gọi đến

let fruits = ["Apple", "Orange", "Plum"];

24 tạo một mảng có độ dài nhất định, nhưng không có phần tử

• Thuộc tính

  fruits[2] = 'Pear'; // now ["Apple", "Orange", "Pear"]

  6 là độ dài mảng hay nói chính xác là chỉ số cuối cùng của nó cộng với một. Nó được tự động điều chỉnh bằng các phương thức mảng
• Nếu chúng ta rút ngắn

  fruits[2] = 'Pear'; // now ["Apple", "Orange", "Pear"]

  6 theo cách thủ công, mảng sẽ bị cắt bớt

Lấy các phần tử

• chúng ta có thể lấy phần tử theo chỉ mục của nó, như

  let fruits = ["Apple", "Orange", "Plum"];
  
  alert[ fruits ]; // Apple,Orange,Plum

  1
• ngoài ra, chúng tôi có thể sử dụng phương pháp

  let fruits = ["Apple", "Orange", "Plum"];

  28 cho phép các chỉ số âm. Đối với các giá trị âm của

  fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]

  5, nó lùi lại từ cuối mảng. Nếu

  fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]

  4, nó hoạt động giống như

  fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]

  3

Chúng ta có thể sử dụng một mảng như một deque với các thao tác sau

• let fruits = ["Apple", "Orange", "Plum"];

  32 thêm

  let fruits = ["Apple", "Orange", "Plum"];

  33 vào cuối

• let fruits = ["Apple", "Orange", "Plum"];

  34 xóa phần tử ở cuối và trả về phần tử đó

• let fruits = ["Apple", "Orange", "Plum"];

  35 loại bỏ phần tử từ đầu và trả về nó

• let fruits = ["Apple", "Orange", "Plum"];

  36 thêm

  let fruits = ["Apple", "Orange", "Plum"];

  33 vào đầu

Để lặp qua các phần tử của mảng

• let fruits = ["Apple", "Orange", "Plum"];

  38 – hoạt động nhanh nhất, tương thích với trình duyệt cũ

• let fruits = ["Apple", "Orange", "Plum"];

  39 – cú pháp hiện đại chỉ dành cho các mục,

• let fruits = ["Apple", "Orange", "Plum"];

  40 – không bao giờ sử dụng

Để so sánh các mảng, không sử dụng toán tử

let fruits = ["Apple", "Orange", "Plum"];

12 [cũng như

let fruits = ["Apple", "Orange", "Plum"];

42,

let fruits = ["Apple", "Orange", "Plum"];

43 và các toán tử khác], vì chúng không có cách xử lý đặc biệt nào đối với mảng. Họ xử lý chúng như bất kỳ đối tượng nào và đó không phải là điều chúng ta thường muốn

Thay vào đó, bạn có thể sử dụng vòng lặp

let arr = new Array[];
let arr = [];

19 để so sánh các mảng theo từng mục

Chúng ta sẽ tiếp tục với mảng và nghiên cứu thêm các phương thức thêm, bớt, trích xuất các phần tử và sắp xếp mảng trong chương tiếp theo Các phương thức của mảng

Làm cách nào để tạo mảng trong JavaScript bằng ví dụ?

Một mảng minh họa với một ví dụ là gì?

Làm cách nào để tạo một mảng sinh viên trong JavaScript?

Làm cách nào để tạo đối tượng mảng trong JavaScript?