摘要：總結(jié)使用訪問數(shù)組元素，使用訪問數(shù)組屬性，如。數(shù)組的長度保證大于每個(gè)元素的索引值，數(shù)組沒有元素，最大索引為，為為數(shù)組元素賦值，如果其索引大于等于現(xiàn)有數(shù)組長度，的屬性值將設(shè)置為如果設(shè)置的值小于數(shù)組長度時(shí)，會(huì)將索引大于的元素全部刪除。

數(shù)組是值的有序集合，數(shù)組中每個(gè)值稱為元素，元素在數(shù)組中的位置稱為索引。JavaScript中的數(shù)組是一種特殊的對(duì)象：

類屬性class attribute為Array

新元素添加到數(shù)組后，自動(dòng)更新自身的length屬性

從Array.prototype對(duì)象中繼承方法

設(shè)置length屬性值小于元素個(gè)數(shù)時(shí)，會(huì)截?cái)鄶?shù)組

JavaScript中，數(shù)組的元素可以是任意JavaScript值，并且同一個(gè)數(shù)組中不同元素值的類型可以不同

數(shù)組的索引是基于0的32位數(shù)值，最大的索引為(2^32 - 1) - 1

數(shù)組是動(dòng)態(tài)的，可以根據(jù)需要增長或縮短

數(shù)組的操作方法大部分定義在Array.prototype原型對(duì)象上，使所有的數(shù)組對(duì)象都可以使用

數(shù)組的實(shí)現(xiàn)經(jīng)過了優(yōu)化，用索引訪問元素的效率高于直接訪問常規(guī)對(duì)象的屬性

數(shù)組可能是稀疏或者稠密的。

有兩種方法可以創(chuàng)建數(shù)組：數(shù)組字面量[1, 2, 3]和new Array(1, 2, 3)。推薦使用數(shù)組字面量創(chuàng)建數(shù)組，簡(jiǎn)潔易懂。

對(duì)象字面量創(chuàng)建的數(shù)組，其元素可以是表達(dá)式、對(duì)象或其他數(shù)組。如果省略數(shù)組中字面量的值，數(shù)組會(huì)變?yōu)橄∈钄?shù)組。

var empty = [];   //  <==> var  empty = new Array();數(shù)組字面量的寫法更簡(jiǎn)潔
var primes = [2, 3, 5, 7, 11];
var misc = [1.1, true, "a"];    //數(shù)組中元素可以是任意類型值

var base = 1024;
var table = [base, base + 1, base + 2, base + 3];  // ==> [ 1024, 1025, 1026, 1027 ]

var b = [[1, {a: "1", b: 2}], [true, {x: 2, y:3}]];

通過Array()構(gòu)造函數(shù)也可以創(chuàng)建數(shù)組，但是使用比較繁瑣，根據(jù)傳入?yún)?shù)個(gè)數(shù)的不同，分為三種情況：

不傳入?yún)?shù)：var a = new Array()；a數(shù)組與[]相同

傳入一個(gè)非負(fù)整數(shù)：var a = new Array(10)；創(chuàng)建一個(gè)存放10個(gè)數(shù)組元素的空間，但是此時(shí)沒有定義索引屬性和存儲(chǔ)值，此時(shí)的數(shù)組是稀疏的

傳入2個(gè)或多個(gè)數(shù)組元素或者一個(gè)非數(shù)值元素：var c = new Array("1", 2, true, "text");，創(chuàng)建的數(shù)組["1", 2, true, "text"]

根據(jù)數(shù)組是否有不連續(xù)的數(shù)組，將其分為稀疏數(shù)組和稠密數(shù)組

稀疏數(shù)組的length屬性大于元素的個(gè)數(shù)，在實(shí)現(xiàn)上比稠密數(shù)組更慢，消耗內(nèi)存空間更大，查找元素的效率與常規(guī)對(duì)象相似。

要避免使用稀疏數(shù)組，其查找效率很低。稀疏數(shù)組空缺的部分沒有值和索引，因?yàn)椴荒苡?b>for-in循環(huán)遍歷出空缺的部分，for-in循環(huán)可以遍歷對(duì)象的可枚舉屬性（自身和繼承）

