Third.js

字符串类型，表示当前安卓的版本号

var android = require('third/browser/android');
console.log('安卓版本：' + (android || '非安卓浏览器'));

字符串类型，表示当前IE浏览器的版本号

var android = require('third/browser/ie');
console.log('IE浏览器的版本号：' + (ie || '非IE浏览器'));

布尔值类型，表示是否是chrome浏览器

var isChrome = require('third/browser/isChrome');
console.log('是否是chrome浏览器：' + (isChrome || '非chrome浏览器'));

此函数用于设置指定名字的cookie值。

NOTE: 此函数需要与cookie/get配套使用。因为为了区分设置在不同域名、不同路径下的同名cookie，set函数在设置cookie时加入了一些额外标志位。如果直接通过document.cookie获取的值就会包含这些额外标志位。

var set = require('third/cookie/set');
set('key', 'value');

此函数用于获取指定名字的cookie值。

NOTE: 此函数需要与cookie/set配套使用。因为为了区分设置在不同域名、不同路径下的同名cookie，set函数在设置cookie时加入了一些额外标志位，get函数则会自动删掉这些标志位。如果用get函数去获取普通的cookie（非set函数设置）则容易出现bug。

var set = require('third/cookie/set');
var get = require('third/cookie/get');
set('key', 'value');
console.log(get('key') === 'value');        // true

此函数用于删除指定名字的。

var set = require('third/cookie/set');
var get = require('third/cookie/get');
var remove = require('third/cookie/remove');
set('key', 'value');
remove('key');
console.log(get('key') === 'value');        // false

此函数用于设置指定名字的cookie值，这里设置的是原始值。

NOTE: 此函数与cookie/set不同点在于，setRaw设置的是原始值，不会修改或添加任何标志位。

var setRaw = require('third/cookie/setRaw');
setRaw('key', 'value');

此函数用于获取指定名字的cookie原始值。

NOTE: 此函数与cookie/get不同点在于：getRaw获取的是原始值，不会判断cookie值来自哪个域名或路径。所以getRaw得到的返回值是数组类型的。

// 当前页面的路径是 /doc/
var setRaw = require('third/cookie/setRaw');
var getRaw = require('third/cookie/getRaw');
setRaw('key', 'value', {
    path: '/doc/test2'
});
setRaw('key', 'value2', {
    path: '/doc/test1'
});
console.log(getRaw('key')[0] === 'value');        // true
console.log(getRaw('key')[1] === 'value2');       // true

此函数用于设置指定名字的cookie值，并且自动设置到当前页面的根域名+根路径（/）下。

var setRootRaw = require('third/cookie/setRootRaw');
setRootRaw('key', 'value');

此函数用于判断当前浏览器是否使用adBlock插件来屏蔽广告。

var adBlock = require('third/detect/adBlock');
console.log(adBlock());

此函数用于判断浏览器是否支持cookie。

var cookie = require('third/detect/cookie');
console.log(cookie());

此函数用于判断浏览器是否支持跨域的请求。如果支持就会返回'xhr'或'xdr'，否则返回空字符串。

1. xhr表示浏览器支持XMLHttpRequest对象的跨域
2. xdr只会出现在IE9和IE8中，它们可以通过XDomainRequest对象来实现跨域请求

var cors = require('third/detect/cors');
console.log(cors());

此函数用于检测当前浏览器的flash插件的版本号。

var flash = require('third/detect/flash');
console.log(flash());       // '25.0.0'

此函数用于判断当前JS的运行环境是否是在frame或iframe标签中。

var inFrame = require('third/detect/inFrame');
console.log(inFrame());       // '25.0.0'

此函数用于判断当前JS的运行环境是否是在预渲染过程中。

var isPrerender = require('third/detect/isPrerender');
console.log(isPrerender());                             // true
console.log(isPrerender(iframe.contentWindow));         // false

此函数用于判断当前JS的运行环境是否是在预览界面的渲染流程中。Safari浏览器有个Top site功能，它会展示最长访问的几个页面的截图。示例如下：

