（本文為阮一峰js標準教程的學習筆記，旨在總結該教程中涉及的知識點大綱及個人所做的一些拓展，方便作為“目錄”或者“大綱”復習和查漏補缺，詳細內容請參見阮一峰教程原文）

第二部分 語法

*********第六章 數組***********

一.數組的定義
1.概念：按次序排列的一組數，每個值都有編號（從0開始）
整個數組用[]表示
2.可以定義時賦值，也可定以後賦值。
arr[0]=‘a‘;
3.任何數據類型都可放入數組，[1,‘1‘,[1,2],{},function(){}]
4.數組的元素仍是數組，就形成了多維數組；

var a = [[1, 2], [3, 4]];
a[0][1] // 2
a[1][1] // 4

二、數組的本質

1.本質上，數組屬於一種特殊的對象。typeof運算符會返回數組的類型是object。

typeof [1, 2, 3] // "object"

2.數組作為對象的特殊性體現在，它的鍵名是依次排列的自然數（0,1,2,3...）
var arr = [‘a‘, ‘b‘, ‘c‘];

Object.keys(arr)
// ["0", "1", "2"]

Object.keys方法返回數組的所有鍵名。可以看到數組的鍵名就是整數0、1、2。
js內部將array視為對象，只不過外在表現形式不同罷了


3.由於數組成員的鍵名是固定的，因此數組不用為每個元素指定鍵名，而對象的每個成員都必須指定鍵名。

4.JavaScript語言規定，對象的鍵名一律為字符串，所以，數組的鍵名其實也是字符串。之所以可以用數值讀取，是因為非字符串的鍵名會被轉為字符串。

var arr = [‘a‘, ‘b‘, ‘c‘];

arr[‘0‘] // ‘a‘ 標準讀取一個對象中某鍵值對的鍵值應該這麽寫
arr[0] // ‘a‘ 數值鍵名被自動轉為了字符串


5.var arr = [1, 2, 3];
arr.0 // SyntaxError

上面代碼中，arr.0的寫法不合法，因為單獨的數值不能作為標識符（identifier）。這個點會被Js引擎認為是小數點，只能arr[0]

6.【數值的整形操作是發生在類型轉換前執行的，比如String(0x86),會先將0x86整形為134，再變換數據類型為"134"】
var a=[];


a[1.00]=6;

a[1.000000000000000000] //
6

a["1.00000"] //
undefined
a["1.0000"]=8;這是在數組中自定義了一個索引（鍵名）為“1.0000”值為8的數組成員
a[1.0000] //6;
a["1.0000"] //8
a[0x1]
//6 十六進制數會先整形為十進制1再轉字符串“1”

三、length屬性
1.返回數組的成員數量。
2.JavaScript使用一個32位整數，保存數組的元素個數。這意味著，數組成員最多只有4294967295個（232 - 1）個，也就是說length屬性的最大值就是4294967295。
3.只要是數組，就一定有length屬性。
該屬性是一個動態的值，等於鍵名中的最大整數加上1。。另外，這也表明數組是一種動態的數據結構，可以隨時增減數組的成員。

var arr = [‘a‘, ‘b‘];
arr.length // 2

arr[2] = ‘c‘;
arr.length // 3

arr[9] = ‘d‘;
arr.length // 10

arr[1000] = ‘e‘;
arr.length // 1001

數組的數字鍵不需要連續。

4.length屬性不光是數組的一個特征指標，是可寫的，對他的修改會反向作用給arr。
5.由於標準數組成員是不需要自己寫鍵名的，默認鍵名依次是0,1,2,3...,而數組中只有使用了默認鍵名的成員（不要求下標連續，隨意），才可以被length屬性記錄或者操作，當然，可以為數組添加鍵名不是自然數的屬性，只是不會影響length，也不會因為length的人為改變受影響。

