Làm cách nào để lấy một giá trị từ một mảng trong JavaScript?

Điều đó là tự nhiên, bởi vì

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

3 loại bỏ một giá trị bởi

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

4. Đó là tất cả những gì nó làm. Phạt tiền đối tượng. Nhưng đối với mảng, chúng ta thường muốn các phần tử còn lại dịch chuyển và chiếm vị trí được giải phóng. Chúng tôi hy vọng sẽ có một mảng ngắn hơn bây giờ

Vì vậy, nên sử dụng các phương pháp đặc biệt

các mảng. phương pháp mối nối là một con dao quân đội Thụy Sĩ cho các mảng. Nó có thể làm mọi thứ. chèn, xóa và thay thế các phần tử

Cú pháp là

arr.splice[start[, deleteCount, elem1, ..., elemN]]

Nó sửa đổi

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

5 bắt đầu từ chỉ mục

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

6. loại bỏ các phần tử

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

7 và sau đó chèn

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

8 vào vị trí của chúng. Trả về mảng các phần tử đã loại bỏ

Phương pháp này rất dễ nắm bắt bằng các ví dụ

Hãy bắt đầu với việc xóa

let arr = ["I", "study", "JavaScript"];

arr.splice[1, 1]; // from index 1 remove 1 element

alert[ arr ]; // ["I", "JavaScript"]

Dễ dàng, phải không?

Trong ví dụ tiếp theo, chúng tôi loại bỏ 3 phần tử và thay thế chúng bằng hai phần tử còn lại

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

0

Ở đây chúng ta có thể thấy rằng

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

11 trả về mảng các phần tử đã bị loại bỏ

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

2

Phương thức

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

11 cũng có thể chèn các phần tử mà không cần xóa. Để làm được điều đó, chúng ta cần đặt

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

7 thành

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

14

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

Cho phép chỉ mục tiêu cực

Ở đây và trong các phương thức mảng khác, chỉ số âm được cho phép. Họ chỉ định vị trí từ cuối mảng, như ở đây

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

1

lát cắt

phương pháp mảng. slice đơn giản hơn nhiều so với

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

15 trông tương tự

Cú pháp là

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

9

Nó trả về một mảng mới sao chép vào đó tất cả các mục từ chỉ mục

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

6 đến

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

17 [không bao gồm

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

17]. Cả

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

6 và

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

17 đều có thể âm, trong trường hợp đó, vị trí từ cuối mảng được giả định

Nó tương tự như một phương thức chuỗi

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

91, nhưng thay vì các chuỗi con, nó tạo ra các mảng con

Ví dụ

arr.splice[start[, deleteCount, elem1, ..., elemN]]

6

Chúng ta cũng có thể gọi nó mà không cần đối số.

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

92 tạo một bản sao của

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

5. Điều đó thường được sử dụng để lấy một bản sao cho các phép biến đổi tiếp theo mà không ảnh hưởng đến mảng ban đầu

concat

phương pháp mảng. concat tạo một mảng mới bao gồm các giá trị từ các mảng khác và các mục bổ sung

Cú pháp là

arr.splice[start[, deleteCount, elem1, ..., elemN]]

9

Nó chấp nhận bất kỳ số lượng đối số nào - mảng hoặc giá trị

Kết quả là một mảng mới chứa các mục từ

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

5, sau đó là

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

95,

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

96, v.v.

Nếu một đối số

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

97 là một mảng, thì tất cả các phần tử của nó sẽ được sao chép. Mặt khác, chính đối số được sao chép

Ví dụ

arr.splice[start[, deleteCount, elem1, ..., elemN]]

0

Thông thường, nó chỉ sao chép các phần tử từ mảng. Các đối tượng khác, ngay cả khi chúng trông giống như mảng, được thêm vào như một tổng thể

arr.splice[start[, deleteCount, elem1, ..., elemN]]

1

…Nhưng nếu một đối tượng dạng mảng có thuộc tính

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

98 đặc biệt, thì nó được coi là một mảng bởi

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

99. thay vào đó các yếu tố của nó được thêm vào

arr.splice[start[, deleteCount, elem1, ..., elemN]]

2

lặp đi lặp lại. cho mỗi

các mảng. Phương thức forEach cho phép chạy một hàm cho mọi phần tử của mảng

cú pháp

arr.splice[start[, deleteCount, elem1, ..., elemN]]

3

Chẳng hạn, điều này cho thấy từng phần tử của mảng

arr.splice[start[, deleteCount, elem1, ..., elemN]]

4

Và mã này phức tạp hơn về vị trí của chúng trong mảng mục tiêu

arr.splice[start[, deleteCount, elem1, ..., elemN]]

5

Kết quả của hàm [nếu nó trả về bất kỳ] bị loại bỏ và bỏ qua

Tìm kiếm trong mảng

Bây giờ hãy giới thiệu các phương thức tìm kiếm trong một mảng

indexOf/lastIndexOf và bao gồm

Các phương thức arr. indexOf và mảng. bao gồm có cú pháp tương tự và về cơ bản giống như đối tác chuỗi của chúng, nhưng hoạt động trên các mục thay vì ký tự

