数组的方法以及数组的去重和排序

数组的方法

• push 尾部添加 此方法改变原数组，返回的是数组的长度

arr=[1,2,3,4]
arr.push(1)    //5
arr            //[1,2,3,4,1]

• pop 尾部删除 此方法改变原数组，返回的是删除的元素

arr=[1,2,3,4]
arr.pop(1)     //4
arr            //[1,2,3]

• unshift 头部添加 此方法改变原数组，返回的是数组的长度

arr=[1,2,3,4]
arr.unshift(0)     //5
arr            //[0,1,2,3,4]

• shift 头部删除 此方法改变原数组，返回的是删除的元素

arr=[1,2,3,4]
arr.shift(1)     //1
arr            //[2,3,4]

• slice 复制数组 此方法不改变原数组，返回的是被复制的部分，接收两个参数，第一个是起始位置（包含），第二个是结束位置（不包含），当第二个参数不传的时候默认复制到最后，当两个参数都不传的时候，默认复制整个数组（使用它可以实现数组的深拷贝）

arr=[1,2,3,4]
arr.slice()     //[1,2,3,4]
arr.slice(1)    //[2,3,4]
arr.slice(1,3)  //[2,3]
arr            //[1,2,3,4]

• splice 删除数组 此方法改变原数组，返回的是被删除的部分，接收三个参数，，第一个是起始位置（包含），第二个是删除的个数，第三个是往删除位置添加的参数，当第二个参数不传的时候默认删除到最后，当三个参数都不传的时候，默认删除整个数组，（使用它可以实现数组的深拷贝）

arr=[1,2,3,4]
arr.splice()     //[1,2,3,4]
arr              //[]
arr.splice(1)    //[2,3,4]
arr              //[1]
arr.splice(1,3)  //[2,3,4]
arr              [1]
arr.splice(1,3,[5,3,6])     //[1]
arr              //[1,[5,3,6]]

• reverse 反转数组 此方法改变原数组，返回的是反转之后的数组

arr=[1,5,2,1]
arr.reverse()   //[1,2,5,1]
arr             //[1,2,5,1]

• sort 对数组进行排序 此方法改变原数组，返回的是排序之后的数组，它的参数是一个函数，当不传参数的时候，默认是从小到大排列

arr=[1,2,5,4,7]
arr.sort((a,b)=>{return a-b})     //[1,2,4,5,7]
arr.sort((a,b)=>{return b-a})     //[7,5,4,2,1]

• join 将数组转换为字符串，不改变原数组，返回的是字符串，它的参数表示将元素以何种方式分隔，当不传参数的时候相当于参数为 “,” ，当参数为 “” 的时候表示元素之间不添加分隔符

arr=[1,2,3]
arr.join()          //"1,2,3"
arr.join("")        //"123"
arr.join("-")       //"1-2-3"
arr                 //[1,2,3]

• concat 将数组进行合并，不改变原数组，返回的是合并之后的数组

arr=[1,2,3];        arr1=[2,3,4]
arr.concat(arr1)          //[1, 2, 3, 2, 3, 4]
arr                       //[1,2,3]
arr0                      //[2,3,4]

• arr.includes()判断数组中是否存在某个元素，返回布尔值

arr=[1,2,3]
arr.includes("5")    //false
arr.includes(2)      //true
arr.includes("2")    //false

• Array.isArray 判断一个对象是不是一个数组

arr=[1,2,3]
Array.isArray(arr)                //true
obj={a:1,b:2}
Array.isArray(Array.from(obj))    //true
Array.isArray(obj)                //false

• arr.forEach(()=>{}) 用于遍历数组(相当于for循环)

arr=[1,2,3]
arr0=[]
arr.forEach((v)=>{arr0.push(v)})
arr0          //[1,2,3]

• arr.map(()={})用于映射一个数组，他不改变原数组，返回映射之后的新数组

arr=[1,2,3]
arr.map((v)=>{return v+1})     //[2,3,4]
arr         //[1,2,3]

• arr.filter(()={})用于过滤一个数组，不改变原数组，返回满足条件的元素组成的数组

arr=[1,2,3]
arr.filter((v)=>{return v>2})      //[3]
arr                                //[1,2,3]

• arr.reduce(()=>{})累计，返回结果是累计之后的值，不改变原数组

arr=[1,2,4]
arr.reduce((a,b)=>{return a+b})    //7
arr.reduce((a,b)=>{return a-b})    //-5
arr.reduce((a,b)=>{return a*b})    //8
arr.reduce((a,b)=>{return a/b})    //0.125
arr                                //[1,2,4]

• arr.indexOf()查找数组中某个元素第一次出现的位置，找到返回下标，找不到返回-1

arr=[1,2,3,1]
arr.indexOf("1")       //0
arr.indexOf("4")       //-1

• arr.lastIndexOf()查找数组中某个元素最后一次出现的位置，找到返回下标，找不到返回-1

arr=[1,2,3,1]
arr.lastIndexOf("1")   //3
arr.lastIndexOf("0")   //-1

