Underscore.js 1.3.3 中文注釋翻譯說明
更新時間：2015年06月25日 09:02:27 投稿：junjie
Underscore一個JavaScript實用庫,提供了一整套函數(shù)式編程的實用功能,但是沒有擴展任何JavaScript內(nèi)置對象,本文就翻譯了它的源代碼中的注釋,需要的朋友可以參考下
// 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)建一個全局對象, 在瀏覽器中表示為window對象, 在Node.js中表示global對象
var root = this;
// 保存"_"(下劃線變量)被覆蓋之前的值
// 如果出現(xiàn)命名沖突或考慮到規(guī)范, 可通過_.noConflict()方法恢復"_"被Underscore占用之前的值, 并返回Underscore對象以便重新命名
var previousUnderscore = root._;
// 創(chuàng)建一個空的對象常量, 便于內(nèi)部共享使用
var breaker = {};
// 將內(nèi)置對象的原型鏈緩存在局部變量, 方便快速調(diào)用
var ArrayProto = Array.prototype, //
ObjProto = Object.prototype, //
FuncProto = Function.prototype;
// 將內(nèi)置對象原型中的常用方法緩存在局部變量, 方便快速調(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)境中沒有提供, 則會由Underscore實現(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)建對象式的調(diào)用方式, 將返回一個Underscore包裝器, 包裝器對象的原型中包含Underscore所有方法(類似與將DOM對象包裝為一個jQuery對象)
var _ = function(obj) {
// 所有Underscore對象在內(nèi)部均通過wrapper對象進行構(gòu)造
return new wrapper(obj);
};
// 針對不同的宿主環(huán)境, 將Undersocre的命名變量存放到不同的對象中
if( typeof exports !== 'undefined') {// Node.js環(huán)境
if( typeof module !== 'undefined' && module.exports) {
exports = module.exports = _;
}
exports._ = _;
} else {// 瀏覽器環(huán)境中Underscore的命名變量被掛在window對象中
root['_'] = _;
}
// 版本聲明
_.VERSION = '1.3.3';
// 集合相關的方法(數(shù)據(jù)和對象的通用處理方法)
// --------------------
// 迭代處理器, 對集合中每一個元素執(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) {
// 對<數(shù)組>中每一個元素執(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 {
// 對<對象>中每一個元素執(zhí)行處理器方法
for(var key in obj) {
if(_.has(obj, key)) {
if(iterator.call(context, obj[key], key, obj) === breaker)
return;
}
}
}
};
// 迭代處理器, 與each方法的差異在于map會存儲每次迭代的返回值, 并作為一個新的數(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) {
// 將每次迭代處理的返回值存儲到results數(shù)組
results[results.length] = iterator.call(context, value, index, list);
});
// 返回處理結(jié)果
if(obj.length === +obj.length)
results.length = obj.length;
return results;
};
// 將集合中每個元素放入迭代處理器, 并將本次迭代的返回值作為"memo"傳遞到下一次迭代, 一般用于累計結(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) {
// 如果沒有初始值, 則將第一個元素作為初始值; 如果被處理的是對象集合, 則默認值為第一個屬性的值
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作用相似, 將逆向迭代集合中的元素(即從最后一個元素開始直到第一個元素)
_.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);
};
// 遍歷集合中的元素, 返回第一個能夠通過處理器驗證的元素
_.find = _.detect = function(obj, iterator, context) {
// result存放第一個能夠通過驗證的元素
var result;
// 通過any方法遍歷數(shù)據(jù), 并記錄通過驗證的元素
// (如果是在迭代中檢查處理器返回狀態(tài), 這里使用each方法會更合適)
any(obj, function(value, index, list) {
// 如果處理器返回的結(jié)果被轉(zhuǎn)換為Boolean類型后值為true, 則當前記錄并返回當前元素
if(iterator.call(context, value, index, list)) {
result = value;
return true;
}
});
return result;
};
// 與find方法作用類似, 但filter方法會記錄下集合中所有通過驗證的元素
_.filter = _.select = function(obj, iterator, context) {
// 用于存儲通過驗證的元素數(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);
// 迭代集合中的元素, 并將通過處理器驗證的元素放到數(shù)組中并返回
each(obj, function(value, index, list) {
if(iterator.call(context, value, index, list))
results[results.length] = value;
});
return results;
};
// 與filter方法作用相反, 即返回沒有通過處理器驗證的元素列表
_.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;
};
// 如果集合中所有元素均能通過處理器驗證, 則返回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))
// 驗證處理器的結(jié)果被轉(zhuǎn)換為Boolean類型后是否為true值
if(!( result = result && iterator.call(context, value, index, list)))
return breaker;
});
return !!result;
};
// 檢查集合中任何一個元素在被轉(zhuǎn)換為Boolean類型時, 是否為true值?或者通過處理器處理后, 是否值為true?
var any = _.some = _.any = function(obj, iterator, context) {
// 如果沒有指定處理器參數(shù), 則默認的處理器函數(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;
};
// 檢查集合中是否有值與目標參數(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方法迭代集合中的元素, 驗證元素的值和類型與目標是否完全匹配
found = any(obj, function(value) {
return value === target;
});
return found;
};
// 依次調(diào)用集合中所有元素的同名方法, 從第3個參數(shù)開始, 將被以此傳入到元素的調(diào)用方法中
// 返回一個數(shù)組, 存儲了所有方法的處理結(jié)果
_.invoke = function(obj, method) {
// 調(diào)用同名方法時傳遞的參數(shù)(從第3個參數(shù)開始)
var args = slice.call(arguments, 2);
// 依次調(diào)用每個元素的方法, 并將結(jié)果放入數(shù)組中返回
return _.map(obj, function(value) {
return (_.isFunction(method) ? method || value : value[method]).apply(value, args);
});
};
// 遍歷一個由對象列表組成的數(shù)組, 并返回每個對象中的指定屬性的值列表
_.pluck = function(obj, key) {
// 如果某一個對象中不存在該屬性, 則返回undefined
return _.map(obj, function(value) {
return value[key];
});
};
// 返回集合中的最大值, 如果不存在可比較的值, 則返回undefined
_.max = function(obj, iterator, context) {
// 如果集合是一個數(shù)組, 且沒有使用處理器, 則使用Math.max獲取最大值
// 一般會是在一個數(shù)組存儲了一系列Number類型的數(shù)據(jù)
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) {
// 如果指定了處理器參數(shù), 則比較的數(shù)據(jù)為處理器返回的值, 否則直接使用each遍歷時的默認值
var computed = iterator ? iterator.call(context, value, index, list) : value;
// 如果比較值相比上一個值要大, 則將當前值放入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;
};
// 通過隨機數(shù), 讓數(shù)組無須排列
_.shuffle = function(obj) {
// shuffled變量存儲處理過程及最終的結(jié)果數(shù)據(jù)
var shuffled = [], rand;
// 迭代集合中的元素
each(obj, function(value, index, list) {
// 生成一個隨機數(shù), 隨機數(shù)在<0-當前已處理的數(shù)量>之間
rand = Math.floor(Math.random() * (index + 1));
// 將已經(jīng)隨機得到的元素放到shuffled數(shù)組末尾
shuffled[index] = shuffled[rand];
// 在前面得到的隨機數(shù)的位置插入最新值
shuffled[rand] = value;
});
// 返回一個數(shù)組, 該數(shù)組中存儲了經(jīng)過隨機混排的集合元素
return shuffled;
};
// 對集合中元素, 按照特定的字段或值進行排列
// 相比Array.prototype.sort方法, sortBy方法支持對對象排序
_.sortBy = function(obj, val, context) {
// val應該是對象的一個屬性, 或一個處理器函數(shù), 如果是一個處理器, 則應該返回需要進行比較的數(shù)據(jù)
var iterator = _.isFunction(val) ? val : function(obj) {
return obj[val];
};
// 調(diào)用順序: _.pluck(_.map().sort());
// 調(diào)用_.map()方法遍歷集合, 并將集合中的元素放到value節(jié)點, 將元素中需要進行比較的數(shù)據(jù)放到criteria屬性中
// 調(diào)用sort()方法將集合中的元素按照criteria屬性中的數(shù)據(jù)進行順序排序
// 調(diào)用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');
};
// 將集合中的元素, 按處理器返回的key分為多個數(shù)組
_.groupBy = function(obj, val) {
var result = {};
// val將被轉(zhuǎn)換為進行分組的處理器函數(shù), 如果val不是一個Function類型的數(shù)據(jù), 則將被作為篩選元素時的key值
var iterator = _.isFunction(val) ? val : function(obj) {
return obj[val];
};
// 迭代集合中的元素
each(obj, function(value, index) {
// 將處理器的返回值作為key, 并將相同的key元素放到一個新的數(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;
};
// 將一個集合轉(zhuǎn)換一個數(shù)組并返回
// 一般用于將arguments轉(zhuǎn)換為數(shù)組, 或?qū)ο鬅o序集合轉(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();
// 將對象轉(zhuǎn)換為數(shù)組, 數(shù)組中包含對象中所有屬性的值列表(不包含對象原型鏈中的屬性)
return _.values(obj);
};
// 計算集合中元素的數(shù)量
_.size = function(obj) {
// 如果集合是一個數(shù)組, 則計算數(shù)組元素數(shù)量
// 如果集合是一個對象, 則計算對象中的屬性數(shù)量(不包含對象原型鏈中的屬性)
return _.isArray(obj) ? obj.length : _.keys(obj).length;
};
// 數(shù)組相關的方法
// ---------------
// 返回一個數(shù)組的第一個或順序指定的n個元素
_.first = _.head = _.take = function(array, n, guard) {
// 如果沒有指定參數(shù)n, 則返回第一個元素
// 如果指定了n, 則返回一個新的數(shù)組, 包含順序指定數(shù)量n個元素
// guard參數(shù)用于確定只返回第一個元素, 當guard為true時, 指定數(shù)量n無效
return (n != null) && !guard ? slice.call(array, 0, n) : array[0];
};
// 返回一個新數(shù)組, 包含除第一個元素外的其它元素, 或排除從最后一個元素開始向前指定n個元素
// 與first方法不同在于, first確定需要的元素在數(shù)組之前的位置, initial確定能排除的元素在數(shù)組最后的位置
_.initial = function(array, n, guard) {
// 如果沒有傳遞參數(shù)n, 則默認返回除最后一個元素外的其它元素
// 如果傳遞參數(shù)n, 則返回從最后一個元素開始向前的n個元素外的其它元素
// guard用于確定只返回一個元素, 當guard為true時, 指定數(shù)量n無效
return slice.call(array, 0, array.length - ((n == null) || guard ? 1 : n));
};
// 返回數(shù)組的最后一個或倒序指定的n個元素
_.last = function(array, n, guard) {
if((n != null) && !guard) {
// 計算并指定獲取的元素位置n, 直到數(shù)組末尾, 作為一個新的數(shù)組返回
return slice.call(array, Math.max(array.length - n, 0));
} else {
// 如果沒有指定數(shù)量, 或guard為true時, 只返回最后一個元素
return array[array.length - 1];
}
};
// 獲取除了第一個或指定前n個元素外的其它元素
_.rest = _.tail = function(array, index, guard) {
// 計算slice的第二個位置參數(shù), 直到數(shù)組末尾
// 如果沒有指定index, 或guard值為true, 則返回除第一個元素外的其它元素
// (index == null)值為true時, 作為參數(shù)傳遞給slice函數(shù)將被自動轉(zhuǎn)換為1
return slice.call(array, (index == null) || guard ? 1 : index);
};
// 返回數(shù)組中所有值能被轉(zhuǎn)換為true的元素, 返回一個新的數(shù)組
// 不能被轉(zhuǎn)換的值包括 false, 0, '', null, undefined, NaN, 這些值將被轉(zhuǎn)換為false
_.compact = function(array) {
return _.filter(array, function(value) {
return !!value;
});
};
// 將一個多維數(shù)組合成為一維數(shù)組, 支持深層合并
// shallow參數(shù)用于控制合并深度, 當shallow為true時, 只合并第一層, 默認進行深層合并
_.flatten = function(array, shallow) {
// 迭代數(shù)組中的每一個元素, 并將返回值作為demo傳遞給下一次迭代
return _.reduce(array, function(memo, value) {
// 如果元素依然是一個數(shù)組, 進行以下判斷:
// - 如果不進行深層合并, 則使用Array.prototype.concat將當前數(shù)組和之前的數(shù)據(jù)進行連接
// - 如果支持深層合并, 則迭代調(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;
}, []);
};
// 篩選并返回當前數(shù)組中與指定數(shù)據(jù)不相等的差異數(shù)據(jù)(可參考difference方法注釋)
_.without = function(array) {
return _.difference(array, slice.call(arguments, 1));
};
// 對數(shù)組中的數(shù)據(jù)進行去重(使用===進行比較)
// 當isSorted參數(shù)不為false時, 將依次對數(shù)組中的元素調(diào)用include方法, 檢查相同元素是否已經(jīng)被添加到返回值(數(shù)組)中
// 如果調(diào)用之前確保數(shù)組中數(shù)據(jù)按順序排列, 則可以將isSorted設為true, 它將通過與最后一個元素進行對比來排除相同值, 使用isSorted效率會高于默認的include方式
// uniq方法默認將以數(shù)組中的數(shù)據(jù)進行對比, 如果聲明iterator處理器, 則會根據(jù)處理器創(chuàng)建一個對比數(shù)組, 比較時以該數(shù)組中的數(shù)據(jù)為準, 但最終返回的唯一數(shù)據(jù)仍然是原始數(shù)組
_.uniq = _.unique = function(array, isSorted, iterator) {
// 如果使用了iterator處理器, 則先將當前數(shù)組中的數(shù)據(jù)會先經(jīng)過按迭代器處理, 并返回一個處理后的新數(shù)組
// 新數(shù)組用于作為比較的基準
var initial = iterator ? _.map(array, iterator) : array;
// 用于記錄處理結(jié)果的臨時數(shù)組
var results = [];
// 如果數(shù)組中只有2個值, 則不需要使用include方法進行比較, 將isSorted設置為true能提高運行效率
if(array.length < 3)
isSorted = true;
// 使用reduce方法迭代并累加處理結(jié)果
// initial變量是需要進行比較的基準數(shù)據(jù), 它可能是原始數(shù)組, 也可能是處理器的結(jié)果集合(如果設置過iterator)
_.reduce(initial, function(memo, value, index) {
// 如果isSorted參數(shù)為true, 則直接使用===比較記錄中的最后一個數(shù)據(jù)
// 如果isSorted參數(shù)為false, 則使用include方法與集合中的每一個數(shù)據(jù)進行對比
if( isSorted ? _.last(memo) !== value || !memo.length : !_.include(memo, value)) {
// memo記錄了已經(jīng)比較過的無重復數(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ù)組中無重復的數(shù)據(jù)
return results;
};
// union方法與uniq方法作用一致, 不同之處在于union允許在參數(shù)中傳入多個數(shù)組
_.union = function() {
// union對參數(shù)中的多個數(shù)組進行淺層合并為一個數(shù)組對象傳遞給uniq方法進行處理
return _.uniq(_.flatten(arguments, true));
};
// 獲取當前數(shù)組與其它一個或多個數(shù)組的交集元素
// 從第二個參數(shù)開始為需要進行比較的一個或多個數(shù)組
_.intersection = _.intersect = function(array) {
// rest變量記錄需要進行比較的其它數(shù)組對象
var rest = slice.call(arguments, 1);
// 使用uniq方法去除當前數(shù)組中的重復數(shù)據(jù), 避免重復計算
// 對當前數(shù)組的數(shù)據(jù)通過處理器進行過濾, 并返回符合條件(比較相同元素)的數(shù)據(jù)
return _.filter(_.uniq(array), function(item) {
// 使用every方法驗證每一個數(shù)組中都包含了需要對比的數(shù)據(jù)
// 如果所有數(shù)組中均包含對比數(shù)據(jù), 則全部返回true, 如果任意一個數(shù)組沒有包含該元素, 則返回false
return _.every(rest, function(other) {
// other參數(shù)存儲了每一個需要進行對比的數(shù)組
// item存儲了當前數(shù)組中需要進行對比的數(shù)據(jù)
// 使用indexOf方法搜索數(shù)組中是否存在該元素(可參考indexOf方法注釋)
return _.indexOf(other, item) >= 0;
});
});
};
// 篩選并返回當前數(shù)組中與指定數(shù)據(jù)不相等的差異數(shù)據(jù)
// 該函數(shù)一般用于刪除數(shù)組中指定的數(shù)據(jù), 并得到刪除后的新數(shù)組
// 該方法的作用與without相等, without方法參數(shù)形式上不允許數(shù)據(jù)被包含在數(shù)組中, 而difference方法參數(shù)形式上建議是數(shù)組(也可以和without使用相同形式的參數(shù))
_.difference = function(array) {
// 對第2個參數(shù)開始的所有參數(shù), 作為一個數(shù)組進行合并(僅合并第一層, 而并非深層合并)
// rest變量存儲驗證數(shù)據(jù), 在本方法中用于與原數(shù)據(jù)對比
var rest = _.flatten(slice.call(arguments, 1), true);
// 對合并后的數(shù)組數(shù)據(jù)進行過濾, 過濾條件是當前數(shù)組中不包含參數(shù)指定的驗證數(shù)據(jù)的內(nèi)容
// 將符合過濾條件的數(shù)據(jù)組合為一個新的數(shù)組并返回
return _.filter(array, function(value) {
return !_.include(rest, value);
});
};
// 將每個數(shù)組的相同位置的數(shù)據(jù)作為一個新的二維數(shù)組返回, 返回的數(shù)組長度以傳入?yún)?shù)中最大的數(shù)組長度為準, 其它數(shù)組的空白位置使用undefined填充
// zip方法應該包含多個參數(shù), 且每個參數(shù)應該均為數(shù)組
_.zip = function() {
// 將參數(shù)轉(zhuǎn)換為數(shù)組, 此時args是一個二維數(shù)組
var args = slice.call(arguments);
// 計算每一個數(shù)組的長度, 并返回其中最大長度值
var length = _.max(_.pluck(args, 'length'));
// 依照最大長度值創(chuàng)建一個新的空數(shù)組, 該數(shù)組用于存儲處理結(jié)果
var results = new Array(length);
// 循環(huán)最大長度, 在每次循環(huán)將調(diào)用pluck方法獲取每個數(shù)組中相同位置的數(shù)據(jù)(依次從0到最后位置)
// 將獲取到的數(shù)據(jù)存儲在一個新的數(shù)組, 放入results并返回
for(var i = 0; i < length; i++)
results[i] = _.pluck(args, "" + i);
// 返回的結(jié)果是一個二維數(shù)組
return results;
};
// 搜索一個元素在數(shù)組中首次出現(xiàn)的位置, 如果元素不存在則返回 -1
// 搜索時使用 === 對元素進行匹配
_.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;
};
// 返回一個元素在數(shù)組中最后一次出現(xiàn)的位置, 如果元素不存在則返回 -1
// 搜索時使用 === 對元素進行匹配
_.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ū)間和步長, 生成一系列整數(shù), 并作為數(shù)組返回
// start參數(shù)表示最小數(shù)
// stop參數(shù)表示最大數(shù)
// step參數(shù)表示生成多個數(shù)值之間的步長值
_.range = function(start, stop, step) {
// 參數(shù)控制
if(arguments.length <= 1) {
// 如果沒有參數(shù), 則start = 0, stop = 0, 在循環(huán)中不會生成任何數(shù)據(jù), 將返回一個空數(shù)組
// 如果有1個參數(shù), 則參數(shù)指定給stop, start = 0
stop = start || 0;
start = 0;
}
// 生成整數(shù)的步長值, 默認為1
step = arguments[2] || 1;
// 根據(jù)區(qū)間和步長計算將生成的最大值
var len = Math.max(Math.ceil((stop - start) / step), 0);
var idx = 0;
var range = new Array(len);
// 生成整數(shù)列表, 并存儲到range數(shù)組
while(idx < len) {
range[idx++] = start;
start += step;
}
// 返回列表結(jié)果
return range;
};
// 函數(shù)相關方法
// ------------------
// 創(chuàng)建一個用于設置prototype的公共函數(shù)對象
var ctor = function() {
};
// 為一個函數(shù)綁定執(zhí)行上下文, 任何情況下調(diào)用該函數(shù), 函數(shù)中的this均指向context對象
// 綁定函數(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ù)必須是一個函數(shù)(Function)類型
if(!_.isFunction(func))
throw new TypeError;
// args變量存儲了bind方法第三個開始的參數(shù)列表, 每次調(diào)用時都將傳遞給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ù)上下本綁定到對象本身, 被綁定的函數(shù)在被調(diào)用時, 上下文對象始終指向?qū)ο蟊旧?
// 該方法一般在處理對象事件時使用, 例如:
// _(obj).bindAll(); // 或_(obj).bindAll('handlerClick');
// document.addEventListener('click', obj.handlerClick);
// 在handlerClick方法中, 上下文依然是obj對象
_.bindAll = function(obj) {
// 第二個參數(shù)開始表示需要綁定的函數(shù)名稱
var funcs = slice.call(arguments, 1);
// 如果沒有指定特定的函數(shù)名稱, 則默認綁定對象本身所有類型為Function的屬性
if(funcs.length == 0)
funcs = _.functions(obj);
// 循環(huán)并將所有的函數(shù)上下本設置為obj對象本身
// each方法本身不會遍歷對象原型鏈中的方法, 但此處的funcs列表是通過_.functions方法獲取的, 它已經(jīng)包含了原型鏈中的方法
each(funcs, function(f) {
obj[f] = _.bind(obj[f], obj);
});
return obj;
};
// memoize方法將返回一個函數(shù), 該函數(shù)集成了緩存功能, 將經(jīng)過計算的值緩存到局部變量并在下次調(diào)用時直接返回
// 如果計算結(jié)果是一個龐大的對象或數(shù)據(jù), 使用時應該考慮內(nèi)存占用情況
_.memoize = function(func, hasher) {
// 用于存儲緩存結(jié)果的memo對象
var memo = {};
// hasher參數(shù)應該是一個function, 它用于返回一個key, 該key作為讀取緩存的標識
// 如果沒有指定key, 則默認使用函數(shù)的第一個參數(shù)作為key, 如果函數(shù)的第一個參數(shù)是復合數(shù)據(jù)類型, 可能會返回類似[Object object]的key, 這個key可能會造成后續(xù)計算的數(shù)據(jù)不正確
hasher || ( hasher = _.identity);
// 返回一個函數(shù), 該函數(shù)首先通過檢查緩存, 再對沒有緩存過的數(shù)據(jù)進行調(diào)用
return function() {
var key = hasher.apply(this, arguments);
return _.has(memo, key) ? memo[key] : (memo[key] = func.apply(this, arguments));
};
};
// 延時執(zhí)行一個函數(shù)
// wait單位為ms, 第3個參數(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會被放到一個單獨的函數(shù)堆棧中執(zhí)行, 執(zhí)行時間是在當前堆棧中調(diào)用的函數(shù)都被執(zhí)行完畢之后
// defer設置函數(shù)在1ms后執(zhí)行, 目的是將func函數(shù)放到單獨的堆棧中, 等待當前函數(shù)執(zhí)行完成后再執(zhí)行
// defer方法一般用于處理DOM操作的優(yōu)先級, 實現(xiàn)正確的邏輯流程和更流暢的交互體驗
_.defer = function(func) {
return _.delay.apply(_, [func, 1].concat(slice.call(arguments, 1)));
};
// 函數(shù)節(jié)流方法, throttle方法主要用于控制函數(shù)的執(zhí)行頻率, 在被控制的時間間隔內(nèi), 頻繁調(diào)用函數(shù)不會被多次執(zhí)行
// 在時間間隔內(nèi)如果多次調(diào)用了函數(shù), 時間隔截止時會自動調(diào)用一次, 不需要等到時間截止后再手動調(diào)用(自動調(diào)用時不會有返回值)
// throttle函數(shù)一般用于處理復雜和調(diào)用頻繁的函數(shù), 通過節(jié)流控制函數(shù)的調(diào)用頻率, 節(jié)省處理資源
// 例如window.onresize綁定的事件函數(shù), 或element.onmousemove綁定的事件函數(shù), 可以用throttle進行包裝
// throttle方法返回一個函數(shù), 該函數(shù)會自動調(diào)用func并進行節(jié)流控制
_.throttle = function(func, wait) {
var context, args, timeout, throttling, more, result;
// whenDone變量調(diào)用了debounce方法, 因此在多次連續(xù)調(diào)用函數(shù)時, 最后一次調(diào)用會覆蓋之前調(diào)用的定時器, 清除狀態(tài)函數(shù)也僅會被執(zhí)行一次
// whenDone函數(shù)在最后一次函數(shù)執(zhí)行的時間間隔截止時調(diào)用, 清除節(jié)流和調(diào)用過程中記錄的一些狀態(tài)
var whenDone = _.debounce(function() {
more = throttling = false;
}, wait);
// 返回一個函數(shù), 并在函數(shù)內(nèi)進行節(jié)流控制
return function() {
// 保存函數(shù)的執(zhí)行上下文和參數(shù)
context = this;
args = arguments;
// later函數(shù)在上一次函數(shù)調(diào)用時間間隔截止時執(zhí)行
var later = function() {
// 清除timeout句柄, 方便下一次函數(shù)調(diào)用
timeout = null;
// more記錄了在上一次調(diào)用至時間間隔截止之間, 是否重復調(diào)用了函數(shù)
// 如果重復調(diào)用了函數(shù), 在時間間隔截止時將自動再次調(diào)用函數(shù)
if(more)
func.apply(context, args);
// 調(diào)用whenDone, 用于在時間間隔后清除節(jié)流狀態(tài)
whenDone();
};
// timeout記錄了上一次函數(shù)執(zhí)行的時間間隔句柄
// timeout時間間隔截止時調(diào)用later函數(shù), later中將清除timeout, 并檢查是否需要再次調(diào)用函數(shù)
if(!timeout)
timeout = setTimeout(later, wait);
// throttling變量記錄上次調(diào)用的時間間隔是否已經(jīng)結(jié)束, 即是否處于節(jié)流過程中
// throttling在每次函數(shù)調(diào)用時設為true, 表示需要進行節(jié)流, 在時間間隔截止時設置為false(在whenDone函數(shù)中實現(xiàn))
if(throttling) {
// 節(jié)流過程中進行了多次調(diào)用, 在more中記錄一個狀態(tài), 表示在時間間隔截止時需要再次自動調(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, 用于在時間間隔后清除節(jié)流狀態(tài)
whenDone();
// throttling變量記錄函數(shù)調(diào)用時的節(jié)流狀態(tài)
throttling = true;
// 返回調(diào)用結(jié)果
return result;
};
};
// debounce與throttle方法類似, 用于函數(shù)節(jié)流, 它們的不同之處在于:
// -- throttle關注函數(shù)的執(zhí)行頻率, 在指定頻率內(nèi)函數(shù)只會被執(zhí)行一次;
// -- debounce函數(shù)更關注函數(shù)執(zhí)行的間隔, 即函數(shù)兩次的調(diào)用時間不能小于指定時間;
// 如果兩次函數(shù)的執(zhí)行間隔小于wait, 定時器會被清除并重新創(chuàng)建, 這意味著連續(xù)頻繁地調(diào)用函數(shù), 函數(shù)一直不會被執(zhí)行, 直到某一次調(diào)用與上一次調(diào)用的時間不小于wait毫秒
// debounce函數(shù)一般用于控制需要一段時間之后才能執(zhí)行的操作, 例如在用戶輸入完畢200ms后提示用戶, 可以使用debounce包裝一個函數(shù), 綁定到onkeyup事件
// ----------------------------------------------------------------
// @param {Function} func 表示被執(zhí)行的函數(shù)
// @param {Number} wait 表示允許的時間間隔, 在該時間范圍內(nèi)重復調(diào)用會被重新推遲wait毫秒
// @param {Boolean} immediate 表示函數(shù)調(diào)用后是否立即執(zhí)行, true為立即調(diào)用, false為在時間截止時調(diào)用
// debounce方法返回一個函數(shù), 該函數(shù)會自動調(diào)用func并進行節(jié)流控制
_.debounce = function(func, wait, immediate) {
// timeout用于記錄函數(shù)上一次調(diào)用的執(zhí)行狀態(tài)(定時器句柄)
// 當timeout為null時, 表示上一次調(diào)用已經(jīng)結(jié)束
var timeout;
// 返回一個函數(shù), 并在函數(shù)內(nèi)進行節(jié)流控制
return function() {
// 保持函數(shù)的上下文對象和參數(shù)
var context = this, args = arguments;
var later = function() {
// 設置timeout為null
// later函數(shù)會在允許的時間截止時被調(diào)用
// 調(diào)用該函數(shù)時, 表明上一次函數(shù)執(zhí)行時間已經(jīng)超過了約定的時間間隔, 此時之后再進行調(diào)用都是被允許的
timeout = null;
if(!immediate)
func.apply(context, args);
};
// 如果函數(shù)被設定為立即執(zhí)行, 且上一次調(diào)用的時間間隔已經(jīng)過去, 則立即調(diào)用函數(shù)
if(immediate && !timeout)
func.apply(context, args);
// 創(chuàng)建一個定時器用于檢查和設置函數(shù)的調(diào)用狀態(tài)
// 創(chuàng)建定時器之前先清空上一次setTimeout句柄, 無論上一次綁定的函數(shù)是否已經(jīng)被執(zhí)行
// 如果本次函數(shù)在調(diào)用時, 上一次函數(shù)執(zhí)行還沒有開始(一般是immediate設置為false時), 則函數(shù)的執(zhí)行時間會被推遲, 因此timeout句柄會被重新創(chuàng)建
clearTimeout(timeout);
// 在允許的時間截止時調(diào)用later函數(shù)
timeout = setTimeout(later, wait);
};
};
// 創(chuàng)建一個只會被執(zhí)行一次的函數(shù), 如果該函數(shù)被重復調(diào)用, 將返回第一次執(zhí)行的結(jié)果
// 該函數(shù)用于獲取和計算固定數(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);
};
};
// 返回一個函數(shù), 該函數(shù)會將當前函數(shù)作為參數(shù)傳遞給一個包裹函數(shù)
// 在包裹函數(shù)中可以通過第一個參數(shù)調(diào)用當前函數(shù), 并返回結(jié)果
// 一般用于多個流程處理函數(shù)的低耦合組合調(diào)用
_.wrap = function(func, wrapper) {
return function() {
// 將當前函數(shù)作為第一個參數(shù), 傳遞給wrapper函數(shù)
var args = [func].concat(slice.call(arguments, 0));
// 返回wrapper函數(shù)的處理結(jié)果
return wrapper.apply(this, args);
};
};
// 將多個函數(shù)組合到一起, 按照參數(shù)傳遞的順序, 后一個函數(shù)的返回值會被一次作為參數(shù)傳遞給前一個函數(shù)作為參數(shù)繼續(xù)處理
// _.compose(A, B, C); 等同于 A(B(C()));
// 該方法的缺點在于被關聯(lián)的函數(shù)處理的參數(shù)數(shù)量只能有一個, 如果需要傳遞多個參數(shù), 可以通過Array或Object復合數(shù)據(jù)類型進行組裝
_.compose = function() {
// 獲取函數(shù)列表, 所有參數(shù)需均為Function類型
var funcs = arguments;
// 返回一個供調(diào)用的函數(shù)句柄
return function() {
// 從后向前依次執(zhí)行函數(shù), 并將記錄的返回值作為參數(shù)傳遞給前一個函數(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];
};
};
// 返回一個函數(shù), 該函數(shù)作為調(diào)用計數(shù)器, 當該函數(shù)被調(diào)用times次(或超過times次)后, func函數(shù)將被執(zhí)行
// after方法一般用作異步的計數(shù)器, 例如在多個AJAX請求全部完成后需要執(zhí)行一個函數(shù), 則可以使用after在每個AJAX請求完成后調(diào)用
_.after = function(times, func) {
// 如果沒有指定或指定無效次數(shù), 則func被直接調(diào)用
if(times <= 0)
return func();
// 返回一個計數(shù)器函數(shù)
return function() {
// 每次調(diào)用計數(shù)器函數(shù)times減1, 調(diào)用times次之后執(zhí)行func函數(shù)并返回func函數(shù)的返回值
if(--times < 1) {
return func.apply(this, arguments);
}
};
};
// 對象相關方法
// ----------------
// 獲取一個對象的屬性名列表(不包含原型鏈中的屬性)
_.keys = nativeKeys ||
function(obj) {
if(obj !== Object(obj))
throw new TypeError('Invalid object');
var keys = [];
// 記錄并返回對象的所有屬性名
for(var key in obj)
if(_.has(obj, key))
keys[keys.length] = key;
return keys;
};
// 返回一個對象中所有屬性的值列表(不包含原型鏈中的屬性)
_.values = function(obj) {
return _.map(obj, _.identity);
};
// 獲取一個對象中所有屬性值為Function類型的key列表, 并按key名進行排序(包含原型鏈中的屬性)
_.functions = _.methods = function(obj) {
var names = [];
for(var key in obj) {
if(_.isFunction(obj[key]))
names.push(key);
}
return names.sort();
};
// 將一個或多個對象的屬性(包含原型鏈中的屬性), 復制到obj對象, 如果存在同名屬性則覆蓋
_.extend = function(obj) {
// each循環(huán)參數(shù)中的一個或多個對象
each(slice.call(arguments, 1), function(source) {
// 將對象中的全部屬性復制或覆蓋到obj對象
for(var prop in source) {
obj[prop] = source[prop];
}
});
return obj;
};
// 返回一個新對象, 并從obj中復制指定的屬性到新對象中
// 第2個參數(shù)開始為指定的需要復制的屬性名(支持多個參數(shù)和深層數(shù)組)
_.pick = function(obj) {
// 創(chuàng)建一個對象, 存放復制的指定屬性
var result = {};
// 從第二個參數(shù)開始合并為一個存放屬性名列表的數(shù)組
each(_.flatten(slice.call(arguments, 1)), function(key) {
// 循環(huán)屬性名列表, 如果obj中存在該屬性, 則將其復制到result對象
if( key in obj)
result[key] = obj[key];
});
// 返回復制結(jié)果
return result;
};
// 將obj中不存在或轉(zhuǎn)換為Boolean類型后值為false的屬性, 從參數(shù)中指定的一個或多個對象中復制到obj
// 一般用于給對象指定默認值
_.defaults = function(obj) {
// 從第二個參數(shù)開始可指定多個對象, 這些對象中的屬性將被依次復制到obj對象中(如果obj對象中不存在該屬性的話)
each(slice.call(arguments, 1), function(source) {
// 遍歷每個對象中的所有屬性
for(var prop in source) {
// 如果obj中不存在或?qū)傩灾缔D(zhuǎn)換為Boolean類型后值為false, 則將屬性復制到obj中
if(obj[prop] == null)
obj[prop] = source[prop];
}
});
return obj;
};
// 創(chuàng)建一個obj的副本, 返回一個新的對象, 該對象包含obj中的所有屬性和值的狀態(tài)
// clone函數(shù)不支持深層復制, 例如obj中的某個屬性存放著一個對象, 則該對象不會被復制
// 如果obj是一個數(shù)組, 則會創(chuàng)建一個相同的數(shù)組對象
_.clone = function(obj) {
// 不支持非數(shù)組和對象類型的數(shù)據(jù)
if(!_.isObject(obj))
return obj;
// 復制并返回數(shù)組或?qū)ο?
return _.isArray(obj) ? obj.slice() : _.extend({}, obj);
};
// 執(zhí)行一個函數(shù), 并將obj作為參數(shù)傳遞給該函數(shù), 函數(shù)執(zhí)行完畢后最終返回obj對象
// 一般在創(chuàng)建一個方法鏈的時候會使用tap方法, 例如:
// _(obj).chain().tap(click).tap(mouseover).tap(mouseout);
_.tap = function(obj, interceptor) {
interceptor(obj);
return obj;
};
// eq函數(shù)只在isEqual方法中調(diào)用, 用于比較兩個數(shù)據(jù)的值是否相等
// 與 === 不同在于, eq更關注數(shù)據(jù)的值
// 如果進行比較的是兩個復合數(shù)據(jù)類型, 不僅僅比較是否來自同一個引用, 且會進行深層比較(對兩個對象的結(jié)構(gòu)和數(shù)據(jù)進行比較)
function eq(a, b, stack) {
// 檢查兩個簡單數(shù)據(jù)類型的值是否相等
// 對于復合數(shù)據(jù)類型, 如果它們來自同一個引用, 則認為其相等
// 如果被比較的值其中包含0, 則檢查另一個值是否為-0, 因為 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, 將判斷兩個值的數(shù)據(jù)類型是否相等(因為null與undefined, false, 0, 空字符串, 在非嚴格比較下值是相等的)
if(a == null || b == null)
return a === b;
// 如果進行比較的數(shù)據(jù)是一個Underscore封裝的對象(具有_chain屬性的對象被認為是Underscore對象)
// 則將對象解封后獲取本身的數(shù)據(jù)(通過_wrapped訪問), 然后再對本身的數(shù)據(jù)進行比較
// 它們的關系類似與一個jQuery封裝的DOM對象, 和瀏覽器本身創(chuàng)建的DOM對象
if(a._chain)
a = a._wrapped;
if(b._chain)
b = b._wrapped;
// 如果對象提供了自定義的isEqual方法(此處的isEqual方法并非Undersocre對象的isEqual方法, 因為在上一步已經(jīng)對Undersocre對象進行了解封)
// 則使用對象自定義的isEqual方法與另一個對象進行比較
if(a.isEqual && _.isFunction(a.isEqual))
return a.isEqual(b);
if(b.isEqual && _.isFunction(b.isEqual))
return b.isEqual(a);
// 對兩個數(shù)據(jù)的數(shù)據(jù)類型進行驗證
// 獲取對象a的數(shù)據(jù)類型(通過Object.prototype.toString方法)
var className = toString.call(a);
// 如果對象a的數(shù)據(jù)類型與對象b不匹配, 則認為兩個數(shù)據(jù)值也不匹配
if(className != toString.call(b))
return false;
// 執(zhí)行到此處, 可以確保需要比較的兩個數(shù)據(jù)均為復合數(shù)據(jù)類型, 且數(shù)據(jù)類型相等
// 通過switch檢查數(shù)據(jù)的數(shù)據(jù)類型, 針對不同數(shù)據(jù)類型進行不同的比較
// (此處不包括對數(shù)組和對象類型, 因為它們可能包含更深層次的數(shù)據(jù), 將在后面進行深層比較)
switch (className) {
case '[object String]':
// 如果被比較的是字符串類型(其中a的是通過new String()創(chuàng)建的字符串)
// 則將B轉(zhuǎn)換為String對象后進行匹配(這里匹配并非進行嚴格的數(shù)據(jù)類型檢查, 因為它們并非來自同一個對象的引用)
// 在調(diào)用 == 進行比較時, 會自動調(diào)用對象的toString()方法, 返回兩個簡單數(shù)據(jù)類型的字符串
return a == String(b);
case '[object Number]':
// 通過+a將a轉(zhuǎn)成一個Number, 如果a被轉(zhuǎn)換之前與轉(zhuǎn)換之后不相等, 則認為a是一個NaN類型
// 因為NaN與NaN是不相等的, 因此當a值為NaN時, 無法簡單地使用a == b進行匹配, 而是用相同的方法檢查b是否為NaN(即 b != +b)
// 當a值是一個非NaN的數(shù)據(jù)時, 則檢查a是否為0, 因為當b為-0時, 0 === -0是成立的(實際上它們在邏輯上屬于兩個不同的數(shù)據(jù))
return a != +a ? b != +b : (a == 0 ? 1 / a == 1 / b : a == +b);
case '[object Date]':
// 對日期類型沒有使用return或break, 因此會繼續(xù)執(zhí)行到下一步(無論數(shù)據(jù)類型是否為Boolean類型, 因為下一步將對Boolean類型進行檢查)
case '[object Boolean]':
// 將日期或布爾類型轉(zhuǎn)換為數(shù)字
// 日期類型將轉(zhuǎn)換為數(shù)值類型的時間戳(無效的日期格式將被換轉(zhuǎn)為NaN)
// 布爾類型中, true被轉(zhuǎn)換為1, false被轉(zhuǎn)換為0
// 比較兩個日期或布爾類型被轉(zhuǎn)換為數(shù)字后是否相等
return +a == +b;
case '[object RegExp]':
// 正則表達式類型, 通過source訪問表達式的字符串形式
// 檢查兩個表達式的字符串形式是否相等
// 檢查兩個表達式的全局屬性是否相同(包括g, i, m)
// 如果完全相等, 則認為兩個數(shù)據(jù)相等
return a.source == b.source && a.global == b.global && a.multiline == b.multiline && a.ignoreCase == b.ignoreCase;
}
// 當執(zhí)行到此時, ab兩個數(shù)據(jù)應該為類型相同的對象或數(shù)組類型
if( typeof a != 'object' || typeof b != 'object')
return false;
// stack(堆)是在isEqual調(diào)用eq函數(shù)時內(nèi)部傳遞的空數(shù)組, 在后面比較對象和數(shù)據(jù)的內(nèi)部迭代中調(diào)用eq方法也會傳遞
// length記錄堆的長度
var length = stack.length;
while(length--) {
// 如果堆中的某個對象與數(shù)據(jù)a匹配, 則認為相等
if(stack[length] == a)
return true;
}
// 將數(shù)據(jù)a添加到堆中
stack.push(a);
// 定義一些局部變量
var size = 0, result = true;
// 通過遞歸深層比較對象和數(shù)組
if(className == '[object Array]') {
// 被比較的數(shù)據(jù)為數(shù)組類型
// size記錄數(shù)組的長度
// result比較兩個數(shù)組的長度是否一致, 如果長度不一致, 則方法的最后將返回result(即false)
size = a.length;
result = size == b.length;
// 如果兩個數(shù)組的長度一致
if(result) {
// 調(diào)用eq方法對數(shù)組中的元素進行迭代比較(如果數(shù)組中包含二維數(shù)組或?qū)ο? eq方法會進行深層比較)
while(size--) {
// 在確保兩個數(shù)組都存在當前索引的元素時, 調(diào)用eq方法深層比較(將堆數(shù)據(jù)傳遞給eq方法)
// 將比較的結(jié)果存儲到result變量, 如果result為false(即在比較中得到某個元素的數(shù)據(jù)不一致), 則停止迭代
if(!( result = size in a == size in b && eq(a[size], b[size], stack)))
break;
}
}
} else {
// 被比較的數(shù)據(jù)為對象類型
// 如果兩個對象不是同一個類的實例(通過constructor屬性比較), 則認為兩個對象不相等
if('constructor' in a != 'constructor' in b || a.constructor != b.constructor)
return false;
// 深層比較兩個對象中的數(shù)據(jù)
for(var key in a) {
if(_.has(a, key)) {
// size用于記錄比較過的屬性數(shù)量, 因為這里遍歷的是a對象的屬性, 并比較b對象中該屬性的數(shù)據(jù)
// 當b對象中的屬性數(shù)量多余a對象時, 此處的邏輯成立, 但兩個對象并不相等
size++;
// 迭代調(diào)用eq方法, 深層比較兩個對象中的屬性值
// 將比較的結(jié)果記錄到result變量, 當比較到不相等的數(shù)據(jù)時停止迭代
if(!( result = _.has(b, key) && eq(a[key], b[key], stack)))
break;
}
}
// 深層比較完畢, 這里已經(jīng)可以確保在對象a中的所有數(shù)據(jù), 對象b中也存在相同的數(shù)據(jù)
// 根據(jù)size(對象屬性長度)檢查對象b中的屬性數(shù)量是否與對象a相等
if(result) {
// 遍歷對象b中的所有屬性
for(key in b) {
// 當size已經(jīng)到0時(即對象a中的屬性數(shù)量已經(jīng)遍歷完畢), 而對象b中還存在有屬性, 則對象b中的屬性多于對象a
if(_.has(b, key) && !(size--))
break;
}
// 當對象b中的屬性多于對象a, 則認為兩個對象不相等
result = !size;
}
}
// 函數(shù)執(zhí)行完畢時, 從堆中移除第一個數(shù)據(jù)(在比較對象或數(shù)組時, 會迭代eq方法, 堆中可能存在多個數(shù)據(jù))
stack.pop();
// 返回的result記錄了最終的比較結(jié)果
return result;
}
// 對兩個數(shù)據(jù)的值進行比較(支持復合數(shù)據(jù)類型), 內(nèi)部函數(shù)eq的外部方法
_.isEqual = function(a, b) {
return eq(a, b, []);
};
// 檢查數(shù)據(jù)是否為空值, 包含'', false, 0, null, undefined, NaN, 空數(shù)組(數(shù)組長度為0)和空對象(對象本身沒有任何屬性)
_.isEmpty = function(obj) {
// obj被轉(zhuǎn)換為Boolean類型后值為false
if(obj == null)
return true;
// 檢查對象或字符串長度是否為0
if(_.isArray(obj) || _.isString(obj))
return obj.length === 0;
// 檢查對象(使用for in循環(huán)時將首先循環(huán)對象本身的屬性, 其次是原型鏈中的屬性), 因此如果第一個屬性是屬于對象本身的, 那么該對象不是一個空對象
for(var key in obj)
if(_.has(obj, key))
return false;
// 所有數(shù)據(jù)類型均沒有通過驗證, 是一個空數(shù)據(jù)
return true;
};
// 驗證對象是否是一個DOM對象
_.isElement = function(obj) {
return !!(obj && obj.nodeType == 1);
};
// 驗證對象是否是一個數(shù)組類型, 優(yōu)先調(diào)用宿主環(huán)境提供的isArray方法
_.isArray = nativeIsArray ||
function(obj) {
return toString.call(obj) == '[object Array]';
};
// 驗證對象是否是一個復合數(shù)據(jù)類型的對象(即非基本數(shù)據(jù)類型String, Boolean, Number, null, undefined)
// 如果基本數(shù)據(jù)類型通過new進行創(chuàng)建, 則也屬于對象類型
_.isObject = function(obj) {
return obj === Object(obj);
};
// 檢查一個數(shù)據(jù)是否是一個arguments參數(shù)對象
_.isArguments = function(obj) {
return toString.call(obj) == '[object Arguments]';
};
// 驗證isArguments函數(shù), 如果運行環(huán)境無法正常驗證arguments類型的數(shù)據(jù), 則重新定義isArguments方法
if(!_.isArguments(arguments)) {
// 對于環(huán)境無法通過toString驗證arguments類型的, 則通過調(diào)用arguments獨有的callee方法來進行驗證
_.isArguments = function(obj) {
// callee是arguments的一個屬性, 指向?qū)rguments所屬函數(shù)自身的引用
return !!(obj && _.has(obj, 'callee'));
};
}
// 驗證對象是否是一個函數(shù)類型
_.isFunction = function(obj) {
return toString.call(obj) == '[object Function]';
};
// 驗證對象是否是一個字符串類型
_.isString = function(obj) {
return toString.call(obj) == '[object String]';
};
// 驗證對象是否是一個數(shù)字類型
_.isNumber = function(obj) {
return toString.call(obj) == '[object Number]';
};
// 檢查一個數(shù)字是否為有效數(shù)字且有效范圍(Number類型, 值在負無窮大 - 正無窮大之間)
_.isFinite = function(obj) {
return _.isNumber(obj) && isFinite(obj);
};
// 檢查數(shù)據(jù)是否為NaN類型(所有數(shù)據(jù)中只有NaN與NaN不相等)
_.isNaN = function(obj) {
return obj !== obj;
};
// 檢查數(shù)據(jù)是否時Boolean類型
_.isBoolean = function(obj) {
// 支持字面量和對象形式的Boolean數(shù)據(jù)
return obj === true || obj === false || toString.call(obj) == '[object Boolean]';
};
// 檢查數(shù)據(jù)是否是一個Date類型
_.isDate = function(obj) {
return toString.call(obj) == '[object Date]';
};
// 檢查數(shù)據(jù)是否是一個正則表達式類型
_.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;
};
// 檢查一個屬性是否屬于對象本身, 而非原型鏈中
_.has = function(obj, key) {
return hasOwnProperty.call(obj, key);
};
// 工具函數(shù)
// -----------------
// 放棄_(下劃線)命名的Underscore對象, 并返回Underscore對象, 一般用于避免命名沖突或規(guī)范命名方式
// 例如:
// var us = _.noConflict(); // 取消_(下劃線)命名, 并將Underscore對象存放于us變量中
// console.log(_); // _(下劃線)已經(jīng)無法再訪問Underscore對象, 而恢復為Underscore定義前的值
_.noConflict = function() {
// previousUnderscore變量記錄了Underscore定義前_(下劃線)的值
root._ = previousUnderscore;
return this;
};
// 返回與參數(shù)相同的值, 一般用于將一個數(shù)據(jù)的獲取方式轉(zhuǎn)換為函數(shù)獲取方式(內(nèi)部用于構(gòu)建方法時作為默認處理器函數(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實體, 包含 & < > " ' \
_.escape = function(string) {
return ('' + string).replace(/&/g, '&').replace(/</g, '<').replace(/>/g, '>').replace(/"/g, '"').replace(/'/g, ''').replace(/\//g, '/');
};
// 指定一個對象的屬性, 返回該屬性對應的值, 如果該屬性對應的是一個函數(shù), 則會執(zhí)行該函數(shù)并返回結(jié)果
_.result = function(object, property) {
if(object == null)
return null;
// 獲取對象的值
var value = object[property];
// 如果值是一個函數(shù), 則執(zhí)行并返回, 否則將直接返回
return _.isFunction(value) ? value.call(object) : value;
};
// 添加一系列自定義方法到Underscore對象中, 用于擴展Underscore插件
_.mixin = function(obj) {
// obj是一個集合一系列自定義方法的對象, 此處通過each遍歷對象的方法
each(_.functions(obj), function(name) {
// 通過addToWrapper函數(shù)將自定義方法添加到Underscore構(gòu)建的對象中, 用于支持對象式調(diào)用
// 同時將方法添加到 _ 本身, 用于支持函數(shù)式調(diào)用
addToWrapper(name, _[name] = obj[name]);
});
};
// 獲取一個全局唯一標識, 標識從0開始累加
var idCounter = 0;
// prefix表示標識的前綴, 如果沒有指定前綴則直接返回標識, 一般用于給對象或DOM創(chuàng)建唯一ID
_.uniqueId = function(prefix) {
var id = idCounter++;
return prefix ? prefix + id : id;
};
// 定義模板的界定符號, 在template方法中使用
_.templateSettings = {
// JavaScript可執(zhí)行代碼的界定符
evaluate : /<%([\s\S]+?)%>/g,
// 直接輸出變量的界定符
interpolate : /<%=([\s\S]+?)%>/g,
// 需要將HTML輸出為字符串(將特殊符號轉(zhuǎn)換為字符串形式)的界定符
escape : /<%-([\s\S]+?)%>/g
};
var noMatch = /.^/;
// escapes對象記錄了需要進行相互換轉(zhuǎn)的特殊符號與字符串形式的對應關系, 在兩者進行相互轉(zhuǎn)換時作為索引使用
// 首先根據(jù)字符串形式定義特殊字符
var escapes = {
'\\' : '\\',
"'" : "'",
'r' : '\r',
'n' : '\n',
't' : '\t',
'u2028' : '\u2028',
'u2029' : '\u2029'
};
// 遍歷所有特殊字符字符串, 并以特殊字符作為key記錄字符串形式
for(var p in escapes)
escapes[escapes[p]] = p;
// 定義模板中需要替換的特殊符號, 包含反斜杠, 單引號, 回車符, 換行符, 制表符, 行分隔符, 段落分隔符
// 在將字符串中的特殊符號轉(zhuǎn)換為字符串形式時使用
var escaper = /\\|'|\r|\n|\t|\u2028|\u2029/g;
// 在將字符串形式的特殊符號進行反轉(zhuǎn)(替換)時使用
var unescaper = /\\(\\|'|r|n|t|u2028|u2029)/g;
// 反轉(zhuǎn)字符串中的特殊符號
// 在模板中涉及到需要執(zhí)行的JavaScript源碼, 需要進行特殊符號反轉(zhuǎn), 否則如果以HTML實體或字符串形式出現(xiàn), 會拋出語法錯誤
var unescape = function(code) {
return code.replace(unescaper, function(match, escape) {
return escapes[escape];
});
};
// Underscore模板解析方法, 用于將數(shù)據(jù)填充到一個模板字符串中
// 模板解析流程:
// 1. 將模板中的特殊符號轉(zhuǎn)換為字符串
// 2. 解析escape形式標簽, 將內(nèi)容解析為HTML實體
// 3. 解析interpolate形式標簽, 輸出變量
// 4. 解析evaluate形式標簽, 創(chuàng)建可執(zhí)行的JavaScript代碼
// 5. 生成一個處理函數(shù), 該函數(shù)在得到數(shù)據(jù)后可直接填充到模板并返回填充后的字符串
// 6. 根據(jù)參數(shù)返回填充后的字符串或處理函數(shù)的句柄
// -------------------
// 在模板體內(nèi), 可通過argments獲取2個參數(shù), 分別為填充數(shù)據(jù)(名稱為obj)和Underscore對象(名稱為_)
_.template = function(text, data, settings) {
// 模板配置, 如果沒有指定配置項, 則使用templateSettings中指定的配置項
settings = _.defaults(settings || {}, _.templateSettings);
// 開始將模板解析為可執(zhí)行源碼
var source = "__p+='" + text.replace(escaper, function(match) {
// 將特殊符號轉(zhuǎn)移為字符串形式
return '\\' + escapes[match];
}).replace(settings.escape || noMatch, function(match, code) {
// 解析escape形式標簽 <%- %>, 將變量中包含的HTML通過_.escape函數(shù)轉(zhuǎn)換為HTML實體
return "'+\n_.escape(" + unescape(code) + ")+\n'";
}).replace(settings.interpolate || noMatch, function(match, code) {
// 解析interpolate形式標簽 <%= %>, 將模板內(nèi)容作為一個變量與其它字符串連接起來, 則會作為一個變量輸出
return "'+\n(" + unescape(code) + ")+\n'";
}).replace(settings.evaluate || noMatch, function(match, code) {
// 解析evaluate形式標簽 <% %>, evaluate標簽中存儲了需要執(zhí)行的JavaScript代碼, 這里結(jié)束當前的字符串拼接, 并在新的一行作為JavaScript語法執(zhí)行, 并將后面的內(nèi)容再次作為字符串的開始, 因此evaluate標簽內(nèi)的JavaScript代碼就能被正常執(zhí)行
return "';\n" + unescape(code) + "\n;__p+='";
}) + "';\n";
if(!settings.variable)
source = 'with(obj||{}){\n' + source + '}\n';
source = "var __p='';" + "var print=function(){__p+=Array.prototype.join.call(arguments, '')};\n" + source + "return __p;\n";
// 創(chuàng)建一個函數(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ù), 則返回一個函數(shù), 該函數(shù)用于將接收到的數(shù)據(jù)替換到模板
// 如果在程序中會多次填充相同模板, 那么在第一次調(diào)用時建議不指定填充數(shù)據(jù), 在獲得處理函數(shù)的引用后, 再直接調(diào)用會提高運行效率
var template = function(data) {
return render.call(this, data, _);
};
// 將創(chuàng)建的源碼字符串添加到函數(shù)對象中, 一般用于調(diào)試和測試
template.source = 'function(' + (settings.variable || 'obj') + '){\n' + source + '}';
// 沒有指定填充數(shù)據(jù)的情況下, 返回處理函數(shù)句柄
return template;
};
// 支持Underscore對象的方法鏈操作, 可參考 wrapper.prototype.chain
_.chain = function(obj) {
return _(obj).chain();
};
// Underscore對象封裝相關方法
// ---------------
// 創(chuàng)建一個包裝器, 將一些原始數(shù)據(jù)進行包裝
// 所有的undersocre對象, 內(nèi)部均通過wrapper函數(shù)進行構(gòu)造和封裝
// Underscore與wrapper的內(nèi)部關系:
// -內(nèi)部定義變量_, 將Underscore相關的方法添加到_, 這樣就可以支持函數(shù)式的調(diào)用, 如_.bind()
// -內(nèi)部定義wrapper類, 將_的原型對象指向wrapper類的原型
// -將Underscore相關的方法添加到wrapper原型, 創(chuàng)建的_對象就具備了Underscore的方法
// -將Array.prototype相關方法添加到wrapper原型, 創(chuàng)建的_對象就具備了Array.prototype中的方法
// -new _()時實際創(chuàng)建并返回了一個wrapper()對象, 并將原始數(shù)組存儲到_wrapped變量, 并將原始值作為第一個參數(shù)調(diào)用對應方法
var wrapper = function(obj) {
// 原始數(shù)據(jù)存放在包裝對象的_wrapped屬性中
this._wrapped = obj;
};
// 將Underscore的原型對象指向wrapper的原型, 因此通過像wrapper原型中添加方法, Underscore對象也會具備同樣的方法
_.prototype = wrapper.prototype;
// 返回一個對象, 如果當前Underscore調(diào)用了chain()方法(即_chain屬性為true), 則返回一個被包裝的Underscore對象, 否則返回對象本身
// result函數(shù)用于在構(gòu)造方法鏈時返回Underscore的包裝對象
var result = function(obj, chain) {
return chain ? _(obj).chain() : obj;
};
// 將一個自定義方法添加到Underscore對象中(實際是添加到wrapper的原型中, 而Underscore對象的原型指向了wrapper的原型)
var addToWrapper = function(name, func) {
// 向wrapper原型中添加一個name函數(shù), 該函數(shù)調(diào)用func函數(shù), 并支持了方法鏈的處理
wrapper.prototype[name] = function() {
// 獲取func函數(shù)的參數(shù), 并將當前的原始數(shù)據(jù)添加到第一個參數(shù)
var args = slice.call(arguments);
unshift.call(args, this._wrapped);
// 執(zhí)行函數(shù)并返回結(jié)果, 并通過result函數(shù)對方法鏈進行封裝, 如果當前調(diào)用了chain()方法, 則返回封裝后的Underscore對象, 否則返回對象本身
return result(func.apply(_, args), this._chain);
};
};
// 將內(nèi)部定義的_(下劃線, 即Underscore方法集合對象)中的方法復制到wrapper的原型鏈中(即Underscore的原型鏈中)
// 這是為了在構(gòu)造對象式調(diào)用的Underscore對象時, 這些對象也會具有內(nèi)部定義的Underscore方法
_.mixin(_);
// 將Array.prototype中的相關方法添加到Underscore對象中, 因此在封裝后的Underscore對象中也可以直接調(diào)用Array.prototype中的方法
// 如: _([]).push()
each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {
// 獲取Array.prototype中對應方法的引用
var method = ArrayProto[name];
// 將該方法添加到Underscore對象中(實際是添加到wrapper的原型對象, 因此在創(chuàng)建Underscore對象時同時具備了該方法)
wrapper.prototype[name] = function() {
// _wrapped變量中存儲Underscore對象的原始值
var wrapped = this._wrapped;
// 調(diào)用Array對應的方法并返回結(jié)果
method.apply(wrapped, arguments);
var length = wrapped.length;
if((name == 'shift' || name == 'splice') && length === 0)
delete wrapped[0];
// 即使是對于Array中的方法, Underscore同樣支持方法鏈操作
return result(wrapped, this._chain);
};
});
// 作用同于上一段代碼, 將數(shù)組中的一些方法添加到Underscore對象, 并支持了方法鏈操作
// 區(qū)別在于上一段代碼所添加的函數(shù), 均返回Array對象本身(也可能是封裝后的Array), concat, join, slice方法將返回一個新的Array對象(也可能是封裝后的Array)
each(['concat', 'join', 'slice'], function(name) {
var method = ArrayProto[name];
wrapper.prototype[name] = function() {
return result(method.apply(this._wrapped, arguments), this._chain);
};
});
// 對Underscore對象進行鏈式操作的聲明方法
wrapper.prototype.chain = function() {
// this._chain用來標示當前對象是否使用鏈式操作
// 對于支持方法鏈操作的數(shù)據(jù), 一般在具體方法中會返回一個Underscore對象, 并將原始值存放在_wrapped屬性中, 也可以通過value()方法獲取原始值
this._chain = true;
return this;
};
// 返回被封裝的Underscore對象的原始值(存放在_wrapped屬性中)
wrapper.prototype.value = function() {
return this._wrapped;
};
}).call(this);
您可能感興趣的文章:
相關文章
這篇文章主要介紹了JavaScript的strict模式與with關鍵字,需要的朋友可以參考下2014-02-02
在添加網(wǎng)頁到收藏夾之后會看到一個漂亮的圖標，很好奇是怎么實現(xiàn)的呢？下面小編就給大家講解下網(wǎng)頁收藏夾顯示ICO圖標（代碼少），有需要的小伙伴可以來參考下2015-08-08
平時工作中，無論是調(diào)試 javascript 代碼還是進行頁面提示，我們都會經(jīng)常使用 javascript 的對話框。除了創(chuàng)建明確不使用狀態(tài)欄的瀏覽器窗口，每個瀏覽器窗口的底部都有一個狀態(tài)欄，用來向用戶顯示一些特定的消息。2009-10-10
下面小編就為大家?guī)硪黄仙Ｕ?關于JavaScript的類的繼承。小編覺得挺不錯的，現(xiàn)在就分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2016-06-06
深入理解JavaScript系列（50）：Function模式（下篇）
這篇文章主要介紹了深入理解JavaScript系列（50）：Function模式（下篇）,本篇我們介紹的一些模式稱為初始化模式和性能模式,主要是用在初始化以及提高性能方面,一些模式之前已經(jīng)提到過，這里只是做一下總結(jié),需要的朋友可以參考下2015-03-03
JavaScript方法和技巧大全...2006-12-12
這篇文章主要介紹了HTML form表單提交方法案例詳解,本篇文章通過簡要的案例,講解了該項技術(shù)的了解與使用,以下就是詳細內(nèi)容,需要的朋友可以參考下2021-08-08![[轉(zhuǎn)]JS寶典學習筆記](http://img.jbzj.com/images/xgimg/bcimg7.png)
[轉(zhuǎn)]JS寶典學習筆記...2007-02-02
初學者經(jīng)常碰到的,即獲取HTML元素集合，循環(huán)給元素添加事件。在事件響應函數(shù)中(event handler)獲取對應的索引。但每次獲取的都是最后一次循環(huán)的索引。原因是初學者并未理解JavaScript的閉包特性。2014-11-11
判斷瀏覽器的js代碼...2007-01-01