UnderScore.jsAPI記錄

Collection Functions (Arrays or Objects)

each         _.each(list, iterator, [context]) 

遍歷list中的全部元素，若是傳遞了context參數，則把iterator綁定到context對象上。iterator的參數是 (value, key, list))。返回list以方便鏈式調用。

_.each([1, 2, 3], alert);
=> alerts each number in turn...

map　　　 _.map(list, iterator, [context]) 

經過變換函數（iterator迭代器）把list中的每一個值映射到一個新的數組中（愚人碼頭注：產生一個新的數組）。

 

reduce　　_.reduce(list, iterator, memo, [context])

reduce方法把list中元素歸結爲一個單獨的數值。

reduceRight_.reduceRight(list, iterator, memo, [context]) 

find_.find(list, predicate, [context]) 

在list中逐項查找，返回第一個經過predicate迭代函數真值檢測的元素值，若是沒有值傳遞給測試迭代器將返回undefined。

filter_.filter(list, predicate, [context]) 

遍歷list中的每一個值，返回包含全部經過predicate真值檢測的元素值。

var evens = _.filter([1, 2, 3, 4, 5, 6], function(num){ return num % 2 == 0; });
=> [2, 4, 6]

where_.where(list, properties) 

遍歷list中的每個值，返回一個數組，這個數組包含包含properties所列出的屬性的全部的鍵 - 值對。

_.where(listOfPlays, {author: "Shakespeare", year: 1611});
=> [{title: "Cymbeline", author: "Shakespeare", year: 1611},
    {title: "The Tempest", author: "Shakespeare", year: 1611}]

 

findWhere_.findWhere(list, properties) 

reject_.reject(list, predicate, [context]) 

返回list中沒有經過predicate真值檢測的元素集合，與filter相反。

every_.every(list, [predicate], [context]) 

若是list中的全部元素都經過predicate的真值檢測就返回true。

some_.some(list, [predicate], [context]) 

若是list中有任何一個元素經過 predicate 的真值檢測就返回true。

contains_.contains(list, value) 

若是list包含指定的value則返回true

invoke_.invoke(list, methodName, *arguments)

在list的每一個元素上執行methodName方法。 

_.invoke([[5, 1, 7], [3, 2, 1]], 'sort');
=> [[1, 5, 7], [1, 2, 3]]

pluck_.pluck(list, propertyName) 

pluck也許是map最常使用的用例模型的簡化版本，即萃取對象數組中某屬性值，返回一個數組。

max_.max(list, [iterator], [context]) 

返回list中的最大值。

min_.min(list, [iterator], [context]) 

返回list中的最小值。

sortBy_.sortBy(list, iterator, [context]) 

返回排序後的列表數據

groupBy_.groupBy(list, iterator, [context]) 

把一個集合分組爲多個集合，經過 iterator 返回的結果進行分組. 

indexBy 
_.indexBy(list, iterator, [context])

給定一個list，和 一個用來返回一個在列表中的每一個元素鍵 的iterator 函數（或屬性名）， 返回一個每一項索引的對象。

 var stooges = [{name: 'moe', age: 40}, {name: 'larry', age: 50}, {name: 'curly', age: 60}];

_.indexBy(stooges, 'age');
=> {
  "40": {name: 'moe', age: 40},
  "50": {name: 'larry', age: 50},
  "60": {name: 'curly', age: 60}
}

countBy_.countBy(list, iterator, [context]) 

排序一個列表組成一個組，而且返回各組中的對象的數量的計數。

shuffle_.shuffle(list) 

返回一個隨機亂序的 list 副本, 

sample_.sample(list, [n]) ，

從 list中產生一個隨機樣本。列表，長度。

_.sample([1, 2, 3, 4, 5, 6]);
=> 4

_.sample([1, 2, 3, 4, 5, 6], 3);
=> [1, 6, 2]

toArray_.toArray(list) 

把list(任何能夠迭代的對象)轉換成一個數組，在轉換 arguments 對象時很是有用。

size_.size(list) 

返回list的長度。

Array Functions

first_.first(array, [n]) 

返回array（數組）的第一個元素。

initial_.initial(array, [n]) 

返回數組中除了最後一個元素外的其餘所有元素。