• arr.splice[start[, deleteCount, elem1, ..., elemN]]

  60 – tìm kiếm

  arr.splice[start[, deleteCount, elem1, ..., elemN]]

  61 bắt đầu từ chỉ mục

  arr.splice[start[, deleteCount, elem1, ..., elemN]]

  62 và trả về chỉ mục nơi nó được tìm thấy, nếu không thì

  arr.splice[start[, deleteCount, elem1, ..., elemN]]

  63

• arr.splice[start[, deleteCount, elem1, ..., elemN]]

  64 – tìm kiếm

  arr.splice[start[, deleteCount, elem1, ..., elemN]]

  61 bắt đầu từ chỉ mục

  arr.splice[start[, deleteCount, elem1, ..., elemN]]

  62, trả về

  arr.splice[start[, deleteCount, elem1, ..., elemN]]

  67 nếu tìm thấy

Thông thường các phương thức này được sử dụng chỉ với một đối số.

arr.splice[start[, deleteCount, elem1, ..., elemN]]

61 để tìm kiếm. Theo mặc định, tìm kiếm là từ đầu

Ví dụ

arr.splice[start[, deleteCount, elem1, ..., elemN]]

6

Xin lưu ý rằng

arr.splice[start[, deleteCount, elem1, ..., elemN]]

69 sử dụng đẳng thức nghiêm ngặt

arr.splice[start[, deleteCount, elem1, ..., elemN]]

90 để so sánh. Vì vậy, nếu chúng ta tìm kiếm

arr.splice[start[, deleteCount, elem1, ..., elemN]]

91, nó sẽ tìm thấy chính xác

arr.splice[start[, deleteCount, elem1, ..., elemN]]

91 chứ không phải số 0

Nếu chúng tôi muốn kiểm tra xem

arr.splice[start[, deleteCount, elem1, ..., elemN]]

61 có tồn tại trong mảng hay không và không cần chỉ mục, thì nên ưu tiên sử dụng

arr.splice[start[, deleteCount, elem1, ..., elemN]]

94

phương pháp mảng. lastIndexOf giống như

arr.splice[start[, deleteCount, elem1, ..., elemN]]

69, nhưng tìm kiếm từ phải sang trái

arr.splice[start[, deleteCount, elem1, ..., elemN]]

7

Phương pháp

arr.splice[start[, deleteCount, elem1, ..., elemN]]

96 xử lý chính xác

arr.splice[start[, deleteCount, elem1, ..., elemN]]

97

Một tính năng nhỏ nhưng đáng chú ý của

arr.splice[start[, deleteCount, elem1, ..., elemN]]

96 là nó xử lý chính xác

arr.splice[start[, deleteCount, elem1, ..., elemN]]

97, không giống như

arr.splice[start[, deleteCount, elem1, ..., elemN]]

69

arr.splice[start[, deleteCount, elem1, ..., elemN]]

8

Đó là bởi vì

arr.splice[start[, deleteCount, elem1, ..., elemN]]

96 đã được thêm vào JavaScript muộn hơn nhiều và sử dụng thuật toán so sánh cập nhật hơn trong nội bộ

tìm và tìm Index/findLast Index

Hãy tưởng tượng chúng ta có một mảng các đối tượng. Làm thế nào để chúng ta tìm thấy một đối tượng với điều kiện cụ thể?

đây là mảng. phương thức find[fn] có ích

Cú pháp là

arr.splice[start[, deleteCount, elem1, ..., elemN]]

9

Hàm được gọi lần lượt cho các phần tử của mảng

• arr.splice[start[, deleteCount, elem1, ..., elemN]]

  61 là phần tử

• arr.splice[start[, deleteCount, elem1, ..., elemN]]

  03 là chỉ số của nó

• arr.splice[start[, deleteCount, elem1, ..., elemN]]

  04 chính là mảng đó

Nếu nó trả về

arr.splice[start[, deleteCount, elem1, ..., elemN]]

67, quá trình tìm kiếm bị dừng,

arr.splice[start[, deleteCount, elem1, ..., elemN]]

61 được trả về. Nếu không tìm thấy gì,

arr.splice[start[, deleteCount, elem1, ..., elemN]]

07 được trả lại

Ví dụ: chúng tôi có một mảng người dùng, mỗi người có các trường

arr.splice[start[, deleteCount, elem1, ..., elemN]]

08 và

arr.splice[start[, deleteCount, elem1, ..., elemN]]

09. Hãy tìm cái có

arr.splice[start[, deleteCount, elem1, ..., elemN]]

10

let arr = ["I", "study", "JavaScript"];

arr.splice[1, 1]; // from index 1 remove 1 element

alert[ arr ]; // ["I", "JavaScript"]

0

Trong thực tế, các mảng đối tượng là một điều phổ biến, vì vậy phương thức

arr.splice[start[, deleteCount, elem1, ..., elemN]]

11 rất hữu ích

Lưu ý rằng trong ví dụ này, chúng tôi cung cấp cho

arr.splice[start[, deleteCount, elem1, ..., elemN]]

11 hàm

arr.splice[start[, deleteCount, elem1, ..., elemN]]

13 với một đối số. Đó là điển hình, các đối số khác của chức năng này hiếm khi được sử dụng

