js Array方法

Array（数组，引用数据类型）：

1. ?js数组是可以自动调节大小的，一个数组中可以包含不同的数据类型。
2. js数组必须用非负整数作为索引访问，不能使用字符串作索引，数组索引是从0开始。并要求使用 "[ ]" 来访问。
3. js数组复制操作时浅拷贝，即复制数组地址的引用。（js对象的复制都是浅拷贝）

注意：在复制数组时要判断是否要修改数组元素，如果要修改数组元素的话，最好是使用数组深拷贝处理，复制数组的原始值。

Array方法：????????

(1)不会修改原有数组

1. concat()：用于连接两个或者多个数组。

   var arr1 = [1,2]
   var arr2 = [3,4]
   var arrConcat = arr1.concat(arr2);// [ 1, 2, 3, 4 ]
   var arr2Concat = arr2.concat(arr1);// [ 3, 4, 1, 2 ]

2. join()：返回一个字符串，join方法会把所有数组元素使用 join() 传入的字符连接起来。

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

3. filter()：过滤出符合要求的元素，返回所有符合要求的所有元素数组。?

   var arr = [1,2,3,4];
   var arrfilter = arr.filter((element)=>{
       return element > 2;
   })
   console.log(arrfilter);// [ 3, 4 ]

4. ?slice()：输入start(开始位置)和end(结束位置)，返回这两个位置之间的元素数组。
   1. 如果只有一个参数，就返回这个位置之后的所有元素数组。
   2. 如果参数为负数，表示从最后一个位置，向前多少个位置。

      const animals = ['ant', 'bison', 'camel', 'duck', 'elephant'];
      console.log(animals.slice(2));// ["camel", "duck", "elephant"]
      console.log(animals.slice(2, 4));// ["camel", "duck"]
      console.log(animals.slice(-2));// ["duck", "elephant"]
      console.log(animals.slice(2, -1));// ["camel", "duck"]
      console.log(animals.slice());// ["ant", "bison", "camel", "duck", "elephant"]

5. map()：返回一个新数组，新数组的元素是原始数组通过回调函数处理之后返回的值。

   const arr = [1, 2, 3, 4, 5];
   let arr1 = arr.map((element) => {
     return element + 10;
   });
   console.log(arr1);// [ 11, 12, 13, 14, 15 ]

6. forEach()：用于遍历数组的每一个元素，并把元素传递给回调函数。

   const arr = [1, 2, 3, 4, 5];
   arr.forEach((element) => {
     console.log(element);
   });
   // 1
   // 2
   // 3
   // 4
   // 5

7. reduce()：对数组中的每个元素按照顺序执行传入的回调函数，每一次的执行结果作为下一次执行的参数传入，返回最后执行结果。

   // 使用语法
   reduce(callbackFn)
   reduce(callbackFn, initialValue)
   
   // 具体操作
   var arr = [1, 2, 3, 4, 5];
   console.log(arr.reduce((accumulator, currentValue) => accumulator + currentValue, 0));// 15
   console.log(arr.reduce((accumulator, currentValue) => accumulator + currentValue));// 15
   
   // 参数解释
   //accumulator: 上一次调用 callbackFn 的结果
   //currentValue：当前元素的值
   //initialValue：初始化的值

8. find()：返回数组中满足条件的第一个元素的值，没有就返回undefined。

   const arr = [5, 12, 8, 130, 44];
   const found = arr.find((element) => element < 100);
   console.log(found);// 5
   const found1 = arr.find((element) => element > 100);
   console.log(found1);// 130

9. findIndex()：返回数组中满足条件的第一个元素的索引，没有就返回-1。

   const arr = [5, 12, 8, 130, 44];
   const found = arr.findIndex((element) => element < 100);
   console.log(found);// 0
   const found1 = arr.findIndex((element) => element > 100);
   console.log(found1);// 3

10. indexOf()：返回数组中第一次出现给定元素的下标，如果不存在则返回 -1。

    // 使用语法
    indexOf(searchElement)
    indexOf(searchElement, fromIndex)
    
    // 具体操作
    const beasts = ['ant', 'bison', 'camel', 'duck', 'bison'];
    console.log(beasts.indexOf('bison'));// 1
    console.log(beasts.indexOf('bison', 2));// 4

11. lastIndexOf()：返回数组中给定元素最后一次出现的索引，如果不存在则返回 -1。该方法从fromIndex位置开始向前搜索数组。

    // 使用语法
    lastIndexOf(searchElement)
    lastIndexOf(searchElement, fromIndex)
    
    //具体操作
    const animals = ['Dodo', 'Tiger', 'Penguin', 'Dodo'];
    console.log(animals.lastIndexOf('Dodo'));// 3
    console.log(animals.lastIndexOf('Dodo',2));// 0

12. flat()：扁平化数组。按照一个可指定的深度递归遍历数组，并将所有元素与遍历到的子数组中的元素合并为一个新数组返回。

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

13. flatMap()：对数组中的每一个元素使用给定的回调函数，返回时将结果展开一级，返回展开后的新元素。

    const arr1 = [1, [1, [1]], [1], 1];
    const result = arr1.flatMap((num) => (num === 1 ? [1, 1] : 3));
    console.log(result);// [ 1, 1, 3, 3, 1, 1 ]

(2)会修改原有数组

1. pop()：返回值为数组被删除的最后一位元素。

   var arr = [1, 2, 3];
   var del = arr.pop();
   console.log(arr); // [1, 2]

2. push()：返回值为新数组的长度。

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

3. shift()：返回被删除的元素，删除数组中的第一位元素

   var arr = ["a","b", "c"];
   var del = arr.shift();
   console.log(arr); // ['b', "c"]
   console.log(del); // a

4. unshift()：返回新数组的长度，在数组的第一位添加单个或者多个元素。

   var arr = ["c", "d"];
   var newlen = arr.unshift("a", "b");
   console.log(arr); //[ 'a', 'b', 'c', 'd' ]
   console.log(newlen); // 4
   

5. sort()：返回排序好的数组，传入回调函数，按照回调函数给数组元素排序。

   var arr = [9, 8, 3, 6, 2, 0];
   arr.sort((a,b)=>{
       return a-b;
   })
   console.log(arr);// [0, 2, 3, 6, 8, 9]

6. reverse()：返回翻转后的数组。

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

7. fill()：返回一个新数组，用一个固定值填充一个数组中从起始索引（默认为?0）到终止索引（默认为?array.length）内的全部元素。

   // 使用语法
   fill(value)
   fill(value, start)
   fill(value, start, end)
   
   // 具体操作
   const arr = [1, 2, 3, 4];
   console.log(arr.fill(0, 2, 4));// [1, 2, 0, 0]
   console.log(arr.fill(5, 1));// [1, 5, 5, 5]
   console.log(arr.fill(6));// [6, 6, 6, 6]
   

8. splice()：返回值为包含了删除的元素的数组。通过移除或者替换已存在的元素或添加新元素，改变一个数组的内容。

   // 使用语法
   splice(start)
   splice(start, deleteCount)
   splice(start, deleteCount, item1)
   splice(start, deleteCount, item1, item2, itemN)
   
   // 具体操作
   const months = ['Jan', 'March', 'April', 'June'];
   console.log(months.splice(1, 0, 'Feb'));// []
   console.log(months);// ["Jan", "Feb", "March", "April", "June"]
   console.log(months.splice(4, 1, 'May'));// ["June"]