last_.last(array, [n]) 

返回array（數組）的最後一個元素。

rest_.rest(array, [index]) 

返回數組中除了第一個元素外的其餘所有元素。

compact_.compact(array) 

返回一個除去全部false值的 array副本。

 

flatten_.flatten(array, [shallow]) 

將一個嵌套多層的數組 array（數組） (嵌套能夠是任何層數)轉換爲只有一層的數組。 若是你傳遞 shallow參數，數組將只減小一維的嵌套。

_.flatten([1, [2], [3, [[4]]]]);
=> [1, 2, 3, 4];

_.flatten([1, [2], [3, [[4]]]], true);
=> [1, 2, 3, [[4]]];

without_.without(array, *values) 

返回一個刪除全部values值的 array副本。（愚人碼頭注：使用===表達式作相等測試。）

_.without([1, 2, 1, 0, 3, 1, 4], 0, 1);
=> [2, 3, 4]

partition_.partition(array, predicate) 

 

 

 

union_.union(*arrays) 

返回傳入的 arrays（數組）並集：按順序返回，數組的元素是惟一的，能夠傳入一個或多個 arrays（數組）。

intersection_.intersection(*arrays) 

返回傳入 arrays（數組）交集。結果中的每一個值是存在於傳入的每一個arrays（數組）裏。

 

difference_.difference(array, *others) 

相似於without，但返回的值來自array參數數組，而且不存在於other 數組.

_.difference([1, 2, 3, 4, 5], [5, 2, 10]);
=> [1, 3, 4]

uniq_.uniq(array, [isSorted], [iterator]) 

返回 array去重後的副本, 使用 === 作相等測試. 若是您肯定 array 已經排序, 那麼給isSorted 參數傳遞 true值, 此函數將運行的更快的算法. 若是要處理對象元素, 傳參iterator 來獲取要對比的屬性.

_.uniq([1, 2, 1, 3, 1, 4]);
=> [1, 2, 3, 4]

zip_.zip(*arrays) 

將 每一個相應位置的arrays的值合併在一塊兒。在合併分開保存的數據時頗有用. 若是你用來處理矩陣嵌套數組時, _.zip.apply 能夠作相似的效果。

_.zip(['moe', 'larry', 'curly'], [30, 40, 50], [true, false, false]);
=> [["moe", 30, true], ["larry", 40, false], ["curly", 50, false]]

object_.object(list, [values]) 

將數組轉換爲對象。傳遞任何一個單獨[key, value]對的列表，或者一個鍵的列表和一個值得列表。 若是存在重複鍵，最後一個值將被返回。

_.object(['moe', 'larry', 'curly'], [30, 40, 50]);
=> {moe: 30, larry: 40, curly: 50}

_.object([['moe', 30], ['larry', 40], ['curly', 50]]);
=> {moe: 30, larry: 40, curly: 50}

indexOf_.indexOf(array, value, [isSorted]) 

返回value在該 array 中的索引值，若是value不存在 array中就返回-1。使用原生的indexOf 函數，除非它失效。若是您正在使用一個大數組，你知道數組已經排序，傳遞true給isSorted將更快的用二進制搜索..,或者，傳遞一個數字做爲第三個參數，爲了在給定的索引的數組中尋找第一個匹配值。

_.indexOf([1, 2, 3], 2);
=> 1

lastIndexOf_.lastIndexOf(array, value, [fromIndex]) 

lastIndexOf_.lastIndexOf(array, value, [fromIndex]) 
返回value在該 array 中的從最後開始的索引值，若是value不存在 array中就返回-1。若是支持原生的lastIndexOf，將使用原生的lastIndexOf函數。 傳遞fromIndex將從你給定的索性值開始搜索。

_.lastIndexOf([1, 2, 3, 1, 2, 3], 2);
=> 4

sortedIndex_.sortedIndex(list, value, [iterator], [context]) 

使用二分查找肯定value在list中的位置序號，value按此序號插入能保持list原有的排序。 若是提供iterator函數，iterator將做爲list排序的依據，包括你傳遞的value 。iterator也能夠是字符串的屬性名用來排序(好比length)。

_.sortedIndex([10, 20, 30, 40, 50], 35);
=> 3

