摘要：本文同步自我得博客前兩天在微博上看到的微博推薦了我的前兩篇文章，有點意外和驚喜。沒看過前兩篇博客的朋友可以戳這里源碼解析一源碼解析二上一篇文章介紹了的個函數的具體實現細節，今天將繼續介紹其他的函數。

本文同步自我得博客：http://www.joeray61.com

前兩天在微博上看到SF的微博推薦了我的前兩篇文章，有點意外和驚喜。作為一個菜鳥，真的是倍受鼓舞，我寫博客的動力也更充足了。
沒看過前兩篇博客的朋友可以戳這里：Underscore源碼解析（一）、Underscore源碼解析（二）
上一篇文章介紹了underscore的10個函數的具體實現細節，今天將繼續介紹其他的函數。

_.invoke = function(obj, method) {
    // 調用同名方法時傳遞的參數(從第3個參數開始)
    var args = slice.call(arguments, 2);
    // 依次調用每個元素的方法, 并將結果放入數組中返回
    return _.map(obj, function(value) {
        return (_.isFunction(method) ? method || value : value[method]).apply(value, args);
    });
};

這個函數依次調用集合中所有元素的同名方法，從第3個參數開始的所有參數將被傳入到元素的調用方法中，最后返回一個數組，該數組存儲了所有方法的處理結果

_.pluck = function(obj, key) {
    // 如果某一個對象中不存在該屬性, 則返回undefined
    return _.map(obj, function(value) {
        return value[key];
    });
};

這個函數遍歷了一個由對象列表組成的集合，并返回每個對象中的指定屬性的值列表

_.max = function(obj, iterator, context) {
    // 如果集合是一個數組, 且沒有使用處理器, 則使用Math.max獲取最大值
    // 一般會是在一個數組存儲了一系列Number類型的數據
    if(!iterator && _.isArray(obj) && obj[0] === +obj[0])
        return Math.max.apply(Math, obj);
    // 對于空值, 直接返回負無窮大
    if(!iterator && _.isEmpty(obj))
        return -Infinity;
    // 一個臨時的對象, computed用于在比較過程中存儲最大值(臨時的)
    var result = {
        computed : -Infinity
    };
    // 迭代集合中的元素
    each(obj, function(value, index, list) {
        // 如果指定了處理器參數, 則比較的數據為處理器返回的值, 否則直接使用each遍歷時的默認值
        var computed = iterator ? iterator.call(context, value, index, list) : value;
        // 如果比較值相比上一個值要大, 則將當前值放入result.value
        computed >= result.computed && ( result = {
            value : value,
            computed : computed
        });
    });
    // 返回最大值
    return result.value;
};

顧名思義，這個函數用來返回集合中的最大值, 如果不存在可比較的值, 則返回undefined

_.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;
};

這個函數沒有加注釋，因為實現過程與max基本相同，用于返回集合中的最小值

_.shuffle = function(obj) {
    // shuffled變量存儲處理過程及最終的結果數據
    var shuffled = [], rand;
    // 迭代集合中的元素
    each(obj, function(value, index, list) {
        // 生成一個隨機數, 隨機數在<0-當前已處理的數量>之間
        rand = Math.floor(Math.random() * (index + 1));
        // 將已經隨機得到的元素放到shuffled數組末尾
        shuffled[index] = shuffled[rand];
        // 在前面得到的隨機數的位置插入最新值
        shuffled[rand] = value;
    });
    // 返回一個數組, 該數組中存儲了經過隨機混排的集合元素
    return shuffled;
};

這個函數是通過隨機數, 讓數組無須排列，實際上是實現了一個模擬洗牌過程的算法

_.sortBy = function(obj, val, context) {
    // val應該是對象的一個屬性, 或一個處理器函數, 如果是一個處理器, 則應該返回需要進行比較的數據
    var iterator = _.isFunction(val) ? val : function(obj) {
        return obj[val];
    };
    // 調用順序: _.pluck(_.map().sort());
    // 調用_.map()方法遍歷集合, 并將集合中的元素放到value節點, 將元素中需要進行比較的數據放到criteria屬性中
    // 調用sort()方法將集合中的元素按照criteria屬性中的數據進行順序排序
    // 調用pluck獲取排序后的對象集合并返回
    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");
};

這個函數對集合中元素, 按照特定的字段或值進行排列，相比Array.prototype.sort方法, sortBy方法支持對對象排序

_.groupBy = function(obj, val) {
    var result = {};
    // val將被轉換為進行分組的處理器函數, 如果val不是一個Function類型的數據, 則將被作為篩選元素時的key值
    var iterator = _.isFunction(val) ? val : function(obj) {
        return obj[val];
    };
    // 迭代集合中的元素
    each(obj, function(value, index) {
        // 將處理器的返回值作為key, 并將相同的key元素放到一個新的數組
        var key = iterator(value, index);
        (result[key] || (result[key] = [])).push(value);
    });
    // 返回已分組的數據
    return result;
};

