push()方法 它可以在数组的末尾添加一个或多个元素，并返回新数组的长度。这个方法可以接受任意数量的参数，每个参数都会添加到数组的末尾。

以下是 push() 方法的语法：

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

其中，array 是要操作的数组，element1, element2, ..., elementN 是要添加到数组末尾的一个或多个元素。 以下是一个使用 push() 方法添加元素的例子：

const fruits = ['apple', 'banana'];
const newLength = fruits.push('orange', 'pear');
console.log(fruits); // ["apple", "banana", "orange", "pear"]
console.log(newLength); // 4

在这个例子中，fruits 数组一开始包含两个元素："apple" 和 "banana"。然后，我们调用 push() 方法，并传递两个参数 "orange" 和 "pear"。push() 方法将这两个元素添加到数组的末尾，并返回新数组的长度 4。最后，我们输出了新的 fruits 数组和 newLength 变量的值。

需要注意的是，push() 方法会直接修改原始数组，而不是创建一个新的数组。如果你需要创建一个新的数组并向其中添加元素，可以使用 concat() 方法。

它可以从数组的末尾删除一个元素，并返回被删除的元素。这个方法不需要接受任何参数，它只是从数组的末尾删除一个元素。 以下是 pop() 方法的语法：

array.pop()

其中，array 是要操作的数组。 以下是一个使用 pop() 方法删除元素的例子：

const fruits = ['apple', 'banana', 'orange'];
const deletedFruit = fruits.pop();
console.log(fruits); // ["apple", "banana"]
console.log(deletedFruit); // "orange"

在这个例子中，fruits 数组一开始包含三个元素："apple"、"banana" 和 "orange"。然后，我们调用 pop() 方法，它会从数组的末尾删除 "orange" 元素，并返回 "orange"。最后，我们输出了新的 fruits 数组和 deletedFruit 变量的值。 需要注意的是，pop() 方法会直接修改原始数组，而不是创建一个新的数组。如果你需要创建一个新的数组并从中删除元素，可以使用 slice() 或 splice() 方法。

它可以在数组的开头添加一个或多个元素，并返回新数组的长度。这个方法可以接受任意数量的参数，每个参数都会添加到数组的开头。

以下是 unshift() 方法的语法：

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

其中，array 是要操作的数组，element1, element2, ..., elementN 是要添加到数组开头的一个或多个元素。

以下是一个使用 unshift() 方法添加元素的例子：

const fruits = ['apple', 'banana'];
const newLength = fruits.unshift('orange', 'pear');
console.log(fruits); // ["orange", "pear", "apple", "banana"]
console.log(newLength); // 4

在这个例子中，fruits 数组一开始包含两个元素："apple" 和 "banana"。然后，我们调用 unshift() 方法，并传递两个参数 "orange" 和 "pear"。unshift() 方法将这两个元素添加到数组的开头，并返回新数组的长度 4。最后，我们输出了新的 fruits 数组和 newLength 变量的值。

需要注意的是，unshift() 方法会直接修改原始数组，而不是创建一个新的数组。如果你需要创建一个新的数组并向其中添加元素，可以使用 concat() 方法。

它可以从数组的开头删除一个元素，并返回被删除的元素。这个方法不需要接受任何参数，它只是从数组的开头删除一个元素。 以下是 shift() 方法的语法：

array.shift()

其中，array 是要操作的数组。 以下是一个使用 shift() 方法删除元素的例子：

const fruits = ['orange', 'pear', 'apple', 'banana'];
const deletedFruit = fruits.shift();
console.log(fruits); // ["pear", "apple", "banana"]
console.log(deletedFruit); // "orange"

在这个例子中，fruits 数组一开始包含四个元素："orange"、"pear"、"apple" 和 "banana"。然后，我们调用 shift() 方法，它会从数组的开头删除 "orange" 元素，并返回 "orange"。最后，我们输出了新的 fruits 数组和 deletedFruit 变量的值。 需要注意的是，shift() 方法会直接修改原始数组，而不是创建一个新的数组。如果你需要创建一个新的数组并从中删除元素，可以使用 slice() 或 splice() 方法。

它可以将数组中的元素反转，并返回反转后的数组。该方法会修改原始数组，而不会创建一个新的数组。 以下是 reverse() 方法的语法：