các mảng. Phương thức findIndex có cùng cú pháp, nhưng trả về chỉ mục nơi phần tử được tìm thấy thay vì chính phần tử đó. Giá trị của

arr.splice[start[, deleteCount, elem1, ..., elemN]]

63 được trả về nếu không tìm thấy gì

các mảng. Phương thức findLastIndex giống như

arr.splice[start[, deleteCount, elem1, ..., elemN]]

15, nhưng tìm kiếm từ phải sang trái, tương tự như

arr.splice[start[, deleteCount, elem1, ..., elemN]]

16

Đây là một ví dụ

let arr = ["I", "study", "JavaScript"];

arr.splice[1, 1]; // from index 1 remove 1 element

alert[ arr ]; // ["I", "JavaScript"]

1

lọc

Phương thức

arr.splice[start[, deleteCount, elem1, ..., elemN]]

11 tìm kiếm một phần tử [đầu tiên] duy nhất làm cho hàm trả về

arr.splice[start[, deleteCount, elem1, ..., elemN]]

67

Nếu có thể có nhiều, chúng ta có thể sử dụng arr. bộ lọc [fn]

Cú pháp tương tự như

arr.splice[start[, deleteCount, elem1, ..., elemN]]

11, nhưng

arr.splice[start[, deleteCount, elem1, ..., elemN]]

20 trả về một mảng gồm tất cả các phần tử phù hợp

let arr = ["I", "study", "JavaScript"];

arr.splice[1, 1]; // from index 1 remove 1 element

alert[ arr ]; // ["I", "JavaScript"]

2

Ví dụ

let arr = ["I", "study", "JavaScript"];

arr.splice[1, 1]; // from index 1 remove 1 element

alert[ arr ]; // ["I", "JavaScript"]

3

Biến đổi một mảng

Hãy chuyển sang các phương thức chuyển đổi và sắp xếp lại một mảng

bản đồ

các mảng. phương pháp bản đồ là một trong những phương pháp hữu ích nhất và thường được sử dụng

Nó gọi hàm cho từng phần tử của mảng và trả về mảng kết quả

Cú pháp là

let arr = ["I", "study", "JavaScript"];

arr.splice[1, 1]; // from index 1 remove 1 element

alert[ arr ]; // ["I", "JavaScript"]

4

Chẳng hạn, ở đây chúng tôi chuyển đổi từng phần tử thành chiều dài của nó

let arr = ["I", "study", "JavaScript"];

arr.splice[1, 1]; // from index 1 remove 1 element

alert[ arr ]; // ["I", "JavaScript"]

5

sắp xếp [fn]

Cuộc gọi đến arr. sort[] sắp xếp mảng tại chỗ, thay đổi thứ tự phần tử của nó

Nó cũng trả về mảng đã sắp xếp, nhưng giá trị trả về thường bị bỏ qua, vì bản thân

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

5 đã được sửa đổi

Ví dụ

let arr = ["I", "study", "JavaScript"];

arr.splice[1, 1]; // from index 1 remove 1 element

alert[ arr ]; // ["I", "JavaScript"]

6

Bạn có nhận thấy bất cứ điều gì lạ trong kết quả?

Thứ tự đã trở thành

arr.splice[start[, deleteCount, elem1, ..., elemN]]

22. Không đúng. Nhưng tại sao?

Các mục được sắp xếp theo chuỗi theo mặc định

Theo nghĩa đen, tất cả các phần tử được chuyển đổi thành chuỗi để so sánh. Đối với các chuỗi, thứ tự từ điển được áp dụng và thực sự là

arr.splice[start[, deleteCount, elem1, ..., elemN]]

23

Để sử dụng thứ tự sắp xếp của riêng mình, chúng ta cần cung cấp một hàm làm đối số của

arr.splice[start[, deleteCount, elem1, ..., elemN]]

24

Hàm sẽ so sánh hai giá trị tùy ý và trả về

let arr = ["I", "study", "JavaScript"];

arr.splice[1, 1]; // from index 1 remove 1 element

alert[ arr ]; // ["I", "JavaScript"]

7

Chẳng hạn, để sắp xếp dưới dạng số

let arr = ["I", "study", "JavaScript"];

arr.splice[1, 1]; // from index 1 remove 1 element

alert[ arr ]; // ["I", "JavaScript"]

8

Bây giờ nó hoạt động như dự định

Hãy bước sang một bên và suy nghĩ những gì đang xảy ra.

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

5 có thể là mảng của bất cứ thứ gì, phải không? . Chúng tôi có một bộ một số mặt hàng. Để sắp xếp nó, chúng ta cần một hàm sắp xếp biết cách so sánh các phần tử của nó. Mặc định là thứ tự chuỗi

Phương thức

arr.splice[start[, deleteCount, elem1, ..., elemN]]

26 triển khai thuật toán sắp xếp chung. Chúng tôi không cần quan tâm đến cách thức hoạt động bên trong của nó [hầu hết thời gian là một quicksort được tối ưu hóa hoặc Timsort]. Nó sẽ duyệt mảng, so sánh các phần tử của nó bằng cách sử dụng hàm được cung cấp và sắp xếp lại chúng, tất cả những gì chúng ta cần là cung cấp

