数组的方法(包括es6)

①arr.push()

从后面添加元素，返回值为添完后的数组长度。

let arr = [1,2,3,4,5];
console.log(arr.push(5)); //6
console.log(arr); //[1,2,3,4,5,5]

②arr.pop()

从后面删除元素，只能是一个，返回值为删除的元素。

let arr = [1,2,3,4,5];
console.log(arr.pop()); //5
console.log(arr); //[1,2,3,4]

③arr.shift()

从前面删除元素，只能是一个，返回值为删除的元素。

let arr = [1,2,3,4,5];
console.log(arr.shift()); //1
console.log(arr); //[2,3,4,5]

④arr.unshift()

从前面添加元素，返回值为添完后数组的长度。

let arr = [1,2,3,4,5];
console.log(arr.unshift(5)); //6
console.log(arr); //[5,1,2,3,4,5]

⑤arr.splice()用于数组或伪数组，根据参数个数和形式的不同，可以在数组中删除指定元素或者插入元素、替换元素

   一个参数，当 splice 方法的参数只有 1 个的时候（i），表示删除数组中索引为 i 及 i 之后的所有元素。返回删除的元素，数组原地修改。其     中，参数 i 是整数。

• i 为非负整数：删除数组中索引为 i 及 i 之后位置上所有的元素
• i 为负整数：索引从后往前计算，最后一位索引是 -1，倒数第二位是 -2，依次类推。删除 i 及 i 之后的所有元素。

删除数组中最后三个元素
var a = [1, 2, 3, 4, 5]
a.splice(-3)
console.log(a) // [1, 2]

清空数组
var a = [1, 2, 3, 4, 5] 
a.splice(0) // 或 a.splice(-5) 
console.log(a) // []

   两个参数，arr.splice(i,n)

   删除从i（索引值）开始之后的元素，n是删除个数，返回值是删除的元素。

let arr = [1,2,3,4,5];
console.log(arr.splice(2,2)); //[3,4]
console.log(arr); //[1,2,5]
只留下数组值第一个和最后一个元素
var a = [1, 2, 3, 4, 5] 
a.splice(1, a.length - 2) 
console.log(a) // [1, 5]

splice实现插入，可以传入三个参数：起始位置、 0（要删除的项数）和要插入的项，如splice(2,0,4)会从当前数组的位置 2 开始插入4,splice(2,0,4,6)会从当前数组的位置 2 开始插入4和6。

splice()方法始终都会返回一个数组，该数组中包含从原始数组中删除的项，如果没有删除任何项，则返回一个空数组。

替换索引位置为2的元素的值为'aaa'
var a = [1, 2, 3, 4, 5]
a.splice(2, 1, 'aaa')
console.log(a) // [1, 2, 'aaa', 4, 5]

 

⑥arr.concat()

数组合并，连接两个新数组，返回值为连接后的新数组。

let arr = [1,2,3,4,5];
console.log(arr.concat([1,2])); //[1,2,3,4,5,1,2]
console.log(arr); //[1,2,3,4,5]

⑦arr.toString()

将数组转换成一个字符串。

let arr = [1,2,3,4,5];
console.log(arr.toString()); //"1,2,3,4,5"

join()方法也可以将数组转换为字符串，不过他可以指定分隔符，传一个参数作为分隔符，如果参数省略，默认使用逗号作为分隔符，这时与toString()方法相同。

let arr = [1,2,3,4,5];
console.log(arr.join("==")); //"1==2==3==4==5"

str.split() ：将字符串转换成数组，与join()方法操作正好相反，可以指定两个参数，第1个参数为分隔符，指定从哪进行分隔的标记，第2个参数指定要返回数组的长度。

let str = "1==2==3==4==5";
console.log(str.split("=="));  // ['1', '2', '3', '4', '5']
let str = "1==2==3==4==5";
console.log(str.split("==",3));  // ['1', '2', '3']

⑧arr.sort()

将数组进行排序,默认情况下根据字符编码进行排序,不是按照数字大小进行排序。sort排序允许接受一个参数（函数），这个函数接受2个形参a,b,并且通过冒泡的方式比较。

let arr = [2,10,6,1,4,22,3]
console.log(arr.sort())   // [1, 10, 2, 22, 3, 4, 6]
let arr1 = arr.sort((a, b) =>a - b)  
console.log(arr1)   // [1, 2, 3, 4, 6, 10, 22]
let arr2 = arr.sort((a, b) =>b-a)  
console.log(arr2)  // [22, 10, 6, 4, 3, 2, 1]

⑨arr.reverse()

数组反转，返回值是反转后的数组。

let arr = [1,2,3,4,5];
console.log(arr.reverse()); //[5,4,3,2,1]
console.log(arr); //[5,4,3,2,1]

⑩arr.slice():从已有的数组中返回选定的元素(数组单元的截取)

   使用的时候很容易混淆 splice 和 slice 方法，记住 splice 方法只能用于数组，而 slice 方法可以用于数组和字符串，表示 “切片”。

   两个参数 arr.slice(start,end)  

   start: 从何处开始选取(截取数组单元起始位置的索引下标)  end: 从何处结束选取(截取数组单元结束位置的索引下标)

   切去索引值start到索引值end的数组，不包含end索引的值，返回值是切出来的数组。不改变原数组。

let arr = [1,2,3,4,5];
console.log(arr.slice(1,3)); //[2,3]
console.log(arr); //[1,2,3,4,5]
取出字符串剔除了首个和末尾的子串
var str = 'abcdef' 
var sub = str.slice(1, -1)
console.log(sub) // 'bcde'

   一个参数 arr.slice(参数1)   当只有一个参数，则会截取至数组的最后一个单元

