数组方法总结

改变原数组的方法

• unshift和shift：删除、添加第一项

shift：删除数组第一项
let arr = ['a','b','c']
arr.shift()
console.log(arr) //["b", "c"]

unshift：向数组第一项添加一项
let arr = ['a','b','c']
arr.unshift('e')
console.log(arr) //["e", "a", "b", "c"]

• pop和push：删除、添加最后一项

pop：删除最后一项
let arr = ['a','a','b','c']
arr.pop()
console.log(arr) //["a", "a", "b"]

push：从最后一项添加一项
let arr = ['a','b','c']
arr.push('e')
console.log(arr) //["a", "b", "c", "e"]

• sort：数组排序

let arr = [2,4,1,3,2];
let fn = (a,b) =>{ 
    return a-b; // 升序
    // return b-a; // 降序
}
arr.sort(fn);
console.log(arr) //[1, 2, 2, 3, 4]

• reverse：反转数组

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

• splice：删除、插入、替换

参数：arr.splice(index, num, newitem1, newitem2 ...)

删除操作：
1:有两个参数且参数二大于0时：删除目标项后的目标个数
let arr = [4,1,3,2]
arr.splice(0,2) //参数一：从第几项开始，包括第几项 ；参数二：删除几个
console.log(arr) //[3, 2]
2:只有一个参数时：删除从目标项开始的所有项，包括目标项
let arr = [4,1,3,2]
arr.splice(1)
console.log(arr) //[4]

插入操作：
let arr2 = ['a','b','c']
let sliceStr = arr2.splice(2,0,'A','B') //参数一：从第几位开始；参数二：插入操作时为0；第三个参数开始；插入的元素
console.log(arr2) //["a", "b", "A", "B", "c"]

替换操作：
let arr2 = ['a','b','c','d','e']
let sliceStr = arr2.splice(2,2,'C','D') //参数一：第几位开始；参数二：替换几位； 参数三开始：替换的元素
console.log(arr2) //["a", "b", "C", "D", "e"]

不改变原数组的方法（返回新数组）

• concat：数组拼接

let arr1 = [4,1,3,2]
let arr2 = ['a','b','c']
let arr3 = arr1.concat(arr2)
console.log(arr3) //[4, 1, 3, 2, "a", "b", "c"]

* jion：将数组以什么拆分拼接成字符串

let arr1 = [4,1,3,2]
let arr2 = ['a','b','c']
let joinStr = arr1.join('/')
console.log(joinStr) //4/1/3/2
console.log(typeof joinStr) //string

将字符串以什么拼接成数组
var str = "1,2,3"
var arr=str.split(",");

• slice：从第n位开始截取到第m位，包括第n位，不包括第m位（arr2.slice(n,m)）

let arr2 = ['a','b','c','d','e','f']
let sliceStr = arr2.slice(2,4)
console.log(sliceStr) //["c", "d"]

截取操作：
1. 从数组尾部截取x位，组成一个新数组
var array = [1,2,3,4,5,6];
let newArr = array.slice(-1);

2. 从a位，截取到第b位（包含起始位置，不包含结束位置）
var array = [1,2,3,4,5,6];
var a=arr.slice(1,2)；

3. 不传第二个参数表示从n截取到数组末尾

• map：映射，对数组的每一项进行操作，然后返回一个新数组

let arr1 = [1,2,3]
let mapArr = arr1.map((v,i,arr) => {
    return v + 1
}) //参数一：value；参数二：index；参数三：数组本身
console.log(mapArr) //[2, 3, 4]

• reduce和reduceRight

两个参数：函数和初始值。若只传一个值，默认函数从第一个值执行。

参数及用法（reduceRight用法同）：
arr.reduce((前一个值，当前值，index，数组本身) => {
    return 操作
}，初始值)

reduce和reduceRight区别：遍历顺序不同，reduce从第一项往后遍历，reduceRight从最后一项往前遍历

reduce示例：
let arr1 = [1,2,3]
let isPass = arr1.reduce((pre, now)=> {
    return pre + 1
}, 1)
// 1   ------初始值
// 1+1 ------前一个值1加上1（pre + 1）
// 2+1 ------前一个值1加上1（pre + 1）
// 3+1 ------前一个值1加上1（pre + 1）
console.log(isPass) //4

reduceRight示例：
let arr1 = [1,2,3]
let isPass = arr1.reduceRight((pre, now, i, arr)=> {
    return pre + now
}, 1)
// 1
// 1+3
// 4+2
// 6+1
console.log(isPass) //7

