创建与读取

Array构造函数创建

var colors = new Array();

可以直接定义数组数量，例如，下面代码将创建length值为20的数字。

var colors = new Array(20);

或者向构造函数中传递数组应该包含的项。

var colors = new Array("red","blue","green");

构造函数传递一个值也可以创建数组

• 如果传递的是数值，则将按照该数值创建包含给定项数的数值；

var colos = new Array(3);   // 创建一个包含3项的数组

• 如果传递的是其他类型参数，则会创建包含该参数且只有一项的数组

var colos = new Array("Greg");   // 创建一个包含1项，字符串"Greg"的数值。

对象字面量

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

设置和读取数组的值

var colors = ["red","blue","green"];
console.log(colors[0]);

colors[2] = "black";
colors[3] = "brown";

数组的长度保存在length属性中，这个属性始终返回0或更大的值。

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

console.log(colors.length);     // 3
console.log(name.length);       // 0

数组的length属性，它不是只读的。因此，通过设置属性，可以从数组末尾移除项或添加项目。

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

将length设置为2后会移除最后一项，所以在访问colors[2]就会显示undefined。

如果将length属性设置为大于数组长度的值，那么新增每一项默认值为undefined。

利用length属性在数组末尾添加新项

var colors = ["red","blue","green"];
colors[colors.length] = "black";
colors[colors.length] = "brown";

console.log(colors);    // ["red", "blue", "green", "black", "brown"]

数组最多可以包含4 294 967 295个项，这几乎满足任何需求了，如果超过上限，就会抛出异常，并且创建接近这个长度的数组，则可能导致运行时间超长的脚本错误。

检测数组

使用instanceof检测的问题

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

instanceof操作符问题在于，它假定只有一个全局执行环境。如果网页包含多个框架，那实际上就存在两个以上不同的全局执行环境，从而存在两个以上不同版本的Array构造函数，如果你从一个框架向另一个框架传入一个数组，那么传入的数组与在第二个框架中原生创建的数组分别具有各自不同的构造函数。

为了解决这个问题，ES5新增了Array.isArray()方法。这个方法检测某个值是不是数组，而不管它是哪个全局执行环境中创建的。

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

转换数组
所有对象都有toLocalsString()，toString() ，valueOf()方法，其中调用valueOf()返回的还是数组本身，而调用数组的toString()方法会返回由数组中每个值的字符串形式拼接而成的一个以逗号分隔的字符串。

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

console.log(colors.toString());  // red,blue,green
console.log(colors.valueOf());   // red,blue,green
console.log(colors);             // red,blue,green

首先调用了toString()方法，以便返回数组的字符串表示，每个字符串表示拼接为一个字符串，中间以逗号分隔。
接着调用valueOf()方法，最后一行代码直接将数组传递到了console.log()。由于console接收字符串参数，所以会在后代调用toString方法，由此会得到toString方法相同的结果。

toLocaleString()方法
toLocaleString()方法也会返回与toString和valueOf相同的值，但也不总是如此。调用数组的toLocaleString()方法时，也会创建一个数组值的以逗号分隔的字符串。而与之前不同的是，为了取得每一项的值，调用的是每一项的toLocaleString()方法，而不是toString方法。

var person1 = {
    toLocaleString : function() {
        return "Nikolaos";
    },
    toString : function() {
        return "Nicholas";
    }
};
var person2 = {
    toLocaleString : function() {
        return "Grigorios";
    },
    toString : function() {
        return "Greg";
    }
};

var people = [person1,person2];

console.log(people);                    // Nicholas,Greg
console.log(people.toString());         // Nicholas,Greg
console.log(people.toLocaleString());   // Nikolaos,Grigorios

栈方法

数组可以表现得像栈一样，可以限制插入和删除项的数据结构。栈是一种LIFO（last-in-first-out，后进先出）的数据结构。栈中项的推入和移除，只发生在一个位置——栈的顶部。ECMA为数组专门提供了push()和pop()方法，以便实现类似栈的行为。

push()方法接收任意数量的参数，把它们逐个添加到数组末尾，并返回修改后数组的长度。而pop()方法则从数组末尾移除最后一项，减少length值，返回移除的项。

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

count = colors.push("black");
console.log(count);     // 3

var item = colors.pop();        // 取得最后一项
console.log(item);              // "black"
console.log(colors.length);     // 2

可以将栈方法与其他数组方法连用。

var colors = ["red","blue"];
colors.push("brown");
colors[3] = "black";
console.log(colors.length);     // 4

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

队列方法

