1.数组去重

方法一：双重for循环+splice()方法

   let arr = ['a', 'a', '1', 3, 2, 2, 3, 1, 'b', 6, 7, 1, 'a']
   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]) {
                   arr.splice(j, 1)
                   j--
               }
           }
       }
       return arr
   }
   console.log(unique(arr))  //['a', '1', 3, 2, 1,'b', 6, 7]

方法二：创建一个新数组，并存放原数组的第一个元素，然后将元素组一一和新数组的元素对比，若不同则存放在新数组中。

   function unique2(arr) {
        let newArr = [arr[0]]
        for (let i = 1; i < arr.length; i++) {
            let flag = false;
            for (let j = 0; j < newArr.length; j++) {
                if (arr[i] === newArr[j]) {
                    flag = true;
                    break;
                }
            }

            if (!flag) {
                newArr.push(arr[i])
            }
        }
        return newArr;
    }
    console.log(unique2(arr)) //['a', '1', 3, 2, 1,'b', 6, 7]

方法三：创建一个新数组+数组的indexOf

  function unique3(arr) {
       let newArr = []
       for(let i=0;i<arr.length;i++){
           if(newArr.indexOf(arr[i])===-1){
               newArr.push(arr[i])
           }
       }
       return newArr
   }
   console.log(unique3(arr)) //['a', '1', 3, 2, 1,'b', 6, 7]

方法四：创建一个新数组+数组的lastIndexOf

function unique4(arr) {
     let newArr = []
     for (let i = 0; i < arr.length; i++) {
         if (newArr.lastIndexOf(arr[i]) === -1) {
             newArr.push(arr[i])
         }
     }
     return newArr
 }
 console.log(unique4(arr)) //['a', '1', 3, 2, 1,'b', 6, 7]

方法五：创建一个新数组+数组的includes

  function unique5(arr) {
      let newArr = []
      for (let i = 0; i < arr.length; i++) {
          if (!newArr.includes(arr[i])) {
              newArr.push(arr[i])
          }
      }
      return newArr
  }
  console.log(unique5(arr)) //['a', '1', 3, 2, 1,'b', 6, 7]

方法六：创建一个新数组+数组的forEach+includes

    function unique6(arr) {
        let newArr = []
        arr.forEach(item=>{
            if (!newArr.includes(item)) {
                newArr.push(item)
            }
        })
        return newArr
    }
    console.log(unique6(arr)) //['a', '1', 3, 2, 1,'b', 6, 7]

方法七：创建一个新数组+数组的filter+includes

   function unique7(arr) {
        let newArr = []
        arr.filter(item=>{
            if (!newArr.includes(item)) {
                newArr.push(item)
            }
        })
        return newArr
    }
    console.log(unique7(arr)) //['a', '1', 3, 2, 1,'b', 6, 7]

方法八：创建一个新数组+ES6的Set

  function unique8(arr) {
        return Array.from(new Set(arr))
    }
    console.log(unique8(arr)) //['a', '1', 3, 2, 1,'b', 6, 7]

2.数组对象根据某一个属性的值去重

    let arr = [
        { id: 1, name: 'shy' },
        { id: 2, name: 'orton' },
        { id: 1, name: 'join' },
        { id: 3, name: 'cena' },
        { id: 2, name: 'belly' },
        { id: 1, name: 'randy' },
    ]

方法一：reduce()

    function unique(arr, type) {
        let obj = {}
        arr=arr.reduce((item, next) => {
            obj[next[type]] ? '' : obj[next[type]] = true && item.push(next)
            return item
        }, [])
        return arr
    }

**方法二：filter()+has()+set()**

    function unique(arr, type) {
            const res = new Map();
            return arr.filter((item) => !res.has(item[type]) && res.set(item[type], 1));
        }
    console.log(unique(arr, 'id'))

3.数组对象根据多个属性的值去重

    let arr = [
        { id: 1, name: 'shy', age: 24 },
        { id: 2, name: 'orton', age: 20 },
        { id: 1, name: 'join', age: 22 },
        { id: 3, name: 'cena', age: 23 },
        { id: 2, name: 'belly', age: 21 },
        { id: 1, name: 'randy', age: 24 },
    ]

