第七章：數(shù)組
2017.02.27
數(shù)組
數(shù)組是值的有序集合。每個值叫做一個元素，而每個元素在數(shù)組中有一個位置，以數(shù)字表示，稱為索引。
JavaScript數(shù)組是無類型的：數(shù)組元素可以是任意類型，并且同一個數(shù)組中的不同元素也可能有不同的類型。
索引是基于零的32位數(shù)值：第一個元素的索引是0，最大可能的索引是2^32-2(4294967294)。數(shù)組最大能容納4294967295個元素。JavaScript數(shù)組是動態(tài)的：根據(jù)需要它們會增長或縮短，并且在創(chuàng)建數(shù)組時無須聲明一個固定的大小或者在數(shù)組大小變化時無須重新分配空間。
JavaScript數(shù)組可能是稀疏的：數(shù)組元素的索引不一定要連續(xù)，它們之間可以有空缺。每個JavaScript數(shù)組都有一個length屬性。針對非稀疏數(shù)組，該屬性就是數(shù)組元素的個數(shù)。針對稀疏數(shù)組，length比所有元素的索引要大。
數(shù)組是對象的特殊形式，數(shù)組索引實際上和碰巧是整數(shù)的屬性名差不多。數(shù)組的實現(xiàn)是經(jīng)過優(yōu)化的，用數(shù)字索引訪問數(shù)組元素一般來說比訪問常規(guī)的對象屬性要快很多。
數(shù)組繼承自Array.prototype中的屬性，它定義了一套豐富的數(shù)組操作方法。
創(chuàng)建數(shù)組
使用數(shù)組直接量是創(chuàng)建數(shù)組最簡單的方法，在方括號中將數(shù)組元素用逗號隔開即可。
數(shù)組直接量中的值不一定要是常量：它們可以是任意的表達(dá)式。
如果省略數(shù)組直接量中的某個值，省略的元素將被賦予undefined。
數(shù)組直接量的語法允許有可選的結(jié)尾的逗號，故[,,]只有兩個元素而非三個。
var empty=[];
var primes=[1,2,3,4,5];
var misc=[1.1,true,"a",[1,{x:1,y:2}],{x:3,y:4}];
var base=1024;var table=[base,base+1,base+3];
var count=[1,,3];//三個元素，1 undefined 3
var undefs=[,,];//兩個元素，undefined undefined
使用構(gòu)造函數(shù)Array()是創(chuàng)建數(shù)組的另一種方法，可以用三種方式調(diào)用構(gòu)造函數(shù)：
//調(diào)用時沒有參數(shù)，創(chuàng)建一個沒有任何元素的空數(shù)組，等同于數(shù)組直接量[].
var a=new Array();
//調(diào)用時有一個參數(shù)，指定長度。數(shù)組中沒有存儲值，數(shù)組的索引屬性也為定義。
var a=new Array(10);
a; //[ , , , , , , , , , ];9個逗號
a.length; //10
for (i in a) console.log(i);//什么都不打印
//顯示指定兩個或多個數(shù)組元素或者數(shù)組的一個非數(shù)值元素。
var a=new Array(5,4,3,2,1,"testing","testing");
> var a=new Array(1)
undefined
> a
[ ]
> var a=new Array("test")
undefined
> a
[ 'test' ]
> var a=new Array(5,4,3,2,1,"testing","testing");
undefined
> a
[ 5, 4, 3, 2, 1, 'testing', 'testing' ]
數(shù)組元素的讀和寫
使用[]操作符來訪問數(shù)組中的一個元素。數(shù)組的引用位于方括號的左邊。方括號中是一個返回非負(fù)整數(shù)值的任意表達(dá)式。使用該語法既可以讀又可以寫數(shù)組的一個元素。
var a=["world"];
var value=a[0];
a[1]=3.14;
i=2;
a[i]=3;
a[i+1]="hello";
a[a[i]]=a[0];
素組是對象的特殊形式。數(shù)組的特別之處在于，當(dāng)使用小于232-2的非負(fù)整數(shù)作為屬性名的時候數(shù)組會自動維護(hù)其length屬性值。所有的索引都是屬性名，但是只有0-232-2之間的整數(shù)屬性名才是索引。所有的數(shù)組都是對象，可以為其創(chuàng)建任意名字的屬性。但如果使用的屬性是數(shù)組的索引，數(shù)組的特殊行為就是將根據(jù)需要更新它們的length屬性值。
注意：可以使用負(fù)數(shù)或非整數(shù)來索引數(shù)組。這種情況下，數(shù)值轉(zhuǎn)化為字符串，字符串作為屬性名來用。如果使用非負(fù)整數(shù)的字符串，他就當(dāng)做數(shù)組索引，當(dāng)使用一個浮點數(shù)和一個整數(shù)相等時情況也是一樣的。
a[-1.23]=true;//創(chuàng)建名為"-1.23"的屬性
a["1000"]=0;//這是數(shù)組的第1001個元素
a[1.000];//和a[1]相等
> var a=[]
undefined
> a
[]
> a["x"]=1;
1
> a
[ x: 1 ]
> a.y=3
3
> a
[ x: 1, y: 3 ]
> a[0]=100
100
> a
[ 100, x: 1, y: 3 ]
> a[1]
undefined
> a.x
事實上，數(shù)組索引僅僅是對象屬性名的一種特殊類型。這意味著JavaScript數(shù)組沒有”越界“錯誤的概念。當(dāng)時圖查詢熱河對象中不存在的屬性時，不會報錯，只會得到undefined值。
在ES5中，數(shù)組可以定義元素的getter和setter方法。如果一個數(shù)組集成了元素或使用了元素的getter和setter方法，你應(yīng)該期望它使用非優(yōu)化的代碼路徑：訪問這種數(shù)組的元素的時間會與常規(guī)對象屬性的查找時間相近。
稀疏數(shù)組
稀疏數(shù)組就是包含從0開始的不連續(xù)索引的數(shù)組。通常，數(shù)組的length屬性值代表數(shù)組中元素的個數(shù)，如果數(shù)組是稀疏的，length屬性值大于元素的個數(shù)?？梢杂肁rray()構(gòu)造函數(shù)或簡單地指定數(shù)組的索引值大于當(dāng)前數(shù)組來創(chuàng)建稀疏數(shù)組。
a=new Array(5);//數(shù)組沒有元素，length為5
a=[];//創(chuàng)建一個空數(shù)組，length為0
a[1000]=0;//賦值添加一個元素，設(shè)置length為1001
也可以用delete產(chǎn)生稀疏數(shù)組。
足夠稀疏的數(shù)組通常在實現(xiàn)上比稠密的數(shù)組更慢，內(nèi)存利用率更高，在這樣的數(shù)組中查找元素的時間與常規(guī)屬性的查找時間一樣長。
數(shù)組長度
每個JavaScript數(shù)組都有一個length屬性。針對非稀疏數(shù)組，該屬性就是數(shù)組元素的個數(shù)。針對稀疏數(shù)組，length比所有元素的索引要大。
在數(shù)組中，找不到一個元素的索引值大于或等于它的長度。
設(shè)置length屬性為一個小魚當(dāng)前長度的非負(fù)整數(shù)n時，當(dāng)前數(shù)組中那些索引值大于或等于n的元素將被刪除。
var a=[1,2,3,4,5]
a.length;//5
a.length=3;//現(xiàn)在為[1,2,3]
a.length=0;//現(xiàn)在為[]
a.length=5;//長度為5，但沒有元素，就像new Array() ;[undefined × 5]
在ES5中，可以用Object.defineProperty()讓數(shù)組的length屬性只讀。
a=[1,2,3];
Object.defineProperty(a,"length",{writable:false});
a.length=0;//無效
a.length;//3
數(shù)組元素的添加和刪除
a=[];//空數(shù)組
a[0]="zero";
a[1]="one";
刪除元素不會修改數(shù)組length屬性。也不會將元素從高索引處一下來補(bǔ)充已刪除屬性留下的空白。刪除元素會使數(shù)組變成稀疏數(shù)組。
a=[1,2,3]
delete a[0];//true
a;//[undefined × 1, 2, 3]
a.length;//3
delete a[2];//tru
a;//[undefined × 1, 2, undefined × 1]
a.length;//3
push()
使用push()方法在數(shù)組末尾增加一個或多個元素。
a=[];
a.push("zero");//a=["zero"]
a.push("one","two");//a=["zero","one","two"];
pop()
使用pop()方法從數(shù)組尾部減少一個元素并返回元素的值。
數(shù)組遍歷
var keys=Object.keys(o);
var values=[];
for(var i=0,len=keys.length;i<len;i++){
if (!a[i]) continue;//跳過null,undefined,不存在的元素
if(!a.hasOwnProperty(i)) continue;//跳過繼承的屬性
var key=keys[i];
values[i]=o[key];
}
【求數(shù)組平方和】
var data=[1,2,3,4,5];
var sum=0;
data.forEach(function(x){
sum+=x*x;
});
sum;//55
多維數(shù)組
數(shù)組的數(shù)組。
var table=new Array(10);
for (var i=0;i<table.length;i++){
table[i]=new Array(10);
}
for(var row=0;row<table.length;row++){
for(col=0;col<table[row].length;col++){
table[row][col]=row*col;
}
}
table[5][7];//35
數(shù)組方法
join()
Array.join()方法將數(shù)組中所有元素都轉(zhuǎn)化為字符串并連接在一起，返回最后生成的字符串?？梢灾付ㄒ粋€可選的字符串在生成的字符串中來分隔數(shù)組的各個元素。如果不指定分隔符，默認(rèn)用逗號。
var a=[1,2,3];
a.join();//"1,2,3"
a.join(" ");//"1 2 3"
a.join("");//"123"
var b=new Array(10);
b.join('-');//"---------":9個連字符
reverse()
Array.reverse()方法將數(shù)組中的元素顛倒順序，返回逆序的數(shù)組。采用替換，不通過重新排列元素創(chuàng)建新數(shù)組，而是在原來的數(shù)組中重新排列它們。
var a=[1,2,3];
a.reverse();//[3,2,1]
sort()
Array.sort()方法將數(shù)組中的元素排序并返回排序后的數(shù)組。當(dāng)不帶參數(shù)調(diào)用sort()時，數(shù)組元素以字母表順序排序（必要時臨時轉(zhuǎn)化為字符串進(jìn)行比較）。
var a=["banana","apple","peach"];
a.sort();//[ 'apple', 'banana', 'peach' ]
如果包含undefined元素，會排到數(shù)組的尾部。
> var a=['a',,,,'b']
undefined
> a.sort()
[ 'a', 'b', , , ]
按照其他方式排序需要傳遞一個比較函數(shù)。該函數(shù)決定了它的兩個參數(shù)在排好序的數(shù)組中的先后順序。假設(shè)第一個參數(shù)應(yīng)該在前，比較函數(shù)應(yīng)該返回一個小于0的數(shù)值。繁殖，假設(shè)第一個參數(shù)應(yīng)該災(zāi)后，函數(shù)應(yīng)該返回一個大于0的數(shù)值。假設(shè)兩個值相等（順序無關(guān)緊要），函數(shù)應(yīng)該返回0。
【對數(shù)字按照數(shù)值大小進(jìn)行排序】
var a=[33,4,1111,222];
a.sort();//[ 1111, 222, 33, 4 ]
a.sort(function(a,b){return a-b;});//[ 4, 33, 222, 1111 ] 從小到大
a.sort(function(a,b){return b-a;});//[ 1111, 222, 33, 4 ] 從大到小
【對字符串執(zhí)行不區(qū)分大小寫的字母表排序】
a=["ant","Bug","cat","Dog"]
a.sort();//[ 'Bug', 'Dog', 'ant', 'cat' ]
a.sort(function(s,t){
var a=s.toLowerCase();
var b=t.toLowerCase();
if(a>b)return 1;
if(a<b)return -1;
return 0;
});//[ 'ant', 'Bug', 'cat', 'Dog' ]
concat()
Array.concat()方法創(chuàng)建并返回一個新數(shù)組，它的元素包括調(diào)用concat()的原始數(shù)組的元素和concat()的每個參數(shù)。如果這些參數(shù)中的任何一個自身是數(shù)組，則連接的是數(shù)組的元素，而非數(shù)組本身。
concat()不會遞歸扁平化數(shù)組的數(shù)組。concat()也不會修改調(diào)用的數(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 ]
a.concat(4,[5,[6,7]]);//[ 1, 2, 3, 4, 5, [ 6, 7 ] ]
slice()
Array.slice()方法返回指定數(shù)組的一個片段或子數(shù)組。它的兩個參數(shù)分別制定了片段的開始和結(jié)束的位置。
返回的數(shù)組包含第一個參數(shù)指定的位置和所有到但不包含第二個參數(shù)指定的位置之間的所有數(shù)組元素。
如果只制定一個參數(shù)，返回的數(shù)組將包含從開始位置到數(shù)組結(jié)尾的所有元素。
如果參數(shù)中出現(xiàn)負(fù)數(shù)，則表示相對于數(shù)組中的最后一個元素的位置。例如，-1指定最后一個元素，-3指定倒數(shù)第三個元素。
slice()不會修改調(diào)用的數(shù)組。
var 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 ]
a.slice(-3,-2);//[ 3 ]
splice()
Array.splice()方法是在數(shù)組中插入或刪除元素的通用方法。
splice會修改調(diào)用的數(shù)組。
從數(shù)組中刪除數(shù)組、插入元素到數(shù)組中或者同時完成這兩種操作。在插入或刪除點之后的數(shù)組元素會根據(jù)需要增加或減小他們的索引值，因此數(shù)組仍然保持連續(xù)。
splice()第一個參數(shù)指定了插入和(或)刪除的起始位置。第二個參數(shù)制定了應(yīng)該從數(shù)組中刪除的元素的個數(shù)。如果省略第二個參數(shù)，從起始點開始到數(shù)組結(jié)尾的所有元素都將被刪除。splice()返回一個由刪除元素組成的數(shù)組，或者如果沒有刪除元素就返回一個空數(shù)組。
var a=[1,2,3,4,5,6,7,8];
a.splice(4);//返回[5,6,7,8],a是[1,2,3,4]
a.splice(1,2);//返回[2,3],a是[1,4]
a.splice(1,1);//返回[4],a是[1]
splice()的前兩個參數(shù)指定需要刪除的數(shù)組元素。緊隨其后的任意個數(shù)的參數(shù)指定了需要插入到數(shù)組中的元素，從第一個參數(shù)指定的位置開始插入。
var a=[1,2,3,4,5];
a.splice(2,0,'a','b');//返回[],a是[1,2,'a','b',3,4,5]
a.splice(2,2,[1,2],3);//返回['a','b'],a是[1,2,[1,2],3,3,4,5]
注意：區(qū)別于concat(),splice()會插入數(shù)組本身而非數(shù)組的元素。
push()
push()和pop()允許將數(shù)組當(dāng)做棧來使用。
push()方法在數(shù)組的尾部添加一個或多個元素，并返回數(shù)組新的長度。
pop()方法刪除數(shù)組的最后一個元素，減小數(shù)組長度并返回刪除的值。
兩個方法都修改并替換原始數(shù)組。
組合使用push()和pop()能夠用JavaScript數(shù)組實現(xiàn)先進(jìn)后出的棧。
var stack=[];
stack.push(1,2);// stack:[1,2]，返回2
stack.pop();//stack:[1]，返回2
stack.push(3);// stack:[1,3]，返回2
stack.pop();//stack:[1]，返回3
stack.push([4,5]);//stack:[1,[4,5]]，返回2
stack.pop();//stack:[1]，返回[4,5]
stack.pop();//stack:[]，返回1
unshift()和shift()
unshift()/shift()在數(shù)組的頭部插入刪除操作。
unshift()在數(shù)組頭部添加一個或多個元素，并將已存在的元素移動到更高索引的位置來獲得足夠的空間，最后返回數(shù)組新的長度。
shift()刪除數(shù)組的第一個元素并將其返回，然后所有隨后的元素下移一個位置來填補(bǔ)數(shù)組頭部的空缺。
var a=[];
a.unshift(1);//a:[1]，返回1
a.unshift(22);//a:[22,1]，返回2
a.shifit();//a:[1]，返回22
a.unshift(3,[4,5]);//a:[3,[4,5],1]，返回3
a.shift();//a:[[4,5],1]，返回3
a.shift();//a:[1]，返回[4,5]
a.shift();//a:[]，返回1
toString()/toLocaleString()
數(shù)組的toString()將其每個元素都轉(zhuǎn)化為字符串，并且出書用逗號分割的字符串列表。輸出不包括方括號或其他任何形式的包裹數(shù)組值的分隔符。
[1,2,3].toString() //'1,2,3'
['a','b','c'].toString() //'a,b,c'
[1,[2,'c']].toString() //'1,2,c'
toLocaleString()是toString()方法的本地化版本。調(diào)用元素的toLocaleString()方法將每個數(shù)組元素轉(zhuǎn)化為字符串，并且使用本地話分隔符講這些字符串連接起來生成最終的字符串。
【ES5中的方法如下】
forEach()
從頭到尾遍歷數(shù)組，為每個元素調(diào)用指定的函數(shù)。
傳遞的函數(shù)作為forEach()的第一個參數(shù)。然后forEach()使用三個參數(shù)調(diào)用該函數(shù)：數(shù)組元素、元素的索引和數(shù)組本身。如果只關(guān)心數(shù)組元素的值，可以編寫只有一個參數(shù)的函數(shù)——額外的參數(shù)將被忽略。
var data=[1,2,3,4,5];
var sum=0;
data.forEach(function(value){sum+=value;});//累加
sum;//15
data.forEach(function(v,i,a){a[i]=v+1});
data;//[2,3,4,5,6]
forEach()方法無法再所有元素都傳遞給調(diào)用的函數(shù)之前終止遍歷。如果要提前終止，必須把forEach()方法放在一個try塊中，并能拋出一個異常。如果forEach調(diào)用的函數(shù)拋出foreach.break異常，循環(huán)會提前終止。
function foreach(a,f,t){
try{a.forEach(f,t);}
catch(e){
if(e===foreach.break) return;
else throw e;
}
}
foreach.break=new Error("StopIteration");
map()
將調(diào)用的數(shù)組的每個元素傳遞給指定的函數(shù)，并返回一個數(shù)組，它包含該函數(shù)的返回值。
a=[1,2,3];
b=a.map(function(x){return x*x;});//b是[1,4,9]
傳遞給map()的函數(shù)調(diào)用方式和傳遞給forEach()的函數(shù)的調(diào)用方式一樣。傳遞給map()的函數(shù)應(yīng)該有返回值。map()返回新數(shù)組，不修改調(diào)用的數(shù)組。如果是稀疏數(shù)組，返回的也是相同方式的稀疏數(shù)組：具有相同的長度，相同的確實元素。
filter()
返回的數(shù)組元素是調(diào)用的數(shù)組的一個子集。傳遞的參數(shù)用來邏輯判斷：函數(shù)返回true或false。如果返回值為true或是能轉(zhuǎn)化為true的值，那么傳遞給判定函數(shù)的元素就是這個子集的成員，它被添加到一個座位返回值的數(shù)組中。
a=[5,4,3,2,1];
smallvalues=a.filter(function(x){return x<3}); //[2,1]
everyother=a.filter(function(x,i){return i%2==0});//[5,3,1]
filter()會跳過稀疏數(shù)組中缺少的元素，返回的數(shù)組總是稠密的。為了壓縮稀疏數(shù)組的空缺，代碼如下：
var dense=sparse.filter(function(){return true;});
壓縮空缺并刪除undefined和null：
a=a.filter(function(x){return x!=undefined&&x!=null;});
every()和some()
數(shù)組的邏輯判定：對數(shù)組元素應(yīng)用指定的函數(shù)進(jìn)行判定，返回true或false。
every()就像數(shù)學(xué)中的"針對所有"的量詞?：當(dāng)且僅當(dāng)針對數(shù)組中的所有元素調(diào)用判定函數(shù)都返回true，它才返回true。
a=[1,2,3,4,5];
a.every(function(x){return x<10;});//true,所有值都<10
a.every(function(x){return x%2===0});//false,不是所有制都是偶數(shù)
some()就像數(shù)學(xué)中的"存在"的量詞?：當(dāng)數(shù)組中至少有一個元素調(diào)用判定函數(shù)返回true，他就返回true。
a=[1,2,3,4,5];
a.some(function(x){return x%2===0});//true:存在偶數(shù)值
a.some(isNaN);false:a不包含非數(shù)值元素
對于空數(shù)組，every()返回true，some()返回false。
some()在判定函數(shù)第一次返回true后就返回true。
every()在判定函數(shù)第一次返回false后就返回false。
reduce()和reduceRight()
reduce()和reduceRight()方法使用指定的函數(shù)將數(shù)組元素進(jìn)行組合，生成單個值。這在數(shù)學(xué)編程中是常見的操作，也可以成為”注入“，”折疊“。
var a=[1,2,3,4,5];
var sum=a.reduce(function(x,y){return x+y},0);//數(shù)組求和
var product=a.reduce(function(x,y){return x*y},0);//數(shù)組求積
var max=a.reduce(function(x,y){return x>y?x:y});//求最大值
reduce()第一個參數(shù)是執(zhí)行化簡操作的函數(shù)，化簡函數(shù)的任務(wù)就是用某種方法將兩個值組合或化簡為一個值，并返回化簡后的值。第二個參數(shù)是可選的 傳遞給函數(shù)的初始值。
第一個參數(shù)的函數(shù)參數(shù)：第一個參數(shù)是到目前為止的化簡操作累積的結(jié)果，第二到四個參數(shù)是數(shù)組元素、元素的索引和數(shù)組本身。第一次調(diào)用時，第一個參數(shù)就是一個初始值，就是傳遞給reduce的第二個參數(shù)。接下來的調(diào)用中，他就是上一次化簡函數(shù)的返回值。
空數(shù)組不帶初始值參數(shù)調(diào)用reduce()將導(dǎo)致類型錯誤異常。如果調(diào)用的時候只有一個值，數(shù)組只有一個元素并且沒有指定初始值，或者有一個空數(shù)組并且制定一個初始值，reduce()將返回那個值而不會調(diào)用化簡函數(shù)。
reduceRight()按照數(shù)組索引從高到低(從右到左)處理數(shù)組，而不是從高到低。
var a=[2,1,4];
a.reduceRight(function(accumulator,value){
return Math.pow(value,accumulator);
});
使用reduce()計算任意數(shù)目的對象的并集：
function extend(o,p){for(prop in p) {o[prop]=p[prop];};return o}
function union(o,p){return extend(extend({},o),p);}
var objects=[{x:1},{y:2},{z:3}];
var merged=objects.reduce(union);//{x:1,y:2,z:3}
當(dāng)擁有同名屬性時.
var objects=[{x:1,a:1},{y:2,a:2},{z:3,a:3}];
var leftunion=objects.reduce(union);//{ x: 1, a: 3, y: 2, z: 3 }
var rightunion=objects.reduceRight(union);//{ z: 3, a: 1, y: 2, x: 1 }
indexOf()/lastIndexOf()
搜索整個數(shù)組中具有給定值的元素，返回找到的第一個元素的索引或者沒有找到返回-1。indexof從頭至尾搜索，lastIndexOf()反向搜索，
第一個參數(shù)是需要搜索的值，第二個參數(shù)是可選的：指定數(shù)組中的一個索引，從那里開始搜索。省略從頭搜索(indexOf)或從尾搜索(lastIndexOf)。第二個參數(shù)可以是負(fù)數(shù)，代表相對于數(shù)組尾部的偏移量。
a=[0,1,2,3,1,2,3,0,1];
a.indexOf(1);//1
a.indexOf(1,2);//4
a.lastIndexOf(1);//8
a.lastIndexOf(1,-2);//4
a.indexOf(-1);//-1
數(shù)組類型
Array.isArray()判斷是否是數(shù)組。
Array.isArray([]);//true
Array.isArray({});//false
類數(shù)組對象
數(shù)組特性：
- 自動跟新length屬性。
- 設(shè)置length為較小值將截斷數(shù)組。
- 從Array.prototype繼承一些方法
- 類屬性為”Array“
【判斷是否是類數(shù)組對象】
function isArrayLike(o){
if(o&&typeof o==="object" &&isFinite(o.length)&&o.length==Math.floor(o.length)&&o.length<4294967296){
return true;
}else{
return false;
}
}
var a={"0":"a","1":"b","2":"c",length:3};
Array.prototype.join.call(a,"+");//"a+b+c"
Array.prototype.slice.call(a,0);//["a","b","c"];
Array.prototype.map.call(a,function(x){return x.toUpperCase();});//["A","B","C"]
作為數(shù)組的字符串
字符串的行為類似于只讀的數(shù)組。
var s="test";
s.charAt(0);//"t"
s[1];//"e"
s="JavaScript"
Array.prototype.join.call(s," ");//'J a v a S c r i p t'
Array.prototype.filter.call(s,function(x){
return x.match(/[^aeiou]/);
}).join("");//'JvScrpt'
字符串是不可變的。把它們當(dāng)做數(shù)組看待時，它們只讀。push(),sort(),reverse(),splice()等會修改數(shù)組，使用這些方法會導(dǎo)致錯誤。
Array.prototype.push.call(s,"~");
//TypeError: Cannot assign to read only property 'length' of object '[object String]'