javascript数组

javascript的实现对数组做了很多优化，使得典型的数组操作可以很快（用类型化数组在执行时间和内存使用上会更加高效）

三种构造方式：

---

new Array()

new Array(size)

new Array(element,element.....)

eg:

var array = new Array()

var array = new Array(10)

var array = new Array(1,2,3);

var array = [1, 2, 3];

注意 1、 size设置数组元素的个数，返回数组元素的length等于size

　　 2、 改变数组的length属性会裁剪或者扩充数组

eg：

var array1 = new Array(10);
array1.push(1);
console.log("array1.length = " + array1.length);  //11
console.log("array1[9] = " + array1[9]);  //undefined

var array2 = new Array();
array2.push(1);
console.log("array2.length = " + array2.length);  //1

var array3 = new Array(10);
array3[0] = 1;
console.log("array3.length = " + array3.length);   //10

var array4 = [1, 2, 3];
array4.push(3,4);
console.log("array4.length = " + array4.length);  //5

var array5 = [1, 2, 3];
array5.length = 2;
console.log("array5[2] = " + array5[2]);  //undefined;

var array6 = [1, 2, 3];
array6.length = 10;
console.log("array6[9] = " + array6[9]);  //undefined;
console.log("array6.length = " + array6.length); //10

ECMAScript3 方法：

---

concat：衔接数组，返回新的数组

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

---

join()

[1,2,3].join("@@");  //1@@2@@3

---

pop()和push(): 1、pop移除数组最后一个元素，缩短数组长度；push()添加元素，元素追加在数组末尾

　　　　　　　　2、pop返回数组最后一个元素，push返回追加后数组的新长度

　　　　　　　　3、直接修改数组，不会创建新的数组

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

---

reverse()：反转数组元素，重新调整数组元素顺序，不会创建新的数组，返回调整后的数组

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

---

 shift和unshift：

　　1、shift()：移除并返回数组的第一个元素，并将后续元素向前移一位，如果数组为空，直接返回undefined，shift不会创建新的数组，而是直接修改数组

　　2、unshift(): 数组头部插入元素， 返回数组的长度

//shift
var a = [1, 2, 3];
a.shift(); //返回1，数组变为[2,3]

var a = new Array();
a.shift(); //返回undefined

//unshift
var a = [1, 2, 3];
a.unshift(4); //返回4， 数组为[4, 1, 2, 3]

---

 slice和splice

　　1、slice：返回数组一部分，返回新数组，注意下标的使用

　　2、splice：1、插入、删除或者替换数组元素, 注意区别于slice()

　　　　2、array.splice(start, deleteCount, value，...) 

　　　　3、start：开始删除或者插入元素的序号

　　　　4、deleteCount，要删除的元素的个数，如果是0表示添加元素

　　　　5、value:要插入数组的元素，一个或者是多个

　　     6、如果有删除数据，返回由删除数据构成的数组，如果没有删除数据，则返回[]

eg：

var a = [1, 2, 3, 4, 5, 6];
a.slice(0, 3); //[1, 2, 3]
a.slice(3); //[4, 5, 6]
a.slice(1, -1); //[2, 3, 4, 5] ，第二个参数为负数时即从数组尾部开始计算

//splice
var a = [1, 2, 3, 4, 5, 6];
a.splice(3); //a 变为[1, 2, 3] 返回[4, 5, 6]
a.splice(3, 2); //a 变为[1, 2, 3, 6] 返回[4, 5]
a.splice(1, 0, 3, 5); //a变为[1, 3, 5, 2, 3, 4, 5, 6] ；返回[]

使用slice将arguments转化为数组：

var toArray= function(){
    return Array.prototype.slice.call(arguments);
}

var array = toArray(1, 2, 3);
console.log(array instanceof Array); //true

---

sort：数组排序，返回数组引用，没有新建数组，不带参数时默认是按字母排序

//sort
var a = [11, 2, 3, "a"];
a.sort(); //[11, 2, 3, "a"]