var undefs = [, , ];   //數(shù)組字面量允許逗號(hào)結(jié)尾，是稀疏數(shù)組，沒有元素，使用for-in循環(huán)不會(huì)輸出任何內(nèi)容
var count = [1, , 3];   //稀疏數(shù)組，使用for-in循環(huán)只輸出[1, 3]
var arr = new Array(10);   //稀疏數(shù)組，沒有賦值和索引

a = new Array(5);   //數(shù)組沒有元素，a.length為5，稀疏
a[1000] = 0;        //a.length為1001，索引大于元素個(gè)數(shù)，稀疏

a = [, , , ];  //是稀疏數(shù)組，0 in a;  => false
a = [1, , 3];   //稀疏數(shù)組，長度為3
a = [,];        //數(shù)組沒有元素，長度是1

總結(jié)：數(shù)組創(chuàng)建盡量使用字面量方法，如果數(shù)組的索引不連續(xù)，則數(shù)組是稀疏數(shù)組，查詢效率低，內(nèi)存消耗高

數(shù)組是特殊的對(duì)象，可以利用對(duì)象屬性的訪問方式.和[]，因?yàn)閿?shù)組元素的索引是非負(fù)數(shù)的字符串，所以需要使用[]訪問，而數(shù)組的屬性（如length則可以用.訪問）。

利用[]可以讀寫數(shù)組的元素：

var a = ["Hello"];
var value = a[0];        //讀取第一個(gè)元素
a[1] = 3.14;         //寫入第二個(gè)元素

數(shù)組是特殊的對(duì)象：

所有的數(shù)組都是對(duì)象，但對(duì)象不一定是數(shù)組；

數(shù)組對(duì)象的屬性名在0~2^32-2之間的是索引，可以為數(shù)組創(chuàng)建任意屬性，只有當(dāng)屬性是索引時(shí)，才更新其length屬性

使用負(fù)整數(shù)、與整數(shù)等的浮點(diǎn)數(shù)作為屬性時(shí)，會(huì)將其轉(zhuǎn)化為索引

    a[-1.23] = true;   //創(chuàng)建一個(gè)名為"-1.23"的屬性
    a[-3] = false;   //創(chuàng)建一個(gè)名為"-3"的屬性
    a["1000"] = 0;     //數(shù)組的第1001個(gè)元素為值為0
    a[2.000];  //與a[2]相同

注：JS中沒有越界的概念，因?yàn)槭菍?shù)組作為對(duì)象來處理，對(duì)于不存在的下標(biāo)，將其當(dāng)做普通屬性添加到數(shù)組對(duì)象上。

總結(jié)：使用[]訪問數(shù)組元素，使用.訪問數(shù)組屬性，如.length。

對(duì)于稠密數(shù)組，其length屬性代表元素的個(gè)數(shù)，索引從0開始，最大值是length - 1。如果是稀疏數(shù)組，其length屬性大于元素的個(gè)數(shù)。數(shù)組的長度保證大于每個(gè)元素的索引值

[].length;   //==>0，數(shù)組沒有元素
[1, 2, 3].length;   //==>3，最大索引為2，length為3

為數(shù)組元素賦值，如果其索引i大于等于現(xiàn)有數(shù)組長度，length的屬性值將設(shè)置為i+1

如果設(shè)置的length值n小于數(shù)組長度時(shí)，會(huì)將索引大于n的元素全部刪除。

在ES5中，可以通過Object.defineProperty()設(shè)置數(shù)組的length屬性的描述符descripter為{writable: false}，使其變?yōu)橹蛔x屬性，設(shè)置之后不能添加或者刪除數(shù)組元素

a = [1, 2, 3, 4, 5];
a.length = 3;             //數(shù)組變?yōu)閇1, 2, 3]
a.length = 0;            //刪除所有數(shù)組元素

a = [1, 2, 3];
//注意設(shè)置為只讀后，不能在為數(shù)組添加元素，除非修改writable為true
Object.defineProperty(a, "length", {writable: false});
a.length = 2;    //a.length不會(huì)改變
a.length;      //==>3

在Array.prototype對(duì)象中定義許多關(guān)于數(shù)組操作的方法。

push()方法：在數(shù)組末尾插入一個(gè)或多個(gè)元素，與pop()方法相對(duì)應(yīng)，返回插入元素后數(shù)組的新長度

