1.Error物件

javascript解析或者執行時，一旦發生錯誤，引擎就會丟擲一個錯誤物件。javascript原生提供一個Error建構函式，所有丟擲的錯誤都是這個建構函式的例項。

var err = new Error('出錯了');
err.message //"出錯了"

上面程式碼中，我們呼叫Error建構函式，生成一個err例項。

Error建構函式接受一個引數，表示錯誤提示，可以從例項的mesage屬性讀到這個引數。

程式碼解析或者執行時發生錯誤，JavaScript引擎就會自動產生、並丟擲一個Error物件例項，然後整個程式就中斷在發生錯誤的地方，不再往下執行。

根據語言標準，Error物件的例項必須有message屬性，表示出錯時的提示資訊，其他屬性則沒有提及。大多數javascript引擎，對Error例項還提供name和stack屬性，分別表示錯誤名稱和錯誤堆疊，但是他們是非標準的，不是每種實現都有。

message : 錯誤提示資訊
name : 錯誤名稱（非標準屬性）
stack : 錯誤的堆疊（非標準屬性）

利用name和message這兩個屬性，可以對發生什麼錯誤有一個大概瞭解。

if（error.name）{
    console.log(error.name + ": " + error.message);
}

上面程式碼表示，顯示錯誤的名稱以及出錯提示資訊。

stack屬性用來檢視錯誤發生時的堆疊。

function throw(){
    throw new Error('');
}
function catchit(){
    try
 
{
        throwit();
    }catch(e){
        console.log(e.stack);
    }
}
catchit()
// Error
//    at throwit (~/examples/throwcatch.js:9:11)
//    at catchit (~/examples/throwcatch.js:3:9)
//    at repl:1:5

上面程式碼顯示，丟擲錯誤首先是在throwit函式，然後在catchit函式，最後在函式的執行環境中。

2.JavaScript的原生錯誤型別

Error物件最一般的錯誤型別，在它的基礎上，JavaScript還定義了其他6中錯誤，也就是說，存在Error的6個派生物件。

（1）SyntaxError

SyntaxError是解析程式碼時發生的語法錯誤。

//變數名錯誤
var 1a;
//缺少括號
console.log 'hello');

(2)ReferenceError

ReferenceError是引用一個不存在的變數時發生的錯誤。

unkonwnVariable
//ReferenceError: unknownVariable is not defined

另一種觸發場景是，將一個值分配給無法分配的物件，比如對函式的執行結果或者this賦值。

console.log() = 1;
// ReferenceError: Invalid left-hand side in assignment
this  = 1;
// ReferenceError: Invalid left-hand side in assignment

上面程式碼對函式console.log的執行結果和this賦值，結果都引發了ReferenceError錯誤。

（3）RangeError

RangeError是一個值超出有效範圍時發生的錯誤。主要有幾種情況，一是陣列長度為負數，二是Number物件的方法超出範圍，以及函式堆疊超過最大值。

new Array(-1)
//RangeError:Invalid array length
(1234).toExponential(21)
//RangeError : toExponential() argument must be between 0 and 20 

(4)TypeError

TypeError是變數或者引數不是預期型別時發生的錯誤。比如，對字串、布林值等原始型別的值使用new命令，就會丟擲這種錯誤，因為使用new命令對的引數是一個建構函式。

new 123
//TypeError : number is not a func
var obj = {};
obj.unknowMethod()
//TypeError : obj.unkonwnMethod is not a function

上面程式碼的第二種情況，呼叫物件不存在的方法，會丟擲TypeError錯誤。

（2）URLError

URIError是URL相關函式的引數不正確時丟擲的錯誤，主要涉及encodeURL()、decodeURL()、encodeURIComponent()、decodeURIComponent()、escape()和unescape()這六個函式。

decodeURI('%2')
// URIError: URI malformed

(6)EvalError