方法一:reduce()

    function unique(arr, type,type2) {
        let obj = {}
        arr=arr.reduce((item, next) => {
            obj[next[type].toString()+next[type2].toString()] ? '' : obj[next[type].toString()+next[type2].toString()] = true && item.push(next)
            return item
        }, [])
        return arr
    }
       console.log(unique(arr, 'id','age'))//当age属性为number类型时，会出现问题1+22===2+21
    /*[
     { id: 1, name: 'shy', age: 24 },
     { id: 2, name: 'orton', age: 20 },
     { id: 1, name: 'join', age: 22 },
     { id: 3, name: 'cena', age: 23 },
     { id: 2, name: 'belly', age: 21 },
 ]*/

方法二：filter()

       function unique2(arr, type,type2) {

       const obj = {};

       // 过滤的过程中完善 obj
       return arr.filter(t => {
           // 这里采用的办法是使用一个不会出现在两个数据中的字符 `|` 来连接
           const key = [t[type], t[type2]].join("|");

           // 检查如果对象中已经存在，那这个数据就过滤掉，不需要了
           if (obj[key]) {
               return false;
           }

           // 如果对象不存在，加入对象，同时把数据保留下来（返回 true）
           obj[key] = true;
           return true;
       });
   }
   console.log(unique2(arr, 'id','age'))
   /*
   [
           { id: 1, name: 'shy', age: 24 },
           { id: 2, name: 'orton', age: 20 },
           { id: 1, name: 'join', age: 22 },
           { id: 3, name: 'cena', age: 23 },
           { id: 2, name: 'belly', age: 21 },
       ]
   */

方法三：for...of+find()

   function unique3(arr, type, type2) {
       // 缓存用于记录
       const newArr = [];
       for (const t of arr) {
           // 检查缓存中是否已经存在
           if (newArr.find(c => c[type] === t[type] && c[type2] === t[type2])) {
               // 已经存在说明以前记录过，现在这个就是多余的，直接忽略
               continue;
           }
           // 不存在就说明以前没遇到过，把它记录下来
           newArr.push(t);
       }

       // 记录结果就是过滤后的结果
       return newArr;
   }
   console.log(unique3(arr, 'id', 'age'))
   /*
       [
               { id: 1, name: 'shy', age: 24 },
               { id: 2, name: 'orton', age: 20 },
               { id: 1, name: 'join', age: 22 },
               { id: 3, name: 'cena', age: 23 },
               { id: 2, name: 'belly', age: 21 },
           ]
       */

4.数组排序

方法一：sort()

   let arr = [8, 4, 1, 2, 4, 12, 4, 51, 24, -1, 0, 2, 4, 45, 21, 13]
   function compare(val1, val2) {
       return val1 - val2;
   };
   sort()方法会把比较的值转成字符串来比较，想要获得准确的排序，需要写一个排序方法
   console.log(arr.sort(compare))//[-1, 0, 1, 2, 2, 4, 4, 4, 4, 8, 12, 13, 21, 24, 45, 51]

方法二：冒泡排序

    function sort(arr) {
        for (var j = 0; j < arr.length - 1; j++) {
            //两两比较，如果前一个比后一个大，则交换位置。
            for (var i = 0; i < arr.length - 1 - j; i++) {
                if (arr[i] > arr[i + 1]) {
                    var temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                }
            }
        }
        return arr
    }
    console.log(sort(arr));//[-1, 0, 1, 2, 2, 4, 4, 4, 4, 8, 12, 13, 21, 24, 45, 51]
        （1）比较相邻的元素。如果第一个比第二个大，就交换他们两个位置。
    （2）对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
    （3）针对所有的元素重复以上的步骤，除了最后一个。
    （4）持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

方法三：快速排序

        function quickSort(arr) {
            //如果数组长度小于等于1，则返回数组本身
            if (arr.length <= 1) {
                return arr;
            }
            //定义中间值的索引
            var index = Math.floor(arr.length / 2);
            //取到中间值
            var temp = arr.splice(index, 1);
            //定义左右部分数组
            var left = [];
            var right = [];
            for (var i = 0; i < arr.length; i++) {
                //如果元素比中间值小，那么放在左边，否则放右边
                if (arr[i] < temp) {
                    left.push(arr[i]);
                } else {
                    right.push(arr[i]);
                }
            }
            return quickSort(left).concat(temp, quickSort(right));
        }
        console.log(quickSort(arr));//  [-1, 0, 1, 2, 2, 4, 4, 4, 4, 8, 12, 13, 21, 24, 45, 51]
        Math.floor(x)方法是向下取整，返回小于或等于x的最接近的整数。
        splice(index, num, item)方法是向数组中添加项目，或是从数组中删除项目，并返回被删除的项目。
        （1）index是整数，被操作项目所在的位置（必须）
        （2）num是整数，要删除的项目的数量，如果为0，表示不删除（必须）
        （3）item是向数组中添加的新项目，可以是多个（可选）
        push()方法是向数组末尾添加一个或多个新项目并返回新数组的长度
        concat()方法连接两个或多个数组，不会改变原有数组，返回一个新数组

