JS数组Array

静态方法：通过Array直接调用的方法。

• from(object, mapFunction, thisValue)：通过给定的对象中创建一个数组。

/**
* object:必需，要转换为数组的对象。
* mapFunction:可选，数组中每个元素要调用的函数。
* thisValue:可选，映射函数(mapFunction)中的 this 对象。
*/
var parameter = "object"
var arr = Array.from(parameter) // ['o', 'b', 'j', 'e', 'c', 't']
var arr = Array.from(parameter,x=>x+"1") // ['o1', 'b1', 'j1', 'e1', 'c1', 't1']

• isArray()：判断对象是否为数组。

Array.isArray("obj") // false
Array.isArray(["Banana", "Orange", "Apple", "Mango"]) //true

实例方法：通过创建实例调用的方法。

• concat(array2[,array3,…,arrayX])：连接两个或更多的数组，并返回结果。

/**
* 参数：可以为具体值，也可以是数组.
* 返回值：一个新的数组
*/
var arr1 = ["hello","world"]
var arr2 = ["!!!"]
var newArr1 = arr1.concat(1,2,3) //["hello","world",1,2,3]
var newArr2 = arr1.concat([1,2,3]) //["hello","world",1,2,3]
var newArr3 = arr1.concat(arr2) // ["hello","world","!!!"]

• copyWithin(target.start,end)：从数组的指定位置拷贝元素到数组的另一个指定位置中。

/** 
* 参数：
* 	target：必需。复制到指定目标索引位置。
* 	start：可选。元素复制的起始位置。
* 	end：可选。停止复制的索引位置(不包含) (默认为 array.length)。如果为负值，表示倒数。
* 返回值：修改原数组。
* 注意：数组总长度不变
*/
var arr = ["1","2","3","4","5","6"]
arr.copyWithin(2) // ["1","2","1","2","3","4"]
arr.copyWithin(2,1) // ['1', '2', '2', '3', '4', '5']

• entries()：返回数组的可迭代对象。

# 通常配合 for of 使用
var fruits = ["Banana", "Orange", "Apple", "Mango"];
for(let [k,v] of fruits.entries()) {
	console.log(k,v)
	//0 'Banana'
	//1 'Orange'
	//2 'Apple'
	//'Mango'
}

• every(function(currentValue,index,arr), thisValue)：检测数值元素的每个元素是否都符合条件。

# 返回值是boolean值
var arr = [12,34,54,23]
var res = arr.every((item)=>item >= 12) // true
var res = arr.every((item)=>item == 12) // false

• fill(value, start, end)：使用一个固定值来填充数组。

/**
* 注意：修改原数组
* 参数：
* 	value：填充值
* 	start：可选。开始填充位置。
* 	end：可选。停止填充位置(不包含) (默认为 array.length)
*/
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.fill(0) // [0, 0, 0, 0]
fruits.fill(0,2,3) // ['Banana', 'Orange', 0, 'Mango']

• filter(function(currentValue,index,arr), thisValue)：检测数值元素，并返回符合条件所有元素的数组。

# 注意：返回值是新数组，不会修改原数组。
var arr = [32,34,5,53,14]
var res = arr.filter((item)=>item>10) // [32,34,53,14]
var res = arr.filter((item)=>item>100) // []

• find(function(currentValue, index, arr),thisValue)：返回符合传入条件的第一个数组元素。

# 不会修改原数组。
# 注意：没有符合条件的元素时返回undefined
var arr = [2,4,5,17,34]
var res = arr.find((item)=>item>10) // 17
var res = arr.find((item)=>item>100) // undefined

• findIndex(function(currentValue, index, arr), thisValue)：返回符合传入条件的第一个数组元素索引。

# 不会修改原数组。
var arr = [10,43,55,23,1]
arr.findIndex(item=>item<10) // 4
arr.findIndex(item=>item>100) // -1

• forEach(function(currentValue, index, arr), thisValue)：数组每个元素都执行一次回调函数。