unshift()方法：在數(shù)組的首部插入一個(gè)或多個(gè)元素，與shift()方法相對(duì)應(yīng)，返回插入元素后的數(shù)組新長度。注意一次插入多個(gè)元素和多次插入一個(gè)元素的效果是不同的

pop()方法：在數(shù)組末尾刪除一個(gè)元素，返回刪除的元素；

shift()方法：在數(shù)組首部刪除一個(gè)元素，返回刪除的元素；

var a = [];
a.push("one");  // ==> ["one"]，在末尾添加一個(gè)元素
a.push("two", "zero");  // ==> ["one", "two", "zero"]，在末尾添加兩個(gè)個(gè)元素

a.pop();      // ==>"zero"，a變?yōu)閇"one", "two"]
a.unshift("four"); // ==> a變?yōu)閇"four", "one", "two"]
a.shift();   // ==> 刪除"four"

注：會(huì)修改調(diào)用該方法的數(shù)組

splice(start, num, insert1, insert2,...)方法是插入、刪除和替換數(shù)組元素的通用方法。

參數(shù)start：插入或刪除的起始位置

參數(shù)num：需要?jiǎng)h除元素的個(gè)數(shù)，如果不指定會(huì)將起始位置后的所有元素刪除

insert、insert2...：需要插入的元素

var a = [1, 2, 3, 4, 5, 6, 7];
a.splice(5);   //==>[6, 7]，a變?yōu)閇1, 2, 3, 4, 5]
a.splice(2, 2);   //==>[3, 4]，a變?yōu)閇1, 2, 5]
a.splice(-1, 1);   //==>[5]，a變?yōu)閇1, 2]

a.splice(1, 0, "a", false, 0);   // ==>[]，沒有刪除元素，a變?yōu)閇1, "a", false, 0, 2]
a.splice(2, 2, ["x", "y"]);     // ==>[false, 0]，a變?yōu)閇1, "a", ["x", "y"], 2]

注：會(huì)修改調(diào)用該方法的數(shù)組

使用for循環(huán)是遍歷數(shù)組的常見方法，可以配合部分if語句過濾部分元素。

