[TOC=2,4] `think`是一個全局對象，該對象里包含了大量有用的屬性和方法。這些方法在應用的任何地方都可以直接使用，無需再 require。 ### 屬性 #### think.startTime 服務啟動時間，是個`unix`時間戳。 #### think.env 當前項目運行的環境，默認支持下面3個值，可以在項目啟動時指定： * `development`?開發環境，會自動更新修改的文件 * `testing`?測試環境 * `production`?線上環境，代碼上線時使用 #### think.dirname 項目的文件夾名稱，可以在項目啟動時指定，默認值如下： ~~~ think.dirname = { config: "config", //配置文件目錄 controller: "controller", //控制器目錄 model: "model", //模型目錄 adapter: "adapter", //適配器目錄 logic: "logic", //邏輯目錄 service: "service", //服務目錄 view: "view", //視圖目錄 middleware: "middleware", //中間件目錄 runtime: "runtime", //運行時目錄 common: "common", //通用目錄 bootstrap: "bootstrap", //啟動目錄 locale: "locale" //本土化目錄 } ~~~ #### think.port 項目運行的端口，可以在項目啟動時指定。如果指定，則忽略配置文件里的端口。 #### think.cli 是否是命令行模式在運行項目，默認為`false`。如果是命令行模式，則該值為傳遞的參數，可以通過下面的方式啟動命令行模式。 ~~~ node www/index.js /home/index/test ~~~ #### think.lang 系統當前的語言，從環境變量中讀取，在`windows`下可能為空。 #### think.mode 項目當前的模式，框架支持3中項目模式： * `think.mode_mini`?單模塊模式，整個項目只有一個模塊 * `think.mode_normal`?多模塊模式，目錄結構只有`Controller`，`View`，`Logic`等分模塊 * `think.mode_module`?多模塊模式，嚴格按照模塊來劃分目錄結構 #### think.version ThinkJS當前的版本 #### think.module 當前項目下的模塊列表，如果項目模式是`think.mode_mini`，那么值為空數組。 #### think.THINK_PATH ThinkJS代碼的路徑 #### think.THINK_LIB_PATH ThinkJS代碼`lib/`的具體路徑 #### think.ROOT_PATH 項目的根目錄，在`www/index.js`中定義 #### think.APP_PATH 項目的`app`目錄，在`www/index.js`中定義 #### think.RESOURCE_PATH 項目的靜態資源根目錄，在`www/index.js`中定義 ### 方法 #### think.Class(methods, clean) 動態的創建一個類，默認繼承自 think.base 。 如果使用 ES6 特性進行開發的話，可以直接使用 ES6 里的 class 來創建類。 ~~~ //繼承自 think.base var Cls1 = think.Class({ getName: function(){ } }) ~~~ ##### 不繼承 think.base ~~~ var Cls2 = think.Class({ getName: function(){ } }, true); ~~~ ##### 繼承一個類 ~~~ //繼承自 Cls2 var Cls3 = think.Class(Cls2, { init: function(name){ this.name = name; }, getName: function(){ } }) ~~~ ##### 實例化類 ~~~ //獲取類的實例，自動調用 init 方法 var instance = new Cls3("thinkjs"); ~~~ #### think.extend(target, source1, source2, ...) * `target`?{Object} 目錄對象 * `source1`?{Mixed} 源對象1 * `return`?{Object} 目錄對象 將 source1, source2 等對象上的屬性或方法復制到 target 對象上，類似于 jQuery 里的 $.extend 方法。 默認為深度復制，可以將第一個參數傳?`false`?進行淺度復制。 ~~~ think.extend({}, {name: "foo"}, {value: "bar"}); // returns {name: "foo", value: "bar"} ~~~ #### think.isBoolean(obj) * `obj`?{Mixed} 要檢測的對象 * `return`?{Boolean} 檢測一個對象是否是布爾值。 ~~~ think.isBoolean(true); //true think.isBoolean(false); //true think.isBoolean("string"); //false ~~~ #### think.isNumber(obj) * `obj`?{Mixed} 要檢測的對象 * `return`?{Boolean} 檢測一個對象是否是數字。 ~~~ think.isNumber(1); //true think.isNumber(1.21); //true ~~~ #### think.isObject(obj) * `obj`?{Mixed} 要檢測的對象 * `return`?{Boolean} 檢測是否是對象 ~~~ think.isObject({}); //true think.isObject({name: "welefen"}); //true think.isObject(new Buffer("welefen")); //false ~~~ #### think.isString(obj) * `obj`?{Mixed} 要檢測的對象 * `return`?{Boolean} 檢測是否是字符串 ~~~ think.isString("xxx"); // true think.isString(new String("xxx")); //true ~~~ #### think.isFunction(obj) * `obj`?{Mixed} 要檢測的對象 * `return`?{Boolean} 檢測是否是函數 ~~~ think.isFunction(function(){}); //true think.isFunction(new Function("")); //true ~~~ #### think.isDate(obj) * `obj`?{Mixed} 要檢測的對象 * `return`?{Boolean} 檢測是否是日期對象 ~~~ think.isDate(new Date()); //true ~~~ #### think.isRegexp(obj) * `obj`?{Mixed} 要檢測的對象 * `return`?{Boolean} 檢測是否是正則 ~~~ think.isRegexp(/\w+/); //true think.isRegexp(new RegExp("/\\w+/")); //true ~~~ #### think.isError(obj) * `obj`?{Mixed} 要檢測的對象 * `return`?{Boolean} 檢測是否是個錯誤 ~~~ think.isError(new Error("xxx")); //true ~~~ #### think.isEmpty(obj) * `obj`?{Mixed} 要檢測的對象 * `return`?{Boolean} 檢測是否為空 ~~~ // 檢測是否為空 think.isEmpty({}); //true think.isEmpty([]); //true think.isEmpty(""); //true think.isEmpty(0); //true think.isEmpty(null); //true think.isEmpty(undefined); //true think.isEmpty(false); //true ~~~ #### think.isArray(obj) * `obj`?{Mixed} 要檢測的對象 * `return`?{Boolean} 檢測是否是數組 ~~~ think.isArray([]); //true think.isArray([1, 2]); //true think.isArray(new Array(10)); //true ~~~ #### think.isIP4(obj) * `obj`?{Mixed} 要檢測的對象 * `return`?{Boolean} 檢測是否是 IP4 ~~~ think.isIP4("10.0.0.1"); //true think.isIP4("192.168.1.1"); //true ~~~ #### think.isIP6(obj) * `obj`?{Mixed} 要檢測的對象 * `return`?{Boolean} 檢測是否是 IP6 ~~~ think.isIP6("2031:0000:130f:0000:0000:09c0:876a:130b"); //true think.isIP6("2031:0000:130f::09c0:876a:130b"); //true ~~~ #### think.isIP(obj) * `obj`?{Mixed} 要檢測的對象 * `return`?{Boolean} 檢測是否是 IP ~~~ think.isIP("10.0.0.1"); //true think.isIP("192.168.1.1"); //true think.isIP("2031:0000:130f:0000:0000:09c0:876a:130b"); //true ip6 ~~~ #### think.isFile(file) * `file`?{Mixed} 要檢測的文件路徑 * `return`?{Boolean} 檢測是否是文件，如果在不存在則返回 false ~~~ think.isFile("/home/welefen/a.txt"); //true think.isFile("/home/welefen/dirname"); //false ~~~ #### think.isDir(dir) * `dir`?{Mixed} 要檢測的路徑 * `return`?{Boolean} 檢測是否是目錄，如果不存在則返回 false ~~~ think.isDir("/home/welefen/dirname"); //true ~~~ #### think.isBuffer(obj) * `obj`?{Mixed} 要檢測的對象 * `return`?{Boolean} 檢測是否是 Buffer ~~~ think.isBuffer(new Buffer(20)); //true ~~~ #### think.isNumberString(obj) * `obj`?{Mixed} 要檢測的對象 * `return`?{Boolean} 是否是字符串類型的數字 ~~~ think.isNumberString(1); //true think.isNumberString("1"); //true think.isNumberString("1.23"); //true ~~~ #### think.isPromise(obj) * `obj`?{Mixed} 要檢測的對象 * `return`?{Boolean} 檢測是否是個 promise ~~~ think.isPromise(new Promise(function(){})); //true think.isPromise(getPromise()); //true ~~~ #### think.isHttp(obj) * `obj`?{Mixed} 要檢測的對象 * `return`?{Boolean} 檢測是否是包裝的 http 對象 ~~~ think.isHttp(http); // true ~~~ #### think.isWritable(path) * `path`?{String} 要寫的目錄 * `return`?{Boolean} 判斷文件或者目錄是否可寫，如果不存在則返回 false #### think.isPrevent(obj) * `obj`?{Mixed} * `return`?{Boolean} 判斷是否是個阻止類型的 promise。通過 think.prevent() 會生成該 promise 。 #### think.mkdir(p, mode) * `p`?{String} 要創建的目錄 * `mode`?{Number} 要創建的目錄權限，默認為?`0777` 遞歸的創建目錄，如果目錄已經存在，那么修改目錄的權限。 ~~~ // 假設 /home/welefen/a/b/ 不存在 think.mkdir("/home/welefen/a/b"); think.mkdir("home/welefne/a/b/c/d/e"); // 遞歸創建子目錄 ~~~ #### think.rmdir(p, reserve) * `p`?{String} 要刪除的目錄 * `reserve`?{Boolean} 是否保留該目錄。如果為 true，則只刪除子目錄 * `return`?{Promise} 遞歸的刪除目錄，如果目錄不存在則直接返回。返回是個 Promise，后續操作要在?`then`?里執行 ~~~ function rmTmp(){ think.rmdir("/foo/bar").then(function(){ //后續其他操作 }) } ~~~ 如果使用?`Generator Function`，則可以使用?`yield` ~~~ function * rmTmp(){ yield think.rmdir("/foo/bar"); //后續其他操作 } ~~~ #### think.chmod(p, mode) * `p`?{String} 要修改的目錄 * `mode`?{Number} 目錄權限，默認為`0777` 修改目錄權限，如果目錄不存在則直接返回 ~~~ think.chmod("/home/welefen/a", 0777); ~~~ #### think.md5(str) * `str`?{String} 要計算md5值的字符串 * `return`?{String} md5值 計算字符串的md5值 ~~~ think.md5("thinkjs"); // returns 7821eb623e0b1138a47db6a88c3f56bc ~~~ #### think.defer() * `return`?{Object} Deferred對象 創建一個`Deferred`對象，`new Promise`的一種快捷方式。雖然不建議使用`Deferred`這種方式，但有時候不得不使用。如：`setTimeout`,?`event`。 ~~~ //使用Deferred的方式 var fn = function(){ var deferred = think.defer(); process.nextTick(function(){ if(xxx){ deferred.resolve(data); }else{ deferred.reject(err); } }) return deferred.promise; } ~~~ 使用`Deferred`方式比直接使用`new Promise`的方法代碼更加簡潔。 ~~~ //直接使用new Promise的方式 var fn = function(){ return new Promise(function(resolve, reject){ process.nextTick(function(){ if(xxx){ resolve(data); }else{ reject(err); } }) }) } ~~~ 注： 異步`callback`的操作不要使用`Deferred`方式，可以用`think.promisify`方法快速把`callback`包裝成`Promise`。 #### think.promisify(fn, receiver) * `fn`?{Function} 要轉化的函數 * `receiver`?{Object} this指向 將異步方法快速包裝成Promise，異步方法必須符合最后一個參數為回調函數，且回調函數的第一個參數為`err`的原則。 ~~~ var fs = require("fs"); //獲取文件內容 var getContent = function(filePath){ //將readFile方法包裝成Promise var readFilePromise = think.promisify(fs.readFile, fs); //讀取文件內容 return readFilePromise(filePath, "utf8"); } //獲取具體的文件內容 getContent("/foo/bar/file.txt").then(function(content){ console.log(content); }).catch(function(err){ console.error(err.stack); }) ~~~ #### think.reject(err) * `err`?{Error} Error對象 * `return`?{Promise} reject promise 返回一個 reject promise，與`Promise.reject`不同的是，該方法會自動打印錯誤信息。避免需要調用 catch 方法手工打印錯誤信息。 ~~~ //使用Promise.reject var fn = function(){ return Promise.reject(new Error("xxx")); } //需要手工調用catch方法打印錯誤信息 fn().catch(function(err){ console.error(err.stack); }) ~~~ ~~~ //使用think.reject var fn = function(){ return think.reject(new Error("xxx")); } //會自動打印格式化后的錯誤信息 fn(); ~~~ #### think.co `co`模塊的別名?[https://github.com/tj/co](https://github.com/tj/co) #### think.lookClass(name, type, module, base) * `name`?{String} 類名 * `type`?{String} 類型 (controller | model | logic ...) * `module`?{String} 模塊名 * `base`?{String} 找不到時找對應的基類 根據類型，名稱來查找類。如果找不到會到 common 模塊下查找，如果還是找不到，則查找對應類型的基類。 ~~~ //查找 home 模塊下 user controller //如果找不到，會找 common 模塊下 user controller //如果還是找不到，會找 base controller think.lookClass("user", "controller", "home"); //查找 admin 模塊下 user controller think.lookClass("admin/user", "controller"); ~~~ #### think.getPath(module, type, prefix) * `module`?{String} 模塊名 * `type`?{String} 類型，如： controller, model, logic * `prefix`?{String} 前綴 根據當前項目類型獲取對應類型的目錄。 ~~~ let path = think.getPath("home", "controller"); ~~~ 假如當前項目的根目錄是`/foo/bar`，那么獲取到的目錄為： * 項目模式`think.mode_mini`?下路徑為?`/foo/bar/app/controller` * 項目模式`think.mode_normal`?下路徑為?`/foo/bar/app/controller/home` * 項目模式`think.mode_module`?下路徑為?`/foo/bar/app/home/controller` #### think.require(name, flag) * `name`?{String} * `flag`?{Boolean} #### think.safeRequire(file) * `file`?{String} 要加載的文件 安全的加載一個文件，如果文件不存在，則返回null，并打印錯誤信息。 #### think.prevent() 返回一個特殊的 reject promise 。該 promise 可以阻止后續的行為且不會報錯。 #### think.log(msg, type, showTime) * `msg`?{String | Error} 信息 * `type`?{String} 類型 * `showTime`?{Number | Boolean} 是否顯示時間 打印日志，該方法打印出來的日志會有時間，類型等信息，方便查看和后續處理。 ~~~ think.log("WebSocket Status: closed", "THINK"); //writes "[2015-09-23 17:43:00] [THINK] WebSocket Status: closed" ~~~ ##### 打印錯誤信息 ~~~ think.log(new Error("error"), "ERROR"); //writes "[2015-09-23 17:50:17] [Error] Error: error" ~~~ ##### 顯示執行時間 ~~~ think.log("/static/module/jquery/1.9.1/jquery.js", "HTTP", startTime); //writes "[2015-09-23 17:52:13] [HTTP] /static/module/jquery/1.9.1/jquery.js 10ms" ~~~ ##### 不顯示時間 ~~~ think.log("/static/module/jquery/1.9.1/jquery.js", "HTTP", null); //writes "[HTTP] /static/module/jquery/1.9.1/jquery.js" ~~~ ##### 自定義 ~~~ think.log(function(colors){ return colors.yellow("[WARNING]") + " test"; }); //writes "[WARNING] test" ~~~ 其中`colors`為 npm 模塊 colors，[https://github.com/Marak/colors.js](https://github.com/Marak/colors.js)?。 #### think.config(name, value, data) * `name`?{String} 配置名稱 * `value`?{Mixed} 配置值 * `data`?{Object} 配置對象 讀取或者設置配置，可以指定總的配置對象。 ~~~ //獲取配置 let value = think.config("name"); //獲取 admin 模塊下的配置 let value = think.config("name", undefined, "admin"); // 寫入配置 think.config("name", "value"); ~~~ #### think.getModuleConfig(module) * `module`?{String} 模塊名稱 * `return`?{Object} 獲取模塊的所有配置。該配置包含模塊的配置，通用模塊的配置，框架默認的配置。 ~~~ //獲取 admin 模塊的所有配置 let configs = think.getModuleConfig("admin"); ~~~ #### think.hook() 注冊、獲取和執行 hook。 系統默認的 hook 列表： ~~~ export default { form_parse: ["parse_json_payload"], resource_check: ["resource"], resource_output: ["output_resource"], route_parse: ["rewrite_pathname", "subdomain_deploy", "route"], app_begin: ["check_csrf", "read_html_cache"], view_init: [], view_template: ["locate_template"], view_parse: ["parse_template"], view_filter: [], view_end: ["write_html_cache"], app_end: [] }; ~~~ 項目中可以根據需要追加或者修改。 ##### 獲取事件對應的 middleware 列表 ~~~ think.hook("view_template"); //returns ["locate_template"] ~~~ ##### 設置 hook ~~~ //替換原有的 hook think.hook("view_template", ["locate_template1"]); //將原有的之前追加 think.hook("view_template", ["locate_template1"], "prepend"); //將原有的之后追加 think.hook("view_template", ["locate_template1"], "append"); ~~~ ##### 刪除 hook ~~~ think.hook("view_template", null); ~~~ ##### 執行 hook ~~~ let result = think.hook("view_template", http, data); //result is a promise ~~~ #### think.middleware() 注冊、創建、獲取和執行 middleware。 ##### 創建 middleware ~~~ //解析 XML 示例 var ParseXML = think.middlearea({ run: function(){ var http = this.http; var payload = http.payload; //payload為上傳的post數據 var data = xmlParse.parse(payload); //使用一個xml解析，這里 xmlParse 是示例 http._post = data; //將解析后的數據賦值給 http._post，后續可以通過 http.post("xxx") 獲取 } }); ~~~ 使用 ES6 創建 middleware。 ~~~ let Cls1 = class extends think.middleware.base { run(){ let http = this.http; } } ~~~ ##### 注冊 middleware middlearea 可以是個簡單的 function，也可以是較為復雜的 class。 ~~~ //注冊 middleware 為 function think.middleware("parse_xml", http => { }) ~~~ ~~~ //注冊 middleware 為 class //會自動調用 run 執行 let Cls = think.middlearea({ run: function(){ let http = this.http; } }); think.middleware("parse_xml", Cls); ~~~ ##### 獲取 middleware ~~~ let middlearea = think.middleare("parse_xml"); ~~~ ##### 執行 middleware ~~~ let result = think.middleare("parse_xml", http); //result is a promise ~~~ #### think.adapter() 創建、注冊、獲取和執行 adapter。 ##### 創建 adapter ~~~ //創建一個 adapter var Cls = think.adapter({ }); //創建一個 session adapter，繼承自 session base 類 var Cls = think.adapter("session", "base", { }) ~~~ ~~~ //使用 ES6 創建一個 session adapter let Cls = class extends think.adapter.session { } ~~~ ##### 注冊 adapter ~~~ //注冊一個 xxx 類型的 session adapter think.adapter("session", "xxx", Cls); ~~~ ##### 獲取 adapter ~~~ //獲取 file 類型的 session adapter let Cls = think.adapter("session", "file"); ~~~ ##### 執行 adapter ~~~ let Adapter = think.adapter("session", "file"); let instance = new Adapter(options); ~~~ #### think.gc(instance) * `instance`?{Object} 類的實例 注冊實例到 gc 隊列中。instance 必須含有屬性`gcType`和方法`gc`。 像 cache, session 這些功能一般都是有過期時間，過期后需要要進行清除工作。框架提供了一套機制方便清除過期的文件等。 ~~~ let Cls = class extends think.adapter.cache { init(options){ super.init(options); this.gcType = "xFileCache"; think.gc(this); } gc(){ //尋找過期的內容并清除 } } ~~~ #### think.http(req, res) * `req`?{Object} request 對象 * `res`?{Object} response 對象 * `return`?{Promise} 根據 req 和 res 包裝成 http 對象。req 和 res 可以自定義。 ~~~ //根據一個 url 生成一個 http 對象，方便命令行下調用 think.http("/index/test").then(http => { }); ~~~ #### think.uuid(length) * `length`?{Number} 生成字符串的長度，默認為 32 生成一個隨機字符串。 #### think.session(http) * `http`?{Object} http對象 生成 session，并寫到 http 對象上。如果已經存在，則直接返回。 #### think.controller() 創建、執行 controller ##### 創建 controller ~~~ //創建 controller, 繼承 think.controller.base let Cls = think.controller({ }) //創建 controller, 繼承 think.controller.rest let Cls = think.controller("rest", { }) ~~~ ~~~ //使用 ES6 創建 controller let Cls1 = class extends think.controller.base { } ~~~ ##### 實例化 controller ~~~ //實例化 home 模塊下 user controller let instance = think.controller("user", http, "home"); ~~~ #### think.logic() 創建、執行 logic ##### 創建 logic ~~~ //創建 logic, 繼承 think.logic.base let Cls = think.logic({ }) ~~~ ~~~ //使用 ES6 創建 logic let Cls1 = class extends think.logic.base { } ~~~ ##### 實例化 logic ~~~ //實例化 home 模塊下 user logic let instance = think.logic("user", http, "home"); ~~~ #### think.model() 創建或者獲取 model。 ##### 創建 model ~~~ //創建一個 model let model = think.model({ getList: function(){ } }); //ES6 里直接繼承 think.model.base 類 let model = class extends think.model.base { getList(){ } } //創建一個 model 繼承自 mongo model let model = think.model("mongo", { getList: function(){ } }); //ES6 里直接繼承 think.model.mongo 類 let model = class extends think.model.mongo { getList(){ } } ~~~ ##### 獲取 model 實例 ~~~ let configs = { host: "127.0.0.1", name: "user" } //獲取 home 模塊下 user model let instance = think.model("user", configs, "home"); ~~~ #### think.service() 創建或者獲取 service。 ##### 創建 service ~~~ //創建一個 service 類 let service = think.service({ }) //ES6 里直接繼承 think.service.base 類 let service = class extends think.service.base { } ~~~ service 基類繼承自?[think.base](https://thinkjs.org/zh-CN/doc/2.0/api_think_base.html)，所以可以用 think.base 里的方法。 如果 serivce 不想寫成類，那就沒必要通過這種方法創建。 ##### 獲取 service ~~~ //獲取 home 模塊下 post service，并傳遞參數 {} //如果獲取到的 service 是個類，則自動實例化 think.service("post", {}, "home"); ~~~ #### think.cache(name, value, options) * `name`?{String} 緩存 key * `value`?{Mixed} 緩存值 * `options`?{Object} 緩存選項 * `return`?{Promise} 操作都是返回 Promise 獲取、設置或者刪除緩存， value 是?`undefined`?表示讀取緩存。 value 是?`null`?時刪除緩存。 value 為?`Function`?時表示獲取緩存，如果獲取不到，則調用該函數，然后將返回值設置到緩存中并返回。 ~~~ //獲取緩存 think.cache("name").then(data => {}); //指定緩存類型獲取，從 redis 里獲取緩存 think.cache("name", undefined, {type: "redis"}); //如果緩存 userList 不存在，則查詢數據庫，并將值設置到緩存中 think.cache("userList", () => { return think.model("user").select(); }); //設置緩存 think.cache("name", "value"); //刪除緩存 think.cache("name", null); ~~~ #### think.locale(key, ...data) * `key`?{String} 要獲取的 key * `data`?{Array} 參數 根據語言獲取對應的值，當前語言存放在`think.lang`，可以在系統啟動時指定。 ~~~ think.locale("CONTROLLER_NOT_FOUND", "test", "/index/test"); //returns "controller `test` not found. url is `/index/test`." ~~~ #### think.validate() 注冊、獲取或執行檢測。 ##### 注冊檢測方法 ~~~ //注冊檢測類型為 not_number think.validate("not_number", value => { return !(/^\d+$/.test(value)); }) ~~~ ##### 獲取檢測方法 ~~~ let fn = think.validate("not_number"); ~~~ ##### 檢測數據 ~~~ let result = think.validate({ name: { value: "name", required: true, not_number: true }, pwd: { value: "xxx", required: true, minLength: 6 } }); //如果 result 是 isEmpty，表示數據都正常 if(think.isEmpty(result)){ } ~~~ #### think.await(key, callback) * `key`?{String} * `callback`?{Function} 執行等待，避免一個耗時的操作多次被執行。 callback 需要返回一個 promise 。 如：用戶訪問時，要請求一個遠程的接口數據。如果不處理，每個用戶請求都會觸發這個遠程接口的訪問，導致有很大的資源浪費。可以讓這些用戶公用一個遠程接口的請求。 ~~~ import superagent from "superagent"; export default class extends think.controller.base { * indexAction(){ let result = yield think.await("get_xxx_data", () => { let req = superagent.post("xxxx"); let fn = think.promisify(req.end, req); return fn(); }); this.success(result); } } ~~~ #### think.npm(pkg) * `pkg`?{String} 模塊名 加載模塊。如果模塊不存在，則自動安裝。這樣可以做到動態安裝模塊。 ~~~ //如果mysql模塊，則通過npm安裝 let mysql = think.npm("mysql"); ~~~ ~~~ //指定版本加載一個模塊 let mysql = think.npm("mysql@2.0.0") ~~~ #### think.error(err, addon) * `err`?{Error | Promise | String} 錯誤信息 * `addon`?{Error | String} 追加的錯誤信息 格式化錯誤信息，將部分系統的錯誤信息描述完整化。 ~~~ let error = think.error(new Error("xxx")); ~~~ ##### 捕獲 promise 的錯誤信息 ~~~ let promise = Project.reject(new Error("xxx")); promise = think.error(promise) ~~~ 自動給 promise 追加 catch，捕獲錯誤信息。 #### think.statusAction(status, http, log) * `status`?{Number} 狀態碼 * `http`?{Object} 包裝的http對象 * `log`?{Boolean} 是否打印錯誤信息 當系統出現異常時（系統錯誤，頁面找不到，沒權限等），顯示對應的錯誤頁面。 創建項目時，會在 common 模塊下生成文件?`src/common/controller/error.js`，專門用來處理錯誤情況。 默認支持的錯誤類型有：`400`,?`403`,?`404`,?`500`,?`503`。 項目里可以根據需要修改錯誤頁面或者擴展。 ~~~ export default class extends think.controller.base { indexAction(){ if(xxxx){ let error = new Error("not found"); //將錯誤信息寫到 http 對象上，用于模版里顯示 this.http.error = error; return think.statusAction(404, this.http); } } } ~~~ ### 類 #### think.base think.base 詳細介紹請見?[這里](https://thinkjs.org/zh-CN/doc/2.0/api_think_base.html) #### think.http.base think.http.base 詳細介紹請見?[這里](https://thinkjs.org/zh-CN/doc/2.0/api_think_http_base.html) 文檔地址：[https://github.com/75team/www.thinkjs.org/tree/master/view/zh-CN/doc/2.0/api_think.md](https://github.com/75team/www.thinkjs.org/tree/master/view/zh-CN/doc/2.0/api_think.md)