栈数据结构访问规则是LIFO，而队列数据结构访问规则是FIFO（First-in-first-Out，先进先出），队列在列表的末端添加项，从列表的前端移除项，由于push()是向末尾添加项的方法，因此要模拟队列只需要一个从数组前端取得项的方法。实现这一操作的数组方法就是shift()，他能移除数组中第一个并返回该项，同时数组长度减1。结合使用shift()和push()方法，可以像使用队列一样使用数组。

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

count = colors.push("black");
console.log(count);         // 3

var item = colors.shift();
console.log(item);          // "red"
console.log(colors.length); // 2

ECMAScript还为数组提供一个unshift()方法。它能在前端添加任意个项并返回新数组的长度。因此，同时使用unshift()和pop()方法，可以从相反的方向模拟阵列。即在数组的前端添加项，从数组末端移除项。

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

count = colors.unshift("black");
console.log(count);     // 3

var item = colors.pop()
console.log(item);      // 2
console.log(colors.length); // 2

重排序方法

reverse()
reverse()会反转数组顺序。

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

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

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

虽然数值5小于10，但在字符串比较时，"10"位于"5"前面，于是顺序就被修改了。sort()可以接受一个比较函数，以便指定顺序。
比较函数接受两个参数，如果第一个参数应该位于第二个之前则返回一个负数，如果两个参数相等则返回0，如果第一个参数位于第二个之后则返回一个正数。

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

这个比较函数适用大多数数据类型，只要将其作为参数传递给sort()方法即可，如下面：

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);
console.log(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);
console.log(values);    // 15,10,5,1,0

对于数值型或者valueOf()方法会返回数值类型的对象类型，可以用一个更简单的比较函数，这个函数只要第二个值减第一个值即可。

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

操作方法

concat()

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

console.log(colors);        // red,green,blue
console.log(colors2);       // red,green,blue,yellow,black,brown

slice()
接受两个位置参数，返回起始和结束位置。（不包括结束位置的项）
在一个参数情况下，返回从起始到最后的所有项。
不会影响原数组，即非破坏性方法

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

console.log(colors2);       // ["green","blue","yellow","purple"]
console.log(colors3);       // ["green","blue","yellow"]

splice()
很强大的数组方法，主要有：

• 删除

可以删除任意数量的项，只需指定2个参数：要删除的第一项的位置和要删除的项数。例如，splice(0,2)会删除数组中的前两项。

• 插入

可以向指定位置插入任意数量的项，只需提供3个参数：起始位置、要删除的项数和要插入的项。例：
splice(2,0,"red","green")会从当前数组的位置2开始插入字符串red和green。

• 替换

可以向指定位置插入任意数量的项，且同时删除任意数量的项，只需指定3个参数：起始位置、要删除的项数和插入任意数量的项。插入的项数不比与删除的相等。例如：
splice(2,1,"red","green")会删除当前数组位置2的项，然后再从位置2插入字符串red和green。

splie(a,b,c,d,...)
第一个参数为位置参数，指定位置。
第二个参数为是否删除项，0为不删除，1~？为删除从这个元素开始删除几个。
后续参数为将要添加的项本身。

splice()方法始终都会返回一个数组，该数组包含了从原始数组删除的项，如果没有则是空数组。

var colors = ["red","green","blue"];
var removed = colors.splice(0,1);       // 位置：0，删除：1个
console.log(removed);                   // 返回删除元素 ["red"]
console.log(colors);                    // ["green","blue"]

removed = colors.splice(1,0,"yellow","orange");     // 位置：0 删除：否 插入："yellow","orange"
console.log(colors);                    // ["green","blue","yellow","orange"]
console.log(removed);                   // 空数组[]

removed = colors.splice(1,1,"red","purple");        // 位置：1，删除：1个，插入："red","purple"
console.log(colors);                    // ["green","red","purple","yellow","orange"]
console.log(removed);                   // ["yellow"]

位置方法

indexOf() 和 lastIndexOf()
这两个方法接受两个参数，要查找的项和表示查找起点位置的索引。其中indexOf方法从数组开头开始向后查找，lastIndexOf方法从数组末尾开始向前查找。
这两个方法都返回要查找的项在数组中的位置，或者在没找到情况下返回-1。在比较第一个参数与数组中的每一项时，会使用全等操作符；也就是说，要求查找的项必须严格相等（===）。

var numbers = [1,2,3,4,5,4,3,2,1];
console.log(numbers.indexOf(4));       // 3
console.log(numbers.lastIndexOf(4));    // 5

