数组的方法有数组原型方法,也有从object对象继承来的方法
数组原型方法主要有以下这些:

    a.valueof()   //返回数组本身
    a.toString()  //返回数组的字符串形式
    a.push(value,vlaue....)   //用于在数组的末端添加一个或多个元素,并返回添加新元素后的数组长度。
    pop()   //用于删除数组的最后一个元素,并返回该元素
    join()  //以参数作为分隔符,将所有数组成员组成一个字符串返回。如果不提供参数,默认用逗号分隔。
    concat()  //用于多个数组的合并。它将新数组的成员,添加到原数组的尾部,然后返回一个新数组,原数组不变。
    shift()  //用于删除数组的第一个元素,并返回该元素。
    unshift(value)  //用于在数组的第一个位置添加元素,并返回添加新元素后的数组长度。
    reverse()   //用于颠倒数组中元素的顺序,返回改变后的数组
    slice(start_index, upto_index);   //用于提取原数组的一部分,返回一个新数组,原数组不变。第一个参数为起始位置(从0开始),第二个参数为终止位置(但该位置的元素本身不包括在内)。如果省略第二个参数,则一直返回到原数组的最后一个成员。负数表示倒数第几个。
    splice(index, count_to_remove, addElement1, addElement2, ...);   //用于删除原数组的一部分成员,并可以在被删除的位置添加入新的数组成员,返回值是被删除的元素。第一个参数是删除的起始位置,第二个参数是被删除的元素个数。如果后面还有更多的参数,则表示这些就是要被插入数组的新元素。
    sort()   //对数组成员进行排序,默认是按照字典顺序排序。排序后,原数组将被改变。如果想让sort方法按照自定义方式排序,可以传入一个函数作为参数,表示按照自定义方法进行排序。该函数本身又接受两个参数,表示进行比较的两个元素。如果返回值大于0,表示第一个元素排在第二个元素后面;其他情况下,都是第一个元素排在第二个元素前面。
    map()   //ES5 新增   对数组的所有成员依次调用一个函数,根据函数结果返回一个新数组。
    map(elem,index,arr)   //map方法接受一个函数作为参数。该函数调用时,map方法会将其传入三个参数,分别是当前成员、当前位置和数组本身。
    forEach()   //(ES5 新增)  遍历数组的所有成员,执行某种操作,参数是一个函数。它接受三个参数,分别是当前位置的值、当前位置的编号和整个数组。
    filter()   //(ES5 新增)  参数是一个函数,所有数组成员依次执行该函数,返回结果为true的成员组成一个新数组返回。该方法不会改变原数组。
    some()    //(ES5 新增)   用来判断数组成员是否符合某种条件。接受一个函数作为参数,所有数组成员依次执行该函数,返回一个布尔值。该函数接受三个参数,依次是当前位置的成员、当前位置的序号和整个数组。只要有一个数组成员的返回值是true,则整个some方法的返回值就是true,否则false。
    every()   //(ES5 新增)    用来判断数组成员是否符合某种条件。接受一个函数作为参数,所有数组成员依次执行该函数,返回一个布尔值。该函数接受三个参数,依次是当前位置的成员、当前位置的序号和整个数组。所有数组成员的返回值都是true,才返回true,否则false。
    reduce()   //(ES5 新增)   依次处理数组的每个成员,最终累计为一个值。从左到右处理(从第一个成员到最后一个成员)
    reduceRight()  //(ES5 新增)  依次处理数组的每个成员,最终累计为一个值。从右到左(从最后一个成员到第一个成员)
    indexOf(s)   //(ES5 新增)  返回给定元素在数组中第一次出现的位置,如果没有出现则返回-1。可以接受第二个参数,表示搜索的开始位置
    lastIndexOf()  //(ES5 新增)   返回给定元素在数组中最后一次出现的位置,如果没有出现则返回-1。

数组去重的若干种方法

常用方法:for循环嵌套,使用splice去重

双层循环,外层循环元素,内层循环时比较值。值相同时,则删去这个值。