array.reverse()

其中，array 是要操作的数组。 以下是一个使用 reverse() 方法反转数组的例子：

const fruits = ['orange', 'pear', 'apple', 'banana'];
fruits.reverse();
console.log(fruits); // ["banana", "apple", "pear", "orange"]

在这个例子中，fruits 数组一开始包含四个元素："orange"、"pear"、"apple" 和 "banana"。然后，我们调用 reverse() 方法，它会将数组中的元素反转，并返回反转后的数组。最后，我们输出了新的 fruits 数组。 需要注意的是，reverse() 方法会直接修改原始数组，而不是创建一个新的数组。如果你需要创建一个新的数组并对其进行反转，可以使用 slice() 和 reverse() 方法组合起来使用。例如：

const fruits = ['orange', 'pear', 'apple', 'banana'];
const reversedFruits = fruits.slice().reverse();
console.log(fruits); // ["orange", "pear", "apple", "banana"]
console.log(reversedFruits); // ["banana", "apple", "pear", "orange"]

在这个例子中，我们先使用 slice() 方法创建了一个新的数组，然后再使用 reverse() 方法反转这个新的数组，最后输出原始数组和新的反转后的数组。

它可以对数组中的元素进行排序，并返回排序后的数组。该方法会修改原始数组，而不会创建一个新的数组。

以下是 sort() 方法的语法：

array.sort(compareFunction)

其中，array 是要操作的数组，compareFunction 是一个可选的函数参数，用于指定排序规则。 如果省略 compareFunction 参数，则 sort() 方法默认按照字符串的 Unicode 编码进行排序。例如，以下代码会按照 Unicode 编码将数组中的元素排序：

const fruits = ['banana', 'apple', 'pear', 'orange'];
fruits.sort();
console.log(fruits); // ["apple", "banana", "orange", "pear"]

如果指定了 compareFunction 参数，则 sort() 方法会使用该参数指定的排序规则进行排序。compareFunction 参数应该是一个函数，它接受两个参数，并返回一个数值：

• 如果第一个参数应该排在第二个参数的前面，则返回一个负数；
• 如果第一个参数应该排在第二个参数的后面，则返回一个正数；
• 如果两个参数相等，则返回 0。
• 以下是一个使用 compareFunction 参数自定义排序规则的例子：

const numbers = [10, 2, 5, 1, 9];
numbers.sort(function(a, b) {
  return a - b;
});
console.log(numbers); // [1, 2, 5, 9, 10]

在这个例子中，我们定义了一个 compareFunction 函数，它接受两个参数 a 和 b，并返回 a - b。这个函数的作用是将数组中的元素按照升序排序。然后，我们将这个函数作为参数传递给 sort() 方法，它会使用该函数指定的排序规则对数组进行排序。最后，我们输出排序后的数组。 需要注意的是，sort() 方法会直接修改原始数组，而不是创建一个新的数组。如果你需要创建一个新的数组并对其进行排序，可以使用 slice() 和 sort() 方法组合起来使用。例如：

const numbers = [10, 2, 5, 1, 9];
const sortedNumbers = numbers.slice().sort(function(a, b) {
  return a - b;
});
console.log(numbers); // [10, 2, 5, 1, 9]
console.log(sortedNumbers); // [1, 2, 5, 9, 10]

在这个例子中，我们先使用 slice() 方法创建了一个新的数组，然后再使用 sort() 方法对其进行排序，最后输出原始数组和新的排序后的数组。

用于在数组中添加或删除元素，并返回被删除的元素。 以下是 splice() 方法的语法：

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

其中：

• array 是要操作的数组。
• start 是要删除或插入元素的起始位置。如果该参数是负数，则表示从数组末尾开始计算的位置。
• deleteCount 是要删除的元素个数。如果省略该参数，则从起始位置开始删除所有元素。
• item1, item2, ... 是要插入到数组中的元素。 以下是一个使用 splice() 方法删除元素的例子：

const fruits = ['apple', 'banana', 'orange', 'pear'];
fruits.splice(1, 2);
console.log(fruits); // ["apple", "pear"]

在这个例子中，我们使用 splice() 方法从数组 fruits 中删除了从索引 1 开始的 2 个元素，也就是 banana 和 orange。然后，我们输出删除后的数组，得到 ["apple", "pear"]。 以下是一个使用 splice() 方法插入元素的例子：

