underscore知识点

最新推荐文章于 2023-05-16 16:49:13 发布

cily_undefined

最新推荐文章于 2023-05-16 16:49:13 发布

阅读量615

点赞数

文章标签：前端插件

本文详细介绍了Underscore.js库的功能，包括集合、数组、函数、对象操作及实用工具，展示了如何使用其丰富的API进行高效编程，适用于前端和后端开发。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、安装（Installation）

Node.js --> npm install underscore

Meteor.js --> meteor add underscore

Require.js --> require(["underscore"], ...

Bower bower --> install underscore

Component --> component install jashkenas/underscore

二、集合函数 (数组或对象)

1、each

语法：_.each(list, iteratee, [context])

说明：遍历list中的所有元素，按顺序用每个元素当做参数调用 iteratee 函数。如果传递了context参数，则把iteratee绑定到context对象上。每次调用iteratee都会传递三个参数：(element, index, list)。如果list是个JavaScript对象，iteratee的参数是 (value, key, list))。返回list以方便链式调用。

例子：

_.each([1, 2, 3], alert);

=> alerts each number in turn...

_.each({one: 1, two: 2, three: 3}, alert);

=> alerts each number value in turn...

2、map

语法：_.map(list, iteratee, [context])

说明：通过对list里的每个元素调用转换函数(iteratee迭代器)生成一个与之相对应的数组。iteratee传递三个参数：value，然后是迭代 index(或 key 愚人码头注：如果list是个JavaScript对象是，这个参数就是key)，最后一个是引用指向整个list。

例子：

_.map([1, 2, 3], function(num){ return num * 3; });

=> [3, 6, 9]

_.map({one: 1, two: 2, three: 3}, function(num, key){ return num * 3; });

=> [3, 6, 9]

_.map([[1, 2], [3, 4]], _.first);

=> [1, 3]

3、reduce

语法：_.reduce(list, iteratee, [memo], [context])

说明：别名为 inject 和 foldl, reduce方法把list中元素归结为一个单独的数值。Memo是reduce函数的初始值，会被每一次成功调用iteratee函数的返回值所取代。这个迭代传递4个参数：memo,value 和迭代的index（或者 key）和最后一个引用的整个 list。

如果没有memo传递给reduce的初始调用，iteratee不会被列表中的第一个元素调用。第一个元素将取代memo参数传递给列表中下一个元素调用的iteratee函数。

例子：

var sum = _.reduce([1, 2, 3], function(memo, num){ return memo + num; }, 0);

=> 6

4、reduceRight

语法：_.reduceRight(list, iteratee, memo, [context])

说明：reducRight是从右侧开始组合元素的reduce函数， Foldr在 JavaScript 中不像其它有惰性求值的语言那么有用（愚人码头注：lazy evaluation：一种求值策略，只有当表达式的值真正需要时才对表达式进行计算）。

例子：

var list = [[0, 1], [2, 3], [4, 5]];

var flat = _.reduceRight(list, function(a, b) { return a.concat(b); }, []);

=> [4, 5, 2, 3, 0, 1]

// concat() 方法用于连接两个或多个数组。

5、find

语法：_.find(list, predicate, [context])

说明：在list中逐项查找，返回第一个通过predicate迭代函数真值检测的元素值，如果没有元素通过检测则返回 undefined。如果找到匹配的元素，函数将立即返回，不会遍历整个list。

例子：

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

=> 2

6、filter

语法：_.filter(list, predicate, [context])

说明：遍历list中的每个值，返回所有通过predicate真值检测的元素所组成的数组。（愚人码头注：如果存在原生filter方法，则用原生的filter方法。）

例子：

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

=> [2, 4, 6]

7、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}]

8、findWhere

语法：_.findWhere(list, properties)

说明：遍历整个list，返回匹配 properties参数所列出的所有键 - 值对的第一个值。

如果没有找到匹配的属性，或者list是空的，那么将返回undefined。

例子：

_.findWhere(publicServicePulitzers, {newsroom: "The New York Times"});

=> {year: 1918, newsroom: "The New York Times",

reason: "For its public service in publishing in full so many official reports, documents and speeches by European statesmen relating to the progress and conduct of the war."}

9、reject

语法：_.reject(list, predicate, [context])

说明：返回list中没有通过predicate真值检测的元素集合，与filter相反