6.數組的鍵名添加超出範圍的數值，鍵名會自動轉為字符串，arr數組將不再是標準數組，而是一個雜交體。
var arr=[];
arr[-1]=‘a‘;
arr[Math.pow(2,32)]=‘b‘;
arr[1.2]=‘c‘;
arr.length;//0;
arr[-1] // "a"
arr[4294967296] // "b"
最後兩行之所以會取到值，是因為取鍵值時，[]運算符會自動將裏面的數值轉為字符串。

arr//["-1":"a","2^32":"b","1.2":"c"]

7.length賦值：只會影響到數組中下標符合要求的成員，下標是自然數的成員；其他自定義下標的成員不參與討論
7.1人為設置一個小於當前成員個數的值。
該數值會自動減少到length設置的值；
var arr=[‘a‘,‘b‘,‘c‘]
arr.length=2;
arr//[‘a‘,‘b‘];

7.2人為設置length大於當前元素個數，則從length這個指標上看，數組成員會增加到這個值,
讀取這些新建的位置上的值返回undefined;

var arr=[];
arr.length=10;
就開辟10個空的儲存位置；

arr[1] //undefined;
document.write(arr)能看到屏幕上打印出 ,,,,,,,,,

arr[0]=undefined;
arr就變成索引0是undefined，剩余九個空的儲存位置；

【for..in遍歷時能遍歷到第一個undefined，後面九個空位遍歷不到】
【用in運算符檢查時，空位置都返回false,只有 0 in arr 返回true，所以從in運算符的角度，數組內還是只有一個成員】
【forEach遍歷數組也會跳過空位置】
document.write(arr)依然是打印出 ,,,,,,,,, 而不是undefined,,,,,,,,,

7.3由於對象讀取不存在的屬性不報錯而是返回undefined，與上面情況註意區分
var arr=["a"]
arr[50]//undefined;



7.4length亂賦值；只要不是0~2^32-1之間的整數，等著報錯把！
length設置不合法的值，js報錯
// 設置負值
[].length = -1
// RangeError: Invalid array length

// 數組元素個數大於等於2的32次方
[].length = Math.pow(2, 32)
// RangeError: Invalid array length

// 設置字符串
[].length = ‘abc‘
// RangeError: Invalid array length


四、類似數組的對象/偽數組
1.有些對象被稱為類似數組的對象，看上去像數組，可以使用Length屬性，但並未真的數組，所以無法使用數組方法；
var obj = {
0: ‘a‘,
1: ‘b‘,
2: ‘c‘,
length: 3
};

obj[0] // ‘a‘
obj[2] // ‘c‘
obj.length // 3
obj.push(‘d‘) // TypeError: obj.push is not a function

2.類似數組的對象只有一個特征，就是具有Length屬性，換句話說，只要有length屬性，就可以認為這個對象類似於數組。但是，對象的length屬性不是動態值，不會隨著成員的變化而變化。
var obj = {
length: 0
};
obj[3] = ‘d‘;
obj.length // 0

3.典型的類似數組的對象是函數的arguments對象，以及大多數DOM元素集，還有字符串。
// arguments對象
function args() { return arguments }
var arrayLike = args(‘a‘, ‘b‘);

arrayLike[0] // ‘a‘
arrayLike.length // 2
arrayLike instanceof Array // false

// DOM元素集
var elts = document.getElementsByTagName(‘h3‘);
elts.length // 3
elts instanceof Array // false

// 字符串
‘abc‘[1] // ‘b‘
‘abc‘.length // 3
‘abc‘ instanceof Array // false

4.數組的slice方法將類似數組的對象，變成真正的數組。
var arr = Array.prototype.slice.call(arrayLike);
【未知】

5.遍歷類似數組的對象，可以采用for循環，也可以采用數組的forEach方法。

// for循環
function logArgs() {
for (var i = 0; i < arguments.length; i++) {
console.log(i + ‘. ‘ + arguments[i]);
}
}

