前言:
每次需要用到数组方法时,总是需要去百度,因为一些方法在一段时间不用就忘记了,所以来做个总结,方便自己以后查找,顺便加深一下记忆。
创建 / 声明数组:
方式一:
var array = [3, 5, 2]; // [3,5,2]
方式二:
var array = Array(4,5,2); // [4,5,2]
改变原数组的方法(9个):
var a = [1,2,3];
ES5:
a.pop()/ a.shift()/ a.push()/ a.unshift()/ a.reverse()/ a.splice()/ a.sort()
ES6:
a.copyWithin() / a.fill()
不改变原数组的方法(8个):
var a = [1,2,3];
ES5:
a.join()/ a.toLocateString()/ a.toString()/ a.slice()/ a.concat()/ a.indexOf()/ a.lastIndexOf()
ES6:
a.includes()
遍历数组并不会改变原始数组的方法(12个):
var a = [1,2,3];
ES5:
a.forEach()/ a.every()/ a.some()/ a.fliter()/ a.map()/ a.reduce()/ a.reduceRight()
ES6:
a.find()/ a.findIndex()/ a.keys()/ a.values()/ a.entries()
定义:删除一个数组中的最后一个元素,并且返回这个元素。
参数:无
尾部删除,返回被删除的元素,改变原数组
var a = [1,2,3]
var b = a.pop()
console.log(a) // [1,2]
console.log(b) // 3
定义:删除数组的第一个元素,并且返回这个元素。
参数:无
删除首部元素,返回被删元素,改变原数组
var a = [1,2,3]
var b = a.shift()
console.log(a) // [2,3]
console.log(b) // 1
定义:向数组的末尾添加一个或多个元素,并返回新的长度。
参数: item1, item2, …, itemX ,要添加到数组末尾的元素
末尾添加,返回长度,改变原数组
var a = [1,2,3]
var b = a.push('末尾')
console.log(a) // [1,2,3,'末尾']
console.log(b) // 4 - 长度
定义:向数组的开头添加一个或更多元素,并返回新的长度。
参数:item1, item2, …, itemX ,要添加到数组开头的元素
首部添加,返回长度,改变原数组
var a = [2,3,4]
var b = a.unshift(0,1)
console.log(a) // [0,1,2,3,4]
console.log(b) // 5 - 长度
定义:用于颠倒数组中元素的顺序。
参数:无
返回的是颠倒后的数组,改变原数组
var a = [1,3,2,7,6]
console.log(a.reverse()) // [6,7,2,3,1]
console.log(a) // [6,7,2,3,1]
定义:向/从数组中添加/删除项目,然后返回被删除的项目。
语法:array.splice(index,howmany,item1,…,itemX)
参数:
index:必需。整数,规定添加/删除项目的位置,使用负数可从数组结尾处规定位置。
howmany:必需。要删除的项目数量。如果设置为 0,则不会删除项目。
item1, …, itemX: 可选。向数组添加的新项目。
返回值: 如果有元素被删除,返回包含被删除项目的新数组。
对数组进行删除修改,返回被删除的元素组成的数组,改变原数组
删除元素:
var a = [1, 2, 3, 4, 5, 6, 7];
var b = a.splice(0, 3); // 从数组下标0开始,删除3个元素
console.log(a); // [4,5,6,7]
console.log(b); // [1,2,3]
var c = a.splice(-1, 3); // 从最后一个元素开始删除3个元素,因为最后一个元素,所以只删除了7
console.log(a); // [4,5,6]
console.log(c); // [7]
删除并添加:
var a = [1, 2, 3, 4, 5, 6, 7];
var b = a.splice(0,3,'添加'); // 从数组下标0开始,删除3个元素,并添加元素'添加'
console.log(a); // ['添加',4,5,6,7]
console.log(b); // [1,2,3]
var c = [1, 2, 3, 4, 5, 6, 7];
var d = c.splice(-2,3,'添加1','添加2'); // 从数组最后第二个元素开始,删除3个元素,并添加两个元素'添加1'、'添加2'
console.log(c); // [1,2,3,4,5,'添加1','添加2']
console.log(d); // [6,7]
不删除只添加
var a = [1, 2, 3, 4, 5, 6, 7];
var b = a.splice(0,0,'添加1','添加2');
console.log(a); // ['添加1','添加2',1,2,3,4,5,6,7]
console.log(b); // [], 没有删除元素,返回空数组
var c = [1, 2, 3, 4, 5, 6, 7];
var d = c.splice(-1,0,'添加1','添加2'); // 在最后一个元素的前面添加两个元素
console.log(c); // [1,2,3,4,5,6,'添加1','添加2',7]
console.log(d); // [] 没有删除元素,返回空数组
splice用法小结:
定义:对数组元素进行排序(ASCII码),并返回这个数组。
参数:可选,规定排序顺序的比较函数。
默认情况下sort()方法没有传比较函数的话,默认按字母升序,如果不是元素不是字符串的话,会调用toString()方法将元素转化为字符串的Unicode(万国码)位点,然后再比较字符。
返回排序后的数组,改变原数组
// 字符串排列 看起来很正常
var a = ["Banana", "Orange", "Apple", "Mango"];
console.log(a.sort()); // ["Apple","Banana","Mango","Orange"]
// 数字排序需注意,因为转换成Unicode字符串之后,有些数字会比较大会排在后面 这显然不是我们想要的
var a = [10, 1, 3, 20,25,8];
console.log(a.sort()); // [1,10,20,25,3,8];
比较函数的两个参数:
sort的比较函数有两个默认参数,要在函数中接收这两个参数,这两个参数是数组中两个要比较的元素,通常我们用 a 和 b 接收两个将要比较的元素:
数组元素为数字的升序、降序:
var array = [10, 1, 3, 4, 20, 4, 25, 8];
// 升序 a-b < 0 a将排到b的前面,按照a的大小来排序的
// 比如被减数a是10,减数是20 10-20 < 0 被减数a(10)在减数b(20)前面
array.sort(function(a,b){
return a-b;
});
console.log(array); // [1,3,4,4,8,10,20,25];
// 降序 被减数和减数调换了 20-10>0 被减数b(20)在减数a(10)的前面
array.sort(function(a,b){
return b-a;
});
console.log(array); // [25,20,10,8,4,4,3,1];
数组多条件排序:
var array = [{id:10,age:2},{id:5,age:4},{id:6,age:10},{id:9,age:6},{id:2,age:8},{id:10,age:9}];
array.sort(function(a,b){
if (a.id === b.id) {// 如果id的值相等,按照age的值降序
return b.age - a.age
} else { // 如果id的值不相等,按照id的值升序
return a.id - b.id
}
})
// [{"id":2,"age":8},{"id":5,"age":4},{"id":6,"age":10},{"id":9,"age":6},{"id":10,"age":9},{"id":10,"age":2}]
自定义比较函数:
var array = [{name:'Koro1'},{name:'Koro1'},{name:'OB'},{name:'Koro1'},{name:'OB'},{name:'OB'}];
array.sort(function(a,b){
if (a.name === 'Koro1'){// 如果name是'Koro1' 返回-1 ,-1<0 a排在b的前面
return -1
} else { // 如果不是的话,a排在b的后面
return 1
}
})
// [{"name":"Koro1"},{"name":"Koro1"},{"name":"Koro1"},{"name":"OB"},{"name":"OB"},{"name":"OB"}]
定义: 在当前数组内部,将指定位置的成员复制到其他位置,并返回这个数组。
语法: array.copyWithin(target, start = 0, end = this.length)
参数: 三个参数都是数值,如果不是,会自动转为数值。
target(必需):从该位置开始替换数据。如果为负值,表示倒数。
start(可选):从该位置开始读取数据,默认为 0。如果为负值,表示倒数。
end(可选):到该位置前停止读取数据,默认等于数组长度。使用负数可从数组结尾处规定位置。
[3, 5, 3, 21, 4].copyWithin(0, 1, 2); // [5, 5, 3, 21, 4]
[3, 5, 3, 21, 4].copyWithin(0, 1, 3); // [5, 3, 3, 21, 4]
[3, 5, 3, 21, 4].copyWithin(0, -2, -1); // [21, 5, 3, 21, 4]
copyWithin用法小结:
定义: 使用给定值,填充一个数组。
参数:
第一个元素(必须):要填充数组的值
第二个元素(可选):填充的开始位置,默认值为0
第三个元素(可选):填充的结束位置(不包括),默认是为this.length
['a', 'b', 'c'].fill(7); // [7, 7, 7]
['a', 'b', 'c'].fill(7, 1, 2); // ['a', 7, 'c']
定义: 把数组中的所有元素通过指定的分隔符进行分隔放入一个字符串,返回生成的字符串。
语法: array.join(seperator)
参数: seperator(可选): 指定要使用的分隔符,默认使用逗号作为分隔符。
不改变原数组,返回转换后的字符串
var a = [1,2,3,4,5]
console.log(a.join(',')) // 1,2,3,4,5
console.log(a.join('+')) // 1+2+3+4+5
console.log(a) // [1,2,3,4,5]
注意:join()/toString()方法在数组元素是数组的时候,会将里面的数组也调用join()/toString(),如果是对象的话,对象会被转为[object Object]字符串
var a= [['OBKoro1','23'],'test'];
console.log(a.join()); // OBKoro1,23,test
var b= [{name:'OBKoro1',age:'23'},'test'];
console.log(b.join()); // [object Object],test
// 对象转字符串推荐JSON.stringify(obj);
定义: 返回一个表示数组元素的字符串。该字符串由数组中的每个元素的 toLocaleString() 返回值经调用 join() 方法连接(由逗号隔开)组成。
语法: array.toLocaleString()
参数:无。
var a=[{name:'OBKoro1'},23,'abcd',new Date()];
console.log(a.toLocaleString()); // [object Object],23,abcd,2019/5/22 下午5:21:14
定义: 可把数组转换为由逗号链接起来的字符串。
语法: array.toString()
参数: 无。
该方法的效果和join方法一样,都是用于数组转字符串的,但是与join方法相比没有优势,也不能自定义字符串的分隔符,因此不推荐使用。
值得注意的是:当数组和字符串操作的时候,js 会调用这个方法将数组自动转换成字符串
var b= [ 'toString','演示'].toString(); // toString,演示
var a= ['调用toString','连接在我后面']+'啦啦啦'; // 调用toString,连接在我后面啦啦啦
定义:返回从startIndex开始(包括),到endIndex(不包括)之间的元素组成的数组,且原数组不会被修改。
注意:字符串也有一个slice() 方法是用来提取字符串的,不要弄混了。
语法: array.slice(startIndex, endIndex);
参数:
startIndex(可选): 索引数值,接受负值,从该索引处开始提取原数组中的元素,默认值为0。
endIndex(可选): 索引数值(不包括),接受负值,在该索引处前结束提取原数组元素,默认值为数组末尾(包括最后一个元素)。
返回新数组,不改变原数组
var a = [1,2,3]
var b = a.slice(0,1)
// 不填参数则表示剪切整个数组
var c = a.slice()
console.log(a) // [1,2,3]
console.log(b) // [1]
console.log(c) // [1,2,3]
console.log(a===c) // false // 注意 a !== c
// 负数表示从后往前数
var d = a.slice(-1,-2)
console.log(d) // [] 从左向右截取,所以说为[]
var e = a.slice(-1)
console.log(e) // [3]
定义: 方法用于合并两个或多个数组,返回一个新数组。
语法: var newArr =oldArray.concat(arrayX,arrayX,…,arrayX)
参数: arrayX(必须):该参数可以是具体的值,也可以是数组对象。可以是任意多个。
合并两个或多个数组,返回新数组,不会改变原数组
var a = [1,2,3]
var b = [4,5]
var c = a.concat(b)
console.log(a) // [1,2,3]
console.log(b) // [4,5]
console.log(c) // [1,2,3,4,5]
补充:
ES6扩展运算符 … 合并数组:
var a = [2, 3, 4, 5]
var b = [ 4,...a, 4, 4]
console.log(a); // [2,3,4,5]
console.log(b); // [4,2,3,4,5,4,4]
定义: 返回在数组中可以找到一个给定元素的第一个索引,如果不存在,则返回-1。
语法: array.indexOf ( searchElement , fromIndex )
参数:
searchElement(必须): 被查找的元素
fromIndex(可选): 开始查找的位置(不能大于等于数组的长度,返回-1),接受负值,默认值为0。
注意:indexOf()不能识别NaN
var a = [1,2,4,3,4,5]
console.log(a.indexOf(4)) // 2
console.log(a.indexOf(4,3)) // 4
使用场景:
// 数组去重
var array = [2,4,4,2,3,6,5,11,23,11];
var newArr = []
for(var i = 0; i < array.length; i++) {
if(newArr.indexOf(array[i]) == -1) {
newArr.push(array[i])
}
}
console.log(newArr) //[2, 4, 3, 6, 5, 11, 23]
去重方法补充:
// ES6去重
function dedupe(array) {
return Array.from(new Set(array));
}
dedupe([1, 1, 2, 3]) // [1, 2, 3]
定义: 方法返回指定元素在数组中的最后一个的索引,如果不存在则返回 -1。(从数组后面往前查找)
语法: arr.lastIndexOf ( searchElement , fromIndex )
参数:
searchElement(必须): 被查找的元素
fromIndex(可选): 逆向查找开始位置,默认值数组的长度-1,即查找整个数组。
关于fromIndex有三个规则:
var a = ['OB',4,'Koro1',1,2,'Koro1',3,4,5,'Koro1']; // 数组长度为10
a.lastIndexOf('Koro1',4)); // 从下标4开始往前找 返回下标2
a.lastIndexOf('Koro1',100); // 大于数组的长度 查找整个数组 返回9
a.lastIndexOf('Koro1',-11); // -1 数组不会被查找
a.lastIndexOf('Koro1',-9); // 从第二个元素4往前查找,没有找到 返回-1
定义: 返回一个布尔值,表示某个数组是否包含给定的值
语法: array.includes( searchElement , fromIndex )
参数:
searchElement(必须): 被查找的元素
fromIndex(可选): 默认值为0,参数表示搜索的起始位置,接受负值。
includes方法是为了弥补indexOf方法的缺陷而出现的:
let a=['OB','Koro1',1,NaN];
a.includes(NaN); // true 识别NaN
a.includes('Koro1',100); // false 超过数组长度 不搜索
a.includes('Koro1',-3); // true 从倒数第三个元素开始搜索
a.includes('Koro1',-100); // true 负值绝对值超过数组长度,搜索整个数组
定义:按升序为数组中含有效值的每一项执行一次回调函数。
语法:array.forEach(function(currentValue, index, arr), thisValue)
参数:
function(必须):数组中每个元素需要调用的函数。
回调函数的参数:
thisValue(可选):当执行回调函数时this绑定对象的值,默认值为undefined
关于forEach()你要知道:
无法中途退出循环,只能用return退出本次回调,进行下一次回调。
它总是返回 undefined值,即使你return了一个值。
下面类似语法同样适用这些规则:
var arr = ['a','b','c']
var copy = []
arr.forEach(function(value, index, arr){
console.log(value, index, arr)
copy.push(value)
})
console.log(copy)
定义:方法用于检测数组所有元素是否都符合函数定义的条件
语法:array.every(function(currentValue, index, arr), thisValue)
参数:(这几个方法的参数,语法都类似)
function(必须):数组中每个元素需要调用的函数。
回调函数的参数:
thisValue(可选):当执行回调函数时this绑定对象的值,默认值为undefined
方法返回值规则:
var a = [1,2,3,4,5]
var b = a.every(function(current,index,array){
return current < 6
})
var c = a.every(function(current,index,array){
return current < 3
})
console.log(b) // true
console.log(c) // false
// 接受箭头函数写法
[12, 5, 8, 130, 44].every(x => x >= 10); // false
[12, 54, 18, 130, 44].every(x => x >= 10); // true
定义:数组中的是否有满足判断条件的元素
语法: array.some(function(currentValue, index, arr), thisValue)
参数:(这几个方法的参数,语法都类似)
function(必须):数组中每个元素需要调用的函数。
回调函数的参数:
thisValue(可选): 当执行回调函数时this绑定对象的值,默认值为undefined
方法返回值规则:
var a = [1,2,3,4,5]
var b = a.some(function(current,index,array){
return current > 4
})
var c = a.some(function(current,index,array){
return current > 5
})
console.log(b) // true
console.log(c) // false
function isBigEnough(element, index, array) {
return (element >= 10); //数组中是否有一个元素大于 10
}
let result = [2, 5, 8, 1, 4].some(isBigEnough); // false
let result = [12, 5, 8, 1, 4].some(isBigEnough); // true
定义: 返回一个新数组, 其包含通过所提供函数实现的测试的所有元素。
语法:
let new_array = arr.filter(function(currentValue, index, arr), thisArg)
参数:(这几个方法的参数,语法都类似)
function(必须):数组中每个元素需要调用的函数。
回调函数的参数:
thisValue(可选):当执行回调函数时this绑定对象的值,默认值为undefined
返回数组中满足条件的元素组成的新数组,原数组不变
var a = [1,2,3,4,11]
// 第一个参数为一个方法,有三个参数,current:当前值 index:当前值下标 array:这个数组对象
var b = a.filter(function(current,index,array){
return current < 10
})
console.log(b) // [1,2,3,4]
console.log(a) // [1,2,3,4,11]
定义:创建一个新数组,其结果是该数组中的每个元素都调用一个提供的函数后返回的结果。
语法:
let new_array = arr.map(function(currentValue, index, arr), thisArg)
参数:(这几个方法的参数,语法都类似)
function(必须):数组中每个元素需要调用的函数。
回调函数的参数:
thisValue(可选):当执行回调函数时this绑定对象的值,默认值为undefined
根据需求格式化原数组,返回格式化后的数组。原数组不变
var a = [1,2,3,4,5]
// 参数同filter方法
var b = a.map(function(current,index,array){
return current + 1
})
console.log(b) // [2,3,4,5,6]
console.log(a) // [1,2,3,4,5]
find()定义:用于找出第一个符合条件的数组成员,并返回该成员,如果没有符合条件的成员,则返回undefined。
findIndex()定义:返回第一个符合条件的数组成员的位置,如果所有成员都不符合条件,则返回-1。
语法:
let new_array = arr.find(function(currentValue, index, arr), thisArg)
let new_array = arr.findIndex(function(currentValue, index, arr), thisArg)
参数:(这几个方法的参数,语法都类似)
function(必须):数组中每个元素需要调用的函数。
回调函数的参数:
thisValue(可选):当执行回调函数时this绑定对象的值,默认值为undefined
这两个方法都可以识别NaN,弥补了indexOf的不足。
// find
let a = [1, 4, -5, 10].find((n) => n < 0); // 返回元素-5
let b = [1, 4, -5, 10, NaN].find((n) => Object.is(NaN, n)); // 返回元素NaN
// findIndex
let a = [1, 4, -5, 10].findIndex((n) => n < 0); // 返回索引2
let b = [1, 4, -5, 10, NaN].findIndex((n) => Object.is(NaN, n)); // 返回索引4
// find
var a = [1,2,3,4]
// b在下面需要使用,则一般用find
var b = a.find(function(ele,index,array){
return ele == 1
})
var c = 3
var d = b + c
console.log(a) // [1,2,3,4]
console.log(b) // 1
console.log(d) // 4
// 若只需判断元素是否存在
// 若果是简单数组(非对象数组),则一般使用Array.includes(value)方法
// 如果为对象数组,则可以使用Array.some()方法
var a = [1,2,3]
console.log(a.includes(1)) // true
var a = [{"name": "xiaoming" },{"name": "xiaohong"}]
console.log(a.some(function(ele){
return ele.name == 'xiaoming'
})) // true
// findIndex
var a = [1,2,3,4]
var b = a.findIndex(function(ele,index,array){
return ele === 2
})
var c = a.indexOf(2)
console.log(a) // [1,2,3,4]
console.log(b) // 1
console.log(c) // 1
遍历键名、遍历键值、遍历键名+键值
定义:三个方法都返回一个新的 Array Iterator 对象,对象根据方法不同包含不同的值。
语法:
array.keys()
array.values()
array.entries()
参数:无。
遍历例子(摘自ECMAScript 6 入门):
for (let index of ['a', 'b'].keys()) {
console.log(index);
}
// 0
// 1
for (let elem of ['a', 'b'].values()) {
console.log(elem);
}
// 'a'
// 'b'
for (let [index, elem] of ['a', 'b'].entries()) {
console.log(index, elem);
}
// 0 "a"
// 1 "b"
在for…of中如果遍历中途要退出,可以使用break退出循环。
如果不使用for…of循环,可以手动调用遍历器对象的next方法,进行遍历:
let letter = ['a', 'b', 'c'];
let entries = letter.entries();
console.log(entries.next().value); // [0, 'a']
console.log(entries.next().value); // [1, 'b']
console.log(entries.next().value); // [2, 'c']
entries()浏览器兼容性(MDN):Chrome 38, Firefox 28,Opera 25,Safari 7.1
keys()浏览器兼容性(MDN):Chrome 38, Firefox 28,Opera 25,Safari 8
用来判断一个元素是否为数组
Array.isArray([]) // true
Array.isArray({}) // false
附上主要参考链接:https://www.jb51.net/article/141330.htm