Bạn có thể chuyển một mảng để bao gồm javascript không?

Question

Điều đó là bình thường, 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ờ

Nội dung chính Show

Làm cách nào để chuyển nhiều giá trị trong mảng trong JavaScript?
Mảng có bao gồm hoạt động với các đối tượng không?
Tôi có thể sử dụng bao gồm JavaScript không?
Làm cách nào để kiểm tra mảng chứa nhiều giá trị trong JavaScript?

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

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", "right", "now"];

// remove 3 first elements and replace them with another
arr.splice(0, 3, "Let's", "dance");

alert( arr ) // now ["Let's", "dance", "right", "now"]

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

let arr = [1, 2, 5];

// from index -1 (one step from the end)
// delete 0 elements,
// then insert 3 and 4
arr.splice(-1, 0, 3, 4);

alert( arr ); // 1,2,3,4,5

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

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

// remove 2 first elements
let removed = arr.splice(0, 2);

alert( removed ); // "I", "study" <-- array of removed elements

Phương thức

let arr = [1, 2, 5];

// from index -1 (one step from the end)
// delete 0 elements,
// then insert 3 and 4
arr.splice(-1, 0, 3, 4);

alert( arr ); // 1,2,3,4,5

1 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 = [1, 2, 5];

// from index -1 (one step from the end)
// delete 0 elements,
// then insert 3 and 4
arr.splice(-1, 0, 3, 4);

alert( arr ); // 1,2,3,4,5

4

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 = [1, 2, 5];

// from index -1 (one step from the end)
// delete 0 elements,
// then insert 3 and 4
arr.splice(-1, 0, 3, 4);

alert( arr ); // 1,2,3,4,5

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

let arr = [1, 2, 5];

// from index -1 (one step from the end)
// delete 0 elements,
// then insert 3 and 4
arr.splice(-1, 0, 3, 4);

alert( arr ); // 1,2,3,4,5

5

Cú pháp là

arr.slice([start], [end])

Nó trả về một mảng mới sao chép vào nó 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 = [1, 2, 5];

// from index -1 (one step from the end)
// delete 0 elements,
// then insert 3 and 4
arr.splice(-1, 0, 3, 4);

alert( arr ); // 1,2,3,4,5

7 (không bao gồm

let arr = [1, 2, 5];

// from index -1 (one step from the end)
// delete 0 elements,
// then insert 3 and 4
arr.splice(-1, 0, 3, 4);

alert( arr ); // 1,2,3,4,5

7). 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 = [1, 2, 5];

// from index -1 (one step from the end)
// delete 0 elements,
// then insert 3 and 4
arr.splice(-1, 0, 3, 4);

alert( arr ); // 1,2,3,4,5

7 đề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

arr.slice([start], [end])

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

Ví dụ

let arr = ["t", "e", "s", "t"];

alert( arr.slice(1, 3) ); // e,s (copy from 1 to 3)

alert( arr.slice(-2) ); // s,t (copy from -2 till the end)

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

arr.slice([start], [end])

2 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

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.concat(arg1, arg2...)

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à

arr.slice([start], [end])

5,

arr.slice([start], [end])

6, v.v.

Nếu một đối số

arr.slice([start], [end])

7 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

arr.slice([start], [end])

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

arr.slice([start], [end])

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

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

2

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

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

Các phương thức arr. indexOf và arr. 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ự

let arr = ["t", "e", "s", "t"];

alert( arr.slice(1, 3) ); // e,s (copy from 1 to 3)

alert( arr.slice(-2) ); // s,t (copy from -2 till the end)

0 – tìm kiếm

let arr = ["t", "e", "s", "t"];

alert( arr.slice(1, 3) ); // e,s (copy from 1 to 3)

alert( arr.slice(-2) ); // s,t (copy from -2 till the end)

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

let arr = ["t", "e", "s", "t"];

alert( arr.slice(1, 3) ); // e,s (copy from 1 to 3)

alert( arr.slice(-2) ); // s,t (copy from -2 till the end)

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

let arr = ["t", "e", "s", "t"];

alert( arr.slice(1, 3) ); // e,s (copy from 1 to 3)

alert( arr.slice(-2) ); // s,t (copy from -2 till the end)

3

let arr = ["t", "e", "s", "t"];

alert( arr.slice(1, 3) ); // e,s (copy from 1 to 3)