eval函式沒有被正確執行時，會丟擲EvalError錯誤。該錯誤型別已經不再是ES5中出現了，只是為了保證與以前的程式碼相容，才繼續保留。

以上六中派生錯誤，連同原始的Error物件，都是建構函式。開發者可以使用它們，人為生成錯誤物件例項。

new Error('出錯了！');
new RangeError('出錯了，變數超出有限範圍！');
new TypeError('出錯了，變數型別無效！');

3.自定義錯誤

除了JavaScript內建的7中錯誤物件，還可以自定義自己的錯誤物件。

function UserError(message){
    this.message = message || "預設資訊";
    this.name = "UserError";
}
UserError.prototype  = new Error();
UserError.prototype.constructor = UsereError;

上面程式碼中自定義一個錯誤物件UserError,讓它繼承Error物件，然後就可以生成這種自定義的錯誤了。

new UserError('這是自定義的錯誤！');

4.throw語句

throw語句的作用是中斷程式執行，丟擲一個意外或錯誤。它接受一個表示式作為引數，可以丟擲各種值。

//丟擲一個字串
throw 'Error!';
//丟擲一個數值
throw 42;
//丟擲一個布林值
throw true;
//丟擲一個物件
throw {toString : function(){return "Error!";}}

上面程式碼表示，throw可以接受各種值作為引數。JavaScript引擎一旦遇到throw語句，就會停止執行後面的語句，並將throw語句的引數值，返回給使用者。

如果只是簡單的錯誤，返回一條資訊就可以了，如果遇到複雜的情況，就需要丟擲錯誤以後進一步處理。這時最好的方法是使用throw語句手動丟擲一個Error物件。

throw new Error('出錯了！');

上面語句新建了一個Error物件，然後將這個物件丟擲，整個程式就會中斷在這個地方。

throw語句還可以丟擲使用者自定義的錯誤。

function UserError(messsage){
    this.message = message || "預設資訊";
    this.name = "UserError";
}
UserError.prototype.toString = function(){
    return this.name + ':"' + this.message + '"';
}
throw new UserError("出錯了！");

可以通過自定義一個assert函式，規範化throw丟擲的資訊。

function assert(expression,message){
    if(!expression){
        throw {name : 'Assertion Exception',message:message};   
    }
}

上面程式碼定義了一個assert函式，它接受一個表示式和一個字串作為引數。一旦表示式不為真，就丟擲指定字串，它的用法如下：

assert(typeof myVar != 'undefined','myVar is undefined');

console物件的assert方法，與上面函式的工作機制一模一樣，所以可以直接使用。

console.assert(typeof myVar != 'undefined','myVar is undefined!');

5.try…catch

對錯誤進行處理，需要使用try…catch結構。

try{
    throw new Error('出錯了！');
}catch(e){
    console.log(e.name + ": " + e.message);
    console.log(e.stack);
}
// Error: 出錯了!
//   at <anonymous>:3:9
//   ...

上面程式碼中，try程式碼一丟擲錯誤（上例用的是throw語句），JavaScript引擎就立即把程式碼執行，轉到catch程式碼塊。可以看做，錯誤可以被catch捕獲。catch接受一個引數，表示try程式碼塊丟擲的值。

function throw(exception){
    try{
        throw exception;
    }catch(e){
        console.log('Caught' : e);
    }
}
throwIt(3);
// Caught: 3
throwIt('hello');
// Caught: hello
throwIt(new Error('An error happened'));
// Caught: Error: An error happened

上面程式碼中，throw語句先後丟擲數值、字串和錯誤物件。
catch程式碼塊被捕獲錯誤以後，程式不會中斷，會按照流程繼續執行下去。

try{
    throw "錯誤了";
}catch(e){
    console.log(111);
}
console.log(222);
//111
//222

上面程式碼中，try程式碼塊丟擲錯誤，被catch程式碼塊捕獲以後，程式會繼續向下執行。
catch程式碼塊之中，還可以再丟擲錯誤，甚至使用檢討的try…catch結構。