用reduce求和数组所有项
let arr = [1,2,3]
let sum = arr.reduce((pre, now) => {
    return pre + now
},0)
console.log(sum) //6

• filter：过滤符合条件项

let arr1 = [1,2,3]
let isPass = arr1.filter((v, i, arr)=> {
    return v > 1
})
console.log(isPass) //[2, 3]

其他

• some：判断是否存在满足条件项，有就返回true

let arr1 = [1,2,3]
let isPass = arr1.some(v=> {
    return v > 2
})
console.log(isPass) //true

• every：判断数组每一项是否满足条件，全部满足才返回true，有一项不满足则返回false

let arr1 = [1,2,3]
let isPass = arr1.every(v=> {
    return v > 2
})
console.log(isPass) //false

• forEach：遍历数组

arr.forEach((v,i) => {
    console.log(i + ':' + v)
})

• indexOf和lastIndexOf：返回索引，没有满足项返回-1

* 用法：参数一位目标查找项；可以接收第二个参数，表示从第几项开始查找
* indexOf和lastIndexOf区别：查找顺序相反，indexOf从前往后查找；lastIdexOf从后往前查找

indexOf用法
let arr = ['a','b','c']
let find1 = arr.indexOf('b')
console.log(find1)

可以接收第二个参数，表示从第几项开始查找
let arr1 = [1,2,3]
let isPass = arr1.indexOf(2,2) //参数一：查找2；参数二：从第二项开始查找
console.log(isPass) //-1

注意；返回的是index！！ 只是查找的方向不同
var arr1 = [1,2,3,3,2];
let isPass1 = arr1.indexOf(2)
let isPass2 = arr1.lastIndexOf(2)
console.log(isPass1) //1
console.log(isPass2) //4

扩展方法

• flat：扁平化数组（多维数组转一维数组）【注意：flat不支持IE浏览器】

用法：arr.flat(n) //n为数组的维度
let A = ['a',['b','c',['d','e']]]   
console.log(A.flat(3)) //["a", "b", "c", "d", "e"]

不知道几维数组时，直接使用Infinity（使用Infinity作为flat的参数，使得无需知道被扁平化的数组的维度。）
例子：console.log(A.flat(Infinity)) //["a", "b", "c", "d", "e"]

• Math.max()：数组最大值

// 该方法接收任意多个数值参数，不接受数组参数。
用法一；
let arr = [1,2,3,4,5,6,7,8]
let max = Math.max(...arr) //解构
console.log(max) //8

用法二：结合apply
let arr = [1,2,3,4,5,6,7,8]
let max = Math.max.apply(this,arr) //apply改变this指向
console.log(max) //8

用法三：结合reduce
let arr = [1,2,3,4,5,6,7,8]
let max = arr.reduce((pre, now) => {
    return Math.max(now)
},0)
console.log(max) //8

• fill：设置数组每一项为一个值

let arr = [1,2,3,4,5]
arr.fill('a')
console.log(arr) //["a", "a", "a", "a", "a"]

• 对象转化数组

1. 对象的key转化到数组里：Object.keys(obj)
let obj = {
    name: 'wx',
    age: 18
}
let keyArr = Object.keys(obj)
console.log(keyArr)  //["name", "age"]

2. 对象的values转化到数组里：Object.values(obj)
let obj = {
    name: 'wx',
    age: 18
}
let valuesArr = Object.values(obj)
console.log(valuesArr)

3. 对象里的每一项key和value放在数组里：
let obj = {
    name: 'wx',
    age: 18
}
let entriesArr = Object.entries(obj)
console.log(entriesArr) //[['name', 'wx'], ['age', 18]]

将数组平均分成几组

let list = []
for(var i=0;i<arr.length;i+=3){
    list.push(arr.slice(i,i+3)); //将数组以3为一组平均分
}

获取数组最大、最小值

<!--第一个参数是指定this指向-->
最小值： Math.min.apply(Math,arr) 
最大值： Math.max.apply(Math,arr)

把数组以几拆分

for(var i=0;i<headItem.length;i+=3){
    headList.push(headItem.slice(i,i+3)); //将数组以3为一组平均
    this.tabHead = headList.map(head=> {
        let headStr = head.join('')
        return headStr
    })
}

判读两个数组是否含有相同项

降低复杂度的方法：先合并再去重，判断合并之后长度和去重长度是否相等

// 合并数组
let normalArr = [...item, ...arr2]
// 合并数组并去重
let setArr = [...new Set(normalArr)]
return normalArr.length !== setArr.length

找到数组中的最小值

let arr=[2,6,1,5,22,3,66,12,9];
let min=Math.min(...arr);
console.log("最小值为："+min);