数组中的方法与技巧

1. 增

   1. push() ：向数组的末尾添加新元素，只能添加一项
      • arr.push(...items) 修改原数组，返回修改后的数组长度
   2. unshift()：向数组首位添加新元素
      • arr.unshift(...items) 修改原数组，返回修改后的数组长度
   3. concat() 返回两个数组合并后的新数组，不修改原数组
      • arr1.concat(arr2)

2. 删除

   1. shift()：删除数组的第一项 修改原数组
      • arr.shift() 返回他删除的值，如果数组为空返回undefined
   2. pop()：删除数组的最后一项 修改原数组
      • arr.pop() 返回他删除的值，如果数组为空返回undefined
   3. slice(start,end)：返回数组中从开始到结束下标的新数组 不修改原数组
      • arr.slice(1) 返回从下标1(包含)开始后所有元素的新数组
      • arr.slice(1,10) 返回从下标1(包含)开始到下标10(不包含)的新数组

3. 特殊

   1. splice()：对数组进行增删改， 修改原数组

      语法：splice(start,deleteCount,...items) // 添加时，start后开始增加

      //删除时，start是从该项目开始进行删除

      //deleteCount是删除的个数

      //item可以为多个，也可以使用...进行打散数组加入新数组

      • 在指定下标位置之后添加

        • arr.splice(1,0,item) 在下标为1后添加一项

      • 删除指定位置或者之后的元素

        • arr.splice(0,1) 从下标为0项开始，删除一项

      • 替换指定位置的元素

        • arr.splice(0,1,item) 从下标0开始，删除一项，添加一项

      • 合并两个数组或者添加多个新元素

        arr1.splice(arr1.length,0,...arr2)  //在之后合并
        arr1.splice(0,0,...arr2)  //在之前合并
        

4. 查找元素

   1. indexOf(searchElement,?fromIndex) 查找符合要求的元素 返回下标，查不到返回-1
      • arr1.indexOf(1) //查找arr1数组中是否有1元素，返回arr1中元素为1的下标
      • arr1.indexOf(5,1) //在数组从下标为1的位置查找元素5，查到返回0
   2. includes(searchElement,?fromIndex) 返回要查找的元素在数组中的位置，找到返回true,否则false
      • arr1.includes(1) 查找数组中为1的元素
      • includes(1,5) 从数组中下标为5(包含)开始查找元素
   3. find((item,index,arry)=>) 通过一个测试函数进行筛选， 返回第一个满足条件的值，否则返回undefined
      • arr1.find((item,index)=>item<10) 返回arr1中第一个小于10的值

5. 排序方式

   1. reverse() 将数组倒叙排列，修改原数组，返回新数组

      • arr.reverse();

   2. sort() 接受一个比值函数，用于判断将哪个值放在最前面 ，用于修正结果

           let arry = [10, 2, 3, 4, 5, 6, 11, 200, 120, "1000000", true, false, "a"]
           arry.sort((value1, value2) => value1 - value2)
           console.table(arry);//
       //true和false以及字符串也会进行排序
       //false, true, 2, 3, 4, 5, 6, 10, 11, 120, 200, '1000000', 'a'
      

6. 转换方法

   1. join() 接受一个分隔符，返回包含数组所有项的字符串 不修改原数组
      • arr.join("")
   2. toString() 将数组转换为逗号分割的字符串不修改原数组
      • arr.toString()