Safari会去真正的加载解析这几个站点页面，然后截图并保存。而当用户点开这些站点时则会再次重新加载解析这些页面。isPreviewLoad函数则是用来判断当前的JS运行环境是否是在这个预览界面的截图流程中。

var isPreviewLoad = require('third/detect/isPreviewLoad');
console.log(isPrerender());                             // true
console.log(isPrerender(iframe.contentWindow));         // false

此函数用于判断当前浏览器是否支持localStorage

var localStorage = require('third/detect/localStorage');
console.log(localStorage());                             // true

此函数用于判断当前浏览器是否支持sessionStorage

var sessionStorage = require('third/detect/sessionStorage');
console.log(sessionStorage());                             // true

此函数用于判断当前浏览器是否支持postMessage

var postMessage = require('third/detect/postMessage');
console.log(postMessage());                             // true

此函数用于判断当前浏览器是否支持sendBeacon

var sendBeacon = require('third/detect/sendBeacon');
console.log(sendBeacon());                             // true

此函数用于判断当前浏览器是否支持touch事件

var touchEvents = require('third/detect/touchEvents');
console.log(touchEvents());                             // true

此函数用于把指定的DOM节点插入到DOM树中，但你不能指定它插入的位置。

NOTE: 此函数适用于将指定节点插入到DOM树中，但是不关心其位置的情况。它可以最大程度的确保DOM节点被安全的插入到DOM树中。这在第三方脚本的场景特别适用，因为开发者其实不确定DOM树的结构，甚至不能确定页面中是否有header和body标签。

更多信息可以参考这篇文章。

var attachIntoDOM = require('third/dom/attachIntoDOM');
console.log(attachIntoDOM(document.createElement('div')));

此函数用于获取页面的高度。

var getPageHeight = require('third/dom/getPageHeight');
console.log(getPageHeight());

此函数用于获取页面的宽度。

var getPageWidth = require('third/dom/getPageWidth');
console.log(getPageWidth());

此函数用于获取页面可视区域左上角点的left值（相对于页面左上角点）。

var getScrollLeft = require('third/dom/getScrollLeft');
console.log(getScrollLeft());

此函数用于获取页面可视区域左上角点的top值（相对于页面左上角点）。

var getScrollTop = require('third/dom/getScrollTop');
console.log(getScrollTop());

此函数用于获取页面可视区域的高度。

var getViewHeight = require('third/dom/getViewHeight');
console.log(getViewHeight());

此函数用于获取页面可视区域的宽度。

var getViewWidth = require('third/dom/getViewWidth');
console.log(getViewWidth());

此函数用于获取指定节点内的文字，相当于node.textContent但做了兼容处理。

var getText = require('third/dom/getText');
console.log(getText(document.getElementById('text')));

此函数用于绑定document ready事件。

var domReady = require('third/event/domReady');
function readyCallback() {
    // TODO
}
domReady(readyCallback, window);
domReady(readyCallback, document.getElementById('iframe').contentWindow);

此函数用于绑定DOM事件。

var on = require('third/event/on');
on(document.body, 'click', function (e) {});
on(window, 'load', function (e) {});

此函数用于取消DOM事件的绑定。

var off = require('third/event/off');
function callback(e) {
    // TODO
}
off(document.body, 'click', callback);
off(window, 'load');

此函数用于阻止浏览器事件的默认行为，它兼容旧版本的IE（>=6）。

var on = require('third/event/on');
var preventDefault = require('third/event/preventDefault');
function callback(e) {
    preventDefault(e);
}
on(document.body, 'click', callback);

此函数用于阻止浏览器事件的继续传播，它兼容旧版本的IE（>=6）。

var on = require('third/event/on');
var stopPropagation = require('third/event/stopPropagation');
function callback(e) {
    stopPropagation(e);
}
on(document.body, 'click', callback);

此函数用于获取事件对象的目标节点，即target值（此方法对旧版本的IE做了fallback处理）。

