JavaScript中的数组方法

数组方法
记录一下数组方法

unshift() shift()

unshift()  向数组开头添加一个或多个元素，并返回新数组的长度， ---改变原数组
	参数：("a","b",...)参数可以是一个或多个
	返回值：返回数组的长度
shift() 删除并返回数组的第一个元素；如果数组是空，返回undefined
	返回值：数组原来的第一个元素的值
	
var arr=['lily','tom','jenny'];
arr.unshift('a','b');
console.log(arr);  // ["a", "b", "lily", "tom", "jenny"]

push() pop()

push()  向数组末尾添加一个或多个元素，并返回新数组的长度  ----改变原数组
	参数：("a","b",...)参数可以是一个或多个
	返回值：返回数组的长度
pop() 删除并返回数组的最后一个元素；如果数组是空，返回undefined
	返回值：数组原来的最后一个元素的值

sort()

sort()  对数组元素进行排序，----改变原数组
	参数：函数，规定排序顺序，如果没有传入参数，那么按照字母顺序（ASCII字符编码顺序）从小到大进行排序
	返回值：对数组的引用；
arr.sort()
arr.sort((a,b)=>{
	return a-b
})

reverse()

reverse()  颠倒数组中元素顺序----改变原数组
	返回值：对数组的引用；
arr.reserve()

fill()

fill() ---使用一个固定值来填充数组  --- 改变原数组
arr.fill(value,start,end)
	参数:(value,start,end)
		value --- 必须。填充的值
		start --- 可选。开始填充位置。
		end --- 可选。停止填充位置(默认是到最后，这一项不填充)
	返回值：数组
var arr=['lily','tom','jenny'];
let a = arr.fill('a',1,2)
console.log(a) // ["lily", "a", "jenny"]
console.log(arr) // ["lily", "a", "jenny"]

splice()

splice() 向数组中插入/删除元素  ----改变原数组
	参数:(index,howmany,item1,item2,...item3)
		index--必需。数字，规定插入/删除元素的下标，使用复数可从结尾计算位置
		howmany--必须。要删除的元素数量。设为0则不删除
		item1,item2,...item3 ---可选。要添加的新元素
	返回值：被删除的元素组成的数组

slice()

slice() 从数组中截取部分元素
arr.slice(start,end)
	参数:(start,end)
		start --- 必须。开始截取的下标。如果是负数，从数组结尾算起。-2，代表倒数第二个元素
		end --- 可选。规定到哪里结束(不包含结束位置)。不指定该参数，那么截取start之后所有元素。
	返回值：返回从start到end(含头不含尾)的元素组成的新数组。

indexOf() lastIndexOf()

indexOf() 查找元素在数组中的下标
	参数:(item,start);
		item --- 必须。要查找的项。
		start --- 可选。查找起点位置的索引。不指定该参数从0开始向后查找。
	返回值：找到返回对应索引，否则返回-1
lastIndexOf() 查找元素在数组中的下标
	参数:(item,start);
		item --- 必须。要查找的项。
		start --- 可选。查找起点位置的索引。不指定该参数从数组最后开始向前查找。
	返回值：找到返回对应索引，否则返回-1

concat()

concat() 合并数组，不修改原数组，返回新数组
	参数：必须。可以是具体的值，也可以是数组对象。可以是多个
	返回值：合并后的新数组
var arr=['lily','tom','jenny'];
var brr=arr.concat('susan',['cc','cici'])
console.log(brr); // ["lily", "tom", "jenny", "susan", "cc", "cici"]
console.log(arr);  //['lily','tom','jenny']

includes()

includes() 判断一个数组是否包含指定的值。
	参数：(item,startIndex)
		item --- 必须。要查找的元素值
		startIndex --- 可选。查找起点位置的索引。可以是负数。
	返回值：布尔值。找到true，否则false

join()

join() 把数组中所有元素转化为一个字符串
	参数：(seperator)
		seperator--- 可选。指定分隔符。不指定默认使用逗号','分隔
	返回值：字符串
var fruits = ["Banana", "Orange", "Apple", "Mango"];
var energy = fruits.join(" and ");  // Banana and Orange and Apple and Mango

keys() values() entries()

keys()  values() entries() 三者都是返回一个数组迭代对象(遍历器对象)
	keys() --- 键名
	values() ---键值
	entries() --- 键值对
var arr=['lily','tom','jenny'];
console.log(arr.keys())  //Array Iterator {}
console.log(arr.values()) //Array Iterator {}
console.log(arr.entries())  //Array Iterator {}
for(let i of arr.keys()){
	console.log(i) // 0 1 2 Number类型
}
for(let i of arr.values()){
	console.log(i) // 'lily' 'tom' 'jenny'
}
for(let i of arr.entries()){
	console.log(i) // [0, "lily"] [1, "tom"]  [2, "jenny"]
}