7. 迭代方法

   1. some() 判断数组中是否存在满足条件的项

      • 对数组每一项都传入函数进行判断，如果有一项为true，则这个方法返回true

        let arr=[1,2,3,4,5,6,7]
        arr.some((item,index,arr)=> item==1) //true   判断是否包含该值
        arr.some((item,index,arr)=> item==1) //true   判断单个值
        

   2. every() 判断数组中每一项是否都满足条件

   • 对数组每一项都传入函数进行判断，如果每一项都返回true，则这个方法返回true

     let arr=[1,2,3,4,5,6,7]
     arr.some((item,index,arr)=> item==1) //true
     

   3. forEach() ES5 及以下循环遍历数组每一项

      • 对数组每一项都运行传入的函数，没有返回值

        let arr=[1,2,3,4,5,6,7]
        arr.forEach((item,index,arr)=>{
        //执行某些操作
        )
        

   4. filter()

      • 对数组每一项进行判断过滤，返回通过的值

        [1,2,3,4,5].filter(item=>item>2)
        // [3, 4, 5]
        

   5. map()

      • 对数组每一项执行操作，返回操作后的值，形成

        [1,2,3,4,5].map(item=> item*2 )
        // [2, 4, 6, 8, 10]
        

数组的流程控制

1. 获取最大值/最小值

   1. 使用 Math.min()或Math.max()结合扩展运算符来查找数组中的最小值或者最大值

      const numbers=[1,2,3,4,5,6,7,8]
      let max=Math.max(...numbers)
      let min=Math.min(...numbers)
      

2. 缩短数组

   1. 使用length属性来缩短数组

      const numbers = [1, 2, 3, 4, 5]
      numbers.length = 3;
      console.log(numbers); // [1, 2, 3] 
      

3. 数组去重

   1. 使用es6的新的数据结构Set，利用set的成员都是唯一的特性

      将数组转成set的结构，再使用...运算符

      const numbers=[2,3,4,5,2]
      console.log(Array.from(new Set(numbers)))
      

   2. 使用for循环嵌套 使用splice去重

   let arr = [1, 2, 3, 4, 5, 5, 6, 7, 6, 6, 7, 7, 7, 10]
           for (let i = 0; i < arr.length; i++) {
               for (let j = i + 1; j < arr.length; j++) {
                   if (arr[i] === arr[j]) {
                       arr.splice(j, 1);
                 //删除后回调j      
                       j--
                   }
               }
           }
   console.log(arr)  //1, 2, 3, 4, 5, 6, 7, 10
   

   3. 利用indexOf去重

      let arr = [1, 2, 3, 4, 5, 5, 6, 7, 6, 6, 7, 7, 7, 10]
              let arr2 = [];
              for (let i = 0; i < arr.length; i++) {
                  // 如何在arr2查不到arr中的元素，就对arr2进行添加新值
                  if (arr2.indexOf(arr[i]) === -1) {
                      arr2.push(arr[i])
                  }
              }
              console.log(arr2);
      

   4. 使用sort()

4. 检查是否为一个数组

   if(!Array.isArray(arr)){
   console.log(`Type error !`)
       return 
   }
   

6. 数组过滤

   1. 使用filter()方法过滤虚值

      注意： filter() 不会对空数组进行检测。

      注意： filter() 不会改变原始数组。

      const myArray = [1, undefined, NaN, 2, null, '@denicmarko', true, 3, false];
      console.log(myArray.filter(Boolean)); // [1, 2, "@denicmarko", true, 3]   
      

7. 判断数组内是否包含某个值

   1. 使用includes判断一个数组中是否包含一个指定的值

      includes方法可以用来判断一个数组中是否包含一个指定的值，返回布尔型

      const numbers = [2, 3, 4, 5, 2]
              if (numbers.includes(2)) {
                  console.log(true)
              }
      

8. 数组求和

其他类型转数组

1. 字符串类型转数组

   1. 有中括号的字符串转数组"[1,2,3,4,5]"数组的每一项都是数字

      let str="[1,2,3,4,5]"
      let arry=eval("("+str+")")
      

   2. 有中括号的字符串转数组，数组的每一项都是字符串

      let str="[1,2,3,4,5]"
      let arry=str.slice(1, str.length - 1).split(",")
      

数组的深拷贝方法

通过JSON.parse和json.stringify

创建临时数组接收通过以上方法获取的新地址数组，操作或者排序新数组，不会影响到原数组

    const arry = [6,5,4,3,65,32,12]
    let arry2 =[]
    arry2 = JSON.parse(JSON.stringify(arry))
        arry2.push("nihao")
        arry2.sort((a,b)=> a-b) 
        console.log(arry2); //[3,4,5,6,12,32,65,'nihao']
		console.log(arry); //[6,5,4,3,,65,32,12]