arr.splice[start[, deleteCount, elem1, ..., elemN]]

27 thực hiện phép so sánh

Nhân tiện, nếu chúng ta muốn biết những yếu tố nào được so sánh – không có gì ngăn cản việc cảnh báo chúng

let arr = ["I", "study", "JavaScript"];

arr.splice[1, 1]; // from index 1 remove 1 element

alert[ arr ]; // ["I", "JavaScript"]

9

Thuật toán có thể so sánh một phần tử với nhiều phần tử khác trong quy trình, nhưng nó cố gắng thực hiện càng ít phép so sánh càng tốt

Hàm so sánh có thể trả về bất kỳ số nào

Trên thực tế, một hàm so sánh chỉ được yêu cầu trả về một số dương để nói “lớn hơn” và một số âm để nói “ít hơn”

Điều đó cho phép viết các hàm ngắn hơn

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

00

Chức năng mũi tên cho tốt nhất

Ghi nhớ chức năng mũi tên?

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

01

Điều này hoạt động chính xác giống như phiên bản dài hơn ở trên

Sử dụng

arr.splice[start[, deleteCount, elem1, ..., elemN]]

28 cho chuỗi

Nhớ thuật toán so sánh chuỗi?

Đối với nhiều bảng chữ cái, tốt hơn là sử dụng phương pháp

arr.splice[start[, deleteCount, elem1, ..., elemN]]

29 để sắp xếp chính xác các chữ cái, chẳng hạn như

arr.splice[start[, deleteCount, elem1, ..., elemN]]

30

Ví dụ: hãy sắp xếp một vài quốc gia bằng tiếng Đức

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

02

đảo ngược

phương pháp mảng. đảo ngược đảo ngược thứ tự của các phần tử trong

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

5

Ví dụ

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

03

Nó cũng trả về mảng

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

5 sau khi đảo ngược

tách và tham gia

Đây là tình huống từ cuộc sống thực. Chúng tôi đang viết một ứng dụng nhắn tin và người đó nhập danh sách người nhận được phân tách bằng dấu phẩy.

arr.splice[start[, deleteCount, elem1, ..., elemN]]

33. Nhưng đối với chúng tôi, một dãy tên sẽ thoải mái hơn nhiều so với một chuỗi. Làm thế nào để có được nó?

các str. phương thức split[delim] thực hiện chính xác điều đó. Nó chia chuỗi thành một mảng bằng dấu phân cách đã cho

arr.splice[start[, deleteCount, elem1, ..., elemN]]

34

Trong ví dụ bên dưới, chúng tôi chia tách bằng dấu phẩy theo sau là dấu cách

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

04

Phương thức

arr.splice[start[, deleteCount, elem1, ..., elemN]]

35 có một đối số số thứ hai tùy chọn – giới hạn về độ dài mảng. Nếu nó được cung cấp, thì các phần tử bổ sung sẽ bị bỏ qua. Trong thực tế nó hiếm khi được sử dụng mặc dù

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

05

Chia thành các chữ cái

Cuộc gọi đến

arr.splice[start[, deleteCount, elem1, ..., elemN]]

36 với một

arr.splice[start[, deleteCount, elem1, ..., elemN]]

37 trống sẽ chia chuỗi thành một mảng các chữ cái

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

06

mảng cuộc gọi. tham gia [keo] làm ngược lại với

arr.splice[start[, deleteCount, elem1, ..., elemN]]

35. Nó tạo ra một chuỗi gồm

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

5 mục được nối bởi

arr.splice[start[, deleteCount, elem1, ..., elemN]]

40 giữa chúng

Ví dụ

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

07

giảm/reduceRight

Khi chúng ta cần lặp lại một mảng – chúng ta có thể sử dụng

arr.splice[start[, deleteCount, elem1, ..., elemN]]

41,

arr.splice[start[, deleteCount, elem1, ..., elemN]]

42 hoặc

arr.splice[start[, deleteCount, elem1, ..., elemN]]

43

Khi chúng ta cần lặp lại và trả về dữ liệu cho từng phần tử – chúng ta có thể sử dụng

arr.splice[start[, deleteCount, elem1, ..., elemN]]

44

Các phương thức arr. giảm và sắp xếp. reduceRight cũng thuộc giống đó, nhưng phức tạp hơn một chút. Chúng được sử dụng để tính toán một giá trị duy nhất dựa trên mảng

Cú pháp là

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

08

Hàm được áp dụng lần lượt cho tất cả các phần tử mảng và “mang” kết quả của nó đến lần gọi tiếp theo

Tranh luận

• arr.splice[start[, deleteCount, elem1, ..., elemN]]

  45 – là kết quả của lần gọi hàm trước, bằng với

  arr.splice[start[, deleteCount, elem1, ..., elemN]]

  46 lần đầu tiên [nếu cung cấp

  arr.splice[start[, deleteCount, elem1, ..., elemN]]

  46]

• arr.splice[start[, deleteCount, elem1, ..., elemN]]

  61 – là mục mảng hiện tại

• arr.splice[start[, deleteCount, elem1, ..., elemN]]

  03 – là vị trí của nó

• arr.splice[start[, deleteCount, elem1, ..., elemN]]

  04 – là mảng