• arr.every(()=>{})判断是不是数组中的所有元素都满足某个条件，返回布尔值

arr=[1,2,3]
arr.erery((v)=>{return v>2})    //false
arr.erery((v)=>{return v>0})    //true

• arr.some(()=>{})判断数组中是否存在满足条件的元素，返回布尔值

arr=[1,2,3]
arr.erery((v)=>{return v>2})    //true
arr.erery((v)=>{return v>3})    //false

• arr.find(()=>{}) 查找数组中的某个元素，找到返回这个元素(只返回第一个匹配的元素)，找不到，返回 undefined

arr=[1,2,3]
arr.find((v)=>{return v>1})    //2
arr.find((v)=>{return v>4})    //undefined

• arr.findIndex(()=>{})查找数组中某个元素所在的下标(只获取第一个满足条件的元素的下标)，找到返回下标，找不到返回-1

arr=[1,2,3]
arr.findIndex((v)=>{return v>0})    //0
arr.findIndex((v)=>{return v==4})    //-1

数组去重的几种方式：

1. 使用 new Set 结合扩展运算符（无法将对象去重）

[...new Set(arr)]
	
例：
arr=[1,1,"n","n",null,null,false,false,true,true,,,{n:1,a:[2]},{n:1,a:[2]},[1,[1,1,2]],[1,[1,1,2]]]
quChong(arr)
[1, "n", null, false, true,undefined, {n:1,a:[2]}, {n:1,a:[2]}, [1,[1,1,2]], [1,[1,1,2]]]

2. 使用 new Set 结合 Array.from（无法将对象去重）

Array.from(new Set(arr))
	
例：
arr=[1,1,"n","n",null,null,false,false,true,true,,,{n:1,a:[2]},{n:1,a:[2]},[1,[1,1,2]],[1,[1,1,2]]]
quChong(arr)
[1, "n", null, false, true,undefined, {n:1,a:[2]}, {n:1,a:[2]}, [1,[1,1,2]], [1,[1,1,2]]]

3. 使用 new Set 结合 forEach（无法将对象去重）

function quChong(arr){
		arr0=arr.slice(0)
	   	 arr=[];
	    	(new Set(arr0)).forEach((v)=>{arr.push(v)})
		return arr;
	}
	
例：
arr=[1,1,"n","n",null,null,false,false,true,true,,,{n:1,a:[2]},{n:1,a:[2]},[1,[1,1,2]],[1,[1,1,2]]]
quChong(arr)
[1, "n", null, false, true,undefined, {n:1,a:[2]}, {n:1,a:[2]}, [1,[1,1,2]], [1,[1,1,2]]]

4. 使用 forEach 根据下标判断（无法将对象去除，而且他将空的元素删除了）

function quChong(arr){
		let newArr=[];
		arr.forEach((v)=>{
			if(newArr.indexOf(v)==-1){
				newArr.push(v)
			}
		})
		return newArr
 }

例：
arr=[1,1,"n","n",null,null,false,false,true,true,,,{n:1,a:[2]},{n:1,a:[2]},[1,[1,1,2]],[1,[1,1,2]]]
quChong(arr)
[1, "n", null, false, true, {n:1,a:[2]}, {n:1,a:[2]}, [1,[1,1,2]], [1,[1,1,2]]]

5. 通过数组中的every进行判断(这个方法的去重效果最好)

function quChong(arr){
	let newArr=[];
	for(let i=0;i<arr.length-1;i++){
		if(newArr.every(v=>JSON.stringify(v)!==JSON.stringify(arr[i]))){
			newArr.push(arr[i])
		}
	}
	return newArr;
}

例：
arr=[1,1,"n","n",null,null,false,false,true,true,,,{n:1,a:[2]},{n:1,a:[2]},[1,[1,1,2]],[1,[1,1,2]]]
quChong(arr)
[1, "n", null, false, true, undefined,{n:1,a:[2]}, [1,[1,1,2]]]

数组排序的几种方式：(升序)

1. 使用数组中的 sort 方法

arr.sort((a,b)=>{return a-b})

2. 双重 for 循环，将当前元素与后面的所有元素进行对比（从前往后进行对比）

	for(let i=0;i<arr.length-1;i++){
		for(let j=i+1;j<arr.length;j++){
			if(arr[i]>arr[j]){
				let str=arr[i]
				arr[i]=arr[j]
				arr[j]=str
			}
		}
	}

3. 双重 for 循环，将当前元素与它相邻的后面的那个元素进行对比

	for(let i=0;i<arr.length;i++){
		for(let j=0;j<arr.length-i;j++){
			if(arr[j]>arr[j+1]){
				let str=arr[j]
				arr[j]=arr[j+1]
				arr[j+1]=str
			}
		}
	}

4. 双重 for 循环，将当前元素与它相邻的后面的那个元素进行对比（与上面那一个本质是一样的）

    for(let i=arr.length-1;i>0;i--){
    	for(let j=0;j<i;j++){
    		if(arr[j]>arr[j+1]){
    			let str=arr[j];
    			arr[j]=arr[i];
    			arr[i]=str
    		}
    	}
    }