const fruits = ['apple', 'banana', 'pear'];
fruits.splice(1, 0, 'orange');
console.log(fruits); // ["apple", "orange", "banana", "pear"]

在这个例子中，我们使用 splice() 方法从数组 fruits 的索引 1 开始插入了一个元素 'orange'。然后，我们输出插入后的数组，得到 ["apple", "orange", "banana", "pear"]。 需要注意的是，splice() 方法会修改原始数组，并返回被删除的元素。如果省略了 deleteCount 参数，则会从 start 开始删除所有后面的元素。如果 deleteCount 参数为 0，则不会删除任何元素，只会插入新的元素。如果 start 参数是负数，则表示从数组末尾开始计算的位置。

用于将多个数组合并成一个新数组，而不会修改原始数组。 以下是 concat() 方法的语法：

array.concat(array1, array2, ..., arrayN)

其中，array 是要合并的数组，array1, array2, ..., arrayN 是要合并的其他数组。 以下是一个使用 concat() 方法合并数组的例子：

const array1 = [1, 2, 3];
const array2 = [4, 5, 6];
const array3 = array1.concat(array2);
console.log(array3); // [1, 2, 3, 4, 5, 6]

在这个例子中，我们使用 concat() 方法将 array1 和 array2 两个数组合并成一个新的数组 array3，而不会修改原始数组 array1 和 array2。然后，我们输出合并后的数组，得到 [1, 2, 3, 4, 5, 6]。 需要注意的是，concat() 方法返回一个新数组，原始数组不会被修改。如果要将多个数组合并到一个数组中，可以多次调用 concat() 方法，或者使用扩展运算符 ...，如下所示：

const array1 = [1, 2, 3];
const array2 = [4, 5, 6];
const array3 = [7, 8, 9];
const array4 = [...array1, ...array2, ...array3];
console.log(array4); // [1, 2, 3, 4, 5, 6, 7, 8, 9]

在这个例子中，我们使用扩展运算符 ... 将 array1、array2 和 array3 三个数组合并到一个新的数组 array4 中，得到 [1, 2, 3, 4, 5, 6, 7, 8, 9]。

用于将数组中的所有元素连接成一个字符串。该方法可以接收一个可选的参数，用于指定连接元素之间的分隔符。 以下是 join() 方法的语法：

array.join(separator)

其中，array 是要连接的数组，separator 是可选的分隔符，用于指定连接元素之间的字符串。如果不提供分隔符，则默认使用逗号 ,。 以下是一个使用 join() 方法连接数组的例子：

const array = ['apple', 'banana', 'orange'];
const str = array.join(', ');
console.log(str); // "apple, banana, orange"

在这个例子中，我们使用 join() 方法将 array 数组中的所有元素连接成一个字符串，并且使用逗号和空格作为分隔符。然后，我们输出连接后的字符串，得到 "apple, banana, orange"。 需要注意的是，join() 方法返回一个字符串，原始数组不会被修改。如果要将字符串转换回数组，可以使用 split() 方法，如下所示：

const str = 'apple, banana, orange';
const array = str.split(', ');
console.log(array); // ["apple", "banana", "orange"]

在这个例子中，我们使用 split() 方法将字符串 str 按照逗号和空格分隔为一个新数组 array，得到 ["apple", "banana", "orange"]。

用于从数组中提取某一段元素，生成一个新的数组。该方法接受两个参数，起始索引和终止索引（不包括），并返回一个新数组。 以下是 slice() 方法的语法：

array.slice(startIndex, endIndex)

其中，array 是要提取元素的数组，startIndex 是起始索引（包括），endIndex 是终止索引（不包括）。如果不提供 endIndex 参数，则默认提取从 startIndex 开始到数组末尾的所有元素。 以下是一个使用 slice() 方法提取数组元素的例子：

const array = [1, 2, 3, 4, 5];
const subArray = array.slice(1, 4);
console.log(subArray); // [2, 3, 4]

