摘要：引用類型和基本包裝類型的主要區別就是對象的生存期。自動創建的基本包裝類型的對象只存在于一行代碼的執行瞬間，隨后就會被銷毀。另外，構造函數也會根據傳入值的類型返回相應基本包裝類型的實例。

為了操作的遍歷，ECMAScript 還提供了3 個特殊的引用類型： Boolean、Number 和String。引用類型和基本包裝類型的主要區別就是對象的生存期。自動創建的基本包裝類型的對象只存在于一行代碼的執行瞬間，隨后就會被銷毀。

另外，Object 構造函數也會根據傳入值的類型返回相應基本包裝類型的實例。如：

var str = new Object("text");
document.write(typeof str); //object
document.write(str instanceof String); //true

使用new 調用基本包裝類型的構造函數，與直接調用同名的轉型函數是不一樣的。如：

var num1 = new Number("321"); //構造函數
document.write(num1 instanceof Number); //true
document.write(typeof num1); //object

var str = "321";
var num2 = Number(str); //轉型函數
document.write(num2 instanceof Number); //false
document.write(typeof num2); //number

Boolean 引用類型與布爾值對應。可以傳入布爾值，語法如下：

var booleanObject = new Boolean(true);
//或
var booleanObject = new Boolean(false);

該引用類型的實例會修改valueOf()和toString()方法。前者返回基本類型值true 和false；后者返回字符串"true" 和"false"。

使用Boolean 引用類型會產生在布爾表達式中使用Boolean 對象。如：

var booleanObj = new Boolean(false);
var booleanValue = false;

document.write(booleanObj && true); //true
document.write(booleanValue && true); //false

布爾表達式中的所有對象都會被轉換為true。所以建議永遠不要使用Boolean 對象。

可以調用Number 構造函數向其傳入相應的數值。如：

var num = new Number(10);

Number 類型也重寫了valueOf()、toLocaleString()和toString()方法。重寫后的valueOf()方法返回對象表示的基本類型的數值。

var num = new Number(10);
document.write(typeof num.valueOf()) //number

其中，toFixed()方法會按照指定的小數位返回數值的字符串表示，如：

var num = new Number(10);
document.write(num.toFixed(2)); //10.00

該方法很適合處理貨幣值。但不同的瀏覽器給這個方法設定的舍入規則有所不同。IE8 以及之前的版本，在給toFixed()傳入0 的情況下，不能正確舍入范圍在{[-0.94,-0.5],[0.5,0.94]}之間的值。IE9 修復了這個問題。

var num = new Number(10);
document.write(num.toFixed(21)); //RangeError: toFixed() argument must be between 0 and 20

toFixed()方法可以表示帶有0 到20 個小數位的數值。

另外，toExponential()方法可以返回以指數表示法（也稱e 表示法）表示的數值的字符串形式。如：

var num = 143210000000;
document.write(num.toExponential(3)); //1.432e+11

最后，toPrecision()方法可能會返回固定大小（fixed）格式，也可能返回指數（exponential）格式；它會根據要處理的數值決定到底是調用toFixed()還是調用toExponential()。如：

var num = 123;
document.write(num.toFixed(1)); //123.0
document.write(num.toExponential(2)); //1.23e+2

document.write(num.toPrecision(1)); //1e+2
document.write(num.toPrecision(3)); //123
document.write(num.toPrecision(4)); //123.0

toPrecision()方法可以表現1 到21 位小叔。某些瀏覽器支持的范圍更大。
仍然不建議直接實例化Number 引用類型，原因與Boolean 對象一樣。如：

var num1 = new Number(10);
var num2 = 10;

console.log(num1); //Number
console.log(num2); //10

console.log(typeof num1); //object
console.log(typeof num2); //number

console.log(num1 instanceof Number); //true
console.log(num2 instanceof Number); //false

String 類型是字符串的對象包裝類型。創建方法如下：

var str = new String("Hello World");

繼承的valueOf()、toLocaleString()和toString()方法，都返回對象所表示的基本字符串值。且每個實例都有一個length 屬性。如：

var str = new String("Hello World");
document.write(str.length); //11

String 類型提供了很多方法，用于輔助完成對ECMAScript 中字符串的解析和操作。

主要有兩個用于訪問字符串中特定字符的方法：charAt()和charCodeAt()，和一個ECMAScript 5 中的方括號表示法。

charAt()方法

該方法以單字符串的形式返回給定位置的那個字符（ECMAScript 沒有字符類型）。如：

var num = "Hello world";
console.log(num.charAt(6)); //w

charCodeAt()方法

該方法返回字符編碼。如：

var num = "Hello world";
console.log(num.charCodeAt(6)); //119

方括號表示法(ECMAScript 5)

