本文以循序漸進的方式,從理論到實踐,梳理出 RequireJS 官方 API 文件中最常用的一些用法,並對文件裡不夠清晰的地方加以舉例與分析,供大家參考。
1. 模組化
相信每個前端開發者在剛接觸 JavaScript 時,都寫過類似下面這種風格的程式碼:
<script type="text/javascript"> var a = 1; var b = 2; var c = a * a + b * b; if(c> 1) { alert('c > 1'); } function add(a, b) { return a + b; } c = add(a,b); </script> <a href="javascript:;" onclick="click(this);" title="">請點擊</a>
這類程式碼有幾個鮮明特徵:
這些程式碼在功能上未必有錯,但從可重用性、健壯性與可維護性來看,這種寫法是有問題的。尤其在頁面邏輯較複雜的應用中,問題會暴露得特別明顯:
於是,當這些問題浮現時,JavaScript 的先行者們開始尋找根本的解法,模組化開發便應運而生。顧名思義,它要求在編寫程式碼時,按層次、按功能,把獨立的邏輯封裝成可重用的模組,對外提供清晰明瞭的呼叫介面,內部細節則完全私有,且各模組在執行期間互不干擾,最終便能解決前面提到的痛點。以下是一個符合模組化要求的簡單範例:
//module.js var student = function (name) { return name && { getName: function () { return name; } }; }, course = function (name) { return name && { getName: function () { return name; } } }, controller = function () { var data = {}; return { add: function (stu, cour) { var stuName = stu && stu.getName(), courName = cour && cour.getName(), current, _filter = function (e) { return e === courName; }; if (!stuName || !courName) return; current = data[stuName] = data[stuName] || []; if (current.filter(_filter).length === 0) { current.push(courName); } }, list: function (stu) { var stuName = stu && stu.getName(), current = data[stuName]; current && console.log(current.join(';')); } } }; //main.js var stu = new student('lyzg'), c = new controller(); c.add(stu,new course('javascript')); c.add(stu,new course('html')); c.add(stu,new course('css')); c.list(stu); 上述程式碼定義了學生、課程與控制器三個模組,接著在 main.js 中呼叫 controller 提供的 add 與 list 介面,為 lyzg 這位學生加入三門課程,最後在主控台顯示出來。運行結果如下:
javascript;html;css
由此可見,模組化的程式碼結構與邏輯十分清晰,看起來相當優雅;由於邏輯都經過拆分,也達到了去耦合的目的,功能因而更為健壯。不過這種方式仍有隱憂——它其實把 student 這類模組引用直接掛到了全域空間下。雖然模組化已大幅減少了全域變數與函式,但模組引用本身仍得依賴全域空間才能被呼叫。當模組數量變多,或引入第三方模組庫時,命名衝突的風險依然存在,因此這並非最完美的方案。目前常見的模組化方式,除了最基本的全域空間模式,還有遵循 AMD 規範、遵循 CMD 規範,以及 ECMAScript 6 的寫法。需說明的是,CMD 與 ES6 並非本文重點,後續將聚焦於 AMD 以及實現了 AMD 規範的 RequireJS。
2. AMD 規範
正如前述,模組化開發的另一種常見形式就是遵循 AMD 規範。但要澄清的是,AMD 並非某個具體實作,而是一種模組化的解決方案,你可以把它理解為一組模組化的介面宣告。若要打造一個符合該規範的工具,就必須實作它預先定義的 API。例如它要求載入模組時採用如下呼叫方式:
require([module], callback) 其中: [module]:是一個數組,裡面的成員就是要加載的模塊; callback:是模塊加載完成之後的回調函數
所有遵循 AMD 的工具都必須照此實作。RequireJS 正是完全依循 AMD 規範打造,因此只要事先了解 AMD,你就知道該怎麼使用 RequireJS。規範的好處在於:不同的實作卻有一致的呼叫方式,切換工具十分容易;至於選用哪一個,則取決於各工具的優點與專案特性,這些都需在專案選型階段確定。目前 RequireJS 並非唯一實現 AMD 的庫,連 Dojo 這類更全面的 JS 庫也都具備 AMD 實現。
最後解釋一下 AMD 的全稱——「異步模組定義」。所謂異步,強調的是在載入模組及其依賴時,都採用非同步方式,避免模組載入阻塞網頁的渲染進度。相較於傳統的異步載入,AMD 的異步載入更為簡便,還能實現按需載入,這一點將於下一節說明。
3. JavaScript 的異步載入與按需載入
HTML 中的 script 標籤在載入與執行過程會阻塞網頁渲染,因此一般建議盡量把 script 放在 body 底部以加快頁面顯示;另一種方式則是透過異步載入,避免 JS 阻塞 HTML 渲染。
第一種異步載入方式,是直接以程式碼動態產生 script 標籤:
(function() { var s = document.createElement('script'); s.type = 'text/javascript'; s.async = true; s.src = 'https://yourdomain.com/script.js'; var x = document.getElementsByTagName('script')[0]; x.parentNode.insertBefore(s, x); })(); 這段程式碼放在 script 標籤內,再把該標籤加到 body 底部即可。
第二種方式是借助 script 的 defer 與 async 屬性。defer 在 IE 與早期 Firefox 中受支援,async 則在支援 HTML5 的瀏覽器上通用;只要具備這兩個屬性,script 就會以異步方式載入,位置也就不再重要:
<script defer async="true" type="text/javascript" src="app/foo.js"></script> <script defer async="true" type="text/javascript" src="app/bar.js"></script> <script defer async="true" type="text/javascript" src="app/main.js"></script>
這種方式下,所有異步 JS 在執行時仍會依序進行,否則便會有依賴問題——若上例中的 main.js 依賴 foo.js 與 bar.js,而 main.js 卻先執行,就會出錯。理論上這已算不錯,但仍不夠理想:它使用起來頗為繁瑣,且頁面需插入多個 script 標籤,也無法真正做到按需載入。
JS 的按需載入可分為兩個層次:第一層是只載入頁面可能用到的 JS;第二層則是只在真正用到某個 JS 時才去載入。傳統方式容易做到第一層,卻難以做到第二層。雖然我們能透過合併與壓縮工具,把某頁所有 JS 集中到單一檔案以減少請求量,但載到客戶端後,其中往往有大量內容根本用不上。若能有工具在需要時才載入對應 JS,問題便迎刃而解——RequireJS 正是這樣的工具。
4. RequireJS 常用用法總結
前文多次提到 RequireJS,本節將詳細說明它的常用用法。它的官方位址是:https://www.requirejs.cn/,你可前往下載最新版本。作為目前使用最廣泛的 AMD 工具,RequireJS 的主要優點包括:
4.01 如何使用 RequireJS
使用方式很簡單,一個 script 標籤就能在網頁中載入 RequireJS:
<script defer async="true" src="/bower_components/requirejs/require.js"></script>
由於用到了 defer 與 async 這兩個異步屬性,require.js 會以異步方式載入,因此把這個 script 標籤放在任何位置都不成問題。
4.02 如何利用 RequireJS 載入並執行當前頁面的邏輯 JS
4.01 只解決了 RequireJS 本身的載入問題,但它畢竟只是一個 JS 庫,是被頁面邏輯所利用的工具;真正實現網頁功能的是我們用 RequireJS 編寫的主 JS。那麼這個主 JS(假設都放在 main.js 中)又該如何被 RJ 載入執行呢?方式如下:
<script data-main="scripts/main.js" defer async="true" src="/bower_components/requirejs/require.js"></script>
對照 4.01 你會發現,script 標籤多了一個 data-main,RJ 用它來指定當前頁面的主 JS,你的邏輯都寫在這個 main.js 裡。當 RJ 自身載入執行後,就會再次異步載入 main.js。這個 main.js 是當前網頁所有邏輯的入口;理想情況下,整個網頁只需這一個 script 標籤,其餘依賴(如 jQuery)皆由 RJ 載入。
4.03 main.js 怎麼寫
假設專案目錄結構如下:

