js数组的常用方法

1.push()

在数组末尾添加一个或多个元素，并返回新的长度。

let numbers = [1, 2, 3];
let result = numbers.push(4, 5);
console.log(result); // 输出: 5
console.log(numbers); // 输出: [1, 2, 3, 4, 5]

2.pop()

删除数组最后一个元素，并返回那个元素。

let numbers = [1, 2, 3];
let result = numbers.pop();
console.log(result); // 输出: 3
console.log(numbers); // 输出: [1, 2]

3.shift()

删除数组的第一个元素，并返回那个元素。

let numbers = [1, 2, 3];
let result = numbers.shift();
console.log(result); // 输出: 1
console.log(numbers); // 输出: [2, 3]

4.unshift()

在数组的开始添加一个或多个元素，并返回新的长度。

let numbers = [2, 3];
let result = numbers.unshift(1);
console.log(result); // 输出: 3
console.log(numbers); // 输出: [1, 2, 3]

5. concat()

创建一个新数组，原数组中的元素加上concat中提供的元素。

let arr1 = [1,2,3]
let arr2 = arr1.concat(4,5)
const.log(arr2) // [1,2,3,4,5]

6.join()

将数组中的所有元素转换为一个字符串，可以指定一个字符串来分隔数组中的元素。

let colors = ['red', 'green', 'blue'];
let colorString = colors.join(', ');
console.log(colorString); // 输出: "red, green, blue"

7.slice()

返回数组的一个片段或子数组，可以指定开始和结束的索引。

let numbers = [1, 2, 3, 4, 5];
let slice = numbers.slice(1, 4);
console.log(slice); // 输出: [2, 3, 4]

8.splice()

通过删除、插入和替换来修改数组。

let numbers = [1, 2, 3, 4, 5];
let removed = numbers.splice(2, 2, 'a', 'b'); // 从索引2开始删除2个元素，然后插入'a'和'b'
console.log(numbers); // 输出: [1, 2, 'a', 'b', 5]
console.log(removed); // 输出: [3, 4]

9.reverse()

颠倒数组中元素的顺序。

let numbers = [1, 2, 3];
numbers.reverse();
console.log(numbers); // 输出: [3, 2, 1]

10.sort()

对数组的元素进行排序。

let numbers = [3, 1, 4, 2];
numbers.sort((a, b) => a - b); // 升序排序
console.log(numbers); // 输出: [1, 2, 3, 4]

11.forEach()

为数组的每个元素执行一次提供的函数。

let arr = [1, 2, 3];
arr.forEach(function(element) {
    console.log(element);
});
// 输出:
// 1
// 2
// 3

12.map()

创建一个新数组，其结果是该数组中的每个元素调用一个提供的函数后返回的结果

const numbers = [1, 2, 3, 4, 5];
const doubled = numbers.map(number => number * 2);
console.log(doubled); // 输出: [2, 4, 6, 8, 10]

13.filter()

创建一个新数组，该数组包含通过提供的函数实现的测试的所有元素。

let arr = [1, 2, 3, 4, 5];
let filtered = arr.filter(function(element) {
    return element > 2;
});
console.log(filtered) // [3, 4, 5]

14.reduce()

对数组中的每个元素执行一个由您提供的reducer函数（升序执行），将其结果汇总为单个返回值。

arr.reduce(callback(accumulator, currentValue[, index[, array]])[, initialValue])

参数：
callback：执行数组中每个值的函数，包含四个参数：
accumulator：累加器，即上一次回调函数执行时的结果。
currentValue：当前数组中正在处理的元素。
index (可选)：当前元素在数组中的索引。
array (可选)：调用reduce()的数组。
initialValue (可选)：作为第一次调用callback的第一个参数。

示例：

// 使用reduce()计算数组中所有数字的总和
const numbers = [1, 2, 3, 4, 5];
const sum = numbers.reduce((accumulator, currentValue) => accumulator + currentValue, 0);
console.log(sum); // 输出：15
 
// 使用reduce()将数组中的字符串连接成一个字符串
const words = ['Hello', 'World'];
const sentence = words.reduce((accumulator, currentValue) => accumulator + ' ' + currentValue, '');
console.log(sentence); // 输出：'Hello World'
 
// 使用reduce()计算数组中对象的平均值
const objects = [{ value: 1 }, { value: 2 }, { value: 3 }];
const average = objects.reduce((accumulator, currentValue) => accumulator + currentValue.value, 0) / objects.length;
console.log(average); // 输出：2