Khi hàm được áp dụng, kết quả của lệnh gọi hàm trước được chuyển sang hàm tiếp theo dưới dạng đối số đầu tiên

Vì vậy, đối số đầu tiên về cơ bản là bộ tích lũy lưu trữ kết quả tổng hợp của tất cả các lần thực hiện trước đó. Và cuối cùng nó trở thành kết quả của

arr.splice[start[, deleteCount, elem1, ..., elemN]]

51

Nghe có vẻ phức tạp?

Cách dễ nhất để nắm bắt đó là bằng ví dụ

Ở đây chúng tôi nhận được tổng của một mảng trong một dòng

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

09

Hàm được truyền cho

arr.splice[start[, deleteCount, elem1, ..., elemN]]

51 chỉ sử dụng 2 đối số, như vậy là đủ

Hãy xem chi tiết về những gì đang xảy ra

1. Trong lần chạy đầu tiên,

   arr.splice[start[, deleteCount, elem1, ..., elemN]]

   53 là giá trị của

   arr.splice[start[, deleteCount, elem1, ..., elemN]]

   46 [đối số cuối cùng của

   arr.splice[start[, deleteCount, elem1, ..., elemN]]

   51], bằng với

   let arr = ["I", "study", "JavaScript"];
   
   // from index 2
   // delete 0
   // then insert "complex" and "language"
   arr.splice[2, 0, "complex", "language"];
   
   alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

   14, và

   arr.splice[start[, deleteCount, elem1, ..., elemN]]

   57 là phần tử mảng đầu tiên, bằng với

   let arr = ["I", "study", "JavaScript"];
   
   // from index 2
   // delete 0
   // then insert "complex" and "language"
   arr.splice[2, 0, "complex", "language"];
   
   alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

   9. Vậy kết quả hàm là

   let arr = ["I", "study", "JavaScript"];
   
   // from index 2
   // delete 0
   // then insert "complex" and "language"
   arr.splice[2, 0, "complex", "language"];
   
   alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

   9
2. Trong lần chạy thứ hai,

   arr.splice[start[, deleteCount, elem1, ..., elemN]]

   60, chúng tôi thêm phần tử mảng thứ hai [

   arr.splice[start[, deleteCount, elem1, ..., elemN]]

   61] vào nó và trả về
3. Ở lần chạy thứ 3,

   arr.splice[start[, deleteCount, elem1, ..., elemN]]

   62 và chúng tôi thêm một yếu tố nữa vào nó, v.v.

Quy trình tính toán

Hoặc ở dạng bảng, trong đó mỗi hàng đại diện cho một lệnh gọi hàm trên phần tử mảng tiếp theo

arr.splice[start[, deleteCount, elem1, ..., elemN]]

53

arr.splice[start[, deleteCount, elem1, ..., elemN]]

57kết quả cuộc gọi đầu tiên

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

14

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

9

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

9cuộc gọi thứ hai

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

9

arr.splice[start[, deleteCount, elem1, ..., elemN]]

61

arr.splice[start[, deleteCount, elem1, ..., elemN]]

70cuộc gọi thứ ba

arr.splice[start[, deleteCount, elem1, ..., elemN]]

70

arr.splice[start[, deleteCount, elem1, ..., elemN]]

70

arr.splice[start[, deleteCount, elem1, ..., elemN]]

73cuộc gọi thứ tư

arr.splice[start[, deleteCount, elem1, ..., elemN]]

73

arr.splice[start[, deleteCount, elem1, ..., elemN]]

75

arr.splice[start[, deleteCount, elem1, ..., elemN]]

76cuộc gọi thứ năm

arr.splice[start[, deleteCount, elem1, ..., elemN]]

76

arr.splice[start[, deleteCount, elem1, ..., elemN]]

78

arr.splice[start[, deleteCount, elem1, ..., elemN]]

79

Ở đây chúng ta có thể thấy rõ kết quả của cuộc gọi trước đó trở thành đối số đầu tiên của cuộc gọi tiếp theo như thế nào

Chúng ta cũng có thể bỏ qua giá trị ban đầu

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

20

Kết quả là như nhau. Đó là bởi vì nếu không có phần tử đầu tiên, thì

arr.splice[start[, deleteCount, elem1, ..., elemN]]

51 sẽ lấy phần tử đầu tiên của mảng làm giá trị ban đầu và bắt đầu lặp lại từ phần tử thứ 2

Bảng tính giống như trên, trừ hàng đầu tiên

Nhưng việc sử dụng như vậy đòi hỏi phải hết sức cẩn thận. Nếu mảng trống, thì cuộc gọi

arr.splice[start[, deleteCount, elem1, ..., elemN]]

51 không có giá trị ban đầu sẽ báo lỗi

Đây là một ví dụ

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

21

Vì vậy, bạn nên luôn chỉ định giá trị ban đầu

phương pháp mảng. reduceRight làm tương tự, nhưng đi từ phải sang trái

Mảng. làArray

Mảng không tạo thành một loại ngôn ngữ riêng biệt. Chúng dựa trên các đối tượng

Vì vậy,

arr.splice[start[, deleteCount, elem1, ..., elemN]]