這個函數將集合中的元素, 按處理器返回的key分為多個數組

_.sortedIndex = function(array, obj, iterator) {
    // 如果沒有指定處理器參數, 則使用默認的處理器函數，該函數會返回參數本身
    iterator || ( iterator = _.identity);
    var low = 0, high = array.length;
    // 不斷與中間值對比，尋找obj的正確插入點
    while(low < high) {
        // (low + high) >> 1 相當于 Math.floor((low + high) / 2)
        var mid = (low + high) >> 1;
        iterator(array[mid]) < iterator(obj) ? low = mid + 1 : high = mid;
    }
    // 返回obj插入array之后的索引號
    return low;
};

這個函數的作用是將obj插入已經排序的array中，返回obj在array中的索引號

_.toArray = function(obj) {
    if(!obj)
        return [];
    if(_.isArray(obj))
        return slice.call(obj);
    // 將arguments轉換為數組
    if(_.isArguments(obj))
        return slice.call(obj);
    if(obj.toArray && _.isFunction(obj.toArray))
        return obj.toArray();
    // 將對象轉換為數組, 數組中包含對象中所有屬性的值列表(不包含對象原型鏈中的屬性)
    return _.values(obj);
};

這個函數很簡單，作用是將一個集合轉換一個數組并返回

_.size = function(obj) {
    // 如果集合是一個數組, 則計算數組元素數量
    // 如果集合是一個對象, 則計算對象中的屬性數量(不包含對象原型鏈中的屬性)
    return _.isArray(obj) ? obj.length : _.keys(obj).length;
};

這個函數用于計算集合中元素的數量，isArray和keys函數后面會介紹到

_.first = _.head = _.take = function(array, n, guard) {
    // 如果沒有指定參數n, 則返回第一個元素
    // 如果指定了n, 則返回一個新的數組, 包含順序指定數量n個元素
    // guard參數用于確定只返回第一個元素, 當guard為true時, 指定數量n無效
    return (n != null) && !guard ? slice.call(array, 0, n) : array[0];
};

這個函數用于返回一個數組的第一個或順序指定的n個元素

_.initial = function(array, n, guard) {
    // 如果沒有傳遞參數n, 則默認返回除最后一個元素外的其它元素
    // 如果傳遞參數n, 則返回從最后一個元素開始向前的n個元素外的其它元素
    // guard用于確定只返回一個元素, 當guard為true時, 指定數量n無效
    return slice.call(array, 0, array.length - ((n == null) || guard ? 1 : n));
};

這個函數返回一個新數組, 包含除最后一個元素外的其它元素, 或排除從最后一個元素開始向前指定n個元素

_.last = function(array, n, guard) {
    if((n != null) && !guard) {
        // 計算并指定獲取的元素位置n, 直到數組末尾, 作為一個新的數組返回
        return slice.call(array, Math.max(array.length - n, 0));
    } else {
        // 如果沒有指定數量, 或guard為true時, 只返回最后一個元素
        return array[array.length - 1];
    }
};

這個函數與first相反，返回數組的最后一個或倒序指定的n個元素

_.rest = _.tail = function(array, index, guard) {
    // 計算slice的第二個位置參數, 直到數組末尾
    // 如果沒有指定index, 或guard值為true, 則返回除第一個元素外的其它元素
    // (index == null)值為true時, 作為參數傳遞給slice函數將被自動轉換為1
    return slice.call(array, (index == null) || guard ? 1 : index);
};

這個函數與initial相反，用于獲取除了第一個或指定前n個元素外的其它元素

_.compact = function(array) {
    return _.filter(array, function(value) {
        return !!value;
    });
};

這個函數借助filter函數，返回數組中所有值能被轉換為true的元素, 返回一個新的數組，不能被轉換的值包括 false, 0, "", null, undefined, NaN, 這些值將被轉換為false

_.flatten = function(array, shallow) {
    // 迭代數組中的每一個元素, 并將返回值作為demo傳遞給下一次迭代
    return _.reduce(array, function(memo, value) {
        // 如果元素依然是一個數組, 進行以下判斷:
        // - 如果不進行深層合并, 則使用Array.prototype.concat將當前數組和之前的數據進行連接
        // - 如果支持深層合并, 則迭代調用flatten方法, 直到底層元素不再是數組類型
        if(_.isArray(value))
            return memo.concat( shallow ? value : _.flatten(value));
        // 數據(value)已經處于底層, 不再是數組類型, 則將數據合并到memo中并返回
        memo[memo.length] = value;
        return memo;
    }, []);
};