for(var i=0, len=arr.length; i
對(duì)于稀疏數(shù)組，可以使用for-in循環(huán)歷來過濾掉不存在的索引。for-in循環(huán)會(huì)訪問繼承的可枚舉屬性，利用hasOwnProperty()方法過濾掉非自身屬性。
for(var i in p) {
  if(!p.hasOwnProperty(i)) {continue;}  //跳過繼承的屬性
}

forEach()方法
由于for-in循環(huán)本身是未遍歷對(duì)象而設(shè)計(jì)，如果數(shù)組有其余可枚舉屬性，需要專門過濾。ES5定義forEach()方法來遍歷數(shù)組。
forEach(fn)方法接收一個(gè)函數(shù)作為參數(shù)，將每個(gè)元素分別調(diào)用該函數(shù)。forEach()可以給fn傳遞三個(gè)參數(shù)，fn(value, index, array)。

value：數(shù)組元素

index：數(shù)組元素對(duì)應(yīng)的索引


array：數(shù)組本身
var a = [1, 2, 3, 4, 5];
//計(jì)算數(shù)組元素的和
var sum = 0;
a.forEach(function(value) {   //只傳遞數(shù)組元素一個(gè)參數(shù)
  sum += value;
});
console.log(sum);   //  ==> 15
//將數(shù)組每個(gè)元素加2
a.forEach(function (value, index, array) {
  array[index] = value + 2;
});
console.log(a);   // ==>[3, 4, 5, 6, 7]


forEach()方法不能在所有元素都傳遞給fn函數(shù)調(diào)用前終止遍歷（不能使用break跳出循環(huán)），如果要提前終止循環(huán)，需要將forEach()方法放在try塊中，如果forEach()調(diào)用的函數(shù)fn能拋出foreach.break異常，遍歷提前終止。
function foreach(value, index, array) {
  try {
    a.forEach(index, array);
  } catch(e) {
    if(e === foreach.break) {
      return;
    } else {
      throw e;
    }
  }
}
2.3 多維數(shù)組
JS并不支持真正的多維數(shù)組，可以利用數(shù)組的數(shù)組來進(jìn)行模擬，使用[][]訪問即可。
var table = new Array(10);   //表格10行
var len=table.length;
for(let i=0; i 35

3 數(shù)組的方法
在Array.prototype中定義了與數(shù)組操作相關(guān)的方法，主要分為ES3和ES5兩個(gè)部分
3.1 ES3中的數(shù)組操作方法

Array.prototype.join()：不修改原字符串
Array.prototype.join(seperator)方法將數(shù)組中所有元素先轉(zhuǎn)化為字符串，再利用參數(shù)seperator傳入的分隔符將元素轉(zhuǎn)換成的字符串拼接起來，最后返回該字符串。默認(rèn)使用,分隔。是String.prototype.split()方法的逆向操作
var a = [1, 2, 3];
a.join();   // ==> "1,2,3"
a.join(" ");   // ==> "1 2 3"
a.join("");   // ==> "123"
"1,2,3".split(",").join();  //==> "1,2,3"

Array.prototype.reverse()：會(huì)修改原數(shù)組
將數(shù)組中的元素順序顛倒，返回逆序后的數(shù)組
var a = [1, 2, 3];
a.reverse.join();   //"3,2,1"，并且a變?yōu)閇3, 2, 1]，所以注意使用副本來操作

Array.prototype.sort()：會(huì)修改原數(shù)組
將數(shù)組中元素按照指定的順序后返回，默認(rèn)按照字母表的順序怕排序。undefined值被排到最后，要使用其他方式排序，需要傳入一個(gè)比較函數(shù)fn(a, b)，依據(jù)兩個(gè)參數(shù)在排序好的數(shù)組中的先后順序：

如果第一個(gè)參數(shù)在第二個(gè)參數(shù)之前，函數(shù)返回值小于0

如果第一個(gè)參數(shù)在第二個(gè)參數(shù)值后，函數(shù)返回值大于0


如果兩個(gè)參數(shù)相等，函數(shù)返回值等于0
var arr = ["banana", "cherry", "apple"];
arr.sort();
arr.join(",");   //==> "apple,banana,cherry"，默認(rèn)按照字母表順序

var a = [1, 2, 3, 4];
a.sort(function(a, b) {
  return a - b;    //如果目標(biāo)是升序，a在b的前面，函數(shù)返回值小于0即可
});
a.sort(function(a, b) {
  return b - a ;   //如果目標(biāo)是降序，a在b的后面，函數(shù)返回值大于0即可
});

//不區(qū)分大小寫升序排列
var arr = ["ant", "Dog", "Bug", "cat"];

arr.sort(function(first, second) {
  first = first.toLowerCase();    //將字符串全部轉(zhuǎn)化為小寫
  second = second.toLowerCase();
  if(first < second) {       //如果正確順序是first在second前，則返回-1
    return -1;
  } else if (first > second) {
    return 1;
  } else {
    return 0;
  }
});



Array.prototype.concat()：不修改原數(shù)組
用于拼接原始數(shù)組與傳入的參數(shù)，組成一個(gè)新的數(shù)組并返回。如果傳入的參數(shù)是數(shù)組，會(huì)連接最外層的數(shù)組元素
var a = [1, 2, 3];
a.concat(4, 5);   // ==> [1, 2, 3, 4, 5]
a.concat([4, 5]);  //  ==> [1, 2, 3, 4, 5]
a.concat(4, [5, [6, 7]]);  //==> [1, 2, 3, 4, 5, [6, 7]]  
// 將數(shù)組[5, [6, 7]]最外層拆開，但是保留內(nèi)部

Array.prototype.slice()：不改變?cè)瓟?shù)組
返回指定數(shù)組的一個(gè)片段或數(shù)組：

通過兩個(gè)參數(shù)指定切割的起始位置與結(jié)束位置（不包含第二個(gè)位置的元素）

如果只有一個(gè)參數(shù)，返回從開始位置到數(shù)組結(jié)束的所有元素


參數(shù)接收負(fù)數(shù)，-1表示最后一個(gè)元素，-2表示倒數(shù)第二個(gè)元素
a = [1, 2, 3, 4, 5];
a.slice(0, 3);   // ==> [1, 2, 3]
a.slice(3);   // ==> [4, 5]
a.slice(1, -1);   // ==> [2, 3, 4]