例子：

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

=> [1, 3, 5]

10、every

语法：_.every(list, [predicate], [context])

说明：如果list中的所有元素都通过predicate的真值检测就返回true。（愚人码头注：如果存在原生的every方法，就使用原生的every。）

例子：

_.every([true, 1, null, 'yes'], _.identity);

=> false

11、some

语法：_.some(list, [predicate], [context])

说明：如果list中有任何一个元素通过 predicate 的真值检测就返回true。一旦找到了符合条件的元素, 就直接中断对list的遍历. （愚人码头注：如果存在原生的some方法，就使用原生的some。）

例子：

_.some([null, 0, 'yes', false]);

=> true

12、contains

语法：_.contains(list, value, [fromIndex])

说明：如果list包含指定的value则返回true（愚人码头注：使用===检测）。如果list 是数组，内部使用indexOf判断。使用fromIndex来给定开始检索的索引位置。

例子：

_.contains([1, 2, 3], 3);

=> true

13、invoke

语法：_.invoke(list, methodName, *arguments)

说明：在list的每个元素上执行methodName方法。任何传递给invoke的额外参数，invoke都会在调用methodName方法的时候传递给它。

例子：

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

=> [[1, 5, 7], [1, 2, 3]]

14、pluck

语法：_.pluck(list, propertyName)

说明：pluck也许是map最常使用的用例模型的简化版本，即萃取数组对象中某属性值，返回一个数组。

例子：

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

_.pluck(stooges, 'name');

=> ["moe", "larry", "curly"]

15、max

语法：_.max(list, [iteratee], [context])

说明：返回list中的最大值。如果传递iteratee参数，iteratee将作为list中每个值的排序依据。如果list为空，将返回-Infinity，所以你可能需要事先用isEmpty检查 list 。

例子：

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

_.max(stooges, function(stooge){ return stooge.age; });

=> {name: 'curly', age: 60};

16、min

语法：_.min(list, [iteratee], [context])

说明：返回list中的最小值。如果传递iteratee参数，iteratee将作为list中每个值的排序依据。如果list为空，将返回Infinity，所以你可能需要事先用isEmpty检查 list 。

例子：

var numbers = [10, 5, 100, 2, 1000];

_.min(numbers);

=> 2

17、sortBy

语法：_.sortBy(list, iteratee, [context])

说明：返回一个排序后的list拷贝副本。如果传递iteratee参数，iteratee将作为list中每个值的排序依据。用来进行排序迭代器也可以是属性名称的字符串(比如 length)。

例子：

_.sortBy([1, 2, 3, 4, 5, 6], function(num){ return Math.sin(num); });

=> [5, 4, 6, 3, 1, 2]

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

_.sortBy(stooges, 'name');

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

18、groupBy

语法：_.groupBy(list, iteratee, [context])

说明：把一个集合分组为多个集合，通过 iterator 返回的结果进行分组. 如果 iterator 是一个字符串而不是函数, 那么将使用 iterator 作为各元素的属性名来对比进行分组.

例子：

_.groupBy([1.3, 2.1, 2.4], function(num){ return Math.floor(num); });

=> {1: [1.3], 2: [2.1, 2.4]}

_.groupBy(['one', 'two', 'three'], 'length');

=> {3: ["one", "two"], 5: ["three"]}

19、indexBy

语法：_.indexBy(list, iteratee, [context])

说明：给定一个list，和一个用来返回一个在列表中的每个元素键的iterator 函数（或属性名），返回一个每一项索引的对象。和groupBy非常像，但是当你知道你的键是唯一的时候可以使用indexBy 。

例子：

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}

}

20、countBy

语法：_.countBy(list, iteratee, [context])

说明：排排序一个列表组成多个组，并且返回各组中的对象的数量的计数。类似groupBy，但是不是返回列表的值，而是返回在该组中值的数目。

例子：

_.countBy([1, 2, 3, 4, 5], function(num) {

return num % 2 == 0 ? 'even': 'odd';

});

=> {odd: 3, even: 2}

21、shuffle

语法：_.shuffle(list)

说明：返回一个随机乱序的 list 副本, 使用 Fisher-Yates shuffle 来进行随机乱序.

例子：

_.shuffle([1, 2, 3, 4, 5, 6]);

=> [4, 1, 6, 3, 5, 2]

22、sample