82 không giúp phân biệt một đối tượng đơn giản với một mảng

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

22

…Nhưng mảng được sử dụng thường xuyên đến mức có một phương pháp đặc biệt cho việc đó. Mảng. isArray[giá trị]. Nó trả về

arr.splice[start[, deleteCount, elem1, ..., elemN]]

67 nếu

arr.splice[start[, deleteCount, elem1, ..., elemN]]

84 là một mảng và

arr.splice[start[, deleteCount, elem1, ..., elemN]]

91 nếu ngược lại

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

23

Hầu hết các phương thức đều hỗ trợ “thisArg”

Hầu như tất cả các phương thức mảng gọi hàm – như

arr.splice[start[, deleteCount, elem1, ..., elemN]]

11,

arr.splice[start[, deleteCount, elem1, ..., elemN]]

20,

arr.splice[start[, deleteCount, elem1, ..., elemN]]

44, ngoại trừ đáng chú ý là

arr.splice[start[, deleteCount, elem1, ..., elemN]]

89, đều chấp nhận tham số bổ sung tùy chọn

arr.splice[start[, deleteCount, elem1, ..., elemN]]

90

Tham số đó không được giải thích trong các phần trên, vì nó ít được sử dụng. Nhưng để hoàn thiện, chúng ta phải che đậy nó

Đây là cú pháp đầy đủ của các phương thức này

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

24

Giá trị của tham số

arr.splice[start[, deleteCount, elem1, ..., elemN]]

90 trở thành

arr.splice[start[, deleteCount, elem1, ..., elemN]]

92 cho

arr.splice[start[, deleteCount, elem1, ..., elemN]]

93

Ví dụ: ở đây chúng tôi sử dụng một phương thức của đối tượng

arr.splice[start[, deleteCount, elem1, ..., elemN]]

94 làm bộ lọc và

arr.splice[start[, deleteCount, elem1, ..., elemN]]

90 chuyển ngữ cảnh

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

25

Nếu trong ví dụ trên chúng ta sử dụng

arr.splice[start[, deleteCount, elem1, ..., elemN]]

96, thì

arr.splice[start[, deleteCount, elem1, ..., elemN]]

97 sẽ được gọi như một hàm độc lập, với

arr.splice[start[, deleteCount, elem1, ..., elemN]]

98, do đó dẫn đến lỗi ngay lập tức

Một cuộc gọi đến

arr.splice[start[, deleteCount, elem1, ..., elemN]]

99 có thể được thay thế bằng

let arr = ["I", "study", "JavaScript"];

arr.splice[1, 1]; // from index 1 remove 1 element

alert[ arr ]; // ["I", "JavaScript"]

00, điều đó cũng tương tự. Cái sau được sử dụng thường xuyên hơn, vì nó dễ hiểu hơn một chút đối với hầu hết mọi người

Tóm lược

Một cheat sheet của các phương pháp mảng

• Để thêm/xóa các phần tử

  • let arr = ["I", "study", "JavaScript"];
    
    arr.splice[1, 1]; // from index 1 remove 1 element
    
    alert[ arr ]; // ["I", "JavaScript"]

    01 – thêm các mục vào cuối,

  • let arr = ["I", "study", "JavaScript"];
    
    arr.splice[1, 1]; // from index 1 remove 1 element
    
    alert[ arr ]; // ["I", "JavaScript"]

    02 – trích xuất một mục từ cuối,

  • let arr = ["I", "study", "JavaScript"];
    
    arr.splice[1, 1]; // from index 1 remove 1 element
    
    alert[ arr ]; // ["I", "JavaScript"]

    03 – trích xuất một mục từ đầu,

  • let arr = ["I", "study", "JavaScript"];
    
    arr.splice[1, 1]; // from index 1 remove 1 element
    
    alert[ arr ]; // ["I", "JavaScript"]

    04 – thêm các mục vào đầu

  • let arr = ["I", "study", "JavaScript"];
    
    arr.splice[1, 1]; // from index 1 remove 1 element
    
    alert[ arr ]; // ["I", "JavaScript"]

    05 – tại chỉ mục

    let arr = ["I", "study", "JavaScript"];
    
    arr.splice[1, 1]; // from index 1 remove 1 element
    
    alert[ arr ]; // ["I", "JavaScript"]

    06 xóa các phần tử

    let arr = ["I", "study", "JavaScript"];
    
    // from index 2
    // delete 0
    // then insert "complex" and "language"
    arr.splice[2, 0, "complex", "language"];
    
    alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

    7 và chèn

    let arr = ["I", "study", "JavaScript"];
    
    arr.splice[1, 1]; // from index 1 remove 1 element
    
    alert[ arr ]; // ["I", "JavaScript"]

    08

  • let arr = ["I", "study", "JavaScript"];
    
    arr.splice[1, 1]; // from index 1 remove 1 element
    
    alert[ arr ]; // ["I", "JavaScript"]

    09 – tạo một mảng mới, sao chép các phần tử từ chỉ số

    let arr = ["I", "study", "JavaScript"];
    
    // from index 2
    // delete 0
    // then insert "complex" and "language"
    arr.splice[2, 0, "complex", "language"];
    
    alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

    6 đến

    let arr = ["I", "study", "JavaScript"];
    
    // from index 2
    // delete 0
    // then insert "complex" and "language"
    arr.splice[2, 0, "complex", "language"];
    
    alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

    17 [không bao gồm] vào đó

  • let arr = ["I", "study", "JavaScript"];
    
    arr.splice[1, 1]; // from index 1 remove 1 element
    
    alert[ arr ]; // ["I", "JavaScript"]

    12 – trả về một mảng mới. sao chép tất cả các thành viên của cái hiện tại và thêm

    let arr = ["I", "study", "JavaScript"];
    
    arr.splice[1, 1]; // from index 1 remove 1 element
    
    alert[ arr ]; // ["I", "JavaScript"]

    08 vào nó. Nếu bất kỳ

    let arr = ["I", "study", "JavaScript"];
    
    arr.splice[1, 1]; // from index 1 remove 1 element
    
    alert[ arr ]; // ["I", "JavaScript"]

    08 nào là một mảng, thì các phần tử của nó được lấy