var on = require('third/event/on');
var getTarget = require('third/event/getTarget');
function callback(e) {
    console.log(getTarget(e));          // body
}
on(document.body, 'click', callback);

此函数用于获取键盘事件的按键值。

var on = require('third/event/on');
var getKeyCode = require('third/event/getKeyCode');
function callback(e) {
    console.log(getKeyCode(e));          // 20
}
on(document.body, 'keyup', callback);

此函数用于获取鼠标事件的点击位置距离页面左上角的水平距离。如果只想获取距离可视区域左上角的距离，则直接用event.clientX。

var on = require('third/event/on');
var getPageX = require('third/event/getPageX');
function callback(e) {
    console.log(getPageX(e));          // 20
    console.log(e.clientX);            // 20
}
on(document.body, 'click', callback);

此函数用于获取鼠标事件的点击位置距离页面左上角的垂直距离。如果只想获取距离可视区域左上角的距离，则直接用event.clientX。

var on = require('third/event/on');
var getPageY = require('third/event/getPageY');
function callback(e) {
    console.log(getPageY(e));          // 200
    console.log(e.clientY);            // 20
}
on(document.body, 'click', callback);

创建一个隐藏的iframe标签，它对普通用户来说是不可见的，并且宽高为0。

NOTE: 新创建的iframe节点并没有被插入到页面中去，而且在IE下直接获取其contentWindow可能会出错。此方法一般需要和dom/attachIntoDOM和iframe/ready或者iframe/write函数一起使用。

var createAnonymous = require('third/iframe/createAnonymous');
var write = require('third/iframe/write');
var attachIntoDOM = require('third/dom/attachIntoDOM');
var iframe = createAnonymous();
attachIntoDOM(iframe);
write(iframe, '<div>IMPORTANT MESSAGE!</div>', function () {});

此函数用于获取iframe（非跨域，必须已经在dom树中）节点内部的window和document对象。

NOTE: 在IE浏览器下，如果当前页面修改过document.domain，那么即使是同域名的iframe节点，直接通过contentWindow获取其window对象，也会报跨域的错误。为了解决这个问题，需要同时再设置iframe节点内的document.domain为相同值。故这个方法并不是同步的，而是异步的。

var createAnonymous = require('third/iframe/createAnonymous');
var ready = require('third/iframe/ready');
var attachIntoDOM = require('third/dom/attachIntoDOM');
var iframe = createAnonymous();
attachIntoDOM(iframe);
ready(iframe, function (win, doc) {
    // TODO
});

此函数用于修改iframe（非跨域，必须已经在dom树中）节点内部的HTML。

var createAnonymous = require('third/iframe/createAnonymous');
var write = require('third/iframe/write');
var attachIntoDOM = require('third/dom/attachIntoDOM');
var iframe = createAnonymous();
attachIntoDOM(iframe);
write(iframe, '<div>IMPORTANT MESSAGE!</div>', function (win, doc) {
    // TODO
});

此函数用于根据指定的HTML字符串创建一个隐藏的iframe（非跨域）节点，iframe节点会被自动插入到DOM树中（位置不确定）。

var createByHTML = require('third/iframe/createByHTML');
var iframe = createByHTML('<div>IMPORTANT MESSAGE!</div>', function (win, doc) {
    // TODO
});

此函数用于根据指定的页面地址创建一个隐藏的iframe（可能会跨域）节点，iframe节点会被自动插入到DOM树中（位置不确定）。

var createBySrc = require('third/iframe/createBySrc');
var iframe = createBySrc('http://example.com/iframe.html');

此函数用于把字符串解析成JSON对象。如果浏览器支持原生的window.JSON，则会优先使用原生的方法。

var parse = require('third/json/parse');
console.log(parse('{"a": 1}').a);       // 1

此函数用于修改字符串，使其除了第一个字母以外其他全部小写，第一个字母大写。

var capitalize = require('third/lang/capitalize');
console.log(capitalize('aPPle'));       // 'Apple'

此函数用于将输入字符串中的部分字符进行转义。一般用于对不可信的字符串做转移，然后在输出到DOM中，避免XSS问题。被转义的字符如下：

