摘要：的內(nèi)置函數(shù)整理了一些語(yǔ)言精粹的方法一章的整理出的的內(nèi)置方法之后還會(huì)整理標(biāo)準(zhǔn)入門的新添加的方法整理這些作用一方面是更好的理解記憶另一方面是對(duì)于類數(shù)組可以使用原型鏈的調(diào)用即可中的一些函數(shù)輸出的為的結(jié)果因此的作用是連接數(shù)組當(dāng)然可以是數(shù)字也會(huì)加入到

整理了一些Javascript語(yǔ)言精粹的方法一章的整理出的ES5的內(nèi)置方法;

之后還會(huì)整理"ES6標(biāo)準(zhǔn)入門"的新添加的ES6方法;

整理這些作用一方面是更好的理解記憶,另一方面是對(duì)于類數(shù)組arguments,可以使用原型鏈的調(diào)用(Array.prototype.call(...))即可;

1.array.concat(item....)

>var a = [1,2,3];
>
>b = a.concat([4,5,6]);

輸出的b為a+b的結(jié)果[1,2,3,4,5,6];因此array.concat的作用是連接數(shù)組,當(dāng)然item可以是數(shù)字也會(huì)加入到里面;

2.array.join(separator)

作用是把一個(gè)數(shù)組變成一個(gè)字符串,中間使用separator連接;

>var a = [1,2,3];
>
>b = a.join(""); //b = "123"
>
>c = a.join(","); //c = "1,2,3"
>

3.array.pop() && array.push()

數(shù)組的標(biāo)準(zhǔn)操作,大概的思路是返回和添加一個(gè)元素到最后一個(gè);

然后push返回的是加入之后的數(shù)組長(zhǎng)度;pop返回的是數(shù)組的被踢出的值;

共同的特性就是都會(huì)改變數(shù)組原來(lái)的數(shù)值;

4.array.reverse();

數(shù)組原地逆轉(zhuǎn),然后返回這個(gè)逆轉(zhuǎn)的數(shù)組;

5.array.shift();

移除數(shù)組頭元素,并且返回,速度并沒(méi)有pop快;

6.array.unshift();

把數(shù)組加到頭元素,返回新的數(shù)組的長(zhǎng)度;

7.array.slice(start,end);

類似于python的切片;返回的是淺復(fù)制的數(shù)組

8.array.splice(start,deleteCount,item..)

從start的點(diǎn)開(kāi)始刪除deleteCount個(gè)數(shù)的元素,然后再這個(gè)地點(diǎn)加入item元素;返回刪除的元素

>var a= [1,2,3];
>
>var b = a.splice(1,2,[1,2,3]) // a = [1,[1,2,3]]; b = [2,3]

9.array.sort(comparefn);

如果不加入comparafn的情況下,sort函數(shù)會(huì)按照字符串的形式來(lái)排序;

> a = [1,22,33,12,112]
[ 1, 22, 33, 12, 112 ]
> a.sort()
[ 1, 112, 12, 22, 33 ]

因此我們?cè)谑褂胹ort函數(shù)的時(shí)候,我們應(yīng)該使用comparefn;下面說(shuō)下這個(gè)函數(shù)的作用機(jī)制:

比較函數(shù)comparefn接受兩個(gè)參數(shù):a,b;

然后comparefn會(huì)返回一個(gè)數(shù)值,如果返回的值大于0,那么就調(diào)換順序,如果小于0,那么就不會(huì)調(diào)換順序;

aList = [1,2,3];
ab = function(a,b){return a-b};
ba = function(a,b){return b-a};

aList.sort(ab); //[1,2,3]
aList.sort(ba);    //[3,2,1] 因?yàn)橐来吮闅vb-a,然后大于0就調(diào)換位置;

然后語(yǔ)言精粹里面加入了更加復(fù)雜的一些比較函數(shù):

var m = ["aa","bb","a",4,8,15,16,23,42];
m.sort(function(a,b){
    if(a===b){ 
        return 0;
    }
    if(typeof a ===typeof b){
        return a < b? -1:1;
    }
    
    //"string" > "number",會(huì)讓number在前面
    return typeof a < typeof b? -1:1;
});


// m為 4,8,15,16,23,42,a,aa,bb

然后繼續(xù)拓展一個(gè)更加高級(jí)的比較方法,用來(lái)比較對(duì)象里面的屬性的排序:

var s = [
    {first:"Joe",last:"Besser"},
    {first:"Moe",last:"Howard"},
    {first:"Joe",last:"Derita"},
    {first:"Curly",last:"Howard"},
    {first:12,last:"Howard"}

];