如果在IE7 及更早版本中使用這種語法，會返回undefined 值。如：

var num = "Hello world";
console.log(num[6]); //w

拼接、刪除等方法

concat()方法

該方法用于將一個或多個字符串拼接起來。如：

var str = "hello";
var newStr = str.concat(" world","!");
document.write(str); //hello
document.write(newStr); //hello world!

實踐中，這種方法復雜麻煩不如+ 加號來的方便。

slice()方法

1 個或2 個參數，第一個參數是開始的位置，第二個參數是結束的位置。如：

var str = "hello world";
var newStr = str.slice(5,7);

document.write(str + "
" + newStr); //w

substr()方法

1 個或2 個參數，第一個參數是開始的位置，第二個參數是返回的字符的個數。如：

var str = "hello world";
var newStr = str.substr(6, 1);

document.write(str + "
" + newStr); //w

substring()方法

1 個或2 個參數，第一個參數是開始的位置，第二個參數是結束的位置。如：

var str = "hello world";
var newStr = str.substring(6, 7);

document.write(str + "
" + newStr); //w

以上三個方法在被傳入負數的情況下，返回的結果就不太相同了。

slice()方法會將兩個參數與字符串長度相加；

substr()方法會將第一個參數與字符串長度相加，第二個參數轉換為0；

substring()方法會將兩個參數都轉換為0；

如下：

var str = "hello world";
var newStr = str.slice(-6, -1);
document.write(str + "
" + newStr); //hello world worl

var str = "hello world";
var newStr = str.substr(3, -4);
document.write(str + "
" + newStr); //" "

var str = "hello world";
var newStr = str.substring(3,-4); //實際上這個方法會把-4 轉換成0，而該方法會從兩個參數中較小的一個作為開始位置，所以相當于調用了str.substring(0,3)
document.write(str + "
" + newStr); //hello world hel

有兩個方法：indexOf()和lastIndexOf()；該兩個方法如果沒有找到該子字符串，則返回-1。

indexOf()方法

indexOf()方法從字符串的開頭向后搜索。如：

var str = "hello world";
document.write(str.indexOf("o")); //4

也可以傳入第二個參數，即從何處開始。如：

var str = "hello world";
document.write(str.indexOf("o",5)); //7

lastIndexOf()方法

lastIndexOf()方法從字符串的后面開始向前搜索。如：

var str = "hello world";
document.write(str.lastIndexOf("o")); //7

當然也有第二個參數。如：

var str = "hello world";
document.write(str.lastIndexOf("o",5)); //4

可以循環調用上面的方法，來找到所有匹配的字符串。如：

var str = "hello world";
var pos = str.indexOf("o");
var result = [];

while (pos > -1){
    result.push(pos);
    pos = str.indexOf("o",pos + 1);
}

document.write(result.join(" ")); //4 7    

這個方法會創建一個字符串的副本，刪除前置和后綴的所有空格，然后返回結果。如：

var str = "      hello world     ";
console.log(str); //"      hello world     "
var newStr = str.trim();
console.log(newStr); //"hello world"

主要有四個方法：toLowerCase()、toUpperCase()、toLocaleLowerCase()、toLocaleUpperCase()。其中后面兩種方法是針對特定地區的實現。對有些少數語言地區會為Unicode 大小寫轉換應用特殊的規則。所以，在不知道自己的代碼將在哪種語言環境中運行的情況下，還是使用后兩種方法比較好。如：

var str = "Apple.Inc";
console.log(str.toUpperCase());
console.log(str.toLowerCase());
console.log(str.toLocaleUpperCase());
console.log(str.toLocaleLowerCase());    
/*
[Log] APPLE.INC (repetition.html, line 16)
[Log] apple.inc (repetition.html, line 17)
[Log] APPLE.INC (repetition.html, line 18)
[Log] apple.inc (repetition.html, line 19)
*/

有四個方法：match()、search()、replace()、split()。

match()方法

本質上與調用RegExp 的exec()方法相同。match()方法接受一個參數（正則表達式或RegExp 對象）如：

var str = "red hed bed led";
var pattern = /.ed/;
var matches = str.match(pattern); //與pattern.exec(str)相同
console.log(matches); //["red"]

search()方法

唯一的參數與match()方法相同。search()方法返回字符串中第一個匹配項的索引；如果沒有就返回-1；如：

var str = "red hed bed led";
var pattern = /ed/;
var matched = str.search(pattern);
console.log(matched); //1

replace()方法

接收兩個參數：第一個是RegExp 對象或者一個字符串；第二個參數是字符串或者一個函數。

如果第一個參數是字符串，就會替換第一個子字符串。如：

var str = "red hed bed led";
var matched = str.replace("red", "aaa");
console.log(matched); //aaa hed bed led

如果第一個參數是正則表達式且指定了全局g 標志，就會替換所有。如：

var str = "red hed bed led";
var matched = str.replace(/ed/g, "aaa,");
console.log(matched); //raaa, haaa, baaa, laaa,

如果第二個參數是字符串，那么可以使用一些特殊的字符序列：

$$ (替換成$)

$&（匹配整個模式的子字符串）

$` (匹配的子字符串之前的子字符串)

$" (匹配的子字符串之后的子字符串)

$n (匹配第n 個捕獲組的子字符串)

$nn (匹配第nn 個捕獲組的子字符串)

如：

var str = "red hed bed led";
var matched = str.replace(/ed/g, "$$-"); //r$- h$- b$- l$-
matched = str.replace(/ed/g, "$&-"); //red- hed- bed- led-
matched = str.replace(/.ed/g, "$`-"); //- red - red hed - red hed bed -
matched = str.replace(/.ed/g, "$"-"); //hed bed led-  bed led-  led- -
matched = str.replace(/(ed)/g, "$1ing"); //reding heding beding leding
console.log(matched);

如果第二個參數是一個函數，這個函數會被傳遞多個參數：模式的匹配項、第一個捕獲組的匹配項、第二個...，最后兩個參數是分別是模式的匹配項在字符串中的位置和原始字符串。如：

function inputText(text){
    return text.replace(/[lo]/g, function(match,pos,orignalText){
        switch(match){
            case "l":
            return "1";
            case "o":
            return "0";
        }
    });
}
var output = inputText("hello");
console.log(output); //he110

split()方法

這個方法可以基于指定的分隔符將一個字符串分割成多個字符串，并將結果放在一個數組中。分隔符可以是字符串，也可以是一個RegExp 對象。第二個參數是可選的，用于指定數組的大小。如：

var str = "Apple.Inc,Baidu.Inc,Alibaba.Inc";
var list = str.split(",");
document.write(list.join(" & ")); //Apple.Inc & Baidu.Inc & Alibaba.Inc
console.log(list); //["Apple.Inc", "Baidu.Inc", "Alibaba.Inc"]

localeCompare()方法

這個方法是比較兩個字符串，并返回下列值中的一個：

如果字符串在字母表中應該排在字符串參數之前，則返回一個負數（多數情況下是-1）；

如果字符串在字母表中應該排在字符串參數之后，則返回一個正數（多數情況下是1）；

如果字符串等于字符串參數，則返回0；

具體如下：

var strValue = "hello";
console.log(strValue.localeCompare("world")); //-1 字符串hello 在字符串參數world 之前，返回-1
console.log(strValue.localeCompare("Alice")); //1
console.log(strValue.localeCompare("hello")); //0

因為返回的數值不一定上上面三種，所以最好用下面這個方法比較：

function compare(x,y){
    var result = x.localeCompare(y);
    if (result > 0){
        document.write(y + "," + x);
    }else if(result < 0){
        document.write(x + "," + y);
    }else{
        document.write("equal");
    }
}

compare("apple","baidu"); //apple,baidu

可以嘗試把string 轉換成array 再用數組重排序的方法：

str = "blue,red,yellow,white";
function compare(str){
    var strArray = str.split(",");
    var newStrArray = strArray.sort(arraySortFunc);
    function arraySortFunc(a,b){
        if (a > b){
            return 1;
        }else if(a < b){
            return -1;
        }else{
            return 0;
        }
    }
    console.log(newStrArray); //["blue", "red", "white", "yellow"]
}
compare(str);

fromCharCode()方法

這是一個靜態方法。目的是接收一個或多個字符編碼，然后將他們轉換成一個字符串。從本質上來看這個方法與charCodeAt()執行的是相反的操作。注意他的語法是String.charCodeAt()如：

function consoleStrCode(str){
    var codeStr = "";
    var codeArray = [];
    for (var i = 0; i < str.length; i ++){
        var codeValue = str.charCodeAt(i);
        codeStr += codeValue + ",";
    }
    codeArray = codeStr.split(",");
    codeArray.pop();
    console.log(codeArray);
}

consoleStrCode("hello"); //["104", "101", "108", "108", "111"]



function consoleCodeStr(codeArray){
    var codeStr = "";
    for (var i = 0;i < codeArray.length;i ++){
        var currentCode = codeArray[i];
        var currentCodeValue = parseInt(currentCode);
        codeStr += String.fromCharCode(currentCodeValue);
    }
    console.log(codeStr);
}

var codeArray = ["104", "101", "108", "108", "111"];
consoleCodeStr(codeArray); //hello

以上代碼就是代碼和字符串互換的函數。

HTML 方法（避免使用）

該方法的目的是簡化常見的HTML 格式化。因為它們創建的標記通常無法表達語義。所以應該避免使用。