1. concat()
concat()方法用于连接两个或多个数组。该方法不会改变现有的数组,仅会返回被连接数组的一个副本
var arr1 = [1,2,3];
var arr2 = [4,5];
var arr3 = arr1.concat(arr2);
console.log(arr1); // [1,2,3]
console.log(arr3); // [1,2,3,4,5]
2. join()
join()方法用于把数组中所有元素放入一个字符串。元素是通过指定的分隔符进行分隔的,默认使用’,'号分割,不改变原数组。
var arr = [1,2,3]
console.log(arr.join()) // 1,2,3
console.log(arr) // [1,2,3]
3. push()
push()方法可向数组的末尾添加一个或多个元素,并返回新的长度。末尾添加,返回的是长度,会改变原数组。
var a = [2,3,4];
var b = a.push(5);
console.log(a); // [2,3,4,5]
console.log(b); // 4
4. pop()
pop() 方法用于删除并返回数组的最后一个元素。返回最后一个元素,会改变原数组。
var arr = [2,3,4]
console.log(arr.pop()); // 4
console.log(arr); // [2,3]
5. shift()
shift() 方法用于把数组的第一个元素从其中删除,并返回第一个元素的 值。返回第一个元素,改变原数组。
var arr = [2,3,4];
console.log(arr.shift()); //2
console.log(arr); // [3,4]
6. unshift()
unshift() 方法可向数组的开头添加一个或更多的元素,并返回新的长度。返回新的长度,改变原数组。
var arr = [2,3,4,5];
console.log(arr.unshift(3,6)); // 6
console.log(arr); // [3,6,2,3,4,5]
7. slice()
slice() 返回一个新的数组,包含从start 到 end(不包括该元素)的arrayObject中的元素。返回选定的元素,该方法不会修改原数组。
var arr = [2,3,4,5];
console.log(arr.slice(1,3)); // [3,4] 不包括 3
console.log(arr); // [2,3,4,5]
8. splice()
splice() 方法可以删除从index处开始的零个或多个元素,并且用参数列表中声明的一个或多个值来替换那些被删除的元素。如果从arrayObject中删除了元素,则返回的是含有被删除的元素的数组。splice()方法会直接对数组进行修改。
var a = [5,6,7,8];
console.log(a.splice(1,0,9)); // [] 从第 1开始删除,删除0个 替换成9
console.log(a); // [5,9,6,7,8]
var b = [5,6,7,8];
console.log(b.splice(1,2,3)); // [6,7] 从下表1开始删, 删除2个,替换成3
console.log(b) // [5,3,8]
9. substring() 和 substr()
相同点:如果只是写一个参数,两者的作用都一样:都是截取字符串从当前下标以后直到字符串最后的字符串片段
substr(startIndex);
substring(startIndex);
var str = '123456789';
console.log(str.substr(2)); // "3456789"
console.log(str.substring(2)); // "3456789"
不同点: 第二个参数
substr(startIndex,lenth): 第二个参数是截取字符串的长度(从起始点截取某个长度的字符串);
substring(startIndex,endIndex):第二个参数是截取字符串最终的下标(截取2个位置之间的字符串,“含头不含尾”)
var str = "123456789"
console.log(str.substr(2,5)); // "34567" // 从下标2开始截取 返回截取的5个数
console.log(str) // 123456789 不会改变原字符串
console.log(str.substring(2,5)); // "345" // 从下标2开始截取, 截取到下标5 不包括5
console.log(str) // 123456789 不会改变原字符串
10. sort排序
按照Unicode code 位置排序,默认升序
var fruit = ['cherries', 'apples', 'bananas'];
fruit.sort(); // ['apples', 'bananas', 'cherries']
var scores = [1, 10, 21, 2];
scores.sort(); // [1, 10, 2, 21]
11. reverse()
reverse()方法用于颠倒数组中元素得顺序。返回得是颠倒后得数组,会改变原数组。
var arr = [2,3,4];
console.log(arr.reverse()); // [4,3,2]
conosle.log(arr); // [4,3,2]
12. indexOf 和 lastIndexOf
都接受两个参数:查找的值,查找起始位置
不存在,返回-1;存在返回位置。indexOf是从前往后查找,lastIndexOf是从后往前查找。
indexOf()
var a = [2,9,9]
a.indexOf(2); //0 查找的2 在下标0
a.indexOf(7); // -1 查找7没有 返回-1
if(a.indexOf(7) === -1){
//元素在数组中不存在
}
lastIndexOf()
var numbers = [2,5,9,2];
number.lastIndexOf(2); // 3从后往前数 在下标3
number.lastIndexOf(7); // 从后往前数 没有7 返回-1
numbers.lastIndexOf(2, 3); // 3
numbers.lastIndexOf(2, 2); // 0
numbers.lastIndexOf(2, -2); // 0
numbers.lastIndexOf(2, -1); // 3
13. every
对数组的每一项都运行给定的函数,有一项为false就返回false,全为true 就返回true
function isBigEnough(element,index,array){
return element < 10;
}
[2,5,8,3,4].every(isBigEnough); // true
// 数组如果有一个大于10就返回false
var arr = [2,5,8,3,11,4];
function isBigEnough(element,index,array){
return element < 10;
}
var brr = arr.every(isBigEnough)
console.log(brr)
14. some
对数组的每一项都运行给定的函数,有一项为true,就为true,全没有就返回false。
function compare(element,index,array){
return element > 10;
}
[2,5,8,1,4].some(compare); // false 全是false 返回false
[12,5,8,1,4].some(compare); // true 有一项是true 返回true
15. filter
对数组的每一项都运行给定的函数,返回结果为true的项 组成的数组
var words = ["spray", "limit", "elite", "exuberant", "destruction", "present", "happy"];
var longWords = words.filter(item=>{
return item.length > 6;
})
// 过滤完 每个字符串的长度大于6的有 ["exuberant", "destruction", "present"];
16. map
对数组的每一项都运行给定的函数,返回每次函数调用的结果组成一个新数组, 不会改变老的数组
var numbers = [1,5,10,15]
var doubles = numbers.map(item=>{
return item * 2;
})
// double [2,10,20,30] 新的 数组
// number [1,5,10,15] 老的数组
17. forEach数组遍历
const items = ['item1', 'item2', 'item3'];
const copy = [];
items.forEach(item=>{
copy.push(item)
});
ES6新增新操作数组的方法
1. find():
传入一个回调函数,找到数组中符合当前搜索规则的第一个元素,返回它,并且终止搜索。
const arr = [1,"2",3,3,"2"]
console.log(arr.find(n => typeof n === "number")) // 1
const arr = ["2",5,3,3,"2"]
console.log(arr.find(n => typeof n === "number")) // 5
const arr = ["2",5,3,3,"2"]
console.log(arr.find(n => typeof n === "string")) // 2
2. findIndex():
传入一个回调函数,找到数组中符合当前搜索规则的第一个元素,返回它的下标,终止搜索。
const arr = [1, "2", 3, 3, "2"]
console.log(arr.findIndex(n => typeof n === "number")) // 0
const arr = ["2",5,3,3,"2"]
console.log(arr.findIndex(n => typeof n === "number")) // 1
const arr = ["2",5,3,3,"2"]
console.log(arr.findIndex(n => typeof n === "string")) // 0
3. fill():
用新元素替换掉数组内的元素,可以指定替换下标范围
arr.fill(value,start,end)
var arr = [1,2,3,4,5,6]
var brr = arr.fill(9,1,3)
console.log(arr) // [1,9,9,4,5,6] 会改变原数组
console.log(brr) // [1,9,9,4,5,6] 从start下标开始替换,提到到end 不包括end
4. copyWithin():
选择数组的某个下标,从该位置开始复制数组元素,默认从0开始复制。也可以指定要复制的元素范围。
// arr.copyWithin(target,start,end) // 目标 开始 结束
const arr = [1,2,3,4,5,6]
console.log(arr.copyWithin(3)) // [1,2,3,1,2,3] 从下标为3的元素开始,复制数组,所以4,5,6被替换成1,2,3
const arr1 = [1,2,3,4,5]
console.log(arr1.copyWithin(3,1)) // [1,2,3,2,3] 从下标为3的元素开始,复制数组,指定复制的第一个元素下标为1,所以4,5被替换成2,3
const arr2 = [1,2,3,4,5]
console.log(arr2.copyWithin(3,1,2)) // [1,2,3,2,5] 从下标为3的元素开始,复制数组,指定复制的第一个元素下标为1,结束位置为2,所以4被替换成2
5. from
将类似数组的对象 (array-like object) 和可遍历(iterable)的对象转为真正的数组
const bar = ["a","b","c"];
var arr = Array.from(bar);
console.log(arr) // ["a","b","c"]
var crr = Array.from('hello world')
console.log(crr) // ["h", "e", "l", "l", "o", " ", "w", "o", "r", "l", "d"]
6. of()
用于将一组值,转换为数组。这个方法的主要目的,是弥补数组构造函数 Array()的不足。因为参数个数的不同,会导致Array()的行为有差异。
Array() // []
Array(3) // [, , ,]
Array(3, 11, 8) // [3, 11, 8]
Array.of(7); // [7]
Array.of(1, 2, 3); // [1, 2, 3]
Array(7); // [ , , , , , , ]
Array(1, 2, 3); // [1, 2, 3]
7. entries() 返回迭代器:返回键值对
// 数组
const arr = ['a','b','c'];
for(let v of arr.entries()){
console.log(v)
}
// [0, 'a'] [1, 'b'] [2, 'c']
// Set
const arr = new Set(['a','b','c']);
for(let v of arr.entries()){
console.log(v)
}
// ['a', 'a'] ['b', 'b'] ['c', 'c']
// Map
const arr = new Map();
arr.set('a','a');
arr.set('b','b');
for(let v of arr.entries()){
console.log(v)
}
// ['a', 'a'] ['b', 'b']
8. values() 返回迭代器:返回键值对的value
// 数组
const arr = ['a','b','c'];
for(let v of arr.values()){
console.log(v)
}
// 'a' 'b' 'c'
// Set
const arr = new Set(['a','b','c']);
for(let v of arr.values()){
console.log(v)
}
// 'a' 'b' 'c'
//Map
const arr = new Map();
arr.set('a', 'a');
arr.set('b', 'b');
for(let v of arr.values()) {
console.log(v)
}
// 'a' 'b'
9. keys() 返回迭代器:返回键值对的key
// 数组
const arr = ['a','b','c'];
for(let v of arr.keys()){
console.log(v)
}
// 0 1 2
//Set
const arr = new Set(['a', 'b', 'c']);
for(let v of arr.keys()) {
console.log(v)
}
// 'a' 'b' 'c'
//Map
const arr = new Map();
arr.set('a', 'a');
arr.set('b', 'b');
for(let v of arr.keys()) {
console.log(v)
}
// 'a' 'b'
10. includes
判断数组中是否存在该元素,参数:查找的值、起始位置,可以替换ES5 时代的indexOf判断方式。indexOf判断元素是否为 NaN, 会判断错误。
var a = [1, 2, 3];
a.includes(2); // true
a.includes(4); // false