# 改变原来数组的方法
# pop
pop() 方法用于删除并返回数组的最后一个元素。
语法：
arrayObject.pop()
参数：无
返回值： arrayObject 的最后一个元素。
说明： pop() 方法将删除 arrayObject 的最后一个元素，把数组长度减 1，并且返回它删除的元素的值。如果数组已经为空，则 pop() 不改变数组，并返回 undefined 值
示例：
const arr = [1, 2, 3];
console.log(arr.pop()) // 3
# push
push() 方法可向数组的末尾添加一个或多个元素，并返回新的长度。
语法：
arrayObject.push(newelement1,newelement2,....,newelementX)
参数：
| 参数 | 描述 |
|---|---|
| newelement1 | 必需。要添加到数组的第一个元素。 |
| newelement2 | 可选。要添加到数组的第二个元素。 |
| newelementX | 可选。可添加多个元素。 |
返回值：把指定的值添加到数组后的新长度。
说明：push() 方法可把它的参数顺序添加到 arrayObject 的尾部。它直接修改 arrayObject，而不是创建一个新的数组。push() 方法和 pop() 方法使用数组提供的先进后出栈的功能。
示例：
const arr = []
console.log(arr.push('a')) // 1
# shift
shift() 方法用于把数组的第一个元素从其中删除，并返回第一个元素的值。
语法：
arrayObject.shift()
参数：无
返回值：数组原来的第一个元素的值。
说明：如果数组是空的，那么 shift() 方法将不进行任何操作，返回 undefined 值。请注意，该方法不创建新数组，而是直接修改原有的 arrayObject。
示例：
const arr = ['a', 'b']
console.log(arr.shift()) // 'a'
# unshift
unshift() 方法可向数组的开头添加一个或更多元素，并返回新的长度。
语法：
arrayObject.unshift(newelement1,newelement2,....,newelementX)
参数：
| 参数 | 描述 |
|---|---|
| newelement1 | 必需。向数组添加的第一个元素。 |
| newelement2 | 可选。向数组添加的第二个元素。 |
| newelementX | 可选。可添加若干个元素。 |
返回值：arrayObject 的新长度。
说明：unshift() 方法将把它的参数插入 arrayObject 的头部，并将已经存在的元素顺次地移到较高的下标处，以便留出空间。该方法的第一个参数将成为数组的新元素 0，如果还有第二个参数，它将成为新的元素 1，以此类推。
请注意，unshift() 方法不创建新的创建，而是直接修改原有的数组。
示例：
const arr = [1, 2, 3]
console.log(arr.unshift(0)) // 4
# splice
splice() 方法向/从数组中添加/删除项目，然后返回被删除的项目。
语法：
arrayObject.splice(index,howmany,item1,.....,itemX)
参数：
| 参数 | 描述 |
|---|---|
| index | 必需。整数，规定添加/删除项目的位置，使用负数可从数组结尾处规定位置。 |
| howmany | 必需。要删除的项目数量。如果设置为 0，则不会删除项目。 |
| item1, ..., itemX | 可选。向数组添加的新项目。 |
返回值：
| 类型 | 描述 |
|---|---|
| Array | 包含被删除项目的新数组，如果有的话。 |
说明：
splice() 方法可删除从 index 处开始的零个或多个元素，并且用参数列表中声明的一个或多个值来替换那些被删除的元素。
如果从 arrayObject 中删除了元素，则返回的是含有被删除的元素的数组。
示例：
const arr = [1, 2, 3]
// 从索引 0 开始，删除两项，并返回删除项的数组
console.log(arr.splice(0, 2)) // [1, 2]
// 从索引 0 开始，插入两项，因为不是删除，所以返回空数组
console.log(arr.splice(0, 0, 1, 2)) // []
// 最终结果
console.log(arr) // [1, 2, 3]
# sort
sort() 方法用于对数组的元素进行排序。
语法：
arrayObject.sort(sortby)
参数：
| 参数 | 描述 |
|---|---|
| sortby | 可选。规定排序顺序。必须是函数。 |
返回值：对数组的引用。请注意，数组在原数组上进行排序，不生成副本。
说明：
如果调用该方法时没有使用参数，将按字母顺序对数组中的元素进行排序，说得更精确点，是按照字符编码的顺序进行排序。要实现这一点，首先应把数组的元素都转换成字符串（如有必要），以便进行比较。
如果想按照其他标准进行排序，就需要提供比较函数，该函数要比较两个值，然后返回一个用于说明这两个值的相对顺序的数字。比较函数应该具有两个参数 a 和 b，其返回值如下：
- 若 a 小于 b，在排序后的数组中 a 应该出现在 b 之前，则返回一个小于 0 的值。
- 若 a 等于 b，则返回 0。
- 若 a 大于 b，则返回一个大于 0 的值。
示例：
const arr = [1, 2, 3, 4]
console.log(arr.sort((a, b) => (a - b))) // [ 1, 2, 3, 4 ]
console.log(arr.sort((a, b) => (b - a))) // [ 4, 3, 2, 1 ]
# reverse
reverse() 方法用于颠倒数组中元素的顺序。
语法：
arrayObject.reverse()
返回值：返回颠倒后的数组
说明：该方法会改变原来的数组，而不会创建新的数组。 示例：
const arr = [1, 2, 3];
console.log(arr.reverse()) // [3, 2, 1]
# copyWithin()
copyWithin() 方法用于从数组的指定位置拷贝元素到数组的另一个指定位置中。
语法：
array.copyWithin(target, start, end)
参数：
| 参数 | 描述 |
|---|---|
| target | 必需。复制到指定目标索引位置。 |
| start | 可选。元素复制的起始位置。 |
| end | 可选。停止复制的索引位置 |
示例：
const arr = [1, 2, 3, 4, 5, 6]
console.log(arr.copyWithin(2, 0, 2)) // [1, 2, 1, 2, 5, 6]
# fill
fill() 方法用于将一个固定值替换数组的元素。
语法：
array.fill(value, start, end)
参数：
| 参数 | 描述 |
|---|---|
| value | 必需。填充的值。 |
| start | 可选。开始填充位置。 |
| end | 可选。停止填充位置(默认为 array.length)，不包含end |
返回值：数组 示例：
const arr = [1, 2, 3, 4]
console.log(arr.fill('a', 0, 2)) // ["a", "a", 3, 4]
# 不改变原来数组的方法
# slice
slice() 方法可从已有的数组中返回选定的元素。
语法：
arrayObject.slice(start,end)
参数：
| 参数 | 描述 |
|---|---|
| start | 必需。规定从何处开始选取。如果是负数，那么它规定从数组尾部开始算起的位置。也就是说，-1 指最后一个元素，-2 指倒数第二个元素，以此类推。 |
| end | 可选。规定从何处结束选取。该参数是数组片断结束处的数组下标。如果没有指定该参数，那么切分的数组包含从 start 到数组结束的所有元素。如果这个参数是负数，那么它规定的是从数组尾部开始算起的元素。 |
返回值：返回一个新的数组，包含从 start 到 end （不包括该元素）的 arrayObject 中的元素。
说明：请注意，该方法并不会修改数组，而是返回一个子数组。如果想删除数组中的一段元素，应该使用方法 Array.splice()。
示例：
const arr = [1, 2, 3]
console.log(arr.slice(1)) // [2, 3]
# join
join() 方法用于把数组中的所有元素放入一个字符串。元素是通过指定的分隔符进行分隔的。
语法：
arrayObject.join(separator)
参数：
| 参数 | 描述 |
|---|---|
| separator | 可选。指定要使用的分隔符。如果省略该参数，则使用逗号作为分隔符。 |
返回值：返回一个字符串。该字符串是通过把 arrayObject 的每个元素转换为字符串，然后把这些字符串连接起来，在两个元素之间插入 separator 字符串而生成的。
示例：
const arr = [1, 2, 3]
console.log(arr.join('')) // '123'
console.log(arr.join('-')) // '1-2-3'
# concat
concat() 方法用于连接两个或多个数组。该方法不会改变现有的数组，而仅仅会返回被连接数组的一个副本。
语法：
arrayObject.concat(arrayX,arrayX,......,arrayX)
返回值：返回一个新的数组。该数组是通过把所有 arrayX 参数添加到 arrayObject 中生成的。如果要进行 concat() 操作的参数是数组，那么添加的是数组中的元素，而不是数组。
示例：
const arr = [1, 2, 3]
console.log(arr.concat(4, 5, 6)) // [1, 2, 3, 4, 5, 6]
console.log(arr.concat([4, 5, 6])) // [1, 2, 3, 4, 5, 6]
# indexOf
indexOf() 方法可返回数组中某个指定的元素位置。
该方法将从头到尾地检索数组，看它是否含有对应的元素。开始检索的位置在数组 start 处或数组的开头（没有指定 start 参数时）。如果找到一个 item，则返回 item 的第一次出现的位置。开始位置的索引为 0。
如果在数组中没找到指定元素则返回 -1。
语法：
array.indexOf(item,start)
参数：
| 参数 | 描述 |
|---|---|
| item | 必须。查找的元素。 |
| start | 可选的整数参数。规定在数组中开始检索的位置。它的合法取值是 0 到 stringObject.length - 1。如省略该参数，则将从字符串的首字符开始检索。 |
返回值：元素在数组中的位置，如果没有搜索到则返回 -1。
const arr = [1, 2, 3]
console.log(arr.indexOf(1)) // 0
console.log(arr.indexOf(10)) // -1
# includes
includes() 方法用来判断一个数组是否包含一个指定的值，如果是返回 true，否则false。
语法：
arr.includes(searchElement)
arr.includes(searchElement, fromIndex)
参数：
| 参数 | 描述 |
|---|---|
| searchElement | 必须。需要查找的元素值。 |
| fromIndex | 可选。从该索引处开始查找 searchElement。如果为负值，则按升序从 array.length + fromIndex 的索引开始搜索。默认为 0。 |
返回值：布尔值。如果找到指定值返回 true，否则返回 false。
示例：
const arr = [1, 2, 3]
console.log(arr.includes(2)) // true
# 数组遍历
# for
# forEach
forEach() 方法用于调用数组的每个元素，并将元素传递给回调函数。
注意: forEach() 对于空数组是不会执行回调函数的。
语法：
array.forEach(function(currentValue, index, arr), thisValue)
参数：
| 参数 | 描述 |
|---|---|
| function(currentValue, index, arr) | 必需。 数组中每个元素需要调用的函数。 |
| thisValue | 可选。传递给函数的值一般用 "this" 值。如果这个参数为空， "undefined" 会传递给 "this" 值 |
第一个参数详解：
| 参数 | 描述 |
|---|---|
| currentValue | 必需。当前元素 |
| index | 可选。当前元素的索引值。 |
| arr | 可选。当前元素所属的数组对象。 |
返回值：undefined
forEach() 本身是不支持的 continue 与 break 语句的。使用 return 语句实现 continue 关键字的效果：
const arr = [1, 2, 3, 4, 5, 6]
arr.forEach(item => {
if (item === 3) {
continue;
}
console.log(item)
})
/*
1
2
4
5
6
*/
无法中途退出循环，只能用return退出本次回调，进行下一次回调。
它总是返回 undefined值,即使你 return 了一个值。
# every
every() 方法用于检测数组所有元素是否都符合指定条件（通过函数提供）。
every() 方法使用指定函数检测数组中的所有元素：
- 如果数组中检测到有一个元素不满足，则整个表达式返回 false ，且剩余的元素不会再进行检测。
- 如果所有元素都满足条件，则返回 true。 注意： every() 不会对空数组进行检测。
注意： every() 不会改变原始数组。 语法：
array.every(function(currentValue,index,arr), thisValue)
参数：
| 参数 | 描述 |
|---|---|
| function(currentValue, index,arr) | 必须。函数，数组中的每个元素都会执行这个函数 |
| thisValue | 可选。对象作为该执行回调时使用，传递给函数，用作 "this" 的值。如果省略了 thisValue ，"this" 的值为 "undefined" |
第一个参数详解：
| 参数 | 描述 |
|---|---|
| currentValue | 必须。当前元素的值 |
| index | 可选。当前元素的索引值 |
| arr | 可选。当前元素属于的数组对象 |
返回值：布尔值。如果所有元素都通过检测返回 true，否则返回 false。 示例：
const arr = [1, 2, 3]
console.log(arr.every(item => item > 2)) // false
# some
some() 方法用于检测数组中的元素是否满足指定条件（函数提供）。
some() 方法会依次执行数组的每个元素：
- 如果有一个元素满足条件，则表达式返回true , 剩余的元素不会再执行检测。
- 如果没有满足条件的元素，则返回false。
注意： some() 不会对空数组进行检测。
注意： some() 不会改变原始数组。 语法：
array.some(function(currentValue,index,arr),thisValue)
参数：
| 参数 | 描述 |
|---|---|
| function(currentValue, index,arr) | 必须。函数，数组中的每个元素都会执行这个函数 |
| thisValue | 可选。对象作为该执行回调时使用，传递给函数，用作 "this" 的值。如果省略了 thisValue ，"this" 的值为 "undefined" |
第一个参数详解：
| 参数 | 描述 |
|---|---|
| currentValue | 必须。当前元素的值 |
| index | 可选。当前元素的索引值 |
| arr | 可选。当前元素属于的数组对象 |
返回值：布尔值。如果数组中有元素满足条件返回 true，否则返回 false。 示例：
const arr = [1, 2, 3]
console.log(arr.some(item => item > 2)) // true
# filter
filter() 方法创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素。
注意： filter() 不会对空数组进行检测。
注意： filter() 不会改变原始数组。
语法：
array.filter(function(currentValue,index,arr), thisValue)
参数：
| 参数 | 描述 |
|---|---|
| function(currentValue, index,arr) | 必须。函数，数组中的每个元素都会执行这个函数 |
| thisValue | 可选。对象作为该执行回调时使用，传递给函数，用作 "this" 的值。如果省略了 thisValue ，"this" 的值为 "undefined" |
第一个参数详解：
| 参数 | 描述 |
|---|---|
| currentValue | 必须。当前元素的值 |
| index | 可选。当前元素的索引值 |
| arr | 可选。当前元素属于的数组对象 |
返回值：返回数组，包含了符合条件的所有元素。如果没有符合条件的元素则返回空数组。 示例：
const arr = [1, 2, 3]
console.log(arr.filter(item=>item > 2))// [3]
# map
map() 方法返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值。
map() 方法按照原始数组元素顺序依次处理元素。
注意： map() 不会对空数组进行检测。
注意： map() 不会改变原始数组。
语法：
array.map(function(currentValue,index,arr), thisValue)
参数：
| 参数 | 描述 |
|---|---|
| function(currentValue, index,arr) | 必须。函数，数组中的每个元素都会执行这个函数 |
| thisValue | 可选。对象作为该执行回调时使用，传递给函数，用作 "this" 的值。 |
| 如果省略了 thisValue，或者传入 null、undefined，那么回调函数的 this 为全局对象。 |
第一个参数详解：
| 参数 | 描述 |
|---|---|
| currentValue | 必须。当前元素的值 |
| index | 可选。当前元素的索引值 |
| arr | 可选。当前元素属于的数组对象 |
返回值：返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值。
示例：
const arr = [1, 2, 3]
console.log(arr.map(item=>item + 1)) // [2, 3, 4]
# reduce
reduce() 方法接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值。
reduce() 可以作为一个高阶函数，用于函数的 compose。
注意: reduce() 对于空数组是不会执行回调函数的。
语法：
array.reduce(function(total, currentValue, currentIndex, arr), initialValue)
参数：
| 参数 | 描述 |
|---|---|
| function(currentValue, index,arr) | 必须。函数，数组中的每个元素都会执行这个函数 |
| initialValue | 可选。传递给函数的初始值 |
第一个参数详解：
| 参数 | 描述 |
|---|---|
| total | 必需。初始值, 或者计算结束后的返回值。 |
| currentValue | 必需。当前元素 |
| currentIndex | 可选。当前元素的索引 |
| arr | 可选。当前元素所属的数组对象。 |
返回值：返回计算结果
示例：
const arr = [1, 2, 3]
console.log(arr.reduce((total, item) => {
return total + item
}, 0)) // 6
# find
find() 方法返回通过测试（函数内判断）的数组的第一个元素的值。
find() 方法为数组中的每个元素都调用一次函数执行：
- 当数组中的元素在测试条件时返回 true 时, find() 返回符合条件的元素，之后的值不会再调用执行函数。
- 如果没有符合条件的元素返回 undefined
注意: find() 对于空数组，函数是不会执行的。
注意: find() 并没有改变数组的原始值。
语法：
array.find(function(currentValue, index, arr),thisValue)
参数：
| 参数 | 描述 |
|---|---|
| function(currentValue, index,arr) | 必须。函数，数组中的每个元素都会执行这个函数 |
| thisValue | 可选。 传递给函数的值一般用 "this" 值。如果这个参数为空， "undefined" 会传递给 "this" 值 |
第一个参数详解：
| 参数 | 描述 |
|---|---|
| currentValue | 必须。当前元素的值 |
| index | 可选。当前元素的索引值 |
| arr | 可选。当前元素属于的数组对象 |
返回值：返回符合测试条件的第一个数组元素值，如果没有符合条件的则返回 undefined。
示例：
const arr = [1, 2, 3]
console.log(arr.find(item => item > 2)) // 3
# findIndex
findIndex() 方法返回传入一个测试条件（函数）符合条件的数组第一个元素位置。
findIndex() 方法为数组中的每个元素都调用一次函数执行：
- 当数组中的元素在测试条件时返回 true 时, findIndex() 返回符合条件的元素的索引位置，之后的值不会再调用执行函数。
- 如果没有符合条件的元素返回 -1
注意: findIndex() 对于空数组，函数是不会执行的。
注意: findIndex() 并没有改变数组的原始值。
语法：
array.findIndex(function(currentValue, index, arr), thisValue)
参数：
| 参数 | 描述 |
|---|---|
| function(currentValue, index,arr) | 必须。函数，数组中的每个元素都会执行这个函数 |
| thisValue | 可选。 传递给函数的值一般用 "this" 值。如果这个参数为空， "undefined" 会传递给 "this" 值 |
第一个参数详解：
| 参数 | 描述 |
|---|---|
| currentValue | 必须。当前元素的值 |
| index | 可选。当前元素的索引值 |
| arr | 可选。当前元素属于的数组对象 |
返回值：返回符合测试条件的第一个数组元素索引，如果没有符合条件的则返回 -1。
const arr = [1, 2, 3]
console.log(arr.findIndex(item => item > 2)) // 2
# keys
keys() 方法用于从数组创建一个包含数组键的可迭代对象。
如果对象是数组返回 true，否则返回 false。
语法：
array.keys()
参数：无
返回值：一个数组可迭代对象。
示例：
const arr = [1, 2, 3]
const keys = arr.keys()
for (let key of keys) {
console.log(key)
}
/*
0
1
2
*/
# values
# entries
entries() 方法返回一个数组的迭代对象，该对象包含数组的键值对 (key/value)。
迭代对象中数组的索引值作为 key， 数组元素作为 value。
语法：
array.entries()
参数：无
返回值：数组迭代对象
示例：
const arr = ['a', 'b', 'c']
const res = arr.entries()
for (let item of res) {
console.log(item)
}
/*
[0, "a"]
[1, "b"]
[2, "c"]
*/
参考：
JavaScript Array 对象 (opens new window)