toString()和toLocalString()

先將數(shù)組的每個(gè)元素轉(zhuǎn)化為字符串，再利用逗號(hào)將其拼接為一個(gè)字符串，其中toLocaleString()方法區(qū)別在于轉(zhuǎn)換Date和Number類型的數(shù)字、日期和時(shí)間時(shí)，根據(jù)時(shí)區(qū)、數(shù)字來轉(zhuǎn)化。
轉(zhuǎn)換結(jié)果與不傳入?yún)?shù)的join()方法類似

[1, 2, 3].toString();   // ==> "1,2,3"
["a", [1, "b"]].toString();  // ==> "a,1,b"
3.2 ES5中操作數(shù)組的方法
ES5中定義了9個(gè)方法來遍歷forEache()、映射map()、過濾filter()、檢測(cè)every() some()、簡(jiǎn)化reduce() reduceRight()和搜索indexOf() lastIndexOf()數(shù)組。九種方法不會(huì)修改調(diào)用它的數(shù)組，但是傳入的函數(shù)會(huì)。
九種方法基本都屬于過程抽象，第一個(gè)參數(shù)基本都是一個(gè)函數(shù)，對(duì)數(shù)組的每個(gè)元素調(diào)用該函數(shù)

Array.prototype.map()
map(fn)只有一個(gè)參數(shù)，map()方法傳遞三個(gè)參數(shù)給fn(value, index, array)，根據(jù)需要選擇。其調(diào)用方式與forEach()相似，但是傳遞給map(fn)的函數(shù)fn有返回值。

map()返回的是新數(shù)組，不修改原數(shù)組


如果是稀疏數(shù)組，返回稀疏素組；具有相同的長度與缺失元素
var a = [1, 2, 3];
a.map(function(value) {
  return value * value;     //map()傳入的函數(shù)必須要有返回值，將返回值作為返回?cái)?shù)組的元素的值
});          //==> [1, 4, 9]，原數(shù)組a還是[1, 2, 3]不變


Array.prototype.filter()
filter()方法返回的數(shù)組是調(diào)用數(shù)組的一個(gè)子集。通過傳遞的函數(shù)進(jìn)行邏輯判斷，如果返回值是true，當(dāng)前元素被添加到返回的子集中；如果返回false，則過濾掉該元素；

filter()會(huì)跳過稀疏數(shù)組中缺失的元素，返回的總是稠密數(shù)組。

arr.filter(function() {return true;});  會(huì)過濾掉所有缺失的元素；


arr.filter(funtion(x) {return (x !== undefined && x !=null)})：過濾掉undefined和null
var a = [5, 4, 3, 2, 1];
a.filter(function(value) {
  return value < 3;
});        // ==> [2, 1]
a.filter(function(value, index) {
  return index % 2 === 0;  //過濾掉索引為奇數(shù)的元素
});     // ==> [5, 3, 1]，不會(huì)改變?cè)瓟?shù)組



Array.prototype.every()和Array.prototype.some()