& => '&
< => '&lt;
> => '&gt;
" => '&quot;
' => '&#39;

使用例子如下：

var escapeHTML = require('third/lang/escapeHTML');
document.body.innerHTML = escapeHTML('user<span>name</span>');

此函数用于将输入字符串中的部分字符进行转义。一般用于对不确定的字符串做转移，然后作为正则表达式的一部分使用。

var escapeReg = require('third/lang/escapeReg');
new RegExp('^\\s*' + escapeReg('[a]') + '=\\s*(.*?)\\s*$', 'g')

此函数用于判断输入的参数是否是字符串

var type = require('third/lang/type');
console.log(type(true));                    // boolean
console.log(type(1));                       // number
console.log(type('string'));                // string
console.log(type(function () {}));          // function
console.log(type([]));                      // array
console.log(type(new Date()));              // date
console.log(type(/a/));                     // regexp
console.log(type({}));                      // object
console.log(type(new Error()));             // error

此函数用于判断输入的参数是否是字符串

var isArray = require('third/lang/isArray');
console.log(isArray([1, 2, 3]));            // true
console.log(isArray(new Array()));          // true
console.log(isArray('1, 2, 3'));            // false

此函数用于判断输入的参数是否是Object类型的对象。

var isObject = require('third/lang/isObject');
console.log(isObject({}));                      // true
console.log(isObject(new Object()));            // true
console.log(isObject(new Array()));             // false
console.log(isObject(window));                  // false

此函数用于判断输入的参数是否是window对象。

NOTE: 注意此函数只能用于判断已经挂载到页面上的window对象。如果是新创建的iframe标签，但尚未append到页面中，则此iframe标签内的window对象是不能通过此判断的。

var isWindow = require('third/lang/isWindow');
console.log(isWindow(window));                  // true
console.log(isWindow({}));                      // false

此函数用于判断输入的函数是否是浏览器原生的函数，而非由用户赋值的

NOTE: 此函数只能用于判断函数，不能用于判断是否是浏览器原生的对象，即host object。例如：window.JSON对象。

在IE<9之前的浏览器中，很多作为函数其实都是host object。对这些函数调用isNative方法就会出现浏览器的兼容性问题。例如：window.setTimeout。

var isNative = require('third/lang/isNative');
console.log(isNative(window.encodeURIComponent));       // true
window.encodeURIComponent = function () {};
console.log(isNative(window.encodeURIComponent));       // false
console.log(isNative(JSON));                            // false
console.log(isNative(JSON.stringify));                  // true

此函数用于生成一个随机数。

var random = require('third/lang/random');
console.log(random());

此函数用于生成一个随机的字符串。这个id是random函数随机生成的数字转换成36进制后的字符串。

var randomId = require('third/lang/randomId');
console.log(randomId());

此函数用于生成一个随机的ID。ID由四组随机字符串通过连接符串起来的

var uuid = require('third/lang/uuid');
console.log(uuid());
console.log(uuid('_'));

此函数用于将近似数组的对象转换成真正的数组，一般用于处理函数参数、NodeList等等。

var toArray = require('third/lang/toArray');
console.log(toArray(document.getElementsByTagName('p')));
console.log(toArray(arguments));

此函数是Third.js的入口级函数。它处理了如下三种因素：

1. 页面处于previewLoad的情况下不会执行回调函数
2. 页面处于prerender的情况下是暂时不会执行回调函数，等页面可见时再执行
3. 获取window对象的策略自动兼容了JS文件被util/fif函数加载时候的情况，使其可以拿到正确的window对象

var run = require('third/run');
run(function (win) {
    // TODO
});

此函数用于监听消息。

var listen = require('third/message/listen');
listen('parent', window, function (data) {
    console.log(typeof data.origin);        // string
    console.log(data.origin);               // source of message's origin
    console.log(typeof data.message);       // string
    console.log(data.message);              // message body
});

此函数用于取消消息监听。

