面试题——数组

1.数组的常用方法

1.1 改变原数组的方法：

• push( 向数组的末尾添加一个或多个元素，并返回新的数组长度 )

• pop( 删除并返回数组的最后一个元素，若该数组为空，则返回undefined )

• shift( 删除数组的第一项，并返回第一个元素的值。若该数组为空，则返回undefined。 )

• unshift( 向数组的开头添加一个或多个元素，并返回新的数组长度 )

• reverse(逆转)

• splice(从第几位开始，截取多少长度，在切口处添加新的数据 ),如果第一个参数是负数，就是倒过来数

  项目中的使用：假如要在数组中插入一个数字，在1后面插入3，可以这样用

  var arr=[1,2,3,4,5] arr.splice(1,0,3)

• sort(对数组元素进行排序。不写函数的话会按照字符串UniCode码排序 )

  sort里可以写函数，函数里必须写两个形参，看返回值1.当返回值为负数，那么前面的数放在前面；为正数，那么后面的数在前；为0，不动；例如var arr=[1,3,5,4,10] 比较顺序是1和3,1和5,1和4,1和10,3和5,3和4…

  var arr=[20,2,10,13,4,8,9];
  arr.sort(function(a,b){
  return a-b//升序
  return b-a//降序
  })
  

1.2 不改变原数组的方法：

• concat( 合并两个或多个数组，生成一个新的数组 )

• join( 将数组的每一项用指定字符连接形成一个字符串。默认连接字符为 “,” 逗号。 )

• split(和join方法是互逆的)(字符串方法)

• toString( 方法将数组的元素转换为字符串 )

• slice(从索引n开始查找到m处（不包含m）

  array.slice(n) 第二个参数省略，则一直查找到末尾

  array.slice(0)原样输出内容，可以实现数组克隆

  array.slice(-n,-m) slice支持负参数，从最后一项开始算起，-1为最后一项，-2为倒数第二项

  返回值：返回一个新数组

• map( Array.map(function)，原数组的每一项执行函数后，返回一个新的数组。原数组不变。（注意该方法和forEach的区别）。 )

• 
  使用map和filter过滤数据的区别

使用map进行过滤时不符合条件的数据会被加工处理为undefined，是对原数组中的元素进行加工处理
filter只会将符合条件的数据返回为一个新数组，是对原数组进行过滤筛选

• forEach( Array.forEach(function)，用于调用数组的每个元素，并将元素传递给回调函数。原数组不变。（注意该方法和map的区别，若直接打印Array.forEach，结果为undefined）。 )

• filter ( .Array.filter(function)，过滤数组中，符合条件的元素并返回一个新的数组。 )

• find

  // find() 方法为数组中的每个元素都调用一次函数执行：
  // 当数组中的元素在测试条件时返回 true 时, find() 返回符合条件的元素，之后的值不会再调用执行函数。
  // 如果没有符合条件的元素返回 undefined
  

   <script>
        var arr = [5, 1, 2, 3, 3, 4, 5, 6, 4, 3, 8, 1];
        console.log(
          arr.find((item) => {
            return item > 5;
          })
        );
      </script>
  

• every( 对数组中的每一项进行判断，若都符合则返回true，否则返回false。 )

• some( Array.some(function)，对数组中的每一项进行判断，若都不符合则返回false，否则返回true。 )

• indexOf (检测当前值在数组中第一次出现的位置索引

  参数：array.indexOf(item,start) item:查找的元素 start:字符串中开始检索的位置。

  返回值：第一次查到的索引(从0开始)，未找到返回-1。)

• reduce这个方法你通常用于什么场景？( Array.reduce(function)，reduce() 方法接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值。 )

  var arr=[1,2,3] var total=arr.reduce((a,b)=>a+b)

  回调函数参数(prev,next,index,currenArr)

  1.perv代表上一次调用回调时的返回值，或者初始值init。
  2.next代表当前正在处理的数组元素.
  3.index代表当前执行元素的下标.
  4.currentArr代表当前循环的数组元素

  比如求和：

  let arr=[1,2,3,4];
  
  let reslut=arr.reduce((prev,next)=>{
      return prev+next
  })
  console.log(reslut)
  
  

• includes(判断一个数组是否包含一个指定的值

  参数：指定的内容

  返回值：布尔值)

2.数组去重

• for循环+indexOf，找到返回元素索引位置，找不到返回-1

<script>
      var arr = [1, 2, 3, 4, 5, 6, 4, 3, 8, 1];
      var newArr=[]
      for (i=0;i<arr.length;i++){
     newArr.indexOf(arr[i])===-1?newArr.push(arr[i]):newArr
      }
      console.log(newArr);
    </script>

• sort排序

<script>
      var arr = [5, 1, 2, 3, 3, 4, 5, 6, 4, 3, 8, 1];
      var newArr = [];
      arr = arr.sort();
      for (i = 1; i < arr.length; i++) {
        arr[i - 1] == arr[i] ? newArr : newArr.push(arr[i - 1]);
      }
      console.log(newArr);
</script>

• set ES6的方法

  <script>
      var arr = [5, 1, 2, 3, 3, 4, 5, 6, 4, 3, 8, 1];
      // .new Set方法，返回是一个类数组，需要结合 ...运算符，转成真实数组
      console.log([...new Set(arr)]);
    </script>

• set + Array.from

  <script>
      var arr = [5, 1, 2, 3, 3, 4, 5, 6, 4, 3, 8, 1];
      //  .new Set方法，返回是一个类数组，需要结合 Array.from ，转成真实数组
      console.log(Array.from(new Set(arr)));
  </script>

• indexof 可以检测某一个元素在数组中出现的位置，找到返回该元素的下标，没找到返回 -1

<script>
      var arr = [5, 1, 2, 3, 3, 4, 5, 6, 4, 3, 8, 1];
      function newArrFn(arr) {
        // 利用indexOf检测元素在数组中第一次出现的位置是否和元素现在的位置相等，
        // 如果相等，说明数组中没有重复的
        return arr.filter(function (item, index) {
          return arr.indexOf(item) === index; //return是filter函数返回true和false的，true就放进数组
        });
      }
      console.log(newArrFn(arr));
    </script>

• includes 利用 includes 检查新数组是否包含原数组的每一项。 如果不包含，就push进去

 <script>
      var arr = [5, 1, 2, 3, 3, 4, 5, 6, 4, 3, 8, 1];
      let newArr=[]
      function newArrFn(arr) {
       for(let i=0;i<arr.length;i++){
         newArr.includes(arr[i])?newArr:newArr.push(arr[i])
       }
       return newArr
      }
      console.log(newArrFn(arr));
    </script>

• reduce

<script>
      let arr = [1, 2, 3, 2, 6, 3, 4, 5, 6];
      let result = arr.reduce((prev, next) => {
        if (!prev.includes(next)) {
          prev.push(next);
        }
        return prev;
        //  debugger;
      },[]);//初始值prev设为空数组
      console.log(result);
    </script>