function unique(arr){            
        for(var i=0; i<arr.length; i++){
            for(var j=i+1; j<arr.length; j++){
                if(arr[i]==arr[j]){//第一个等同于第二个,splice方法删除第二个
                    arr.splice(j,1);
                    j--;
                }
            }
        }
return arr;
}
var arr = [1,1,'true','true',true,true,666,666,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}];
    console.log(unique(arr))
    //[1, "true", 666, false, undefined, NaN, NaN, "NaN", "a", {…}, {…}] 
//NaN和{}没有去重,两个null直接消失了

indexOf去重

新建一个空的结果数组,for 循环原数组,判断结果数组是否存在当前元素,如果有相同的值则跳过,不相同则push进数组。

function unique(arr) {
    if (!Array.isArray(arr)) {
        console.log('type error!')
        return
    }
    var array = [];
    for (var i = 0; i < arr.length; i++) {
        if (array .indexOf(arr[i]) === -1) {
            array .push(arr[i])
        }
    }
    return array;
}
var arr = [1,1,'true','true',true,true,666,666,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}];
console.log(unique(arr))
   // [1, "true", true, 666, false, undefined, null, NaN, NaN, "NaN", 0, "a", {…}, {…}]  //NaN、{}没有去重

排序相邻对比去重

利用sort()排序方法,然后根据排序后的结果进行遍历及相邻元素比对。

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 arrry;
}
     var arr = [1,1,'true','true',true,true,666,666,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}];
        console.log(unique(arr))
// [0, 1, 666, "NaN", NaN, NaN, {…}, {…}, "a", false, null, true, "true", undefined]      //NaN、{}没有去重

includes监测数组中是否相同值

function unique(arr) {
    if (!Array.isArray(arr)) {
        console.log('type error!')
        return
    }
    var array =[];
    for(var i = 0; i < arr.length; i++) {
            if( !array.includes( arr[i]) ) {//includes 检测数组是否有某个值
                    array.push(arr[i]);
              }
    }
    return array
}
var arr = [1,1,'true','true',true,true,666,666,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}];
    console.log(unique(arr))
    //[1, "true", true, 666, false, undefined, null, NaN, "NaN", 0, "a", {…}, {…}]     //{}没有去重

递归去重

function unique(arr) {
        var array= arr;
        var len = array.length;

    array.sort(function(a,b){   //排序后更加方便去重
        return a - b;
    })

    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 = [1,1,'true','true',true,true,666,666,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}];
console.log(unique(arr))
//[1, "a", "true", true, 666, false, 1, {…}, null, NaN, NaN, "NaN", 0, "a", {…}, undefined]

利用ES6 Set去重

function unique (arr) {
  return Array.from(new Set(arr))
}
var arr = [1,1,'true','true',true,true,666,666,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}];
console.log(unique(arr))
 //[1, "true", true, 666, false, undefined, null, NaN, "NaN", 0, "a", {}, {}]

解构赋值可以简写成这样

[...new Set(arr)] 

使用for循环push多条元素到数组中

注意循环 每次取出来的值都放在了adata中 所以adata对象一定要定义到循环里面。

    let arr=[]
    let addarr=[{ id: 210, name: "123" },{ id: 211, name: "124" },{ id: 212, name: "153" },{ id: 213, name: "122" },{ id: 214, name: "222"}]
    for (let i = 0; addarr.length > i; i++) {
        let adata = {}
        adata.id=addarr[i].id
        arr.push(adata);
    }
    console.log(arr) 

错误示范

    let arr=[]
    let addarr=[{ id: 210, name: "123" },{ id: 211, name: "124" },{ id: 212, name: "153" },{ id: 213, name: "122" },{ id: 214, name: "222"}]、
    let adata = {}
    for (let i = 0; addarr.length > i; i++) {
        adata.id=addarr[i].id
        arr.push(adata);
    }
    console.log(arr) //这样每条结果都是相同的

每次取出来的值都放在了 adata.id中,因为是在外面定义的对象,所以 adata.id的地址是一样的,arr中保存的是 adata.id的地址,当最后一次给 adata.id赋值的时候,由于是同一个 adata.id,所以最后一次给 adata.id赋值的后会把之前的值覆盖掉。