// forEach方法
function logArgs() {
Array.prototype.forEach.call(arguments, function (elem, i) {
console.log(i+‘. ‘+elem);
});
}

五、in運算符；

1.檢查某個鍵名是否存在的運算符in，適用於對象，也適用於數組。

var arr = [ ‘a‘, ‘b‘, ‘c‘ ];
2 in arr // true
‘2‘ in arr // true
4 in arr // false

上面代碼表明，數組存在鍵名為2的鍵。由於鍵名都是字符串，所以數值2會自動轉成字符串

2.如果數組的某個位置是空位，in運算符返回false。

var arr = [];
arr[100] = ‘a‘;

100 in arr // true
1 in arr // false

上面代碼中，數組arr只有一個成員arr[100]，其他位置的鍵名都會返回false。

六、for..in循環和數組的遍歷；
1.遍歷數組和對象，畢竟數組只是一種特殊對象。
var a = [1, 2, 3];

for (var i in a) {
console.log(a[i]);
}
// 1
// 2
// 3

2.for...in不僅會遍歷數組所有的數字鍵，還會遍歷非數字鍵。
var a = [1, 2, 3];
a.foo = true;

for (var key in a) {
console.log(key);
}
// 0
// 1
// 2
// foo

上面代碼在遍歷數組時，也遍歷到了非整數鍵foo。所以，不推薦使用for...in遍歷數組。
3.數組的遍歷可以考慮使用for循環或while循環。

var a = [1, 2, 3];

// for循環
for(var i = 0; i < a.length; i++) {
console.log(a[i]);
}

// while循環
var i = 0;
while (i < a.length) {
console.log(a[i]);
i++;
}

var l = a.length;
while (l--) {
console.log(a[l]);
}

最後一種寫法是逆向遍歷，即從最後一個元素向第一個元素遍歷。

4.forEach方法對象不能用，這針對數組，而且針對其中的整數索引的成員，無視空位置。
數組的forEach方法，也可以用來遍歷數組，詳見《標準庫》一章的Array對象部分。

var colors = [‘red‘, ‘green‘, ‘blue‘];
colors.forEach(function (color) {
console.log(color);
});

七、數組的空位
1.當數組的某個位置是空元素，即兩個逗號之間沒有任何值，我們稱該數組存在空位（hole）。

var a = [1, , 1];
a.length // 3

2.空位也會算在length屬性中
3.最後一個元素後面有逗號，並不會產生空位，有沒有這個逗號結果一樣
var a=[1,2,3,]
a.length//3
4.數組的空位是可以讀取的，返回undefined。但是你用in運算符查他的索引又返回false，意思查不到
var a = [, , ,];
a[1] // undefined

5.使用delete命令刪除一個數組成員，會形成空位，並且不會影響length屬性。

var a = [1, 2, 3];
delete a[1];

a[1] // undefined
a.length // 3

6.上面代碼用delete命令刪除了數組的第二個元素，這個位置就形成了空位，但是對length屬性沒有影響。也就是說，length屬性不過濾空位。所以，使用length屬性進行數組遍歷，一定要非常小心。
7.數組的某個位置是空位，與某個位置是undefined，是不一樣的。如果是空位，使用數組的forEach方法、for...in結構、以及Object.keys方法進行遍歷，空位都會被跳過。
8.果某個位置是undefined，遍歷的時候就不會被跳過。

var a = [undefined, undefined, undefined];

a.forEach(function (x, i) {
console.log(i + ‘. ‘ + x);
});
// 0. undefined
// 1. undefined
// 2. undefined

for (var i in a) {
console.log(i);
}
// 0
// 1
// 2

Object.keys(a)
// [‘0‘, ‘1‘, ‘2‘]

9.空位就是數組沒有這個元素，所以不會被遍歷到，而undefined則表示數組有這個元素，值是undefined，所以遍歷不會跳過。

語法》第六章 數組