摘要：創(chuàng)建一個(gè)全局對(duì)象在瀏覽器中表示為對(duì)象在中表示對(duì)象保存下劃線變量被覆蓋之前的值如果出現(xiàn)命名沖突或考慮到規(guī)范可通過方法恢復(fù)被占用之前的值并返回對(duì)象以便重新命名創(chuàng)建一個(gè)空的對(duì)象常量便于內(nèi)部共享使用將內(nèi)置對(duì)象的原型鏈緩存在局部變量方便快速調(diào)用將

// Underscore.js 1.3.3

// (c) 2009-2012 Jeremy Ashkenas, DocumentCloud Inc.

// Underscore is freely distributable under the MIT license.

// Portions of Underscore are inspired or borrowed from Prototype,

// Oliver Steele"s Functional, and John Resig"s Micro-Templating.

// For all details and documentation:

// http://documentcloud.github.com/underscore

(function() {

// 創(chuàng)建一個(gè)全局對(duì)象, 在瀏覽器中表示為window對(duì)象, 在Node.js中表示global對(duì)象

var root = this;

// 保存"_"(下劃線變量)被覆蓋之前的值

// 如果出現(xiàn)命名沖突或考慮到規(guī)范, 可通過_.noConflict()方法恢復(fù)"_"被Underscore占用之前的值, 并返回Underscore對(duì)象以便重新命名

var previousUnderscore = root._;

// 創(chuàng)建一個(gè)空的對(duì)象常量, 便于內(nèi)部共享使用

var breaker = {};

// 將內(nèi)置對(duì)象的原型鏈緩存在局部變量, 方便快速調(diào)用

var ArrayProto = Array.prototype, //

ObjProto = Object.prototype, //

FuncProto = Function.prototype;

// 將內(nèi)置對(duì)象原型中的常用方法緩存在局部變量, 方便快速調(diào)用

var slice = ArrayProto.slice, //

unshift = ArrayProto.unshift, //

toString = ObjProto.toString, //

hasOwnProperty = ObjProto.hasOwnProperty;

// 這里定義了一些JavaScript 1.6提供的新方法

// 如果宿主環(huán)境中支持這些方法則優(yōu)先調(diào)用, 如果宿主環(huán)境中沒有提供, 則會(huì)由Underscore實(shí)現(xiàn)

var nativeForEach = ArrayProto.forEach, //

nativeMap = ArrayProto.map, //

nativeReduce = ArrayProto.reduce, //

nativeReduceRight = ArrayProto.reduceRight, //

nativeFilter = ArrayProto.filter, //

nativeEvery = ArrayProto.every, //

nativeSome = ArrayProto.some, //

nativeIndexOf = ArrayProto.indexOf, //

nativeLastIndexOf = ArrayProto.lastIndexOf, //

nativeIsArray = Array.isArray, //

nativeKeys = Object.keys, //

nativeBind = FuncProto.bind;

// 創(chuàng)建對(duì)象式的調(diào)用方式, 將返回一個(gè)Underscore包裝器, 包裝器對(duì)象的原型中包含Underscore所有方法(類似與將DOM對(duì)象包裝為一個(gè)jQuery對(duì)象)

var _ = function(obj) {

    // 所有Underscore對(duì)象在內(nèi)部均通過wrapper對(duì)象進(jìn)行構(gòu)造

    return new wrapper(obj);

};

// 針對(duì)不同的宿主環(huán)境, 將Undersocre的命名變量存放到不同的對(duì)象中

if( typeof exports !== "undefined") {// Node.js環(huán)境

    if( typeof module !== "undefined" && module.exports) {

        exports = module.exports = _;

    }

    exports._ = _;

} else {// 瀏覽器環(huán)境中Underscore的命名變量被掛在window對(duì)象中

    root["_"] = _;

}

// 版本聲明

_.VERSION = "1.3.3";

// 集合相關(guān)的方法(數(shù)據(jù)和對(duì)象的通用處理方法)

// --------------------

// 迭代處理器, 對(duì)集合中每一個(gè)元素執(zhí)行處理器方法

var each = _.each = _.forEach = function(obj, iterator, context) {

    // 不處理空值

    if(obj == null)

        return;

    if(nativeForEach && obj.forEach === nativeForEach) {

        // 如果宿主環(huán)境支持, 則優(yōu)先調(diào)用JavaScript 1.6提供的forEach方法

        obj.forEach(iterator, context);

    } else if(obj.length === +obj.length) {

        // 對(duì)<數(shù)組>中每一個(gè)元素執(zhí)行處理器方法

        for(var i = 0, l = obj.length; i < l; i++) {

            if( i in obj && iterator.call(context, obj[i], i, obj) === breaker)

                return;

        }

    } else {

        // 對(duì)<對(duì)象>中每一個(gè)元素執(zhí)行處理器方法

        for(var key in obj) {

            if(_.has(obj, key)) {

                if(iterator.call(context, obj[key], key, obj) === breaker)

                    return;

            }

        }

    }

};

// 迭代處理器, 與each方法的差異在于map會(huì)存儲(chǔ)每次迭代的返回值, 并作為一個(gè)新的數(shù)組返回

_.map = _.collect = function(obj, iterator, context) {

    // 用于存放返回值的數(shù)組

    var results = [];

    if(obj == null)

        return results;

    // 優(yōu)先調(diào)用宿主環(huán)境提供的map方法

    if(nativeMap && obj.map === nativeMap)

        return obj.map(iterator, context);

    // 迭代處理集合中的元素

    each(obj, function(value, index, list) {

        // 將每次迭代處理的返回值存儲(chǔ)到results數(shù)組

        results[results.length] = iterator.call(context, value, index, list);

    });

    // 返回處理結(jié)果

    if(obj.length === +obj.length)

        results.length = obj.length;

    return results;

};

// 將集合中每個(gè)元素放入迭代處理器, 并將本次迭代的返回值作為"memo"傳遞到下一次迭代, 一般用于累計(jì)結(jié)果或連接數(shù)據(jù)

_.reduce = _.foldl = _.inject = function(obj, iterator, memo, context) {

    // 通過參數(shù)數(shù)量檢查是否存在初始值

    var initial = arguments.length > 2;

    if(obj == null)

        obj = [];

    // 優(yōu)先調(diào)用宿主環(huán)境提供的reduce方法

    if(nativeReduce && obj.reduce === nativeReduce && false) {

        if(context)

            iterator = _.bind(iterator, context);

        return initial ? obj.reduce(iterator, memo) : obj.reduce(iterator);

    }

    // 迭代處理集合中的元素

    each(obj, function(value, index, list) {

        if(!initial) {

            // 如果沒有初始值, 則將第一個(gè)元素作為初始值; 如果被處理的是對(duì)象集合, 則默認(rèn)值為第一個(gè)屬性的值

            memo = value;

            initial = true;

        } else {

            // 記錄處理結(jié)果, 并將結(jié)果傳遞給下一次迭代

            memo = iterator.call(context, memo, value, index, list);

        }

    });

    if(!initial)

        throw new TypeError("Reduce of empty array with no initial value");

    return memo;

};

// 與reduce作用相似, 將逆向迭代集合中的元素(即從最后一個(gè)元素開始直到第一個(gè)元素)

_.reduceRight = _.foldr = function(obj, iterator, memo, context) {

    var initial = arguments.length > 2;

    if(obj == null)

        obj = [];

    // 優(yōu)先調(diào)用宿主環(huán)境提供的reduceRight方法

    if(nativeReduceRight && obj.reduceRight === nativeReduceRight) {

        if(context)

            iterator = _.bind(iterator, context);

        return initial ? obj.reduceRight(iterator, memo) : obj.reduceRight(iterator);

    }

    // 逆轉(zhuǎn)集合中的元素順序

    var reversed = _.toArray(obj).reverse();

    if(context && !initial)

        iterator = _.bind(iterator, context);

    // 通過reduce方法處理數(shù)據(jù)

    return initial ? _.reduce(reversed, iterator, memo, context) : _.reduce(reversed, iterator);

};

// 遍歷集合中的元素, 返回第一個(gè)能夠通過處理器驗(yàn)證的元素

_.find = _.detect = function(obj, iterator, context) {

    // result存放第一個(gè)能夠通過驗(yàn)證的元素

    var result;

    // 通過any方法遍歷數(shù)據(jù), 并記錄通過驗(yàn)證的元素

    // (如果是在迭代中檢查處理器返回狀態(tài), 這里使用each方法會(huì)更合適)

    any(obj, function(value, index, list) {

        // 如果處理器返回的結(jié)果被轉(zhuǎn)換為Boolean類型后值為true, 則當(dāng)前記錄并返回當(dāng)前元素

        if(iterator.call(context, value, index, list)) {

            result = value;

            return true;

        }

    });

    return result;

};

// 與find方法作用類似, 但filter方法會(huì)記錄下集合中所有通過驗(yàn)證的元素

_.filter = _.select = function(obj, iterator, context) {

    // 用于存儲(chǔ)通過驗(yàn)證的元素?cái)?shù)組

    var results = [];

    if(obj == null)

        return results;

    // 優(yōu)先調(diào)用宿主環(huán)境提供的filter方法

    if(nativeFilter && obj.filter === nativeFilter)

        return obj.filter(iterator, context);

    // 迭代集合中的元素, 并將通過處理器驗(yàn)證的元素放到數(shù)組中并返回

    each(obj, function(value, index, list) {

        if(iterator.call(context, value, index, list))

            results[results.length] = value;

    });

    return results;

};

// 與filter方法作用相反, 即返回沒有通過處理器驗(yàn)證的元素列表

_.reject = function(obj, iterator, context) {

    var results = [];

    if(obj == null)

        return results;

    each(obj, function(value, index, list) {

        if(!iterator.call(context, value, index, list))

            results[results.length] = value;

    });

    return results;

};

// 如果集合中所有元素均能通過處理器驗(yàn)證, 則返回true

_.every = _.all = function(obj, iterator, context) {

    var result = true;

    if(obj == null)

        return result;

    // 優(yōu)先調(diào)用宿主環(huán)境提供的every方法

    if(nativeEvery && obj.every === nativeEvery)

        return obj.every(iterator, context);

    // 迭代集合中的元素

    each(obj, function(value, index, list) {

        // 這里理解為 result = (result && iterator.call(context, value, index, list))

        // 驗(yàn)證處理器的結(jié)果被轉(zhuǎn)換為Boolean類型后是否為true值

        if(!( result = result && iterator.call(context, value, index, list)))

            return breaker;

    });

    return !!result;

};

// 檢查集合中任何一個(gè)元素在被轉(zhuǎn)換為Boolean類型時(shí), 是否為true值?或者通過處理器處理后, 是否值為true?

var any = _.some = _.any = function(obj, iterator, context) {

    // 如果沒有指定處理器參數(shù), 則默認(rèn)的處理器函數(shù)會(huì)返回元素本身, 并在迭代時(shí)通過將元素轉(zhuǎn)換為Boolean類型來判斷是否為true值

    iterator || ( iterator = _.identity);

    var result = false;

    if(obj == null)

        return result;

    // 優(yōu)先調(diào)用宿主環(huán)境提供的some方法

    if(nativeSome && obj.some === nativeSome)

        return obj.some(iterator, context);

    // 迭代集合中的元素

    each(obj, function(value, index, list) {

        if(result || ( result = iterator.call(context, value, index, list)))

            return breaker;

    });

    return !!result;

};

// 檢查集合中是否有值與目標(biāo)參數(shù)完全匹配(同時(shí)將匹配數(shù)據(jù)類型)

_.include = _.contains = function(obj, target) {

    var found = false;

    if(obj == null)

        return found;

    // 優(yōu)先調(diào)用宿主環(huán)境提供的Array.prototype.indexOf方法

    if(nativeIndexOf && obj.indexOf === nativeIndexOf)

        return obj.indexOf(target) != -1;

    // 通過any方法迭代集合中的元素, 驗(yàn)證元素的值和類型與目標(biāo)是否完全匹配

    found = any(obj, function(value) {

        return value === target;

    });

    return found;

};

// 依次調(diào)用集合中所有元素的同名方法, 從第3個(gè)參數(shù)開始, 將被以此傳入到元素的調(diào)用方法中

// 返回一個(gè)數(shù)組, 存儲(chǔ)了所有方法的處理結(jié)果

_.invoke = function(obj, method) {

    // 調(diào)用同名方法時(shí)傳遞的參數(shù)(從第3個(gè)參數(shù)開始)

    var args = slice.call(arguments, 2);

    // 依次調(diào)用每個(gè)元素的方法, 并將結(jié)果放入數(shù)組中返回

    return _.map(obj, function(value) {

        return (_.isFunction(method) ? method || value : value[method]).apply(value, args);

    });

};

// 遍歷一個(gè)由對(duì)象列表組成的數(shù)組, 并返回每個(gè)對(duì)象中的指定屬性的值列表

_.pluck = function(obj, key) {

    // 如果某一個(gè)對(duì)象中不存在該屬性, 則返回undefined

    return _.map(obj, function(value) {

        return value[key];

    });

};

// 返回集合中的最大值, 如果不存在可比較的值, 則返回undefined

_.max = function(obj, iterator, context) {

    // 如果集合是一個(gè)數(shù)組, 且沒有使用處理器, 則使用Math.max獲取最大值

    // 一般會(huì)是在一個(gè)數(shù)組存儲(chǔ)了一系列Number類型的數(shù)據(jù)

    if(!iterator && _.isArray(obj) && obj[0] === +obj[0])

        return Math.max.apply(Math, obj);

    // 對(duì)于空值, 直接返回負(fù)無窮大

    if(!iterator && _.isEmpty(obj))

        return -Infinity;

    // 一個(gè)臨時(shí)的對(duì)象, computed用于在比較過程中存儲(chǔ)最大值(臨時(shí)的)

    var result = {

        computed : -Infinity

    };

    // 迭代集合中的元素

    each(obj, function(value, index, list) {

        // 如果指定了處理器參數(shù), 則比較的數(shù)據(jù)為處理器返回的值, 否則直接使用each遍歷時(shí)的默認(rèn)值

        var computed = iterator ? iterator.call(context, value, index, list) : value;

        // 如果比較值相比上一個(gè)值要大, 則將當(dāng)前值放入result.value

        computed >= result.computed && ( result = {

            value : value,

            computed : computed

        });

    });

    // 返回最大值

    return result.value;

};

// 返回集合中的最小值, 處理過程與max方法一致

_.min = function(obj, iterator, context) {

    if(!iterator && _.isArray(obj) && obj[0] === +obj[0])

        return Math.min.apply(Math, obj);

    if(!iterator && _.isEmpty(obj))

        return Infinity;

    var result = {

        computed : Infinity

    };

    each(obj, function(value, index, list) {

        var computed = iterator ? iterator.call(context, value, index, list) : value;

        computed < result.computed && ( result = {

            value : value,

            computed : computed

        });

    });

    return result.value;

};

// 通過隨機(jī)數(shù), 讓數(shù)組無須排列

_.shuffle = function(obj) {

    // shuffled變量存儲(chǔ)處理過程及最終的結(jié)果數(shù)據(jù)

    var shuffled = [], rand;

    // 迭代集合中的元素

    each(obj, function(value, index, list) {

        // 生成一個(gè)隨機(jī)數(shù), 隨機(jī)數(shù)在<0-當(dāng)前已處理的數(shù)量>之間

        rand = Math.floor(Math.random() * (index + 1));

        // 將已經(jīng)隨機(jī)得到的元素放到shuffled數(shù)組末尾

        shuffled[index] = shuffled[rand];

        // 在前面得到的隨機(jī)數(shù)的位置插入最新值

        shuffled[rand] = value;

    });

    // 返回一個(gè)數(shù)組, 該數(shù)組中存儲(chǔ)了經(jīng)過隨機(jī)混排的集合元素

    return shuffled;

};

// 對(duì)集合中元素, 按照特定的字段或值進(jìn)行排列

// 相比Array.prototype.sort方法, sortBy方法支持對(duì)對(duì)象排序

_.sortBy = function(obj, val, context) {

    // val應(yīng)該是對(duì)象的一個(gè)屬性, 或一個(gè)處理器函數(shù), 如果是一個(gè)處理器, 則應(yīng)該返回需要進(jìn)行比較的數(shù)據(jù)

    var iterator = _.isFunction(val) ? val : function(obj) {

        return obj[val];

    };

    // 調(diào)用順序: _.pluck(_.map().sort());

    // 調(diào)用_.map()方法遍歷集合, 并將集合中的元素放到value節(jié)點(diǎn), 將元素中需要進(jìn)行比較的數(shù)據(jù)放到criteria屬性中

    // 調(diào)用sort()方法將集合中的元素按照criteria屬性中的數(shù)據(jù)進(jìn)行順序排序

    // 調(diào)用pluck獲取排序后的對(duì)象集合并返回

    return _.pluck(_.map(obj, function(value, index, list) {

        return {

            value : value,

            criteria : iterator.call(context, value, index, list)

        };

    }).sort(function(left, right) {

        var a = left.criteria, b = right.criteria;

        if(a ===

            void 0)

            return 1;

        if(b ===

            void 0)

            return -1;

        return a < b ? -1 : a > b ? 1 : 0;

    }), "value");

};

// 將集合中的元素, 按處理器返回的key分為多個(gè)數(shù)組

_.groupBy = function(obj, val) {

    var result = {};

    // val將被轉(zhuǎn)換為進(jìn)行分組的處理器函數(shù), 如果val不是一個(gè)Function類型的數(shù)據(jù), 則將被作為篩選元素時(shí)的key值

    var iterator = _.isFunction(val) ? val : function(obj) {

        return obj[val];

    };

    // 迭代集合中的元素

    each(obj, function(value, index) {

        // 將處理器的返回值作為key, 并將相同的key元素放到一個(gè)新的數(shù)組

        var key = iterator(value, index);

        (result[key] || (result[key] = [])).push(value);

    });

    // 返回已分組的數(shù)據(jù)

    return result;

};

_.sortedIndex = function(array, obj, iterator) {

    iterator || ( iterator = _.identity);

    var low = 0, high = array.length;

    while(low < high) {

        var mid = (low + high) >> 1;

        iterator(array[mid]) < iterator(obj) ? low = mid + 1 : high = mid;

    }

    return low;

};

// 將一個(gè)集合轉(zhuǎn)換一個(gè)數(shù)組并返回

// 一般用于將arguments轉(zhuǎn)換為數(shù)組, 或?qū)?duì)象無序集合轉(zhuǎn)換為數(shù)據(jù)形式的有序集合

_.toArray = function(obj) {

    if(!obj)

        return [];

    if(_.isArray(obj))

        return slice.call(obj);

    // 將arguments轉(zhuǎn)換為數(shù)組

    if(_.isArguments(obj))

        return slice.call(obj);

    if(obj.toArray && _.isFunction(obj.toArray))

        return obj.toArray();

    // 將對(duì)象轉(zhuǎn)換為數(shù)組, 數(shù)組中包含對(duì)象中所有屬性的值列表(不包含對(duì)象原型鏈中的屬性)

    return _.values(obj);

};

// 計(jì)算集合中元素的數(shù)量

_.size = function(obj) {

    // 如果集合是一個(gè)數(shù)組, 則計(jì)算數(shù)組元素?cái)?shù)量

    // 如果集合是一個(gè)對(duì)象, 則計(jì)算對(duì)象中的屬性數(shù)量(不包含對(duì)象原型鏈中的屬性)

    return _.isArray(obj) ? obj.length : _.keys(obj).length;

};

// 數(shù)組相關(guān)的方法

// ---------------

// 返回一個(gè)數(shù)組的第一個(gè)或順序指定的n個(gè)元素

_.first = _.head = _.take = function(array, n, guard) {

    // 如果沒有指定參數(shù)n, 則返回第一個(gè)元素

    // 如果指定了n, 則返回一個(gè)新的數(shù)組, 包含順序指定數(shù)量n個(gè)元素

    // guard參數(shù)用于確定只返回第一個(gè)元素, 當(dāng)guard為true時(shí), 指定數(shù)量n無效

    return (n != null) && !guard ? slice.call(array, 0, n) : array[0];

};

// 返回一個(gè)新數(shù)組, 包含除第一個(gè)元素外的其它元素, 或排除從最后一個(gè)元素開始向前指定n個(gè)元素

// 與first方法不同在于, first確定需要的元素在數(shù)組之前的位置, initial確定能排除的元素在數(shù)組最后的位置

_.initial = function(array, n, guard) {

    // 如果沒有傳遞參數(shù)n, 則默認(rèn)返回除最后一個(gè)元素外的其它元素

    // 如果傳遞參數(shù)n, 則返回從最后一個(gè)元素開始向前的n個(gè)元素外的其它元素

    // guard用于確定只返回一個(gè)元素, 當(dāng)guard為true時(shí), 指定數(shù)量n無效

    return slice.call(array, 0, array.length - ((n == null) || guard ? 1 : n));

};

// 返回?cái)?shù)組的最后一個(gè)或倒序指定的n個(gè)元素

_.last = function(array, n, guard) {

    if((n != null) && !guard) {

        // 計(jì)算并指定獲取的元素位置n, 直到數(shù)組末尾, 作為一個(gè)新的數(shù)組返回

        return slice.call(array, Math.max(array.length - n, 0));

    } else {

        // 如果沒有指定數(shù)量, 或guard為true時(shí), 只返回最后一個(gè)元素

        return array[array.length - 1];

    }

};

// 獲取除了第一個(gè)或指定前n個(gè)元素外的其它元素

_.rest = _.tail = function(array, index, guard) {

    // 計(jì)算slice的第二個(gè)位置參數(shù), 直到數(shù)組末尾

    // 如果沒有指定index, 或guard值為true, 則返回除第一個(gè)元素外的其它元素

    // (index == null)值為true時(shí), 作為參數(shù)傳遞給slice函數(shù)將被自動(dòng)轉(zhuǎn)換為1

    return slice.call(array, (index == null) || guard ? 1 : index);

};

// 返回?cái)?shù)組中所有值能被轉(zhuǎn)換為true的元素, 返回一個(gè)新的數(shù)組

// 不能被轉(zhuǎn)換的值包括 false, 0, "", null, undefined, NaN, 這些值將被轉(zhuǎn)換為false

_.compact = function(array) {

    return _.filter(array, function(value) {

        return !!value;

    });

};

// 將一個(gè)多維數(shù)組合成為一維數(shù)組, 支持深層合并

// shallow參數(shù)用于控制合并深度, 當(dāng)shallow為true時(shí), 只合并第一層, 默認(rèn)進(jìn)行深層合并

_.flatten = function(array, shallow) {

    // 迭代數(shù)組中的每一個(gè)元素, 并將返回值作為demo傳遞給下一次迭代

    return _.reduce(array, function(memo, value) {

        // 如果元素依然是一個(gè)數(shù)組, 進(jìn)行以下判斷:

        // - 如果不進(jìn)行深層合并, 則使用Array.prototype.concat將當(dāng)前數(shù)組和之前的數(shù)據(jù)進(jìn)行連接

        // - 如果支持深層合并, 則迭代調(diào)用flatten方法, 直到底層元素不再是數(shù)組類型

        if(_.isArray(value))

            return memo.concat( shallow ? value : _.flatten(value));

        // 數(shù)據(jù)(value)已經(jīng)處于底層, 不再是數(shù)組類型, 則將數(shù)據(jù)合并到memo中并返回

        memo[memo.length] = value;

        return memo;

    }, []);

};

// 篩選并返回當(dāng)前數(shù)組中與指定數(shù)據(jù)不相等的差異數(shù)據(jù)(可參考difference方法注釋)

_.without = function(array) {

    return _.difference(array, slice.call(arguments, 1));

};

// 對(duì)數(shù)組中的數(shù)據(jù)進(jìn)行去重(使用===進(jìn)行比較)

// 當(dāng)isSorted參數(shù)不為false時(shí), 將依次對(duì)數(shù)組中的元素調(diào)用include方法, 檢查相同元素是否已經(jīng)被添加到返回值(數(shù)組)中

// 如果調(diào)用之前確保數(shù)組中數(shù)據(jù)按順序排列, 則可以將isSorted設(shè)為true, 它將通過與最后一個(gè)元素進(jìn)行對(duì)比來排除相同值, 使用isSorted效率會(huì)高于默認(rèn)的include方式

// uniq方法默認(rèn)將以數(shù)組中的數(shù)據(jù)進(jìn)行對(duì)比, 如果聲明iterator處理器, 則會(huì)根據(jù)處理器創(chuàng)建一個(gè)對(duì)比數(shù)組, 比較時(shí)以該數(shù)組中的數(shù)據(jù)為準(zhǔn), 但最終返回的唯一數(shù)據(jù)仍然是原始數(shù)組

_.uniq = _.unique = function(array, isSorted, iterator) {

    // 如果使用了iterator處理器, 則先將當(dāng)前數(shù)組中的數(shù)據(jù)會(huì)先經(jīng)過按迭代器處理, 并返回一個(gè)處理后的新數(shù)組

    // 新數(shù)組用于作為比較的基準(zhǔn)

    var initial = iterator ? _.map(array, iterator) : array;

    // 用于記錄處理結(jié)果的臨時(shí)數(shù)組

    var results = [];

    // 如果數(shù)組中只有2個(gè)值, 則不需要使用include方法進(jìn)行比較, 將isSorted設(shè)置為true能提高運(yùn)行效率

    if(array.length < 3)

        isSorted = true;

    // 使用reduce方法迭代并累加處理結(jié)果

    // initial變量是需要進(jìn)行比較的基準(zhǔn)數(shù)據(jù), 它可能是原始數(shù)組, 也可能是處理器的結(jié)果集合(如果設(shè)置過iterator)

    _.reduce(initial, function(memo, value, index) {

        // 如果isSorted參數(shù)為true, 則直接使用===比較記錄中的最后一個(gè)數(shù)據(jù)

        // 如果isSorted參數(shù)為false, 則使用include方法與集合中的每一個(gè)數(shù)據(jù)進(jìn)行對(duì)比

        if( isSorted ? _.last(memo) !== value || !memo.length : !_.include(memo, value)) {

            // memo記錄了已經(jīng)比較過的無重復(fù)數(shù)據(jù)

            // 根據(jù)iterator參數(shù)的狀態(tài), memo中記錄的數(shù)據(jù)可能是原始數(shù)據(jù), 也可能是處理器處理后的數(shù)據(jù)

            memo.push(value);

            // 處理結(jié)果數(shù)組中保存的始終為原始數(shù)組中的數(shù)據(jù)

            results.push(array[index]);

        }

        return memo;

    }, []);

    // 返回處理結(jié)果, 它只包含數(shù)組中無重復(fù)的數(shù)據(jù)

    return results;

};

// union方法與uniq方法作用一致, 不同之處在于union允許在參數(shù)中傳入多個(gè)數(shù)組

_.union = function() {

    // union對(duì)參數(shù)中的多個(gè)數(shù)組進(jìn)行淺層合并為一個(gè)數(shù)組對(duì)象傳遞給uniq方法進(jìn)行處理

    return _.uniq(_.flatten(arguments, true));

};

// 獲取當(dāng)前數(shù)組與其它一個(gè)或多個(gè)數(shù)組的交集元素

// 從第二個(gè)參數(shù)開始為需要進(jìn)行比較的一個(gè)或多個(gè)數(shù)組

_.intersection = _.intersect = function(array) {

    // rest變量記錄需要進(jìn)行比較的其它數(shù)組對(duì)象

    var rest = slice.call(arguments, 1);

    // 使用uniq方法去除當(dāng)前數(shù)組中的重復(fù)數(shù)據(jù), 避免重復(fù)計(jì)算

    // 對(duì)當(dāng)前數(shù)組的數(shù)據(jù)通過處理器進(jìn)行過濾, 并返回符合條件(比較相同元素)的數(shù)據(jù)

    return _.filter(_.uniq(array), function(item) {

        // 使用every方法驗(yàn)證每一個(gè)數(shù)組中都包含了需要對(duì)比的數(shù)據(jù)

        // 如果所有數(shù)組中均包含對(duì)比數(shù)據(jù), 則全部返回true, 如果任意一個(gè)數(shù)組沒有包含該元素, 則返回false

        return _.every(rest, function(other) {

            // other參數(shù)存儲(chǔ)了每一個(gè)需要進(jìn)行對(duì)比的數(shù)組

            // item存儲(chǔ)了當(dāng)前數(shù)組中需要進(jìn)行對(duì)比的數(shù)據(jù)

            // 使用indexOf方法搜索數(shù)組中是否存在該元素(可參考indexOf方法注釋)

            return _.indexOf(other, item) >= 0;

        });

    });

};

// 篩選并返回當(dāng)前數(shù)組中與指定數(shù)據(jù)不相等的差異數(shù)據(jù)

// 該函數(shù)一般用于刪除數(shù)組中指定的數(shù)據(jù), 并得到刪除后的新數(shù)組

// 該方法的作用與without相等, without方法參數(shù)形式上不允許數(shù)據(jù)被包含在數(shù)組中, 而difference方法參數(shù)形式上建議是數(shù)組(也可以和without使用相同形式的參數(shù))

_.difference = function(array) {

    // 對(duì)第2個(gè)參數(shù)開始的所有參數(shù), 作為一個(gè)數(shù)組進(jìn)行合并(僅合并第一層, 而并非深層合并)

    // rest變量存儲(chǔ)驗(yàn)證數(shù)據(jù), 在本方法中用于與原數(shù)據(jù)對(duì)比

    var rest = _.flatten(slice.call(arguments, 1), true);

    // 對(duì)合并后的數(shù)組數(shù)據(jù)進(jìn)行過濾, 過濾條件是當(dāng)前數(shù)組中不包含參數(shù)指定的驗(yàn)證數(shù)據(jù)的內(nèi)容

    // 將符合過濾條件的數(shù)據(jù)組合為一個(gè)新的數(shù)組并返回

    return _.filter(array, function(value) {

        return !_.include(rest, value);

    });

};

// 將每個(gè)數(shù)組的相同位置的數(shù)據(jù)作為一個(gè)新的二維數(shù)組返回, 返回的數(shù)組長(zhǎng)度以傳入?yún)?shù)中最大的數(shù)組長(zhǎng)度為準(zhǔn), 其它數(shù)組的空白位置使用undefined填充

// zip方法應(yīng)該包含多個(gè)參數(shù), 且每個(gè)參數(shù)應(yīng)該均為數(shù)組

_.zip = function() {

    // 將參數(shù)轉(zhuǎn)換為數(shù)組, 此時(shí)args是一個(gè)二維數(shù)組

    var args = slice.call(arguments);

    // 計(jì)算每一個(gè)數(shù)組的長(zhǎng)度, 并返回其中最大長(zhǎng)度值

    var length = _.max(_.pluck(args, "length"));

    // 依照最大長(zhǎng)度值創(chuàng)建一個(gè)新的空數(shù)組, 該數(shù)組用于存儲(chǔ)處理結(jié)果

    var results = new Array(length);

    // 循環(huán)最大長(zhǎng)度, 在每次循環(huán)將調(diào)用pluck方法獲取每個(gè)數(shù)組中相同位置的數(shù)據(jù)(依次從0到最后位置)

    // 將獲取到的數(shù)據(jù)存儲(chǔ)在一個(gè)新的數(shù)組, 放入results并返回

    for(var i = 0; i < length; i++)

    results[i] = _.pluck(args, "" + i);

    // 返回的結(jié)果是一個(gè)二維數(shù)組

    return results;

};

// 搜索一個(gè)元素在數(shù)組中首次出現(xiàn)的位置, 如果元素不存在則返回 -1

// 搜索時(shí)使用 === 對(duì)元素進(jìn)行匹配

_.indexOf = function(array, item, isSorted) {

    if(array == null)

        return -1;

    var i, l;

    if(isSorted) {

        i = _.sortedIndex(array, item);

        return array[i] === item ? i : -1;

    }

    // 優(yōu)先調(diào)用宿主環(huán)境提供的indexOf方法

    if(nativeIndexOf && array.indexOf === nativeIndexOf)

        return array.indexOf(item);

    // 循環(huán)并返回元素首次出現(xiàn)的位置

    for( i = 0, l = array.length; i < l; i++)

    if( i in array && array[i] === item)

        return i;

    // 沒有找到元素, 返回-1

    return -1;

};

// 返回一個(gè)元素在數(shù)組中最后一次出現(xiàn)的位置, 如果元素不存在則返回 -1

// 搜索時(shí)使用 === 對(duì)元素進(jìn)行匹配

_.lastIndexOf = function(array, item) {

    if(array == null)

        return -1;

    // 優(yōu)先調(diào)用宿主環(huán)境提供的lastIndexOf方法

    if(nativeLastIndexOf && array.lastIndexOf === nativeLastIndexOf)

        return array.lastIndexOf(item);

    var i = array.length;

    // 循環(huán)并返回元素最后出現(xiàn)的位置

    while(i--)

    if( i in array && array[i] === item)

        return i;

    // 沒有找到元素, 返回-1

    return -1;

};

// 根據(jù)區(qū)間和步長(zhǎng), 生成一系列整數(shù), 并作為數(shù)組返回

// start參數(shù)表示最小數(shù)

// stop參數(shù)表示最大數(shù)

// step參數(shù)表示生成多個(gè)數(shù)值之間的步長(zhǎng)值

_.range = function(start, stop, step) {

    // 參數(shù)控制

    if(arguments.length <= 1) {

        // 如果沒有參數(shù), 則start = 0, stop = 0, 在循環(huán)中不會(huì)生成任何數(shù)據(jù), 將返回一個(gè)空數(shù)組

        // 如果有1個(gè)參數(shù), 則參數(shù)指定給stop, start = 0

        stop = start || 0;

        start = 0;

    }

    // 生成整數(shù)的步長(zhǎng)值, 默認(rèn)為1

    step = arguments[2] || 1;

    // 根據(jù)區(qū)間和步長(zhǎng)計(jì)算將生成的最大值

    var len = Math.max(Math.ceil((stop - start) / step), 0);

    var idx = 0;

    var range = new Array(len);

    // 生成整數(shù)列表, 并存儲(chǔ)到range數(shù)組

    while(idx < len) {

        range[idx++] = start;

        start += step;

    }

    // 返回列表結(jié)果

    return range;

};

// 函數(shù)相關(guān)方法

// ------------------

// 創(chuàng)建一個(gè)用于設(shè)置prototype的公共函數(shù)對(duì)象

var ctor = function() {

};

// 為一個(gè)函數(shù)綁定執(zhí)行上下文, 任何情況下調(diào)用該函數(shù), 函數(shù)中的this均指向context對(duì)象

// 綁定函數(shù)時(shí), 可以同時(shí)給函數(shù)傳遞調(diào)用形參

_.bind = function bind(func, context) {

    var bound, args;

    // 優(yōu)先調(diào)用宿主環(huán)境提供的bind方法

    if(func.bind === nativeBind && nativeBind)

        return nativeBind.apply(func, slice.call(arguments, 1));

    // func參數(shù)必須是一個(gè)函數(shù)(Function)類型

    if(!_.isFunction(func))

        throw new TypeError;

    // args變量存儲(chǔ)了bind方法第三個(gè)開始的參數(shù)列表, 每次調(diào)用時(shí)都將傳遞給func函數(shù)

    args = slice.call(arguments, 2);

    return bound = function() {

        if(!(this instanceof bound))

            return func.apply(context, sargs.concat(slice.call(arguments)));

        ctor.prototype = func.prototype;

        var self = new ctor;

        var result = func.apply(self, args.concat(slice.call(arguments)));

        if(Object(result) === result)

            return result;

        return self;

    };

};

// 將指定的函數(shù), 或?qū)ο蟊旧淼乃泻瘮?shù)上下本綁定到對(duì)象本身, 被綁定的函數(shù)在被調(diào)用時(shí), 上下文對(duì)象始終指向?qū)ο蟊旧?
// 該方法一般在處理對(duì)象事件時(shí)使用, 例如:

// _(obj).bindAll(); // 或_(obj).bindAll("handlerClick");

// document.addEventListener("click", obj.handlerClick);

// 在handlerClick方法中, 上下文依然是obj對(duì)象

_.bindAll = function(obj) {

    // 第二個(gè)參數(shù)開始表示需要綁定的函數(shù)名稱

    var funcs = slice.call(arguments, 1);

    // 如果沒有指定特定的函數(shù)名稱, 則默認(rèn)綁定對(duì)象本身所有類型為Function的屬性

    if(funcs.length == 0)

        funcs = _.functions(obj);

    // 循環(huán)并將所有的函數(shù)上下本設(shè)置為obj對(duì)象本身

    // each方法本身不會(huì)遍歷對(duì)象原型鏈中的方法, 但此處的funcs列表是通過_.functions方法獲取的, 它已經(jīng)包含了原型鏈中的方法

    each(funcs, function(f) {

        obj[f] = _.bind(obj[f], obj);

    });

    return obj;

};

// memoize方法將返回一個(gè)函數(shù), 該函數(shù)集成了緩存功能, 將經(jīng)過計(jì)算的值緩存到局部變量并在下次調(diào)用時(shí)直接返回

// 如果計(jì)算結(jié)果是一個(gè)龐大的對(duì)象或數(shù)據(jù), 使用時(shí)應(yīng)該考慮內(nèi)存占用情況

_.memoize = function(func, hasher) {

    // 用于存儲(chǔ)緩存結(jié)果的memo對(duì)象

    var memo = {};

    // hasher參數(shù)應(yīng)該是一個(gè)function, 它用于返回一個(gè)key, 該key作為讀取緩存的標(biāo)識(shí)

    // 如果沒有指定key, 則默認(rèn)使用函數(shù)的第一個(gè)參數(shù)作為key, 如果函數(shù)的第一個(gè)參數(shù)是復(fù)合數(shù)據(jù)類型, 可能會(huì)返回類似[Object object]的key, 這個(gè)key可能會(huì)造成后續(xù)計(jì)算的數(shù)據(jù)不正確

    hasher || ( hasher = _.identity);

    // 返回一個(gè)函數(shù), 該函數(shù)首先通過檢查緩存, 再對(duì)沒有緩存過的數(shù)據(jù)進(jìn)行調(diào)用

    return function() {

        var key = hasher.apply(this, arguments);

        return _.has(memo, key) ? memo[key] : (memo[key] = func.apply(this, arguments));

    };

};

// 延時(shí)執(zhí)行一個(gè)函數(shù)

// wait單位為ms, 第3個(gè)參數(shù)開始將被依次傳遞給執(zhí)行函數(shù)

_.delay = function(func, wait) {

    var args = slice.call(arguments, 2);

    return setTimeout(function() {

        return func.apply(null, args);

    }, wait);

};

// 延遲執(zhí)行函數(shù)

// JavaScript中的setTimeout會(huì)被放到一個(gè)多帶帶的函數(shù)堆棧中執(zhí)行, 執(zhí)行時(shí)間是在當(dāng)前堆棧中調(diào)用的函數(shù)都被執(zhí)行完畢之后

// defer設(shè)置函數(shù)在1ms后執(zhí)行, 目的是將func函數(shù)放到多帶帶的堆棧中, 等待當(dāng)前函數(shù)執(zhí)行完成后再執(zhí)行

// defer方法一般用于處理DOM操作的優(yōu)先級(jí), 實(shí)現(xiàn)正確的邏輯流程和更流暢的交互體驗(yàn)

_.defer = function(func) {

    return _.delay.apply(_, [func, 1].concat(slice.call(arguments, 1)));

};

// 函數(shù)節(jié)流方法, throttle方法主要用于控制函數(shù)的執(zhí)行頻率, 在被控制的時(shí)間間隔內(nèi), 頻繁調(diào)用函數(shù)不會(huì)被多次執(zhí)行

// 在時(shí)間間隔內(nèi)如果多次調(diào)用了函數(shù), 時(shí)間隔截止時(shí)會(huì)自動(dòng)調(diào)用一次, 不需要等到時(shí)間截止后再手動(dòng)調(diào)用(自動(dòng)調(diào)用時(shí)不會(huì)有返回值)

// throttle函數(shù)一般用于處理復(fù)雜和調(diào)用頻繁的函數(shù), 通過節(jié)流控制函數(shù)的調(diào)用頻率, 節(jié)省處理資源

// 例如window.onresize綁定的事件函數(shù), 或element.onmousemove綁定的事件函數(shù), 可以用throttle進(jìn)行包裝

// throttle方法返回一個(gè)函數(shù), 該函數(shù)會(huì)自動(dòng)調(diào)用func并進(jìn)行節(jié)流控制

_.throttle = function(func, wait) {

    var context, args, timeout, throttling, more, result;

    // whenDone變量調(diào)用了debounce方法, 因此在多次連續(xù)調(diào)用函數(shù)時(shí), 最后一次調(diào)用會(huì)覆蓋之前調(diào)用的定時(shí)器, 清除狀態(tài)函數(shù)也僅會(huì)被執(zhí)行一次

    // whenDone函數(shù)在最后一次函數(shù)執(zhí)行的時(shí)間間隔截止時(shí)調(diào)用, 清除節(jié)流和調(diào)用過程中記錄的一些狀態(tài)

    var whenDone = _.debounce(function() {

        more = throttling = false;

    }, wait);

    // 返回一個(gè)函數(shù), 并在函數(shù)內(nèi)進(jìn)行節(jié)流控制

    return function() {

        // 保存函數(shù)的執(zhí)行上下文和參數(shù)

        context = this;

        args = arguments;

        // later函數(shù)在上一次函數(shù)調(diào)用時(shí)間間隔截止時(shí)執(zhí)行

        var later = function() {

            // 清除timeout句柄, 方便下一次函數(shù)調(diào)用

            timeout = null;

            // more記錄了在上一次調(diào)用至?xí)r間間隔截止之間, 是否重復(fù)調(diào)用了函數(shù)

            // 如果重復(fù)調(diào)用了函數(shù), 在時(shí)間間隔截止時(shí)將自動(dòng)再次調(diào)用函數(shù)

            if(more)

                func.apply(context, args);

            // 調(diào)用whenDone, 用于在時(shí)間間隔后清除節(jié)流狀態(tài)

            whenDone();

        };

        // timeout記錄了上一次函數(shù)執(zhí)行的時(shí)間間隔句柄

        // timeout時(shí)間間隔截止時(shí)調(diào)用later函數(shù), later中將清除timeout, 并檢查是否需要再次調(diào)用函數(shù)

        if(!timeout)

            timeout = setTimeout(later, wait);

        // throttling變量記錄上次調(diào)用的時(shí)間間隔是否已經(jīng)結(jié)束, 即是否處于節(jié)流過程中

        // throttling在每次函數(shù)調(diào)用時(shí)設(shè)為true, 表示需要進(jìn)行節(jié)流, 在時(shí)間間隔截止時(shí)設(shè)置為false(在whenDone函數(shù)中實(shí)現(xiàn))

        if(throttling) {

            // 節(jié)流過程中進(jìn)行了多次調(diào)用, 在more中記錄一個(gè)狀態(tài), 表示在時(shí)間間隔截止時(shí)需要再次自動(dòng)調(diào)用函數(shù)

            more = true;

        } else {

            // 沒有處于節(jié)流過程, 可能是第一次調(diào)用函數(shù), 或已經(jīng)超過上一次調(diào)用的間隔, 可以直接調(diào)用函數(shù)

            result = func.apply(context, args);

        }

        // 調(diào)用whenDone, 用于在時(shí)間間隔后清除節(jié)流狀態(tài)

        whenDone();

        // throttling變量記錄函數(shù)調(diào)用時(shí)的節(jié)流狀態(tài)

        throttling = true;

        // 返回調(diào)用結(jié)果

        return result;

    };

};

// debounce與throttle方法類似, 用于函數(shù)節(jié)流, 它們的不同之處在于:

// -- throttle關(guān)注函數(shù)的執(zhí)行頻率, 在指定頻率內(nèi)函數(shù)只會(huì)被執(zhí)行一次;

// -- debounce函數(shù)更關(guān)注函數(shù)執(zhí)行的間隔, 即函數(shù)兩次的調(diào)用時(shí)間不能小于指定時(shí)間;

// 如果兩次函數(shù)的執(zhí)行間隔小于wait, 定時(shí)器會(huì)被清除并重新創(chuàng)建, 這意味著連續(xù)頻繁地調(diào)用函數(shù), 函數(shù)一直不會(huì)被執(zhí)行, 直到某一次調(diào)用與上一次調(diào)用的時(shí)間不小于wait毫秒

// debounce函數(shù)一般用于控制需要一段時(shí)間之后才能執(zhí)行的操作, 例如在用戶輸入完畢200ms后提示用戶, 可以使用debounce包裝一個(gè)函數(shù), 綁定到onkeyup事件

// ----------------------------------------------------------------

// @param {Function} func 表示被執(zhí)行的函數(shù)

// @param {Number} wait 表示允許的時(shí)間間隔, 在該時(shí)間范圍內(nèi)重復(fù)調(diào)用會(huì)被重新推遲wait毫秒

// @param {Boolean} immediate 表示函數(shù)調(diào)用后是否立即執(zhí)行, true為立即調(diào)用, false為在時(shí)間截止時(shí)調(diào)用

// debounce方法返回一個(gè)函數(shù), 該函數(shù)會(huì)自動(dòng)調(diào)用func并進(jìn)行節(jié)流控制

_.debounce = function(func, wait, immediate) {

    // timeout用于記錄函數(shù)上一次調(diào)用的執(zhí)行狀態(tài)(定時(shí)器句柄)

    // 當(dāng)timeout為null時(shí), 表示上一次調(diào)用已經(jīng)結(jié)束

    var timeout;

    // 返回一個(gè)函數(shù), 并在函數(shù)內(nèi)進(jìn)行節(jié)流控制

    return function() {

        // 保持函數(shù)的上下文對(duì)象和參數(shù)

        var context = this, args = arguments;

        var later = function() {

            // 設(shè)置timeout為null

            // later函數(shù)會(huì)在允許的時(shí)間截止時(shí)被調(diào)用

            // 調(diào)用該函數(shù)時(shí), 表明上一次函數(shù)執(zhí)行時(shí)間已經(jīng)超過了約定的時(shí)間間隔, 此時(shí)之后再進(jìn)行調(diào)用都是被允許的

            timeout = null;

            if(!immediate)

                func.apply(context, args);

        };

        // 如果函數(shù)被設(shè)定為立即執(zhí)行, 且上一次調(diào)用的時(shí)間間隔已經(jīng)過去, 則立即調(diào)用函數(shù)

        if(immediate && !timeout)

            func.apply(context, args);

        // 創(chuàng)建一個(gè)定時(shí)器用于檢查和設(shè)置函數(shù)的調(diào)用狀態(tài)

        // 創(chuàng)建定時(shí)器之前先清空上一次setTimeout句柄, 無論上一次綁定的函數(shù)是否已經(jīng)被執(zhí)行

        // 如果本次函數(shù)在調(diào)用時(shí), 上一次函數(shù)執(zhí)行還沒有開始(一般是immediate設(shè)置為false時(shí)), 則函數(shù)的執(zhí)行時(shí)間會(huì)被推遲, 因此timeout句柄會(huì)被重新創(chuàng)建

        clearTimeout(timeout);

        // 在允許的時(shí)間截止時(shí)調(diào)用later函數(shù)

        timeout = setTimeout(later, wait);

    };

};

// 創(chuàng)建一個(gè)只會(huì)被執(zhí)行一次的函數(shù), 如果該函數(shù)被重復(fù)調(diào)用, 將返回第一次執(zhí)行的結(jié)果

// 該函數(shù)用于獲取和計(jì)算固定數(shù)據(jù)的邏輯, 如獲取用戶所用的瀏覽器類型

_.once = function(func) {

    // ran記錄函數(shù)是否被執(zhí)行過

    // memo記錄函數(shù)最后一次執(zhí)行的結(jié)果

    var ran = false, memo;

    return function() {

        // 如果函數(shù)已被執(zhí)行過, 則直接返回第一次執(zhí)行的結(jié)果

        if(ran)

            return memo;

        ran = true;

        return memo = func.apply(this, arguments);

    };

};

// 返回一個(gè)函數(shù), 該函數(shù)會(huì)將當(dāng)前函數(shù)作為參數(shù)傳遞給一個(gè)包裹函數(shù)

// 在包裹函數(shù)中可以通過第一個(gè)參數(shù)調(diào)用當(dāng)前函數(shù), 并返回結(jié)果

// 一般用于多個(gè)流程處理函數(shù)的低耦合組合調(diào)用

_.wrap = function(func, wrapper) {

    return function() {

        // 將當(dāng)前函數(shù)作為第一個(gè)參數(shù), 傳遞給wrapper函數(shù)

        var args = [func].concat(slice.call(arguments, 0));

        // 返回wrapper函數(shù)的處理結(jié)果

        return wrapper.apply(this, args);

    };

};

// 將多個(gè)函數(shù)組合到一起, 按照參數(shù)傳遞的順序, 后一個(gè)函數(shù)的返回值會(huì)被一次作為參數(shù)傳遞給前一個(gè)函數(shù)作為參數(shù)繼續(xù)處理

// _.compose(A, B, C); 等同于 A(B(C()));

// 該方法的缺點(diǎn)在于被關(guān)聯(lián)的函數(shù)處理的參數(shù)數(shù)量只能有一個(gè), 如果需要傳遞多個(gè)參數(shù), 可以通過Array或Object復(fù)合數(shù)據(jù)類型進(jìn)行組裝

_.compose = function() {

    // 獲取函數(shù)列表, 所有參數(shù)需均為Function類型

    var funcs = arguments;

    // 返回一個(gè)供調(diào)用的函數(shù)句柄

    return function() {

        // 從后向前依次執(zhí)行函數(shù), 并將記錄的返回值作為參數(shù)傳遞給前一個(gè)函數(shù)繼續(xù)處理

        var args = arguments;

        for(var i = funcs.length - 1; i >= 0; i--) {

            args = [funcs[i].apply(this, args)];

        }

        // 返回最后一次調(diào)用函數(shù)的返回值

        return args[0];

    };

};

// 返回一個(gè)函數(shù), 該函數(shù)作為調(diào)用計(jì)數(shù)器, 當(dāng)該函數(shù)被調(diào)用times次(或超過times次)后, func函數(shù)將被執(zhí)行

// after方法一般用作異步的計(jì)數(shù)器, 例如在多個(gè)AJAX請(qǐng)求全部完成后需要執(zhí)行一個(gè)函數(shù), 則可以使用after在每個(gè)AJAX請(qǐng)求完成后調(diào)用

_.after = function(times, func) {

    // 如果沒有指定或指定無效次數(shù), 則func被直接調(diào)用

    if(times <= 0)

        return func();

    // 返回一個(gè)計(jì)數(shù)器函數(shù)

    return function() {

        // 每次調(diào)用計(jì)數(shù)器函數(shù)times減1, 調(diào)用times次之后執(zhí)行func函數(shù)并返回func函數(shù)的返回值

        if(--times < 1) {

            return func.apply(this, arguments);

        }

    };

};

// 對(duì)象相關(guān)方法

// ----------------

// 獲取一個(gè)對(duì)象的屬性名列表(不包含原型鏈中的屬性)

_.keys = nativeKeys ||

function(obj) {

    if(obj !== Object(obj))

        throw new TypeError("Invalid object");

    var keys = [];

    // 記錄并返回對(duì)象的所有屬性名

    for(var key in obj)

    if(_.has(obj, key))

        keys[keys.length] = key;

    return keys;

};

// 返回一個(gè)對(duì)象中所有屬性的值列表(不包含原型鏈中的屬性)

_.values = function(obj) {

    return _.map(obj, _.identity);

};

// 獲取一個(gè)對(duì)象中所有屬性值為Function類型的key列表, 并按key名進(jìn)行排序(包含原型鏈中的屬性)

_.functions = _.methods = function(obj) {

    var names = [];

    for(var key in obj) {

        if(_.isFunction(obj[key]))

            names.push(key);

    }

    return names.sort();

};

// 將一個(gè)或多個(gè)對(duì)象的屬性(包含原型鏈中的屬性), 復(fù)制到obj對(duì)象, 如果存在同名屬性則覆蓋

_.extend = function(obj) {

    // each循環(huán)參數(shù)中的一個(gè)或多個(gè)對(duì)象

    each(slice.call(arguments, 1), function(source) {

        // 將對(duì)象中的全部屬性復(fù)制或覆蓋到obj對(duì)象

        for(var prop in source) {

            obj[prop] = source[prop];

        }

    });

    return obj;

};

// 返回一個(gè)新對(duì)象, 并從obj中復(fù)制指定的屬性到新對(duì)象中

// 第2個(gè)參數(shù)開始為指定的需要復(fù)制的屬性名(支持多個(gè)參數(shù)和深層數(shù)組)

_.pick = function(obj) {

    // 創(chuàng)建一個(gè)對(duì)象, 存放復(fù)制的指定屬性

    var result = {};

    // 從第二個(gè)參數(shù)開始合并為一個(gè)存放屬性名列表的數(shù)組

    each(_.flatten(slice.call(arguments, 1)), function(key) {

        // 循環(huán)屬性名列表, 如果obj中存在該屬性, 則將其復(fù)制到result對(duì)象

        if( key in obj)

            result[key] = obj[key];

    });

    // 返回復(fù)制結(jié)果

    return result;

};

// 將obj中不存在或轉(zhuǎn)換為Boolean類型后值為false的屬性, 從參數(shù)中指定的一個(gè)或多個(gè)對(duì)象中復(fù)制到obj

// 一般用于給對(duì)象指定默認(rèn)值

_.defaults = function(obj) {

    // 從第二個(gè)參數(shù)開始可指定多個(gè)對(duì)象, 這些對(duì)象中的屬性將被依次復(fù)制到obj對(duì)象中(如果obj對(duì)象中不存在該屬性的話)

    each(slice.call(arguments, 1), function(source) {

        // 遍歷每個(gè)對(duì)象中的所有屬性

        for(var prop in source) {

            // 如果obj中不存在或?qū)傩灾缔D(zhuǎn)換為Boolean類型后值為false, 則將屬性復(fù)制到obj中

            if(obj[prop] == null)

                obj[prop] = source[prop];

        }

    });

    return obj;

};

// 創(chuàng)建一個(gè)obj的副本, 返回一個(gè)新的對(duì)象, 該對(duì)象包含obj中的所有屬性和值的狀態(tài)

// clone函數(shù)不支持深層復(fù)制, 例如obj中的某個(gè)屬性存放著一個(gè)對(duì)象, 則該對(duì)象不會(huì)被復(fù)制

// 如果obj是一個(gè)數(shù)組, 則會(huì)創(chuàng)建一個(gè)相同的數(shù)組對(duì)象

_.clone = function(obj) {

    // 不支持非數(shù)組和對(duì)象類型的數(shù)據(jù)

    if(!_.isObject(obj))

        return obj;

    // 復(fù)制并返回?cái)?shù)組或?qū)ο?
    return _.isArray(obj) ? obj.slice() : _.extend({}, obj);

};

// 執(zhí)行一個(gè)函數(shù), 并將obj作為參數(shù)傳遞給該函數(shù), 函數(shù)執(zhí)行完畢后最終返回obj對(duì)象

// 一般在創(chuàng)建一個(gè)方法鏈的時(shí)候會(huì)使用tap方法, 例如:

// _(obj).chain().tap(click).tap(mouseover).tap(mouseout);

_.tap = function(obj, interceptor) {

    interceptor(obj);

    return obj;

};

// eq函數(shù)只在isEqual方法中調(diào)用, 用于比較兩個(gè)數(shù)據(jù)的值是否相等

// 與 === 不同在于, eq更關(guān)注數(shù)據(jù)的值

// 如果進(jìn)行比較的是兩個(gè)復(fù)合數(shù)據(jù)類型, 不僅僅比較是否來自同一個(gè)引用, 且會(huì)進(jìn)行深層比較(對(duì)兩個(gè)對(duì)象的結(jié)構(gòu)和數(shù)據(jù)進(jìn)行比較)

function eq(a, b, stack) {

    // 檢查兩個(gè)簡(jiǎn)單數(shù)據(jù)類型的值是否相等

    // 對(duì)于復(fù)合數(shù)據(jù)類型, 如果它們來自同一個(gè)引用, 則認(rèn)為其相等

    // 如果被比較的值其中包含0, 則檢查另一個(gè)值是否為-0, 因?yàn)?0 === -0 是成立的

    // 而 1 / 0 == 1 / -0 是不成立的(1 / 0值為Infinity, 1 / -0值為-Infinity, 而Infinity不等于-Infinity)

    if(a === b)

        return a !== 0 || 1 / a == 1 / b;

    // 將數(shù)據(jù)轉(zhuǎn)換為布爾類型后如果值為false, 將判斷兩個(gè)值的數(shù)據(jù)類型是否相等(因?yàn)閚ull與undefined, false, 0, 空字符串, 在非嚴(yán)格比較下值是相等的)

    if(a == null || b == null)

        return a === b;

    // 如果進(jìn)行比較的數(shù)據(jù)是一個(gè)Underscore封裝的對(duì)象(具有_chain屬性的對(duì)象被認(rèn)為是Underscore對(duì)象)

    // 則將對(duì)象解封后獲取本身的數(shù)據(jù)(通過_wrapped訪問), 然后再對(duì)本身的數(shù)據(jù)進(jìn)行比較

    // 它們的關(guān)系類似與一個(gè)jQuery封裝的DOM對(duì)象, 和瀏覽器本身創(chuàng)建的DOM對(duì)象

    if(a._chain)

        a = a._wrapped;

    if(b._chain)

        b = b._wrapped;

    // 如果對(duì)象提供了自定義的isEqual方法(此處的isEqual方法并非Undersocre對(duì)象的isEqual方法, 因?yàn)樵谏弦徊揭呀?jīng)對(duì)Undersocre對(duì)象進(jìn)行了解封)

    // 則使用對(duì)象自定義的isEqual方法與另一個(gè)對(duì)象進(jìn)行比較

    if(a.isEqual && _.isFunction(a.isEqual))

        return a.isEqual(b);

    if(b.isEqual && _.isFunction(b.isEqual))

        return b.isEqual(a);

    // 對(duì)兩個(gè)數(shù)據(jù)的數(shù)據(jù)類型進(jìn)行驗(yàn)證

    // 獲取對(duì)象a的數(shù)據(jù)類型(通過Object.prototype.toString方法)

    var className = toString.call(a);

    // 如果對(duì)象a的數(shù)據(jù)類型與對(duì)象b不匹配, 則認(rèn)為兩個(gè)數(shù)據(jù)值也不匹配

    if(className != toString.call(b))

        return false;

    // 執(zhí)行到此處, 可以確保需要比較的兩個(gè)數(shù)據(jù)均為復(fù)合數(shù)據(jù)類型, 且數(shù)據(jù)類型相等

    // 通過switch檢查數(shù)據(jù)的數(shù)據(jù)類型, 針對(duì)不同數(shù)據(jù)類型進(jìn)行不同的比較

    // (此處不包括對(duì)數(shù)組和對(duì)象類型, 因?yàn)樗鼈兛赡馨顚哟蔚臄?shù)據(jù), 將在后面進(jìn)行深層比較)

    switch (className) {

        case "[object String]":

            // 如果被比較的是字符串類型(其中a的是通過new String()創(chuàng)建的字符串)

            // 則將B轉(zhuǎn)換為String對(duì)象后進(jìn)行匹配(這里匹配并非進(jìn)行嚴(yán)格的數(shù)據(jù)類型檢查, 因?yàn)樗鼈儾⒎莵碜酝粋€(gè)對(duì)象的引用)

            // 在調(diào)用 == 進(jìn)行比較時(shí), 會(huì)自動(dòng)調(diào)用對(duì)象的toString()方法, 返回兩個(gè)簡(jiǎn)單數(shù)據(jù)類型的字符串

            return a == String(b);

        case "[object Number]":

            // 通過+a將a轉(zhuǎn)成一個(gè)Number, 如果a被轉(zhuǎn)換之前與轉(zhuǎn)換之后不相等, 則認(rèn)為a是一個(gè)NaN類型

            // 因?yàn)镹aN與NaN是不相等的, 因此當(dāng)a值為NaN時(shí), 無法簡(jiǎn)單地使用a == b進(jìn)行匹配, 而是用相同的方法檢查b是否為NaN(即 b != +b)

            // 當(dāng)a值是一個(gè)非NaN的數(shù)據(jù)時(shí), 則檢查a是否為0, 因?yàn)楫?dāng)b為-0時(shí), 0 === -0是成立的(實(shí)際上它們?cè)谶壿嬌蠈儆趦蓚€(gè)不同的數(shù)據(jù))

            return a != +a ? b != +b : (a == 0 ? 1 / a == 1 / b : a == +b);

        case "[object Date]":

        // 對(duì)日期類型沒有使用return或break, 因此會(huì)繼續(xù)執(zhí)行到下一步(無論數(shù)據(jù)類型是否為Boolean類型, 因?yàn)橄乱徊綄?duì)Boolean類型進(jìn)行檢查)

        case "[object Boolean]":

            // 將日期或布爾類型轉(zhuǎn)換為數(shù)字

            // 日期類型將轉(zhuǎn)換為數(shù)值類型的時(shí)間戳(無效的日期格式將被換轉(zhuǎn)為NaN)

            // 布爾類型中, true被轉(zhuǎn)換為1, false被轉(zhuǎn)換為0

            // 比較兩個(gè)日期或布爾類型被轉(zhuǎn)換為數(shù)字后是否相等

            return +a == +b;

        case "[object RegExp]":

            // 正則表達(dá)式類型, 通過source訪問表達(dá)式的字符串形式

            // 檢查兩個(gè)表達(dá)式的字符串形式是否相等

            // 檢查兩個(gè)表達(dá)式的全局屬性是否相同(包括g, i, m)

            // 如果完全相等, 則認(rèn)為兩個(gè)數(shù)據(jù)相等

            return a.source == b.source && a.global == b.global && a.multiline == b.multiline && a.ignoreCase == b.ignoreCase;

    }

    // 當(dāng)執(zhí)行到此時(shí), ab兩個(gè)數(shù)據(jù)應(yīng)該為類型相同的對(duì)象或數(shù)組類型

    if( typeof a != "object" || typeof b != "object")

        return false;

    // stack(堆)是在isEqual調(diào)用eq函數(shù)時(shí)內(nèi)部傳遞的空數(shù)組, 在后面比較對(duì)象和數(shù)據(jù)的內(nèi)部迭代中調(diào)用eq方法也會(huì)傳遞

    // length記錄堆的長(zhǎng)度

    var length = stack.length;

    while(length--) {

        // 如果堆中的某個(gè)對(duì)象與數(shù)據(jù)a匹配, 則認(rèn)為相等

        if(stack[length] == a)

            return true;

    }

    // 將數(shù)據(jù)a添加到堆中

    stack.push(a);

    // 定義一些局部變量

    var size = 0, result = true;

    // 通過遞歸深層比較對(duì)象和數(shù)組

    if(className == "[object Array]") {

        // 被比較的數(shù)據(jù)為數(shù)組類型

        // size記錄數(shù)組的長(zhǎng)度

        // result比較兩個(gè)數(shù)組的長(zhǎng)度是否一致, 如果長(zhǎng)度不一致, 則方法的最后將返回result(即false)

        size = a.length;

        result = size == b.length;

        // 如果兩個(gè)數(shù)組的長(zhǎng)度一致

        if(result) {

            // 調(diào)用eq方法對(duì)數(shù)組中的元素進(jìn)行迭代比較(如果數(shù)組中包含二維數(shù)組或?qū)ο? eq方法會(huì)進(jìn)行深層比較)

            while(size--) {

                // 在確保兩個(gè)數(shù)組都存在當(dāng)前索引的元素時(shí), 調(diào)用eq方法深層比較(將堆數(shù)據(jù)傳遞給eq方法)

                // 將比較的結(jié)果存儲(chǔ)到result變量, 如果result為false(即在比較中得到某個(gè)元素的數(shù)據(jù)不一致), 則停止迭代

                if(!( result = size in a == size in b && eq(a[size], b[size], stack)))

                    break;

            }

        }

    } else {

        // 被比較的數(shù)據(jù)為對(duì)象類型

        // 如果兩個(gè)對(duì)象不是同一個(gè)類的實(shí)例(通過constructor屬性比較), 則認(rèn)為兩個(gè)對(duì)象不相等

        if("constructor" in a != "constructor" in b || a.constructor != b.constructor)

            return false;

        // 深層比較兩個(gè)對(duì)象中的數(shù)據(jù)

        for(var key in a) {

            if(_.has(a, key)) {

                // size用于記錄比較過的屬性數(shù)量, 因?yàn)檫@里遍歷的是a對(duì)象的屬性, 并比較b對(duì)象中該屬性的數(shù)據(jù)

                // 當(dāng)b對(duì)象中的屬性數(shù)量多余a對(duì)象時(shí), 此處的邏輯成立, 但兩個(gè)對(duì)象并不相等

                size++;

                // 迭代調(diào)用eq方法, 深層比較兩個(gè)對(duì)象中的屬性值

                // 將比較的結(jié)果記錄到result變量, 當(dāng)比較到不相等的數(shù)據(jù)時(shí)停止迭代

                if(!( result = _.has(b, key) && eq(a[key], b[key], stack)))

                    break;

            }

        }

        // 深層比較完畢, 這里已經(jīng)可以確保在對(duì)象a中的所有數(shù)據(jù), 對(duì)象b中也存在相同的數(shù)據(jù)

        // 根據(jù)size(對(duì)象屬性長(zhǎng)度)檢查對(duì)象b中的屬性數(shù)量是否與對(duì)象a相等

        if(result) {

            // 遍歷對(duì)象b中的所有屬性

            for(key in b) {

                // 當(dāng)size已經(jīng)到0時(shí)(即對(duì)象a中的屬性數(shù)量已經(jīng)遍歷完畢), 而對(duì)象b中還存在有屬性, 則對(duì)象b中的屬性多于對(duì)象a

                if(_.has(b, key) && !(size--))

                    break;

            }

            // 當(dāng)對(duì)象b中的屬性多于對(duì)象a, 則認(rèn)為兩個(gè)對(duì)象不相等

            result = !size;

        }

    }

    // 函數(shù)執(zhí)行完畢時(shí), 從堆中移除第一個(gè)數(shù)據(jù)(在比較對(duì)象或數(shù)組時(shí), 會(huì)迭代eq方法, 堆中可能存在多個(gè)數(shù)據(jù))

    stack.pop();

    // 返回的result記錄了最終的比較結(jié)果

    return result;

}

// 對(duì)兩個(gè)數(shù)據(jù)的值進(jìn)行比較(支持復(fù)合數(shù)據(jù)類型), 內(nèi)部函數(shù)eq的外部方法

_.isEqual = function(a, b) {

    return eq(a, b, []);

};

// 檢查數(shù)據(jù)是否為空值, 包含"", false, 0, null, undefined, NaN, 空數(shù)組(數(shù)組長(zhǎng)度為0)和空對(duì)象(對(duì)象本身沒有任何屬性)

_.isEmpty = function(obj) {

    // obj被轉(zhuǎn)換為Boolean類型后值為false

    if(obj == null)

        return true;

    // 檢查對(duì)象或字符串長(zhǎng)度是否為0

    if(_.isArray(obj) || _.isString(obj))

        return obj.length === 0;

    // 檢查對(duì)象(使用for in循環(huán)時(shí)將首先循環(huán)對(duì)象本身的屬性, 其次是原型鏈中的屬性), 因此如果第一個(gè)屬性是屬于對(duì)象本身的, 那么該對(duì)象不是一個(gè)空對(duì)象

    for(var key in obj)

    if(_.has(obj, key))

        return false;

    // 所有數(shù)據(jù)類型均沒有通過驗(yàn)證, 是一個(gè)空數(shù)據(jù)

    return true;

};

// 驗(yàn)證對(duì)象是否是一個(gè)DOM對(duì)象

_.isElement = function(obj) {

    return !!(obj && obj.nodeType == 1);

};

// 驗(yàn)證對(duì)象是否是一個(gè)數(shù)組類型, 優(yōu)先調(diào)用宿主環(huán)境提供的isArray方法

_.isArray = nativeIsArray ||

function(obj) {

    return toString.call(obj) == "[object Array]";

};

// 驗(yàn)證對(duì)象是否是一個(gè)復(fù)合數(shù)據(jù)類型的對(duì)象(即非基本數(shù)據(jù)類型String, Boolean, Number, null, undefined)

// 如果基本數(shù)據(jù)類型通過new進(jìn)行創(chuàng)建, 則也屬于對(duì)象類型

_.isObject = function(obj) {

    return obj === Object(obj);

};

// 檢查一個(gè)數(shù)據(jù)是否是一個(gè)arguments參數(shù)對(duì)象

_.isArguments = function(obj) {

    return toString.call(obj) == "[object Arguments]";

};

// 驗(yàn)證isArguments函數(shù), 如果運(yùn)行環(huán)境無法正常驗(yàn)證arguments類型的數(shù)據(jù), 則重新定義isArguments方法

if(!_.isArguments(arguments)) {

    // 對(duì)于環(huán)境無法通過toString驗(yàn)證arguments類型的, 則通過調(diào)用arguments獨(dú)有的callee方法來進(jìn)行驗(yàn)證

    _.isArguments = function(obj) {

        // callee是arguments的一個(gè)屬性, 指向?qū)rguments所屬函數(shù)自身的引用

        return !!(obj && _.has(obj, "callee"));

    };

}

// 驗(yàn)證對(duì)象是否是一個(gè)函數(shù)類型

_.isFunction = function(obj) {

    return toString.call(obj) == "[object Function]";

};

// 驗(yàn)證對(duì)象是否是一個(gè)字符串類型

_.isString = function(obj) {

    return toString.call(obj) == "[object String]";

};

// 驗(yàn)證對(duì)象是否是一個(gè)數(shù)字類型

_.isNumber = function(obj) {

    return toString.call(obj) == "[object Number]";

};

// 檢查一個(gè)數(shù)字是否為有效數(shù)字且有效范圍(Number類型, 值在負(fù)無窮大 - 正無窮大之間)

_.isFinite = function(obj) {

    return _.isNumber(obj) && isFinite(obj);

};

// 檢查數(shù)據(jù)是否為NaN類型(所有數(shù)據(jù)中只有NaN與NaN不相等)

_.isNaN = function(obj) {

    return obj !== obj;

};

// 檢查數(shù)據(jù)是否時(shí)Boolean類型

_.isBoolean = function(obj) {

    // 支持字面量和對(duì)象形式的Boolean數(shù)據(jù)

    return obj === true || obj === false || toString.call(obj) == "[object Boolean]";

};

// 檢查數(shù)據(jù)是否是一個(gè)Date類型

_.isDate = function(obj) {

    return toString.call(obj) == "[object Date]";

};

// 檢查數(shù)據(jù)是否是一個(gè)正則表達(dá)式類型

_.isRegExp = function(obj) {

    return toString.call(obj) == "[object RegExp]";

};

// 檢查數(shù)據(jù)是否是Null值

_.isNull = function(obj) {

    return obj === null;

};

// 檢查數(shù)據(jù)是否是Undefined(未定義的)值

_.isUndefined = function(obj) {

    return obj ===

    void 0;

};

// 檢查一個(gè)屬性是否屬于對(duì)象本身, 而非原型鏈中

_.has = function(obj, key) {

    return hasOwnProperty.call(obj, key);

};

// 工具函數(shù)

// -----------------

// 放棄_(下劃線)命名的Underscore對(duì)象, 并返回Underscore對(duì)象, 一般用于避免命名沖突或規(guī)范命名方式

// 例如:

// var us = _.noConflict(); // 取消_(下劃線)命名, 并將Underscore對(duì)象存放于us變量中

// console.log(_); // _(下劃線)已經(jīng)無法再訪問Underscore對(duì)象, 而恢復(fù)為Underscore定義前的值

_.noConflict = function() {

    // previousUnderscore變量記錄了Underscore定義前_(下劃線)的值

    root._ = previousUnderscore;

    return this;

};

// 返回與參數(shù)相同的值, 一般用于將一個(gè)數(shù)據(jù)的獲取方式轉(zhuǎn)換為函數(shù)獲取方式(內(nèi)部用于構(gòu)建方法時(shí)作為默認(rèn)處理器函數(shù))

_.identity = function(value) {

    return value;

};

// 使指定的函數(shù)迭代執(zhí)行n次(無參數(shù))

_.times = function(n, iterator, context) {

    for(var i = 0; i < n; i++)

    iterator.call(context, i);

};

// 將HTML字符串中的特殊字符轉(zhuǎn)換為HTML實(shí)體, 包含 & < > " " 

_.escape = function(string) {

    return ("" + string).replace(/&/g, "&").replace(//g, ">").replace(/"/g, """).replace(/"/g, """).replace(///g, "/");

};

// 指定一個(gè)對(duì)象的屬性, 返回該屬性對(duì)應(yīng)的值, 如果該屬性對(duì)應(yīng)的是一個(gè)函數(shù), 則會(huì)執(zhí)行該函數(shù)并返回結(jié)果

_.result = function(object, property) {

    if(object == null)

        return null;

    // 獲取對(duì)象的值

    var value = object[property];

    // 如果值是一個(gè)函數(shù), 則執(zhí)行并返回, 否則將直接返回

    return _.isFunction(value) ? value.call(object) : value;

};

// 添加一系列自定義方法到Underscore對(duì)象中, 用于擴(kuò)展Underscore插件

_.mixin = function(obj) {

    // obj是一個(gè)集合一系列自定義方法的對(duì)象, 此處通過each遍歷對(duì)象的方法

    each(_.functions(obj), function(name) {

        // 通過addToWrapper函數(shù)將自定義方法添加到Underscore構(gòu)建的對(duì)象中, 用于支持對(duì)象式調(diào)用

        // 同時(shí)將方法添加到 _ 本身, 用于支持函數(shù)式調(diào)用

        addToWrapper(name, _[name] = obj[name]);

    });

};

// 獲取一個(gè)全局唯一標(biāo)識(shí), 標(biāo)識(shí)從0開始累加

var idCounter = 0;

// prefix表示標(biāo)識(shí)的前綴, 如果沒有指定前綴則直接返回標(biāo)識(shí), 一般用于給對(duì)象或DOM創(chuàng)建唯一ID

_.uniqueId = function(prefix) {

    var id = idCounter++;

    return prefix ? prefix + id : id;

};

// 定義模板的界定符號(hào), 在template方法中使用

_.templateSettings = {

    // JavaScript可執(zhí)行代碼的界定符

    evaluate : /<%([sS]+?)%>/g,

    // 直接輸出變量的界定符

    interpolate : /<%=([sS]+?)%>/g,

    // 需要將HTML輸出為字符串(將特殊符號(hào)轉(zhuǎn)換為字符串形式)的界定符

    escape : /<%-([sS]+?)%>/g

};

var noMatch = /.^/;

// escapes對(duì)象記錄了需要進(jìn)行相互換轉(zhuǎn)的特殊符號(hào)與字符串形式的對(duì)應(yīng)關(guān)系, 在兩者進(jìn)行相互轉(zhuǎn)換時(shí)作為索引使用

// 首先根據(jù)字符串形式定義特殊字符

var escapes = {

    "" : "",

    """ : """,

    "r" : "
",

    "n" : "
",

    "t" : "	",

    "u2028" : "u2028",

    "u2029" : "u2029"

};

// 遍歷所有特殊字符字符串, 并以特殊字符作為key記錄字符串形式

for(var p in escapes)

escapes[escapes[p]] = p;

// 定義模板中需要替換的特殊符號(hào), 包含反斜杠, 單引號(hào), 回車符, 換行符, 制表符, 行分隔符, 段落分隔符

// 在將字符串中的特殊符號(hào)轉(zhuǎn)換為字符串形式時(shí)使用

var escaper = /|"|
|
|	|u2028|u2029/g;

// 在將字符串形式的特殊符號(hào)進(jìn)行反轉(zhuǎn)(替換)時(shí)使用

var unescaper = /(|"|r|n|t|u2028|u2029)/g;

// 反轉(zhuǎn)字符串中的特殊符號(hào)

// 在模板中涉及到需要執(zhí)行的JavaScript源碼, 需要進(jìn)行特殊符號(hào)反轉(zhuǎn), 否則如果以HTML實(shí)體或字符串形式出現(xiàn), 會(huì)拋出語(yǔ)法錯(cuò)誤

var unescape = function(code) {

    return code.replace(unescaper, function(match, escape) {

        return escapes[escape];

    });

};

// Underscore模板解析方法, 用于將數(shù)據(jù)填充到一個(gè)模板字符串中

// 模板解析流程:

// 1. 將模板中的特殊符號(hào)轉(zhuǎn)換為字符串

// 2. 解析escape形式標(biāo)簽, 將內(nèi)容解析為HTML實(shí)體

// 3. 解析interpolate形式標(biāo)簽, 輸出變量

// 4. 解析evaluate形式標(biāo)簽, 創(chuàng)建可執(zhí)行的JavaScript代碼

// 5. 生成一個(gè)處理函數(shù), 該函數(shù)在得到數(shù)據(jù)后可直接填充到模板并返回填充后的字符串

// 6. 根據(jù)參數(shù)返回填充后的字符串或處理函數(shù)的句柄

// -------------------

// 在模板體內(nèi), 可通過argments獲取2個(gè)參數(shù), 分別為填充數(shù)據(jù)(名稱為obj)和Underscore對(duì)象(名稱為_)

_.template = function(text, data, settings) {

    // 模板配置, 如果沒有指定配置項(xiàng), 則使用templateSettings中指定的配置項(xiàng)

    settings = _.defaults(settings || {}, _.templateSettings);

    // 開始將模板解析為可執(zhí)行源碼

    var source = "__p+="" + text.replace(escaper, function(match) {

        // 將特殊符號(hào)轉(zhuǎn)移為字符串形式

        return "" + escapes[match];

    }).replace(settings.escape || noMatch, function(match, code) {

        // 解析escape形式標(biāo)簽 <%- %>, 將變量中包含的HTML通過_.escape函數(shù)轉(zhuǎn)換為HTML實(shí)體

        return ""+
_.escape(" + unescape(code) + ")+
"";

    }).replace(settings.interpolate || noMatch, function(match, code) {

        // 解析interpolate形式標(biāo)簽 <%= %>, 將模板內(nèi)容作為一個(gè)變量與其它字符串連接起來, 則會(huì)作為一個(gè)變量輸出

        return ""+
(" + unescape(code) + ")+
"";

    }).replace(settings.evaluate || noMatch, function(match, code) {

        // 解析evaluate形式標(biāo)簽 <% %>, evaluate標(biāo)簽中存儲(chǔ)了需要執(zhí)行的JavaScript代碼, 這里結(jié)束當(dāng)前的字符串拼接, 并在新的一行作為JavaScript語(yǔ)法執(zhí)行, 并將后面的內(nèi)容再次作為字符串的開始, 因此evaluate標(biāo)簽內(nèi)的JavaScript代碼就能被正常執(zhí)行

        return "";
" + unescape(code) + "
;__p+="";

    }) + "";
";

    if(!settings.variable)

        source = "with(obj||{}){
" + source + "}
";

    source = "var __p="";" + "var print=function(){__p+=Array.prototype.join.call(arguments, "")};
" + source + "return __p;
";

    // 創(chuàng)建一個(gè)函數(shù), 將源碼作為函數(shù)執(zhí)行體, 將obj和Underscore作為參數(shù)傳遞給該函數(shù)

    var render = new Function(settings.variable || "obj", "_", source);

    // 如果指定了模板的填充數(shù)據(jù), 則替換模板內(nèi)容, 并返回替換后的結(jié)果

    if(data)

        return render(data, _);

    // 如果沒有指定填充數(shù)據(jù), 則返回一個(gè)函數(shù), 該函數(shù)用于將接收到的數(shù)據(jù)替換到模板

    // 如果在程序中會(huì)多次填充相同模板, 那么在第一次調(diào)用時(shí)建議不指定填充數(shù)據(jù), 在獲得處理函數(shù)的引用后, 再直接調(diào)用會(huì)提高運(yùn)行效率

    var template = function(data) {

        return render.call(this, data, _);

    };

    // 將創(chuàng)建的源碼字符串添加到函數(shù)對(duì)象中, 一般用于調(diào)試和測(cè)試

    template.source = "function(" + (settings.variable || "obj") + "){
" + source + "}";

    // 沒有指定填充數(shù)據(jù)的情況下, 返回處理函數(shù)句柄

    return template;

};

// 支持Underscore對(duì)象的方法鏈操作, 可參考 wrapper.prototype.chain

_.chain = function(obj) {

    return _(obj).chain();

};

// Underscore對(duì)象封裝相關(guān)方法

// ---------------

// 創(chuàng)建一個(gè)包裝器, 將一些原始數(shù)據(jù)進(jìn)行包裝

// 所有的unde