语法：_.sample(list, [n])

说明：从 list中产生一个随机样本。传递一个数字表示从list中返回n个随机元素。否则将返回一个单一的随机项。

例子：

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

=> 4

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

=> [1, 6, 2]

23、toArray

语法：_.toArray(list)

说明：把list(任何可以迭代的对象)转换成一个数组，在转换 arguments 对象时非常有用。

例子：

(function(){ return _.toArray(arguments).slice(1); })(1, 2, 3, 4);

=> [2, 3, 4]

24、size

语法：_.size(list)

说明：返回list的长度。

例子：

_.size({one: 1, two: 2, three: 3});

=> 3

25、partition

语法：_.partition(array, predicate)

说明：拆分一个数组（array）为两个数组：第一个数组其元素都满足predicate迭代函数，而第二个的所有元素均不能满足predicate迭代函数。

例子：

_.partition([0, 1, 2, 3, 4, 5], isOdd);

=> [[1, 3, 5], [0, 2, 4]]

三、数组函数（Array Functions）

注：所有的数组函数也可以用于 arguments (参数)对象。但是，Underscore函数不能用于稀疏（"sparse" ）数组。

1、first

语法：_.first(array, [n])

说明：返回array （数组）的第一个元素。传递 n参数将返回数组中从第一个元素开始的n个元素（愚人码头注：返回数组中前 n 个元素.）。

例子：

_.first([5, 4, 3, 2, 1]);

=> 5

2、initial

语法：_.initial(array, [n])

说明：返回数组中除了最后一个元素外的其他全部元素。在arguments对象上特别有用。传递 n参数将从结果中排除从最后一个开始的n个元素（愚人码头注：排除数组后面的 n 个元素）。

例子：

_.initial([5, 4, 3, 2, 1]);

=> [5, 4, 3, 2]

3、last

语法：_.last(array, [n])

说明：返回array（数组）中最后一个元素。传递 n参数将返回数组中从最后一个元素开始的n个元素（愚人码头注：返回数组里的后面的n个元素）。

例子：

_.last([5, 4, 3, 2, 1]);

=> 1

4、rest

语法：_.rest(array, [index])

说明：返回数组中除了第一个元素外的其他全部元素。传递 index 参数将返回从index开始的剩余所有元素。

例子：

_.rest([5, 4, 3, 2, 1]);

=> [4, 3, 2, 1]

5、compact

语法：_.compact(array)

说明：返回一个除去了所有false值的 array副本。在javascript中, false, null, 0, "", undefined 和 NaN 都是false值.

例子：

_.compact([0, 1, false, 2, '', 3]);

=> [1, 2, 3]

6、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]]];

7、without

语法：_.without(array, *values)

说明：返回一个删除所有values值后的 array副本。（愚人码头注：使用===表达式做相等测试。）

例子：

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

=> [2, 3, 4]

8、union

语法：_.union(*arrays)

说明：返回传入的 arrays（数组）并集：按顺序返回，返回数组的元素是唯一的，可以传入一个或多个 arrays （数组）。

例子：

_.union([1, 2, 3], [101, 2, 1, 10], [2, 1]);

=> [1, 2, 3, 101, 10]

9、intersection

语法：_.intersection(*arrays)

说明：返回传入 arrays（数组）交集。结果中的每个值是存在于传入的每个arrays（数组）里。

例子：

_.intersection([1, 2, 3], [101, 2, 1, 10], [2, 1]);

=> [1, 2]

10、difference

语法：_.difference(array, *others)

说明：类似于without，但返回的值来自array参数数组，并且不存在于other 数组。

例子：

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

=> [1, 3, 4]

11、uniq

语法：_.uniq(array, [isSorted], [iteratee])

说明：返回 array去重后的副本, 使用 === 做相等测试. 如果您确定 array 已经排序, 那么给 isSorted 参数传递 true值, 此函数将运行的更快的算法. 如果要处理对象元素, 传递 iteratee函数来获取要对比的属性.

例子：

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

=> [1, 2, 3, 4]

12、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]]

13、unzip

语法：_.unzip(*arrays)

说明：与zip功能相反的函数，给定若干arrays，返回一串联的新数组，其第一元素个包含所有的输入数组的第一元素，其第二包含了所有的第二元素，依此类推。通过apply用于传递数组的数组。

例子：

