JavaScript数组详解-全网最全

定义数组的方式

定义数组的方式有多种，分别如下

let array=[] （字面量）
let array=new Array()
let array=new Array([length]) length表示长度
let array=new Array(arg1,arg2,arg3....)

let array=[];   // 初始化一个空数组
let array2=new Array();  // 初始化一个空数组
let array3=new Array(10); // 初始化一个长度为10的数组，数组的每一项都是empty
let array4=new Array(10,20,30,40);//  初始化一个长度为4的数组，数组的项分别为 10，20，30，40

其中在开发中，let array=[]使用的最多，也是推荐的。

数组的增删改查

数组的新增

定义一个数组之后需要向数组中添加对应的项，这里先介绍几种简单的处理方法。

array[index]=xxx
array[array.length]=xxx

let array=[];
array[0]=100;
array[1]=200;
console.log(array); //   100， 200

let array2=[10,20];
array2[array.length]=30;
console.log(array2);  // 10 20 30

数组的修改

如果需要修改的项存在则执行修改操作，不存在执行新增操作

let array=[];
array[0]=100;
array[1]=200;
console.log(array); //   100， 200

array[1]=300;    // 项存在，执行修改操作
console.log(array); // 100 300

数组的删除

arr.length=xxx xxx小于数组的长度就可以删除项

let array=[];
array[0]=100;
array[1]=200;
console.log(array); //   100， 200
array.length=0;
console.log(array); // []

数组的查询

循环遍历每一项，for循环，forEach循环等等
下标(索引)获取，array[index] 其中index表示索引

let array=[10,20,30,40,50];
console.log(array[0]); // 获取数组的第一项 10
for(let i=0;i<array.length;i++){
    console.log(array[i]);  //  遍历数组的每一项 10，20，30，40，50
}

检测数组的方法和数组的length属性

初始化数组之后，数组自带有一个length属性，表示数组的长度，这里就不再进行介绍了，检测数组的方法有instanceof和Array.isArray()

let array=[10,20,30,40,50];
console.log(Array.isArray(array));  // true
console.log(array instanceof Array); // true

我们知道数组是对象，既然是对象就必然离不开属性(length)和方法，关于属性length，就那啥了，你们懂的，主要介绍一下数组的方法，这里分为ES5数组常用的方法和ES6数组的方法。

ES5数组常用的方法

转换方法

Array.toString()：将数组变成由逗号分割的字符串
Array.valueOf()：返回数组本身

let array=[10,20,30,40,50];
console.log(array.toString());  // 10,20,30,40,50
console.log(array.valueOf());   // [10,20,30,40,50]

栈方法（遵循后进先出的原则）

Array.push()：将一个或多个元素添加到数组的末尾，并返回该数组的新长度
Array.pop()：从数组中删除最后一个元素，并返回该元素的值。此方法更改数组的长度

let array=[];
array.push(10,20,30,40,50,60);
console.log(array);// 10,20,30,40,50,60
let item=array.pop();
console.log(item);// 60
console.log(array);//  10,20,30,40,50

注意：数组的方法不支持推入整个数组，例如arr.push([1,2,3])不会是1,2,3，[1,2,3]只会作为数组中的一项，如果想实现，可以使用ES6的扩展运算符...

let array=[10,20,30,40];
let array1=[50,60,70,80];
array.push(...array1); // 使用扩展运算符
console.log(array);// 10,20,30,40,50,60,70,80

队列方法（遵循先进先出的原则）

