数组的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) // true

11.lastIndexOf(): 返回指定元素在数组中最后一次出现的索引，如果不存在则返回-1。

let fruits = ['apple', 'banana', 'orange', 'banana'];
let lastIndex = fruits.lastIndexOf('banana');
console.log(lastIndex); // 输出: 3

12.includes(): 检查数组是否包含指定元素，返回布尔值。

let fruits = ['apple', 'banana', 'orange'];
let includesOrange = fruits.includes('orange');
console.log(includesOrange); // 输出: true

13.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); // 输出: 15

19.every(): 检查数组中的所有元素是否满足指定条件，如果所有元素都满足条件则返回true，否则返回false。

let numbers = [2, 4, 6, 8, 10];
let allEven = numbers.every(function(number) {
  return number % 2 === 0;
});
console.log(allEven); // 输出: true

20.some(): 检查数组中的任意元素是否满足指定条件，如果至少有一个元素满足条件则返回true，否则返回false。

let numbers = [2, 4, 6, 8, 9];
let hasOdd = numbers.some(function(number) {
  return number % 2 !== 0;
});
console.log(hasOdd); // 输出: true

21.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); // 2

23.fill(): 将数组的所有元素替换为静态值，可以指定起始索引和结束索引。

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('----