JavaScript权威指南--数组Array

什么是数组

数组是值的有序集合。每一个值叫做元素，每一个元素在数组中有一个位置，用数字表示，称为索引。js数组是无类型的、动态的，也可能是稀疏的。每个数组都有length属性。数组最大能容纳4294967294(2^32 - 2)。数组继承自Array.prototype。里面的方法不仅对数组有效。类数组对象同样有效。

数组特性：自动更新length属性；length较小将截断数组；类属性为Array；从Array.prototype中继承属性。

创建数组

    1）使用数组直接量

var arr = []; // 空数组
var a = 123;
var arr2 = [a, 1, '1', true,[{x : 2}]]; // 定义数组可使用对象，变量，常用数据类型
var arr3 = [1, , 3] // 中间省略的值直接被赋予undefined

    2)调用构造函数Array

var arr4 = new Array(); // 空数组
var arr5 = new Array(10); // length,预分配数组空间
var arr6 = new Array(5, 5);

数组元素的读和写

var arr6 = new Array(3, 5);
console.log(arr6[1]); // 5
arr6[3] = 6;
console.log(arr6[3]); // 6

稀疏数组

稀疏数组是包含从0开始的不连续索引的数组。可以使用Array()构造函数或指定数组的索引值大于当前的数组长度来创建稀疏数组。（很少用，一般当做包含undefined值的非稀疏数组对待）

var a = [];
var a[10] = 12;

var a = new Array(5);

数组长度

a = [1, 2, 3]
console.log(a.length); // 3 
Object.defineProperty(a, 'length', {writable:false}) // 只读
a.length = 0;
console.log(a.length); // 3 

数组的增加和删除

1）增加

a = []; // 开始是空数组
a[0] = 1; // 增加一个元素 改变原数组 a = [1]

a = []; // 开始是空数组
a.push('1') //在末尾追加一个元素,改变元素组 a=['1']

2）删除

a = [0, 1, 2, 3]
delete a[1]; // a[1, empty, 2, 3]， delete删除不会改变数组长度,只是使该数组变成稀疏数组

数组遍历

1) for

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

        if(!a[i]) continue; // 跳过null和undefined的元素
        if(a[i] === undefined) continue; // 跳过undefined元素
        if(!(i in a)) continue //跳过不存在的元素

2) forEach

var data= [1, 2, 3, 4];
data.forEach(function(x){ // 把每个元素作为参数传入
        console.log(x）；

})

多维数组

javascript不支持真正的多维数组，饭可以使用数组的数组来近似。

var table = new Array(10) //10行
for(var i=0; i<table.length;i++){
      table[i] = new Array(10)
}  // 每行10列
for (var i=0;i<table.length; i++) {
     for(var j=0;j<table[i].length; j++) {
          table[i][j] = i * j;
     }
}
console.log(table);

数组方法

1)ECMAScript3

join() : 将数组中所有元素转化为字符串并连接在一起，返回最后生成的字符串，不改变原数组。可指定连接元素符号，默认为逗号。

var aa = [1, 2, 3, 4];  
var b = aa.join();  // 1,2,3,4
var c = aa.join('');  // 1234
var d = aa.join(' ');  // 1 2 3 4
var e = aa.join('_');  // _2_3_4

reverse() : 颠倒数组元素的顺序，返回逆序的数组，改变了原数组

var a = [1, 2, 3, 4]; 
a.reverse();  // [4, 3, 2, 1]

 sort() : 将数组元素排序返回排序后的数组。如果有undefined，会被排在尾部。改变原数组。

//按照字母表顺序排序
var a = new Array('pineapple', 'banana', 'apple');
a.sort();  // ["apple", "banana", "pineapple"]

//按照字母表顺序排序
var a = [1, 2, 3, 4, 111,333, 323];
a.sort();  // [1, 111, 2, 3, 323, 333, 4]

// 区分字母大小写
var a = ['Dog', 'big','apple','Cat']
a.sort();  // ["Cat", "Dog", "apple", "big"]

// 数字从小到大排序
var a = [1, 2, 3, 4, 111,333, 323];
a.sort(function(a,b){
      return a-b;  // 根据顺序返回负数 0 正数
})