main.js 是與當前頁面相關的主 JS,app 資料夾存放本專案自訂的模組,lib 存放第三方庫。
HTML 中按 4.02 的方式配置 RJ,main.js 的程式碼如下:
require(['lib/foo', 'app/bar', 'app/app'], function(foo, bar, app) { //use foo bar app do sth }); 這段 JS 透過 RJ 提供的 require 方法載入三個模組,並在三者都載入成功後執行頁面邏輯。require 方法有兩個參數:第一個是陣列,每個元素都是一個模組的 module ID;第二個是回調函式,會在第一個參數定義的所有模組載入成功後被呼叫,其形參的個數與順序分別對應第一個參數的模組。例如第一個模組是 lib/foo,回調函式的第一個參數就是 foo 模組的引用。由於回調在各模組載入之後才執行,這些引用必然有效。
從這段簡短的程式碼,你應該已經知道如何使用 RJ 了。
4.04 RJ 的 baseUrl 與 module ID
在說明 RJ 如何解析依賴模組路徑之前,必須先釐清 baseUrl 與 module ID 這兩個概念。
HTML 中的 base 元素可定義頁面內所有 http 請求的 URL 前綴;RJ 的 baseUrl 作用與此類似。由於 RJ 總是動態請求依賴的 JS 檔,必然涉及路徑解析問題,RJ 預設採用「baseUrl + moduleID」的解析方式(後續將舉例說明)。baseUrl 至關重要,RJ 對它的處理遵循以下規則:
上述三種方式,優先級由低到高排列。
data-main 的用法你已了解,config 的配置如下:
require.config({ baseUrl: 'scripts' });這個配置必須放在 main.js 的最前面。data-main 與 config 同時存在時,以 config 為準。由於 RJ 的其他配置也都在此處進行,4.03 的 main.js 可改寫為如下結構,以便日後擴展:
require.config({ baseUrl: 'scripts' }); require(['lib/foo', 'app/bar', 'app/app'], function(foo, bar, app) { // use foo bar app do sth }); 關於 module ID,就是用在 require 與後續 define 方法的依賴陣列參數中,用來標識某個模組的字串。上例的 ['lib/foo', 'app/bar', 'app/app'] 就是一個依賴陣列,每個元素都是 module ID。值得注意的是,module ID 不一定是該模組 JS 路徑的一部分——有的 module ID 很短,實際路徑卻很長,這與 RJ 的解析規則有關,下一節將詳細說明。
4.05 RJ 的檔案解析規則
RJ 預設按「baseUrl + module ID」解析檔案,且預設載入的檔案都是 js,因此 module ID 裡可省略 .js 後綴,這也是你看到的 module ID 都是 lib/foo、app/bar 這種形式的原因。有三種 module ID 不適用此規則:
假如 main.js 如下使用:
require.config({ baseUrl: 'scripts' }); require(['/lib/foo', 'test.js', '/js/jquery'], function(foo, bar, app) { // use foo bar app do sth }); 這三個 module 都不會依「baseUrl + module ID」解析,而是直接用 module ID 解析,等效於下面的程式碼:
<script src="/lib/foo.js"></script> <script src="test.js"></script> <script src="/js/jquery.js"></script>
以下舉例說明各種 module ID 的解析:
例 1,專案結構如下:

main.js 如下:
require.config({ baseUrl: 'scripts' }); require(['lib/foo', 'app/bar', 'app/app'], function(foo, bar, app) { // use foo bar app do sth }); baseUrl 為 scripts 目錄;moduleID 為 lib/foo、app/bar、app/app。依「baseUrl + moduleID」並自動補上 .js 後綴,最終三個模組的 JS 路徑為:
scripts/lib/foo.js scripts/app/bar.js scripts/app/app.js
例 2,專案結構同例 1,main.js 改為:
require.config({ baseUrl: 'scripts/lib', paths: { app: '../app' } }); require(['foo', 'app/bar', 'app/app'], function(foo, bar, app) { // use foo bar app do sth }); 這裡出現了一個新配置 paths,它的作用是把 module ID 中的特定部分進行轉義。以上例而言,app 被轉義為 ../app,這是一個相對路徑,相對於 baseUrl 所指定的目錄。由專案結構可知,../app 其實對應 scripts/app 目錄。正因為有這個轉義,app/bar 才能被正確解析為 scripts/app/bar.js,而非 scripts/lib/app/bar.js,關鍵就在 paths 的配置。由此可見,module ID 不一定是 JS 路徑的一部分;paths 對於路徑層次較深的 JS 特別有效,因為它能簡化 module ID。此外,第一個模組 ID 為 foo 且無 paths 轉義,依解析規則其路徑為 scripts/lib/foo.js。paths 中只有當模組位於 baseUrl 所指資料夾的同層或上層目錄時,才會用到 ../ 這種相對路徑。
例 3,專案結構同例 1,main.js 同例 2,這裡改以 app.js 為例說明。假設 app 依賴 bar(config 仍需在 main.js 中定義),由於此問題在定義模組時更常見,故用 define 舉例,app.js 模組如下:
define(['./bar'], function(bar) { return { doSth: function() { bar.doSth(); } } }); 這段程式碼透過 define 定義了一個模組(define 的用法後續再介紹),第一個參數是依賴陣列,第二個參數是回調,會在所有依賴載入成功後呼叫,其回傳值會成為此模組的引用供其他模組使用。這裡若完全遵守 RJ 解析規則,依賴應寫成 app/bar 才對;但由於 app.js 與 bar.js 位於同一目錄,因此可利用 ./ 這個同目錄相對標識符來解析——只要 app.js 已載入成功,到同目錄找 bar.js 便必然能找到。這種配置在定義模組時非常實用,因為它讓你的模組不再依賴存放資料夾的名稱。
4.06 RJ 的異步載入
RJ 無論是 require 還是 define 的依賴模組都是異步載入的,因此下面的程式碼不一定能解析到正確的 JS 檔:
<script data-main="scripts/main" src="scripts/require.js"></script> <script src="scripts/other.js"></script> //main.js require.config({ paths: { foo: 'libs/foo-1.1.3' } }); //other.js require( ['foo'], function( foo ) { //foo is undefined }); 由於 main.js 是異步載入的,other.js 會比它先載入,但 RJ 的配置存在於 main.js 中,因此 other.js 執行時讀不到 RJ 配置,解析出的 foo 路徑會變成 scripts/foo.js,而正確路徑應是 scripts/libs/foo-1.1.3.js。
儘管 RJ 的依賴是異步載入的,但已載入的模組在多次被依賴時不會重新載入:
define(['require', 'app/bar', 'app/app'], function(require) { var bar= require("app/bar"); var app= require("app/app"); //use bar and app do sth }); 上例在回調定義時只用一個形參,主要是為了減少形參數量、避免回調簽名過長。依賴的模組可在回調內部直接用 require(moduleID) 取得;由於回調執行前依賴已載入,此處呼叫不會重新載入。但若在此取得一個未出現在依賴陣列中的 module ID,require 很可能取不到該模組引用,因為它可能需要重新載入,而前提是它並未在其他模組中被載入過。
4.07 RJ 官方推薦的 JS 檔案組織結構
RJ 建議檔案組織盡量扁平、避免多層嵌套,最理想的是把專案相關的放在一個資料夾、第三方庫放在另一個資料夾,如下:

4.08 使用 define 定義模組
AMD 規定的模組定義規範為:
define(id?, dependencies?, factory); 其中: id: 模塊標識,可以省略。 dependencies: 所依賴的模塊,可以省略。 factory: 模塊的實現,或者一個JavaScript對象
關於第一個參數,本文不多著墨,因為 RJ 建議所有模組都不要使用它:使用第一個參數定義的模組稱為「命名模組」,不使用則為「匿名模組」;命名模組一旦更名,所有依賴它的模組都得跟著修改!第二個參數是依賴陣列,與 require 相同,若省略則定義的是無依賴模組;最後一個參數是回調或一個簡單物件,會在模組載入完畢後呼叫(即使沒有第二個參數,它也會被呼叫)。
本節範例皆採用如下專案結構:

1. 定義簡單物件模組(app/bar.js):
define({ bar:'I am bar.' }); 利用main.js測試: require.config({ baseUrl: 'scripts/lib', paths: { app: '../app' } }); require(['app/bar'], function(bar) { console.log(bar);// {bar: 'I am bar.'} }); 2. 定義無依賴的模組(app/nodec.js):
define(function () { return { nodec: "yes, I don't need dependence." } }); 利用 main.js 測試:
require.config({ baseUrl: 'scripts/lib', paths: { app: '../app' } }); require(['app/nodec'], function(nodec) { console.log(nodec);// {nodec: yes, I don't need dependence.'} }); 3. 定義依賴其他模組的模組(app/dec.js):
define(['jquery'], function($){ //use $ do sth ... return { useJq: true } }); 利用 main.js 測試:
require.config({ baseUrl: 'scripts/lib', paths: { app: '../app' } }); require(['app/dec'], function(dec) { console.log(dec);//{useJq: true} }); 4. 循環依賴:當模組 foo 的依賴陣列中存在 bar,而 bar 的依賴陣列中又存在 foo,便形成循環依賴。稍作修改的 bar.js 與 foo.js 如下。
app/bar.js:
define(['foo'],function(foo){ return { name: 'bar', hi: function(){ console.log('Hi! ' + foo.name); } } }); lib/foo.js:
define(['app/bar'],function(bar){ return { name: 'foo', hi: function(){ console.log('Hi! ' + bar.name); } } }); 利用 main.js 測試:
require.config({ baseUrl: 'scripts/lib', paths: { app: '../app' } }); require(['app/bar', 'foo'], function(bar, foo) { bar.hi(); foo.hi(); }); 運行結果:

若改變 main.js 中 require 部分的依賴順序,結果如下:

循環依賴會導致兩個互相依賴的模組中,始終有一個在取得另一個時得到 undefined。解法是在定義模組時,若涉及循環依賴,於 define 內部透過 require 重新取得。main.js 不變,bar.js 改為:
define(['require', 'foo'], function(require, foo) { return { name: 'bar', hi: function() { foo = require('foo'); console.log('Hi! ' + foo.name); } } }); foo.js 改為:
define(['require', 'app/bar'], function(require, bar) { return { name: 'foo', hi: function() { bar = require('app/bar'); console.log('Hi! ' + bar.name); } } }); 以此重新執行,結果如下:

模組定義總結:無論以回調函式還是簡單物件定義,模組輸出的都是一個引用,因此這個引用必須有效,回調不能回傳 undefined;但並不限於物件類型,也可以是陣列、函式甚至基本型別,只不過回傳物件時,你能藉此組織更多介面。
4.09 內建的 RJ 模組
再看這段程式碼:
define(['require', 'app/bar'], function(require) { return { name: 'foo', hi: function() { var bar = require('app/bar'); console.log('Hi! ' + bar.name); } } }); 依賴陣列中的 require 這個 moduleID 對應一個內建模組,用它來載入模組的方式你已經看過,比如在 main.js 中、在 define 中。另一個內建模組是 module,它與 RJ 的另一個配置有關,具體用法請見第 5 部分。
4.10 其他 RJ 實用功能
1. 生成相對於模組的 URL 位址
define(["require"], function(require) { var cssUrl = require.toUrl("./style.css"); }); 這個功能在你需要動態載入某些檔案時很有用,注意要使用相對路徑。
2. 主控台調試
require("module/name").callSomeFunction()
若你想在主控台查看某模組有哪些方法可呼叫,只要該模組已在頁面載入時透過依賴被載入過,就能用以上程式碼在主控台進行各種測試。
5. RequireJS 常用配置總結
在 RJ 的配置中,前面已接觸到 baseUrl 與 paths,另外幾個常用配置是:
5.01 shim
為那些未使用 define() 聲明依賴關係、屬於「瀏覽器全域變數注入」型腳本,做依賴與導出配置。
例 1:利用 exports 將模組的全域變數與 RequireJS 關聯,main.js 如下:
require.config({ baseUrl: 'scripts/lib', paths: { app: '../app' }, shim: { underscore: { exports: '_' } } }); require(['underscore'], function(_) { // 現在可以通過_調用underscore的api了 }); 如你所見,RJ 在 shim 中新增了對 underscore 模組的配置,並透過 exports 指定該模組暴露的全域變數,以便統一管理。
例 2:利用 deps 配置 JS 模組的依賴,main.js 如下:
require.config({ baseUrl: 'scripts/lib', paths: { app: '../app' }, shim: { backbone: { deps: ['underscore', 'jquery'], exports: 'Backbone' } } }); require(['backbone'], function(Backbone) { //use Backbone's API }); 由於 backbone 依賴 jquery 與 underscore,可透過 deps 屬性配置它的依賴,這樣 backbone 便會在另外兩個模組載入完畢後才載入。
例 3:jquery 等庫的外掛配置方法:
requirejs.config({ shim: { 'jquery.colorize': { deps: ['jquery'], exports: 'jQuery.fn.colorize' }, 'jquery.scroll': { deps: ['jquery'], exports: 'jQuery.fn.scroll' }, 'backbone.layoutmanager': { deps: ['backbone'] exports: 'Backbone.LayoutManager' } } }); 5.02 config
我們常需要把配置資訊傳給某個模組,這些往往是 application 層級的資訊,需要一個手段向下傳遞。在 RequireJS 中,這透過 requirejs.config() 的 config 配置項實現;需要取得這些資訊的模組可載入特殊依賴「module」,並呼叫 module.config()。
例 1:在 requirejs.config() 中定義 config 供其他模組使用
requirejs.config({ config: { 'bar': { size: 'large' }, 'baz': { color: 'blue' } } }); 如你所見,config 屬性中的 bar 這一節用於 module ID 為 bar 的模組,baz 則用於 module ID 為 baz 的模組。具體使用以 bar.js 為例:
define(['module'], function(module) { //Will be the value 'large'var size = module.config().size; }); 前面提過,RJ 的內建模組除了 require 還有 module,用法就在此處——透過它來載入 config 的內容。
5.03 enforceDefine
若設為 true,當某腳本不是透過 define() 定義、且不具備可供檢查的 shim 導出字串值時,就會拋出錯誤。這個屬性能強制要求所有 RJ 依賴或載入的模組都透過 define 或 shim 受到 RJ 管理,同時也有助於錯誤檢測。
5.04 urlArgs
RequireJS 取得資源時附加在 URL 後面的額外 query 參數。作為瀏覽器或伺服器未正確配置時的「cache bust」手段很有用,使用範例如下:
urlArgs: "bust=" + (new Date()).getTime()
6. 錯誤處理
6.01 載入錯誤的捕獲
IE 中捕獲載入錯誤並不完美:
IE 6-8 中的 script.onerror 無效,無法判斷載入腳本是否導致 404;更糟的是,在 404 中仍會觸發 state 為 complete 的 onreadystatechange 事件。
IE 9+ 中 script.onerror 有效,但有個 bug:執行腳本後它並不觸發 script.onload 事件句柄,因此無法支援匿名 AMD 模組的標準方法,所以 script.onreadystatechange 事件仍被使用;然而 state 為 complete 的 onreadystatechange 會在 script.onerror 觸發之前先觸發。
因此,為了在 IE 中捕獲載入錯誤,需將 enforceDefine 設為 true,這也要求你所有模組都用 define 定義,或用 shim 配置 RJ 對它的引用。
注意:若你設定了 enforceDefine: true,且用 data-main="" 來載入主 JS 模組,則該主 JS 模組必須用 define() 而非 require() 來載入其所需程式碼。主 JS 模組仍可呼叫 require/requirejs 設定 config 值,但模組載入必須使用 define()。例如原本這段會報錯:
require.config({ enforceDefine: true, baseUrl: 'scripts/lib', paths: { app: '../app' }, shim: { backbone: { deps: ['underscore', 'jquery'], exports: 'Backbone' } } }); require(['backbone'], function(Backbone) { console.log(Backbone); }); 把最後三行改成:
define(['backbone'], function(Backbone) { console.log(Backbone); }); 才不會報錯。
6.02 paths 備錯
requirejs.config({ //To get timely, correct error triggers in IE, force a define/shim exports check. enforceDefine: true, paths: { jquery: [ 'https://ajax.googleapis.com/ajax/libs/jquery/1.4.4/jquery.min', //If the CDN location fails, load from this location 'lib/jquery' ] } }); //Later require(['jquery'], function ($) { }); 上述程式碼會先嘗試載入 CDN 版本,若出錯則退回本地的 lib/jquery.js。注意:paths 備錯僅在模組 ID 精確匹配時才有效,這有別於常規 paths 配置(可匹配模組 ID 的任意前綴)。備錯主要用於異常的錯誤恢復,而非常規的路徑查找解析,因為後者在瀏覽器中效率較低。
6.03 全域 requirejs.onError
為了捕獲在區域 errback 中未被捕獲的異常,你可以重載 requirejs.onError():
requirejs.onError = function (err) { console.log(err.requireType); if (err.requireType === 'timeout') { console.log('modules: ' + err.requireModules); } throw err; }; 以上就是本文的全部內容,希望對大家的學習有所幫助。