var unlisten = require('third/message/unlisten');
unlisten('parent', window);

此函数用于发送消息。

var send = require('third/message/send');
send('parent', window.parent, 'message');

向指定服务器地址发送ping请求，传输数据。如果你需要发送的数据量较轻，并且不在乎发送的返回结果，那么使用这个方法发送数据。ping请求会采用三种数据传输方法之一来发送数据：

1. 图片方式的请求（创建一个Image实例，指定接口地址为Image实例的src值）
2. 调用navigator.sendBeacon方法发送跨域请求
3. 调用XMLHttpRequest对象发送跨域请求

var ping = require('third/request/ping');
ping('/api/ping', {
    id: '0067ED',
    data: [2, 3, 4]
});

unloadPing与ping方法的不同之处在于：unloadPing是处理在页面关闭时候发送请求的方法，它是ping方法的特殊变种。普通的ping请求在页面关闭时很容易发送失败，而它使用了特别的手段，确保请求可以更高概率的发送成功。

var unloadPing = require('third/request/unloadPing');
unloadPing('/api/ping', {
    id: '0067ED',
    data: [2, 3, 4]
});

向指定服务器地址发起JSONP请求。

var jsonp = require('third/request/jsonp');
jsonp('/api/ping', function (error, data) {
    if (error) {
        // something going wrong.
        return;
    }

    console.log(data);
});

向指定服务器地址发起跨域请求。如果你需要发送大量的数据，甚至发送图片，并且非常关心返回的数据，那么需要使用这个函数。submit请求一般会采用两种数据传输方法之一：

1. 调用XMLHttpRequest对象发送跨域请求
2. 使用iframe加form表单来发起跨域请求

var submit = require('third/request/submit');
var data = {
    id: '0067ED',
    data: [1, 2, 3]
};
submit('/api/submit', data, function (error, data) {
    if (error) {
        // something going wrong.
        return;
    }

    console.log(data);
});

文件上传及表单提交

当需要上传文件时，传递给submit函数的参数需要变成form表单的node节点。

<form id="submitForm" method="post" enctype="multipart/form-data">
    <input type="text" name="username" value="zmmbreeze"></input>
    <input type="password" name="password" value="1234567"></input>
    <input type="file" name="head"></input>
</form>
<script>
var submit = require('third/request/submit');
var submitForm = document.getElementById('submitForm');
var data = {
    id: '0067ED',
    data: [1, 2, 3]
};
submit(submitForm, function (error, data) {
    if (error) {
        // something going wrong.
        return;
    }

    console.log(data);
});
</script>

此函数用于创建沙盒，沙盒的本质是一个空的、隐藏的、非跨域iframe节点。

var create = require('third/sandbox/create');
window.encodeURIComponent = 'test';
create(function (win) {
    console.log(win.encodeURIComponent !== 'test'); // true
});

此函数用于创建一个全局的沙盒，并且可以通过它获取此沙盒。尚未创建全局沙盒之前，函数默认返回的是JS当前执行环境的window对象。当函数传入一个回调函数时，会开始创建次全局沙盒实例。由于创建沙盒是异步的，故必须通过回调函数异步的获取沙盒实例。沙盒创建完成之后执行global()便可以同步的获取沙盒实例。

NOTE: Third工具库内基本所有涉及到native API调用的函数，都会使用global()函数来获取或调用native的API函数。这是为了避免浏览器的提供的native API被网页开发者重写。

var global = require('third/sandbox/global');
window.encodeURIComponent = 'test';
// 未创建时
console.log(global() === window);   // true
// 开始创建
global(function (win) {
    // 创建完成
    console.log(global() === win);                  // true
    console.log(win.encodeURIComponent !== 'test'); // true
});

此函数用于创建沙盒，并在沙盒内部执行指定的JS。

var eval = require('third/sandbox/eval');
eval('window.test = 1;', function (win) {
    console.log(win.test);      // 1
});

此函数用于创建沙盒，并在沙盒内部加载并执行指定的远程JS文件（单个或多个）。

