Javascript的內置函數(ES5)-讀Javascript語言精粹

Javascript的內置函數(ES5)

整理了一些Javascript語言精粹的方法一章的整理出的ES5的內置方法;

以後還會整理'ES6標準入門'的新添加的ES6方法;

整理這些做用一方面是更好的理解記憶,另外一方面是對於類數組arguments,可使用原型鏈的調用(Array.prototype.call(...))便可;

ES5中的一些函數

Array

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

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

輸出的b爲a+b的結果[1,2,3,4,5,6];所以array.concat的做用是鏈接數組,固然item能夠是數字也會加入到裏面;

2.array.join(separator)

做用是把一個數組變成一個字符串,中間使用separator鏈接;

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

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

數組的標準操做,大概的思路是返回和添加一個元素到最後一個;

而後push返回的是加入以後的數組長度;pop返回的是數組的被踢出的值;

共同的特性就是都會改變數組原來的數值;

4.array.reverse();

數組原地逆轉,而後返回這個逆轉的數組;

5.array.shift();

移除數組頭元素,而且返回,速度並無pop快;

6.array.unshift();

把數組加到頭元素,返回新的數組的長度;

7.array.slice(start,end);

相似於python的切片;返回的是淺複製的數組

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

從start的點開始刪除deleteCount個數的元素,而後再這個地點加入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函數會按照字符串的形式來排序;

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

所以咱們在使用sort函數的時候,咱們應該使用comparefn;下面說下這個函數的做用機制:

比較函數comparefn接受兩個參數:a,b;

而後comparefn會返回一個數值,若是返回的值大於0,那麼就調換順序,若是小於0,那麼就不會調換順序;

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] 由於依此遍歷b-a,而後大於0就調換位置;

而後語言精粹裏面加入了更加複雜的一些比較函數:

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',會讓number在前面
    return typeof a < typeof b? -1:1;
});


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

而後繼續拓展一個更加高級的比較方法,用來比較對象裏面的屬性的排序:

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<b ? direction:-direction; 
                //意思是若是是統一的類型,那麼就正序排列
            }
            return typeof a < typeof b? direction:-direction;
        }
    }
};
s.sort(by("first",-1));

若是還須要比較第二個last的排序,那麼能夠繼續拓展,改變上面若是a===b的時候排序方法:

var by = function(name,minor,direction){
    .....//不變的部分
    if(a===b){
        return typeof minor ==="function"? minor(o,p):0;
    }
    .....//不變
}


//至關於遞歸了一次調用方法是
s.sort(by("first",by("last"),-1));

固然我也在這裏碰到了一個問題

//若是隻是調用一次排序函數,那麼這樣是沒問題的
s.sort(by("first",-1));
//若是兩個同時調用:
s.sort(by("first",1));
s.sort(by("first",-1));
//返回的對象的排序方式是如出一轍的;
//因此這樣的話,也就是第二個方法其實並無奏效;
//查了下彷佛是回調機制問題,之後再研究;

function

1.function.apply(thisArg,argArray);

其實call和apply很像,call只是apply的語法糖寫法;

apply的做用仍是顯式的綁定this到函數上面;

詳細的可見你不知道的Javascript上冊

Object

1.object.hasOwnProperty(name)

最有用的地方就是遍歷對象的屬性了

Number

1.number.toExponential(fractionDigits)

轉化爲字符串,用指數形式表示,而且選擇保留小數點後幾位的問題

> 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)

轉化爲字符串,而且選擇保留小數點後幾位的問題

> Math.PI.toFixed(2)
'3.14'
> Math.PI.toFixed(3)
'3.142'

3.number.toString(radix)

數字轉化爲字符串,radix是控制多少進制

> 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的位置開始;沒找到返回-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)

和正則表達式匹配..之後再更新

3.string.replace(searchValue,replaceValue)

replace方法對string進行查找和替換操做,而且返回一個新的字符串;

searchValue能夠是正則表達式,若是searchvalue是普通的字符串,那麼只會替換第一個

> text
'Mississippi'
> text.replace("ss","SS")
'MiSSissippi'
> text
'Mississippi'
> text.replace("ss","SS").replace("ss","SS")
'MiSSiSSippi'

下面是和正則表達式的匹配:

4.string.search(regexp)

string的search方法和indexOf方法很類似,可是隻能接受正則表達式對象;

5.string.slice(start,end)

複製string的一個部分來構造新的字符串,這個方法和array.slice()很相似;

> text
'Mississippi'
> text.slice(1)
'ississippi'
> text.slice(1,3) //end - start 的個數差是須要書要輸出的個數
'is'

6.string.split(separator,limit)

把字符串用separator分解成爲一個數組,而後這個separator能夠是正則表達式對象,
limits表示了這裏須要多少個;

> 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()

兩個方法分別返回一個新的字符串,string被轉化成爲大寫和小寫的格式

參考資料

JavaScript語言精粹