flat()

flat() 数组降维  ---- 不改变原数组
	参数:(depth) 可选。 指定最终的数组的结构深度。默认是1
	返回值：一个新数组，降维后的新数组   

copyWithin()

copyWithin()  从数组指定位置拷贝元素到数组的另一个指定位置中
	参数：(target,start,end);
		target:必须。复制到指定目标索引位置
		start: 可选。元素复制的起始位置。
		end: 可选。停止复制的索引位置。如果为负数，表示倒数.
var arr=['lily','tom','jenny','a','b','c','d'];
var a = arr.copyWithin(0,3) // ["a", "b", "c", "d", "b", "c", "d"]

高阶函数

find()
findIndex()
forEach()
map()
filter()
every()
some()
reduce()
reduceRight()

找到即停止，不在继续执行

find() 查找数组中符合条件的第一项并返回，找不到返回undefined
arr.find((item,index,arr)=>{
	return 条件
},thisValue)
	参数：(function(item,index,arr)=>{},)
		function(item,index,arr)
			item -- 当前元素
            index--- 当前索引
            arr --- 当前元素所属的数组对象
        thisValue --- 可选。传递给函数的值一般用this值。为空则传递undefined
    返回值：数组中符合条件的第一项，找不到返回undefined
    
findIndex() 查找数组中符合条件的返回下标，找不到返回-1
arr.findIndex((item,index,arr)=>{
	return 条件
},thisValue)
	参数：同上
    返回值：符合条件的下标，找不到返回-1
    
forEach()  遍历数组中的每一项
arr.forEach((item,index,arr)=>{
	return 条件
},thisValue)
	参数：同上
    返回值：无

map() 对数组中每一项处理后返回新数组
arr.map((item,index,arr)=>{
	return 操作
},thisValue)
	参数：同上
    返回值：新数组，数组中的元素为原始数组元素调用函数处理后的值。

filter() 筛选出来符合条件的项
arr.filter((item,index,arr)=>{
	return 条件
},thisValue)
	参数：同上
    返回值：返回包含所有符合条件的元素的新数组，如果没有符合条件的返回空数组

every() 检查是否所有元素都符合条件
arr.every((item,index,arr)=>{
	return 条件
},thisValue)
	参数：同上
    返回值：布尔值，如果所有元素都满足条件返回true，否则false

some() 检查是否存在元素符合条件
arr.some((item,index,arr)=>{
	return 条件
},thisValue)
	参数：同上
    返回值：布尔值，如果任一元素满足条件返回true，全部不满足false

reduce() 接收一个函数作为累加器，数组中的每一项(从左到右)开始计算，最后计算为一个值
arr.reduce((prev,next,index,arr)=>{
	return 条件
},initValue)
参数：(function(prev,next,index,arr)=>{},)
		function(prev,next,index,arr)
			prev -- 计算后的返回值
            next --- 当前元素
            index --- 当前下标
            arr --- 当前元素所属的数组对象
        thisValue --- 可选。传递给函数的初始值。不指定的话初始值就是第一项
    返回值：返回计算结果
reduceRight() 接收一个函数作为累加器，数组中的每一项(从右到左)开始计算，最后计算为一个值
arr.reduceRight((prev,next,index,arr)=>{
	return 条件
},initValue)
参数：(function(prev,next,index,arr)=>{},)
		function(prev,next,index,arr)
			prev -- 计算后的返回值
            next --- 当前元素
            index --- 当前下标
            arr --- 当前元素所属的数组对象
        thisValue --- 可选。传递给函数的初始值。
    返回值：返回计算结果

Array方法

Array.from() 
Array.from(object,mapFunction,thisValue)
	参数：(object,mapFunction,thisValue)
		object --- 必选。要转化为数组的对象
		mapFunction --- 可选。数组中每一项都调用的函数
		thisValue --- 可选。映射函数mapFunction中的this对象
		
var arr=['lily','tom','jenny'];
let brr = Array.from(arr,(item,index)=>{
	return "hi!"+item
})
console.log(brr) // ["hi!lily", "hi!tom", "hi!jenny"]

Array.of() 将一组数值转化成数组
let brr=Array.of(1,2,3)
console.log(brr) // [1, 2, 3]
let arr1 = Array.of('你好','hello');
console.log(arr1);//["你好", "hello"]

Array.isArray() 判断是否是数组
	参数：要判断的对象
	返回值：布尔值，是数组返回true，否则false