方法四：插入排序

        function insertSort(arr) {
            //假设第0元素是有序序列，第1元素之后是无序的序列。从第1元素开始依次将无序序列的元素插入到有序序列中
            for (var i = 1; i < arr.length; i++) {
                if (arr[i] < arr[i - 1]) {
                    //取出无序序列中需要插入的第i个元素
                    var temp = arr[i];
                    //定义有序中的最后一个位置
                    var j = i - 1;
                    arr[i] = arr[j];
                    //比较大小，找到插入的位置
                    while (j >= 0 && temp < arr[j]) {
                        arr[j + 1] = arr[j];
                        j--;
                    };
                    //插入
                    arr[j + 1] = temp;
                }
            }
            return arr
        }
        console.log(insertSort(arr));//  [-1, 0, 1, 2, 2, 4, 4, 4, 4, 8, 12, 13, 21, 24, 45, 51]
        （1）从第一个元素开始，该元素可以认为已经被排序
        （2）取出下一个元素，在已经排序的元素序列中扫描
        （3）如果该元素（已排序）大于新元素，将该元素移到下一位置
        （4）重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
        （5）将新元素插入到下一位置中
        （6）重复步骤2

方法五：选择排序

   function selectSort(arr){
       for(var i=0;i<arr.length;i++){
           //设置当前范围最小值和索引
           var min = arr[i];
           var minIndex = i;
           //在该范围选出最小值
           for(var j=i+1;j<arr.length;j++){
               if(min>arr[j]){
                   min = arr[j];
                   minIndex = j;
               }
           }
           //将最小值插入,并将原来位置的最小值删除
           arr.splice(i,0,min);
           arr.splice(minIndex+1,1);
       }
       return arr
   }
   console.log(selectSort(arr)) //[-1, 0, 1, 2, 2, 4, 4, 4, 4, 8, 12, 13, 21, 24, 45, 51]
   （1）在未排序序列中找到最小（大）元素
   （2）并存放到排序序列的起始位置
   （3）然后，再从剩余未排序元素中继续寻找最小（大）元素
   （4）然后放到已排序序列的末尾。
   （5）以此类推

5.数组对象根据某个属性的值排序

    let arr = [
        { id: 1, name: 'shy', age: 24 },
        { id: 2, name: 'orton', age: 20 },
        { id: 1, name: 'join', age: 22 },
        { id: 3, name: 'cena', age: 23 },
        { id: 2, name: 'belly', age: 21 },
        { id: 1, name: 'randy', age: 24 },
    ]
    function compare(property, flag = true) {
        return function (a, b) {
            var value1 = a[property];
            var value2 = b[property];
            return flag ? value1 - value2 : value2 - value1;
        }
    }
    console.log(arr.sort(compare('age')))
    /*
     [
        { id: 2, name: 'orton', age: 20 },
        { id: 2, name: 'belly', age: 21 },
        { id: 1, name: 'join', age: 22 },
        { id: 3, name: 'cena', age: 23 },
        { id: 1, name: 'shy', age: 24 },
        { id: 1, name: 'randy', age: 24 },
    ]
    */

6.数组对象根据多个属性的值排序

    let arr = [
        { id: 1, name: 'shy', age: 24 },
        { id: 2, name: 'orton', age: 20 },
        { id: 1, name: 'join', age: 22 },
        { id: 3, name: 'cena', age: 23 },
        { id: 2, name: 'belly', age: 21 },
        { id: 1, name: 'randy', age: 24 },
    ]
    function compare(property, flag = true) {
        return function (a, b) {
            if (a[property[0]] === b[property[0]]) {
                return flag ? a[property[1]] - b[property[1]] : b[property[1]] - a[property[1]]
            } else {
                return flag ? a[property[0]] - b[property[0]] : b[property[0]] - a[property[0]]
            }

        }

    }
    console.log(arr.sort(compare(['id', 'age'])))
    /*
    [
       { id: 1, name: 'join', age: 22 },
       { id: 1, name: 'shy', age: 24 },
       { id: 1, name: 'randy', age: 24 },
       { id: 2, name: 'orton', age: 20 },
       { id: 2, name: 'belly', age: 21 },
       { id: 3, name: 'cena', age: 23 }, 
   ]
   */