var load = require('third/sandbox/load');
load('http://example.com/script.js', function (win, doc) {
    console.log(win.test);      // 1
});
load(
    [
        'http://example.com/script2.js',
        'http://example.com/script1.js'
    ],
    function (win, doc) {
        console.log(win.test);      // 1
    },
    'GBK'
);

此函数用于解析URL地址。

var parse = require('third/url/parse');
var url = parse('http://example.com:8000/books/12?type=music#hash');
console.log(url.protocol);      // 'http:'
console.log(url.origin);        // 'http://example.com:8000'
console.log(url.host);          // 'example.com:8000'
console.log(url.hostname);      // 'example.com'
console.log(url.port);          // '8000'
console.log(url.pathname);      // '/books/12'
console.log(url.search);        // '?type=music'
console.log(url.href);          // 'http://example.com:8000/books/12?type=music#hash'
console.log(url.hash);          // '#hash'

var url2 = parse('http://example.com/');
console.log(url2.origin);       // 'http://example.com'
console.log(url2.host);         // example.com
console.log(url2.hostname);     // example.com

此函数用于获取指定URL上指定参数名的搜索参数值。

var getQuery = require('third/url/getQuery');
var types = getQuery('?type=1&type=2#type=3', 'type');
console.log(types);             // ['1', '2']

var team = getQuery('?team=%230067ED#type=3', 'team');
console.log(team);              // '#0067ED'

var noname = getQuery('?team=%230067ED#type=3', 'noname');
console.log(noname);            // ''

此函数用于获取指定URL上的所有搜索参数值。

var getQuerys = require('third/url/getQuerys');
var querys = getQuerys('?team=%230067ED&type=1&type=2#type=3');
console.log(querys.team);             // '#0067ED'
console.log(querys.type);             // ['1', '2']

此函数用于获取指定URL上的所有搜索参数值。

var getFirstQuery = require('third/url/getFirstQuery');
var firstType = getFirstQuery('?team=%230067ED&type=1&type=2#type=3', 'type');
console.log(firstType);             // '1'

此函数用于判断指定URL上是否包含了指定参数名的参数。

var hasQuery = require('third/url/hasQuery');
console.log(hasQuery('?team=%230067ED&type=1&type=2', 'type'));      // true
console.log(hasQuery('?team=&type=1&type=2#type=3', 'team'));        // true
console.log(hasQuery('?type=1&type=2#type=3', 'team'));              // false

此函数用于更新指定URL上的指定参数名的参数值。

var setQuery = require('third/url/setQuery');
var updatedUrl = setQuery('?team=%230067ED&type=1&type=2', 'type', 3);
console.log(updatedUrl);        // '?team=%230067ED&type=3'
updatedUrl = setQuery('?team=%230067ED&type=1&type=2', 'type', [3, 4]);
console.log(updatedUrl);        // '?team=%230067ED&type=3&type=4'
updatedUrl = setQuery('?team=%230067ED&type=1&type=2', 'type', '');
console.log(updatedUrl);        // '?team=%230067ED&type='

此函数用于删除指定URL上的指定参数名的参数。

var deleteQuery = require('third/url/deleteQuery');
var updatedUrl = deleteQuery('?team=%230067ED&type=1&type=2', 'type');
console.log(updatedUrl);        // '?team=%230067ED&type=3'
updatedUrl = deleteQuery('?type=1&type=2', 'type');
console.log(updatedUrl);        // ''

此函数用于将Object或Array形式参数对象序列化成字符串形式的参数，一般在数据传输时调用。

NOTE：如果toQuery方法的输入参数是Array形式，则其值必须是{key:'参数名', value:'参数值'}形式的对象。使用Array的优势在于可以控制序列化后的参数顺序

NOTE：如果某个参数的值是数组，则会在生成的字符串形式中给参数名加上[]后缀。此行为与jQuery.param方法的行为保持一致.