在这个例子中，我们使用 slice() 方法从 array 数组中提取了从索引 1（包括）到索引 4（不包括）的元素，得到了一个新数组 subArray，它包含 [2, 3, 4] 这三个元素。 需要注意的是，slice() 方法不会修改原始数组，它会返回一个新数组。如果不提供参数，它会返回原始数组的一个副本。 如果想要提取数组的最后几个元素，可以使用负数作为参数。例如，如果要提取数组的最后三个元素，可以这样写：

const array = [1, 2, 3, 4, 5];
const subArray = array.slice(-3);
console.log(subArray); // [3, 4, 5]

在这个例子中，我们使用 slice() 方法并将 -3 作为参数，它会从数组的倒数第三个元素开始提取到数组的最后一个元素，得到了一个新数组 subArray，它包含 [3, 4, 5] 这三个元素。

用于查找给定元素在数组中第一次出现的位置。如果找到该元素，则返回其在数组中的索引值；如果未找到，则返回 -1。 以下是 indexOf() 方法的语法：

array.indexOf(searchElement, fromIndex)

其中，array 是要查找元素的数组，searchElement 是要查找的元素，fromIndex 是查找的起始位置。如果不提供 fromIndex 参数，则默认从数组的第一个元素开始查找。 以下是一个使用 indexOf() 方法查找数组元素的例子：

const array = [1, 2, 3, 4, 5];
const index = array.indexOf(3);
console.log(index); // 2

在这个例子中，我们使用 indexOf() 方法查找 array 数组中第一次出现的元素 3，它在数组中的索引值为 2，因此 index 的值为 2。 如果要查找一个不存在于数组中的元素，indexOf() 方法会返回 -1。例如：

const array = [1, 2, 3, 4, 5];
const index = array.indexOf(6);
console.log(index); // -1

在这个例子中，我们使用 indexOf() 方法查找 array 数组中第一次出现的元素 6，由于该元素不存在于数组中，因此 indexOf() 方法返回 -1。 需要注意的是，indexOf() 方法只会查找第一次出现的位置，如果要查找所有出现的位置，可以使用 forEach() 或者 filter() 方法进行遍历。

用于查找给定元素在数组中最后一次出现的位置。如果找到该元素，则返回其在数组中的索引值；如果未找到，则返回 -1。 以下是 lastIndexOf() 方法的语法：

array.lastIndexOf(searchElement, fromIndex)

其中，array 是要查找元素的数组，searchElement 是要查找的元素，fromIndex 是查找的起始位置。如果不提供 fromIndex 参数，则默认从数组的最后一个元素开始查找。 以下是一个使用 lastIndexOf() 方法查找数组元素的例子：

const array = [1, 2, 3, 4, 5, 3];
const index = array.lastIndexOf(3);
console.log(index); // 5

在这个例子中，我们使用 lastIndexOf() 方法查找 array 数组中最后一次出现的元素 3，它在数组中的索引值为 5，因此 index 的值为 5。 如果要查找一个不存在于数组中的元素，lastIndexOf() 方法会返回 -1。例如：

const array = [1, 2, 3, 4, 5];
const index = array.lastIndexOf(6);
console.log(index); // -1

在这个例子中，我们使用 lastIndexOf() 方法查找 array 数组中最后一次出现的元素 6，由于该元素不存在于数组中，因此 lastIndexOf() 方法返回 -1。 需要注意的是，lastIndexOf() 方法只会查找最后一次出现的位置，如果要查找所有出现的位置，可以使用 forEach() 或者 filter() 方法进行遍历。

用于对数组中的每个元素执行指定的操作。可以使用 forEach() 方法来遍历数组中的每个元素，而无需使用 for 循环。 以下是 forEach() 方法的语法：

array.forEach(callback(currentValue, index, array), thisArg)

其中，array 是要遍历的数组，callback 是要执行的函数。该函数会接收三个参数：当前遍历到的元素 currentValue，当前元素的索引 index，以及遍历的数组本身 array。可以使用这些参数来执行自定义的操作。 以下是一个使用 forEach() 方法遍历数组的例子：

const array = [1, 2, 3, 4, 5];
array.forEach(function(element) {
  console.log(element);
});

在这个例子中，我们使用 forEach() 方法遍历 array 数组中的每个元素，并使用 console.log() 函数将它们输出到控制台。 需要注意的是，forEach() 方法不会修改原始数组。如果需要修改数组，可以在回调函数中对元素进行修改。 除了 currentValue、index 和 array 参数之外，forEach() 方法还接受一个可选的 thisArg 参数。该参数用于指定在回调函数中使用的 this 关键字。如果省略 thisArg 参数，则默认使用全局对象。