_.unzip([['moe', 'larry', 'curly'], [30, 40, 50], [true, false, false]])

=> ["moe", 30, true], ["larry", 40, false], ["curly", 50, false]

14、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}

15、indexOf

语法：_.indexOf(array, value, [isSorted])

说明：返回value在该 array 中的索引值，如果value不存在 array中就返回-1。使用原生的indexOf 函数，除非它失效。如果您正在使用一个大数组，你知道数组已经排序，传递true给isSorted将更快的用二进制搜索..,或者，传递一个数字作为第三个参数，为了在给定的索引的数组中寻找第一个匹配值。

例子：

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

=> 1

16、lastIndexOf

语法：_.lastIndexOf(array, value, [fromIndex])

说明：返回value在该 array 中的从最后开始的索引值，如果value不存在 array中就返回-1。如果支持原生的lastIndexOf，将使用原生的lastIndexOf函数。传递fromIndex将从你给定的索性值开始搜索。

例子：

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

=> 4

17、sortedIndex

语法：_.sortedIndex(list, value, [iteratee], [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

18、findIndex

语法：_.findIndex(array, predicate, [context])

说明：类似于_.indexOf，当predicate通过真检查时，返回第一个索引值；否则返回-1。

例子：

_.findIndex([4, 6, 8, 12], isPrime);

=> -1 // not found

_.findIndex([4, 6, 7, 12], isPrime);

=> 2

19、findLastIndex

语法：_.findLastIndex(array, predicate, [context])

说明：和_.findIndex类似，但反向迭代数组，当predicate通过真检查时，最接近末端的索引值将被返回。

例子：

var users = [{'id': 1, 'name': 'Bob', 'last': 'Brown'},

{'id': 2, 'name': 'Ted', 'last': 'White'},

{'id': 3, 'name': 'Frank', 'last': 'James'},

{'id': 4, 'name': 'Ted', 'last': 'Jones'}];

_.findLastIndex(users, {

name: 'Ted'

});

=> 3

20、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) Function）

1、bind

语法：_.bind(function, object, *arguments)

说明：绑定函数 function 到对象 object 上, 也就是无论何时调用函数, 函数里的 this 都指向这个 object.任意可选参数 arguments 可以传递给函数 function , 可以填充函数所需要的参数,这也被称为 partial application。对于没有结合上下文的partial application绑定，请使用partial。

(愚人码头注：partial application翻译成“部分应用”或者“偏函数应用”。partial application可以被描述为一个函数，它接受一定数目的参数，绑定值到一个或多个这些参数，并返回一个新的函数，这个返回函数只接受剩余未绑定值的参数。参见：http://en.wikipedia.org/wiki/Partial_application。

例子：

var func = function(greeting){ return greeting + ': ' + this.name };

func = _.bind(func, {name: 'moe'}, 'hi');

func();

=> 'hi: moe'

2、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);

3、partial

语法：_.partial(function, *arguments)

说明：局部应用一个函数填充在任意个数的 arguments，不改变其动态this值。和bind方法很相近。你可以传递_ 给arguments列表来指定一个不预先填充，但在调用时提供的参数。

例子：

var subtract = function(a, b) { return b - a; };

sub5 = _.partial(subtract, 5);

sub5(20);

=> 15

// Using a placeholder

subFrom20 = _.partial(subtract, _, 20);

subFrom20(5);

=> 15

4、memoize

语法：_.memoize(function, [hashFunction])

说明：Memoizes方法可以缓存某函数的计算结果。对于耗时较长的计算是很有帮助的。如果传递了 hashFunction 参数，就用 hashFunction 的返回值作为key存储函数的计算结果。hashFunction 默认使用function的第一个参数作为key。memoized值的缓存可作为返回函数的cache属性。

例子：

var fibonacci = _.memoize(function(n) {

return n < 2 ? n: fibonacci(n - 1) + fibonacci(n - 2);

});

5、delay

语法：_.delay(function, wait, *arguments)

说明：类似setTimeout，等待wait毫秒后调用function。如果传递可选的参数arguments，当函数function执行时， arguments 会作为参数传入。

例子：

var log = _.bind(console.log, console);

_.delay(log, 1000, 'logged later');

=> 'logged later' // Appears after one second.

6、defer

语法：_.defer(function, *arguments)

说明：延迟调用function直到当前调用栈清空为止，类似使用延时为0的setTimeout方法。对于执行开销大的计算和无阻塞UI线程的HTML渲染时候非常有用。如果传递arguments参数，当函数function执行时， arguments 会作为参数传入。

例子：

_.defer(function(){ alert('deferred'); });

// Returns from the function before the alert runs.

7、throttle

语法：_.throttle(function, wait, [options])

说明：创建并返回一个像节流阀一样的函数，当重复调用函数的时候，至少每隔 wait毫秒调用一次该函数。对于想控制一些触发频率较高的事件有帮助。（愚人码头注：详见：javascript函数的throttle和debounce）

默认情况下，throttle将在你调用的第一时间尽快执行这个function，并且，如果你在wait周期内调用任意次数的函数，都将尽快的被覆盖。如果你想禁用第一次首先执行的话，传递{leading: false}，还有如果你想禁用最后一次执行的话，传递{trailing: false}。

例子：

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

$(window).scroll(throttled);

8、debounce

语法：_.debounce(function, wait, [immediate])

说明：返回 function 函数的防反跳版本, 将延迟函数的执行(真正的执行)在函数最后一次调用时刻的 wait 毫秒之后. 对于必须在一些输入（多是一些用户操作）停止到达之后执行的行为有帮助。例如: 渲染一个Markdown格式的评论预览, 当窗口停止改变大小之后重新计算布局, 等等.

传参 immediate 为 true， debounce会在 wait 时间间隔的开始调用这个函数。（愚人码头注：并且在 waite 的时间之内，不会再次调用。）在类似不小心点了提交按钮两下而提交了两次的情况下很有用。

例子：

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

$(window).resize(lazyLayout);

9、once

语法：_.once(function)

说明：创建一个只能调用一次的函数。重复调用改进的方法也没有效果，只会返回第一次执行时的结果。作为初始化函数使用时非常有用, 不用再设一个boolean值来检查是否已经初始化完成.

例子：

var initialize = _.once(createApplication);

initialize();

// Application is only created once.

10、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 havesaved.

11、before

语法：_.before(count, function)

说明：创建一个函数,调用不超过count 次。当count已经达到时，最后一个函数调用的结果将被记住并返回。

例子：

var monthlyMeeting = _.before(3, askForRaise);

monthlyMeeting();

// the result of any subsequent calls is the same as the second call

12、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'

13、negate

语法：_.negate(predicate)

说明：返回一个新的predicate函数的否定版本。

例子：

var isFalsy = _.negate(Boolean);

_.find([-2, -1, 0, 1, 2], isFalsy);

=> 0

14、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）

1、keys

语法：_.keys(object)

说明：检索object拥有的所有可枚举属性的名称。

例子：

_.keys({one: 1, two: 2, three: 3});

=> ["one", "two", "three"]

2、allKeys

语法：_.allKeys(object)

说明：检索object拥有的和继承的所有属性的名称。

例子：

function Stooge(name) {

this.name = name;

}

Stooge.prototype.silly = true;

_.allKeys(new Stooge("Moe"));

=> ["name", "silly"]

3、values

语法：_.values(object)

说明：返回object对象所有的属性值。

例子：

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

=> [1, 2, 3]

4、mapObject

语法：_.mapObject(object, iteratee, [context])

说明：它类似于map，但是这用于对象。转换每个属性的值。

例子：

_.mapObject({start: 5, end: 12}, function(val, key) {

return val + 5;

});

=> {start: 10, end: 17}

5、pairs

语法：_.pairs(object)

说明：把一个对象转变为一个[key, value]形式的数组。

例子：

_.pairs({one: 1, two: 2, three: 3});

=> [["one", 1], ["two", 2], ["three", 3]]

6、invert

语法：_.invert(object)

说明：返回一个object副本，使其键（keys）和值（values）对换。对于这个操作，必须确保object里所有的值都是唯一的且可以序列号成字符串.

例子：

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

=> {Moses: "Moe", Louis: "Larry", Jerome: "Curly"};

7、create

语法：_.create(prototype, props)

说明：创建具有给定原型的新对象，可选附加props 作为 own的属性。基本上，和Object.create一样，但是没有所有的属性描述符。

例子：

var moe = _.create(Stooge.prototype, {name: "Moe"});

8、functions

语法：_.functions(object)

说明：返回一个对象里所有的方法名, 而且是已经排序的 — 也就是说, 对象里每个方法(属性值是一个函数)的名称.

例子：

_.functions(_);

=> ["all", "any", "bind", "bindAll", "clone", "compact", "compose" ...

9、findKey

语法：_.findKey(object, predicate, [context])

说明：Similar to _.findIndex but for keys in objects. Returns the key where the predicate truth test passes or undefined.

例子：

10、extend

语法：_.extend(destination, *sources)

说明：复制source对象中的所有属性覆盖到destination对象上，并且返回 destination 对象. 复制是按顺序的, 所以后面的对象属性会把前面的对象属性覆盖掉(如果有重复).

例子：

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

=> {name: 'moe', age: 50}

11、extendOwn

语法：_.extendOwn(destination, *sources)

说明：类似于 extend, 但只复制自己的属性覆盖到目标对象。（愚人码头注：不包括继承过来的属性）

例子：

12、pick

语法：_.pick(object, *keys)

说明：返回一个object副本，只过滤出keys(有效的键组成的数组)参数指定的属性值。或者接受一个判断函数，指定挑选哪个key。

例子：

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

13、omit

语法：_.omit(object, *keys)

说明：返回一个object副本，只过滤出除去keys(有效的键组成的数组)参数指定的属性值。或者接受一个判断函数，指定忽略哪个key。

例子：

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

14、defaults

语法：_.defaults(object, *defaults)

说明：用defaults对象填充object 中的undefined属性。并且返回这个object。一旦这个属性被填充，再使用defaults方法将不会有任何效果。

例子：

var iceCream = {flavor: "chocolate"};

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

=> {flavor: "chocolate", sprinkles: "lots"}

15、clone

语法：_.clone(object)

说明：创建一个浅复制（浅拷贝）的克隆object。任何嵌套的对象或数组都通过引用拷贝，不会复制。

例子：

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

=> {name: 'moe'};

16、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]

17、has

语法：_.has(object, key)

说明：对象是否包含给定的键吗？等同于object.hasOwnProperty(key)，但是使用hasOwnProperty 函数的一个安全引用，以防意外覆盖。

例子：

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

=> true

18、property

语法：_.property(key)

说明：返回一个函数，这个函数返回任何传入的对象的key属性。

例子：

var stooge = {name: 'moe'};

'moe' === _.property('name')(stooge);

=> true

19、propertyOf

语法：_.propertyOf(object)

说明：和_.property相反。需要一个对象，并返回一个函数,这个函数将返回一个提供的属性的值。

例子：

var stooge = {name: 'moe'};

_.propertyOf(stooge)('name');

=> 'moe'

20、matcher

语法：_.matcher(attrs)

说明：返回一个断言函数，这个函数会给你一个断言可以用来辨别给定的对象是否匹配attrs指定键/值属性。

例子：

var ready = _.matcher({selected: true, visible: true});

var readyToGoList = _.filter(list, ready);

21、isEqual

语法：_.isEqual(object, other)

说明：执行两个对象之间的优化深度比较，确定他们是否应被视为相等。

例子：

var stooge = {name: 'moe', luckyNumbers: [13, 27, 34]};

var clone = {name: 'moe', luckyNumbers: [13, 27, 34]};

stooge == clone;

=> false

_.isEqual(stooge, clone);

=> true

22、isMatch

语法：_.isMatch(object, properties)

说明：告诉你properties中的键和值是否包含在object中。

例子：

var stooge = {name: 'moe', age: 32};

_.isMatch(stooge, {age: 32});

=> true

23、isEmpty

语法：_.isEmpty(object)

说明：如果object 不包含任何值(没有可枚举的属性)，返回true。对于字符串和类数组（array-like）对象，如果length属性为0，那么_.isEmpty检查返回true。

例子：

_.isEmpty([1, 2, 3]);

=> false

_.isEmpty({});

=> true

24、isElement

语法：_.isElement(object)

说明：如果object是一个DOM元素，返回true。

例子：

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

=> true

25、isArray

语法：_.isArray(object)

说明：如果object是一个数组，返回true。

例子：

(function(){ return _.isArray(arguments); })();

=> false

_.isArray([1,2,3]);

=> true

26、isObject

语法：_.isObject(value)

说明：如果object是一个对象，返回true。需要注意的是JavaScript数组和函数是对象，字符串和数字不是。

例子：

_.isObject({});

=> true

_.isObject(1);

=> false

27、isArguments

语法：_.isArguments(object)

说明：如果object是一个参数对象，返回true。

例子：

(function(){ return _.isArguments(arguments); })(1, 2, 3);

=> true

_.isArguments([1,2,3]);

=> false

28、isFunction

语法：_.isFunction(object)

说明：如果object是一个函数（Function），返回true。

例子：

_.isFunction(alert);

=> true

29、isString

语法：_.isString(object)

说明：如果object是一个字符串，返回true。

例子：

_.isString("moe");

=> true

30、isNumber

语法：_.isNumber(object)

说明：如果object是一个数值，返回true (包括 NaN)。

例子：

_.isNumber(8.4 * 5);

=> true

31、isFinite

语法：_.isFinite(object)

说明：如果object是一个有限的数字，返回true。

例子：

_.isFinite(-101);

=> true

_.isFinite(-Infinity);

=> false

32、isBoolean

语法：_.isBoolean(object)

说明：如果object是一个布尔值，返回true，否则返回false。

例子：

_.isBoolean(null);

=> false

33、isDate

语法：_.isDate(object)

说明：Returns true if object is a Date.

例子：

_.isDate(new Date());

=> true

34、isRegExp

语法：_.isRegExp(object)

说明：如果object是一个正则表达式，返回true。

例子：

_.isRegExp(/moe/);

=> true

35、isError

语法：_.isError(object)

说明：如果object继承至 Error 对象，那么返回 true。

例子：

try {

throw new TypeError("Example");

} catch (o_O) {

_.isError(o_O)

}

=> true

36、isNaN

语法：_.isNaN(object)

说明：如果object是 NaN，返回true。

注意：这和原生的isNaN 函数不一样，如果变量是undefined，原生的isNaN 函数也会返回 true 。

例子：

_.isNaN(NaN);

=> true

isNaN(undefined);

=> true

_.isNaN(undefined);

=> false

37、isNull

语法：_.isNull(object)

说明：如果object的值是 null，返回true。

例子：

_.isNull(null);

=> true

_.isNull(undefined);

=> false

38、isUndefined

语法：_.isUndefined(value)

说明：如果value是undefined，返回true。

例子：

_.isUndefined(window.missingVariable);

=> true

六、实用功能（Utility Functions）

1、noConflict

语法：_.noConflict()

说明：放弃Underscore 的控制变量"_"。返回Underscore 对象的引用。

例子：

var underscore = _.noConflict();

2、identity

语法：_.identity(value)

说明：返回与传入参数相等的值. 相当于数学里的: f(x) = x

这个函数看似无用, 但是在Underscore里被用作默认的迭代器iterator.

例子：

var stooge = {name: 'moe'};

stooge === _.identity(stooge);

=> true

3、constant

语法：_.constant(value)

说明：创建一个函数，这个函数返回相同的值用来作为_.constant的参数。

例子：

var stooge = {name: 'moe'};

stooge === _.constant(stooge)();

=> true

4、noop

语法：_.noop()

说明：返回undefined，不论传递给它的是什么参数。可以用作默认可选的回调参数。

例子：

obj.initialize = _.noop;

5、times

语法：_.times(n, iteratee, [context])

说明：调用给定的迭代函数n次,每一次调用iteratee传递index参数。生成一个返回值的数组。

注意: 本例使用链式语法。

例子：

_(3).times(function(n){ genie.grantWishNumber(n); });

6、random

语法：_.random(min, max)

说明：返回一个min 和 max之间的随机整数。如果你只传递一个参数，那么将返回0和这个参数之间的整数。

例子：

_.random(0, 100);

=> 42

7、mixin

语法：_.mixin(object)

说明：允许用您自己的实用程序函数扩展Underscore。传递一个 {name: function}定义的哈希添加到Underscore对象，以及面向对象封装。

例子：

_.mixin({

capitalize: function(string) {

return string.charAt(0).toUpperCase() + string.substring(1).toLowerCase();

}

});

_("fabio").capitalize();

=> "Fabio"

8、iteratee

语法：_.iteratee(value, [context])

说明：一个重要的内部函数用来生成可应用到集合中每个元素的回调，返回想要的结果 - 无论是等式，任意回调，属性匹配，或属性访问。

通过_.iteratee转换判断的Underscore 方法的完整列表是 map, find, filter, reject, every, some, max, min, sortBy, groupBy, indexBy, countBy, sortedIndex, partition, 和 unique.

例子：

var stooges = [{name: 'curly', age: 25}, {name: 'moe', age: 21}, {name: 'larry', age: 23}];

_.map(stooges, _.iteratee('age'));

=> [25, 21, 23];

9、uniqueld

语法：_.uniqueId([prefix])

说明：为需要的客户端模型或DOM元素生成一个全局唯一的id。如果prefix参数存在， id 将附加给它。

例子：

_.uniqueId('contact_');

=> 'contact_104'

10、escape

语法：_.escape(string)

说明：转义HTML字符串，替换&, <, >, ", ', 和 /字符。

例子：

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

=> "Curly, Larry & Moe"

11、unescape

语法：_.unescape(string)

说明：和escape相反。转义HTML字符串，替换&, <, >, ", `, 和 /字符。

例子：

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

=> "Curly, Larry & Moe"

12、result

语法：_.result(object, property, [defaultValue])

说明：如果指定的property 的值是一个函数，那么将在object上下文内调用它;否则，返回它。如果提供默认值，并且属性不存在，那么默认值将被返回。如果设置defaultValue是一个函数，它的结果将被返回。

例子：

var object = {cheese: 'crumpets', stuff: function(){ return 'nonsense'; }};

_.result(object, 'cheese');

=> "crumpets"

_.result(object, 'stuff');

=> "nonsense"

_.result(object, 'meat', 'ham');

=> "ham"

13、now

语法：_.now()

说明：一个优化的方式来获得一个当前时间的整数时间戳。可用于实现定时/动画功能。

例子：

_.now();

=> 1392066795

14、template

语法：_.template(templateString, [settings])

说明：将 JavaScript 模板编译为可以用于页面呈现的函数, 对于通过JSON数据源生成复杂的HTML并呈现出来的操作非常有用。模板函数可以使用 <%= … %>插入变量, 也可以用<% … %>执行任意的 JavaScript 代码。如果您希望插入一个值, 并让其进行HTML转义,请使用<%- … %>。当你要给模板函数赋值的时候，可以传递一个含有与模板对应属性的data对象。如果您要写一个一次性的, 您可以传对象 data 作为第二个参数给模板 template 来直接呈现, 这样页面会立即呈现而不是返回一个模板函数. 参数 settings 是一个哈希表包含任何可以覆盖的设置 _.templateSettings.

例子：

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

compiled({name: 'moe'});

=> "hello: moe"

var template = _.template("<b><%- value %></b>");

template({value: '<script>'});

=> "<b><script></b>"

您也可以在JavaScript代码中使用 print. 有时候这会比使用 <%= ... %> 更方便.

var compiled = _.template("<% print('Hello ' + epithet); %>");

compiled({epithet: "stooge"});

=> "Hello stooge"

如果ERB式的分隔符您不喜欢, 您可以改变Underscore的模板设置, 使用别的符号来嵌入代码.定义一个 interpolate 正则表达式来逐字匹配嵌入代码的语句, 如果想插入转义后的HTML代码则需要定义一个 escape 正则表达式来匹配,还有一个 evaluate 正则表达式来匹配您想要直接一次性执行程序而不需要任何返回值的语句.您可以定义或省略这三个的任意一个.例如, 要执行Mustache.js类型的模板:

_.templateSettings = {

interpolate: /\{\{(.+?)\}\}/g

};

var template = _.template("Hello {{ name }}!");

template({name: "Mustache"});

=> "Hello Mustache!"

默认的, template 通过 with 语句来取得 data 所有的值. 当然, 您也可以在 variable 设置里指定一个变量名. 这样能显著提升模板的渲染速度.

_.template("Using 'with': <%= data.answer %>", {variable: 'data'})({answer: 'no'});

=> "Using 'with': no"

预编译模板对调试不可重现的错误很有帮助. 这是因为预编译的模板可以提供错误的代码行号和堆栈跟踪, 有些模板在客户端(浏览器)上是不能通过编译的在编译好的模板函数上, 有 source 属性可以提供简单的预编译功能.

JST.project = <%= _.template(jstText).source %>;

</script>