JavaScript的常用数组方法（18个）上

一、concat

concat() 方法是 JavaScript 数组的一个原生方法，用于将多个数组或值合并成一个新数组。

它的语法如下：

array.concat(value1, value2, ..., valueN)

其中，value1 到 valueN 是要合并到数组中的数组或值。可以传递多个参数，每个参数可以是数组或单个值。

以下是一些示例：

const arr1 = [1, 2, 3];
const arr2 = [4, 5, 6];
const arr3 = arr1.concat(arr2);
console.log(arr3); // 输出：[1, 2, 3, 4, 5, 6]

const arr4 = [7, 8, 9];
const arr5 = arr1.concat(arr2, arr4);
console.log(arr5); // 输出：[1, 2, 3, 4, 5, 6, 7, 8, 9]

const arr6 = arr1.concat("hello", [10, 11], "world");
console.log(arr6); // 输出：[1, 2, 3, "hello", 10, 11, "world"]

在上述示例中，我们首先定义了两个数组 arr1 和 arr2，然后使用 concat() 方法将它们合并成一个新数组 arr3。接着，我们又定义了一个数组 arr4，并使用 concat() 方法将 arr1、arr2 和 arr4 合并成一个新数组 arr5。最后，我们使用 concat() 方法将数组、字符串和值合并成一个新数组 arr6。

总的来说，concat() 方法是 JavaScript 数组的一个常用方法，用于合并多个数组或值，并返回一个新数组。它不会修改原始数组，而是返回一个新的数组副本。在实际开发中，可以利用 concat() 方法进行数组的合并操作。

二、join

join() 方法是 JavaScript 数组的一个原生方法，用于将数组中的所有元素转换为一个字符串。

它的语法如下：

array.join(separator)

其中，separator 是可选的参数，表示要使用的分隔符。如果省略了 separator 参数，则默认使用逗号 , 作为分隔符。

以下是一些示例：

const arr = ["apple", "banana", "orange"];
const str1 = arr.join();
console.log(str1); // 输出："apple,banana,orange"

const str2 = arr.join("-");
console.log(str2); // 输出："apple-banana-orange"

在上述示例中，我们首先定义了一个数组 arr，然后使用 join() 方法将其转换为一个字符串 str1。由于没有指定分隔符，因此默认使用逗号 , 作为分隔符。接着，我们又使用 join() 方法将数组转换为一个以横线 - 为分隔符的字符串 str2。

总的来说，join() 方法是 JavaScript 数组的一个常用方法，用于将数组转换为一个字符串。在实际开发中，可以利用 join() 方法将数组中的元素按照指定的格式拼接成一个字符串，从而方便进行数据的处理和传输。

三、pop

pop() 方法是 JavaScript 数组的一个原生方法，用于删除数组中的最后一个元素，并返回被删除的元素。

它的语法如下：

array.pop()

以下是一个示例：

const arr = [1, 2, 3, 4];
const removedElement = arr.pop();
console.log(arr); // 输出：[1, 2, 3]
console.log(removedElement); // 输出：4

在上述示例中，我们首先定义了一个数组 arr，然后使用 pop() 方法删除了数组中的最后一个元素，并将修改后的数组输出到控制台。同时，被删除的元素 4 也被保存到了变量 removedElement 中。

总的来说，pop() 方法是 JavaScript 数组的一个常用方法，用于删除数组中的最后一个元素，并返回被删除的元素。在实际开发中，可以利用 pop() 方法实现对数组的后进先出（LIFO）操作。

四、push

push() 方法是 JavaScript 数组的一个原生方法，用于向数组末尾添加一个或多个元素，并返回修改后数组的长度。

它的语法如下：

array.push(element1, ..., elementN)

其中，element1 到 elementN 是要添加到数组末尾的一个或多个元素。

以下是一个示例：

const arr = [1, 2, 3];
const newLength = arr.push(4, 5);
console.log(arr); // 输出：[1, 2, 3, 4, 5]
console.log(newLength); // 输出：5

在上述示例中，我们首先定义了一个数组 arr，然后使用 push() 方法向数组末尾添加了两个元素 4 和 5。最后，我们将修改后的数组输出到控制台，并将返回值（即修改后数组的长度）保存到变量 newLength 中。

总的来说，push() 方法是 JavaScript 数组的一个常用方法，用于向数组末尾添加一个或多个元素，并返回修改后数组的长度。在实际开发中，可以利用 push() 方法实现对数组的后进先出（LIFO）操作。

五、reverse

reverse() 方法是 JavaScript 数组的一个原生方法，用于反转数组中元素的顺序，并返回修改后的数组。

它的语法如下：

array.reverse()

以下是一个示例：

const arr = [1, 2, 3];
arr.reverse();
console.log(arr); // 输出：[3, 2, 1]

在上述示例中，我们首先定义了一个数组 arr，然后使用 reverse() 方法反转了数组中元素的顺序，并将修改后的数组输出到控制台。

需要注意的是，reverse() 方法会直接修改原数组，而不是创建一个新的数组，因此在使用时需要注意不要影响到原数组中的其他操作。