//字母不区分大小写
var a = ['Dog', 'big','apple','Cat'];
a.sort(function(a, b){
      var s = a.toLowerCase();
      var t = b.toLowerCase();
      if(s>t){
           return -1
      }
      if(s<t){
           return 1;
      } 
     return 0; 
})  // ["Dog", "Cat", "big", "apple"]

concat() : 创建并返回新数组

var a = [1, 2, 3, 4]; 
var b = a.concat([23, 24],45);
console.log(a); // [1, 2, 3, 4]
console.log(b); // [1, 2, 3, 4, 23, 24, 45]

slice(a, b) : 返回指定数组的一个片段或子数组. 两个参数指定开始和结束位置。负数表示相对于数组最后一个元素的位置。不改                        变原数组

var a = [1, 2, 3, 4, 5];
var b = a.slice(1, 4);  // [2, 3, 4]
var c = a.slice(2); // [3, 4, 5]
var d = a.slice(1, -1); // [2, 3, 4]
var e = a.slice(-1, 1); // []
console.log(a) // [1, 2, 3, 4, 5]

splice(a, b) : 在数组中插入或删除元素, 第一个参数指定插入或删除的开始位置，第二参数指定从该数组删除元素的个数。返回删                        除的元素组成的数组。改变了原数组。

var a = [1, 2, 3, 4, 5];
a.splice(4); // a: [1, 2, 3, 4]; 返回 [5]
a.splice(1,2); // a:[1, 4]; 返回 [2, 3]
a.splice(2,0,'a','b'); //a:[1, 4, "a", "b"]; 返回 []
a.splice(2,1, [1,2], 3, 5);  // a: [1, 4, [1, 2], 3, 5, "b"]; 返回 ['a']

push() : 在数组尾部增加元素，返回新的数组长度。改变原数组。

pop() : 删除数组最后一个元素，返回删除的元素。改变原数组。

push与pop实现先进后出的栈。

var stack = [];
stack.push(1,2,3,4);  //返回4
stack.pop();  //返回4
stack.push([5,4]);  //返回4
stack.pop();  // 返回[5, 4]

unshift() :在数组的头部一次性增加一个或多个元素，返回新数组的长度。改变原数组

shift() : 在数组的头部删除一个元素，返回删除的元素。修改数组索引，改变原数组

var a = [1, 3]
a.unshift(12,34); // a: [12, 34, 1, 3] ; 返回 4
a.shift();  // a: [34, 1, 3] ; 返回 12

toString() 和 toLocaleString() : 将每个元素转化为字符串.

[1, 2, 3].toString();  // "1,2,3"
[1, 2, 3].toLocaleString();  // "1,2,3"
['1','2', '3'].toString();  // "1,2,3"
['1','2',3, 4, [5, 6]].toString();  // "1,2,3,4,5,6"

2)ECMAScript5新增

forEach() : 遍历数组，为每个元素调用指定的函数。三个参数：数组元素、元素的索引、数组本身。

var data= [1, 2, 3, 4];
data.forEach(function(x){ // 把每个元素作为参数传入
      console.log(x）；
})

map() : 将调用的数组元素传递给指定的函数，返回一个新数组。

1 var a = [1, 2, 3, , 5]; // [1, 2, 3, empty, 5] 2 var b = a.map(function(x) {return 2*x}); // [2, 4, 6, empty, 10]

filter() : 调用数组的一个子集，返回布尔值。若为true返回稠密数组。不改变原数组。

var a = [1, 2, 3, , 5, 'z',[1, 2]];
        var s = a.filter(function(x) {
            return x < 4
        });  // [1, 2, 3]

every(),some() : 对数组元素应用指定的函数进行判断返回布尔值。every（&&）；some(||)

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

  5 a.some(isNaN); // false

reduce()：使用指定的函数将数组进行组合,生成单个值。按照索引从左到右。两个参数第一个为操作的函数，第二个参数可选为传递给函数的初始值。

var a = [1, 2, 3, 4, 5];
var sum = a.reduce(function(x,y) {return x+y}, 0);  // 15
var max = a.reduce(function(x,y) {return (x>y)?x:y;});  // 5

reduceRight(): 按照索引从右到左。

indexOf(),lastIndexOf() : 寻找某个值的第一个索引，如果没有就返回-1，indexOf从头至尾搜索。lastIndexOf反向搜索。

数组类型

isArray([])判断是否为数组