js数组方法有以下种类
1. Array.prototype.join 数组转为字符串
var arr = [1, 2, 3];
arr.join(); // "1,2,3"
arr.join("_"); // "1_2_3"
function repeatString(str, n) {
return new Array(n + 1).join(str);
}
repeatString("a", 3); // "aaa"
repeatString("Hi", 5); // "HiHiHiHiHi"
2. Array.prototype.reverse 将数组逆序
ar arr = [1, 2, 3];
arr.reverse(); // [3, 2, 1]
arr; // [3, 2, 1] 原数组修改
3. Array.prototype.sort 数组排序
var arr = ["a", "d", "c", "b"];
arr.sort(); // ["a", "b", "c", "d"]
arr = [13, 24, 51, 3];
arr.sort(); // [13, 24, 3, 51]
arr; // [13, 24, 3, 51]
arr.sort(function(a, b) {
return a - b;
}); // [3, 13, 24, 51]
arr = [{age : 25}, {age : 39}, {age : 99}];
arr.sort(function(a, b) {
return a.age - b.age;
});
arr.forEach(function(item) {
console.log('age', item.age);
});
// result:
// age 25
// age 39
// age 99
4. Array.prototype.concat 数组合并
ar arr = [1, 2, 3];
arr.concat(4, 5); // [1, 2, 3, 4, 5]
arr; // [1, 2, 3] 原数组未被修改
arr.concat([10, 11], 13); // [1, 2, 3, 10, 11, 13]
arr.concat([1, [2, 3]]); // [1, 2, 3, 1, [2, 3]]
5. Array.prototype.slice 返回部分数组
slice 参数 ： slice（start，end）；
slice 方法，在string对象和array对象 的用法上类似。
对于数组对象来说，slice 方法提取 从 start下标起 以end下标 为结尾的 一段元素（但不包括end下标的元素），然后返回新的数组，对原数组没有任何是影响，
当参数为负时 则该参数 是从 数组的末尾 索引 开始算起，（-1 指的是 数组中倒数第一个元素， -2 指的是，数组中倒数第二个元素。）
当参数为一个参数，当为一个参数时，提取 是以 start下标起 至末尾的 部分元素。
当start 为0 时， 等于说是 克隆一个新的数组，克隆后 两个数组进行各自的操作，都互不影响，
var clone = array.slice(0)；
var arr = [1, 2, 3, 4, 5];
arr.slice(1, 3); // [2, 3]
arr.slice(1); // [2, 3, 4, 5]
arr.slice(1, -1); // [2, 3, 4]
arr.slice(-4, -3); // [2]
//原数组未被修改
6. Array.prototype.splice 数组拼接
splice 的参数 ：splice (start, deleteCount, [item1[, item2[, . . . [,itemN]]]])
数组从 start下标开始，删除deleteCount 个元素，并且可以在这个位置开始添加 n个元素
当start ,deleteCount 均为0 的时候，也就是在数组的最前面插入新的元素。
当 参数只有 start，deleteCount 就是从start 下标开始删除deleteCount 个数组的元素，
当参数只有start参数时，就是删除 从start下标起至最后 的元素
当参数 为负的时 则该参数规定的是从数组元素的尾部开始算起的位置 （-1 指的是 数组中倒数第一个元素， -2 指的是，数组中倒数第二个元素。）
var arr = [1, 2, 3, 4, 5];
arr.splice(2); // returns [3, 4, 5]
arr; // [1, 2];
arr = [1, 2, 3, 4, 5];
arr.splice(2, 2); // returns [3, 4]
arr; // [1, 2, 5];
arr = [1, 2, 3, 4, 5];
arr.splice(1, 1, 'a', 'b'); // returns [2]
arr; // [1, "a", "b", 3, 4, 5]
可以看出 slice和splice在数组截取时结果相同
7. Array.prototype.forEach 数组遍历
var arr = [1, 2, 3, 4, 5];
arr.forEach(function(x, index, a){
console.log(x + '|' + index + '|' + (a === arr));
});
// 1|0|true
// 2|1|true
// 3|2|true
// 4|3|true
// 5|4|true
8.Array.prototype.map 数组映射
var arr = [1, 2, 3];
arr.map(function(x) {
return x + 10;
}); // [11, 12, 13]
arr; // [1, 2, 3]
9.Array.prototype.fileter 数组过滤
var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
arr.filter(function(x, index) {
return index % 3 === 0 || x >= 8;
}); // returns [1, 4, 7, 8, 9, 10]
arr; // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
10 . Array.prototype.every & some 数组判断
var arr = [1, 2, 3, 4, 5];
arr.every(function(x) {
return x < 10;
}); // true
arr.every(function(x) {
return x < 3;
}); // false
var arr = [1, 2, 3, 4, 5];
arr.some(function(x) {
return x === 3;
}); // true
arr.some(function(x) {
return x === 100;
}); // false
11. Array.prototype.reduce&reduceRight
max = arr.reduceRight(function(x, y) {
console.log(x + "|" + y);
return x > y ? x : y;
});
// 6|9
// 9|3
max; // 9
var arr = [1, 2, 3];
var sum = arr.reduce(function(x, y) {
return x + y
}, 0); // 6
arr; //[1, 2, 3]
arr = [3, 9, 6];
var max = arr.reduce(function(x, y) {
console.log(x + "|" + y);
return x > y ? x : y;
});
// 3|9
// 9|6
max; // 9
12 Array.prototype.indexOf&lastIndexOf 数组检索
var arr = [1, 2, 3, 2, 1];
arr.indexOf(2); // 1
arr.indexOf(99); // -1
arr.indexOf(1, 1); // 4
arr.indexOf(1, -3); // 4
arr.indexOf(2, -1); // -1
arr.lastIndexOf(2); // 3
arr.lastIndexOf(2, -2); // 3
arr.lastIndexOf(2, -3); // 1
13. Array.isArray 判断是否为数组
Array.isArray([]); // true
[] instanceof Array; // true
({}).toString.apply([]) === '[object Array]'; // true
[].constructor === Array; // true