前端常见js方法

如何实现数组的随机排序？

方法一：

 var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    function randSort1(arr) {
      for (var i = 0, len = arr.length; i < len; i++) {
        var rand = parseInt(Math.random() * len);
        var temp = arr[rand];
        arr[rand] = arr[i];
        arr[i] = temp;
      }
      return arr;
    }
    console.log(randSort1(arr));

方法二：

 var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    function randSort2(arr) {
      var mixedArray = [];
      while (arr.length > 0) {
        var randomIndex = parseInt(Math.random() * arr.length);
        mixedArray.push(arr[randomIndex]);
        arr.splice(randomIndex, 1);
      }
      return mixedArray;
    }
    console.log(randSort2(arr));

方法三：

  var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    arr.sort(function () {
      return Math.random() - 0.5;
    });
    console.log(arr);

数组去重

方法一. 利用ES6 Set去重

Array.from(new Set(arr));
    [...new Set(arr)];

方法二. 利用for嵌套for，然后splice去重

 function unique(arr) {
      for (let i = 0; i < arr.length; i++) {
        for (let j = i + 1; j < arr.length; j++) {
          if (arr[i] == arr[j]) {
            // 第一个等同于第二个，splice方法删除第二个
            arr.splice(j, 1);
            j--;
          }
        }
      }
      return arr;
    }

方法三. 利用reduce+includes

 function unique(arr) {
      return arr.reduce(
        (prev, cur) => (prev.includes(cur) ? prev : [...prev, cur]),
        []
      );
    }

方法四. 利用filter

function unique(arr) {
      return arr.filter(function (item, index, arr) {
        return arr.indexof(item, 0) === index;
      });
    }

方法五. 利用递归去重

 function unique(arr) {
      var array = arr;
      var len = array.length;
      array.sort();
      function loop(index) {
        if (index >= 1) {
          if (array[index] === array[index - 1]) {
            array.splice(index, 1);
          }
          loop(index - 1); //递归loop，然后数组去重
        }
      }
      loop(len - 1);
      return array;
    }

数组降维

方法一.数组字符串化

 var arr = [[222, 333, 444], [55, 66, 77], { a: 1 }];
    arr += "";
    arr = arr.split(",");
    console.log(arr); // [222,333,444,55,66,77,[object Object]]

方法二.递归

function reduceDimension(arr) {
      let ret = [];
      let toArr = function (arr) {
        arr.forEach((item) => {
          item instanceof Array ? toArr(item) : ret.push(item);
        });
      };
      toArr(arr);
      return ret;
    }

方法三.Array.prototype.flat()

    var arr1 = [1, 2, [3, 4]];
    arr1.flat(); // [1, 2, 3, 4]
    var arr2 = [1, 2, [3, 4, [5, 6]]];
    arr2.flat(); // [1, 2, 3, 4, [5, 6]]
    var arr3 = [1, 2, [3, 4, [5, 6]]];
    arr3.flat(2); // [1, 2, 3, 4, 5, 6]
    //使用工nfinity作为深度，展开任意深度的嵌套数组
    arr3.flat(Infinity); // [1, 2, 3, 4,  5, 6]

方法四.栈

 var arr1 = [1, 2, 3, [1, 2, 3, 4, [2, 3, 4]]];
    var res;
    // 不使用递归，使用stack反嵌套多层嵌套数组
    function flatten(input) {
      const stack = [...input];
      const res = [];
      while (stack.length) {
        // 使用pop 从 stack中取出并移除值
        const next = stack.pop();
        if (Array.isArray(next)) {
          // 使用push送回内层数组中的元素
          stack.push(...next);
        } else {
          res.push(next);
        }
      }
      //使用reverse恢复原数组的顺序
      return res.reverse();
    }
    res = flatten(arr1);
    console.log(res); // [1,2,3,1,2,3,4,2,3,4]