var toQuery = require('third/url/toQuery');
console.log(toQuery({
    team: '#0067ED',
    members: ['michael', 'john', 'jerry']
}));
// team=%230067ED&members%5B%5D=michael&members%5B%5D=john&members%5B%5D=jerry
console.log(toQuery([
    {
        key: 'members',
        value: ['michael', 'john', 'jerry']
    },
    {
        key: 'team',
        value: '#0067ED'
    }
]));
// members%5B%5D=michael&members%5B%5D=john&members%5B%5D=jerry&team=%230067ED

此函数实现了Friendly iframe（简称fif）方式的加载JS文件的方法。Friendly iframe是IAB（The Interactive Advertising Bureau）推荐的加载广告的方法。它一般有如下的特点：

1. 创建一个iframe，它的和父页面是同域的，不会收到同源策略影响
2. iframe内部有一个或多个script节点，它们会加载远程的JS文件
3. iframe内部的JS环境中有一个全局变量inDapIF，它的值为true
4. 被加载的远程JS文件需要从全局变量inDapIF此来判断当前加载它的方法是否是Friendly iframe（它们可能还需要兼容普通加载的方式）

NOTE: 使用Friendly iframe方式加载JS文件有一个巨大的优势，就是不会block页面的load事件。

var fif = require('third/util/fif');
fif('script.js', function (context, doc) {
    // TODO script loaded
});
fif(['script1.js', 'script2.js'], function (context, doc) {
    // TODO script loaded
});

此函数实现了The Method Queue Pattern。

NOTE: 使用此范式的一个优点是即使SDK尚未被加载，也可以先调用SDK之后会提供的接口。作为命令的形式存到队列里面，等SDK真正加载完成之后再去执行。

假设我们按照如下形式提供SDK的接口：

var mqp = require('third/util/mqp');
(function () {
    var ExportApi = {
        ready(callback) {
            // TODO 在loaded之后执行 callback
        },
        send(message) {
            console.log(message);
        }
    };
    mqp('__mq', ExportApi);
})();

在外部调用时就可以采用如下的代码形式，可以看到push进数组的命令自身也是数组类型。它的第一项对应了ExportApi（即代理API）的函数名。

<script>
    __mq = __mq || [];
    __mq.push(['send', 'message']);
    __mq.push(function () {
        // TODO loaded
    });
</script>
<script src="exportApi.js" async></script>

如果通过函数名来调用代理API的方式不能满足你的需求，则可以自定义options.callback这个回调函数。样例如下：

var mqp = require('third/util/mqp');
(function () {
    var ExportApi = {
        ready(callback) {},
        send(data) {
            console.log(message);
        },
        event(data) {
            console.log(message);
        }
    };
    // 白名单
    var WHITE_LIST = 'send,event'.split(',');
    mqp('__mq', ExportApi, {
        callback: function (proxy, method, params) {
            if (!~WHITE_LIST.indexOf(method)) {
                return;
            }
            proxy[method].apply(proxy, params);
        }
    });
})();

可以看到我们通过自定义options.callback函数，实现了一个白名单列表，只有白名单内的方法名才能被执行。

<script>
    __mq = __mq || [];
    __mq.push(['send', 1, 2]);
    __mq.push(['event', 1, 2]);     // 此行不会起作用，`ExportApi.event`方法不会被调用
</script>
<script src="exportApi.js" async></script>

此函数实现了简易的类继承功能。

var inherits = require('third/util/inherits');
function Father(firstName) {
    this.firstName = firstName;
    this.lastName = 'zhou';
}
Father.prototype.myName = function () {
    return this.firstName + this.lastName;
};

function Son(firstName) {
    Son.superClass.constructor.call(this, firstName);
}

inherits(Son, Father);
console.log(new Son('mm').myName());   // mmzhou

此函数对console.log做了简单的封装，确保在浏览器不支持console.logAPI的时候不会报错。同时也支持console.group和console.groupEnd方法。

NOTE: 此函数不应该在实际的生产环境中使用，建议仅用于一些特殊情况下的debug。

var log = require('third/util/log');
log.group('THIRD');
log('message');
log.groupEnd();