用于将数组中的每个元素通过某个函数进行转换，生成一个新的数组。 以下是 map() 方法的语法：

array.map(callback(currentValue, index, array), thisArg)

其中，array 是要转换的数组，callback 是要执行的函数。该函数会接收三个参数：当前遍历到的元素 currentValue，当前元素的索引 index，以及遍历的数组本身 array。可以使用这些参数来执行自定义的操作，返回值会被添加到新的数组中。 以下是一个使用 map() 方法将数组中的元素都乘以 2 的例子：

const array = [1, 2, 3, 4, 5];
const newArray = array.map(function(element) {
  return element * 2;
});
console.log(newArray);

在这个例子中，我们使用 map() 方法将 array 数组中的每个元素都乘以 2，并生成一个新的数组 newArray。然后使用 console.log() 函数将新数组输出到控制台。 需要注意的是，map() 方法不会修改原始数组。如果需要修改数组，可以在回调函数中对元素进行修改。 除了 currentValue、index 和 array 参数之外，map() 方法还接受一个可选的 thisArg 参数。该参数用于指定在回调函数中使用的 this 关键字。如果省略 thisArg 参数，则默认使用全局对象。

用于从数组中过滤出符合指定条件的元素，并返回一个新的数组。 以下是 filter() 方法的语法：

array.filter(callback(currentValue, index, array), thisArg)

其中，array 是要过滤的数组，callback 是用来测试每个元素的函数。该函数接收三个参数：当前遍历到的元素 currentValue，当前元素的索引 index，以及遍历的数组本身 array。使用这些参数来执行自定义的测试，返回值为 true 表示元素符合条件，将被包含在返回的新数组中，返回值为 false 则不会被包含在新数组中。 以下是一个使用 filter() 方法将数组中的偶数元素筛选出来的例子：

const array = [1, 2, 3, 4, 5];
const newArray = array.filter(function(element) {
  return element % 2 === 0;
});
console.log(newArray);

在这个例子中，我们使用 filter() 方法将 array 数组中的偶数元素筛选出来，并生成一个新的数组 newArray。然后使用 console.log() 函数将新数组输出到控制台。 需要注意的是，filter() 方法不会修改原始数组。如果需要修改数组，可以在回调函数中对元素进行修改。 除了 currentValue、index 和 array 参数之外，filter() 方法还接受一个可选的 thisArg 参数。该参数用于指定在回调函数中使用的 this 关键字。如果省略 thisArg 参数，则默认使用全局对象。

用于检测数组中的所有元素是否都符合指定条件。如果所有元素都符合条件，则返回 true，否则返回 false。 以下是 every() 方法的语法：

array.every(callback(currentValue, index, array), thisArg)

其中，array 是要检测的数组，callback 是用来测试每个元素的函数。该函数接收三个参数：当前遍历到的元素 currentValue，当前元素的索引 index，以及遍历的数组本身 array。使用这些参数来执行自定义的测试，返回值为 true 表示元素符合条件，every() 方法会继续检测下一个元素，返回值为 false 则不再检测后续的元素，直接返回 false。 以下是一个使用 every() 方法检测数组中的所有元素是否都大于等于 0 的例子：

const array = [1, 2, 3, 4, 5];
const result = array.every(function(element) {
  return element >= 0;
});
console.log(result);

在这个例子中，我们使用 every() 方法检测数组 array 中的所有元素是否都大于等于 0，并将结果存储在 result 变量中。然后使用 console.log() 函数将结果输出到控制台。 需要注意的是，every() 方法不会修改原始数组。如果需要修改数组，可以在回调函数中对元素进行修改。 除了 currentValue、index 和 array 参数之外，every() 方法还接受一个可选的 thisArg 参数。该参数用于指定在回调函数中使用的 this 关键字。如果省略 thisArg 参数，则默认使用全局对象。

用于检测数组中的某个元素是否符合指定条件。如果至少有一个元素符合条件，则返回 true，否则返回 false。 以下是 some() 方法的语法：

array.some(callback(currentValue, index, array), thisArg)

