JavaScript引用类型——Array类型

Array类型

除了Object之外，Array类型恐怕是ECMAScript中最常用的类型了。ECMAScript数组的每一项可以保存任何数据类型的数据。ECMAScript数组的大小是可以动态调整的，即可以随着数据的添加自动增长以容纳新数据。
创建数组的基本方式有两种。第一种是使用Array构造函数，如：

var color = new Array();
var color = new Array(20); //length值为20的数组
var color = new Array("red", "blue", "green");
var colors = new Array(3); //创建一个包含3项的数组
var names = new Array("Icey"); //创建一个包含1项，即字符串"Icey"的数组

在使用Array构造函数是也可以省略new操作符。如：

var colors = Array(3);  //创建一个包含3项的数组
var names = Array("Icey"); ///创建一个包含1项，即字符串"Icey"的数组

创建数组的第二种基本方式是使用数组字面量表示法。如：

var colors = ["red", "blue", "green" ];
var names = [];
var values = [1, 2, ]; //不要这样，这样会创建一个包含2或3项的数组
var values = [,,,,,,];//不要这样，这样会创建一个包含5或6项的数组

使用数组字面量表示法时，也不会调用Array构造函数。

var colors = ["red", "blue", "green" ];
alert(colors[0]);
colors[2] = "black";
colors[3] = "brown";

数组的项数保存在其length属性中，这个属性始终会返回0或更大的值，如：

var colors = ["red", "blue", "green" ];
var names = [];

alert(colors.length); //3
alert(names.length); //0

数组的length属性很有特定——它不是只读的。因此，通过设置这个属性，可以从数组的末尾移除项或项数组中添加新项。如：

var colors = ["red", "blue", "green"];
colors.length = 2;
alert(colors[2]); //undefined

var colors = ["red", "blue", "green"];
colors.length = 4;
alert(colors[3]); //undefined

利用 length属性也可以方便的在数组末尾添加新项，如：

var colors = ["red", "blue", "green"];
colors[colors.length] = "black";
alert(colors[colors.length]); //"black"

由于数组最后一项的索引值始终是length-1,因此下一个新项的位置就是length。

var colors = ["red", "blue", "green"];
colors[99] = "black";
alert(colors.length); //100

- **1. 检测数组 **
方法一：

if (value instanceof Array) {
//对数组执行某些操作
}

方法二：

if(Array.isArray(value)){
//对数组执行某些操作
}

- **2. 转换方法 **
所有对象都具有toLocalString()、toString()和valueOf()方法。其中，调用toString()方法会返回有数组中每个值的字符串形式拼接而成的一个以逗号分隔的字符串。而调用valueOf()方法返回的还是数组。实际上，为了创建这个字符串会调用数组每一项的toString()方法。如：

var colors = ["red", "blue", "green"];
alert(colors.toString()); //red,bule,green
alert(colors.valueOf()); //red,blue,green
alert(colors); //red,blue,green

由于alert()要接收字符串参数，所以它会在后台调用toString()方法，由此会得到与直接调用toString()方法相同的结果。

var person1 = {
toLocaleString : function () {
return "Icey";
},
toString : function(){
return "icey";
}
};

var person2 = {
toLocaleString: function(){
return "Root";
},
toString : function(){
"root";
}
};

var people = [person1, person2];
alert(people); //icey,root
alert(people.toString); //icey,root
alert(people.toLocaleString); //Icey,Root

***join()方法***

var colors = ["red", "green", "blue"];
alert(colors.join(",")); //red,green,blue
alert(colors.join("||")); //red||green||blue

- **3. 栈方法 **
栈是一种后进先出的数据结构，栈中项的插入和移除只发生在栈顶。ECMAScript为数组专门提供了**push()**和**pop()**方法，以便实现类似栈的数据结构。
push()方法可以接收任意数量的参数，把它们逐个添加到数组末尾，并返回**修改后数组的长度**。
pop()方法从数组末尾移除最后一项，减少数组的length值，返回返回**移除的项**。

var colors = new Array();
var count = colors.push("red", "green");
alert(count); //2

count = colors.push("blue");
alert(count); //3

var item = colors.pop();
alert(item); //"blue"
alert(colors.length); //2

可以将栈方法与其他数组方法连用，如：

var colors = ["red", "blue"];
colors.push("green");
colors[3] = "black";
alert(colors.length); //4

var item = colors.pop();
alert(item); //"black"

