下面以var arr = ['x', 'u', 'e', 'y', 'i', 'n', 'g']
为例
修改器方法:
修改器方法会改变原数组
1. arr.pop() && arr.push()
会改变原数组
arr.pop()
删除数组最后一个元素,并返回这个元素
arr.pop() // "g"
arr.push()
在数组末尾增加一个元素,返回数组的新长度
arr.push('l') // 8
arr // ["x", "u", "e", "y", "i", "n", "g", "l"]
2. arr.shift() && arr.unshift()
arr.shift() 删除数组开头第一个元素,并返回这个元素
arr.shift() // "x"
arr.unshift() 在数组开头增加一个元素,返回数组新长度。
arr.unshift('l') // 8
arr // ["l", "x", "u", "e", "y", "i", "n", "g"]
3. arr.reverse()
会改变原数组
数组倒序,返回倒序后的数组
arr.reverse() // ["g", "n", "i", "y", "e", "u", "x"]
4. arr.sort() || arr.sort(compareFunction)
对数组进行排序,并返回排好序的当前数组。(写得这么拗口是为了强调是原数组的顺序改变)
.sort()
使用的是就地排序算法,且不一定稳定。
(就地排序意思是直接在原数组上排序。稳定指的是两个相等的元素排好序后前后顺序不变)
默认排序顺序是根据字符串Unicode码点。
这意味着:
var scores = [1, 10, 21, 2];
scores.sort(); // [1, 10, 2, 21]
// 10在2之前,因为在 Unicode 指针顺序中"10"在"2"之前
不过.sort()
可以接受一个函数作为参数,自己指定排序规则:
var scores = [1, 10, 21, 2];
scores.sort(function (a, b) { // 从小到大排序
return a - b
}) // [ 1, 2, 10, 21 ]
函数compareFunction 的规则如下:
- 如果 compareFunction(a, b) 小于 0 ,那么 a 会被排列到 b 之前;
- 如果 compareFunction(a, b) 等于 0 , a 和 b 的相对位置不变。
备注: ECMAScript 标准并不保证这一行为,而且也不是所有浏览器都会遵守(例如 Mozilla 在 2003 年之前的版本); - 如果 compareFunction(a, b) 大于 0 , b 会被排列到 a 之前。
- compareFunction(a, b) 必须总是对相同的输入返回相同的比较结果,否则排序的结果将是不确定的。
5. arr.splice(start, deleteCount, item1, item2, …)
修改数组,从start
开始,删除deleteCount
个元素,再插入后面的item1, item2, ...
// 从下标0开始,删除一个元素,并插入‘X'
arr.splice(0, 1, 'X') // ["x"]
arr // ["X", "u", "e", "y", "i", "n", "g"]
访问方法:
访问方法不会改变原数组,一般都是返回一个新数组
1. arr1.concat(arr2)
合并arr1
和arr2
var arr1 = ["x", "u", "e"]
var arr2 = ["y", "i", "n", "g"]
arr1.concat(arr2) // ["x", "u", "e", "y", "i", "n", "g"]
2. arr.includes(searchElement, fromIndex)
从fromIndex
开始查找searchElement
,找到了返回true
,找不到返回false
fromIndex
可省略,默认从下标0开始找。
arr.includes('u') // true
arr.includes('u', 2) // false
3. arr.join(separator)
数组合并成一个字符串,每一个元素用separator
隔开。
separator
可省略,默认为,
arr.join() // "x,u,e,y,i,n,g"
arr.join('') // "xueying"
4. arr.slice(begin, end)
抽取数组在[begin
,end
)区间内的元素,返回一个新数组。
arr.slice(0, 3) // ["x", "u", "e"]
5. arr.toString()
arr.toString() // "x,u,e,y,i,n,g"
6. arr.indexOf(searchElement[, fromIndex = 0])
返回searchElement
的下标,没有则返回 -1
可以指定fromIndex
表示从哪个下标开始查找,默认为下标0
arr.indexOf('u') // 1
arr.indexOf('u', 2) // -1
7. arr.lastIndexOf(searchElement[, fromIndex = arr.length – 1])
找到数组中最后一个和searchElement
相等的元素的下标。
可以指定fromIndex
表示从哪个下标开始查找,默认从数组最后一个元素开始。
var arr = ["x", "u", "l", "e", "y", "i", "n", "g", "l"]
arr.lastIndexOf('l') // 8
迭代方法
1. arr.forEach()
语法:
array.forEach(callback(currentValue, index, array){
//do something
}, thisArg)
对数组每一个元素执行callback
函数。
callback
函数接收3个参数:
-
currentValue
:当前元素的值 -
index
: 当前元素的下标 -
array
:原数组
thisArg
:可选,用作callback
函数的this值。
var arr = ['x', 'u', 'e', 'y', 'i', 'n', 'g']
arr.forEach((element, index, array) => console.log('arr[' + index + '] = ' + element))
/*
arr[0] = x
arr[1] = u
arr[2] = e
arr[3] = y
arr[4] = i
arr[5] = n
arr[6] = g
*/
2. arr.every(callback[, thisArg]) && arr.some(callback[, thisArg])
arr.every(callback[, thisArg])
测试数组的 所有 元素是否都通过了callback
函数的测试。
全部通过返回true
,否则返回false
thisArg
指定this
值。
// 格式和forEach方法没区别
var arr = ['x', 'u', 'e', 'y', 'i', 'n', 'g']
console.log(arr.every((element, index, array) => element === element.toLowerCase())) // 数组中的元素是否都为小写
// true
arr.some(callback[, thisArg])
测试数组的 某些 元素是否全部通过了callback
函数的测试。
// 语法和forEach方法没区别
var arr = ['X', 'u', 'e', 'y', 'i', 'n', 'g'] // 第一个元素大写
console.log(arr.some((element, index, array) => element === element.toLowerCase())) // 数组中是否有小写的元素
// true
3. arr.filter(callback[, thisArg])
过滤器,创建一个新数组, 其包含通过所提供函数实现的测试的所有元素
语法还是跟forEach
方法没区别。
var arr = ['X', 'u', 'e', 'y', 'i', 'n', 'g'] // 第一个元素大写
console.log(arr.filter((element, index, array) => element === element.toLowerCase()))
// [ 'u', 'e', 'y', 'i', 'n', 'g' ]
4. arr.find(callback[, thisArg]) && arr.findIndex(callback[, thisArg])
arr.find(callback[, thisArg])
语法同上。
返回数组中第一个满足callback
函数的元素的值。否则返回 undefined
。
var arr = ['X', 'u', 'e', 'y', 'i', 'n', 'g'] // 第一个元素大写
console.log(arr.find((element, index, array) => element === element.toLowerCase()))
// "u"
arr.findIndex(callback[, thisArg])
语法同上。
返回数组中第一个满足callback
函数的元素的索引。否则返回-1。
var arr = ['X', 'u', 'e', 'y', 'i', 'n', 'g'] // 第一个元素大写
console.log(arr.findIndex((element, index, array) => element === element.toLowerCase()))
// 1
5. arr.entries()
(迭代器)返回一个新的Array Iterator对象,该对象包含数组中每个索引的键/值对。
跟Python中迭代器一样,用.next()
访问下一键值对。
var iterator = arr.entries();
iterator.next() // {value: Array(2), done: false} done表示迭代是否已经完成
iterator.next().value // [1, "u"]
6. arr.keys() && arr.values()
arr.keys()
返回一个新的Array迭代器,它包含数组中每个索引的键。
var iterator = arr.keys();
iterator.next() // {value: 0, done: false}
iterator.next().value // 1
// 不断next直到最后一个
console.log(iterator.next()) // {value: undefined, done: true}
arr.values()
返回一个新的 Array Iterator 对象,它包含数组每个索引的值。
PS: Chrome 未实现,Firefox未实现,Edge已实现。
Chrome 及Firefox可以用”arrSymbol.iterator“方法来代替values()方法。
var arr = [1,2,3,4,5]
var i = arr[Symbol.iterator]()
i.next() // {value: 1, done: false}
i.next() // {value: 2, done: false}
7. arr.map(callback)
创建一个新数组,其结果是该数组中的每个元素都调用callback
函数后返回的结果。
语法:
arr.map(function callback(currentValue, index, array) {
// Return element for new_array
}[, thisArg])
例子:
arr.map((element, index, array) => element.toUpperCase()) // ["X", "U", "E", "Y", "I", "N", "G"]
8. arr.reduce(callback[, initialValue])
累加器, 数组中的每个元素(从左到右)应用一个函数,将其减少为单个值。
callback
函数接收4个参数:
-
accumulator
:累加器累加回调的返回值; 它是上一次调用回调时返回的累积值,或initialValue -
currentValue
:数组中正在处理的元素 -
currentIndex
:数组中正在处理的当前元素的索引。 -
array
:原数组
initialValue
:用作第一个调用 callback的第一个参数的值。 如果没有提供初始值,则将使用数组中的第一个元素。 在没有初始值的空数组上调用 reduce 将报错。
回调函数第一次执行时,accumulator 和currentValue的取值有两种情况:
- 调用reduce时提供initialValue,accumulator取值为initialValue,currentValue取数组中的第一个值。
- 没有提供 initialValue,accumulator取数组中的第一个值,currentValue取数组中的第二个值。
// 取最大值
var arr = [1, 2, 3, 4, 5, 6]
console.log(arr.reduce((accumulator, currentValue) => Math.max(accumulator, currentValue)))
// 6
// 连接数组的元素
var arr = ['x', 'u', 'e', 'y', 'i', 'n', 'g']
console.log(arr.reduce((accumulator, currentValue) => accumulator.concat(currentValue)))
// xueying