alert( arr.slice(-2) ); // s,t (copy from -2 till the end)

4 – tìm kiếm

let arr = ["t", "e", "s", "t"];

alert( arr.slice(1, 3) ); // e,s (copy from 1 to 3)

alert( arr.slice(-2) ); // s,t (copy from -2 till the end)

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

let arr = ["t", "e", "s", "t"];

alert( arr.slice(1, 3) ); // e,s (copy from 1 to 3)

alert( arr.slice(-2) ); // s,t (copy from -2 till the end)

2, trả về

let arr = ["t", "e", "s", "t"];

alert( arr.slice(1, 3) ); // e,s (copy from 1 to 3)

alert( arr.slice(-2) ); // s,t (copy from -2 till the end)

7 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ố.

let arr = ["t", "e", "s", "t"];

alert( arr.slice(1, 3) ); // e,s (copy from 1 to 3)

alert( arr.slice(-2) ); // s,t (copy from -2 till the end)

1 để 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

let arr = ["t", "e", "s", "t"];

alert( arr.slice(1, 3) ); // e,s (copy from 1 to 3)

alert( arr.slice(-2) ); // s,t (copy from -2 till the end)

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

arr.concat(arg1, arg2...)

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

arr.concat(arg1, arg2...)

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

arr.concat(arg1, arg2...)

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

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

let arr = ["t", "e", "s", "t"];

alert( arr.slice(1, 3) ); // e,s (copy from 1 to 3)

alert( arr.slice(-2) ); // s,t (copy from -2 till the end)

1 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.concat(arg1, arg2...)

4

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

let arr = ["t", "e", "s", "t"];

alert( arr.slice(1, 3) ); // e,s (copy from 1 to 3)

alert( arr.slice(-2) ); // s,t (copy from -2 till the end)

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

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

7

Phương thức

arr.concat(arg1, arg2...)

6 xử lý chính xác

arr.concat(arg1, arg2...)

7

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

arr.concat(arg1, arg2...)

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

arr.concat(arg1, arg2...)

7, không giống như

let arr = ["t", "e", "s", "t"];

alert( arr.slice(1, 3) ); // e,s (copy from 1 to 3)

alert( arr.slice(-2) ); // s,t (copy from -2 till the end)

9

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

8

Đó là bởi vì

arr.concat(arg1, arg2...)

6 đã đượ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ộ

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

let arr = ["t", "e", "s", "t"];

alert( arr.slice(1, 3) ); // e,s (copy from 1 to 3)

alert( arr.slice(-2) ); // s,t (copy from -2 till the end)

1 là phần tử

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

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

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

04 là chính mảng đó

Nếu nó trả về

let arr = ["t", "e", "s", "t"];

alert( arr.slice(1, 3) ); // e,s (copy from 1 to 3)

alert( arr.slice(-2) ); // s,t (copy from -2 till the end)

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

let arr = ["t", "e", "s", "t"];

alert( arr.slice(1, 3) ); // e,s (copy from 1 to 3)

alert( arr.slice(-2) ); // s,t (copy from -2 till the end)

1 đượ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

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

let arr = ["t", "e", "s", "t"];

alert( arr.slice(1, 3) ); // e,s (copy from 1 to 3)

alert( arr.slice(-2) ); // s,t (copy from -2 till the end)

3 đượ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

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ề

let arr = ["t", "e", "s", "t"];

alert( arr.slice(1, 3) ); // e,s (copy from 1 to 3)

alert( arr.slice(-2) ); // s,t (copy from -2 till the end)

7

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

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

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

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 thực hiện 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", "right", "now"];

// remove 3 first elements and replace them with another
arr.splice(0, 3, "Let's", "dance");

alert( arr ) // now ["Let's", "dance", "right", "now"]

0

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", "right", "now"];

// remove 3 first elements and replace them with another
arr.splice(0, 3, "Let's", "dance");

alert( arr ) // now ["Let's", "dance", "right", "now"]

1

Đ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?

Đố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", "right", "now"];

// remove 3 first elements and replace them with another
arr.splice(0, 3, "Let's", "dance");

alert( arr ) // now ["Let's", "dance", "right", "now"]

2

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", "right", "now"];

// remove 3 first elements and replace them with another
arr.splice(0, 3, "Let's", "dance");

alert( arr ) // now ["Let's", "dance", "right", "now"]

3

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

Đâ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", "right", "now"];

