收藏｜12個人工智能檢查論文寫作語法必備網站！

法是論文寫作中經常會遇到的難題，如何在行文中避免“中國式英語”的表述方式呢？12個人工智能檢查論文寫作語法的網站了解一下吧。

01.SpellCheckPlus

網址：http://spellcheckplus.com/

SpellCheckPlus可在線免費檢查拼寫、語法，并配有英文解說來幫助大家學習正確用法。發現易混淆單詞和短語。

02.lang-8

網址：http://lang-8.com/

可以在這里和不同語言的母語者一起進行語言學習和文化交流的免費網站。目前會員遍及世界上190個國家，是網上學習語言交流社區。

03.Hemingway Editor

網址：http://www.hemingwayapp.com/

快速檢查英語語法與拼寫錯誤，提供細致的修改建議，如建議替換使用的單詞等，并能檢測文章的可讀性指數。

04.Whitesmoke

網址：http://www.whitesmoke.com

Whitesmoke可以糾正英語語法和拼寫錯誤，并能根據作文的語境替換更恰當的詞匯，美化語句和寫作風格。另外，該軟件還附帶幾百個信函模板，能輔助快速寫作。

05.grammarly

網址：https://www.grammarly.com/

Grammarly 的界面設計非常簡潔，很像在線寫作網站的風格，文檔也都會自動保存在網站內，供你隨時編輯和查看，如果沒有太多格式的要求，你完全可以直接在 Grammarly 上寫作。同時你也可以把本地文檔導入 Grammarly 進行語法檢查，適合于學生、教師、作家和專業人士使用。可以設置一般分析、商業、學術、技術、創意等語法檢測機制。

06.Gingersoftware

網址：http://www.gingersoftware.com/zh

GingerSoftware是一款可以按語境幫你檢查語法和拼寫問題的語言工具。Ginger可根據每句話的上下文在 MS-Word、Outlook、PowerPoint、IE 和 Firefox中糾正你的拼寫和語法錯誤。

07.AutoCrit Online Editing

網址：https://www.autocrit.com/

AutoCrit將你的文稿與成功出版的文章對比，即時反饋公正的改進意見，使用AutoCrit可以讓你的文章在同行評審時不會犯那些低級錯誤。

08.Paper Rater

網址：http://www.paperrater.com/free_paper_graderPaper Rater

可查看詳細統計的用詞、語法和拼寫是否有錯誤以及內容是否涉及抄襲。此外，也會評估詞匯等級和寫作風格。

09.NounPlus

網址：https://www.nounplus.net/grammarcheck/

Nounplus工具的語法算法主要側重于語法、句法，并且擁有超過1000個常用的語法錯誤篩選機制。你還可以安裝手機應用來使用，提供安卓和iOS手機應用。

10.ProWritingAid

網址：https://prowritingaid.com/

ProWritingAid的語法檢查服務十分強大，分類比較細致，既可以檢查拼寫錯誤，還能檢查用詞是否老套累贅或者模糊抽象無意義、是否過于口語化、句子和段落長度是否合適、有無抄襲等多項錯誤。

11.Stylewriter

網址：http://www.editorsoftware.com/StyleWriter.htmlStylewriter

能檢查拼寫（英美式拼寫區別）、用詞、語態等錯誤，并自動給出修改建議及原因。而且用不同顏色來標記，方便改正。此外，Stylewriter 還能檢測代表文章可讀性的bog 指數，bog 指數越高文章越難懂。

12.1checker

網址：http://www.1checker.com/Account/Login?backurl=%2FOnlineChecker

一款英文自動檢查糾錯服務工具，除了可以提供英文寫作技巧、糾正語法錯誤和自動潤稿修正外，還具有作文批改評分模式，存儲常用錯字、生字辭典，提供豐富的商用英文書信、英文作文范本等等資源。針對個人用戶完全免費，提供在線版、桌面版、Mac版、Windows版應用、word插件、寫作模版。

（來源：答魔科研）

TML即一切，所有打算進行Web編程的人都應該熟悉HTML，并了解如何解析HTML。尤其對前端工程師來說這更是基礎，本文我們就來介紹一下JS下常見的HTML解析庫。

DOMParser

JavaScript和jQuery的DOM操作功能非常適合簡單HTML片段的解析。在實際編程中，如果要以編程方式解析DOM完整HTML或XML，則需要一個更好的解決方案，那就是DOMParser，它是所有現代數瀏覽器都支持的功能。

