摘要：數組是數據的有序列表，與其他語言不同的是，數組的每一項可以保存任何類型的數據。如下的代碼創建的就是一個密集數組稀疏數組與密集數組相反，并不強制要求數組元素是緊密相連的，即允許間隙的存在。

數組是數據的有序列表，與其他語言不同的是，ECMAScript 數組的每一項可以保存任何類型的數據。也就是說，可以用數組的第一個位置來保存字符串，用第二位置來保存數值，用第三個位置來保存對象， 以此類推

牢記：

JavaScript中的數組并不像我們在C或java等語言中遇到的常規數組，在js中數組并不是起始地址+長度構成的一片連續的地址空間。
javascript中數組其實就是個對象,只不過會自動管理一些"數字"屬性和length屬性罷了。
說的更直接一點,JavaScript中的數組根本沒有索引,因為索引應該是數字,而JavaScript中數組的索引其實是字符串

構造函數方式

1.無參構造函數，創建一空數組

var colors = new Array();

2.創建指定長度的數組，一個數字參數構造函數，指定數組長度（由于數組長度可以動態調整，作用并不大）

var colors = new Array(5);

3.帶有初始化數據的構造函數，創建數組并初始化參數數據

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

使用Array構造函數是可以省略new操作符，如下：

var colors = Array(3); // 創建一個包含 3 項的數組
var names = Array("Greg"); // 創建一個包含 1 項，即字符串"Greg"的數組

注意，這里有個坑！
同樣是使用構造函數的方式，并傳遞一個值，new Array(2)與new Array("2")是有區別的

new Array(2) // ["undefined", "undefined"]
new Array("2") // ["2"]

字面量方式

數組字面量由一對包含數組項的方括號表示，多個數組項之間以逗號隔開，如下所示:

var colors = ["red", "blue", "green"]; // 創建一個包含 3 個字符串的數組
var names = []; // 創建一個空數組
var values = [1,2,]; // 不要這樣!這樣會創建一個包含 2 或 3 項的數組
var options = [,,,,,]; // 不要這樣!這樣會創建一個包含 5 或 6 項的數組

字面量方式創建數組的兼容問題

javascript中數組其實就是個對象,只不過會自動管理一些"數字"屬性和length屬性

var a1=[1,2,3,4];
console.log(a1[0]); //1
var i=1;
console.log(a1[i]); //2
console.log(a1[++i]); //3

數組也是對象，我們可以使用索引的奧秘在于，數組會把索引值轉換為對應字符串（1=>”1”）作為對象屬性名，驗證：

console.log(1 in a1);//true，確實是一個屬性

索引特殊性在于數組會自動更新length屬性，當然因為JavaScript語法規定數字不能作為變量名，所以我們不能顯示使用array.1這樣的格式。由此可見其實負數，甚至非數字”索引“都是允許的，只不過這些會變成數組的屬性，而不是索引

var a = new Array(1,2,3);
a[-10] = "a[-10]";
a["sss"] = "sss";
console.log(a); // [1, 2, 3, -10: "a[-10]", sss: "sss"]

為對象添加數組方法

var blankArray = [];
var obj = {
    splice: blankArray.splice,
    push: blankArray.push,
    unshift: blankArray.unshift,
    pop: blankArray.pop,
    shift: blankArray.shift
};
obj.push();
obj.unshift();
obj.pop();
obj.shift();

數組的length屬性不是只讀的
1.通過設置這個屬性，可以從數組的末尾移除項或向數組中添加新項

var colors = ["red", "blue", "green"]; // 創建一個包含 3 個字符串的數組 colors.length = 2;
alert(colors[2]); //undefined

2.利用 length 屬性也可以方便地在數組末尾添加新項

var colors = ["red", "blue", "green"]; // 創建一個包含 3 個字符串的數組
colors[colors.length] = "black"; //(在位置3)添加一種顏色
colors[colors.length] = "brown"; //(在位置4)再添加一種顏色

3.利用length屬性刪除／清空數組

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

arr.length = 0;
console.log(arr); // []

密集數組：在Java和C語言中，數組是一片連續的存儲空間，有著固定的長度。加入數組其實位置是address，長度為n，那么占用的存儲空間是address[0],address[1],address[2].......address[n-1]。即數組元素之間是緊密相連的，不存在空隙。如下的js代碼創建的就是一個密集數組

var data = [3,1,6,9,2];  

稀疏數組：與密集數組相反，javascript并不強制要求數組元素是緊密相連的，即允許間隙的存在。如下的js代碼是合法的：

var sparse = new Array();  
sparse[0] = 0;  
sparse[3] = 3;  
alert(sparse[0]);//輸出0  
alert(sparse[1]);//輸出undefined 

密集數組的創建： var dense = Array.apply(null, Array(3));

稀疏數組與密集數組便利區別：

// 稀疏數組  
var array = new Array(3);   
array[2] = "name";  
for(var a in array){  
  console.log("index=" + a + ",value=" + array[a]);  
}  
   
// 密集數組  
var dense = Array.apply(null, Array(3));   
dense[2] = "name";  
for(var a in dense){  
  console.log("index=" + a + ",value=" + dense[a]);  
}

// 結果
// 稀疏數組：index=2,value=name
// 密集數組：index=0,value=undefined
//         index=1,value=undefined
//         index=2,value=name

差別：稀疏數組只遍歷了已存在元素的次數，密集數組遍歷了arr.length次

特點：
1.具有length屬性；
2.按索引方式存儲數據；
3.不具有數組的push()、pop()等方法；

偽數組無法直接調用數組方法或期望length屬性有什么特殊的行為，不具有數組的push()、pop()等方法，但仍可以對真正數組遍歷方法來遍歷它們。

常見的偽數組類型：
1.function內的arguments對象；
2.調用getElementsByTagName, document.childNodes之類的，返回的NodeList對象都屬于偽數組；
3.自定義對象的偽數組；

如何將偽數組轉換成數組？
1.聲明一個空數組，通過遍歷偽數組把它們重新添加到新的數組(不推薦)

var links = document.querySelectorAll("a");
var arr = [];
for (var i = 0; i < links.length; i++) {
  arr[arr.length] = links[i]
}

2.使用數組的slice()方法 它返回的是數組，使用call或者apply指向偽數組

var arr = Array.prototype.slice.call(links);

3.原型繼承

links.__proto__ = Array.prototype;

4.ES6中數組的新方法 from()

var arr = Array.from(links);

1.length賦值為0

var arr = [1,2,3,4];
arr.length = 0;
console.log(arr); // 輸出 []，空數組，即被清空了

2.splice

var arr = [1,2,3,4];
arr.splice(0,arr.length);
console.log(arr); // 輸出 []，空數組，即被清空了

3.賦值為[]

var arr = [1,2,3,4];
arr = []; // 賦值為一個空數組以達到清空原數組