- **4. 队列方法 **
队列的数据结构的访问规则是先进先出。队列在列表的末端添加项，从列表的前端移除项。
push()方法向数组末端添加项，使用shift()方法从数组前端取得项。
shift()它能够移除数组中的第一个项并返回该项，同时将数组长度减1.结合使用push()和shift()，可以像使用队列一样使用数组。

var colors = new Array();
var count = colors.push("red", "green");
alert(count); //2

count = colors.push("blue");
alert(count); //3

var item = colors.shift();
alert(item); //red
alert(colors.length); //2

ECMAScript 还提供了unshift()方法，顾名思义，unshift()与shift()的用途相反：它能在数组前端添加任意个项并返回数组的长度。因此，同时使用unshift()和pop()方法，可以从相反的方向来模拟队列，即在数组的前端添加项，从数组末端移除项，如：

var colors = new Array();
var count = colors.unshift("red", "green");
alert(count); //2

count = colors.unshift("blue");
alert(count); //3

var item = colors.pop();
alert(item); //green
alert(colors.length); //2

- **5. 重排序方法 **

数组中已经存在两个可以直接用来直接重排序的方法：**reverse()**和**sort()**。

- reverse()方法反转数组项的顺序

var values = [1, 2, 3, 4, 5];
values.reverse();
alert(values); //5,4,3,2,1

- sort()方法，默认情况下按升序排列数组——即最小值位于最前面，最大值位于最后面。为了实现排序，sort()方法会调用每个数组项的toString()转型方法，然后比较得到的字符串，以确定如何排序。即使数组中的每一项都是数值，sort()方法比较的也是字符串，如：

var values = [0, 1, 5, 10, 15];
values.sort();
alert(values); //0,1,10,15,5

sort()方法可以接收一个比较函数作为参数。
比较函数接收两个参数，如果第一个参数应该位于第二个之前则返回一个负数，如果两个参数相等则返回0，如果第一个参数应该位于第二个参数之后则返回一个正数。如：

function compare(value1, value2) {
if(value1 < value2){
return -1;
}else if(value1 > value2){
return 1;
}else{
return 0;
}
}

var values = [0, 1, 5, 10, 15];
values.sort(compare);
alert(values); //0,1,5,10,15

也可以通过比较函数产生降序结果，如：

function compare(value1, value2) {
if(value1 < value2){
return 1;
}else if(value1 > value2){
return -1;
}else{
return 0;
}
}

var values = [0, 1, 5, 10, 15];
values.sort(compare);
alert(values); //15,10,5,1,0

对于数值类型或者其valueOf()方法会返回数值类型的对象类型，可以使用一个更简单的比较函数。

function compare(value1, value2) {
return value2 - value1;
}

- **6. 操作方法 **

ECMAScript 为操作已经包含在数组中的项提供了很多方法。
- **concat()**方法:可以基于当前数组中的所有项创建一个新数组。具体来说，这个方法会先创建当前数组的一个副本，然后将接收到的参数添加到这个副本的末尾，最后返回新构建的数组。在没有给concat()方法传递参数的情况下，它只是复制当前数组并返回副本。

var colors = ["red", "green", "blue"];
var colors2 = colors.concat("yellow", ["black", "brown"]);

alert(colors); //red,green,blue
alert(colors2); //red,green,blue,yellow,black,brown

- **slice()**方法：能够基于当前数组中的一或多个项创建一个新数组。slice()方法可以接受一个或两个参数，即要返回项的起始和结束位置。在只有一个参数的情况下，slice()方法返回从该参数指定位置开始到当前数组末尾的所有项。如果有两个参数，该方法返回起始和结束位置之间的项——但不包括结束位置的项。slice()方法不会影响原始数组。如:

var colors = ["red", "green", "blue", "yellow", "purple"];
var colors2 = colors.slice(1);
var colors3 = colors.slice(1,4);
alert(colors2); //green,blue,yellow,purple
alert(colors3); //green,blue,yellow

如果slice()方法中有一个负数,这用数组长度加上该数来确定相应的位置。如果结束位置小于起始位置，则返回空数组。

- **splice()**方法：
- 删除：可以删除任意数量的项，只需要指定两个参数：要删除的第一项的位置和要删除的项数。如：splice(0,2)会删除数组中的前两项。
- 插入：可以向指定位置插入任意数量的项，只需提供3个参数：起始位置、0（要删除的项数）和要插入的项。例如：splice(2,0,"red","green")会从当前数组的位置2开始插入字符串"red","green".
- 替换：可以向指定位置插入任意数量的项，且同时删除任意数量的项，只需提供3个参数：起始位置、要删除的项数和要插入的任意数量的项。例如：splice(2,1,"red","green")。
splice()方法始终都会返回一个数组，该数组中包含从原始数组中删除的项（如果没有删除任何项，则返回一个空数组）。