通過使用DOMParser，可以輕松解析HTML文檔。但是，一般需要通過欺騙瀏覽器來實現解析，比如，通過向當前文檔添加新元素。

DOMParser的用法非常簡單明了：

let domParser = new DOMParser();
let doc = domParser.parseFromString(stringContainingXMLSource, "application/xml");
domParser = new DOMParser();
doc = domParser.parseFromString(stringContainingSVGSource, "image/svg+xml");
domParser = new DOMParser();
doc = domParser.parseFromString(stringContainingHTMLSource, "text/html");

Cheerio

專為服務器設計的核心jQuery的快速，靈活和精致的實現。

Cheerio看起來像jQuery，但是不支持瀏覽器。Cheerio可以解析HTML并使其易于操作，但不會像瀏覽器中那樣解釋HTML，解析出與瀏覽器不同的內容，并且解析的結果不會直接發送給用戶。

Cheerio實現了jQuery子集，去掉了jQuery中所有與DOM不一致或者是用來填補瀏覽器的東西，重現了jQuery最美妙的API

由于使用了極其簡潔而又標準的DOM模型， Cheerio對文檔的轉換，操作，渲染都極其的高效。

JavaScript開發人員都應該熟悉Cheerio的語法和用法：

var chro = require('cheerio'),
$ = chio.load('<h1 class="title">Hello World!</h1>');
$('h1.title').text('Hello Chongchong!');
$('h1').attr('id', 'welcome');
$.html();
結果：
<h1 class="title" id=" welcome ">Hello Chongchong!</h1>

jsdom

jsdom是很多Web標準（尤其是WHATWG DOM和 HTML 標準）純JavaScript實現，可與Node.js結合使用。jsdom項目的目標是模擬Web瀏覽器的子集，從而滿足測試和抓取實際的Web應用程序。

jsdom不僅僅是HTML解析器，它還可以當成瀏覽器。在解析的上下文中，如果要解析的數據中省略了必要的標記，它會自動添加必要的標記。例如，如果沒有html標簽，它將像瀏覽器一樣隱式地添加它。

還可以選擇指定一些屬性，例如文檔，引薦來源網址或用戶代理的URL。如果需要解析包含本地URL的鏈接，則該URL特別有用。

由于它實際上與解析無關，因此只提到jsdom具有（虛擬）控制臺，對cookie的支持等。總之，需要模擬瀏覽器環境

它還可以處理外部資源。如有需求jsdom可以用來加載并執行JS腳本。

const jsdom = require("jsdom");
const { JSDOM } = jsdom;
const dom = new JSDOM('<!DOCTYPE html><p>Hello, Chongchong!</p>');
console.log(dom.window.document.querySelector("p").textContent);

結果：

"Hello, Chongchong!"

parse5

parse5提供了處理HTML時所需的幾乎所有內容。Parse5庫，目標是構建其他工具，但也可以實現HTML解析以完成簡單任務。Parse5易于使用，但是并不提供瀏覽器為提供的操作DOM的方法（例如getElementById）。

parse5衍生出了一系列采用它的令人印象深刻的項目：jsdom，Angular2和Polymer。如果需求為對HTML的高級操作或解析的可靠基礎，那么顯然這是一個不錯的選擇。

const parse5 = require('parse5');

const document = parse5.parse('<!DOCTYPE html><html><head></head><body>Hello Chongchong!</body></html>');

console.log(document.childNodes[1].tagName);

總結

本文我們介紹幾個JS下常見的Html解析庫。根據標準，實際的HTML格式語法格式是需要容錯的。當時這在庫很難簡單完美的實現。如果你有更好的推薦，歡迎和大家一起分享。

內容是《Web前端開發之Javascript視頻》的課件，請配合大師哥《Javascript》視頻課程學習。

錯誤處理對于web應用開發至關重要，任何javascript錯誤都有可能會導致網頁無法使用，因此作為開發人員，必須要及時處理有可能出現的錯誤；

從IE4.0之后，幾乎所有的瀏覽器都包含了一些基本的錯誤處理功能，但并沒有統一，后來，由ECMAscript添加了異常處理機制，也就是try…catch…finally結構以及throw操作；

錯誤處理的重要性: 好的錯誤處理技術可以讓腳本的開發、調試和部署更加流暢，能對代碼進行更好的控制；另外，JS缺乏標準的開發環境；

錯誤類型：

語法錯誤（syntax error）：也稱為解析錯誤，發生在傳統編程語言的編譯解釋時；發生語法錯誤時，就會發生阻塞，也就是不能繼續執行代碼，但只是同一個線程中的代碼會受影響，其他線程中的代碼不受影響；