every()和some()用于對(duì)數(shù)組進(jìn)行邏輯判斷，返回true或`false；每個(gè)元素應(yīng)用傳入的函數(shù)進(jìn)行判斷：

every()方法：當(dāng)且僅當(dāng)數(shù)組中所有元素調(diào)用函數(shù)的判斷結(jié)果為true時(shí)，才返回true

some()方法：至少有一個(gè)元素調(diào)用函數(shù)的判斷結(jié)果為true時(shí)，返回true

every()和some()在確定返回true或false后會(huì)停止遍歷數(shù)組。類似&&和||的短路特性


在空數(shù)組上調(diào)用，根據(jù)慣例，every()返回true，some()返回false
var a = [5, 4, 3, 2, 1];
a.every(function(value) {
  return value < 10;
});      //  ==>true，所有的值都小于10
a.every(function(value) {
  return value % 2 === 0;
});    // ==> false，不是所有元素都是偶數(shù)

a.some(function(value) {
  return value % 2 === 0;
});    // ==> true，數(shù)組a中有偶數(shù)
a.some(isNaN);   //  ==> false，a中所有元素都不是非數(shù)值元素



Array.prototype.reduce()和Array.prototype.reduceRight()

reduce()和reduceRight()：使用指定函數(shù)將數(shù)組中的元素進(jìn)行組合，生成單個(gè)值。在函數(shù)式編程中常用，稱為注入和折疊。ruduceRight()的工作原理與reduce()相同，只是從右側(cè)開始索引
reduce(fn, init)有兩個(gè)參數(shù)：

fn是執(zhí)行簡(jiǎn)化操作的函數(shù)；

init是傳遞給簡(jiǎn)化函數(shù)的初始值，如果不指定，默認(rèn)為數(shù)組的第一個(gè)元素


reduce()傳遞給化簡(jiǎn)函數(shù)fn(init, value, index array)四個(gè)參數(shù)：

init：第一次調(diào)用函數(shù)時(shí)，init是reduce()傳入的初始值，如果reduce()沒有指定第二個(gè)參數(shù)，默認(rèn)使用數(shù)組的第一個(gè)元素；以后的調(diào)用中，其值等于化簡(jiǎn)函數(shù)的返回值


value、index、array：分別是數(shù)組元素、元素索引和數(shù)組本身。
var a = [1, 2, 3, 4, 5];
a.reduce(function(init, value) {
  return init + value;
}, 0);    //初始值init是0，返回累加的結(jié)果==> 15
//初始值為1，如果不指定，默認(rèn)為數(shù)組的第一個(gè)元素
a.reduce(function(init, value) {return init * value;}, 1);  //  ==>120
a.reduce(function(init, value) {return (init > value)? init: value;});

var a = [2, 3, 4];
//計(jì)算2^(3^4)，乘方操作的優(yōu)先順序是從右到左。
a.reduceRight(function(init, value) {return Math.pow(value, init);});


a.reduce(function(init, value) {return init + value;}, 0); 的執(zhí)行過程：

化簡(jiǎn)函數(shù)第一次調(diào)用時(shí)，reduce()方法將0傳遞給函數(shù)的init參數(shù)，將數(shù)組的第一個(gè)元素傳遞給value

執(zhí)行化簡(jiǎn)函數(shù)，將返回值賦予init，再次繼續(xù)下次調(diào)用



Array.prototype.indexOf()和Array.prototype.lastIndexOf()

搜索整個(gè)數(shù)組中指定值，返回第一個(gè)匹配值的索引，如果沒有找到返回-1。indexOf()從頭到尾查找、lastIndexOf()從尾到頭查找。
indexOf()與lastIndexOf()的參數(shù)沒有函數(shù)，第一個(gè)參數(shù)是查找的值；第二個(gè)參數(shù)可選，指定開始查找的索引位置
//查找數(shù)組中所有出現(xiàn)的value，返回一個(gè)包含匹配值索引的數(shù)組
function findall(arr, value) {
  var results = [];
  var len = a.length;
  var index = 0;         //開始查找的索引

  while(index < len) {   //arr.indexOf(arr, index)中第二個(gè)參數(shù)是為了過濾掉之前已經(jīng)查找過的數(shù)組元素
    index = arr.indexOf(value, index);    //避免重復(fù)的同時(shí)，加快了搜索效率
    if(index === -1) {break;}      //如果未找到，便退出；因?yàn)閒orEach()退出循環(huán)不方便，所以使用while
    results.push(index);
    index += 1;
  }
}

4 類數(shù)組對(duì)象
4.1 數(shù)組類型
判斷一個(gè)未知的對(duì)象是否為數(shù)組，可以使用ES5提供的Array.isArray()方法，定義在Array()構(gòu)造器函數(shù)上，沒有定義在Array.prototype原型上。
Array.isArray([]);    //  ==>true
Array.isArray({});    //  ==>false
因?yàn)?b>typeof和instanceof在判斷Array類型時(shí)比較繁復(fù)，所以使用同一的Array.isArray()來判斷。isArray()方法的可能實(shí)現(xiàn)：
//Function.isArray || function(o)用來判斷程序中是否有同名的isArray函數(shù)，確保不會(huì)重寫原有函數(shù)。
var isArray = Function.isArray || function(o) {
  return (typeof o === "object") && (Object.prototype.toString.call(o) === "[object Array]");
};
4.2 類數(shù)組對(duì)象
JS中數(shù)組的部分特性是其余對(duì)象沒有的：

新元素添加到數(shù)組后，自動(dòng)更新length屬性

設(shè)置length為較小值時(shí)，截?cái)鄶?shù)組

從Array.prototype中繼承屬性

類屬性為Array


這4點(diǎn)并不是數(shù)組的本質(zhì)。但是可以將一個(gè)用于length屬性（值為數(shù)值），其余屬性為非負(fù)整數(shù)（索引）的對(duì)象看做類數(shù)組。由于數(shù)組的方法通用性很強(qiáng)，可以使用數(shù)組的方法來操作類數(shù)組對(duì)象，只是類數(shù)組對(duì)象并未繼承Array.prototype對(duì)象，所以需要Function.call()來間接調(diào)用。
var a = {"0": "a", "1": "b", "2": "c", "length": 3};   //類數(shù)組對(duì)象
Array.prototype.join.call(a, ",");      // ==> "a,b,c"
Array.prototype.slice.call(a, 0);     //  ==> ["a", "b", "c"]真正數(shù)組的副本
Array.prototype.map.call(a, function(value) {
  return value.toUpperCase();
});      //  ==> ["A", "B", "C"]
函數(shù)的參數(shù)arguments對(duì)象和document.getElementsByTagName()獲取的對(duì)象都是類數(shù)組對(duì)象。檢測(cè)一個(gè)對(duì)象是否是類數(shù)組對(duì)象：
//判斷o是否為類數(shù)組對(duì)象
//字符串和函數(shù)有l(wèi)ength屬性，使用typeof將其排除
//在DOM中，文本節(jié)點(diǎn)有l(wèi)ength屬性，要額外調(diào)用o.nodeType !== 3排除
function isArrayLike(o) {
  if(o && typeof o === "object" &&    //非null和undefined，并且是對(duì)象
      isFinite(o.length) &&
      o.length >= 0 &&
      o.length == Math.floor(o.length) &&   //o.length是整數(shù)
      o.length < Math.pow(2, 32)) {   //數(shù)組索引的上限是2^32-1
    retun true;
  } else {
    return false;
  }
}
4.3 作為數(shù)組的字符串
在ES5中，字符串的行為類似于只讀的數(shù)組，可以使用charAt()訪問單個(gè)字符，也可以通過[]訪問單個(gè)字符。
var s = "test";
s.charAt(0);   // ==> "t"
s[1];   // ==> "e"
使用[]的索引形式訪問字符串，可以簡(jiǎn)化charAt()的調(diào)用。因?yàn)樽址糜诜秦?fù)的整數(shù)length屬性，每個(gè)字符的索引是非負(fù)整數(shù)，可以將字符串看做類數(shù)組對(duì)象，使用數(shù)組的方法來操作字符串。
調(diào)用的方法不能改變?cè)址?b>splice()、sort()、reverse()、pop()、push()、shift()與unshift()方法不能使用，使用數(shù)組方法修改字符串會(huì)導(dǎo)致錯(cuò)誤，但是沒有錯(cuò)誤提示

var s = "javascript";
Array.prototype.join.call(s, " ");  // ==>"j a v a s c r i p t"
總結(jié)

使用對(duì)象字面量方式創(chuàng)建數(shù)組

數(shù)組元素的讀寫都可以通過[]

對(duì)于稀疏數(shù)組，其length屬性大于元素的個(gè)數(shù)

ES5之后，單純的數(shù)組遍歷可以使用forEach()，對(duì)于需要判斷跳出循環(huán)遍歷的，可以使用for循環(huán)替代、或使用try-catch

數(shù)組的操作方法都定義在Array.prototype原型對(duì)象上，可以對(duì)數(shù)組進(jìn)行：forEach()、map()、every()和some()、filter()、reduce()和reduceRinght()、indexOf()和lastIndexOf()、splice()、sort()、reverse()

類數(shù)組對(duì)象指有非負(fù)整數(shù)的length值，并且索引為非負(fù)整數(shù)的對(duì)象，類數(shù)組對(duì)象可以使用數(shù)組的方法來操作，使用Function.call()來間接調(diào)用即可