7.数组合并

    let arr1 = [1, 2, 3]
    let arr2 = [4, 5, 6]

方法一：concat()

   console.log(arr1.concat(arr2)) //[1, 2, 3, 4, 5, 6]

方法二；结构赋值

    console.log([...arr1, ...arr2]) //[1, 2, 3, 4, 5, 6]

方法三：for循环

    function arrConcat(a, b) {
        for (let i in b) {
            a.push(b[i])
        }
        return a
    }
    console.log(arrConcat(arr1, arr2)) //[1, 2, 3, 4, 5, 6]

8.数组对象根据某一个属性的值相同进行合并

方法一：for循环判断新数组对象中该属性是否存在，存在合并

    let arr = [
        { id: 1, name: 'shy', age: 24 },
        { id: 2, name: 'orton', age: 20 },
        { id: 1, name: 'join', age: 22 },
        { id: 3, name: 'cena', age: 23 },
        { id: 2, name: 'belly', age: 21 },
        { id: 1, name: 'randy', age: 24 },
    ]
    function arrConcat(arr, type) {
        let tempArr = [],
            newArr = [];
        for (let i = 0; i < arr.length; i++) {
            if (tempArr.indexOf(arr[i][type]) === -1) {
                newArr.push({
                    id:arr[i][type],
                    name:[arr[i].name],
                    age:[arr[i].age]
                })
                tempArr.push(arr[i][type])
            } else {
                for (let j = 0; j < newArr.length; j++) {
                    if (newArr[j][type] == arr[i][type]) {
                        newArr[j].name.push(arr[i].name)
                        newArr[j].age.push(arr[i].age)
                    }
                }
            }

        }
        return newArr;
    }
    console.log(arrConcat(arr,'id'))
    /*
        [
            {
                "id": 1,
                "name": ["shy","join","randy"],
                "age": [24,22,24]
            },
            {
                "id": 2,
                "name": ["orton","belly"],
                "age": [20,21]
            },
            {
                "id": 3,
                "name": ["cena"],
                "age": [23]
            }
        ]
    */

方法二：reduce()+findIndex()

    function arrConcat(arr, type) {
        let newArray = [];
        newArray = arr.reduce((total, cur, index) => {
            let hasValue = total.findIndex(current => { return current[type] === cur[type] })
            console.log(hasValue, cur)
            if (hasValue === -1) {
                total.push({
                    id: cur[type],
                    name: [cur.name],
                    age: [cur.age]
                })
            } else {
                total[hasValue].name = total[hasValue].name.concat(cur.name)
                total[hasValue].age = total[hasValue].age.concat(cur.age)
            }

            return total
        }, [])
        return newArray
    }

    console.log(arrConcat(arr, 'id'))
    /*
       [
           {
               "id": 1,
               "name": ["shy","join","randy"],
               "age": [24,22,24]
           },
           {
               "id": 2,
               "name": ["orton","belly"],
               "age": [20,21]
           },
           {
               "id": 3,
               "name": ["cena"],
               "age": [23]
           }
       ]
       */

9.数组对象根据多个属性的值相同进行合并

    let arr = [
        { id: 1, name: 'shy', age: 24 },
        { id: 2, name: 'orton', age: 20 },
        { id: 1, name: 'join', age: 22 },
        { id: 3, name: 'cena', age: 23 },
        { id: 2, name: 'belly', age: 21 },
        { id: 1, name: 'randy', age: 24 },
    ]
    function arrConcat(arr, type) {
        let type0= type[0]
        let type1= type[1]
        let tempArr = [],
        tempArr2 = [],
            newArr = [];
        for (let i = 0; i < arr.length; i++) {
            if (tempArr.indexOf(arr[i][type0]) === -1 && tempArr2.indexOf(arr[i][type1]) === -1) {
                newArr.push({
                    id: arr[i][type0],
                    name: [arr[i].name],
                    age: arr[i][type1]
                })
                tempArr.push(arr[i][type0])
                tempArr2.push(arr[i][type1])
            } else {
                for (let j = 0; j < newArr.length; j++) {
                    if (newArr[j][type0] == arr[i][type0] && newArr[j][type1] == arr[i][type1]) {
                        newArr[j].name.push(arr[i].name)
                    }
                }
            }

        }
        return newArr;
    }
    console.log(arrConcat(arr, ['id', 'age']))
    /*
        [
            {
                "id": 1,
                "name": ["shy","randy"],
                "age": 24
            },
            {
                "id": 2,
                "name": ["orton"],
                "age": 20
            },
            {
                "id": 3,
                "name": ["cena"],
                "age": 23
            }
        ]
        */

