js数组部分实现

1.扁平化数组

arr.flat(n),n表示扁平化的次数，为Infinity

    let arr = [1, [2, 3, [4, 5]]];
    arr.flat(Infinity)
    function flatten(arr) {
      while(arr.some(item=>Array.isArray(item))){
        arr=[].concat(...arr)
      }
      return arr
    }
    flatten(arr)

2.去重

运用扩展运算符和set

    let arr = [2, 3, 4, 5, 1, 2, 3, 4];
    let newArr = [...new Set(arr)];

 

    Array.prototype.distinct = function() {
      let arr = this,
        result = [],
        len = arr.length,
        i,
        j;
      for (i = 0; i < len; i++) {
        for (j = i + 1; j < len; j++) {
          if (arr[i] === arr[j]) {
            j = ++i;
          }
        }
        result.push(arr[i]);
      }
      return result;
    };

3.排序

arr.sort((a,b)=>a-b)

冒泡排序：相邻两两比较

    Array.prototype.bubleSort = function() {
      let arr = this,
        len = arr.length;
      for (let i = 1; i < len; i++) {
        for (let j = 0; j < len - i; j++) {
          if (arr[j] > arr[j + 1]) {
            [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
          }
        }
      }
    };
    arr.bubleSort();

选择排序：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。

    Array.prototype.bubleSort = function() {
      let arr = this,
        len = arr.length;
      for (let i = 0; i < len; i++) {
        for (let j = 0; j < len; j++) {
          if (arr[j] > arr[i]) {
            [arr[i], arr[j]] = [arr[j], arr[i]];
          }
        }
      }
      return arr; //其实不用这句话，直接改动的就是原数组
    };
    arr.bubleSort()

虚插入实现方法　

    Array.prototype.resetSort = function() {
      let arr = this;
      let newArr = [];
      while (arr.length > 0) {
        newArr.push(Math.min(...arr))
        arr.splice(arr.indexOf(Math.min(...arr)), 1);
      }
      return newArr
    };
    let newArr=arr.resetSort()

4.最大值

    Math.max(...arr)

5.求和

    let sum = arr.reduce((prev,cur)=>{
      return prev+cur
    })

6.合并

    arr1.concat(arr2)
    [...arr1,...arr2]

7.是否包含

    arr.some(item => item === n);
    arr.includes(n); // 返回布尔
    arr.indexOf(n); // 存在返回索引，不存在返回-1
    arr.find(item => item === n); //存在返回该对象，不存在返回undefined
    arr.findIndex(item => item === n); //存在返回下标，不存在返回-1

8.类数组转换

    Array.prototype.slice.call(arguments) //arguments是类数组
    Array.prototype.slice.apply(arguments)
    Array.from(arguments)
    [...arguments]