- A+
所属分类：Web前端
数组的32中方法=>{
1.push(): 在数组末尾添加一个或多个元素，并返回修改后的数组。
let fruits = ['apple', 'banana', 'orange']; fruits.push('mango'); console.log(fruits); // 输出: ['apple', 'banana', 'orange', 'mango']2.pop(): 移除数组的最后一个元素，并返回被移除的元素。
let fruits = ['apple', 'banana', 'orange']; let removedFruit = fruits.pop(); console.log(removedFruit); // 输出: 'orange' console.log(fruits); // 输出: ['apple', 'banana']3.shift(): 移除数组的第一个元素，并返回被移除的元素。
let fruits = ['apple', 'banana', 'orange']; let removedFruit = fruits.shift(); console.log(removedFruit); // 输出: 'apple' console.log(fruits); // 输出: ['banana', 'orange']4.unshift(): 在数组的开头添加一个或多个元素，并返回修改后的数组。
let fruits = ['apple', 'banana', 'orange']; fruits.unshift('mango', 'grape'); console.log(fruits); // 输出: ['mango', 'grape', 'apple', 'banana', 'orange']5.concat(): 合并两个或多个数组，并返回新的合并后的数组，原始数组不受影响。
let fruits = ['apple', 'banana']; let moreFruits = ['orange', 'mango']; let allFruits = fruits.concat(moreFruits); console.log(allFruits); // 输出: ['apple', 'banana', 'orange', 'mango'] console.log(fruits); // 输出: ['apple', 'banana']6.slice(): 返回一个新数组，包含从开始索引到结束索引（不包括结束索引）的元素。在只有一个参数的情况下， slice()方法返回从该参数指定位置开始到当前数组末尾的所有项。
let fruits = ['apple', 'banana', 'orange', 'mango']; let slicedFruits = fruits.slice(1, 3); console.log(slicedFruits); // 输出: ['banana', 'orange'] const arr = [1,3,5,7,9,11]; const arrCopy = arr.slice(1); const arrCopy2 = arr.slice(1,4); const arrCopy3 = arr.slice(1,-2);//相当于arr.slice(1,4) const arrCopy4 = arr.slice(-4,-1);//相当于arr.slice(2,5) console.log(arr); //[1, 3, 5, 7, 9, 11](原数组没变) console.log(arrCopy); //[3, 5, 7, 9, 11] console.log(arrCopy2); //[3, 5, 7] console.log(arrCopy3); //[3, 5, 7] console.log(arrCopy4); //[5, 7, 9]7.splice(): 从数组中添加、删除或替换元素，并返回被删除的元素组成的数组。
array.splice(index,howmany,item1,.....,itemX)
index: 必需。规定从何处添加/删除元素。该参数是开始插入和（或）删除的数组元素的下标，必须是数字。
howmany: 可选。规定应该删除多少元素。必须是数字，但可以是 "0"。如果未规定此参数，则删除从 index 开始到原数组结尾的所有元素。
item1: 可选。要添加到数组的新元素
let fruits = ['apple', 'banana', 'orange', 'mango']; let removedFruits = fruits.splice(1, 2, 'grape', 'cherry'); console.log(removedFruits); // 输出: ['banana', 'orange'] console.log(fruits); // 输出: ['apple', 'grape', 'cherry', 'mango'] let fruits1 = ['apple', 'banana', 'orange', 'mango']; let removed1 = fruits1.splice(1); console.log(removed1); // 输出: ['banana', 'orange', 'mango'] console.log(fruits1); // 输出: ['apple']8.forEach(): 对数组中的每个元素执行指定的操作。
let fruits = ['apple', 'banana', 'orange']; fruits.forEach(function(fruit) { console.log(fruit); }); // 输出: // 'apple' // 'banana' // 'orange'9.map(): 对数组中的每个元素执行指定的操作，并返回一个新数组，新数组的元素是原始数组经过操作后的结果。
let numbers = [1, 2, 3, 4, 5]; let multipliedNumbers = numbers.map(function(number) { return number * 2; }); console.log(multipliedNumbers); // 输出: [2, 4, 6, 8, 10]10.indexOf(): 返回指定元素在数组中首次出现的索引，如果不存在则返回-1。
let fruits = ['apple', 'banana', 'orange']; let index = fruits.indexOf('banana'); console.log(index); // 输出: 1 let fa = fruits.indexOf('banana') !== -1; console.log(fa) // true11.lastIndexOf(): 返回指定元素在数组中最后一次出现的索引，如果不存在则返回-1。
let fruits = ['apple', 'banana', 'orange', 'banana']; let lastIndex = fruits.lastIndexOf('banana'); console.log(lastIndex); // 输出: 312.includes(): 检查数组是否包含指定元素，返回布尔值。
let fruits = ['apple', 'banana', 'orange']; let includesOrange = fruits.includes('orange'); console.log(includesOrange); // 输出: true13.join(): 将数组中的所有元素连接成一个字符串。
let fruits = ['apple', 'banana', 'orange']; let fruitsString = fruits.join(', '); console.log(fruitsString); // 输出: 'apple, banana, orange'14.reverse(): 反转数组中元素的顺序，原始数组会被修改。
let fruits = ['apple', 'banana', 'orange']; fruits.reverse(); console.log(fruits); // 输出: ['orange', 'banana', 'apple']15.sort(): 对数组元素进行排序，默认按照字母顺序排序，原始数组会被修改。
let fruits = ['apple', 'banana', 'orange']; fruits.sort(); console.log(fruits); // 输出: ['apple', 'banana', 'orange']16.filter(): 根据指定条件筛选数组中的元素，返回一个新数组。
//需求找到数组内偶数 let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; let evenNumbers = numbers.filter((item, i, arr) => { return item % 2 == 0 }) console.log(evenNumbers); // 输出: [2, 4, 6, 8, 10] // ------------------------------------------------------------------------- let arrObj = [ {name: 'aa', age: 13 }, { name: 'bb', age: 23 }, { name: 'cc', age: 18 }, { name: 'dd', age: 11 }, {name: 'ee', age: 28 } ] let ap = arrObj.filter(ele => ele.age > 18) console.log(ap) // [{ "name": "bb", "age": 23 }, { "name": "ee", "age": 28 }] let arrObjFilter = arrObj.filter(ele => ele.age > 18).map(ele => { return ele.name }) console.log(arrObjFilter) // ['bb', 'ee'] // ------------------------------------------------------------------------- // 可以去重 let arr = [1, 2, 3, 2, 3, 4] let arrFilter = arr.filter((ele, index, arr) => { return arr.indexOf(ele) === index }) console.log(arrFilter) // [1, 2, 3, 4];17.reduce(): 对数组中的元素执行一个累加器函数，返回一个累计值。
let numbers = [1, 2, 3, 4, 5]; let sum = numbers.reduce((acc, number) =>{ return acc + number; }, 0); console.log(sum); // 输出: 15 // 取最大 最小值 let arr = [1, 2, 3, 4, 5]; let max = arr.reduce((pre,cur,index,arr) => { return pre > cur ? pre : cur }); let min = arr.reduce((pre,cur,index,arr) => { return pre < cur ? pre : cur }); console.log(max) // 得到 5 console.log(min) // 得到 1 // ----------------------------------------------- // 数组去重 let arr = [1, 2, 3, 4, 4, 1] let newArr = arr.reduce((pre,cur) => { if(!pre.includes(cur)){ return pre.concat(cur) }else{ return pre } },[]) 18.reduceRight(): 从数组的末尾开始，对数组中的元素执行一个累加器函数，返回一个累计值。
let numbers = [1, 2, 3, 4, 5]; let sum = numbers.reduceRight(function(acc, number) { return acc + number; }, 0); console.log(sum); // 输出: 1519.every(): 检查数组中的所有元素是否满足指定条件，如果所有元素都满足条件则返回true，否则返回false。
let numbers = [2, 4, 6, 8, 10]; let allEven = numbers.every(function(number) { return number % 2 === 0; }); console.log(allEven); // 输出: true20.some(): 检查数组中的任意元素是否满足指定条件，如果至少有一个元素满足条件则返回true，否则返回false。
let numbers = [2, 4, 6, 8, 9]; let hasOdd = numbers.some(function(number) { return number % 2 !== 0; }); console.log(hasOdd); // 输出: true21.find(): 返回数组中满足指定条件的第一个元素，如果找不到则返回undefined。
let numbers = [1, 2, 3, 4, 5]; let evenNumber = numbers.find(function(number) { return number % 2 === 0; }); console.log(evenNumber); // 输出: 2 let arrObj = [ {name: 'aa', age: 13 }, { name: 'bb', age: 23 }, { name: 'cc', age: 18 }, { name: 'dd', age: 11 }, {name: 'ee', age: 28 } ] let ap = arrObj.find(ele => ele.age === 18) console.log(ap); // {name: 'cc', age: 18}22.findIndex(): 返回数组中满足指定条件的第一个元素的索引，如果找不到则返回-1。
let numbers = [1, 2, 3, 4, 5]; let evenNumber = numbers.findIndex(function(number) { return number === 2; }); console.log(evenNumber); // 输出: 1 let arrObj = [ {name: 'aa', age: 13 }, { name: 'bb', age: 23 }, { name: 'cc', age: 18 }, { name: 'dd', age: 11 }, {name: 'ee', age: 28 } ] let ap = arrObj.findIndex(ele => ele.age === 18) console.log(ap); // 223.fill(): 将数组的所有元素替换为静态值，可以指定起始索引和结束索引。
array.fill(value, start, end)
value: 必需。填充的值。
start: 可选。开始填充位置。
end: 可选。停止填充位置 (默认为 array.length)。
let numbers = [1, 2, 3, 4, 5]; numbers.fill(0, 2, 4); console.log(numbers); // 输出: [1, 2, 0, 0, 5] let fruits = ["Banana", "Orange", "Apple", "Mango"]; fruits.fill("Runoob", 2, 4); console.log(fruits) // ['Banana', 'Orange', 'Runoob', 'Runoob']24.flat(depth ): 将多维数组转换为一维数组，可以指定转换的层数。depth :指定要提取嵌套数组的结构深度，默认值为 1。
let nestedArray = [1, [2, [3, 4]]]; let flattenedArray = nestedArray.flat(2); console.log(flattenedArray); // 输出: [1, 2, 3, 4]25.flatMap(): 对数组中的每个元素执行指定的操作，并将结果展开到一个新数组中。
let numbers = [1, 2, 3, 4, 5]; let multipliedAndFlattened = numbers.flatMap(function(number) { return [number * 2, number * 3]; }); console.log(multipliedAndFlattened); // 输出: [2, 3, 4, 6, 6, 9, 8, 12, 10, 15] const arr1 = [1, 2, [3], [4, 5], 6, []]; const flattened = arr1.flatMap(num => num); console.log('----?----',flattened); // [1, 2, 3, 4, 5, 6] let arr = [1, 2, 3, 4]; const ad = arr.flatMap(x => [x, x * 2]); const ap = arr.reduce((acc, x) => acc.concat([x, x * 2]), []) console.log('----?----',ad); // [1, 2, 2, 4, 3, 6, 4, 8] console.log('----?----',ap); // [1, 2, 2, 4, 3, 6, 4, 8]26.toString(): 将数组转换为逗号分隔的字符串。
let fruits = ['apple', 'banana', 'orange']; let fruitsString = fruits.toString(); console.log(fruitsString); // 输出: 'apple,banana,orange'27.isArray(): 检查一个值是否为数组，返回布尔值。
let fruits = ['apple', 'banana', 'orange']; let isFruitsArray = Array.isArray(fruits); console.log(isFruitsArray); // 输出: true28.keys(): 返回一个包含数组索引的可迭代对象。
let fruits = ['apple', 'banana', 'orange']; let keys = fruits.keys(); for (let key of keys) { console.log(key); // 输出: 0, 1, 2 }29.values(): 返回一个包含数组值的可迭代对象。
let fruits = ["apple", "banana", "orange"]; let values = fruits.values(); console.log("----?----", values); // Array Iterator {} for (let value of values) { console.log(value); // 输出: 'apple', 'banana', 'orange' }30.entries(): 返回一个包含数组键值对的可迭代对象。
let fruits = ['apple', 'banana', 'orange']; let entries = fruits.entries(); for (let [index, value] of entries) { console.log(index, value); // 输出: 0 'apple', 1 'banana', 2 'orange' }31.from(): 将一个类似数组或可迭代对象转换为真正的数组。
let string = 'hello'; let stringArray = Array.from(string); console.log(stringArray); // 输出: ['h', 'e', 'l', 'l', 'o'] var arr = Array.from([1, 2, 3], x => x * 10); console.log('----?----',arr); // [10, 20, 30]32.copyWithin(): 在数组内部将指定范围的元素复制到其他位置。
array.copyWithin(target, start, end)
| 参数 | 描述 |
|---|---|
| target | 必需。复制到指定目标索引位置。 |
| start | 可选。元素复制的起始位置。 |
| end | 可选。停止复制的索引位置 (默认为 array.length)。如果为负值，表示倒数。 |
let numbers = [1, 2, 3, 4, 5]; numbers.copyWithin(1, 3); console.log(numbers); // 输出: [1, 4, 5, 4, 5] //--------------------------------------------------------------------- var fruits = ["Banana", "Orange", "Apple", "Mango", "Kiwi", "Papaya"]; fruits.copyWithin(2, 0, 2); console.log('----?----',fruits); // [Banana,Orange,Banana,Orange,Kiwi,Papaya] //--------------------------------------------------------------------- var fruits = ["Banana", "Orange", "Apple", "Mango", "Kiwi", "Papaya"]; fruits.copyWithin(2, 0, 3); console.log('----?----',fruits); // ['Banana', 'Orange', 'Banana', 'Orange', 'Apple', 'Papaya']