這個函數用于將一個多維數組合成為一維數組, 支持深層合并，其中第二個參數shallow用于控制合并深度, 當shallow為true時, 只合并第一層, 默認進行深層合并

_.without = function(array) {
    return _.difference(array, slice.call(arguments, 1));
};

這個函數用于篩選并返回當前數組中與指定數據不相等的差異數據，具體可以參看我后續對difference函數的介紹

_.uniq = _.unique = function(array, isSorted, iterator) {
    // 如果使用了iterator處理器, 則先將當前數組中的數據會先經過按迭代器處理, 并返回一個處理后的新數組
    // 新數組用于作為比較的基準
    var initial = iterator ? _.map(array, iterator) : array;
    // 用于記錄處理結果的臨時數組
    var results = [];
    // 如果數組中只有2個值, 則不需要使用include方法進行比較, 將isSorted設置為true能提高運行效率
    if(array.length < 3)
        isSorted = true;
    // 使用reduce方法迭代并累加處理結果
    // initial變量是需要進行比較的基準數據, 它可能是原始數組, 也可能是處理器的結果集合(如果設置過iterator)
    _.reduce(initial, function(memo, value, index) {
        // 如果isSorted參數為true, 則直接使用===比較記錄中的最后一個數據
        // 如果isSorted參數為false, 則使用include方法與集合中的每一個數據進行對比
        if( isSorted ? _.last(memo) !== value || !memo.length : !_.include(memo, value)) {
            // memo記錄了已經比較過的無重復數據
            // 根據iterator參數的狀態, memo中記錄的數據可能是原始數據, 也可能是處理器處理后的數據
            memo.push(value);
            // 處理結果數組中保存的始終為原始數組中的數據
            results.push(array[index]);
        }
        return memo;
    }, []);
    // 返回處理結果, 它只包含數組中無重復的數據
    return results;
};

這個函數用于對數組中的數據進行去重(使用===進行比較)，當isSorted參數不為false時, 將依次對數組中的元素調用include方法, 檢查相同元素是否已經被添加到返回值(數組)中，如果調用之前確保數組中數據按順序排列, 則可以將isSorted設為true, 它將通過與最后一個元素進行對比來排除相同值, 使用isSorted效率會高于默認的include方式，uniq方法默認將以數組中的數據進行對比, 如果聲明iterator處理器, 則會根據處理器創建一個對比數組, 比較時以該數組中的數據為準, 但最終返回的唯一數據仍然是原始數組

_.union = function() {
    // union對參數中的多個數組進行淺層合并為一個數組對象傳遞給uniq方法進行處理
    return _.uniq(_.flatten(arguments, true));
};

這個函數與uniq作用一致, 不同之處在于union允許在參數中傳入多個數組

_.intersection = _.intersect = function(array) {
    // rest變量記錄需要進行比較的其它數組對象
    var rest = slice.call(arguments, 1);
    // 使用uniq方法去除當前數組中的重復數據, 避免重復計算
    // 對當前數組的數據通過處理器進行過濾, 并返回符合條件(比較相同元素)的數據
    return _.filter(_.uniq(array), function(item) {
        // 使用every方法驗證每一個數組中都包含了需要對比的數據
        // 如果所有數組中均包含對比數據, 則全部返回true, 如果任意一個數組沒有包含該元素, 則返回false
        return _.every(rest, function(other) {
            // other參數存儲了每一個需要進行對比的數組
            // item存儲了當前數組中需要進行對比的數據
            // 使用indexOf方法搜索數組中是否存在該元素(可參考indexOf方法注釋)
            return _.indexOf(other, item) >= 0;
        });
    });
};

這個函數用于獲取當前數組與其它一個或多個數組的交集元素，從第二個參數開始為需要進行比較的一個或多個數組

_.difference = function(array) {
    // 對第2個參數開始的所有參數, 作為一個數組進行合并(僅合并第一層, 而并非深層合并)
    // rest變量存儲驗證數據, 在本方法中用于與原數據對比
    var rest = _.flatten(slice.call(arguments, 1), true);
    // 對合并后的數組數據進行過濾, 過濾條件是當前數組中不包含參數指定的驗證數據的內容
    // 將符合過濾條件的數據組合為一個新的數組并返回
    return _.filter(array, function(value) {
        return !_.include(rest, value);
    });
};

這個函數會篩選并返回當前數組中與指定數據不相等的差異數據，一般用于刪除數組中指定的數據, 并得到刪除后的新數組

今天一共介紹了21個函數的具體實現，我都寫累了，大家可能也看累了吧，我覺得寫太多也不利于大家消化這些知識，今天就到這兒吧。thx for reading, hope u enjoy