需要掌握的算法

数组去重

1. function unique (arr) {
     return Array.from(new Set(arr))
   }
   //
   [...new Set(arr)]

2. function unique(arr) {
     return arr.filter(function(item, index, arr) {
       //当前元素，在原始数组中的第一个索引==当前索引值，否则返回当前元素
       return arr.indexOf(item, 0) === index;
     });
   }

3. function unique(arr) {
       if (!Array.isArray(arr)) {
           console.log('type error!')
           return;
       }
       arr = arr.sort()
       var arrry= [arr[0]];
       for (var i = 1; i < arr.length; i++) {
           if (arr[i] !== arr[i-1]) {
               arrry.push(arr[i]);
           }
       }
       return array;
   }

数组扁平化

1. function flatten(arr) {
       var result = [];
       for (var i = 0, len = arr.length; i < len; i++) {
           if (Array.isArray(arr[i])) {
               result = result.concat(flatten(arr[i]))
           }
           else {
               result.push(arr[i])
           }
       }
       return result;
   }

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

3. function flatten(arr) {
       return arr.reduce(function(prev, next){
           return prev.concat(Array.isArray(next) ? flatten(next) : next)
       }, [])
   }

判断是否是数组的方法

1. Array.isArray(arr)
2. ```arr instanceof Array //true，注意arr instanceof Object === true但是可以判断是否是数组。
3. a.constructor == Array这个方法有风险，因为constructor可能被改写。
4. Object.prototype.toString.call(a)别的数据类型会返回自身内容的字符串形式，只有对象会返回类型。
   但是注意不要有这种骚操作：

   //重写了toString方法
   Object.prototype.toString = () => {
       alert('你吃过了么？');
   }

5. 考虑到兼容性，可以对方法一进行包装

   if (!Array.isArray) {
     Array.isArray = function(arg) {
       return Object.prototype.toString.call(arg) === '[object Array]';
     };
   }

典型题

1. Array.prototype.getReader = function () {
       const _this = this
       let index = 0
       return {
           read: (n = 1) => {
               if (typeof n !== 'number' || Math.trunc(n) !== n || n < 0) {
                   return 'Error'
               }
               let r = []
               if (_this.length - index >= n) {
                   for (let i = index; i < index + n; i++) {
                       r.push(_this[i])
                   }
                   index += n
               } else {
                   for (let i = index; i < _this.length; i++) {
                       r.push(_this[i])
                       index = _this.length
                   }
               }
               return r
           }
       }
   }
   // example
   n默认值为1
   const arr = [1, 2, 3, 4, 5, 6];
   const reader = arr.getReader();
   console.log(reader.read('1')); // Error
   console.log(reader.read(-1)); // Error
   console.log(reader.read(1.5)); // Error
   console.log(reader.read()); // [1]
   console.log(reader.read(1)); // [2]
   console.log(reader.read(2)); // [3, 4]
   console.log(reader.read(3));//[5, 6]
   console.log(reader.read());//[]
   console.log(arr);//[1, 2, 3, 4, 5, 6]

2. // const a = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'];
   // chunk(a, 4);
   // 结果：
   // [['a', 'b', 'c', 'd'],['e', 'f', 'g', 'h']]
   const chunk = (arr, n) => {
       const r = []
       while (arr.length>0) {
           if (arr.length > n) {
               const t = []
               for (let i = 0; i < n; i++) {
                   t.push(arr[i])
               }
               r.push(t)
               arr.splice(0, n)
           } else {
               r.push([...arr])
               arr.splice(0, arr.length)
           }
       }
       return r
   }
   const a = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h','1'];
   const t = chunk(a, 4);
   console.log(t);