其中，array 是要检测的数组，callback 是用来测试每个元素的函数。该函数接收三个参数：当前遍历到的元素 currentValue，当前元素的索引 index，以及遍历的数组本身 array。使用这些参数来执行自定义的测试，返回值为 true 表示元素符合条件，some() 方法会停止检测并返回 true，否则继续检测下一个元素，如果所有元素都不符合条件，则返回 false。 以下是一个使用 some() 方法检测数组中是否存在大于等于 5 的元素的例子：

const array = [1, 2, 3, 4, 5];
const result = array.some(function(element) {
  return element >= 5;
});
console.log(result);

在这个例子中，我们使用 some() 方法检测数组 array 中是否存在大于等于 5 的元素，并将结果存储在 result 变量中。然后使用 console.log() 函数将结果输出到控制台。 需要注意的是，some() 方法不会修改原始数组。如果需要修改数组，可以在回调函数中对元素进行修改。 除了 currentValue、index 和 array 参数之外，some() 方法还接受一个可选的 thisArg 参数。该参数用于指定在回调函数中使用的 this 关键字。如果省略 thisArg 参数，则默认使用全局对象。

用于查找数组中符合指定条件的第一个元素。如果找到符合条件的元素，则返回该元素，否则返回 undefined。 以下是 find() 方法的语法：

array.find(callback(currentValue, index, array), thisArg)

其中，array 是要查找的数组，callback 是用来测试每个元素的函数。该函数接收三个参数：当前遍历到的元素 currentValue，当前元素的索引 index，以及遍历的数组本身 array。使用这些参数来执行自定义的测试，返回值为 true 表示该元素符合条件，find() 方法会返回该元素，否则继续查找下一个元素，如果所有元素都不符合条件，则返回 undefined。 以下是一个使用 find() 方法查找数组中第一个大于等于 5 的元素的例子：

const array = [1, 2, 3, 4, 5];
const result = array.find(function(element) {
  return element >= 5;
});
console.log(result);

在这个例子中，我们使用 find() 方法查找数组 array 中第一个大于等于 5 的元素，并将结果存储在 result 变量中。然后使用 console.log() 函数将结果输出到控制台。 需要注意的是，find() 方法只会返回符合条件的第一个元素，不会查找后续的元素。如果需要查找所有符合条件的元素，可以使用 filter() 方法。 除了 currentValue、index 和 array 参数之外，find() 方法还接受一个可选的 thisArg 参数。该参数用于指定在回调函数中使用的 this 关键字。如果省略 thisArg 参数，则默认使用全局对象。

用于对数组中的所有元素进行累加计算，并返回计算结果。 以下是 reduce() 方法的语法：

array.reduce(callback(accumulator, currentValue, currentIndex, array), initialValue)

其中，array 是要计算的数组，callback 是用来执行每一次计算的函数。该函数接收四个参数：累加器 accumulator，当前遍历到的元素 currentValue，当前元素的索引 currentIndex，以及遍历的数组本身 array。使用这些参数来执行自定义的计算，返回值会被添加到累加器中，最后返回的结果就是累加器的值。initialValue 是可选的，用于指定累加器的初始值，如果省略该参数，则默认使用数组的第一个元素作为累加器的初始值，并从数组的第二个元素开始进行计算。 以下是一个使用 reduce() 方法计算数组中所有元素的和的例子：

const array = [1, 2, 3, 4, 5];
const result = array.reduce(function(accumulator, currentValue) {
  return accumulator + currentValue;
});
console.log(result);

在这个例子中，我们使用 reduce() 方法对数组 array 中的所有元素进行累加计算，并将结果存储在 result 变量中。然后使用 console.log() 函数将结果输出到控制台。 需要注意的是，reduce() 方法可以用于计算各种类型的值，而不仅仅是数字类型的值。例如，可以使用 reduce() 方法计算一个数组中所有字符串的长度之和，或者一个数组中所有对象某个属性的值的总和等等。 除了 accumulator、currentValue、currentIndex 和 array 参数之外，reduce() 方法还接受一个可选的 initialValue 参数。该参数用于指定累加器的初始值。如果省略 initialValue 参数，则默认使用数组的第一个元素作为累加器的初始值，并从数组的第二个元素开始进行计算。