var stooges = [{name: 'moe', age: 40}, {name: 'curly', age: 60}];
_.sortedIndex(stooges, {name: 'larry', age: 50}, 'age');
=> 1

range_.range([start], stop, [step]) 

一個用來建立整數靈活編號的列表的函數，便於each 和 map循環。若是省略start則默認爲 0；step 默認爲 1.返回一個從start 到stop的整數的列表，用step來增長 （或減小）獨佔。值得注意的是，若是stop值在start前面（也就是stop值小於start值），那麼值域會被認爲是零長度，而不是負增加。-若是你要一個負數的值域 ，請使用負數step.

_.range(10);
=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
_.range(1, 11);
=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
_.range(0, 30, 5);
=> [0, 5, 10, 15, 20, 25]
_.range(0, -10, -1);
=> [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
_.range(0);
=> []

Function (uh, ahem) Functions

bind_.bind(function, object, *arguments) 

綁定函數 function 到對象 object 上, 也就是不管什麼時候調用函數, 函數裏的 this 都指向這個 object. 任意可選參數 arguments 能夠綁定到函數 function , 能夠填充函數所須要的參數, 這也被成爲 partial application。

var func = function(greeting){ return greeting + ': ' + this.name };
func = _.bind(func, {name: 'moe'}, 'hi');
func();
=> 'hi: moe'

bindAll_.bindAll(object, *methodNames) 

把methodNames參數指定的方法綁定到object上，這些方法就會在對象的上下文環境中執行。綁定函數用做事件處理函數時很是便利，不然函數被調用時this一點用也沒有。若是不設置methodNames參數，對象上的全部方法都會被綁定。

var buttonView = {
  label  : 'underscore',
  onClick: function(){ alert('clicked: ' + this.label); },
  onHover: function(){ console.log('hovering: ' + this.label); }
};
_.bindAll(buttonView, 'onClick', 'onHover');
// When the button is clicked, this.label will have the correct value.
jQuery('#underscore_button').bind('click', buttonView.onClick);

partial_.partial(function, *arguments) 

局部應用一個函數填充在任意個數的 參數，不改變其動態this值。和bind方法很相近。 You may pass _ in your list of arguments to specify an argument that should not be pre-filled, but left open to supply at call-time.

var add = function(a, b) { return a + b; };
add5 = _.partial(add, 5);
add5(10);
=> 15

memoize_.memoize(function, [hashFunction]) 

Memoizes方法能夠緩存某函數的計算結果。對於耗時較長的計算是頗有幫助的。若是傳遞了 hashFunction 參數，就用 hashFunction 的返回值做爲key存儲函數的計算結果。 hashFunction 默認使用function的第一個參數做爲key

var fibonacci = _.memoize(function(n) {
  return n < 2 ? n: fibonacci(n - 1) + fibonacci(n - 2);
});

delay_.delay(function, wait, *arguments) 

elay相似setTimeout，等待wait毫秒後調用function。若是傳遞可選的參數arguments，當函數function執行時， arguments 會做爲參數傳入。

var log = _.bind(console.log, console);
_.delay(log, 1000, 'logged later');
=> 'logged later' // Appears after one second.

defer_.defer(function, *arguments) 

延遲調用function直到當前調用棧清空爲止，相似使用延時爲0的setTimeout方法。對於執行開銷大的計算和無阻塞UI線程的HTML渲染時候很是有用。 若是傳遞arguments參數，當函數function執行時， arguments 會做爲參數傳入。

_.defer(function(){ alert('deferred'); });
// Returns from the function before the alert runs.

throttle_.throttle(function, wait, [options]) 

建立並返回一個像節流閥同樣的函數，當重複調用函數的時候，最多每隔 wait毫秒調用一次該函數。對於想控制一些觸發頻率較高的事件有幫助。（愚人碼頭注：詳見：javascript函數的throttle和debounce）

默認狀況下，throttle將在你調用的第一時間儘快執行這個function，而且，若是你在wait週期內調用任意次數的函數，都將盡快的被覆蓋。若是你想禁用第一次首先執行的話，傳遞{leading: false}，還有若是你想禁用最後一次執行的話，傳遞{trailing: false}。

var throttled = _.throttle(updatePosition, 100);
$(window).scroll(throttled);

debounce_.debounce(function, wait, [immediate]) 

返回 function 函數的防反跳版本, 將延遲函數的執行(真正的執行)在函數最後一次調用時刻的 wait 毫秒以後. 對於必須在一些輸入（可能是一些用戶操做）中止到達以後執行的行爲有幫助。 例如: 渲染一個Markdown格式的評論預覽, 當窗口中止改變大小以後從新計算佈局, 等等.

傳參 immediate 爲 true 會讓debounce 在 wait 間隔以後 觸發最後的函數調用而不是最早的函數調用.在相似不當心點了提交按鈕兩下而提交了兩次的狀況下頗有用.

var lazyLayout = _.debounce(calculateLayout, 300);
$(window).resize(lazyLayout);

once_.once(function) 

建立一個只能調用一次的函數。重複調用改進的方法也沒有效果，只會返回第一次執行時的結果。 做爲初始化函數使用時很是有用, 不用再設一個boolean值來檢查是否已經初始化完成.

var initialize = _.once(createApplication);
initialize();
initialize();
// Application is only created once.

after_.after(count, function) 

建立一個函數, 只有在運行了 count 次以後纔有效果. 在處理同組異步請求返回結果時, 若是你要確保同組裏全部異步請求完成以後才 執行這個函數, 這將很是有用.

var renderNotes = _.after(notes.length, render);
_.each(notes, function(note) {
  note.asyncSave({success: renderNotes});
});
// renderNotes is run once, after all notes have saved.

now_.now() 

一個優化的方式來得到一個當前時間的整數時間戳。 可用於實現定時/動畫功能。

_.now();
=> 1392066795351

wrap_.wrap(function, wrapper) 

將第一個函數 function 封裝到函數 wrapper 裏面, 並把函數 function 做爲第一個參數傳給 wrapper. 這樣可讓 wrapper 在 function 運行以前和以後 執行代碼, 調整參數而後附有條件地執行.

var hello = function(name) { return "hello: " + name; };
hello = _.wrap(hello, function(func) {
  return "before, " + func("moe") + ", after";
});
hello();
=> 'before, hello: moe, after'

compose_.compose(*functions)

返回函數集 functions 組合後的複合函數, 也就是一個函數執行完以後把返回的結果再做爲參數賦給下一個函數來執行. 以此類推. 在數學裏, 把函數 f(), g(), 和 h() 組合起來能夠獲得複合函數 f(g(h())).

var greet    = function(name){ return "hi: " + name; };
var exclaim  = function(statement){ return statement.toUpperCase() + "!"; };
var welcome = _.compose(greet, exclaim);
welcome('moe');
=> 'hi: MOE!'

Object Functions

keys_.keys(object) 

獲取object對象全部的屬性名稱。

_.keys({one: 1, two: 2, three: 3});
=> ["one", "two", "three"]

values_.values(object) 

返回object對象全部的屬性值。

_.values({one: 1, two: 2, three: 3});
=> [1, 2, 3]

pairs_.pairs(object) 

把一個對象轉變爲一個[key, value]形式的數組。

_.pairs({one: 1, two: 2, three: 3});
=> [["one", 1], ["two", 2], ["three", 3]]

invert_.invert(object) 

R返回一個object副本，使其鍵（keys）和值（values）對換。對於這個操做，必須確保object裏全部的值都是惟一的且能夠序列號成字符串.

_.invert({Moe: "Moses", Larry: "Louis", Curly: "Jerome"});
=> {Moses: "Moe", Louis: "Larry", Jerome: "Curly"};

functions_.functions(object) 

返回一個對象裏全部的方法名, 並且是已經排序的 — 也就是說, 對象裏每一個方法(屬性值是一個函數)的名稱.

_.functions(_);
=> ["all", "any", "bind", "bindAll", "clone", "compact", "compose" ...

extend_.extend(destination, *sources) 

複製source對象中的全部屬性覆蓋到destination對象上，而且返回 destination 對象. 複製是按順序的, 因此後面的對象屬性會把前面的對象屬性覆蓋掉(若是有重複).

_.extend({name: 'moe'}, {age: 50});
=> {name: 'moe', age: 50}

pick_.pick(object, *keys) 

返回一個object副本，只過濾出keys(有效的鍵組成的數組)參數指定的屬性值。

_.pick({name: 'moe', age: 50, userid: 'moe1'}, 'name', 'age');
=> {name: 'moe', age: 50}
_.pick({name: 'moe', age: 50, userid: 'moe1'}, function(value, key, object) {
  return _.isNumber(value);
});
=> {age: 50}

omit_.omit(object, *keys) 

返回一個object副本，只過濾出除去keys(有效的鍵組成的數組)參數指定的屬性值。

_.omit({name: 'moe', age: 50, userid: 'moe1'}, 'userid');
=> {name: 'moe', age: 50}
_.omit({name: 'moe', age: 50, userid: 'moe1'}, function(value, key, object) {
  return _.isNumber(value);
});
=> {name: 'moe', userid: 'moe1'}

defaults_.defaults(object, *defaults) 

用defaults對象填充object中undefined屬性。而且返回這個object。一旦這個屬性被填充，再使用defaults方法將不會有任何效果。

var iceCream = {flavor: "chocolate"};
_.defaults(iceCream, {flavor: "vanilla", sprinkles: "lots"});
=> {flavor: "chocolate", sprinkles: "lots"}

clone_.clone(object) 

建立 一個淺複製（淺拷貝）的克隆object。任何嵌套的對象或數組都經過引用拷貝，不會複製。

_.clone({name: 'moe'});
=> {name: 'moe'};

tap_.tap(object, interceptor) 

用 object做爲參數來調用函數interceptor，而後返回object。這種方法的主要意圖是做爲函數鏈式調用 的一環, 爲了對此對象執行操做並返回對象自己。

_.chain([1,2,3,200])
  .filter(function(num) { return num % 2 == 0; })
  .tap(alert)
  .map(function(num) { return num * num })
  .value();
=> // [2, 200] (alerted)
=> [4, 40000]

has_.has(object, key) 

 

對象是否包含給定的鍵嗎？等同於object.hasOwnProperty(key)，可是使用hasOwnProperty 函數的一個安全引用，以防意外覆蓋。

_.has({a: 1, b: 2, c: 3}, "b");
=> true

property_.property(key) 

返回一個函數，這個函數返回任何傳入的對象的key         屬性。

var moe = {name: 'moe'};
'moe' === _.property('name')(moe);
=> true

matches_.matches(attrs) 

返回一個斷言函數，這個函數會給你一個斷言             能夠用來辨別 給定的對象是否匹配指定鍵/值屬性的列表。

var ready = _.matches({selected: true, visible: true});
var readyToGoList = _.filter(list, ready);

isEqual_.isEqual(object, other) 

執行兩個對象之間的優化深度比較，肯定他們是否應被視爲相等。

var moe   = {name: 'moe', luckyNumbers: [13, 27, 34]};
var clone = {name: 'moe', luckyNumbers: [13, 27, 34]};
moe == clone;
=> false
_.isEqual(moe, clone);
=> true

isEmpty_.isEmpty(object) 

若是object 不包含任何值(沒有可枚舉的屬性)，返回true。

_.isEmpty([1, 2, 3]);
=> false
_.isEmpty({});
=> true

isElement_.isElement(object) 

若是object是一個DOM元素，返回true

_.isElement(jQuery('body')[0]);
=> true

isArray_.isArray(object) 

若是object是一個數組，返回true。

(function(){ return _.isArray(arguments); })();
=> false
_.isArray([1,2,3]);
=> true

isObject_.isObject(value) 

若是object是一個對象，返回true。須要注意的是JavaScript數組和函數是對象，字符串和數字不是。

_.isObject({});
=> true
_.isObject(1);
=> false

isArguments_.isArguments(object) 

若是object是一個參數對象，返回true

(function(){ return _.isArguments(arguments); })(1, 2, 3);
=> true
_.isArguments([1,2,3]);
=> false

isFunction_.isFunction(object) 

若是object是一個參數對象，返回true

_.isFunction(alert);
=> true

isString_.isString(object) 

若是object是一個字符串，返回true

_.isString("moe");
=> true

isNumber_.isNumber(object) 

若是object是一個數值，返回true (包括 NaN)。

_.isNumber(8.4 * 5);
=> true

isFinite_.isFinite(object) 

若是object是一個有限的數字，返回true。

_.isFinite(-101);
=> true

_.isFinite(-Infinity);
=> false

isBoolean_.isBoolean(object) 

若是object是一個布爾值，返回true。

_.isBoolean(null);
=> false

isDate_.isDate(object) 

若是object是一個日期時間，返回true

_.isDate(new Date());
=> true

isRegExp_.isRegExp(object) 

若是object是一個正則表達式，返回true

_.isRegExp(/moe/);
=> true

isNaN_.isNaN(object) 

若是object是 NaN，返回true。 
注意： 這和原生的isNaN 函數不同，若是變量是undefined，原生的isNaN 函數也會返回 true 。

_.isNaN(NaN);
=> true
isNaN(undefined);
=> true
_.isNaN(undefined);
=> false

isNull_.isNull(object) 

若是object的值是 null，返回true。

_.isNull(null);
=> true
_.isNull(undefined);
=> false

isUndefined_.isUndefined(value) 

若是value是undefined，返回true。

_.isUndefined(window.missingVariable);
=> true

Utility Functions

noConflict_.noConflict() 

放棄Underscore 的控制變量"_"。返回Underscore 對象的引用。

var underscore = _.noConflict();

identity_.identity(value) 

返回與傳入參數相等的值. 至關於數學裏的: f(x) = x
這個函數看似無用, 可是在Underscore裏被用做默認的迭代器iterator.

var moe = {name: 'moe'};
moe === _.identity(moe);
=> true

constant_.constant(value) 

建立一個函數，這個函數 返回相同的值 用來做爲_.constant的參數。

var moe = {name: 'moe'};
moe === _.constant(moe)();
=> true

times_.times(n, iterator, [context]) 

random_.random(min, max) 

返回一個min 和 max之間的隨機整數。若是你只傳遞一個參數，那麼將返回0和這個參數之間的整數。

_.random(0, 100);
=> 42

mixin_.mixin(object) 

uniqueId_.uniqueId([prefix]) 

escape_.escape(string) 

轉義HTML字符串，替換&, <, >, ", ', and /字符。

_.escape('Curly, Larry & Moe');
=> "Curly, Larry & Moe"

unescape_.unescape(string) 

和escape相反。轉義HTML字符串，替換&, &lt;, &gt;, &quot;, &#x27;, and&#x2F;字符。

_.unescape('Curly, Larry & Moe');
=> "Curly, Larry & Moe"

result_.result(object, property) 

 

若是對象 object 中的屬性 property 是函數, 則調用它, 不然, 返回它。

var object = {cheese: 'crumpets', stuff: function(){ return 'nonsense'; }};
_.result(object, 'cheese');
=> "crumpets"
_.result(object, 'stuff');
=> "nonsense"

 

template_.template(templateString, [data], [settings]) 

將 JavaScript 模板編譯爲能夠用於頁面呈現的函數, 對於經過JSON數據源生成複雜的HTML並呈現出來的操做很是有用。 模板函數可使用 <%= … %>插入變量, 也能夠用<% … %>執行任意的 JavaScript 代碼。 若是您但願插入一個值, 並讓其進行HTML轉義,請使用<%- … %>。 當你要給模板函數賦值的時候，能夠傳遞一個含有與模板對應屬性的data對象 。 若是您要寫一個一次性的, 您能夠傳對象 data 做爲第二個參數給模板 template來直接呈現, 這樣頁面會當即呈現而不是返回一個模板函數. 參數 settings 是一個哈希表包含任何能夠覆蓋的設置 _.templateSettings.

var compiled = _.template("hello: <%= name %>");
compiled({name: 'moe'});
=> "hello: moe"

var list = "<% _.each(people, function(name) { %> <li><%= name %></li> <% }); %>";
_.template(list, {people: ['moe', 'curly', 'larry']});
=> "<li>moe</li><li>curly</li><li>larry</li>"

var template = _.template("<b><%- value %></b>");
template({value: '<script>'});
=> "<b>&lt;script&gt;</b>"

Chaining

chain_.chain(obj) 

value_(obj).value() 

 

相關內容來自網絡，http://www.css88.com/doc/underscore/#each

來自@愚人碼頭