// remove 3 first elements and replace them with another
arr.splice(0, 3, "Let's", "dance");

alert( arr ) // now ["Let's", "dance", "right", "now"]

4

Phương thức

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

35 có đố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", "right", "now"];

// remove 3 first elements and replace them with another
arr.splice(0, 3, "Let's", "dance");

alert( arr ) // now ["Let's", "dance", "right", "now"]

5

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

Lệnh gọi tới

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

36 với một số trống

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

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

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

// remove 3 first elements and replace them with another
arr.splice(0, 3, "Let's", "dance");

alert( arr ) // now ["Let's", "dance", "right", "now"]

6

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", "right", "now"];

// remove 3 first elements and replace them with another
arr.splice(0, 3, "Let's", "dance");

alert( arr ) // now ["Let's", "dance", "right", "now"]

7

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", "right", "now"];

// remove 3 first elements and replace them with another
arr.splice(0, 3, "Let's", "dance");

alert( arr ) // now ["Let's", "dance", "right", "now"]

8

Hàm được áp dụng lần lượt cho tất cả các phần tử của 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 ____2_______46 lần đầu tiên (nếu cung cấp ______2_______46)

let arr = ["t", "e", "s", "t"];

alert( arr.slice(1, 3) ); // e,s (copy from 1 to 3)

alert( arr.slice(-2) ); // s,t (copy from -2 till the end)

1 – 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

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", "right", "now"];

// remove 3 first elements and replace them with another
arr.splice(0, 3, "Let's", "dance");

alert( arr ) // now ["Let's", "dance", "right", "now"]

9

Hàm được chuyển đến

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

Ở lần chạy đầu tiên,

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

53 là giá trị

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 = [1, 2, 5];

// from index -1 (one step from the end)
// delete 0 elements,
// then insert 3 and 4
arr.splice(-1, 0, 3, 4);

alert( arr ); // 1,2,3,4,5

4 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ì vậy, kết quả chức năng 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

Ở lần chạy thứ hai,
```
arr.splice(start[, deleteCount, elem1, ..., elemN])
```
60, chúng ta thêm phần tử mảng thứ hai (
```
arr.splice(start[, deleteCount, elem1, ..., elemN])
```
61) vào nó và trả về
Ở 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 đó, 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])

57resultthe first call

let arr = [1, 2, 5];

// from index -1 (one step from the end)
// delete 0 elements,
// then insert 3 and 4
arr.splice(-1, 0, 3, 4);

alert( arr ); // 1,2,3,4,5

4

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"

9the second call

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])

70the third call

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

70

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

70

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

73the fourth call

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

73

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

75

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

76the fifth call

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", "right", "now"];

// remove 2 first elements
let removed = arr.splice(0, 2);

alert( removed ); // "I", "study" <-- array of removed elements

0

Kết quả là như nhau. Đó là bởi vì nếu không có phần đầ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", "right", "now"];

// remove 2 first elements
let removed = arr.splice(0, 2);

alert( removed ); // "I", "study" <-- array of removed elements

1

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 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", "right", "now"];

// remove 2 first elements
let removed = arr.splice(0, 2);

alert( removed ); // "I", "study" <-- array of removed elements

2

…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ề

let arr = ["t", "e", "s", "t"];

alert( arr.slice(1, 3) ); // e,s (copy from 1 to 3)

alert( arr.slice(-2) ); // s,t (copy from -2 till the end)

7 nếu

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

84 là một mảng và

arr.concat(arg1, arg2...)

1 nếu ngược lại

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

// remove 2 first elements
let removed = arr.splice(0, 2);

alert( removed ); // "I", "study" <-- array of removed elements

3

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

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

11,

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

20,

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

44, với một ngoại lệ đáng chú ý là

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

89, chấp nhận một 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", "right", "now"];

// remove 2 first elements
let removed = arr.splice(0, 2);

alert( removed ); // "I", "study" <-- array of removed elements

4

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", "right", "now"];

// remove 2 first elements
let removed = arr.splice(0, 2);

alert( removed ); // "I", "study" <-- array of removed elements

5

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

Có thể thay thế lệnh gọi tới

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

99 bằng ________________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

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 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 vào

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 = [1, 2, 5];

// from index -1 (one step from the end)
// delete 0 elements,
// then insert 3 and 4
arr.splice(-1, 0, 3, 4);

