JS数组方法

小弟不才，欢迎质疑

Array.of：常用于转换为数组的方法，主要是为了弥补Array的不足，因为参数个数的不同会导致Array()的行为有一些差异。通常用来解决new Array(）构造器时里面传入的参数不同而造成的风险，详情如下

const aa  = Array()
console.log(aa)//[]
const bb  = Array(3,2,1)
console.log(bb)//[3,2,1]
//到这里一切都正常
const cc  = Array(3)
console.log(cc)//打印出来一个奇奇怪怪的东西
//但我们用Array.of就是OK的啦，别问我我为什么，我不知道
const cc  = Array.of(3)
console.log(cc)//[3]

Array.from()：将类数组转换为真正意义上的数组

//举例
funtion fn(){
	console.log(arguments)//这里打印出来的就是一个类数组
	console.log(Array.from(arguments))//这样打印出来的就是一个真正的数组
}
fn(1,2,3,4)

sort() 排序
这个方法的参数是一个函数，这个函数有两个参数:a,b。实现它的原理是原地算法

const arr = [1,2,6,3,5,4]
let res = sort(function(a,b){
	return a-b
})

也可以根据数组对象的某个属性进行排序

var items = [
  { name: 'Edward', value: 21 },
  { name: 'Sharpe', value: 37 },
  { name: 'And', value: 45 },
  { name: 'The', value: -12 },
  { name: 'Magnetic'，value: 45},
  //如果某个对象的属性没有的话，如果直接用下面那样排序的话会出现混乱的现象。这时候应该用for in 先遍历一下这个对象，然后再做排序
  //比如酱紫 { name: 'Magnetic'}
  { name: 'Zeros', value: 37 }
];
//根据value值排序
let res = itme.sort((a,b)=>{
	return a.value - b.value
})

sort排序对象在es10（2019年）之前有不稳定性，但在es10要求了sort的稳定排序
flat():数组拉平,扁平化数组，指定深度的递归遍历。

var arr = [1, 2, [3, 4]];
console.log(arr.flat())//[1,2,3,4]
const arr1 = [0, 1, 2, [[[3, 4]]]];
//里面的参数就是指定递归多少层
console.log(arr.flat(3))//[1,2,3,4]

也可用于去除数组里空项

var arr= [1, 2, , 4, 5];
let res = arr.flat() //[1,2,4,5]

unshift();在数组第一个元素之前添加，改变原数组，返回数组长度

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

shift()：删除数组第一个元素

const array1 = [1, 2, 3]
console.log(arr.unshift())//[2,3]

push()：在数组最后一项添加，返回数组的长度

const arr = [1,2,3,4,4]
let res = arr.push(2)
conlose.log(res) //[1,2,3,4,4,2]

pop():删除数组最后一项，返回该元素的值

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

reverse():翻转数组，返回颠倒后的数组。反转数组也可以用双指针算法实现，但我不会

const a = [1, 2, 3];
console.log(a.reverse); // [3, 2, 1]

join():把数组转换为字符串，用拼接符拼接

var a = ['Wind', 'Rain', 'Fire'];
var myVar1 = a.join();      // myVar1的值变为"Wind,Rain,Fire"
var myVar2 = a.join(', ');  // myVar2的值变为"Wind, Rain, Fire"
var myVar3 = a.join(' + '); // myVar3的值变为"Wind + Rain + Fire"
var myVar4 = a.join('');    // myVar4的值变为"WindRainFire"

slice():提取指定区域的元素，返回一个新数组。可以用于对原数组的浅拷贝。两个参数，（开始，结束），不包含结束位置，结束参数可选

const a = [1,2,3,5,6];
let b = a.slice(0,1) // 1,2
//也可将类数组对象转换为数组
function list() {
  return Array.prototype.slice.call(arguments);
}

var list1 = list(1, 2, 3); // [1, 2, 3]

splice() 删除指定区域内的元素，指定区域内插入，指定区域替换。这个方法会改变原数组，包含指定起始位置

//删除
let arr =  [1, 2, 3, 4]
arr.splice(0,2)//(指定起始位置,删除几项)
console.log(arr)

插入

let arr = [1, 2, 3, 4]
arr.splice(1,0,6)//(指定起始位置,删除的项,插入的项)

替换

let arr = [1, 2, 3, 4]
arr.splice(1,1,6)//(指定起始位置,删除的项,插入的项)

fill() 指定位置填充固定值，不包含结束位置，三个参数（填充值，起始位置（可选），结束位置（可选）），返回修改后的数组。起始位置默认为0，结束位置默认为arr.length。

const arr = [1, 2, 3, 4];
console.log(arr.fill(0, 2, 4))//[1,2,0,0]
console.log(arr.fill(0))//[0,0,0,0]

concat() 连接两个数组，返回一个新数组。可以用于做数组的浅拷贝

let arr = [1, 2, 3, 4];
const arr1 = [1, 2, 3, 4];
console.log(arr.concat(arr1))//[1, 2, 3, 4,1, 2, 3, 4]
//做一个浅拷贝
let res = arr.concat()

entries() 返回一个可迭代对象，该对象包含数组的键（索引值）值（数组元素）对，然后在原型链上会增加一个next()的方法，我们可以用这个next()，方法进行一些操作。

const arr = [1, 2, 3, 4, 5]
let res = arr.entries()
console.log(res)//这时就能看到原型链上多了一个next方法
console.log(res.next())//这时就能看到这里面的value就有了原数组的键值对
console.log(res.next().value)//[0(键),1(值)]
console.log(res.next().value)//[1(键),2(值)]
console.log(res.next().value)//[2(键),3(值)]

every() 给数组添加一个判断条件，如果数组元素都满足就返回ture，有一个不满足则返回false，剩余元素则不会 执行检测。

const arr = [1, 2, 3, 4, 5]
let res = arr.every((a)=>{
	return a < 6
})
console.log(res)//true

some():给数组添加一个判断条件，有一个元素满足条件就返回true，剩余元素就不会再进行检测，如果都不满足则返回false。空数组也返回false。

const arr = [1, 2, 3, 4, 5]
let res = arr.some((a)=>{
	return a === 2
})
console.log(res)//true

filter(很重要) 给数组添加一个有过滤条件的函数，返回一个符合条件的元素的新数组。

let arr = [1, 2, 3, 4]
let res = arr.filter((itme) =>{
	return itme > 2
})

map(很重要) 返回一个执行了回调函数中方法的新数组

let arr = [1, 2, 3, 4]
let res = arr.map((a)=>{
	return a*5
})

forEach():对数组进行循环遍历，给每一项给定一个函数。没有返回值。

const arr = [1, 2, 3, 4];
//因为没有返回值，也不会改变原数组，我们要在这里开辟一个新变量
let num = 0
arr.forEach(function(当前处理元素,索引值,数组){
	num.push(当前处理元素)
})

indexOf():查找数组中指定元素并返回第一次出现的位置，参数1是要查找的元素，参数2是起始位置。如果没有这个元素，就返回-1.

const arr = [1,2,2,2,3,4];
let res = arr.indexOf(2,0)// 1

lastIndexOf():查找数组中指定元素 并返回最后一次出现的位置，参数1是要查找的元素，参数2是起始位置。如果没有这个元素，就返回-1.

const arr = [1,2,2,2,3,4];
let res = arr.lastIndexOf(2,0)// 3

reduce():通常用于累加。它也可以实现所有数组方法的功能。

//reduce接收四个参数
arr.reduce(acc(累加器),cur(当前值),idx(当前索引),array(调用这个reduce的数组))
//如果需要初始值的话，给reduce给一个初始值
arr.reduce(function(acc,cur){
	return acc + cur
},初始值)

Array.isArray() 判断是否为一个数组。
includes():判断数组是否存在某一个指定值，有就返回ture,没有返回false。有两个参数，参数1是要查找的值，参数2（可选）是查找的起始位置，如果起始位置大于length,就会返回false。

let arr = [1, 2, 3, 4]
let res = arr.includes(2)//true

find():返回数组中满足测试条件的第一个值，没有就返回undefined。

let arr = [1, 2, 3, 4]
let res = arr.find( a =>{
	return a>2
})

findIndex():返回数组中满足测试条件的第一个索引，没有就返回-1。这里好像和indexOf差不多 - _ -，但是indexOf找的是指定元素第一次出现的位置

let arr = [1, 2, 3, 4]
let res = arr.findIndex( a =>{
	return a>2
})