1. 实现数组的乱序输出

主要的实现思路就是：

  • 取出数组的第一个元素，随机产生一个索引值，将该第一个元素和这个索引对应的元素进行交换。
  • 第二次取出数据数组第二个元素，随机产生一个除了索引为1的之外的索引值，并将第二个元素与该索引值对应的元素进行交换

  • 按照上面的规律执行，直到遍历完成

    1. var arr = [1,2,3,4,5,6,7,8,9,10];
    2. for (var i = 0; i < arr.length; i++) {
    3. const randomIndex = Math.round(Math.random() * (arr.length - 1 - i)) + i;
    4. [arr[i], arr[randomIndex]] = [arr[randomIndex], arr[i]];
    5. }
    6. console.log(arr)

    2. 实现数组的扁平化

    （1）递归实现
    普通的递归思路很容易理解，就是通过循环递归的方式，一项一项地去遍历，如果每一项还是一个数组，那么就继续往下遍历，利用递归程序的方法，来实现数组的每一项的连接：

    1. let arr = [1, [2, [3, 4, 5]]];
    2. function flatten(arr) {
    3. let result = [];
    5. for(let i = 0; i < arr.length; i++) {
    6.   if(Array.isArray(arr[i])) {
    7.     result = result.concat(flatten(arr[i]));
    8.   } else {
    9.     result.push(arr[i]);
    10.   }
    11. }
    12. return result;
    13. }
    14. flatten(arr);  //  [1, 2, 3, 4，5]

    （2）reduce 函数迭代
    从上面普通的递归函数中可以看出，其实就是对数组的每一项进行处理，那么其实也可以用reduce 来实现数组的拼接，从而简化第一种方法的代码，改造后的代码如下所示：

    1. let arr = [1, [2, [3, 4]]];
    2. function flatten(arr) {
    3.   return arr.reduce(function(prev, next){
    4.       return prev.concat(Array.isArray(next) ? flatten(next) : next)
    5.   }, [])
    6. }
    7. console.log(flatten(arr));//  [1, 2, 3, 4，5]

    （3）扩展运算符实现
    这个方法的实现，采用了扩展运算符和 some 的方法，两者共同使用，达到数组扁平化的目的：

    1. let arr = [1, [2, [3, 4]]];
    2. function flatten(arr) {
    3.   while (arr.some(item => Array.isArray(item))) {
    4.       arr = [].concat(...arr);
    5.   }
    6.   return arr;
    7. }
    8. console.log(flatten(arr)); //  [1, 2, 3, 4，5]

    （4）split 和 toString
    可以通过 split 和 toString 两个方法来共同实现数组扁平化，由于数组会默认带一个 toString 的方法，所以可以把数组直接转换成逗号分隔的字符串，然后再用 split 方法把字符串重新转换为数组，如下面的代码所示：

    1. let arr = [1, [2, [3, 4]]];
    2. function flatten(arr) {
    3.   return arr.toString().split(',');
    4. }
    5. console.log(flatten(arr)); //  [1, 2, 3, 4，5]

    过这两个方法可以将多维数组直接转换成逗号连接的字符串，然后再重新分隔成数组。
    （5）ES6 中的 flat
    我们还可以直接调用 ES6 中的 flat 方法来实现数组扁平化。flat 方法的语法：arr.flat([depth])
    其中 depth 是 flat 的参数，depth 是可以传递数组的展开深度（默认不填、数值是 1），即展开一层数组。如果层数不确定，参数可以传进 Infinity，代表不论多少层都要展开：

    1. let arr = [1, [2, [3, 4]]];
    2. function flatten(arr) {
    3. return arr.flat(Infinity);
    4. }
    5. console.log(flatten(arr)); //  [1, 2, 3, 4，5]

    可以看出，一个嵌套了两层的数组，通过将 flat 方法的参数设置为 Infinity，达到了我们预期的效果。其实同样也可以设置成 2，也能实现这样的效果。在编程过程中，如果数组的嵌套层数不确定，最好直接使用 Infinity，可以达到扁平化。
    （6）正则和 JSON 方法
    在第4种方法中已经使用 toString 方法，其中仍然采用了将 JSON.stringify 的方法先转换为字符串，然后通过正则表达式过滤掉字符串中的数组的方括号，最后再利用 JSON.parse 把它转换成数组：

    1. let arr = [1, [2, [3, [4, 5]]], 6];
    2. function flatten(arr) {
    3. let str = JSON.stringify(arr);
    4. str = str.replace(/(\[|\])/g, '');
    5. str = '[' + str + ']';
    6. return JSON.parse(str); 
    7. }
    8. console.log(flatten(arr)); //  [1, 2, 3, 4，5]

    3. 实现数组去重

    给定某无序数组，要求去除数组中的重复数字并且返回新的无重复数组。
    ES6方法（使用数据结构集合）： ```javascript const array = [1, 2, 3, 5, 1, 5, 9, 1, 2, 8];

Array.from(new Set(array)); // [1, 2, 3, 5, 9, 8]

  1. ES5方法：使用map存储不重复的数字
  2. ```javascript
  3. const array = [1, 2, 3, 5, 1, 5, 9, 1, 2, 8];
  5. uniqueArray(array); // [1, 2, 3, 5, 9, 8]
  7. function uniqueArray(array) {
  8.   let map = {};
  9.   let res = [];
  10.   for(var i = 0; i < array.length; i++) {
  11.     if(!map.hasOwnProperty([array[i]])) {
  12.       map[array[i]] = 1;
  13.       res.push(array[i]);
  14.     }
  15.   }
  16.   return res;
  17. }

4. 实现数组的flat方法

  1. function _flat(arr, depth) {
  2.   if(!Array.isArray(arr) || depth <= 0) {
  3.     return arr;
  4.   }
  5.   return arr.reduce((prev, cur) => {
  6.     if (Array.isArray(cur)) {
  7.       return prev.concat(_flat(cur, depth - 1))
  8.     } else {
  9.       return prev.concat(cur);
  10.     }
  11.   }, []);
  12. }

5. 实现数组的push方法

  1. let arr = [];
  2. Array.prototype.push = function() {
  3.     for( let i = 0 ; i < arguments.length ; i++){
  4.         this[this.length] = arguments[i] ;
  5.     }
  6.     return this.length;
  7. }

6. 实现数组的filter方法

  1. Array.prototype._filter = function(fn) {
  2.     if (typeof fn !== "function") {
  3.         throw Error('参数必须是一个函数');
  4.     }
  5.     const res = [];
  6.     for (let i = 0, len = this.length; i < len; i++) {
  7.         fn(this[i]) && res.push(this[i]);
  8.     }
  9.     return res;
  10. }

7. 实现数组的map方法

  1. Array.prototype._map = function(fn) {
  2.    if (typeof fn !== "function") {
  3.         throw Error('参数必须是一个函数');
  4.     }
  5.     const res = [];
  6.     for (let i = 0, len = this.length; i < len; i++) {
  7.         res.push(fn(this[i]));
  8.     }
  9.     return res;
  10. }