let arr = ['aa','bb','cc','dd','ee','ff'];
let data = arr.slice(2);
console.log(data); //['cc','dd','ee','ff'];

console.log(arr); //['aa','bb','cc','dd','ee','ff'];

⑪arr.forEach(callback)

遍历数组,无return 即使有return，也不会返回任何值，并且会影响原来的数组。callback的参数： value：当前索引的值， index：索引， array：原数组

var arr = [1,2,3,4]; 
var res = arr.forEach((item,index,arr)=>{     
 arr[index] = item * 2; 
 return arr 
})
console.log(arr); // [2,4,6,8]
console.log(res); // undefined 

⑫arr.map(callback)

遍历数组,有return，返回一个新数组。callback的参数： value：当前索引的值， index：索引， array：原数组

var arr1 = [1,2,3,4]; 
var res1 = arr1.map((item,index,arr)=>{ 
 item = item * 3; 
 return item; 
})
console.log(arr1); // [1,2,3,4]
console.log(res1); // [3,6,9,12]

ps: arr.forEach()和arr.map()的区别

* arr.forEach()是和for循环一样，是代替for。arr.map()是修改数组其中的数据，并返回新的数据。

* arr.forEach() 没有return arr.map() 有return。

⑬arr.filter(callback)

过滤数组,返回一个满足要求的数组。callback的参数： value：当前索引的值， index：索引

let arr = [1,2,3,4,5];
let arr1 = arr.filter((item,index) => (item > 3))
console.log(arr1); //[4,5]
console.log(arr); //[1,2,3,4,5]

⑭arr.every(callback)

依据判断条件，判断数组的元素是否全满足，若全满足返回true。callback的参数： value：当前索引的值， index：索引

let arr = [1,2,3,4,5];
let arr1 = arr.every((item,index) => (item > 3))
console.log(arr1); //false
let arr2 = arr.every((item,index) => (item < 6))
console.log(arr2); //true

⑮arr.some(callback)

依据判断条件，判断数组的元素是否有一个满足，若有一个满足返回true。callback的参数： value：当前索引的值， index：索引

let arr = [1,2,3,4,5];
let arr1 = arr.some((item,index) => (item > 3))
console.log(arr1); //true
let arr2 = arr.some((item,index) => (item > 6))
console.log(arr2); //false

⑯arr.reduce(callback,initialValue)

迭代数组的所有项，累加器，数组中的每个值（从左到右）合并，最终计算为一个值。

参数：

• callback:
• previousValue 必选 --上一次调用回调返回的值，或者是提供的初始值（initialValue）
• currentValue 必选 --数组中当前被处理的数组项
• index 可选 --当前数组项在数组中的索引值
• array 可选 --原数组
• initialValue: 可选 --初始值

实行方法：回调函数第一次执行时，preValue 和 curValue 可以是一个值，如果 initialValue 在调用 reduce() 时被提供，那么第一个 preValue 等于 initialValue ，并且curValue 等于数组中的第一个值；如果initialValue 未被提供，那么preValue 等于数组中的第一个值。

let arr = [0,1,2,3,4];
let arr1 = arr.reduce((preValue,curValue) => preValue + curValue);
console.log(arr1); //10
let arr2 = arr.reduce((preValue,curValue) => preValue + curValue,5);
console.log(arr2); //15

⑰arr.reduce()拓展

（1）计算数组中每个元素出现的次数。

let names = ['peter', 'tom', 'mary', 'bob', 'tom','peter'];
let nameNum = names.reduce((pre,cur)=>{
    if(cur in pre){
        pre[cur]++    
    }else {
        pre[cur] = 1    
    }
    return pre
},{})
console.log(nameNum);//{ peter: 2, tom: 2, mary: 1, bob: 1 }

（2）数组去重。

let arr = [1,2,3,4,5,1,2,4];
let newArr = arr.reduce((pre,cur)=>{
    if(!pre.includes(cur)){
        return pre.concat(cur);    
    }else {
        return pre;    
    }
},{})
console.log(newArr);[1,2,3,4,5]

（3）将多维数组转化为一维。

let arr = [[0, 1], [2, 3], [4,[5,6,7]]]
const newArr = function(arr){
    return arr.reduce((pre,cur)=>pre.concat(Array.isArray(cur)?newArr(cur):cur),[])
}
console.log(newArr(arr)); //[0, 1, 2, 3, 4, 5, 6, 7]

⑱arr.indexOf()

查找某个元素的索引值，若有重复的，则返回第一个查到的索引值若不存在，则返回 -1。

let arr = [1,2,3,4,5,2]
let arr1 = arr.indexOf(2)
console.log(arr1)  // 1
let arr2 = arr.indexOf(9)
console.log(arr2)  // -1

⑲arr.lastIndexOf()

和indexOf()功能一样，只不过是从后往前找。

let arr = [1,2,3,4,5,2]
let arr1 = arr.lastIndexOf(2)
console.log(arr1)  // 5
let arr2 = arr.lastIndexOf(9)

console.log(arr2)  // -1

⑳Array.from()

从将伪数组变为数组，就是只要有length的就可以转成数组。

let str = '12345'
console.log(Array.from(str))    // ["1", "2", "3", "4", "5"]
let obj = {0:'a',1:'b',length:2}
console.log(Array.from(obj))   // ["a", "b"]

21.arr.find(callback)

找到第一个符合条件的数组成员。

let arr = [1,2,3,4,5,2,4]
let arr1 = arr.find((value, index, array) =>value > 2)
console.log(arr1)   // 3