总的来说，reverse() 方法是 JavaScript 数组的一个常用方法，用于反转数组中元素的顺序。在实际开发中，可以利用 reverse() 方法实现对数组中元素的倒序排列等操作。

六、shift

shift() 方法是 JavaScript 数组的一个原生方法，用于删除数组中的第一个元素，并返回被删除的元素。

它的语法如下：

array.shift()

 以下是一个示例：

const arr = [1, 2, 3];
const removedElement = arr.shift();
console.log(arr); // 输出：[2, 3]
console.log(removedElement); // 输出：1

在上述示例中，我们首先定义了一个数组 arr，然后使用 shift() 方法删除了数组中的第一个元素，并将修改后的数组输出到控制台。同时，被删除的元素 1 也被保存到了变量 removedElement 中。

需要注意的是，当数组为空时调用 shift() 方法会返回 undefined。

总的来说，shift() 方法是 JavaScript 数组的一个常用方法，用于删除数组中的第一个元素，并返回被删除的元素。在实际开发中，可以利用 shift() 方法实现对数组的先进先出（FIFO）操作。

七、unshift

unshift() 方法是 JavaScript 数组的一个原生方法，用于向数组的开头添加一个或多个元素，并返回修改后数组的长度。

它的语法如下：

array.unshift(element1, ..., elementN)

其中，element1 到 elementN 是要添加到数组开头的一个或多个元素。

以下是一个示例：

const arr = [1, 2, 3];
const newLength = arr.unshift(4, 5);
console.log(arr); // 输出：[4, 5, 1, 2, 3]
console.log(newLength); // 输出：5

在上述示例中，我们首先定义了一个数组 arr，然后使用 unshift() 方法向数组开头添加了两个元素 4 和 5。最后，我们将修改后的数组输出到控制台，并将返回值（即修改后数组的长度）保存到变量 newLength 中。

总的来说，unshift() 方法是 JavaScript 数组的一个常用方法，用于向数组开头添加一个或多个元素，并返回修改后数组的长度。在实际开发中，可以利用 unshift() 方法实现对数组的先进先出（FIFO）操作。

八、slice

slice() 方法是 JavaScript 数组的一个原生方法，用于从数组中提取指定位置的元素，返回一个新的数组对象，不会影响原有数组。

它的语法如下：

array.slice(begin, end)

其中，begin 是提取起始位置的索引（从 0 开始），end 是提取结束位置的索引（不包括该位置对应的元素）。如果省略 end，则提取到数组末尾。

以下是一些示例：

const arr = [1, 2, 3, 4, 5];
const slicedArr1 = arr.slice(1, 4);
console.log(slicedArr1); // 输出：[2, 3, 4]

const slicedArr2 = arr.slice(2);
console.log(slicedArr2); // 输出：[3, 4, 5]

const slicedArr3 = arr.slice(-2);
console.log(slicedArr3); // 输出：[4, 5]

在上述示例中，我们首先定义了一个数组 arr，然后使用 slice() 方法从数组中提取了指定位置的元素，并将提取得到的新数组输出到控制台。

需要注意的是，slice() 方法不会修改原有数组，而是返回一个新的数组对象。同时，提取的范围是左闭右开区间，即包括起始位置对应的元素，但不包括结束位置对应的元素。

总的来说，slice() 方法是 JavaScript 数组的一个常用方法，用于从数组中提取指定位置的元素，返回一个新的数组对象，不会影响原有数组。在实际开发中，可以利用 slice() 方法实现对数组的裁剪和复制等操作。

九、splice

splice() 方法是 JavaScript 数组的一个原生方法，用于向数组中插入、删除或替换元素，并返回被删除的元素组成的数组。

它的语法如下：

array.splice(start, deleteCount, item1, item2, ...)

其中，start 是指定修改的起始位置的索引，deleteCount 是要删除的元素个数（如果为 0，则不删除元素），item1 到 itemN 是要添加到数组的新元素。

以下是一些示例：

const arr = [1, 2, 3, 4, 5];
const removed = arr.splice(2, 1); // 从索引 2 开始删除 1 个元素
console.log(arr); // 输出：[1, 2, 4, 5]
console.log(removed); // 输出：[3]

arr.splice(1, 0, 'a', 'b'); // 从索引 1 开始删除 0 个元素，并添加 'a' 和 'b'
console.log(arr); // 输出：[1, 'a', 'b', 2, 4, 5]

arr.splice(2, 2, 'x', 'y', 'z'); // 从索引 2 开始删除 2 个元素，并添加 'x', 'y', 'z'
console.log(arr); // 输出：[1, 'a', 'x', 'y', 'z', 4, 5]

在上述示例中，我们首先定义了一个数组 arr，然后使用 splice() 方法对数组进行了插入、删除和替换操作，并将修改后的数组输出到控制台。同时，我们还将被删除的元素保存在变量 removed 中。

需要注意的是，splice() 方法会修改原有数组，并返回由被删除的元素组成的数组。