console.log(numbers.indexOf(4,4));      // 5
console.log(numbers.lastIndexOf(4,4));   // 3

var person = {name:"Nicholas"};
var people = [{name:"Nicholas"}];

var morePeople = [person];

console.log(people.indexOf(person));        // -1
console.log(morePeople.indexOf(person));    // 0

迭代方法

ES5为数组定义了5个迭代方法。每个方法都接收两个参数：要在每一项上运行的函数（可选）和运行该函数的作用域对象——影响this对象的值。传入这些方法中的函数会接受三个对象：数值项的值、该项在数组中的位置和数组对象本身。

• every()

对数组每一项与运行给定函数，如果该函数每一项返回true，则返回true。

• filter()

对数组中的每一项运行给定函数，返回该函数会返回true的项组成的数组。

• forEach()

对数组中的每一项运行给定函数。这个方法没有返回值。

• map()

对数组中的每一项运行给定函数，返回每次函数调用的结果组成的数组。

• some()

对数组中的每一项运行给定函数，如果该函数对任一项返回true。则返回true。

以上方法都不会修改数组中的包含的值。

最相似的是every()和some()，它们都用于查询数组中的项是否满足某个条件。对every()来说，传入的函数必须对每一项都返回true，这个方法才返回true；否则，返回false（很像&&逻辑）。
而对于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);
})
console.log(everyResult);       // false

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

filter()
在看看filter()函数，利用指定函数确定是否在返回的数组中包含某一项。例如，返回一个所有数值大于2的数组。

var numbers = [1,2,3,4,5,4,3,2,1];

var filterResult = numbers.filter(function(item,index,array) {
    return (item > 2);
})

console.log(filterResult);  // [3,4,5,4,3]

map()
map()也返回一个数组，这个数组每一项都是在原始数组中的对应项上运行传入函数的结果。
例如，可以给数组中每一项乘以2，然后返回这些乘积组成的数组。

var numbers = [1,2,3,4,5,4,3,2,1];

var mapResult = numbers.map(function(item,index,array) {
    return item * 2;
})

console.log(mapResult);     // [2,4,6,8,10,8,6,4,2]

forEach()
对数组中的每一项运行传入的函数。这个方法没有返回值，本质上与使用for循环迭代数组一样。

var numbers = [1,2,3,4,5,4,3,2,1];

numbers.forEach(function(item,index,array) {
    // 执行某些操作
});

数组里的每一项和10相加

numbers.forEach(function(item,index,array) {
    console.log(item);      // 1 2 3 4 5 4 3 2 1 
    // item表示数组元素
    
    console.log(index);     // 0 1 2 3 4 5 6 7 8
    // index表示索引值

    console.log(array);     // [1,2,3,4,5,4,3,2,1]    
    // array表示数组本身
})

自己随便写了个：

var numbers = [1,2,3,4,5,4,3,2,1];

numbers.forEach(function(item,index,array) {
    array[index] += 10;
    // item += 10;   无法使用这个表达式实现，我估计item只是一个表示变量，无关numbers内部。
})
console.log(numbers);   // [11,12,13,14,15,14,13,12,11]

归并方法

ES5新增了两个归并数组的方法：reduce()和reduceRight()。这两个方法都会迭代数组所有项，然后构建一个最终返回的值。其中reduce()方法从数组第一项开始，逐个遍历到最后，reduceRight()则从数组最后一项开始，向前遍历直到第一项。

两个方法接受两个参数：一个在每一项上调用的函数和作为归并基础的初始值。传给reduce和reduceRigh的函数接受4个参数：前一个值、当前值、项的索引和数组对象。这个函数返回的任何值都会作为第一个参数自动传给下一项。第一次迭代发生在数组的第二项上，因此第一个参数是数组的第一项，第二个参数就是数组的第二项。
使用reduce()方法可以执行求数组中所有值之和的操作。如：

var values = [1,2,3,4,5];

var sum = values.reduce(function(prev,cur,index,array) {
    return prev + cur;
})
console.log(sum);   // 15

第一次执行回调函数，prev是1，cur是2.第二次，prev是3（1+2的结果），cur是3（数组第三项）。这个过程会持续把数组中的每一项访问一遍，最后返回结果。
reduceRight()作用类似，只不过相反而已。

var values = [1,2,3,4,5];

var sum = values.reduceRight(function(prev,cur,index,array) {
    return prev + cur;
})
console.log(sum);   // 15

使用reduce()函数reduceRight()，主要取决于要从哪头开始遍历数组。除此之外，它们完全相同。