這篇文章主要為大家展示了“怎么編寫可維護的JavaScript代碼”，內容簡而易懂，條理清晰，希望能夠幫助大家解決疑惑，下面讓小編帶領大家一起研究并學習一下“怎么編寫可維護的JavaScript代碼”這篇文章吧。
員工經(jīng)過長期磨合與沉淀，具備了協(xié)作精神，得以通過團隊的力量開發(fā)出優(yōu)質的產(chǎn)品。創(chuàng)新互聯(lián)公司堅持“專注、創(chuàng)新、易用”的產(chǎn)品理念，因為“專注所以專業(yè)、創(chuàng)新互聯(lián)網(wǎng)站所以易用所以簡單”。公司專注于為企業(yè)提供成都網(wǎng)站設計、做網(wǎng)站、微信公眾號開發(fā)、電商網(wǎng)站開發(fā)，小程序開發(fā)，軟件按需定制網(wǎng)站等一站式互聯(lián)網(wǎng)企業(yè)服務。
JavaScript這門編程語言發(fā)展至今已經(jīng)非常流行了，各種名詞也層出不窮，我們隨便列舉下就有一大堆，比如Node.js、jQuery、 JavaScript MVC、Backbone.js、AMD、CommonJS、RequireJS、CoffeScript、Flexigrid、Highchart、 Script Loader、Script Minifier、JSLint、JSON、Ajax......這么多的東西席卷我們的腦海，無疑讓人頭暈目眩。但本質的東西總是不變的，而所謂本質就是一些核心的基礎概念。這里的基礎不是指JavaScript的表達式、數(shù)據(jù)類型、函數(shù)API等基礎知識，而是指支撐上面這么一大堆JavaScript 名詞背后東西的基礎。我知道這樣會讓我這篇文章很難寫下去，因為那將包含太多主題，所以本文只打算管中窺豹：本文將先講一些概念，然后講一些實踐指導原則，***涉及一些工具的討論。
在正式開始這篇博客之前，我們需要問自己為什么代碼可維護性值得我們關注。相信只要你寫過相當量的代碼后，都已經(jīng)發(fā)現(xiàn)了這點：Fix Bug比寫代碼困難得多?；ㄈ齻€小時寫的代碼，而之后為了Fix其中的一個Bug花兩三天時間，這種情況并不少見。再加上Fix Bug的人很可能不是代碼原作者，這無疑更雪上加霜。所以代碼可維護性是一個非常值得探討的話題，提高代碼可維護性就一定程度上能節(jié)省Fix Bug的時間，節(jié)省Fix Bug的時間進而就節(jié)省了人力成本。
No 1. 將代碼組織成模塊
基本任何一門編程語言都認為模塊化能提升代碼可維護性。我們知道軟件工程的核心在于控制復雜度，而模塊化本質上是分離關注點，從而分解復雜度。
IIFE模塊模式
當我們最開始學習編寫JavaSript代碼時，基本都會寫下面這樣的代碼：
重慶分公司
重慶分公司
var myVar = 10; var myFunc = function() { // ... };這樣的代碼本身沒有什么問題，但是當這樣的代碼越來越多時，會給代碼維護帶來沉重的負擔。原因是這樣導致myVar和myFunc暴露給全局命名空間，從而污染了全局命名空間。以我個人經(jīng)驗來看，一般當某個頁面中的JavaScript代碼達到200行左右時就開始要考慮這個問題了，尤其是在企業(yè)項目中。那么我們該怎么辦呢？
最簡單的解決方法是采用IIFE（Immediate Invoked Function Expression，立即執(zhí)行函數(shù)表達式）來解決（注意這里是函數(shù)表達式，而不是函數(shù)聲明，函數(shù)聲明類似 var myFunc = function() { // ... }），如下：
(function() { var myVar = 10; var myFunc = function() { // ... }; }) ();現(xiàn)在myVar和myFunc的作用域范圍就被鎖定在這個函數(shù)表達式內部，而不會污染全局命名空間了。這有點類似”沙盒機制“（也是提供了一個安全的執(zhí)行上下文）。我們知道JavaScript中沒有塊級作用域，能產(chǎn)生作用域只能借助函數(shù)，正如上面這個例子一樣。
但是現(xiàn)在myVar、myFunc只能在函數(shù)表達式內部被使用，如果它需要向外提供一些借口或功能（像大部分JavaScript框架或JavaScript庫一樣），那么該怎么辦呢？我們會采用下面的做法：
(function(window, $, undefined) { var myFunc = function() { // ... } window.myFunc = myFuc; }) (window, jQuery);我們來簡單分析下，代碼很簡單：首先將window對象和jQuery對象作為立即執(zhí)行函數(shù)表達式的參數(shù)，$只是傳入的jQuery對象的別名；其次我們并未傳遞第三個參數(shù)，但是函數(shù)卻有一個名為undefined的參數(shù)，這是一個小技巧，正因為沒有傳第三個參數(shù)，所以這里第三個參數(shù)undefined的值始終是undefined，就保證內部能放心使用undefined，而不用擔心其他地方修改undefined的值；***通過 window.myFunc導出要暴露給外部的函數(shù)。
比如我們看一個實際JavaScript類庫的例子，比如 Validate.js，我們可以看到它是這樣導出函數(shù)的：
(function(window, document, undefined) { var FormValidator = function(formName, fields, callback) { // ... }; window.FormValidator = FormValidator; }) (window, document);是不是與前面說的基本一樣？另一個例子是jQuery插件的編寫范式中的一種，如下：
(function($) { $.fn.pluginName = function() { // plugin implementation code }; })(jQuery);既然jQuery插件都來了，那再來一個jQuery源碼的例子也無妨：
(function( window, undefined ) { var jQuery = function( selector, context ) { // The jQuery object is actually just the init constructor 'enhanced' return new jQuery.fn.init( selector, context, rootjQuery ); }, // Expose jQuery to the global object window.jQuery = window.$ = jQuery; })( window );上面這樣寫使得我們調用jQuery函數(shù)既可以用$("body")，又可以用jQuery("body")。
命名空間（Namespace）
雖然使用IIEF模塊模式讓我們的代碼組織成一個個模塊，維護性提升了，但如果代碼規(guī)模進一步增大，比如達到2000-10000級別，這時前面方法的局限性又體現(xiàn)出來了？
怎么說呢？觀察下前面的代碼，所有函數(shù)都是通過作為window對象屬性的方式導出的，這樣如果有很多個開發(fā)人員同時在開發(fā)，那么就顯得不太優(yōu)雅了。尤其是有的模塊與模塊之間可能存在層級關系，這時候我們需要借助“命名空間”了，命名空間可以用來對函數(shù)進行分組。
我們可以這樣寫：
(function(myApp, $, undefined) { // ... }) (window.myApp = window.myApp || {}, jQuery);或者這樣：
var myApp = (function(myApp, $, undefined) { ... return myApp; }) (window.myApp || {}, jQuery);現(xiàn)在我們不再往立即執(zhí)行函數(shù)表達式傳遞window對象，而是傳遞掛載在window對象上的命名空間對象。第二段代碼中的 || 是為了避免在多個地方使用myApp變量時重復創(chuàng)建對象。
Revealing Module Pattern
這種模塊模式的主要作用是區(qū)分出私有變量/函數(shù)和公共變量/函數(shù)，達到將私有變量/函數(shù)隱藏在函數(shù)內部，而將公有變量/函數(shù)暴露給外部的目的。
代碼示例如下：
var myModule = (function(window, $, undefined) { var _myPrivateVar1 = ""; var _myPrivateVar2 = ""; var _myPrivateFunc = function() { return _myPrivateVar1 + _myPrivateVar2; }; return { getMyVar1: function() { return _myPrivateVar1; }, setMyVar1: function(val) { _myPrivateVar1 = val; }, someFunc: _myPrivateFunc }; }) (window, jQuery);myPrivateVar1、 myPrivateVar2是私有變量，myPrivateFunc是私有函數(shù)。而getMyVar1（public getter）、getMyVar1（public setter）、someFunc是公共函數(shù)。是不是有點類似普通的Java Bean？
或者我們可以寫成這種形式（換湯不換藥）：
var myModule = (function(window, $, undefined) { var my= {}; var _myPrivateVar1 = ""; var _myPrivateVar2 = ""; var _myPrivateFunc = function() { return _myPrivateVar1 + _myPrivateVar2; }; my.getMyVar1 = function() { return _myPrivateVar1; }; my.setMyVar1 = function(val) { _myPrivateVar1 = val; }; my.someFunc = _myPrivateFunc; return my; }) (window, jQuery);模塊擴展（Module Augmentation）
有時候我們想為某個已有模塊添加額外功能，可以像下面這樣：
var MODULE = (function (my) { my.anotherMethod = function () { // added method... }; return my; }(MODULE || {}));Tight Augmentation
上面的例子傳入的MODULE可能是undefined，也就是說它之前可以不存在。與之對應Tight Augmentation模式要求傳入的MODULE一定存在并且已經(jīng)被加載進來。
var MODULE = (function (my) { var old_moduleMethod = my.moduleMethod; my.moduleMethod = function () { // method override, has access to old through old_moduleMethod... }; return my; }(MODULE));代碼意圖很明顯：實現(xiàn)了重寫原模塊的moduleMethod函數(shù)，并且可以在重寫的函數(shù)中調用od_moduleMethod。但這種寫法不夠靈活，因為它假定了一個先決條件：MODULE模塊一定存在并且被加載進來了，且它包含moduleMethod函數(shù)。
子模塊模式
這個模式非常簡單，比如我們?yōu)楝F(xiàn)有模塊MODULE創(chuàng)建一個子模塊如下：
MODULE.sub = (function () { var my = {}; // ... return my; }());No 2. 利用OO
構造函數(shù)模式（Constructor Pattern）
JavaScript沒有類的概念，所以我們不可以通過類來創(chuàng)建對象，但是可以通過函數(shù)來創(chuàng)建對象。比如下面這樣：
var Person = function(firstName, lastName, age) { this.firstName = firstName; this.lastName = lastName; this.age = age; }; Person.prototype.country = "China"; Person.prototype.greet = function() { alert("Hello, I am " + this.firstName + " " + this.lastName); };這里firstName、lastName、age可以類比為Java類中的實例變量，每個對象有專屬于自己的一份。而country可以類比為Java類中的靜態(tài)變量，greet函數(shù)類比為Java類中的靜態(tài)方法，所有對象共享一份。我們通過下面的代碼驗證下（在Chrome的控制臺輸）：
var Person = function(firstName, lastName, age) { this.firstName = firstName; this.lastName = lastName; this.age = age; }; Person.prototype.country = "China"; Person.prototype.greet = function() { alert("Hello, I am " + this.firstName + " " + this.lastName); }; var p1 = new Person("Hub", "John", 30); var p2 = new Person("Mock", "William", 23); console.log(p1.fistName == p2.firstName); // false console.log(p1.country == p2.country); // true console.log(p1.greet == p2.greet); // true但是如果你繼續(xù)測下面的代碼，你得不到你可能預期的p2.country也變?yōu)閁K：
p1.country = "UK"; console.log(p2.country); // China
這與作用域鏈有關，后面我會詳細闡述。繼續(xù)回到這里。既然類得以通過函數(shù)模擬，那么我們如何模擬類的繼承呢？
比如我們現(xiàn)在需要一個司機類，讓它繼承Person，我們可以這樣：
var Driver = function(firstName, lastName, age) { this.firstName = firstName; this.lastName = lastName; this.age = age; }; Driver.prototype = new Person(); // 1 Driver.prototype.drive = function() { alert("I'm driving. "); }; var myDriver = new Driver("Butter", "John", 28); myDriver.greet(); myDriver.drive();代碼行1是實現(xiàn)繼承的關鍵，這之后Driver又定義了它擴展的只屬于它自己的函數(shù)drive，這樣它既可以調用從Person繼承的greet函數(shù)，又可以調用自己的drive函數(shù)了。
No3. 遵循一些實踐指導原則
下面是一些指導編寫高可維護性JavaScript代碼的實踐原則的不完整總結。
盡量避免全局變量
JavaScript使用函數(shù)來管理作用域。每個全局變量都會成為Global對象的屬性。你也許不熟悉Global對象，那我們先來說說Global對象。ECMAScript中的Global對象在某種意義上是作為一個***的“兜底兒”對象來定義的：即所有不屬于任何其他對象的屬性和方法最終都是它的屬性和方法。所有在全局作用域中定義的變量和函數(shù)都是Global對象的屬性。像escape()、encodeURIComponent()、 undefined都是Global對象的方法或屬性。
事實上有一個我們更熟悉的對象指向Global對象，那就是window對象。下面的代碼演示了定義全局對象和訪問全局對象：
myglobal = "hello"; // antipattern console.log(myglobal); // "hello" console.log(window.myglobal); // "hello" console.log(window["myglobal"]); // "hello" console.log(this.myglobal); // "hello"
使用全局變量的缺點是：
全局變量被應用中所有代碼共享，所以很容易導致不同頁面出現(xiàn)命名沖突（尤其是包含第三方代碼時）
全局變量可能與宿主環(huán)境的變量沖突
function sum(x, y) { // antipattern: implied global result = x + y; return result; }result現(xiàn)在就是一個全局變量。要改正也很簡單，如下：
function sum(x, y) { var result = x + y; return result; }另外通過var聲明創(chuàng)建的全局變量與未通過var聲明隱式創(chuàng)建的全局變量有下面的不同之處：
通過var聲明創(chuàng)建的全局變量無法被delete
而隱式創(chuàng)建的全局變量可以被delete
delete操作符運算后返回true或false，標識是否刪除成功，如下：
// define three globals var global_var = 1; global_novar = 2; // antipattern (function () { global_fromfunc = 3; // antipattern }()); // attempt to delete delete global_var; // false delete global_novar; // true delete global_fromfunc; // true // test the deletion typeof global_var; // "number" typeof global_novar; // "undefined" typeof global_fromfunc; // "undefined"推薦使用Single Var Pattern來避免全局變量如下：
function func() { var a = 1, b = 2, sum = a + b, myobject = {}, i, j; // function body... }上面只用了一個var關鍵詞就讓a、b、sum等變量全部成為局部變量了。并且為每個變量都設定了初始值，這可以避免將來可能出現(xiàn)的邏輯錯誤，并提高可讀性（設定初始值意味著能很快看出變量保存的到底是一個數(shù)值還是字符串或者是一個對象）。
局部變量相對于全局變量的另一個優(yōu)勢在于性能，在函數(shù)內部從函數(shù)本地作用域查找一個變量毫無疑問比去查找一個全局變量快。
避免變量提升（hoisting）陷阱
你很可能已經(jīng)看到過很多次下面這段代碼，這段代碼經(jīng)常用來考察變量提升的概念:
myName = "global"; function func() { console.log(myName); // undefined var myName = "local"; console.log(myName); // local } func();這段代碼輸出什么呢？JavaScript的變量提升會讓這段代碼的效果等價于下面的代碼：
myName = "global"; function func() { var myName; console.log(myName); // undefined myName = "local"; console.log(myName); // local } func();所以輸出為undefined、local就不難理解了。變量提升不是ECMAScript標準，但是卻被普遍采用
對非數(shù)組對象用for-in，而對數(shù)組對象用普通for循環(huán)
雖然技術上for-in可以對任何對象的屬性進行遍歷，但是不推薦對數(shù)組對象用for-in，理由如下：
如果數(shù)組對象包含擴展函數(shù)，可能導致邏輯錯誤
for-in不能保證輸出順序
for-in遍歷數(shù)組對象性能較差，因為會沿著原型鏈一直向上查找所指向的原型對象上的屬性
所以推薦對數(shù)組對象用普通的for循環(huán)，而對非數(shù)組對象用for-in。但是對非數(shù)組對象使用for-in時常常需要利用hasOwnProperty()來濾除從原型鏈繼承的屬性（而一般不是你想要列出來的），比如下面這個例子：
// the object var man = { hands: 2, legs: 2, heads: 1 }; // somewhere else in the code // a method was added to all objects if (typeof Object.prototype.clone === "undefined") { Object.prototype.clone = function () {}; } for(var i in man) { console.log(i, ": ", man[i]); }輸出如下：
hands : 2 legs : 2 heads : 1 clone : function () {}即多了clone，這個可能是另外一個開發(fā)者在Object的原型對象上定義的函數(shù)，卻影響到了我們現(xiàn)在的代碼，所以規(guī)范的做法有兩點。***堅決不允許在原生對象的原型對象上擴展函數(shù)或者屬性 。 第二將代碼改寫為類似下面這種：
for(var i in man) { if(man.hasOwnProperty(i)) { console.log(i, ": ", man[i]); } }進一步我們可以改寫代碼如下：
for(var i in man) { if(man.hasOwnProperty(i)) { console.log(i, ": ", man[i]); } }這樣有啥好處呢？***點防止man對象重寫了hasOwnProperty函數(shù)的情況；第二點性能上提升了，主要是原型鏈查找更快了。
進一步緩存Object.prototype.hasOwnProperty函數(shù)，代碼變成下面這樣：
var i, hasOwn = Object.prototype.hasOwnProperty; for (i in man) { if (hasOwn.call(man, i)) { // filter console.log(i, ":", man[i]); } }避免隱式類型轉換
隱式類型轉換可能導致一些微妙的邏輯錯誤。我們知道下面的代碼返回的是true：
0 == false 0 == ""
建議做法是始終使用恒等于和恒不等于，即===和!===。
而對于下面的代碼：
null == false undefined == false
我們常常期望它返回true的，但卻返回的是false。
那么我們可以用下面的代碼來將其強制轉換為布爾類型后比較：
!!null === false !!undefined === false
避免eval()
eval()接受任意字符串并將其作為JavaScript代碼進行執(zhí)行，最初常用于執(zhí)行動態(tài)生成的代碼，但是eval()是有害的，比如可能導致XSS漏洞，如果根據(jù)某個可變屬性名訪問屬性值，可以用[]取代eval()，如下：
// antipattern var property = "name"; alert(eval("obj." + property)); // preferred var property = "name"; alert(obj[property]);注意傳遞字符串給setTimeout()、setInterval()和Function()也類似eval()，也應該避免。比如下面：
// antipatterns setTimeout("myFunc()", 1000); setTimeout("myFunc(1, 2, 3)", 1000); // preferred setTimeout(myFunc, 1000); setTimeout(function () { myFunc(1, 2, 3); }, 1000);如果你遇到非要使用eval()不可的場景，用new Function()替代，因為eval()的字符串參數(shù)中即使通過var聲明變量，它也會成為一個全局變量，而new Function()則不會，如下：
eval("var myName='jxq'");則myName成了全局變量，而用newFunction()如下：
var a = new Function("firstName, lastName", "var myName = firstName+lastName");實際上a現(xiàn)在是一個匿名函數(shù)：
function anonymous(firstName, lastName) { var myName = firstName+lastName }則myName現(xiàn)在就不是全局變量了。當然如果還堅持用eval()，可以用一個立即執(zhí)行函數(shù)表達式將eval()包起來：
(function() { eval("var myName='jxq';"); }) (); // jxq console.log(typeof myName); // undefined另外一個eval()和Function()的區(qū)別是前者會影響作用域鏈，而后者不會，如下：
(function() { var local = 1; eval("console.log(typeof local);"); })(); // number (function() { var local = 1; Function("console.log(typeof local);"); })(); // undefined使用parseInt()時，指定第二個進制參數(shù)
這個不用多提，相信大家也都知道了
使用腳本引擎，讓JavaScript解析數(shù)據(jù)生成HTML
傳說中的12306在查詢車票時返回的是下面這么一大串（我已無力吐槽，這個是我今天剛截的，實際大概100來行）：