Array常用API及样例

push(): 将一个或多个元素添加到数组的末尾，并返回新的长度。
pop(): 删除并返回数组的最后一个元素。改变原数组

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

shift(): 删除并返回数组的第一个元素，改变原数组。

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

unshift(): 将一个或多个元素添加到数组的开头，并返回新的长度。

const a = [1,2,3,4]
a.unshift(5)
console.log(a) // [5, 1, 2, 3, 4]

join('') 把数组内数据取出，把数组中的元素拼接成字符串

let txt=[ 'b','o','o','n','u','R' ];
let veb = txt.join('');
console.log(veb)   // 'boonuR'

concat(): 用于将一个数组或值合并至一个数组中，该方法不会改变原数组

var arr = [1, 2, 3, 4, 5];
var newArr = arr.concat(6);
console.log(newArr); // [1, 2, 3, 4, 5, 6];

… : 展开语法...: 可以在数组构造时, 将数组表达式在语法层面展开

var arr = [1, 2, 3, 4, 5];
arr = [...arr, 6];
console.log(arr); // [1, 2, 3, 4, 5, 6];

length: 属性，可以在数组末尾后面添加一个元素

var arr = [1, 2, 3, 4, 5];
arr[length] = 6;
console.log(arr); // [1, 2, 3, 4, 5, 6];

slice(): 用于从数组中提取一段元素，并返回一个新的数组。这个方法不会改变原始数组，包含从 start 到 end（不包括 end）选择的数组元素。可以用于字符串

let arr = [0, 1, 2, 3, 4, 5];  
let a = arr.slice(2, 4);  // 从索引2开始，到索引4之前，但不包括索引4的元素。结果是 [2, 3]  
let b = arr.slice(2);  // 从索引2开始，到数组末尾。结果是 [2, 3, 4, 5]
let c = arr.slice();  // 或 arr.slice(0)   输出 [0, 1, 2, 3, 4, 5]
或者
let str = "Hello, world!";  
let extractedStr = str.slice(7, 12); // 提取从索引 7 到索引 12 的字符  
console.log(extractedStr); // 输出: "world"

splice(): 用于添加/删除数组中的元素。这个方法会直接修改原数组。

let arr = [0, 1, 2, 3, 4, 5];  
let a = arr.splice(2, 2);  // 从索引2开始，删除2个元素。结果是 [2, 3]  
console.log(arr);  // 输出 [0, 1, 4, 5]  
let b = arr.splice(2, 0, 'new1', 'new2');  //在索引2的位置插入'new1'和'new2'。b 结果是 []
console.log(arr); // 输出 [0, 1, 'new1', 'new2', 2, 3, 4, 5]
let c = arr.splice(2);  // 从索引2开始，删除所有元素。c 结果是 [2, 3, 4, 5]  
console.log(arr); // 输出 [0, 1]

sort(): 用于对数组的元素进行排序。这个方法会直接修改原数组。

// 普通用法：升序排序数组
let arr = [5, 2, 3, 1, 4];  
arr.sort();  // console.log(arr);   输出 [1, 2, 3, 4, 5]
// 自定义排序函数：
let arr = [5, 2, 3, 1, 4];  
arr.sort((a, b) => a - b);  // 使用自定义的比较函数，按照数字的大小进行升序排序；b - a
// 按照字母顺序对字符串数组进行排序。
let arr = ['cat', 'dog', 'elephant', 'ant'];  
arr.sort();  // 使用默认的排序方式，结果是 ['ant', 'cat', 'dog', 'elephant']，因为'ant'在字母表中的位置比'cat'更靠前  
arr.sort((a, b) => a.localeCompare(b));  // 使用自定义的比较函数，按照字母顺序进行排序，结果是 ['ant', 'cat', 'dog', 'elephant']，这是正确的字母顺序排序结果

reverse(): 用于反转数组的元素顺序，即第一个元素变成最后一个，最后一个变成第一个。这个方法会直接修改原数组。

let numbers = [1, 2, 3, 4, 5];  
// 使用 slice() 方法复制数组，然后对复制的数组使用 reverse()  
let reversedNumbers = numbers.slice().reverse();  // 这里的slice() 方法被用来创建一个 numbers 数组的浅拷贝
console.log(numbers); // 输出: [1, 2, 3, 4, 5]，原数组未变  
console.log(reversedNumbers); // 输出: [5, 4, 3, 2, 1]，复制的数组已反转

forEach(): 对数组中的每个元素执行一次给定的函数。支持三个参数，数组中的当前项item，当前项的索引index，原始数组array；理论上这个方式是没有返回值的，只是遍历数组中的每一项，不对原来数组进行修改，但是可以自己通过数组的索引来修改原来的数组；

var forEachArray = [10,34,57,43,76];  
var res = forEachArray.forEach((item,index,array) => { array[index] = item*10; }) 
console.log(res);//--> undefined;  
console.log(forEachArray);//--> [100,340,570,430,760] 通过数组索引改变了原数组；

map(): 创建一个新数组，其结果是该数组中的每个元素都调用一个提供的函数后的结果。支持三个参数，value数组中的当前项，index当前项的索引，array原始数组；理论上这个方式是没有返回值的，只是遍历数组中的每一项，不对原来数组进行修改，但是可以自己通过数组的索引来修改原来的数组；

