think（ThinkJS全局對象）

think是一個全局對象，該對象里包含了大量有用的屬性和方法。這些方法在應用的任何地方都可以直接使用，無需再 require。

屬性

think.startTime

服務啟動時間，是個unix時間戳。

think.env

當前項目運行的環(huán)境，默認支持下面3個值，可以在項目啟動時指定：

• development 開發(fā)環(huán)境，會自動更新修改的文件
• testing 測試環(huán)境
• production 線上環(huán)境，代碼上線時使用

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。如果是命令行模式，則該值為傳遞的參數(shù)，可以通過下面的方式啟動命令行模式。

node www/index.js /home/index/test

think.lang

系統(tǒng)當前的語言，從環(huán)境變量中讀取，在windows下可能為空。

think.mode

項目當前的模式，框架支持3中項目模式：

• think.mode_mini 單模塊模式，整個項目只有一個模塊
• think.mode_normal 多模塊模式，目錄結構只有Controller，View，Logic等分模塊
• think.mode_module 多模塊模式，嚴格按照模塊來劃分目錄結構

think.version

ThinkJS當前的版本

think.module

當前項目下的模塊列表，如果項目模式是think.mode_mini，那么值為空數(shù)組。

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

項目的靜態(tài)資源根目錄，在www/index.js中定義

方法

think.Class(methods, clean)

動態(tài)的創(chuàng)建一個類，默認繼承自 think.base 。 如果使用 ES6 特性進行開發(fā)的話，可以直接使用 ES6 里的 class 來創(chuàng)建類。

//繼承自 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 方法。

默認為深度復制，可以將第一個參數(shù)傳 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}

檢測一個對象是否是數(shù)字。

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}

檢測是否是函數(shù)

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}

檢測是否是數(shù)組

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}

是否是字符串類型的數(shù)字

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} 要創(chuàng)建的目錄
• mode {Number} 要創(chuàng)建的目錄權限，默認為 0777

遞歸的創(chuàng)建目錄，如果目錄已經存在，那么修改目錄的權限。

// 假設 /home/welefen/a/b/ 不存在
think.mkdir("/home/welefen/a/b");
think.mkdir("home/welefne/a/b/c/d/e"); // 遞歸創(chuàng)建子目錄

think.rmdir(p, reserve)

• p {String} 要刪除的目錄
• reserve {Boolean} 是否保留該目錄。如果為 true，則只刪除子目錄
• return {Promise}

遞歸的刪除目錄，如果目錄不存在則直接返回。返回是個 Promise，后續(xù)操作要在 then 里執(zhí)行

function rmTmp(){
  think.rmdir("/foo/bar").then(function(){
    //后續(xù)其他操作
  })
}

如果使用 Generator Function，則可以使用 yield

function * rmTmp(){
  yield think.rmdir("/foo/bar");
  //后續(xù)其他操作
}

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對象

創(chuàng)建一個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} 要轉化的函數(shù)
• receiver {Object} this指向

將異步方法快速包裝成Promise，異步方法必須符合最后一個參數(shù)為回調函數(shù)，且回調函數(shù)的第一個參數(shù)為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

think.lookClass(name, type, module, base)

• name {String} 類名
• type {String} 類型 (controller | model | logic ...)
• module {String} 模塊名
• base {String} 找不到時找對應的基類

根據(jù)類型，名稱來查找類。如果找不到會到 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} 前綴

根據(jù)當前項目類型獲取對應類型的目錄。

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 可以阻止后續(xù)的行為且不會報錯。

think.log(msg, type, showTime)

• msg {String | Error} 信息
• type {String} 類型
• showTime {Number | Boolean} 是否顯示時間

打印日志，該方法打印出來的日志會有時間，類型等信息，方便查看和后續(xù)處理。

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"

顯示執(zhí)行時間

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 。

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()

注冊、獲取和執(zhí)行 hook。

系統(tǒng)默認的 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: []
};

項目中可以根據(jù)需要追加或者修改。

獲取事件對應的 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);

執(zhí)行 hook

let result = think.hook("view_template", http, data);
//result is a promise

think.middleware()

注冊、創(chuàng)建、獲取和執(zhí)行 middleware。

創(chuàng)建 middleware

//解析 XML 示例
var ParseXML = think.middlearea({
  run: function(){
    var http = this.http;
    var payload = http.payload; //payload為上傳的post數(shù)據(jù)
    var data = xmlParse.parse(payload); //使用一個xml解析，這里 xmlParse 是示例
    http._post = data; //將解析后的數(shù)據(jù)賦值給 http._post，后續(xù)可以通過 http.post("xxx") 獲取
  }
});

使用 ES6 創(chuàng)建 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 執(zhí)行
let Cls = think.middlearea({
  run: function(){
    let http = this.http;

  }
});
think.middleware("parse_xml", Cls);

獲取 middleware

let middlearea = think.middleare("parse_xml");

執(zhí)行 middleware

let result = think.middleare("parse_xml", http);
//result is a promise

think.adapter()

創(chuàng)建、注冊、獲取和執(zhí)行 adapter。

創(chuàng)建 adapter