// Uncaught SyntaxError: Invalid or unexpected token
// 未捕獲的語法錯誤：無效或意外的標記
document.write("zeronetwork;

運行時錯誤（Runtime error）：也稱為exception異常, 其發生在編譯期/解釋期后，此時，問題并不出現在代碼的語法上，而是在嘗試完成一個非法的操作；

<input type="button" value="單擊" onclick="handleClick()" />
<script>
// Uncaught ReferenceError: openMy is not defined
// 未捕獲的引用錯誤：未定義openMy
function handleClick(){
    openMy();
}
</script>

錯誤報告：

因為每個瀏覽器都有自己的內置Javascript解釋程序，所以每種瀏覽器報告錯誤的方式都不同；有些是彈出錯誤信息，有些是把信息打印在控制臺中；

IE(windows): 默認情況下，會彈出包含錯誤細節的對話框，并詢問是否繼續執行頁面上的腳本；如果瀏覽器有調試器(如：Microsoft Script Debugger) ，此對話框會提供一個是調試還是忽略的選項；如果在IE設置中取消了”顯示錯誤”，那么會在頁面左下角顯示一個黃色的圖標；

注：如果JS代碼就在HTML里，顯示錯誤行是正確的，如果是外部的JS文件，則行號往往差一行，如第5行則為第4行；

Mozilla(所有平臺): 在控制臺中打印錯誤信息，并發出警告；其會報告三種類型的消息：錯誤、嚴格警告和消息等的；

Safari (MacOS)：是對JavaScript錯誤和調試的支持最差，默認情況下，它對終端用戶不提供任何javascript錯誤報告；

錯誤處理：

Javascript提供了兩種處理錯誤的方式：

BOM包含一個onerror事件處理函數，該函數通常被綁定在window對象或image對象上；
ECMAscript定義了try…catch結構來處理異常；

onerror事件處理函數:

window對象的onerror屬性是一個事件處理程序，頁面上出現異常時，error事件便在window對象上觸發，并把錯誤消息輸出到Javascript控制臺上，這種方式也稱為全局錯誤捕獲；如：

window.onload = function(){
    show(); // 在onload事件中調用了一個不存在的函數
}
window.onerror = function(){
    alert("出現錯誤");
    return true;
}

獲取錯誤信息：

window.onerror事件處理程序在調用時可以傳5個參數，由這5個參數可以獲取詳細的錯誤信息；

message：錯誤信息，描述錯誤的一條消息；
URL：引發錯誤的Javascript所在的文檔的URL；
line：文檔中發生錯誤的行數；
column：發生錯誤的列數；
error：錯誤對象，這個error也稱為全局錯誤對象；

window.onerror = function(sMessage, sUrl, sLine, sColumn, error){
console.log("Error:" + sMessage + " URL：" + sUrl + " Line：" + sLine + " Column：" + sColumn);
console.log(error);
    return true;
}

onerror處理程序的返回值：

如果返回true，則阻止執行默認的事件處理程序，也就是將通知瀏覽器，事件處理程序已經處理了錯誤，不需要其他操作，反之會顯示錯誤消息；

某些元素也支持onerror; 但其處理函數沒有任何關于error信息的參數，如:

document.images[0].onerror = function(event){
console.log(event);  // Event
console.log(event.type);  // error
}

這里的event參數是一個類型為Event事件對象，其存儲的信息除了type返回了error，并沒有其他和錯誤相關的信息；

全局錯誤處理window.onerror通常不能恢復腳本繼續執行，但會給開發者發送錯誤信息；

window.onerror = function(error){
  console.log(error);
}
show();
console.log("中止，不會被執行");
window.onload = function(){
  console.log("也不會被執行");
}

可以是簡單的打印，也可以把錯誤保存到日志記錄里；

window.onerror就是綁定在window對象的error事件，也可以使用標準的添加事件偵聽的方式window.addEventListener(eventtype, handler)，其需要兩個參數，eventtype為事件類型，在此為error，handler是事件處理函數，其需要一個參數event，一個ErrorEvent類型的對象，其保存著有關事件和錯誤的所有信息，如：

window.addEventListener("error", function(event){
  console.log(event);  // ErrorEvent
  console.log(event.error);  // Error對象
  console.log(event.error.name);
  console.log(event.error.message);
  console.log(event.error.stack);
  console.log(event.lineno);  // 行
  console.log(event.colno);  // 列
  console.log(event.filename);
});

在實際的開發中，這兩種方式都會被使用，只不過addEventListener有定的兼容必問題，所以要兼顧所有的瀏覽器且不太關注事件對象本身的話，就使用window.onerror；

當加載自不同域的腳本中發生語法錯誤時，為避免信息泄露，語法錯誤的細節將不會報告，只會返回簡單的"Script error."；

<script>
window.onerror = function(msg, url, lineNo, columnNo, error){
  console.log(msg);  // Script error
  console.log(url);  // ""
  console.log(lineNo);  // 0
  console.log(columnNo);  // 0
  console.log(error);  // null
}
</script>
<script src="https://www.zeronetwork.cn/demo/demo.js"></script>

可以針對同域和不同域的錯誤分開處理，如：

<script>
window.onerror = function(msg, url, lineNo, columnNo, error){
  var str_error = msg.toLowerCase();
  var sub_string = "script error";
  if(str_error.indexOf(sub_string) > -1)
    alert("腳本發生錯誤，詳情請在控制臺查看");
  else{
    var message = [
      '消息：' + msg,
      'URL：' + url,
      '行：' + lineNo,
      '列：' + columnNo,
      '錯誤對象：' + error
    ].join(" - ");
    alert(message);
  }
}
show();
</script>
<script src="https://www.zeronetwork.cn/demo/demo.js"></script>

從上在的執行結果來看，error事件執行了兩次，原因是使用了兩個script，也就是當一個script有錯誤發生時，它只會阻止當前的script塊，而不會阻止其他的script塊；如：

<script>
show();  // 會捕獲
console.log("不會被執行");
myshow();  // 不會捕獲
</script>
<script src="https://www.zeronetwork.cn/demo/demo.js"></script>
<script>
console.log("執行了");
demo();  // 會捕獲
console.log("不會被執行");
</script>

body元素的onerror特性，也可以充當事件處理函數，如：

<body onerror="alert('出現了錯誤');return true;">

注意，先注釋掉window.onerror等代碼；

此時，可以直接使用event、source、lineno、colno、error等屬性；

<body onerror="alert(event + '\n' + source + '\n' + lineno + '\n' + colno + '\n' + error);return true;">

當然了，也可以為body綁定error事件，此時各屬性，必須明確指定，如：

document.body.onerror = function(msg, url,lineno,colno,error){
  alert(msg + '\n' + url + '\n' + lineno + '\n' + colno + '\n' + error);
  return true;
}

try-catch語句：

try語句中為期待正常執行的代碼塊，當在try語句中發生錯誤，其余代碼會中止執行，catch語句就處理該錯誤，如果沒有錯誤，就跳過catch語句；try和catch必須成對出現；

try{
    //code
    [break]
}catch([exception]){
    //code
}[finally]{
    //code
}
// 如
try {
    show();
    alert("不能執行");
} catch (error) {
    alert("出現一個錯誤:" + error);
} finally{
    alert("管你呢");
}

try語句塊內的錯誤只會中止try語句塊中發生錯誤之后的邏輯代碼，并不會中止整個腳本的運行；執行try-catch語句，必須是運行時，運行時錯誤，也被稱為異常；try-catch語句中指定只能有一個catch子句；try-catch語句適合處理無法預知、無法控制的錯誤；finally常被用于無論結果是否有異常，都要執行的代碼，如：

try{
  alert("try");
  show();
  alert("no exec");
}catch(error){
  alert("catch");
}finally{
  alert("finally");
}
alert("continute");

代碼執行的兩條路徑：如果沒有異常，執行路徑為：try->finally，反之為：try的部分->catch->finally；

一般用于關閉打開的鏈接和釋放資源；

var connection = {open: function(){},close: function(){},send: function(data){}}
// var data = "大師哥王唯"; // 注釋這一行，讓它產生異常
connection.open();
try{
    connection.send(data);
}catch(exception){
    console.log("出現一個錯誤");
}finally{
    connection.close();
    console.log("關閉了");
}

還有一個典型的應用，讀寫文件，如：

function openFile(){};
function writeFile(data){};
function closeFile(){};
openFile();
try{
  writeFile();
}catch(error){
  console.log(error);
}finally{
  closeFile();
}

在try-catch-finally語句塊中的變量是全局變量：

try{
  var name = "王唯";
  show();
  var city = "蚌埠";
}catch(error){
  var age = 18;
  console.log(name);
}finally{
  var sex = "男";
  console.log(name);
  console.log(age);
}
console.log(name);
console.log(city);
console.log(age);
console.log(sex);

try-catch-finally與return：

如果直接在try-catch-finally語句塊中執行return，會拋出異常，如：

try {
  console.log("try");
  // return;  // Illegal return statement 非法返回語句
  console.log("try agin");
} catch (error) {
  console.log(error);
  // return;  // Illegal return statement
}finally{
  console.log("finally");
  // return;  // Illegal return statement
}

如：

function foo(){
  try {
    console.log("try");
    return 1;
    show();
    console.log("try agin");
  } catch (error) {
    console.log(error);
    return 2;
  }finally{
    console.log("finally");
    return 3;
  }
}
console.log(foo());  // 3

try-finally：

沒有catch從句，只有try-finally也可以，目的是，只確保執行開始和最終的過程，而不處理錯誤，如：

try{
  console.log("try");
  show();
}finally{
  console.log("finally"); // 會執行
}
console.log("over"); // 不會執行，已中止

但此時，還是會拋出異常的，但此時，會在執行完finally后中止執行，并會查找外部的catch語句;

嵌套try-catch語句：

在catch子句中，也有可能會發生錯誤，所以就可以使用嵌套的try-catch語句，如：

try {
    show();
    console.log("不能執行");
} catch (error) {
    console.log("出現一個錯誤:" + error);
    try {
        var arr = new Array(10000000000000000);
        arr.push(error);
    } catch (error) {
        console.log("又出現了一個錯誤：" + error);
    }
} finally{
    console.log("管你呢");
}

也可以在try中嵌套try-catch-finally語句，如：

try{
  try{
    console.log("try");
    show();
  }catch(error){
    console.log("error");
  }finally{
    console.log("finally");
  }
}catch(error){
  console.log(error);
}

一個比較典型的應用，就是處理json數據，如：

// var json = '{"name":"wangwei", "age": 18, "sex": "男"}';
var json = '{bad json}';  // Uncaught SyntaxError
var data = JSON.parse(json);
console.log(data.name);
console.log(data.age);
console.log(data.sex);

一量json數據發生錯誤，整個應用都會崩潰，所以應該使用try-catch，如：

<div id="msg">您的信息：</div>
<script>
window.onload = function(){
  var msg = document.getElementById("msg");
  try{
    // var json = '{"name":"王唯", "age": 18, "sex": "男"}';
    var json = '{bad json}';  // Uncaught SyntaxError
    var data = JSON.parse(json);
    msg.innerHTML += "姓名：" + data.name + "，年齡：" + data.age + "，性別：" + data.sex;
  }catch(error){
    msg.innerHTML = "開小差了，找不到你的信息";
  }
}
</script>

當使用了try-catch語句，就不會將錯誤提交給瀏覽器，也就不會觸發error事件，如：

window.onerror = function(error){
  console.log(error);  // 不會觸發
}
try{
  show();
}catch(error){
  console.log(error);
}

Error錯誤對象：

在catch中會捕獲一個Error錯誤對象；該對象在Javascript解析或運行時，一旦發生錯誤，引擎就會拋出這個對象；如果沒有相關聯的try-catch捕獲該對象，就由瀏覽器輸出這個對象；

// ...
console.log("錯誤：" + error + " name:" + error.name + " message:" + error.message);

也可以通過Error的構造器創建一個錯誤對象，這個Error對象也可用于用戶自定義的異常；語法：new Error([message[, filename[, lineNumber]]]);

message：可選，錯誤描述信息；
fileName：可選，非標準，被創建的Error對象的fileName屬性值，默認是調用Error構造器代碼所在的文件的名字; 但大部分瀏覽器沒有實現；
lineNumber：可選，非標準，被創建的Error對象的lineNumber屬性值，默認是調用Error構造器代碼所在的文件的行號；但大部分瀏覽器沒有實現；

實例化Error對象，也可以不使用new關鍵字，如：

var error = new Error("自定義錯誤對象");
var error = Error("不使用new");
console.log(error);
console.log(error.name);  // Error
console.log(error.message);  // 自定義錯誤對象

Error錯誤對象屬性：

name：表示錯誤類型的字符串；
message：實際的錯誤信息；

Error類還有6個子類，其可以通過錯誤對象的name屬性返回具體異常類的名稱：

EvalError：錯誤發生在eval()函數中；
RangeError：數值超出javascript可表示的范圍；；
ReferenceError：使用了非法或不能識別的引用；
SyntaxError：發生了語法錯誤；
TypeError：操作數的類型不是預期所需的；
URIError：在encodeURI()或decodeURI()函數中發生了錯誤；

// EvalError
try{
  throw new EvalError("Eval異常");
}catch(error){
  console.log(error);
  console.log(error instanceof EvalError);  // true
  console.log(error.name);  // EvalError
  console.log(error.message);  // Eval異常
}
// RangeError
var num = 1;
try{
  num.toPrecision(500);  //  [pr??s??n] 精度
}catch(error){
  console.log(error); 
}
// ReferenceError
var x;
try {
  x = y + 1;
} catch (error) {
  console.log(error);
}
// SyntaxError
try{
  eval("alert('wangwei)");
}catch(error){
  console.log(error);
}
// TypeError
var num = 1;
try{
  num.toUpperCase(); // 無法將數字轉為大寫
}catch(error){
  console.log(error);
}
// URIError (malformed [?m?l?f??md]格式不正確，畸形的)
try{
  decodeURI("%%%"); // 使用了非法字符
}catch(error){
  console.log(error);
}

Error對象的message屬性是瀏覽器生成的用于表示錯誤描述的信息，因為這個屬性是特定于瀏覽器的，所以不同的瀏覽器上可能產生不同的錯誤信息，如：

try {
    eval("a ++ b");
    show();
    console.log("執行了嗎？");
} catch (error) {
    // SyntaxError:Unexpected identifier或
    // SyntaxError:unexpected token: identifier
    console.log(error.name + ":" + error.message);
}

使用name屬性判斷錯誤類型：

try {
    eval("a++b");
} catch (error) {
    console.log(error instanceof SyntaxError); // true
    if(error.name == "SyntaxError")
        console.log(error.name + ":" + error.message);
    else
        console.log("未知錯誤：" + error.message);
}

拋出異常：

throw語句的作用是手動中斷程序執行，拋出一個錯誤，一般用于有目的的拋出異常，也就是允許開發者可以創建自定義錯誤；

throw可以拋出任何類型的值，也就是說，它的參數可以是任何值；語法：throw error_object；error_object可以是字符串、數字、布爾或對象；

throw "出現一個錯誤";
throw 50666;
throw true;
throw new Object();
throw {
    toString:function(){
        return 'Error!';
    }
}
function getRectArea(width, height){
  if(isNaN(width) || isNaN(height))
    throw '參數應該是number類型';
  return width * height;
}
getRectArea("wangwei",10);

對于Javascript引擎來說，只要遇到throw語句，程序就會終止；

也可以拋出一個Error錯誤對象；Error對象的構造函數只有一個參數,

throw new Error("請再次嘗試");

其他Error子類對象也可以拋出：

throw new SyntaxError("...");
throw new TypeError("...");
throw new RangeError("...");
throw new EvalError("...");
throw new URIError("...");
throw new ReferenceError("...");

對于Error類和其子類來說，錯誤對象的name就是其構造函數的名稱，message是其構造函數的參數；

當拋出異常后，throw之后的語句將不會執行，并跳到相關聯的catch語句中進行處理，如：

<h1>請輸入18-99之間的數字</h1>
<input id="txtInput" type="text" />
<button id="btn">確定</button>
<p id="msg"></p>
<script>
function myFun(){
  var msg,x;
  msg = document.getElementById("msg");
  msg.innerHTML = "";
  x = document.getElementById("txtInput").value;
  try{
    if(x == "") throw "空的";
    if(isNaN(x)) throw "不是數字";
    x = Number(x);
    if(x < 18) throw "太小";
    if(x > 99) throw "太大";
    msg.innerHTML = "輸入的值正確：" + String(x);
  }
  catch(error){
    msg.innerHTML = "輸入的值不正確：" + error; 
  }
}
var btn = document.getElementById("btn");
btn.onclick = myFun;
</script>

也可以在某個語句塊的外部捕獲throw異常，如：

function sum(a,b){
    if(arguments.length < 2)
        throw new Error("需要兩個參數");
    else
        return a + b;
}
try{
    console.log(sum(18));
}catch(error){
    // Error:需要兩個參數
    console.log(error.name + ":" + error.message);
}

可以通過instanceof判斷異常的類型來特定處理某一類的異常，例如可以區分瀏覽器拋出的異常和開發人員拋出的異常，如：

function sum(a,b){
    if(arguments.length < 2)
      throw new Error("需要兩個參數");
    if(isNaN(a) || isNaN(b))
      throw "參數是不是Number類型";
    return a + b;
}
try{
    console.log(sum(18,12));
}catch(error){
  if(error instanceof SyntaxError)
    console.log("語法錯誤：" + error.name + ":" + error.message);
  else if(error instanceof Error)
    console.log(error.name + ":" + error.message);
  else
      console.log(error);
}

注：判斷Error類型要放到if的最后一個條件；

即使在catch語句中，還可以根據實際情況，再次拋出異常，此時，其可以被外部的try-catch語句塊捕獲（如果存在的話）；

當發生異常時，代碼會立即停止，僅當有try-catch語句捕獲到異常時，代碼才會繼續執行；其背后運行的原理是，當發生異常，JavaScript解釋器會立即停止執行的邏輯，并跳轉到就近的try-catch異常處理程序，如果發生異常的代碼塊中沒有相關聯的catch從句，解釋器會檢查更高層的閉合代碼塊，看它是否有相關聯的異常處理程序，以此類推，直到找到一個異常處理程序為止；如果發生異常的函數中沒有處理它的try-catch語句，異常將向上傳播到調用該函數的代碼，如此，異常就會沿著Javascript的語法結構或調用棧向上傳播；如果沒有找到任何異常處理程序，JavaScript將把異常當成程序錯誤來處理，并通過瀏覽器報告給用戶；

自定義錯誤類型：

可以基于Error類來創建自定義的錯誤類型，此時可以使用throw拋出自定義的異常類，或通過instanceof來檢查這個異常類的類型，新類型需要實現name和message屬性；

function CustomError(message){
  this.name = "CustomError";
  this.message = message || 'Default Message';
  this.stack = (new Error()).stack;
}
// CustomError.prototype = new Error();
// 或者
CustomError.prototype = Object.create(Error.prototype);
CustomError.prototype.constructor = CustomError;
try{
  var name = "jingjing";
  if(name !== "wangwei")
    throw new CustomError("自定義的錯誤類型");
}catch(error){
  console.log(error.message);
}

小示例：

function UserException(message){
  this.name = "UserException";
  this.message = message;
}
function getMothName(m){
  m = m - 1;  // 調整月份數字到數組索引（1=Jan,12=Dec）
  var months = ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'];
  if(months[m] != undefined)
    return months[m];
  else
    throw new UserException("Invalid Month No");
}
try{
  var myMonth = 15;
  var monthName = getMothName(myMonth);
}catch(error){
  var monthName = "未知";
  console.log(error.name + ":" + error.message);
}

小示例：驗證電話號碼，如：

function Telephone(num){
  num = String(num);
  var pattern = /^((0\d{2,3}-\d{7,8})|(1[3584]\d{9}))$/;
  if(pattern.test(num)){
    this.value = num.match(pattern)[0];
    this.valueOf = function(){
      return this.value;
    };
    this.toString = function(){
      return String(this.value);
    }
  }else{
    throw new TelephoneFormatException(num);
  }
}
function TelephoneFormatException(value){
  this.name = "TelephoneFormatException";
  this.message = "電話號碼格式不正確";
  this.value = value;
  this.toString = function(){
    return this.value + ":" + this.message;
  }
}
// 應用
var TELEPHONE_INVALID = -1;
var TELEPHONE_UNKNOWN_ERROR = -2;
function verifyTelephone(num){
  try{
    num = new Telephone(num);
  }catch(error){
    if(error instanceof TelephoneFormatException)
      return TELEPHONE_INVALID;
    else
      return TELEPHONE_UNKNOWN_ERROR;
  }
  return num.toString();
}
console.log(verifyTelephone("010-66668888"));
console.log(verifyTelephone("13812345678"));
console.log(verifyTelephone("138123456")); // -1
console.log(verifyTelephone("wangwei")); // -1

常見錯誤：

由于javaScript是松散類型的，也不會驗證函數的參數，因此錯誤只會在運行時出現；一般來說，需要關注三種錯誤：類型轉換錯誤、數據類型錯誤、通信錯誤；

類型轉換錯誤：

一般發生在使用某個操作符，或者使用其他可能自動轉換值的數據類型的語言結構時；

function output(str1,str2,str3){
  var result = str1 + str2;
  if(str3)
    result += str3;
  return result;
}
console.log(output(1,2,3));
console.log(output(1,2));
console.log(output(1,2,0));
console.log(output(1,2,"wangwei"));

這就是一個非常典型的與期望不一致的方式；

數據類型錯誤：

在流控制語句中使用非布爾值，是極為常見的一個錯誤來源，為避免此類錯誤，就要做到在條件比較時確定傳入的是布爾值，例如，把if語句改成：if(typeof str3 == 'number')；

所以在使用某個變量或對象時，一定要適當地檢查它的數據類型，如：

function reverseSort(values){
  // if(values){
  //   values.sort();
  //   values.reverse();
  // }
  if(arguments.length > 0){
    if(!Array.isArray(values))
      return [];
    else{
      values.sort();
      values.reverse();
      return values;
    }
  }
  return [];
}
var arr = [3,2,6,9,4];
// var arr = 100;  // Uncaught TypeError: values.sort is not a function
console.log(reverseSort(arr));

另一個常見的錯誤就是將參數與null值進行比較。與null進行比較只能確保相應的值不是null和undefined。要確保傳入的值有效，僅檢測null值是不夠的；

function reverseSort(values){
  // if(values != null){  // 任何非數組值都會導致錯誤
  if(values instanceof Array) // 非數組值被忽略
    values.sort();
    values.reverse();
  }
  return values;
}
var arr = [3,2,6,9,4];
// var arr = 100;  // Uncaught TypeError: values.sort is not a function
console.log(reverseSort(arr));
// 或
function reverseSort(values, fun){
  if(values instanceof Array){
    if(fun != null && typeof fun === "function")
      values.sort(fun);
    else
      values.sort();
  }
  return values;
}
var arr = [3,2,6,9,4];
console.log(reverseSort(arr, function(a,b){
  return a > b ? -1 : 1;
}));