• Để tìm kiếm giữa các yếu tố

  • let arr = ["I", "study", "JavaScript"];
    
    arr.splice[1, 1]; // from index 1 remove 1 element
    
    alert[ arr ]; // ["I", "JavaScript"]

    15 – tìm kiếm

    arr.splice[start[, deleteCount, elem1, ..., elemN]]

    61 bắt đầu từ vị trí

    let arr = ["I", "study", "JavaScript"];
    
    arr.splice[1, 1]; // from index 1 remove 1 element
    
    alert[ arr ]; // ["I", "JavaScript"]

    06, trả lại chỉ mục hoặc

    arr.splice[start[, deleteCount, elem1, ..., elemN]]

    63 nếu không tìm thấy

  • let arr = ["I", "study", "JavaScript"];
    
    arr.splice[1, 1]; // from index 1 remove 1 element
    
    alert[ arr ]; // ["I", "JavaScript"]

    19 – trả về

    arr.splice[start[, deleteCount, elem1, ..., elemN]]

    67 nếu mảng có

    arr.splice[start[, deleteCount, elem1, ..., elemN]]

    84, ngược lại là

    arr.splice[start[, deleteCount, elem1, ..., elemN]]

    91

  • let arr = ["I", "study", "JavaScript"];
    
    arr.splice[1, 1]; // from index 1 remove 1 element
    
    alert[ arr ]; // ["I", "JavaScript"]

    23 – lọc các phần tử thông qua hàm, trả về giá trị đầu tiên/tất cả khiến nó trả về

    arr.splice[start[, deleteCount, elem1, ..., elemN]]

    67

  • arr.splice[start[, deleteCount, elem1, ..., elemN]]

    15 giống như

    arr.splice[start[, deleteCount, elem1, ..., elemN]]

    11, nhưng trả về chỉ mục thay vì giá trị

• Để lặp qua các phần tử

  • let arr = ["I", "study", "JavaScript"];
    
    arr.splice[1, 1]; // from index 1 remove 1 element
    
    alert[ arr ]; // ["I", "JavaScript"]

    27 – gọi

    arr.splice[start[, deleteCount, elem1, ..., elemN]]

    93 cho mọi phần tử, không trả về bất cứ thứ gì

• Để biến đổi mảng

  • let arr = ["I", "study", "JavaScript"];
    
    arr.splice[1, 1]; // from index 1 remove 1 element
    
    alert[ arr ]; // ["I", "JavaScript"]

    29 – tạo một mảng mới từ kết quả của việc gọi

    arr.splice[start[, deleteCount, elem1, ..., elemN]]

    93 cho mọi phần tử

  • let arr = ["I", "study", "JavaScript"];
    
    arr.splice[1, 1]; // from index 1 remove 1 element
    
    alert[ arr ]; // ["I", "JavaScript"]

    31 – sắp xếp mảng tại chỗ, sau đó trả về nó

  • let arr = ["I", "study", "JavaScript"];
    
    arr.splice[1, 1]; // from index 1 remove 1 element
    
    alert[ arr ]; // ["I", "JavaScript"]

    32 – đảo ngược mảng tại chỗ, sau đó trả về nó

  • let arr = ["I", "study", "JavaScript"];
    
    arr.splice[1, 1]; // from index 1 remove 1 element
    
    alert[ arr ]; // ["I", "JavaScript"]

    33 – chuyển đổi một chuỗi thành mảng và ngược lại

  • let arr = ["I", "study", "JavaScript"];
    
    arr.splice[1, 1]; // from index 1 remove 1 element
    
    alert[ arr ]; // ["I", "JavaScript"]

    34 – tính toán một giá trị duy nhất trên mảng bằng cách gọi

    arr.splice[start[, deleteCount, elem1, ..., elemN]]

    93 cho từng phần tử và chuyển kết quả trung gian giữa các lệnh gọi

• Ngoài ra

  • let arr = ["I", "study", "JavaScript"];
    
    arr.splice[1, 1]; // from index 1 remove 1 element
    
    alert[ arr ]; // ["I", "JavaScript"]

    36 kiểm tra

    arr.splice[start[, deleteCount, elem1, ..., elemN]]

    84 có phải là một mảng không, nếu vậy trả về

    arr.splice[start[, deleteCount, elem1, ..., elemN]]

    67, nếu không thì trả về

    arr.splice[start[, deleteCount, elem1, ..., elemN]]

    91