//創(chuàng)建一個 adapter
var Cls = think.adapter({

});

//創(chuàng)建一個 session adapter，繼承自 session base 類
var Cls = think.adapter("session", "base", {

})

//使用 ES6 創(chuàng)建一個 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");

執(zhí)行 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}

根據(jù) req 和 res 包裝成 http 對象。req 和 res 可以自定義。

//根據(jù)一個 url 生成一個 http 對象，方便命令行下調用
think.http("/index/test").then(http => {

});

think.uuid(length)

• length {Number} 生成字符串的長度，默認為 32

生成一個隨機字符串。

think.session(http)

• http {Object} http對象

生成 session，并寫到 http 對象上。如果已經存在，則直接返回。

think.controller()

創(chuàng)建、執(zhí)行 controller

創(chuàng)建 controller

//創(chuàng)建 controller, 繼承 think.controller.base
let Cls = think.controller({

})
//創(chuàng)建 controller, 繼承 think.controller.rest
let Cls = think.controller("rest", {

})

//使用 ES6 創(chuàng)建 controller
let Cls1 = class extends think.controller.base {

}

實例化 controller

//實例化 home 模塊下 user controller
let instance = think.controller("user", http, "home");

think.logic()

創(chuàng)建、執(zhí)行 logic

創(chuàng)建 logic

//創(chuàng)建 logic, 繼承 think.logic.base
let Cls = think.logic({

})

//使用 ES6 創(chuàng)建 logic
let Cls1 = class extends think.logic.base {

}

實例化 logic

//實例化 home 模塊下 user logic
let instance = think.logic("user", http, "home");

think.model()

創(chuàng)建或者獲取 model。

創(chuàng)建 model

//創(chuàng)建一個 model
let model = think.model({
  getList: function(){

  }
});

//ES6 里直接繼承 think.model.base 類
let model = class extends think.model.base {
  getList(){

  }
}

//創(chuàng)建一個 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()

創(chuàng)建或者獲取 service。

創(chuàng)建 service

//創(chuàng)建一個 service 類
let service = think.service({

})

//ES6 里直接繼承 think.service.base 類
let service = class extends think.service.base {

}

service 基類繼承自 think.base，所以可以用 think.base 里的方法。

如果 serivce 不想寫成類，那就沒必要通過這種方法創(chuàng)建。

獲取 service

//獲取 home 模塊下 post service，并傳遞參數(shù) {} 
//如果獲取到的 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 時表示獲取緩存，如果獲取不到，則調用該函數(shù)，然后將返回值設置到緩存中并返回。

//獲取緩存
think.cache("name").then(data => {});

//指定緩存類型獲取，從 redis 里獲取緩存
think.cache("name", undefined, {type: "redis"});

//如果緩存 userList 不存在，則查詢數(shù)據(jù)庫，并將值設置到緩存中
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} 參數(shù)

根據(jù)語言獲取對應的值，當前語言存放在think.lang，可以在系統(tǒng)啟動時指定。

think.locale("CONTROLLER_NOT_FOUND", "test", "/index/test");
//returns 
"controller `test` not found. url is `/index/test`."

think.validate()

注冊、獲取或執(zhí)行檢測。

注冊檢測方法

//注冊檢測類型為 not_number
think.validate("not_number", value => {
  return !(/^\d+$/.test(value));
})

獲取檢測方法

let fn = think.validate("not_number");

檢測數(shù)據(jù)

let result = think.validate({
  name: {
    value: "name",
    required: true,
    not_number: true
  },
  pwd: {
    value: "xxx",
    required: true,
    minLength: 6
  }
});
//如果 result 是 isEmpty，表示數(shù)據(jù)都正常
if(think.isEmpty(result)){

}

think.await(key, callback)

• key {String}
• callback {Function}

執(zhí)行等待，避免一個耗時的操作多次被執(zhí)行。 callback 需要返回一個 promise 。

如：用戶訪問時，要請求一個遠程的接口數(shù)據(jù)。如果不處理，每個用戶請求都會觸發(fā)這個遠程接口的訪問，導致有很大的資源浪費?？梢宰屵@些用戶公用一個遠程接口的請求。

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} 模塊名

加載模塊。如果模塊不存在，則自動安裝。這樣可以做到動態(tài)安裝模塊。

//如果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} 追加的錯誤信息

格式化錯誤信息，將部分系統(tǒng)的錯誤信息描述完整化。

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} 狀態(tài)碼
• http {Object} 包裝的http對象
• log {Boolean} 是否打印錯誤信息

當系統(tǒng)出現(xiàn)異常時（系統(tǒng)錯誤，頁面找不到，沒權限等），顯示對應的錯誤頁面。

創(chuàng)建項目時，會在 common 模塊下生成文件 src/common/controller/error.js，專門用來處理錯誤情況。

默認支持的錯誤類型有：400, 403, 404, 500, 503。

項目里可以根據(jù)需要修改錯誤頁面或者擴展。

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 詳細介紹請見 這里

think.http.base

think.http.base 詳細介紹請見 這里

文檔地址：https://github.com/75team/www.thinkjs.org/tree/master/view/zh-CN/doc/2.0/api_think.md