var mapArray = [10,34,57,43,76];  
var res = mapArray.map((item,index,input) => {  
       return item*10;
}) 
console.log(res);//--> [100,340,570,430,760] ;  
console.log(mapArray);//--> [10,34,57,43,76] 通过数组索引改变了原数组；

filter(): 用于创建一个新数组，其包含通过提供的函数实现的测试的所有元素。

let numbers = [1, 2, 3, 4, 5];  
let evenNumbers = numbers.filter(function(num) {  
  return num % 2 === 0;  
}); 
console.log(evenNumbers);  // 输出 [2, 4]
或者
let numbers = ['145', '75', '475', '175'];  
let evenNumbers = numbers.filter((num) => { 
  return num.indexOf('7') != -1;  
}); 
console.log(evenNumbers);  // ['75', '475', '175']

some(): 用于检测数组中是否有至少一个元素满足提供的测试函数。

let numbers = [1, 2, 3, 4, 5];  
let hasEven = numbers.some(function(num) {  
  return num % 2 === 0;  
});  
console.log(hasEven);  // 输出 true，因为数组中存在偶数

reduce(): 对累加器和数组中的每个元素（从左到右）应用一个函数，将其减少为单个值；函数本身接受两个参数：accumulator（累加器）和currentValue（当前值）

const numbers = [1, 2, 3, 4];  
// 使用 reduce 计算总和； 累加器的初始值，这里是0
const sum = numbers.reduce((accumulator, currentValue) => accumulator + currentValue, 0);  
console.log(sum); // 输出: 10
// 数组对象累加
const items = [{value: 1}, {value: 2}, {value: 3}, {value: 4}];  
const totalValue = items.reduce((acc, item) => acc + item.value, 0);  
console.log(totalValue); // 输出: 10

every(): 测试数组的所有元素是否都通过由提供的函数实现的测试。

const numbers = [1, 2, 3, 4];  
// 使用 every 检查所有数是否都大于0  
const allPositive = numbers.every(number => number > 0);  
console.log(allPositive); // 输出: true
// 检查数组对象属性
const users = [{isActive: true}, {isActive: false}, {isActive: true}];  
const allActive = users.every(user => user.isActive);  
console.log(allActive); // 输出: false

includes(): 判断一个数组是否包含一个指定的值，返回 true 或 false。也可以用在字符串上

let numbers = [1, 2, 3, 4, 5];  
console.log(numbers.includes(3));  // 输出 true，因为数组中存在数字3  
console.log(numbers.includes(-3));  // 输出 false，因为数组中不存在数字-3
或者
let str = "Hello, world!";  
console.log(str.includes("world")); // 输出: true  
console.log(str.includes("world", 7)); // 输出: true，因为从索引7开始，"world" 是在字符串中的。

find(): 用于搜索和定位数据。它的功能是根据指定的条件或标准，在数据集中查找特定的元素或子集。

大多数情况下，find() 用于数组（列表）中查找特定元素
const array = [{ a: 1, b: 2 },{ a: 2, b: 2 },{ a: 3, b: 5 }];  
const found = array.find(ele => ele.a > 2);  // 结果是 { a: 3, b: 5 }
console.log(found.b) // 5

用于对象查找
const obj = {a: 1, b: 2, c: 3};  
const found = Object.keys(obj).find(key => obj[key] > 2);  // 结果是 "c"
 // console.log(Object.keys(obj)) //  ['a', 'b', 'c']

注意点：
1，返回第一个满足条件的元素：一旦找到满足条件的元素，find() 就会停止搜索并返回该元素。
如果没有找到任何元素，则返回 undefined 或 null
2，接受回调函数作为参数：为了确定查找的准则，find() 通常接受一个回调函数作为参数。这个回调函数决定了如何评估每个元素是否满足查找条件。
3，性能考虑：find() 是一个线性搜索算法，最坏情况下的时间复杂度是 O(n)。如果需要更高效的搜索（例如二分查找），应考虑使用其他方法或数据结构。
4，其他用途，例如数据库查询、文件系统搜索等。

findIndex(): 返回数组中满足提供的测试函数的第一个元素的索引。否则返回 -1。

let people = [ { name: 'Alice', age: 20 }, { name: 'Bob', age: 17 }, { name: 'David', age: 15 } ];  
// 使用 findIndex 方法查找年龄大于 18 的第一个人的索引  
let index = people.findIndex(function(person) {  
  return person.age > 18;  
});  
// 更简洁，可以使用箭头函数  
let indexArrow = people.findIndex(person => person.age > 18); 
console.log(index); // 输出: 0  注意：输出 0 是因为 Alice 是第一个年龄大于 18 的人
// 假设我们要找到名字以 "C" 开头的第一个人的索引
let indexForNameStartingWithC = people.findIndex(person => person.name.startsWith('C'));  
console.log(indexForNameStartingWithC); // 输出: 2 因为 Charlie 是名字以 "C" 开头的第一个人，他的索引是 2

includes() 方法用来判断一个数组是否包含一个指定的值，如果是返回 true，否则false。
arr.includes(searchElement, fromIndex)
searchElement，必须。需要查找的元素值。
fromIndex，可选。从该索引处开始查找 searchElement。如果为负值，则按升序从 array.length + fromIndex 的索引开始搜索。默认为 0。

[1, 2, 3].includes(2);     // true
[1, 2, 3].includes(4);     // false
[1, 2, 3].includes(3, 3);  // false
[1, 2, 3].includes(3, -1); // true
[1, 2, NaN].includes(NaN); // true