var arr = [3,24,12,55,34]
arr.forEach(item=>{
	console.log(item); //循环输出 3 24 12 55 34
})

• includes(searchElement,fromIndex )：判断一个数组是否包含一个指定的值。

/**
* searchElement:必须。需要查找的元素值。
* fromIndex:可选。从该索引处开始查找 searchElement。如果为负值，则按升序从 array.length + fromIndex 的索引开始搜索。默认为 0。
*/
[1, 2, 3].includes(2);     // true
[1, 2, 3].includes(3, 3);  // false
[1, 2, 3, 3].includes(3, 3);  // true
[1, 2, 3].includes(3, -1); // true
[1, 2, NaN].includes(NaN); // true

• indexOf(item,start)：搜索数组中的元素，并返回它所在的位置。

/**
* item:	必须。查找的元素。
* start:可选的整数参数。规定在数组中开始检索的位置。它的合法取值是 0 到 stringObject.length - 1。如省略该参数，则将从字符串的首字符开始检索。
*/
var arr = [2,13,23,1,54]
arr.indexOf(23) // 2
arr.indexOf(23,3) // -1

• lastIndexOf(item,start)：搜索数组中的元素，并返回它最后出现的位置。

/**
* item:	必须。查找的元素。
* start:可选的整数参数。规定在字符串中开始检索的位置。它的合法取值是 0 到 stringObject.length - 1。如省略该参数，则将从字符串的最后一个字符处开始检索。
*/
var fruits=["Banana","Orange","Apple","Mango","Banana","Orange","Apple"];
fruits.lastIndexOf("Apple"); //6
var fruits=["Banana","Orange","Mango","Banana","Orange","Apple","Apple"];
fruits.lastIndexOf("Apple",4); //-1

• join(arg)：把数组的所有元素放入一个字符串中。

/**
* 参数：
* 	arg:可选，有参数时通过此参数进行连接。
* 返回值：字符串
*/
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.join(); // Banana,Orange,Apple,Mango
fruits.join(123); // Banana123Orange123Apple123Mango

• keys()：返回数组的可迭代对象，包含原始数组的键(key)。

/**
* 返回值：是一个可迭代的迭代器对象，通过for of可获取key值
*/
var fruits=["Banana", "Orange", "Apple", "Mango"];
for(let key of fruits.keys()){
	console.log(key); //循环输出 0 1 2 3
}

• map(function(currentValue, index, arr), thisValue)：通过指定函数处理数组的每个元素，并返回处理后的数组。

# 返回一个新数组，不影响原数组。
var arr = [2,4,5,6]
var newArr = arr.map( item => item * 2) // [4,8,10,12]

• pop()：删除数组的最后一个元素并返回删除的元素。

# 此方法修改影响原数组。
var fruits = ["apple","banana","mongo"]
fruits.pop() // "mongo"
console.log(fruits) // ["apple","banana"]

• push(arg1,…,argN)：向数组的末尾添加一个或更多元素，并返回新的长度。

# 此方法修改影响原数组。
var fruits = ["apple","banana","mongo"]
fruits.push() // 3
fruits.push("orange") // 4

• reduce(function(previousValue, currentValue, currentIndex, array),initialValue)：将数组元素计算为一个值（从左到右）。

• • reduceRight()：将数组元素计算为一个值（从右到左）。

/**
* 参数:
* 	previousValue:上一次调用 callbackFn 时的返回值。在第一次调用时，若指定了初始值 initialValue，其值则为 initialValue，否则为数组索引为 0 的元素 array[0]。
* 	currentValue:数组中正在处理的元素。在第一次调用时，若指定了初始值 initialValue，其值则为数组索引为 0 的元素 array[0]，否则为 array[1]。
* 	currentIndex:数组中正在处理的元素的索引。若指定了初始值 initialValue，则起始索引号为 0，否则从索引 1 起始。
* 	array:用于遍历的数组。
* 	initialValue:作为第一次调用 callback 函数时参数 previousValue 的值。若指定了初始值 initialValue，则 currentValue 则将使用数组第一个元素；否则 previousValue 将使用数组第一个元素，而 currentValue 将使用数组第二个元素。
*/
var arr = [1,2,3,4]
var result = arr.reduce((previousValue, currentValue)=>{
	return (previousValue + currentValue)
}) // 10
var result = arr.reduce((previousValue, currentValue)=>{
	return (previousValue + currentValue)
},5) // 15