var colors = ["red", "green", "blue"];
var removed = colors.splice(0,1);
alert(colors); //green,blue
alert(removed); //red
removed = colors.splice(1,0,"yellow","orange");
alert(colors); //green,yellow,orange,blue
alert(removed); //返回一个空数组[]
removed = colors.splice(1,1,"red","purple");
alert(colors); //green,red,purple,orange,blue
alert(removed); //yellow

- **7.位置方法 **
ECMAScript5为数组添加两个位置方法：**indexOf()**和**lastIndexOf()**。这两个方法都接收两个参数：要查找的项和（可选的）表示查找起点位置的索引。其中，indexOf()方法从数组的开头（位置0）开始向后查找，lastIndexOf()方法则从数组的末尾开始向前查找。
这两个方法都返回要查找的项在数组中的位置，或者在没有的情况下返回-1比较是使用全等操作符（===）。

var numbers = [1,2,3,4,5,4,3,2,1];
alert(numbers.indexOf(4)); //3
alert(numbers.lastIndexOf(4)); //5
alert(numbers.indexOf(4,4)); //5
alert(numbers.lastIndexOf(4,4)); //3
var person = {name : "Icey"};
var people = [{name : "Icey"}];
var morePeople = [person];
alert(people.indexOf(person)); //-1
alert(morePeople.indexOf(person)); //0

- **8. 迭代方法 **
ECMAScript5为数组定义了5个迭代方法。每个方法都有两个参数：要做每一项上运行的函数和（可选的）运行该函数的作用域对象——影响this的值。传入这些方法中的函数会接收三个参数：数组项的值、该项在数组中的位置和数组对象本身。根据使用的方法不同，这个函数执行后的返回值可能会也可能不会影响方法的返回值。以下是5个迭代方法的作用。
 - every()：对数组中每一项运行给定函数，如果该函数对每一项都返回true,则返回true。
 - filter()：对数组中每一项运行给定函数，返回该函数会返回true的项组成的数组。
 - forEach()：对数组中每一项运行给定函数。这个方法没有返回值。
 - ma()：对数组中每一项运行给定函数，返回每次函数调用的结果组成的数组。
- some()：对数组中每一项运行给定函数，如果该函数对任一项返回true,则返回true。
以上方法都不会修改数组中的包含的值。

var numbers = [1,2,3,4,5,4,3,2,1];
var everyResult = numbers.every(function (item,index,array) {
return (item>2);
});

alert(everyResult); //false

var someResult = numbers.some(function (item,index,array) {
return (itme>2);
});
alert(someResult); //true

var numbers = [1,2,3,4,5,4,3,2,1];
var filterResult = numbers.filter(function (item,index,array) {
return (item>2);
});
alert(filterResult); //[3,4,5,4,3]

var numbers = [1,2,3,4,5,4,3,2,1];
var mapResult = numbers.map(function (item,index,array) {
return item*2;
});
alert(mapResult); //[2,4,6,8,10,8,6,4,2]

var numbers = [1,2,3,4,5,4,3,2,1];
numbers.forEach(function (item,index,array) {
//执行某些操作
})

- **9. 归并方法 **
ECMAScript5 还新增了两个归并数组的方法：**reduce()**和**reduceRight()**。这俩个方法都会迭代数组的所有项，然后构建一个最终返回的值。reduce()方法从数组第一项开始，逐个遍历到最后。reduceRight()从数组最好一项开始，向前遍历到第一项。
这两个方法都接收两个参数：一个在每一项上调用的函数和（可选的）作为归并基础的初始值。传给reduce()和reduceRight()的函数接收4个参数：前一个值，当前值，项的索引和数组对象。这个函数返回的任何值都会最为第一个参数自动传给下一项。第一次迭代发生在数组的第二项上，因此第一个参数是数组的第一项，第二个参数是数组的第二项。

var values = [1,2,3,4,5];
var sum = values.reduce(function (prev,cur,index,array) {
return prev+cur;
})
alert(sum); //15

var values = [1,2,3,4,5];
var sum = values.reduceRight(function (prev,cur,index,array) {
return prev+cur;
})
alert(sum); //15