通信錯誤：最典型的就是Ajax應用，用其可以動態加載信息，但是，javascript與服務器之間的任何一次通信，都有可能會產生錯誤；

調試技巧：

使用警告框: 這是最簡單、流行的方式，如：

function test(){
    alert("函數內");
    var iNum1 = 5, iNum2 = 10;
    alert(iNum1);
    var iResult = iNum1 + iNum2;
    alert(iResult);
}
test();

拋出自定義錯誤：

function assert(bCondition, sErrorMessage){
    if(!bCondition)
        throw new Error(sErrorMessage);
}
function divide(iNum1, iNum2){
    assert(arguments.length == 2, "divide需要兩個參數");
    assert((!isNaN(iNum1) && !isNaN(iNum2)), "需要Number類型");
    return iNum1 / iNum2;
}
console.log(divide(10,2));
console.log(divide(10,"c"));  // 異常
// 或
try{
  console.log(divide(10,"c"));
}catch(error){
  console.log(error.name + ":" + error.message);
}

Javascript校驗器：

jslint的主要目的是指出不合規范的js語法和可能的語法錯誤，包括一些不良代碼；官網：http://www.jslint.com/

如以下，會給出警告：

語句未使用塊標記；
一行的結尾未以分號結束；
用var聲明一個已在使用的變量；
with語句；

