1.認識數組
數組就是某類數據的集合，數據類型可以是整型、字符串、甚至是對象 Javascript不支持多維數組，但是因為數組里面可以包含對象（數組也是一個對象），所以數組可以通過相互嵌套實現類似多維數組的功能
1.1 定義數組
聲明有10個元素的數組 復制代碼 代碼如下
: var a = new Array(10);
此時為a已經開辟了內存空間，包含10個元素，用數組名稱加 [下標] 來調用，
例如 a[2] 但此時元素並未初始化，調用將返回 undefined 以下代碼定義了個可變數組，並進行賦值 復制代碼 代碼如下:
var a = new Array(); a[0] = 10; a[1] = "aaa"; a[2] = 12.6; 上面提過了，數組里面可以放對象，例如下面代碼
var a = new Array();
a[0] = true;
a[1] = document.getElementByIdx_x("text");
a[2] = {x:11, y:22};
a[3] = new Array(); 數組可以實例化的時候直接賦值，例如 ?
var a = new Array(1, 2, 3, 4, 5);
var b = [1, 2, 3, 4, 5]; a 和 b 都是數組，只不過b用了隱性聲明，創建了另一個實例，此時如果用alert(a==b)將彈出false
1.2 多維數組 其實Javascript是不支持多維數組的，在asp里面可以用 dim a(10,3)來定義多維數組，在Javascript里面，如果用 var a = new Array(10,3) 將報錯 但是之前說過，數組里面可以包含對象，所以可以把數組里面的某個元素再聲明為數組，例如 ? 1 2 3 4 var a = new Array(); a[0] = new Array(); a[0][0] = 1; alert(a[0][0]); //彈出 1 聲明的時候賦值 ?
var a = new Array([1,2,3], [4,5,6], [7,8,9]);
var b = [[1,2,3], [4,5,6], [7,8,9]]; 效果一樣，a采用常規實例化，b是隱性聲明，結果都是生成一個多維數組
1.3 Array literals 這個還真不知中文怎么叫，文字數組？ 說到數組，不得不說到Array Literals，數組其實是特殊的對象，對象有特有屬性和方法，通過 對象名.屬性 、對象.方法() 來取值和調用，而數組是通過下標來取值，Array Literals跟數組有很多相似，都是某數據類型的集合，但是Array Literals從根本來說，是個對象，聲明和調用，跟數組是有區別
var aa = new Object();
aa.x = "cat";
aa.y = "sunny";
alert(aa.x); //彈出cat 創建一個簡單的對象，一般調用是通過aa.x，而如果當成Array literals的話，用alert(aa[“x”])一樣會彈出cat
var a = {x:"cat", y:"sunny"};
alert(a["y"]);
//彈出sunny 這是另一種創建對象的方法，結果是一樣的
2.數組元素的操作 上面已經說過，可以通過 數組[下標] 來讀寫元素 下標的范圍是 0 – (23(上標2) -1)，當下標是負數、浮點甚至布爾值的時候，數組會自動轉換為對象類型，例如
var b = new Array(); b[2.2] = "XXXXX";
alert(b[2.2]); //-> XXXXX 此時相當於b[“2.2”] = “XXXXX”
2.1數組的循環
var a = [1,2,3,4,5,6];
for(var i =0; i<a.length; i++)
{ alert(a[i]); }
這是最常用的，歷遍數組，代碼將依次彈出1至6 還有一種常用的
var a = [1,2,3,4,5,6];
for(var e in a)
{ alert(e); }
還是依次彈出1至6，for…in是歷遍對象（數組是特殊的對象）對象，用在數組上，因為數組沒有屬性名，所以直接輸出值，這結構語句用在對象上，例如下面
var a = {x:1,y:2,z:3};
for(var e in a)
{ alert(e + ":" + a[e]); } 此時e取到的是屬性名，即 x、y、x，而要取得值，則采用 數組名[屬性]，所以 a[e] 等同於 a[“x”]、a[“y”]、a[“z”]
2.2數組常用函數 concat 在現有數組后面追加數組，並返回新數組，不影響現有數組
var a = [123];
var b = "sunnycat";
var c = ["www",21,"ido"];
var d = {x:3.14, y:"SK"};
var e = [1,2,3,4,[5,6,[7,8]]];
alert(a.concat(b));
// -> 123,sunnycat alert(a);
// -> 123 alert(b.concat(c, d));
// -> sunnycatwww,21,ido[object Object] alert(c.concat(b));
// -> www,21,ido,sunnycat alert(e.concat(11,22,33).join(" # "));
// -> 1 # 2 # 3 # 4 # 5,6,7,8 # 11 # 22 # 33 需要注意的是只能用於數組或字符串，如果被連接（前面的a）的是數值、布爾值、對象，就會報錯，字符串連接數組時，字符串會跟數組首元素拼接成新元素，而數組連接字符串則會追加新元素（這點我也不清楚原委，知情者請透露），對於數組里面包含數組、對象的，連接后保持原樣 join 用指定間隔符連起來，把數組轉為字符串
var a = ['a','b','c','d','e','f','g'];
lert(a.join(","));
// -> a,b,c,d,e,f,g 相當於a.toString() alert(a.join(" x "));
// -> a x b x c x d x e x f x g 這個很容易理解，但需要注意的是只轉換一維數組里面，如果數組里面還有數組，將不是采用join指定的字符串接，而是采用默認的toString()，例如
var a = ['a','b','c','d','e','f','g',[11,22,33]];
alert(a.join(" * "));
// -> a * b * c * d * e * f * g * 11,22,33 數組里面的數組，並沒用 * 連接 pop 刪除數組最后一個元素，並返回該元素
var a = ["aa","bb","cc"];
document.write(a.pop());
// -> cc document.write(a);
// -> aa, bb 如果數組為空，則返回undefined push 往數組后面添加數組，並返回數組新長度
var a = ["aa","bb","cc"];
document.write(a.push("dd"));
// -> 4 document.write(a);
// -> aa,bb,cc,dd document.write(a.push([1,2,3]));
// -> 5 document.write(a);
// -> aa,bb,cc,dd,1,2,3 跟concat的區別在於，concat不影響原數組，直接返回新數組，而push則直接修改原數組，返回的是數組新長度 sort 數組排序，先看個例子
var a = [11,2,3,33445,5654,654,"asd","b"];
alert(a.sort());
// -> 11,2,3,33445,5654,654,asd,b 結果是不是很意外，沒錯，排序並不是按整型大小，而是字符串對比，就是取第一個字符的ANSI碼對比，小的排前面，相同的話取第二個字符再比，如果要按整型數值比較，可以這樣
var a = [11,2,3,33445,5654,654];
a.sort(function(a,b)
{ return a - b; });
alert(a);
// -> 2,3,11,654,5654,33445 sort()方法有個可選參數，就是代碼里的function，這是個簡單的例子，不可對非數字進行排序，非數字需要多做判斷，這里就不多講 reverse 對數組進行反排序跟，sort()一樣，取第一字符ASCII值進行比較
var a = [11,3,5,66,4];
alert(a.reverse());
// -> 4,66,5,3,11 如果數組里面還包含數組，則當為對象處理，並不會把元素解出來
var a = ['a','b','c','d','e','f','g',[4,11,33]];
alert(a.reverse());
// -> 4,11,33,g,f,e,d,c,b,a alert(a.join(" * "));
// -> 4,11,33 * g * f * e * d * c * b * a 按理應該是11排最后面，因為這里把 4,11,33 當做完整的對象比較，所以被排在第一位。看不明白的話，用join()串起來，就明了多 shift 刪除數組第一個元素，並返回該元素，跟pop差不多
var a = ["aa","bb","cc"]; document.write(a.shift());
// -> aa document.write(a); // -> bb,cc 當數組為空時，返回undefined unshift 跟shift相反，往數組最前面添加元素，並返回數組新長度
var a = ["aa","bb","cc"]; document.write(a.unshift(11));
// -> 4 注：IE下返回undefined document.write(a);
// -> 11,aa,bb,cc document.write(a.unshift([11,22]));
// -> 5 document.write(a);
// -> 11,22,11,aa,bb,cc document.write(a.unshift("cat"));
// -> 6 document.write(a);
// -> cat,11,22,11,aa,bb,cc 注意該方法，在IE下將返回undefined，貌似微軟的bug，我在firefox下則能正確發揮數組新長度 slice 返回數組片段
var a = ['a','b','c','d','e','f','g'];
alert(a.slice(1,2));
// -> b alert(a.slice(2));
// -> c,d,e,f,g alert(a.slice(-4));
// -> d,e,f,g alert(a.slice(-2,-6));
// -> 空 a.slice(1,2)，從下標為1開始，到下標為2之間的數，注意並不包括下標為2的元素 如果只有一個參數，則默認到數組最后 -4是表示倒數第4個元素，所以返回倒數的四個元素 最后一行，從倒數第2開始，因為是往后截取，所以顯然取不到前面的元素，所以返回空數組，如果改成 a.slice(-6,-2) 則返回b,c,d,e splice 從數組刪除某片段的元素，並返回刪除的元素
var a = [1,2,3,4,5,6,7,8,9];
document.write(a.splice(3,2));
// -> 4,5 document.write(a);
// -> 1,2,3,6,7,8,9 document.write(a.splice(4));
// -> 7,8,9 注：IE下返回空 document.write(a);
// -> 1,2,3,6 document.write(a.splice(0,1));
// -> 1 document.write(a);
// -> 2,3,6 document.write(a.splice(1,1,["aa","bb","cc"]));
// -> 3 document.write(a);
// -> 2,aa,bb,cc,6,7,8,9
document.write(a.splice(1,2,"ee").join("#"));
// -> aa,bb,cc#6 document.write(a);
// -> 2,ee,7,8,9 document.write(a.splice(1,2,"cc","aa","tt").join("#"));
// -> ee#7 document.write(a);
// -> 2,cc,aa,tt,8,9 注意該方法在IE下，第二個參數是必須的，不填則默認為0，例如a.splice(4)，在IE下則返回空，效果等同於a.splice(4,0) toString 把數組轉為字符串，不只數組，所有對象均可使用該方法
var a = [5,6,7,8,9,["A","BB"],100];
document.write(a.toString());
// -> 5,6,7,8,9,A,BB,100 var b = new Date() document.write(b.toString());
// -> Sat Aug 8 17:08:32 UTC+0800 2009 var c = function(s){ alert(s); } document.write(c.toString());
// -> function(s){ alert(s); } 布爾值則返回true或false，對象則返回[object objectname] 相比join()方法，join()只對一維數組進行替換，而toString()則把整個數組（不管一維還是多維）完全平面化 同時該方法可用於10進制、2進制、8進制、16進制轉換，例如
var a = [5,6,7,8,9,"A","BB",100];
for(var i=0; i<a.length; i++){ document.write(a[i].toString() + " 的二進制是 " + a[i].toString(2) + " ，八進制是 " + a[i].toString(8) + " ，十六進制是 " + a[i].toString(16)); // -> 4,5 } 輸出結果 5 的二進制是 101 ，八進制是 5 ，十六進制是 5 6 的二進制是 110 ，八進制是 6 ，十六進制是 6 7 的二進制是 111 ，八進制是 7 ，十六進制是 7 8 的二進制是 1000 ，八進制是 10 ，十六進制是 8 9 的二進制是 1001 ，八進制是 11 ，十六進制是 9 A 的二進制是 A ，八進制是 A ，十六進制是 A BB 的二進制是 BB ，八進制是 BB ，十六進制是 BB 100 的二進制是 1100100 ，八進制是 144 ，十六進制是 64 轉換只能在元素進行，如果對整個數組進行轉換，則原封不動返回該數組 toLocaleString 返回本地格式字符串，主要用在Date對象上
var a = new Date();
document.write(a.toString());
// -> Sat Aug 8 17:28:36 UTC+0800 2009 document.write(a.toLocaleString());
// -> 2009年8月8日 17:28:36 document.write(a.toLocaleDateString());
// -> 2009年8月8日 區別在於，toString()返回標准格式，toLocaleString()返回本地格式完整日期（在【控制面板】>>【區域和語言選項】，通過修改[時間]和[長日期]格式），toLocaleDateString()跟toLocaleString()一樣，只是少了時間 valueOf 根據不同對象返回不同原始值，用於輸出的話跟toString()差不多，但是toString()是返回string類型，而valueOf()是返回原對象類型
var a = [1,2,3,[4,5,6,[7,8,9]]];
var b = new Date();
var c = true;
var d = function(){ alert("sunnycat"); };
document.write(a.valueOf());
// -> 1,2,3,4,5,6,7,8,9 document.write(typeof (a.valueOf()));
// -> object document.write(b.valueOf());
// -> 1249874470052 document.write(typeof(b.valueOf()));
// -> number document.write(c.valueOf());
// -> true document.write(typeof(c.valueOf()));
// -> boolean document.write(d.valueOf());
// -> function () { alert("sunnycat"); } document.write(typeof(d.valueOf()));
// -> function 數組也是對象，所以typeof (a.valueOf())返回object，返回的依然是個多維數組
var a = [1,2,3,[4,5,6,[7,8,9]]];
var aa = a.valueOf(); document.write(aa[3][3][1]);
// -> 8 Date對象返回的是距離1970年1月1日的毫秒數， Math和Error對象沒有valueOf方法 Jquery 數組操作 在jquery中處理JSON數組的情況中遍歷用到的比較多，但是用添加移除這些好像不是太多。 今天試過json[i].remove(),json.remove(i)之后都不行，看網頁的DOM對象中好像JSON數據是以數組的形式出現的，查閱了下相關JS中數組的操作一試果然很爽。 記錄下來。
1、數組的創建
var arrayObj = new Array();
//創建一個數組 var arrayObj = new Array([size]);
//創建一個數組並指定長度，注意不是上限，是長度 var arrayObj = new Array([element0[, element1[, ...[, elementN]]]]);
創建一個數組並賦值 要說明的是，雖然第二種方法創建數組指定了長度，但實際上所有情況下數組都是變長的，也就是說即使指定了長度為5，仍然可以將元素存儲在規定長度以外的，注意：這時長度會隨之改變。
2、數組的元素的訪問
var testGetArrValue=arrayObj[1];
//獲取數組的元素值 arrayObj[1]= "這是新值";
//給數組元素賦予新的值
3、數組元素的添加
arrayObj. push([item1 [item2 [. . . [itemN ]]]]);
// 將一個或多個新元素添加到數組結尾，並返回數組新長度 arrayObj.unshift([item1 [item2 [. . . [itemN ]]]]);
// 將一個或多個新元素添加到數組開始，數組中的元素自動后移，返回數組新長度 arrayObj.splice(insertPos,0,[item1[, item2[, . . . [,itemN]]]]);
//將一個或多個新元素插入到數組的指定位置，插入位置的元素自動后移，返回"" 4、數組元素的刪除 ? 1 2 3 arrayObj.pop(); //移除最后一個元素並返回該元素值 arrayObj.shift();
//移除最前一個元素並返回該元素值，數組中元素自動前移 arrayObj.splice(deletePos,deleteCount);
//刪除從指定位置deletePos開始的指定數量deleteCount的元素，數組形式返回所移除的元素
5、數組的截取和合並
arrayObj.slice(start, [end]);
//以數組的形式返回數組的一部分，注意不包括 end 對應的元素，如果省略 end 將復制 start 之后的所有元素 arrayObj.concat([item1[, item2[, . . . [,itemN]]]]);
//將多個數組（也可以是字符串，或者是數組和字符串的混合）連接為一個數組，返回連接好的新的數組
6、數組的拷貝
arrayObj.slice(0);
//返回數組的拷貝數組，注意是一個新的數組，不是指向 arrayObj.concat(); //返回數組的拷貝數組，注意是一個新的數組，不是指向
7、數組元素的排序 arrayObj.reverse(); //反轉元素（最前的排到最后、最后的排到最前），返回數組地址 arrayObj.sort();
//對數組元素排序，返回數組地址
8、數組元素的字符串化 arrayObj.join(separator);
//返回字符串，這個字符串將數組的每一個元素值連接在一起，中間用 separator 隔開。 toLocaleString 、toString 、valueOf：可以看作是join的特殊用法，不常用