Array.shift()：从数组中删除第一个元素，并返回该元素的值。此方法更改数组的长度
Array.unshift()：方法将一个或多个元素添加到数组的开头，并返回该数组的新长度(该方法修改原有数组）

let array=[10,20,30,40];
let item=array.shift();
console.log(item);  // 10
console.log(array);// 20,30,40
array.unshift(100,200,300);
console.log(array);// 100,200,300,20,30,40

重排序方法

Array.reverse()：将数组中元素的位置颠倒，并返回该数组。数组的第一个元素会变成最后一个，数组的最后一个元素变成第一个。该方法会改变原数组
Array.sort()：对数组的元素进行排序，并返回数组。默认排序顺序是在将元素转换为字符串，然后比较它们的UTF-16代码单元值序列时构建的

let array1=[10,20,30,40,50];
array1.reverse();
console.log(array1);// 50,40,30,20,10
let array2=[10,5,20,30,40,50];
array2.sort();
console.log(array2);// 10,20,30,40,5,50

控制台输出可以看到，sort排序方法并没有实现我们期望的结果 5，10，20，30，40，50，这是因为首先sort会调用每个数组项的toString()转型方法，然后比较得到的字符串，如果要实现期望的结果，可以在sort中传入一个函数实现排序。

Array.sort(function(a,b){})

a：用于比较的第一个参数

b：用于比较的第二个参数

如果第一个参数应该位于第二个参数之前则返回一个负数，如果两个参数相等则返回0，如果第一个参数应该位于第二个参数之后则返回一个正数。

Array.sort()实现升序

let array=[10,20,40,50,30];
function compare(x,y) {
    if(x<y){
        return -1;
    }else if(x>y){
        return 1
    }else {
        return 0
    }
}
array.sort(compare);
console.log(array);    // 10，20，30，40，50

经过排序之后，得到了排序之后升序的结果，如果想要实现降序，将位置调换一下就可以了

Arra.sort()实现降序

let array=[10,20,40,50,30];
function compare(x,y) {
    if(x<y){
        return 1;
    }else if(x>y){
        return -1
    }else {
        return 0
    }
}
array.sort(compare);
console.log(array); // 50,40,30,20,10

如果是对于数值类型或者其valueOf()方法会返回数值类型的对象类型，可以直接使用第一个参数减去第二个参数

操作方法

Array.concat()：用于合并两个或多个数组。此方法不会更改现有数组，而是返回一个新数组
Array.slice([start,end])：可以接受一或两个参数，即返回项的起始位置和结束位置，只有一个参数，返回该参数指定位置到当前数组末尾的所有项，如果有两个参数，该方法返回起始位置到结束位置之间的项(但不包括结束位置的项)
Array.splice()：
- 删除 =>可以删除任意数量的项，只需指定两个参数，要删除第一项的位置和要删除的项数
- 插入=>可以向指定位置插入任意数量的项，只需提供3个参数，起始位置，0，要插入的项，如果要插入多个项，可以传入第n项，第n+1项，...
- 替换=>可以向指定位置插入任意数量的项，且同时删除任意数量的项,只需指定3个参数，起始位置，要删除的项数和要插入的的任意数量的项，插入的项数不必与删除的项数相等
Array.join()：使用不同的符号连接数组

Array.concat()

let array=[10,20,30,40];
let array1=[50,60];
let newArray=array.concat(array1);
console.log(newArray);  // 10,20,30,40,50,60
let array2=array.concat('20',[50,60],80);
console.log(array2);  // 10,20,30,40,20,50,60,80

Array.slice(start,end)

start：表示起始位置的索引

end：表示结束位置的索引

let array=[10,20,30,40,50,60,70];
let array1=array.slice(1);// 没有结束位置，表示从起始位置到数组末尾
console.log(array1);// 20,30,40,50,60,70
let array2=array.slice(2,5); // 起始位置的索引为2，结束位置的索引为5(不包括结束位置)
console.log(array2);// 30,40,50

注意：如果slice()方法中起始位置或结束位置中有负数，则用数组的长度加上该数来确定，举个例子：在一个包含5项的数组中slice(-2,-1)和slice(3,4)是一样的，如果结束位置小于起始位置则返回空数组。

Array.splice(index,item)实现删除操作

let array=[10,20,30,40,50];
array.splice(2,2); // 从索引2开始删除两项
console.log(array); //  10,20,50

Array.splice(start,0,addItem)实现新增操作

let array=[10,20,30];
array.splice(1,0,40,50,60);//  从下标1开始删除0项，新增40，50，60这三项
console.log(array); // 10,40,50,60,20,30

Array.splice(start,deleteItem,addItem)实现修改操作

let array=[10,20,30,40,50,60,70];
array.splice(2,2,90,100,110); // 从下标2开始删除2项，插入90，100，110这三项
console.log(array);//   10,20,90,100,110,50,60,70

需要注意的一点是：插入项的时候是插入当前删除项的前面

Array.join()

这个方法可以使用不同的符号连接成字符串，默认不传参数使用逗号(,)进行连接

let array=[10,20,30,40,50,60];
let array1=array.join('-');
let array2=array.join('|');
let array3=array.joing();
console.log(array1); // 10-20-30-40-50-60
console.log(array2); // 10|20|30|40|50|60
console.log(array3); // 10,20,30,40,50,60

位置方法

Array.indexOf(searchElement,fromIndex)：从数组的开头(位置0)开始向后查找，没有找到返回-1
Array.lastIndexOf(searchElemengt,fromIndex)：从数组的末尾开始向前查找，没有找到返回-1

searchElement：需要查找的元素

fromIndex：表示从什么位置开始查找

// 索引     0,1,2,3,4,5,6,7,8
let array=[1,2,3,4,5,4,3,2,1];
console.log(array.indexOf(4));// 3 查找元素为4第一次出现的位置
console.log(array.lastIndexOf(4));// 5 查找元素为4最后一次出现的位置
console.log(array.indexOf(4,4));  // 5 从索引4开始查找元素为4第一次出现的位置
console.log(array.lastIndexOf(4,4))// 3 从索引4开始查找元素为4最后一个出现的位置

迭代方法

Array.every(function(item,index,array))：对数组中的每一项运行给定函数，如果该函数对每一项都返回true,则返回true
Array.filter(function(item,index,array))：对数组中的每一项运行给定函数，返回该函数会返回true的项组成的数组
Array.some(function(item,index,array))：对数组中的每一项运行给定函数，如果该函数对任一项返回true,则返回true
Array.forEach(function(item,index,array))：对数组中的每一项运行给定函数，这个方法没有返回值
Array.map(function(item,index,array))：对数组中的每一项运行给定函数，返回每次函数调用的结果返回的数组

let arrays=[1,2,3,4,5,4,3,2,1];
let everyResult=arrays.every((item,index,array)=>{
    return item>10;
})
console.log(everyResult);   // false
let someResult=arrays.some((item,index,array)=>{
    return item>10
})
console.log(someResult);    // false
let filterResult=arrays.filter((item,index,array)=>{
    return item>2;
})
console.log(filterResult);  // 3,4,5,4,3
let mapResult=arrays.map((item,index,array)=>{
    return item*2;
})
console.log(mapResult);// 2,4,6,8,10,8,6,4,2
arrays.forEach((item,index,array)=>{
    console.log(item);  // 1,2,3,4,5,4,3,2,1
})

注意：以上方法都不会修改数组中包含的值

归并方法

Array.reduce()：迭代数组的所有项，然后构建一个最终返回的值，从数组的第一项开始，遍历到最后
Array.reduceRight()：迭代数组的所有项，然后构建一个最终返回的值，从数组的最后一项开始，向前遍历到第一项

let array=[1,2,3,4,5];
let sum=array.reduce((prev,cur,index,array)=>{
    return prev+cur
});
console.log(sum);
let sum2=array.reduceRight((prev,cur,index,array)=>{
    return prev+cur
})
console.log(sum2);

注意：reduce实现的功能有很多，这里只简单的提一下

ES6数组新增的方法

Array.from()

用于将类对象转为真正的数组，类似数组的对象和可遍历的对象，常见的类数组有：

document.querySelectorAll('标签')获取的集合
函数内部属性arguments对象

注意：只要是部署了Iterator接口的数据结构，Array.from都能将其转为数组，Array.from()方法还支持类似数组的对象，任何有length属性的对象，都可以通过Array.from方法转为数组

let lis=document.querySelectorAll('li');
let arrays=Array.from(lis);
arrays.push(11111);
console.log(arrays);// li,li,li,11111
function foo() {
    var args=Array.from(arguments);
    args.push(10,20);
    console.log(args);  // 10,20
}
foo();

Array.of()

用于将一组值，转换为数组

注意：Array.of()总是返回参数值组成的数组，如果没有参数，就返回一个空数组

console.log(Array.of(3,11,8));  //  3,11,8
console.log(Array.of(3));   // 3
console.log(new Array(1,2));    // 1,2
console.log(Array.of());   // []
console.log(Array.of(undefined)); // undefined
console.log(Array.of(1));   //  1
console.log(Array.of(1,2)); // 1,2

Array.copyWithin(target,start=0,end=this.length)

在当前数组内部，将指定位置的成员复制到其它位置(会覆盖原有成员),然后返回当前数组

参数：

target(必须)：从该位置开始替换数据，如果为负值，表示倒数

start(可选)：从该位置读取数据，默认为0，如果为负值，表示从末尾开始计算

end(可选): 到该位置前停止读取数据，默认等于数组长度，如果为负值，表示从末尾开始计算

[1, 2, 3, 4, 5].copyWithin(-2)
// [1, 2, 3, 1, 2]
[1, 2, 3, 4, 5].copyWithin(0, 3)
// [4, 5, 3, 4, 5]
[1, 2, 3, 4, 5].copyWithin(0, 3, 4)
// [4, 2, 3, 4, 5]
[1, 2, 3, 4, 5].copyWithin(-2, -3, -1)
// [1, 2, 3, 3, 4]

Array.fill()

使用给定值，填充一个数组

console.log(['a','b','c'].fill(7)); // 7,7,7
console.log(new Array(3).fill(10)); // 10,10,10
console.log(['a','b','c'].fill(7,1,2));// 'a',7,'c'

Array.find()和Array.findIndex()

Array.find()：用于找出第一个符合条件的数组成员，它的参数是一个回调函数，所有数组成员依次执行该回调方法，直到找出第一个返回值为true的成员，然后返回该成员，如果没有符合条件的成员，则返回undefined。
Array.findIndex()：返回第一个符合条件的数组成员位置，如果所有成员都不符合条件，则返回-1

let item1=[1,4,-5,10,-6].find((n)=>n<=-5);
console.log(item1);  // -5
let item2=[1,4,-5,10].find((item,index,arr)=>{
    return item<-5
})
console.log(item2); // undefined

let item3=[1,5,10,15].findIndex((item,index,arr)=>{
    return item>9
});
console.log(item3); // 下标为2

Array.includes()

返回一个布尔值，表示某个数组是否包含给定的值

[1, 2, 3].includes(2);     // true
[1, 2, 3].includes(4);     // false
[1, 2, 3].includes(3, 3);  // false
[1, 2, 3].includes(3, -1); // true
[1, 2, NaN].includes(NaN); // true

Array.flat()和Array.flatMap()

Array.flat([depth])：用于将嵌套的数组拉平，变成一维数组，该方法返回一个新数组，对原始数据没有影响
Array.flatMap()：对原数组的每一个成员执行一个函数(相当于执行Array.map()方法)，然后对返回值组成的数组执行flat方法，该方法返回一个新数组，不改变原数组

depth：指定要提取嵌套数组的结构深度，默认值为 1

let array1=[1,2,[3,4]].flat();
console.log(array1); // 1,2,3,4
let array2=[1,2,[3,[4,5]]].flat();
console.log(array2)    // 1,2,3[,4,5]
let array3=[1,2,[3,[4,5]]].flat(2);
console.log(array3);// 1,2,3,4,5

#### 数组实例的entries()、keys()、values()

keys()：对数组键名的遍历

values()：对数组键值的遍历

entries()：对数组键值对的遍历

数组其实也是有键的，一般我们用console.log()方法输出的时候都是它的值，键表示索引，可以使用console.info()方法输出详细信息

let array=[1,2,3,4,5];
for(let item of array.keys()){
    console.log('键是:'+item);    // 0,1,2,3,4
}
for(let item of array.values()){
    console.log('值是:'+item);  // 1,2,3,4,5
}
for(let [index,value] of array.entries()){
    console.log(`键：${index},值:${value}`);
}

数组排序的方法

数组的简单排序

上文说了一下数组自带的排序方法sort，会将数组的每一项都调用toString()方法再进行比较，我们先来看下一个简单的例子

<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title>简单排序</title>
    </head>
    <body>
        <script type="text/javascript">
            var numbers=[4,6,8,0,1,2,3,7,9];
            numbers.sort();//调用数组内置排序方法
            console.log(numbers);//0,1,2,3,4,6,7,8,9
            numbers.reverse();//将数组进行反转
            console.log(numbers);//9,8,7,6,4,3,2,1,0
        </script>
    </body>
</html>

<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title>简单数组自定义排序</title>
    </head>
    <body>
        <script type="text/javascript">
            var number=[0,1,10,15,5];
            function arrAsc(a,b){    //实现数组升序的方法
                if(a>b){
                    return 1;
                }else if(a<b){
                    return -1;
                }else{
                    return 0;
                }
            }
            number.sort(arrAsc);//调用数组升序的方法
            console.log(number);//0.1,5,10,15
            function arrDesc(a,b){    //实现数组降序的方法
                if(a>b){
                    return -1;
                }else if(a<b){
                    return 1;
                }else{
                    return 0;
                }
            }
            number.sort(arrDesc);//调用数组降序的方法
            console.log(number);//15,10,5,1,0
            
        </script>
    </body>
</html>

对象数组排序

<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title>简单对象自定义属性排序</title>
    </head>
    <body>
        <script type="text/javascript">
            var friuts=[
                {
                    name:'apple',
                    price:18.5,
                    count:10
                },
                {
                    name:'pear',
                    price:1.5,
                    count:5,
                },
                {
                    name:'banana',
                    price:20.5,
                    count:20
                },
            ]
            console.log(JSON.stringify(friuts));//未排序前
            //按价格升序排序
            friuts.sort(function(x,y){
                return x.price-y.price;
            });
            console.log(JSON.stringify(friuts));
            //按名称排序
            friuts.sort(function(x,y){
                if(x.name>y.name){
                    return 1;
                }else if(x.name<y.name){
                    return -1;
                }else{
                    return 0;
                }
            });
            console.log(JSON.stringify(friuts));
        </script>
    </body>
</html>

自定义排序方法

<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title>通用的排序方法</title>
    </head>
    <body>
        <script type="text/javascript">
            var friuts=[
                {
                    name:'apple',
                    price:18.5,
                    count:10
                },
                {
                    name:'pear',
                    price:1.5,
                    count:5,
                },
                {
                    name:'banana',
                    price:20.5,
                    count:20
                },
            ]
            var sortExp=function(key,isAsc){
                return function(x,y){
                    if(isNaN(key)){
                        if(x[key]>y[key]){
                            return 1*(isAsc?1:-1);
                            
                        }else if(x[key]<y[key]){
                            return -1*(isAsc?1:-1);
                        }else{
                            return 0;
                        }
                        
                    }else{
                        return (x[key]-y[key])*(isAsc?1:-1)
                    }
                }
            }
            //价格升序
            friuts.sort(sortExp('price',true));
            console.log(JSON.stringify(friuts));
            //价格降序
            friuts.sort(sortExp('price',false));
            console.log(JSON.stringify(friuts));
            //名称升序
            friuts.sort(sortExp('name',true));
            console.log(JSON.stringify(friuts));
            //名称降序
            friuts.sort(sortExp('name',false));
            console.log(JSON.stringify(friuts));
            //数量升序
            friuts.sort(sortExp('count',true));
            console.log(JSON.stringify(friuts));
            //数量降序
            friuts.sort(sortExp('count',false));
            console.log(JSON.stringify(friuts));
        </script>
    </body>
</html>

手写数组去重的12种方法

1、使用ES6 中的Set实现去重（ES6中最常用）

function unique (arr) {
    return Array.from(new Set(arr))
}
let array=[1,2,3,1,2,'true','true',false,false,undefined,undefined,null,null,NaN,NaN,{},{}]
console.log(unique(array));//  1,2,3,'true',false,undefined,null,NaN,{},{}

缺点：可以看到{}无法实现去重

2、使用双重for循环和splice实现去重（ES5）

function unique(array){
    for(let i=0;i<array.length;i++){    // 外层循环元素
        for(let j=i+1;j<array.length;j++){  // 内层进行值比较
            if(array[i]==array[j]){
                array.splice(j,1);
                j--;
            }
        }
    }
    return array;
}
let array=[1,2,3,1,2,'true','true',false,false,undefined,undefined,null,null,NaN,NaN,{},{}];
console.log(unique(array)); // 1,2,3,'true',false,undefined,NaN,NaN,{},{}

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

缺点：null直接消失，NaN和{}无法实现去重

3、使用indexOf实现去重

function unique(arr) {
    let array = [];
    for (let i = 0; i < arr.length; i++) {
        if (array.indexOf(arr[i]) === -1) {
            array.push(arr[i])
        }
    }
    return array;
}
let array=[1,2,3,1,2,'true','true',false,false,undefined,undefined,null,null,NaN,NaN,{},{}];
console.log(unique(array));// 1,2,3,'true',false,undefined,null,NaN,NaN{},{}

缺点：NaN和{}无法实现去重

4、使用sort()实现去重

function unique(arr) {
    arr = arr.sort()
    let array= [arr[0]];
    for (let i = 1; i < arr.length; i++) {
        if (arr[i] !== arr[i-1]) {
            array.push(arr[i]);
        }
    }
    return array;
}
let array=[1,2,3,1,2,'true','true',false,false,undefined,undefined,null,null,NaN,NaN,{},{}];
console.log(unique(array));// 1, 2, 3, NaN, NaN, {}, {}, false, null, "true", undefined

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

缺点：NaN和{}无法实现去重

5、使用对象的属性不能相同的特点实现去重

function unique(arr) {
    let array= [];
    let  obj = {};
    for (var i = 0; i < arr.length; i++) {
        if (!obj[arr[i]]) {
            array.push(arr[i])
            obj[arr[i]] = 1
        } else {
            obj[arr[i]]++
        }
    }
    return array;
}
let array=[1,2,3,1,2,'true','true',false,false,undefined,undefined,null,null,NaN,NaN,{},{}];
console.log(unique(array));// 1, 2, 3, "true", false, undefined, null, NaN, {}

6、使用 includes实现去重

function unique(arr) {
    let array =[];
    for(let i = 0; i < arr.length; i++) {
        if( !array.includes( arr[i]) ) {
            array.push(arr[i]);
        }
    }
    return array
}
let array=[1,2,3,1,2,'true','true',false,false,undefined,undefined,null,null,NaN,NaN,{},{}];
console.log(unique(array));// 1, 2, 3, "true", false, undefined, null, NaN, {}, {}

缺点：{}无法实现去重

7、使用hasOwnProperty实现去重

function unique(arr) {
    let obj = {};
    return arr.filter(function(item, index, arr){
        return obj.hasOwnProperty(typeof item + item) ? false : (obj[typeof item + item] = true)
    })
}
let array=[1,2,3,1,2,'true','true',false,false,undefined,undefined,null,null,NaN,NaN,{},{}];
console.log(unique(array));// 1, 2, 3, "true", false, undefined, null, NaN, {}

利用hasOwnProperty 判断是否存在对象属性

8、使用filter实现去重

function unique(arr) {
    return arr.filter(function(item, index, arr) {
        return arr.indexOf(item, 0) === index;  // NaN无法实现查找
    });
}
let array=[1,2,3,1,2,'true','true',false,false,undefined,undefined,null,null,NaN,NaN,{},{}];
console.log(unique(array));// 1,2,3,'true',false,undefined,null,{},{}

缺点：NaN不见了，{}也无法实现去重

9、使用递归实现去重

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;
}
let array=[1,2,3,1,2,'true','true',false,false,undefined,undefined,null,null,NaN,NaN,{},{}];
console.log(unique(array));// false,null,1,2,3,'true',NaN,NaN,{},{},undefined