調試器：

Javascript自身不具備調試器，但目前所有的瀏覽器可以使用自身的調試器；

IE調試：

啟用IE的調試功能：

菜單“工具”|“Internet選項”命令，打開“Internet選項”對話框，在“高級”選項卡中，找到兩個“禁用腳本調試”復選框并取消；開始調試，調試的主要工作是反復地跟蹤代碼，找出錯誤并修正；

設置斷點：

在調試程序窗口中，將光標移動到需要添加斷點的行上，按一次F9鍵或單擊，當前行的背景色變為紅色，并且在窗口左邊界上標上紅色的圓點，當程序運行到斷點時就會暫停；

運行調試：

單擊繼續或按F5進行逐步運行調試；F10步進、F11步入，都可以繼續向下執行；將鼠標移動到變量名上時，會顯示變量當前時刻的值；或者在右側的“監視”窗格中可以觀察該變量的值；點擊變量信息框中的變量值或右側“監視”空格中的變量值可以修改變量的當前值；更多的調試操作：查看調用關系、監視特定變量的值等；

// 示例
var balance = 200.0;    //
var willPay = 20.0;
function pay(_balance, _pay){
    return _balance - _pay;
}
function showBalance(){
    debugger;
    var blnc = pay(balance,willPay);
    alert("當前余額:" + blnc);
}
showBalance();

日志輸出：

程序運行時，有些中間數據需要記錄，以便檢查程序運行的狀態；對于JavaScript記錄中間數據通常是以日志的形式記錄需要記錄的數據，再發送到服務器上保存起來；日志記錄的內容可以是任意的信息，根據開發者的需要而定；

在線咨詢

上一篇：css背景圖片高度自適應解決方案
下一篇：HTML 音頻(Audio)

您的項目需求

*請認真填寫需求信息，我們會在24小時內與您取得聯系。

整合營銷服務商