数组常用操作
var arr = [1, 2, 3, 4, 5, 6]
-
push在数组最后添加一个元素，改变原数组
arr.push('hello')
console.log(arr); // [1, 2, 3, 4, 5, 6, 'hello']
-
pop把数组最后一位弹出来返回，改变原数组
var value = arr.pop();
console.log(value); // 'hello'
console.log(arr); // [1, 2, 3, 4, 5, 6]
-
shift把数组第一位元素拿出来返回，改变原数组
var value1 = arr.shift();
console.log(value1); // 1
console.log(arr); // [2, 3, 4, 5, 6]
-
unshift在数组第一位新增元素，改变元素组
arr.unshift(1)
console.log(arr); // [1, 2, 3, 4, 5, 6]
-
join把数组元素（对象调用其toString()方法）使用参数作为连接符连接成一个字符串，不会修改原数组内容。
console.log(arr.join('--')); // 1--2--3--4--5--6
console.log(arr); // [1, 2, 3, 4, 5, 6]
-
splice用于数组添加、删除，有三个参数：开始索引、删除元素的位移、插入的新元素（可以多个）。
- 删除：指定前两个参数删除数组元素，删除的元素组成新数组，原数组改变。
console.log(arr.splice(1,3)); // [2, 3, 4]
console.log(arr); // [1, 5, 6]
- 添加或替换：第二个参数也就是执行删除动作执行次数为0，第三个参数及以后填写要插入内容，就是添加效果；第二个参数不为0，则先在该位置删除再插入，就是替换效果，原数组改变。
arr.splice(1,0,22,33,44)
console.log(arr); // [1, 22, 33, 44, 5, 6]
arr.splice(1,3,2,3,4)
console.log(arr); // [1, 2, 3, 4, 5, 6]
-
sort方法用于对数组进行排序，当没有参数的时候按字母表升序排序，如果含有undefined会被排到最后面，对象元素则会调用其to string方法，如果要按照自定义方式排序，可以传入排序方法，会改变原数组。
arr.splice(2,4,5,3,4,6);
console.log(arr); // [1, 2, 5, 3, 4, 6]
arr.sort();
console.log(arr); // [1, 2, 3, 4, 5, 6]
字母升序排序
var a = ['a','d','e','b','c'];
a.sort();
console.log(a); // ['a','b','c','d','e']
注意···
var b = [7, 8, 9, 10, 11];
b.sort();
console.log(b); // [10, 11, 7, 8, 9]
排序错误，是因为按照字母表排序7比10大，所以需要传入自定义排序函数。
b.sort(function(v1,v2) {
return v1 - v2;
});
console.log(b); // [7, 8, 9, 10, 11]
b.sort(function(v1,v2) {
return v2 - v1;
});
console.log(b); // [11, 10, 9, 8, 7]
-
reverse用于将数组逆序，会改变原素组。
b.reverse();
console.log(b); // [7, 8, 9, 10, 11]
-
concat用于拼接数组，拼接后返回的是一个新数组，不会修改原数组，也不会递归连接数组内部数组。
var c = ['hello', 'world'];
console.log(c.concat(b)); // ['hello', 'world', 7, 8, 9, 10, 11]
console.log(b); // [7, 8, 9, 10, 11]
console.log(c); // ['hello', 'world']
concat也可以拼接数字或字符串
console.log(b.concat(88)); // [7, 8, 9, 10, 11, 88]
console.log(b.concat('hello')); // [7, 8, 9, 10, 11, 'hello']
ES5数组拓展
-
.indexOf(element)用于查找数组内指定的元素位置，查找到后返回其索引，没有查到返回-1，indexOf是从头至尾搜索(lastIndexOf为反向搜索)。
var arr = [1, 2, 3, 4, 5, 6, 2]
arr.indexOf(2); // 1
arr.lastIndexOf(2); // 6
-
.forEach(element,index,array)遍历数组，参数为一个回调函数，回调函数有三个参数：当前元素、当期元素索引值、整个数组。改变原数组。
var arr = [1, 2, 3, 4, 5];
arr.forEach(function(value,i,array) {
arr[i] = value + 1
})
console.log(arr); // [2, 3, 4, 5, 6]
var a = [3, 4, 'hello', 'world']
a.forEach(function(value,i) {
a[i] = "" + value + value
});
console.log(a); // ['33', '44', 'hellohello', 'worldworld']
-
.map(function(element))与forEach类似，遍历数组，回调函数返回值组成一个新数组返回，新数组索引结构与原数组一致，原数组不变。
var arr = [1, 2, 3, 4, 5];
console.log(arr.map(function(val) {
return val * val
})); // [1, 4, 9, 16, 25]
console.log(arr); // [1, 2, 3, 4, 5]
var arr2 = [1, 2, 3, 4].map(function(val) {
return val + 'a'
});
console.log(arr2); // ['1a', '2a', '3a', '4a']
-
.every(function(element,index,array))与.some(function(element,index,array))都是回调函数，返回一个布尔值。
- every是所有函数的每个回调函数都返回true时才会返回true，当遇到false的时候终止执行，返回false。
var arr = [1, 2, 3, 4];
console.log(arr.every(function(val) {
return val > 0
})); // true
console.log(arr.every(function(val) {
return val > 1
})); // false
var arr = [2, 3, -4, 5, 6];
console.log(arr.every(function(val) {
return val > 0
})); // false,判断数组是否都为正数
- some是函数存在有一个回调函数返回true时终止执行，并返回true，否则返回false。
var arr = [1, 2, 3, 4];
console.log(arr.some(function(val) {
return val > 3
})); // true
console.log(arr.some(function(val) {
return val > 4
})); // false
注：在空数组上调用every返回true，some返回false。
-
.filter(function(element))返回数组的一个子集，回调函数用于逻辑判断是否返回，返回true则把当前元素加入到返回数组中，false则不加。
新数组只包含返回true的值，索引缺失的不包括，原数组保持不变。
var arr = [1, 2, 3, 4, 5, 6];
var arr2 = arr.filter(function(val) {
return val%2 == 0;
});
console.log(arr2); // [2, 4, 6]
console.log(arr); // [1, 2, 3, 4, 5, 6]
例子：生成新数组，年龄大于18岁；姓名中含“c”。
var students = [{name:'ad',age:10}, {name:'bb',age:20}, {name:'ca',age:8}, {name:'ce',age:5}];
var age18 = students.filter(function(val) {
return val.age > 18
});
console.log(age18); // [{name:'bb',age:20}]
var nameC = students.filter(function(val) {
return val.name.indexOf('c') > -1
});
console.log(nameC); // [{name:'ca',age:8}, {name:'ce',age:5}]
例子：生成新数组，只包含正数。
var arr = [3, -1, 2, '饥人谷', true];
var newarr = arr.filter(function(val) {
if((typeof(val) === 'number') && val > 0) {
return true
}
return false
});
console.log(newarr); // [3, 2]
-
.reduce(function(v1,v2),value)遍历数组，调用回调函数，将数组元素组合成一个值，reduce从索引最小值开始（reduceRight反向），方法有两个参数：回调函数，把两个值合为一个值，返回结果；value，初始值（可选）。
var arr = [1, 2, 3, 4, 5, 6];
var a = arr.reduce(function(v1,v2) {
return v1 + v2
});
console.log(a); // 21
var b = arr.reduceRight(function(v1,v2) {
return v1 - v2
},100); // 100为初始值，相当于v1
console.log(b); // 79
例子：写一个函数实现reduce功能。
var arr = [3, 4, 5, 6];
var result = reduce(arr,function(v1,v2) {
return v1 + v2
},10); // 10为initValue初始值
function reduce(arr,fn,initValue) {
var arr2 = arr.concat([]); // 拼接空数组，使arr2与arr元素相同，且操作arr2不改变原数组arr的值
if(initValue !== undefined) { // 如果initValue不等于undefined说明传入了初始参数
arr2.unshift(initValue) // 将初始值传到数组arr2的第一位
}
while(arr2.length > 1) { // '>1'说明至少有2个及以上元素
arr2.splice(0,2,fn(arr2[0],arr2[1])) // 从数组第一位开始，执行2次，替换成fn，即fn替换掉前两位元素
}
return arr2[0] // 返回数组第一位
};
console.log(result); // 28
例子：使用reduce方法，将嵌套多层的数组变成一层数组。
var arr = [3, [2, -4, [5, 7]], -3, ['aa', [['bb']]]];
var arr2 = flatten(arr);
function flatten(arr) {
return arr.reduce(function(initArr,currentArr) { // initArr为初始值，即为空数组[]，currentArr为遍历原数组时的第一个元素，即为3
return initArr.concat(Array.isArray(currentArr)?flatten(currentArr):currentArr) // Array.isArray(currentArr)?判断原数组中的元素是否为数组，flatten(currentArr)是，再递归循环一次，:currentArr不是，则concat拼接到空数组中
},[]) // 初始值为空数组
};
console.log(arr2); // [3, 2, -4, 5, 7, -3, "aa", "bb"]
