JavaScript数组

r数组元素的增删：

arr.push()方法：数组尾部加一个元素
arr.unshift()方法：数组头部加一个元素

var arr = [];
arr[0] = 1;
arr[1] = 2;
arr.push(3);
arr; // [1, 2, 3]

arr[arr.length] = 4; // equal to arr.push(4);
arr; // [1, 2, 3, 4]

arr.unshift(0);
arr; // [0, 1, 2, 3, 4];

arr.pop()方法：数组尾部减一个元素
arr.shift()方法：数组头部减一个元素

delete arr[2];   //只会删除元素，数组长度不会变
arr; // [0, 1, undefined, 3, 4]

 

数组迭代

var i = 0, n = 10;
var arr = [1, 2, 3, 4, 5];
for (; i < n; i++) {
    console.log(arr[i]); // 1, 2, 3, 4, 5
}

for(i in arr) {
    console.log(arr[i]); // 1, 2, 3, 4, 5
}

二维数组：

二维数组的遍历

var arr = [[0, 1], [2, 3], [4, 5]];                  //row 0
var i = 0, j = 0;　　　　　　　　　　　　　　　　　　　　　 //0
var row;　　　　　　　　　　　　　　　　　　　　　　　　　　　//1
for (; i < arr.length; i++) {　　　　　　　　　　　　　　 //row 1
     row = arr[i];　　　　　　　　　　　　　　　　　　　　　//2
     console.log('row ' + i);　　　　　　　　　　　　　　 //3
     for (j = 0; j < row.length; j++) {              //row 2　　
          console.log(row[j]);                       //4
     } 　　　　　　　　　　　　　　　　　　　　　　　　　　　 //5
}

arr.join(); //将数组转为字符串

var arr = [1, 2, 3];
arr.join("_"); // "1_2_3"

创建一个n+1大小的数组，若用join()方法会产生含n个“,”的字符串，而str正代替这些“,”以造成重复n次str参数的字符串。

function repeatString(str, n) { return new Array(n + 1).join(str); } repeatString("a", 3); // "aaa"

arr.reverse(); //将数组逆序，原数组会被修改

arr.sort(); //排序，原数组会被修改

默认按照字母顺序排序（会把数字转化为字符串排序）

arr = [13, 24, 51, 3];
//升序排列

arr.sort(function(a, b) {
     return a - b;
}); // [3, 13, 24, 51]

排列对象的顺序

arr = [{age : 25}, {age : 39}, {age : 99}];　　　　//age 25
arr.sort(function(a, b) {　　　　　　　　　　　　　　 //age 39
     return a.age - b.age;                       //age 99
});
arr.forEach(function(item) {
     console.log('age', item.age);
});

数组连接 arr.concat()，数组不会被修改

var 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]]

 

arr.slice(); //截取 返回两个index之间部分数组，左闭右开区间,原数组未被修改 

var arr = [1, 2, 3, 4, 5];
arr.slice(1, 3); // [2, 3]

arr.splice();  数组截取拼接(原数组被修改)

var arr = [1, 2, 3, 4, 5];
arr.splice(2); // returns [3, 4, 5]
arr; // [1, 2];

arr.splice(2, 2); // returns [3, 4]  开始位置/删除元素的个数
arr; // [1, 2, 5];

arr.splice(1, 1, 'a', 'b'); // returns [2]   开始位置/删除元素的个数/在原位置上添加的元素
arr; // [1, "a", "b", 3, 4, 5]

数组遍历  arr.forEach()

var arr = [1, 2, 3, 4, 5];
arr.forEach(function(x ){
    console.log(x);
});

数组映射  arr.map()  数组不会改变

var arr = [1, 2, 3];
arr.map(function(x) {
     return x + 10;
}); // [11, 12, 13]

数组过滤  arr.filter()  数组不会改变

var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
arr.filter(function(x, index) {
     return index % 3 === 0;    //索引%3===0；
}); // returns [1, 4, 7, 10]

数组判断 arr.every()/arr.some()   数组不会被修改

var arr = [1, 2, 3, 4, 5];
arr.every(function(x) {
     return x < 10;
}); // true

arr.some(function(x) {
     return x === 3;
}); // true

arr.reduce()  数组不会被修改

//数组求和
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

 

indexOf 数组的检索 
indexOf（a,b）;a 是查找的元素  b是开始查找的位置  正数从左数的位置  负数从右数的位置
indexOf(元素)； 返回的是元素的下标 不存在返回-1
lastIndexOf 从右往左查

 

判断是否是数组有 
1. Array.isArray(arr)
2. arr instanceof Array   
3. Object.prototype.toString.apply(arr) 
4. arr.constructor === Array