定义数组与数组的一些方法

数组的定义方式

Var 变量名 = [值1，值2，值3]；

Var 变量名 = new Array（值1，值2，值3）｜｜new Array（）

数组取值

         变量名[索引值]
                注意：数组的索引值是从0开始的，依次是：0、1、2、3....

获取数组长度及对数组增、删、改

        长度：变量名.length (字符串也可以用)

        增加|修改： arr[索引值]=“要增加的值|要修改值”

        删除：delete arr[索引值] 注意：这种方式删除数组元素不够彻底，删除之后原来的元素值为空，但是还会占据一个数组的位置

数组的方法

        concat

                将所有的数组连接成一个数组，并返回结果

var a = [1,2,3,4];

var b = [3,4,5,6];

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

        join

                将数组里的元素以特定的符号连接在一起，返回字符串

var a = [1,2,3,4];

console.log(a.join("*")) //1*2*3*4

console.log(a.join("")) //1234

        pop

                ​​​​​​​删除最后一个元素，返回值为被删除的元素

var a = [1,2,3,4];

console.log(a.pop()) //4

console.log(a) //[1, 2, 3]

        shift

                删除第一个元素，返回值为被删除的元素

var a = [1,2,3,4];

console.log(a.shift()) //1

console.log(a) //[2, 3, 4]

        push

                可向数组的末尾添加一个或多个元素，并且返回新数组的长度

var a = [1,2,3,4];

console.log(a.push(5,6,7)) //7

console.log(a) //[1, 2, 3, 4, 5, 6, 7]

        unshift

                向数组的开头添加一个或者多个元素，并且返回新数组的长度

var a = [1,2,3,4];

console.log(a.unshift(5,6,7)) //7

console.log(a) //[5, 6, 7, 1, 2, 3, 4]

        reverse

                翻转数组，返回新的数组

var a = [1,2,3,4];

console.log(a.reverse()) //[4, 3, 2, 1]

        splice

                用于添加或删除数组中的元素，返回值为被删除的元素。第一个参数是：索引，从哪里开始删除；第二个是删除几个，第三个开始是添加的元素。

var a = [1,2,3,4];

console.log(a.splice(0,2,5,6)) //[1, 2]

console.log(a) //[5, 6, 3, 4]

        slice

                选取数组中的元素。两个参数(索引值)，第一个参数是从哪个索引开始，截取到哪个索引，不含结束，如果只写一个索引，就是从当前索引直接截取都最后

var a = [1,2,3,4,5,6];

console.log(a.slice(1,4)) //[2, 3, 4]

        indexOf

                从前往后查找，可返回数组中某个指定的元素的索引值，如果没有就返回-1

var a = [1,2,3,4,5,6];

console.log(a.indexOf(7)) //-1

console.log(a.indexOf(3)) //2

        lastIndexOf

                从后往前查找，有就返回索引值，没有就返回-1

var a = [1,2,3,4,3,5,6];

console.log(a.lastIndexOf(7)) //-1

console.log(a.lastIndexOf(3)) //4

        sort

                排序，a-b正序，b-a倒序

var a = [1,14,17,2,3,4,3,5,6,36];

a.sort(function(a,b){

return a-b

})

console.log(a) //[1, 2, 3, 3, 4, 5, 6, 14, 17, 36]



var a = [1,14,17,2,3,4,3,5,6,36];

a.sort(function(a,b){

return b-a

})

console.log(a) //[36, 17, 14, 6, 5, 4, 3, 3, 2, 1]

        toString

                转字符串

var a = [1,2,3,4,5];

console.log(a.toString()) //1,2,3,4,5

        filter

                筛选数组，并返回新的新数组

var a = [1,2,3,4,5,6,7,6,5,4,3,2,6,5,3];

var b = a.filter(function(v,i,s,q){

// console.log(i) //索引值

// console.log(v) //数组中每个元素

// console.log(s) //元素本身

// console.log(q)//undefined

return v>4

})

console.log(b) //[5, 6, 7, 6, 5, 6, 5]

​​​​​​​

数组去重的办法
​​​​​        

        es6 的 set 去重

// 如果不考虑兼容性问题，这种方式代码量最少。但是这种方法还无法去掉{}空对象

var arr = [true,undefined,1,1,'true','true',true,undefined, "undefined",null, NaN, 3,"undefined",null,NaN,'NaN', 0, 0, 'a', 'a',{},{},"{}"];

var b = [...new Set(arr)]

console.log(b)

//[true, undefined, 1, 'true', 'undefined', null, NaN, 3, 'NaN', 0, 'a', {…}, {…}, '{}']





var arr = [1,1,'true','true',true,true,15,15,false,false, undefined,undefined, "undefined","undefined",null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{},"{}"];

function fn(a){

return Array.from(new Set(a))

}

console.log(fn(arr))

        For 循环嵌套 for 循环，然后splice去重（es5 中常使用）

// 注意的是，NAN 和 {}没有去重，null消失了

var arr = [true,undefined,1,1,'true','true',true,undefined, "undefined",null, NaN, 3,"undefined",null,NaN,'NaN', 0, 0, 'a', 'a',{},{},"{}"];

function fn(arr){

for (var i=0; i<arr.length; i++){

for (var j=i+1; j<arr.length; j++){

if(arr[i] == arr[j]){

arr.splice(j,1);

}

}

}

return arr

}

console.log(fn(arr)) //[true,1, undefined, 'true', 'undefined', NaN, 3, NaN, 'NaN', 0, 'a', {…}, {…}, '{}']

// 利用indexOf 去重，注意：这种方法nan和{}也不能去重
// 利用sort排序，然后循环，比较，push
// 利用includes 去重
// hasOwnProperty ：利用hasOwnProperty 判断是否存在对象属性,这种方式可以去重所有类型
var arr = [true,undefined,1,1,'true','true',true,undefined, "undefined",null, NaN, 3,"undefined",null,NaN,'NaN', 0, 0, 'a', 'a',{},{},"{}"];

function fn(arr){

var obj = {};

return arr.filter(function(item,index,arr){

return obj.hasOwnProperty(typeof item+item) ? false:(obj[typeof item+item] = true)

})

}

console.log(fn(arr))

//[true, undefined, 1, 'true', 'undefined', null, NaN, 3, 'NaN', 0, 'a', {…}, '{}']

filter 去重：当前元素，在原数组中的第一个索引值==当前索引值，否则返回当前元素
var arr = [true,undefined,1,1,'true','true',true,undefined, "undefined",null, NaN, 3,"undefined",null,NaN,'NaN', 0, 0, 'a', 'a',{},{},"{}"];

function fn(arr){

return arr.filter(function(item,index,arr){

return arr.indexOf(item,0) === index;

})

}

console.log('ok',fn(arr))

//[true, undefined, 1, 'true', 'undefined', null, 3, 'NaN', 0, 'a', {…}, {…}, '{}'] //对象不能去重，nan直接没有了

利用递归去重
利用map数据结构去重
利用re duce和includes去重
var arr = [true,undefined,1,1,'true','true',true,undefined, "undefined",null, NaN, 3,"undefined",null,NaN,'NaN', 0, 0, 'a', 'a',{},{},"{}"];

function fn(arr){

return arr.reduce((prev,cur)=>

prev.includes(cur) ? prev: [...prev,cur],[]

)

}

console.log('ok',fn(arr))

//[true, undefined, 1, 'true', 'undefined', null, NaN, 3, 'NaN', 0, 'a', {…}, {…}, '{}']//对象不能去重

 如有错误，欢迎指正～谢谢