15.reduceRight()

对数组中的每个元素执行一个由您提供的reducer函数（降序执行），将其结果汇总为单个返回值

arr.reduceRight(callback(accumulator, currentValue, index, array), initialValue)

参数：
callback：执行于每个数组元素的函数，包含四个参数：
accumulator：累加器累计回调的返回值；
currentValue：数组当前元素的值；
index：数组当前元素的索引；
array：调用reduceRight的数组。
initialValue：作为第一次调用callback函数的第一个参数。

示例：

// 使用reduceRight()计算数组元素的总和，假设初始值为0
const numbers = [1, 2, 3, 4, 5];
const sum = numbers.reduceRight((accumulator, currentValue) => accumulator + currentValue, 0);
console.log(sum); // 输出：15
 
// 使用reduceRight()将数组的元素转换为字符串并连接它们
const words = ['JavaScript', 'Python', 'C#'];
const sentence = words.reduceRight((accumulator, currentValue) => accumulator + ' ' + currentValue, '');
console.log(sentence); // 输出："C# Python JavaScript"

16.indexOf()

返回数组中第一个找到的元素索引，如果不存在则返回-1。

let array = [1, 2, 3, 4, 5];
// 查找元素 3 的索引
let index = array.indexOf(3); // 返回 2
// 查找元素 6 的索引，不存在于数组中
let indexNotFound = array.indexOf(6); // 返回 -1

let array1 = [1, 2, 3, 2, 1];
// 从索引 2 开始查找元素 2 的索引
let index = array1.indexOf(2, 2); // 返回 3

17.lastIndexOf()

返回数组中最后一个找到的元素索引，如果不存在则返回-1

// 基本用法
let array = [2, 5, 9, 2];
let index = array.lastIndexOf(2);
console.log(index); // 输出: 3

// 查找不存在的元素
let array = [2, 5, 9];
let index = array.lastIndexOf(7);
console.log(index); // 输出: -1

// 从数组末尾向前搜索
let array = [2, 5, 9, 2];
let index = array.lastIndexOf(2, 2);
console.log(index); // 输出: 0

// 从数组末尾向前搜索，忽略0索引
let array = [2, 5, 9, 2];
let index = array.lastIndexOf(2, -1);
console.log(index); // 输出: 3

// 查找数组中最后一个undefined
let array = [undefined, null, false, undefined];
let index = array.lastIndexOf(undefined);
console.log(index); // 输出: 3

// 查找数组中最后一个null
let array = [undefined, null, false, undefined];
let index = array.lastIndexOf(null);
console.log(index); // 输出: 1

// 查找数组中最后一个0
let array = [0, -1, 10, 0];
let index = array.lastIndexOf(0);
console.log(index); // 输出: 3

18.includes()

判断数组是否包含某个元素，返回布尔值。

let array = [1, 2, 3, 4, 5];
console.log(array.includes(3)); // true
console.log(array.includes(6)); // false

19.find()

返回数组中第一个满足提供的测试函数的元素值。

let array = [1, 2, 3, 4, 5];
let result = array.find(element => element > 3);
console.log(result); // 输出: 4

20.findIndex()

返回数组中第一个满足提供的测试函数的元素索引。

let array1 = [5, 12, 8, 130, 44];
let index = array1.findIndex(element => element > 13);
console.log(index); // 输出: 2

21.every()

测试数组中的所有元素是否通过了指定函数的测试。

// 检查数组中所有元素是否大于10
const numbers = [12, 15, 20, 30, 40];
const allNumbersAreGreaterThan10 = numbers.every(number => number > 10);
console.log(allNumbersAreGreaterThan10); // 输出: false
 
// 使用 thisArg
const objects = [{ number: 12 }, { number: 15 }, { number: 20 }];
const allNumbersAreGreaterThan10WithThisArg = objects.every(function(obj) {
  return this.number > 10;
}, { number: 10 });
console.log(allNumbersAreGreaterThan10WithThisArg); // 输出: false

22.some()

测试数组中是否至少有一个元素通过了指定函数的测试。

let numbers = [1, 2, 3, 4, 5];
let someResult = numbers.some(num => num > 3);
console.log(someResult); // 输出: true

23.isArray()

判断一个对象是否为数组。

var arr = [1, 2, 3];
console.log(Array.isArray(arr));  // 输出：true