缺点：{},NaN没有实现去重

10、使用Map数据结构实现去重

function arrayNonRepeatfy(arr) {
    let map = new Map();
    let array = new Array();  // 数组用于返回结果
    for (let i = 0; i < arr.length; i++) {
        if(map .has(arr[i])) {  // 如果有该key值
            map .set(arr[i], true); 
        } else { 
            map .set(arr[i], false);   // 如果没有该key值
            array .push(arr[i]);
        }
    } 
    return array ;
}
let array=[1,2,3,1,2,'true','true',false,false,undefined,undefined,null,null,NaN,NaN,{},{}];
console.log(arrayNonRepeatfy(array));// 1,2,3,'true',false,undefined,null,NaN,{},{}

创建一个空Map数据结构，遍历需要去重的数组，把数组的每一个元素作为key存到Map中。由于Map中不会出现相同的key值，所以最终得到的就是去重后的结果。

缺点：{}没有实现去重

11、使用reduce+includes实现去重

function unique(arr){
    return arr.reduce((prev,cur) => prev.includes(cur) ? prev : [...prev,cur],[]);
}
let array=[1,2,3,1,2,'true','true',false,false,undefined,undefined,null,null,NaN,NaN,{},{}];
console.log(unique(array));// 1,2,3,'true',false,undefined,null,NaN,{},{}