alert( arr ); // 1,2,3,4,5

7 (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ỳ trong số

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

arr.splice(1, 1); // from index 1 remove 1 element

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

08 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

let arr = ["t", "e", "s", "t"];

alert( arr.slice(1, 3) ); // e,s (copy from 1 to 3)

alert( arr.slice(-2) ); // s,t (copy from -2 till the end)

1 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

let arr = ["t", "e", "s", "t"];

alert( arr.slice(1, 3) ); // e,s (copy from 1 to 3)

alert( arr.slice(-2) ); // s,t (copy from -2 till the end)

3 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ề

let arr = ["t", "e", "s", "t"];

alert( arr.slice(1, 3) ); // e,s (copy from 1 to 3)

alert( arr.slice(-2) ); // s,t (copy from -2 till the end)

7 nếu mảng có

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

84, nếu không thì

arr.concat(arg1, arg2...)

1

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 hàm trả về

let arr = ["t", "e", "s", "t"];

alert( arr.slice(1, 3) ); // e,s (copy from 1 to 3)

alert( arr.slice(-2) ); // s,t (copy from -2 till the end)

7

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ần 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ề

let arr = ["t", "e", "s", "t"];

alert( arr.slice(1, 3) ); // e,s (copy from 1 to 3)

alert( arr.slice(-2) ); // s,t (copy from -2 till the end)

7, nếu không thì

arr.concat(arg1, arg2...)

1

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 = [1, 2, 5];

// from index -1 (one step from the end)
// delete 0 elements,
// then insert 3 and 4
arr.splice(-1, 0, 3, 4);

alert( arr ); // 1,2,3,4,5

1 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 mỗi 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ả các kết quả là _______26_______7, trả về __26_______7, nếu không thì _______29_______1

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ề

let arr = ["t", "e", "s", "t"];

alert( arr.slice(1, 3) ); // e,s (copy from 1 to 3)

alert( arr.slice(-2) ); // s,t (copy from -2 till the end)

7 và ngừng lặp qua 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", "right", "now"];

// remove 2 first elements
let removed = arr.splice(0, 2);

alert( removed ); // "I", "study" <-- array of removed elements

6

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 = [1, 2, 5];

// from index -1 (one step from the end)
// delete 0 elements,
// then insert 3 and 4
arr.splice(-1, 0, 3, 4);

alert( arr ); // 1,2,3,4,5

7

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 = [1, 2, 5];

// from index -1 (one step from the end)
// delete 0 elements,
// then insert 3 and 4
arr.splice(-1, 0, 3, 4);

alert( arr ); // 1,2,3,4,5

7 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

Làm cách nào để chuyển nhiều giá trị trong mảng trong JavaScript?

Sử dụng Mảng. phương thức concat() để đẩy nhiều giá trị vào một mảng , e. g. kết quả const = mảng. concat('b', 'c', 'd');.

Mảng có bao gồm hoạt động với các đối tượng không?

Có nhiều phương pháp để kiểm tra một mảng có đối tượng hay không. Sử dụng phương thức bao gồm (). Nếu mảng có chứa đối tượng/phần tử thì có thể xác định bằng cách sử dụng phương thức include() . Phương thức này trả về true nếu mảng chứa đối tượng/phần tử khác trả về false.

Tôi có thể sử dụng bao gồm JavaScript không?

Phương thức include() xác định xem một mảng có bao gồm một giá trị nhất định trong số các mục nhập của nó hay không, trả về giá trị đúng hoặc sai nếu thích hợp .

Làm cách nào để kiểm tra mảng chứa nhiều giá trị trong JavaScript?

Để kiểm tra xem có tồn tại nhiều giá trị trong một mảng hay không. .

Sử dụng phương thức every() để lặp qua mảng giá trị

Trên mỗi lần lặp, hãy sử dụng phương thức indexOf để kiểm tra xem giá trị có được chứa trong mảng khác không

Nếu tất cả các giá trị tồn tại trong mảng, mọi phương thức sẽ trả về true

programming javascript

Bạn có thể chuyển một mảng để bao gồm javascript không?

Làm cách nào để chuyển nhiều giá trị trong mảng trong JavaScript?

Mảng có bao gồm hoạt động với các đối tượng không?

Tôi có thể sử dụng bao gồm JavaScript không?

Làm cách nào để kiểm tra mảng chứa nhiều giá trị trong JavaScript?

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội