• MDN : JavaScript Standard built-in object - Array

var array = [];

创建了一个空数组。

var array = [element1 [, element2] [, elementN]];

示例：

var names = ["Kent Beck", "Erich Gamma", "James Gosling", "Doug Lea", "Bob Lee"];

var array = new Array();

创建了一个空数组。

var array = new Array(size);

示例：

var array = new Array(5);

var array = new Array(element1 [, element2] [, elementN]);

示例：

var array = new Array("Kent Beck", "Erich Gamma", "James Gosling", "Doug Lea", "Bob Lee");

通过下标访问Array对象中的元素，下标从0开始。

示例：

var names = ["Kent Beck", "Erich Gamma", "James Gosling", "Doug Lea", "Bob Lee"];
console.log(names[0]); //Kent Beck

Array对象的属性有下面这些：

向数组的末尾添加一个或更多元素，并返回新的长度。此时把这个数组当成栈一样操作。

示例：

var names = [];
names.push("Kent Beck"); //["Kent Beck"]
names.push("Erich Gamma", "James Gosling"); //["Kent Beck", "Erich Gamma", "James Gosling"]
var length = names.push("Doug Lea", "Bob Lee"); //["Kent Beck", "Erich Gamma", "James Gosling", "Doug Lea", "Bob Lee"]

删除并返回数组的最后一个元素。此时把这个数组当成栈一样操作。

示例：

var names = ["Kent Beck", "Erich Gamma", "James Gosling", "Doug Lea", "Bob Lee"];
var name = names.pop(); //Bob Lee

删除并返回数组的第一个元素。此时把这个数组当成队列一样操作。

示例：

var names = ["Kent Beck", "Erich Gamma", "James Gosling", "Doug Lea", "Bob Lee"];
var name = names.shift(); //Kent Beck

向数组的开头添加一个或更多元素，并返回新的长度。

示例：

var names = ["Kent Beck", "Erich Gamma", "James Gosling", "Doug Lea", "Bob Lee"];
names.unshift("Brendan Eich"); //=>["Brendan Eich", "Kent Beck", "Erich Gamma", "James Gosling", "Doug Lea", "Bob Lee"]
names.unshift("A", "B", "C"); //=>["A", "B", "C", "Brendan Eich", "Kent Beck", "Erich Gamma", "James Gosling", "Doug Lea", "Bob Lee"]

连接两个或更多的数组，并返回新数组。

示例：

var names = ["A", "B", "C"];
var numbers = [1, 2, 3];
var newArray = names.concat(numbers, [true, false]);
for (index in newArray) {
    console.log(index + " : " + newArray[index]);
}

把数组的所有元素连接成一个字符串。元素通过指定的分隔符进行分隔。如果没有指定分隔符，默认的分隔符是","。

示例：

var array = ['Wind', 'Rain', 'Fire'];
array.join();    // 'Wind,Rain,Fire'
array.join('-'); // 'Wind-Rain-Fire'

对数组进行排序，你可以传入排序策略。

compareStrategy函数原型是function(a, b)。

函数返回值：

• 0 : 表示元素相等
• -1 : b排在前面， a排在后面
• 1 : a排在前面， b排在后面

示例：

var fruit = ['cherries', 'apples', 'bananas'];
fruit.sort(); // ['apples', 'bananas', 'cherries']

var scores = [1, 10, 21, 2];
scores.sort(); // [1, 10, 2, 21]
// Note that 10 comes before 2,
// because '10' comes before '2' in Unicode code point order.

var things = ['word', 'Word', '1 Word', '2 Words'];
things.sort(); // ['1 Word', '2 Words', 'Word', 'word']
// In Unicode, numbers come before upper case letters,
// which come before lower case letters.

对数组元素顺序反转。返回值仍然是原来的数组，并没有新产生数组，这个要特别注意。

示例：

var array = ['one', 'two', 'three'];
var reversedArray = array.reverse();

console.log(array);         // ['three', 'two', 'one']
console.log(reversedArray); // ['three', 'two', 'one']

对数组进行遍历。callback函数的原型是：function(item, index, array)。

注意：如果你要用于浏览器端，那么IE9以前的IE不支持此函数。

示例：

var array = ['one', 'two', 'three'];
array.forEach(function(item, index, array) {
    console.log(item);
});

查询给定的元素在数组中的索引。如果没有找到返回-1。

你也可以指定从哪个位置开始查找，查找的方式是从前往后找。

示例：

var names = ['A', 'B', 'C', 'D'];
if (names.indexOf('B') === -1) {
    console.log('B doesn't exists in names');
}

完全复制整个数组到新数组。

示例：

var names = ["Kent Beck", "Erich Gamma", "James Gosling", "Doug Lea", "Bob Lee"];
var copyNames = names.slice();
copyNames.pop();

从beginIndex开始的位置到数组末尾这一段元素复制到一个新数组。

有趣的是beginIndex可以是负数，你听说过数组的下标是负数吗，似乎都是非负数嘛！

下面看一个图：

原来，我们平时用的是正向思维，人家用了一个逆向思维！！太绝了！

此函数的实现，如果发现你传入的是负数，使用beginIndex = array.length + beginIndex就转成了我们正常用的下标了。

示例：

var names = ["Kent Beck", "Erich Gamma", "James Gosling", "Doug Lea", "Bob Lee"];
var copyNames1 = names.slice(3);
var copyNames2 = names.slice(-2);

从beginIndex开始的位置到endIndex - 1这一段元素复制到一个新数组。

beginIndex和endIndex都可以是负数。并且，beginIndex指向的位置可以在endIndex指向的位置的后面，这种情况下，实现了倒序！

如下图：

示例：

var names = ["Kent Beck", "Erich Gamma", "James Gosling", "Doug Lea", "Bob Lee"];
var copyNames1 = names.slice(3, 1);
var copyNames2 = names.slice(-2, -4);

从beginIndex开始的位置，往后删除deleteCount个元素。不会产生新数组，直接修改原数组。

beginIndex同样可以是负数。

示例：

var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];
myFish.splice(2, 1);
// myFish is ["angel", "clown", "sturgeon"]

先从beginIndex开始的位置，往后删除deleteCount个元素。

beginIndex同样可以是负数。

不会产生新数组，直接修改原数组。

删除操作完成后，再从beginIndex开始的位置插入传入的元素。

示例：

var array = ['A', 'B', 'C', 'D'];
array.splice(2, 0, 'E', 'F'); //没有删除，直接从2位置上开始插入，后面的元素往后挤
// array is ['A', 'B', 'E', 'F', 'C', 'D'];

var array = ['A', 'B', 'C', 'D'];
array.splice(2, 1, 'E', ); //先从2位置开始删除一个元素，再从2位置上开始插入，后面的元素往后挤，相当于替换
// array is ['A', 'B', 'E', 'D'];

把数组转换为字符串，并返回结果。与array.join()返回的结果一样。

把数组转换为本地字符串，并返回结果。

array.toLocaleString()与array.toString()的结果可能不一样， 比如涉及到语言、地区等相关的时候。

示例：

var names = [new Date(), "B", "C", "D"];
console.log(names.toString());       //Mon Feb 20 2016 15:29:17 GMT+0800 (CST),B,C,D
console.log(names.toLocaleString()); //2/20/2016, 3:29:17 PM,B,C,D

ECMAScript数组确实很强大，不仅能当作数组使用，也可以当作栈和队列使用。 如果你学习过Java的话，应该对Java里面的ArrayList类非常熟悉。它底层也是通过数组实现的， 我们就使用数组实现一个类似于Java中的ArrayList。

示例：

function ArrayList() {

	var elements = [];

    //避免多次执行下面的创建函数的语句，只创建一次即可
    if (ArrayList.prototype.size) {
        return
    }

	/**
	 * @brief: 获取列表的元素个数
	 * @return: 元素个数
	 */
	ArrayList.prototype.size = function() {
		return this.elements.length;
	};

	/**
	 * @brief 添加元素 可以添加一个，也可以添加多个，支持可变参数
	 * @param elements 要添加的元素
	 */
	ArrayList.prototype.add = function(elements) {
		if (arguments.length == 1) {
			this.elements.push(arguments[0]);
		} else if (arguments.length >= 2) {
			for (var i = 0; i < arguments.length; i++) {
			    this.elements.push(arguments[i]);
			}
		}
	};

    /**
     * @brief 设置指定索引的元素
     * @param index 索引
     */
    ArrayList.prototype.set = function(index, element) {
        if (index >= 0 && index < elements.length) {
            this.elements.splice(index, 1, element);
        }
    };

	/**
	 * @brief 获取指定索引的元素
	 * @param index 索引
	 */
	ArrayList.prototype.get = function(index) {
		if (index < 0 || index >= elements.length) {
		    return null;
		} else {
		    return this.elements[index];
		}
	};

	/**
	 * @brief 删除指定索引的元素
	 * @param index 索引
	 */
	ArrayList.prototype.removeAt = function(index) {
	    if (index >= 0 && index < elements.length) {
	        this.elements.splice(index, 1);
	    }
	};

	/**
	 * @brief 删除指定元素
	 * @param obj 元素
	 */
	ArrayList.prototype.removeObj = function(obj) {
	    var index = this.indexOf(obj);
	    if (index === -1) {
	        return;
	    }
	    this.removeAt(index);
	};

	/**
	 * @brief 获取指定元素的索引
	 * @param obj 元素
	 */
	ArrayList.prototype.indexOf = function(obj) {
	    // IE9才开始支持原生的indexOf函数，所以，我们自己实现。
		for (var i = 0; i < elements.length; i++) {
			if (this.elements[i] === obj) {
				return i;
			}
		}
		return -1;
	};

	/**
	 * @brief 是否是空的
	 * @return Boolean
	 */
	ArrayList.prototype.isEmpty = function() {
		return this.elements.length === 0;
	};

	/**
	 * @brief 删除所有的元素
	 */
	ArrayList.prototype.clearAll = function() {
		this.elements = [];
	};

	/**
	 * @brief 是否包含指定的元素
	 * @return Boolean
	 */
	ArrayList.prototype.contains = function(obj) {
		return this.indexOf(obj) !== -1;
	};

	/**
     * @brief 是否包含指定的元素
     * @return Boolean
     */
    ArrayList.prototype.toString = function() {
        return this.elements.toString();
    };
}

ECMAScript数组已经能够当作栈使用了， 不过，标准的栈不仅有push、pop操作， 还有一个peek操作，就是值拿出栈顶的元素，不出栈。实现如下：

示例：

function Stack() {

    var elements = [];

    Stack.prototype.peek = function() {
        return (elements.length == 0) ? null : elements[elements.length - 1];
    };

    ...
}

ECMAScript数组已经能够当作队列使用了，只是，标准队列的操作中应该有一个take操作， 其实就是shift函数。