Xin lưu ý rằng các phương thức

arr.splice[start[, deleteCount, elem1, ..., elemN]]

89,

let arr = ["I", "study", "JavaScript"];

arr.splice[1, 1]; // from index 1 remove 1 element

alert[ arr ]; // ["I", "JavaScript"]

41 và

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice[2, 0, "complex", "language"];

alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

11 tự sửa đổi mảng

Những phương pháp này là những phương pháp được sử dụng nhiều nhất, chúng bao gồm 99% các trường hợp sử dụng. Nhưng có rất ít người khác

• mảng. một số[fn]/mảng. every[fn] kiểm tra mảng

  Hàm

  arr.splice[start[, deleteCount, elem1, ..., elemN]]

  27 được gọi trên từng phần tử của mảng tương tự như hàm

  arr.splice[start[, deleteCount, elem1, ..., elemN]]

  44. Nếu bất kỳ/tất cả kết quả là

  arr.splice[start[, deleteCount, elem1, ..., elemN]]

  67, trả về

  arr.splice[start[, deleteCount, elem1, ..., elemN]]

  67, nếu không thì

  arr.splice[start[, deleteCount, elem1, ..., elemN]]

  91

  Các phương thức này hoạt động giống như toán tử

  let arr = ["I", "study", "JavaScript"];
  
  arr.splice[1, 1]; // from index 1 remove 1 element
  
  alert[ arr ]; // ["I", "JavaScript"]

  48 và

  let arr = ["I", "study", "JavaScript"];
  
  arr.splice[1, 1]; // from index 1 remove 1 element
  
  alert[ arr ]; // ["I", "JavaScript"]

  49. nếu

  arr.splice[start[, deleteCount, elem1, ..., elemN]]

  27 trả về một giá trị trung thực, thì

  let arr = ["I", "study", "JavaScript"];
  
  arr.splice[1, 1]; // from index 1 remove 1 element
  
  alert[ arr ]; // ["I", "JavaScript"]

  51 ngay lập tức trả về

  arr.splice[start[, deleteCount, elem1, ..., elemN]]

  67 và ngừng lặp lại các mục còn lại;

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

  let arr = ["I", "study", "JavaScript"];
  
  arr.splice[1, 1]; // from index 1 remove 1 element
  
  alert[ arr ]; // ["I", "JavaScript"]

  56 để so sánh các mảng

  let arr = ["I", "study", "JavaScript"];
  
  // from index 2
  // delete 0
  // then insert "complex" and "language"
  arr.splice[2, 0, "complex", "language"];
  
  alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

  26

• mảng. fill[value, start, end] – điền vào mảng bằng cách lặp lại

  arr.splice[start[, deleteCount, elem1, ..., elemN]]

  84 từ chỉ mục

  let arr = ["I", "study", "JavaScript"];
  
  // from index 2
  // delete 0
  // then insert "complex" and "language"
  arr.splice[2, 0, "complex", "language"];
  
  alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

  6 đến

  let arr = ["I", "study", "JavaScript"];
  
  // from index 2
  // delete 0
  // then insert "complex" and "language"
  arr.splice[2, 0, "complex", "language"];
  
  alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

  17

• mảng. copyWithin[đích, bắt đầu, kết thúc] – sao chép các phần tử của nó từ vị trí

  let arr = ["I", "study", "JavaScript"];
  
  // from index 2
  // delete 0
  // then insert "complex" and "language"
  arr.splice[2, 0, "complex", "language"];
  
  alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

  6 đến vị trí

  let arr = ["I", "study", "JavaScript"];
  
  // from index 2
  // delete 0
  // then insert "complex" and "language"
  arr.splice[2, 0, "complex", "language"];
  
  alert[ arr ]; // "I", "study", "complex", "language", "JavaScript"

  17 vào chính nó, tại vị trí

  let arr = ["I", "study", "JavaScript"];
  
  arr.splice[1, 1]; // from index 1 remove 1 element
  
  alert[ arr ]; // ["I", "JavaScript"]

  62 [ghi đè hiện có]

• mảng. phẳng [độ sâu]/arr. flatMap[fn] tạo mảng phẳng mới từ mảng đa chiều

Để biết danh sách đầy đủ, hãy xem hướng dẫn

Ngay từ cái nhìn đầu tiên, có vẻ như có rất nhiều phương pháp, khá khó nhớ. Nhưng thực ra điều đó dễ dàng hơn nhiều

Xem qua cheat sheet chỉ để biết về chúng. Sau đó giải quyết các nhiệm vụ của chương này để thực hành, để bạn có kinh nghiệm với các phương thức mảng

Sau này, bất cứ khi nào bạn cần làm gì đó với một mảng, và bạn không biết làm thế nào – hãy đến đây, xem cheat sheet và tìm phương pháp phù hợp. Ví dụ sẽ giúp bạn viết nó một cách chính xác. Bạn sẽ sớm tự động ghi nhớ các phương pháp mà không cần nỗ lực cụ thể từ phía bạn