//這里的direction為 1或者-1.其中-1為正序(升高排列);
var by = function(name,direction){
    return function(o,p){
        var a,b;
        //下面是為了首先判斷是object,而且不是null;
        if(typeof o === "object" && typeof p ==="object" && o&& p){
            a =o[name];
            b = p[name];
            if( a=== b){
                return 0;
            }
            if(typeof a === typeof b){
                return a
如果還需要比較第二個(gè)last的排序,那么可以繼續(xù)拓展,改變上面如果a===b的時(shí)候排序方法:
var by = function(name,minor,direction){
    .....//不變的部分
    if(a===b){
        return typeof minor ==="function"? minor(o,p):0;
    }
    .....//不變
}


//相當(dāng)于遞歸了一次調(diào)用方法是
s.sort(by("first",by("last"),-1));
當(dāng)然我也在這里碰到了一個(gè)問(wèn)題
//如果只是調(diào)用一次排序函數(shù),那么這樣是沒(méi)問(wèn)題的
s.sort(by("first",-1));
//如果兩個(gè)同時(shí)調(diào)用:
s.sort(by("first",1));
s.sort(by("first",-1));
//返回的對(duì)象的排序方式是一模一樣的;
//所以這樣的話,也就是第二個(gè)方法其實(shí)并沒(méi)有奏效;
//查了下似乎是回調(diào)機(jī)制問(wèn)題,以后再研究;
function
1.function.apply(thisArg,argArray);
其實(shí)call和apply很像,call只是apply的語(yǔ)法糖寫法;
apply的作用還是顯式的綁定this到函數(shù)上面;
詳細(xì)的可見(jiàn)你不知道的Javascript上冊(cè)
Object
1.object.hasOwnProperty(name)
最有用的地方就是遍歷對(duì)象的屬性了
Number
1.number.toExponential(fractionDigits)
轉(zhuǎn)化為字符串,用指數(shù)形式表示,并且選擇保留小數(shù)點(diǎn)后幾位的問(wèn)題
> Math.PI.toExponential(2)
"3.14e+0"
> Math.PI.toExponential(3)
"3.142e+0"
> Math.PI.toExponential(5)
"3.14159e+0"
2.number.toFixed(fractionDigits)
轉(zhuǎn)化為字符串,并且選擇保留小數(shù)點(diǎn)后幾位的問(wèn)題
> Math.PI.toFixed(2)
"3.14"
> Math.PI.toFixed(3)
"3.142"
3.number.toString(radix)
數(shù)字轉(zhuǎn)化為字符串,radix是控制多少進(jìn)制
> Math.PI.toString()
"3.141592653589793"
> Math.PI.toString(2)
"11.001001000011111101101010100010001000010110100011"
> Math.PI.toString(8)
"3.1103755242102643"
String
1.string.indexOf(searchString,position)
尋找string里面的字符串里面的字符串,而且從position的位置開(kāi)始;沒(méi)找到返回-1
> var text = "Mississippi"
> text.indexOf("ss")
2
> text.indexOf("ss",2)
2
> text.indexOf("ss",3)
5
> text.indexOf("ss",6)
-1
2.string.match(regexp)
和正則表達(dá)式匹配..以后再更新
3.string.replace(searchValue,replaceValue)
replace方法對(duì)string進(jìn)行查找和替換操作,并且返回一個(gè)新的字符串;
searchValue可以是正則表達(dá)式,如果searchvalue是普通的字符串,那么只會(huì)替換第一個(gè)
> text
"Mississippi"
> text.replace("ss","SS")
"MiSSissippi"
> text
"Mississippi"
> text.replace("ss","SS").replace("ss","SS")
"MiSSiSSippi"
下面是和正則表達(dá)式的匹配:
4.string.search(regexp)
string的search方法和indexOf方法很相似,但是只能接受正則表達(dá)式對(duì)象;
5.string.slice(start,end)
復(fù)制string的一個(gè)部分來(lái)構(gòu)造新的字符串,這個(gè)方法和array.slice()很類似;
> text
"Mississippi"
> text.slice(1)
"ississippi"
> text.slice(1,3) //end - start 的個(gè)數(shù)差是需要書(shū)要輸出的個(gè)數(shù)
"is"
6.string.split(separator,limit)
把字符串用separator分解成為一個(gè)數(shù)組,然后這個(gè)separator可以是正則表達(dá)式對(duì)象,
limits表示了這里需要多少個(gè);
> a = "123456789"
"123456789"
> a.split("")
[ "1", "2", "3", "4", "5", "6", "7", "8", "9" ]
> a.split("",5)
[ "1", "2", "3", "4", "5" ]

> f = "a|b|c|"
"a|b|c|"
> f.split(/|/)
[ "a", "b", "c", "" ]

7.string.toLowerCase()/toUpperCase()
兩個(gè)方法分別返回一個(gè)新的字符串,string被轉(zhuǎn)化成為大寫和小寫的格式
參考資料
JavaScript語(yǔ)言精粹