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
网友评论