10.数组中某个值出现的个数

    let arr = [8, 4, 1, 2, 4, 12, 4, 51, 24, -1, 0, 2, 4, 45, 21, 13]
    function arrNum(arr, key) {
        return arr.reduce((r, a) => a === key ? r + 1 : r + 0, 0)
    }
    console.log(arrNum(arr, 2)) //2

11.数组中每个值出现的个数

方法一:for循环

    let arr = [8, 4, 1, 2, 4, 12, 4, 51, 24, -1, 0, 2, 4, 45, 21, 13]
    function getArrNum(arr){
        let obj = {}
        for(let i = 0;i<arr.length;i++){
            obj[arr[i]]=(obj[arr[i]]+1)||1
        }
        return obj
    }
    console.log(getArrNum(arr)) //{0: 1, 1: 1, 2: 2, 4: 4, 8: 1, 12: 1, 13: 1, 21: 1, 24: 1, 45: 1, 51: 1, -1: 1}

方法二：reduce()

   function getArrNum(arr) {
       return arr.reduce((r, a) => {
           r[a] = (r[a] + 1) || 1
           return r
       }, {})
   }
   console.log(getArrNum(arr))//{0: 1, 1: 1, 2: 2, 4: 4, 8: 1, 12: 1, 13: 1, 21: 1, 24: 1, 45: 1, 51: 1, -1: 1}

12.数组中某个值出现的次数最多

方法一：for循环+for..in

    let arr = [8, 4, 1, 2, 4, 12, 4, 51, 24, -1, 0, 2, 4, 45, 21, 13]
    function getArrMost(arr) {
        let obj = {},
            mostVal = '';
        for (let i = 0; i < arr.length; i++) {
            obj[arr[i]] = (obj[arr[i]] + 1) || 1
        }
        // return obj
        for (var key in obj) { // 从对象中得到数组中出现最多的元素
            if (!mostVal) {
                mostVal = key;
            } else if (obj[mostVal] < obj[key]) {
                mostVal = key;
            }
        }
        return mostVal
    }
    console.log(getArrMost(arr)) // 4

方法二：reduce()+for..in

   function getArrMost(arr) {
       let mostVal = ''
       let obj = arr.reduce((r, a) => {
           r[a] = (r[a] + 1) || 1
           return r
       }, {})
               for (var key in obj) { // 从对象中得到数组中出现最多的元素
           if (!mostVal) {
               mostVal = key;
           } else if (obj[mostVal] < obj[key]) {
               mostVal = key;
           }
       }
       return mostVal
   }
   console.log(getArrMost(arr)); //4

13.同一个数组对象中判断某一个属性的值是否相同

    let arr = [
        { id: 1, name: 'shy', age: 24 },
        { id: 2, name: 'orton', age: 20 },
        { id: 1, name: 'join', age: 22 },
        { id: 3, name: 'cena', age: 23 },
        { id: 2, name: 'belly', age: 21 },
        { id: 1, name: 'randy', age: 24 },
    ]
    function isAllEqual(arr, type) {//该属性是否全部相同
        return arr.every(params => arr.filter(item => item[type] === params[type]).length === arr.length)
    }
    console.log(isAllEqual(arr, 'id'))//false
    function isEqual(arr, type) {//该属性是否有相同
        return arr.some(params => arr.filter(item => item[type] === params[type]).length > 1)
    }
    console.log(isEqual(arr, 'id'))//true

14.同一个数组对象中判断多个属性的值是否相同

   let arr = [
        { id: 1, name: 'shy', age: 24 },
        { id: 2, name: 'orton', age: 20 },
        { id: 1, name: 'join', age: 22 },
        { id: 3, name: 'cena', age: 23 },
        { id: 2, name: 'belly', age: 21 },
        { id: 1, name: 'randy', age: 24 },
    ]
   function isAllEqual(arr, type) {//该属性是否全部相同
        return arr.every(params => arr.filter(item => item[type[0]] === params[type[0]]).length === arr.length && arr.filter(item => item[type[1]] === params[type[1]]).length === arr.length)
    }
    console.log(isAllEqual(arr, ['id', 'age']))//false
    function isEqual(arr, type) {//该属性是否有相同
        return arr.some(params => arr.filter(item => item[type[0]] === params[type[0]]).length > 1 && arr.filter(item => item[type[1]] === params[type[1]]).length > 1)
    }
    console.log(isEqual(arr, ['id', 'age']))//true