• reverse()：反转数组的元素顺序。

# 此方法修改影响原数组。
var arr = [1,2,3,4]
arr.reverse() // [4,3,2,1]

• shift()：删除并返回数组的第一个元素。

# 此方法修改影响原数组。
var arr = [1,2,3,4]
arr.shift() // 1
console.log(arr) // [2,3,4]

• unshift(arg1,…,argN)：向数组的开头添加一个或更多元素，并返回新的长度。

# 此方法修改影响原数组。
var arr = [1,2,3,4]
arr.unshift(5) //5
arr.unshift(1,2) // 7
console.log(arr) // [1,2,5,1,2,3,4]

• slice(begin,end)：选取数组的一部分，并返回一个新数组。

/**
* 参数：
* 	begin:(可选)提取起始处的索引（从 0 开始），从该索引开始提取原数组元素。如果该参数为负数，则表示从原数组中的倒数第几个元素开始提取，若大于数组长度，则返回空数组。
* 	end:(可选)提取终止处的索引，在该索引处结束（不包括）提取原数组元素。如果该参数为负数，则它表示在原数组中的倒数第几个元素结束抽取。如果 end 大于数组的长度，slice 也会一直提取到原数组末尾。
*/
var animals = ['ant', 'bison', 'camel', 'duck', 'elephant']
animals.slice() //["ant", "bison", "camel", "duck", "elephant"]
animals.slice(2) //["camel", "duck", "elephant"]
animals.slice(2, 4) //["camel", "duck"]
animals.slice(-2) //["duck", "elephant"]
animals.slice(2, -1) //["camel", "duck"]

• some(function(currentValue, index, arr), thisValue)：判断数组元素中是否有元素符合指定条件。

var arr = [10,2,5,23,12]
arr.some(item=>item>10) // true
arr.some(item=>item>100) // false

• sort(function compare(firstEl,secondEl){…})：对数组的元素进行排序。

# 此方法会改变原数组。
/**
* 参数：
* 	function compare:用来指定按某种顺序进行排列的函数。如果省略，元素按照转换为的字符串的各个字符的Unicode位点进行排序。
* 	firstEl:第一个用于比较的元素。
* 	secondEl:第二个用于比较的元素。
*/
var arr = [1, 30, 4, 21, 100000]
arr.sort() // [1, 100000, 21, 30, 4]
arr.sort((a,b)=>{return a - b}) // [1, 4, 21, 30, 100000]

• splice(start,deleteCount,item1,…,itemN)：从数组中添加或删除元素。

# 此方法会改变原数组。
/**
* 参数：
* 	start:指定修改的开始位置。如果超出了数组的长度，则从数组末尾开始添加内容；如果是负值，则表示从数组末位开始
* 	deleteCount:表示要移除的数组元素的个数。如果 deleteCount 大于 start 之后的元素的总数，则从 start 后面的元素都将被删除（含第 start 位）
* 	item:要添加进数组的元素
* 返回值：由被删除的元素组成的一个数组。如果只删除了一个元素，则返回只包含一个元素的数组。如果没有删除元素，则返回空数组。
*/
var arr = [1,3,4,5]
arr.splice(3,0,2) // []
console.log(arr) // [1, 3, 4, 2, 5]

• toString()：把数组转换为字符串，并返回结果。

# 此方法不影响原数组。
# 与 join() 方法区别：join可以添加参数，无参数时，与toString一致。
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.toString() //'Banana,Orange,Apple,Mango'