var n = 100;
try{
    throw n;
}catch(e){
    if(e<=50){
        //...
    }else{
    throw e;
    }
}

上面程式碼中，catch程式碼之中又丟擲了一個錯誤。

為了捕獲不同型別的錯誤，catch程式碼塊之中可以加入判斷語句。

try {
  foo.bar();
} catch (e) {
  if (e instanceof EvalError) {
    console.log(e.name + ": " + e.message);
  } else if (e instanceof RangeError) {
    console.log(e.name + ": " + e.message);
  }
  // ...
}

上面程式碼中，catch捕獲錯誤之後，會判斷錯誤型別，進行不同處理。
try…catch結構是JavaScript受到java語言影響的一個明顯例子。這種結構多多少少是對結構化程式設計原則的一種破壞，處理不當就會變成類似goto語句的效果，應該謹慎使用。

6.finally程式碼塊

try…catch結構允許在最後新增一個finally程式碼塊，表示不管是否出現錯誤，都必須在最後執行的語句。

function cleansUp(){
    try{
        throw new Erro('出錯了！');
        console.log('此行不會執行');
    }finally{
        console.log('完成清理工作');
    }
}
cleanUp();
//完成清理工作
//Error : 出錯了......

上面程式碼中，由於沒有catch語句塊，所以錯誤沒有捕獲，執行finally程式碼塊之後，程式就中斷在錯誤丟擲的地方。

function idle(x){
    try{
        console.log(x);
        return 'result';
    }finally{
        console.log("FINALLY");
    }
}
idle('hello')
// hello
// FINALLY
// "result"

上面程式碼說明，即使有return語句在前，finally程式碼塊依然會得到執行，且在執行完畢以後，才會顯示return語句的值。

下面的例子說明，return語句的執行是排在finally程式碼之前，只是等程式碼執行完畢之後才返回。

var count = 0;
function countUp(){
    try{
        return count;
    }finally{
        count++;
    }
}
countUp()
//0
count
//1

上面程式碼說明，return語句的count的值，是在finally程式碼塊執行之前，就獲取完成了。

下面是finally程式碼塊用法的典型場景。

openFile();
try{
    writeFile(Data);
}catch(e){
    handleError(e)
}finally{
    closeFile();
}

上面程式碼首先開啟一個檔案，然後在try程式碼塊中寫入檔案，如果沒有發生錯誤，則執行finally程式碼塊關閉檔案；一旦發生錯誤，則先使用catch程式碼塊處理錯誤，再使用finally程式碼塊關閉檔案。

下面的例子充分反映了try…catch…finally這三者之間的執行順序。

unction f() {
  try {
    console.log(0);
    throw 'bug';
  } catch(e) {
    console.log(1);
    return true; // 這句原本會延遲到finally程式碼塊結束再執行
    console.log(2); // 不會執行
  } finally {
    console.log(3);
    return false; // 這句會覆蓋掉前面那句return
    console.log(4); // 不會執行
  }

  console.log(5); // 不會執行
}

var result = f();
// 0
// 1
// 3

result
// false

上面程式碼中，catch程式碼塊結束結束執行之前，會先執行finally程式碼塊。從catch轉入finally的標誌。不僅有return語句，還有throw語句。

function f() {
  try {
    throw '出錯了！';
  } catch(e) {
    console.log('捕捉到內部錯誤');
    throw e; // 這句原本會等到finally結束再執行
  } finally {
    return false; // 直接返回
  }
}

try {
  f();
} catch(e) {
  // 此處不會執行
  console.log('caught outer "bogus"');
}

//  捕捉到內部錯誤

上面程式碼中，進入catch程式碼塊之後，一遇到throw語句，就會去執行finally程式碼塊，其中有return false語句，因此就直接返回了，不再會回去執行catch程式碼塊剩下的部分了。