var a = [11, 2, 3, "a"];
function orderByNumber(a, b){
    return a - b;
}
a.sort(orderByNumber); //[2, 3, 11, "a"]

---

toString 和 toLocalString

　　　　1、toString有必要时会调用元素的toString；等价于使用join()

　　　　2、toLocalString对数组每个元素调用toLocalString

//toString
[1, 2, 3].toString(); //"1,2,3"
[1, 2, 3].join(); //"1,2,3"

[1, 2, "a", [2, "b"]].toString(); //"1,2,a,2,b"

ECMAScript5 新增方法：

---

every(): 测试断言函数是否对于数组中每个元素为真，每个为真返回true，否则返回false

eg: 

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

[1, 2, 3].every(function(x){
    return x <3;
});   //false

---

filter(): 过滤不满足条件的数组元素，返回符合条件的数组

eg:

[1, 2, 3].filter(function(x){
    return x < 3;
});  //[1,2]

---

forEach(): 为每个数组元素调用一个函数，没有返回值

注意：1、forEach没有返回值

　　　2、对于forEach中每次调用的函数对于数组序号i有三个参数： f(array[i], i, array)

　　   3、forEach如果设定了第二个参数object，则在函数内的this指向object， 类似于map、 filter、every等

eg：

//forEach

[1, 2, 3].forEach(function(x){
    x++;  //return undefined;
});


var a = [1, 2, 3];
a.forEach(function(x,i, a){
    a[i]++;  //return undefined;
});
console.log("a = " + a); //2, 3, 4 

var b = [1, 2, 3];
b.forEach(function(x){
    console.log(x);
    x++;  //return undefined;
});
console.log("b = " + b); //1, 2, 3

---

indexOf()：查找数组，返回查找元素的下标

[1, 2 ,3].indexOf(1); //0;

[1, 2 ,3].indexOf(1, 1); //-1; 第二个参数是开始查找的下标

[1, 2 ,3].indexOf(4); //-1;

---

lastIndexOf()：反向查找数组，返回查找元素的下标

//lastIndexOf
[1, 2, 3].lastIndexOf(4);  //-1
[1, 2, 3].lastIndexOf(3);  //2
[1, 2, 3].lastIndexOf(3, 1); //-1 ,第二个参数设置开始查找的位置，1表示从倒数第二个数开始

---

map(): 从数组元素中计算新值，返回新的数组

[1, 2, 3].map(function(x){
    return x * x; //[1, 4, 9]
});

---

reduce()：1、从数组元素中计算新的值，返回最后一次调用f的返回值

　　　　　2、添加第二个参数时相当于传递给函数的初始值，结果等价于将第二个参数添加在数组的头部

　　        

//reduce
[1, 2, 3].reduce(function(x, y){
    return x * y; //(1*2)*3 = 6;
})
[1, 2, 3].reduce(function(x, y){
    return x + y; //(1+2)+3 = 6
})

[1, 2, 3].reduce(function(x, y){
    return x * y; //((6*1)*2)*3 = 36;
}, 6);

[1, 2, 3].reduce(function(x, y){
    return x + y; //((6+1)+2)+3 = 12
}, 6)

---

reduceRight()：原理类似于reduce，只是从右向左开始

//reduceRight
[1, 2, 3].reduceRight(function(x, y){
    return x * y; //(3*2)*1 = 6;
})
[1, 2, 3].reduceRight(function(x, y){
    return x + y; //(3+2)+1 = 6
})

[1, 2, 3].reduceRight(function(x, y){
    return x * y; //((6*3)*2)*1 = 36;
}, 6);

[1, 2, 3].reduceRight(function(x, y){
    return x + y; //((6+3)+2)+1 = 12
}, 6)

---

some()：判断是否有元素满足断言函数，至少有一个满足时返回true，否则返回false

//some
[1, 2, 3].some(function(x){
    return x > 2; //true
});

[1, 2, 3].some(function(x){
    return x > 3; //false
});