集合函数（数组或对象）

每个_.each（列表、迭代、[上下文]） 别名：对于每个 来源
在上迭代列表元素，每个元素依次生成一个迭代功能。这个迭代已绑定到上下文对象，如果是通过。每次调用迭代用三个参数调用：（元素、索引、列表）.如果列表是JavaScript对象，迭代的参数将是（值、键、列表）。返回列表用于链接。

_.每个（[1，2，3]，警报）；=>依次提醒每个号码。。。_.each（{one:1，two:2，three:3}，alert）；=>依次提醒每个数值。。。

注意：集合函数用于数组、对象和类似数组的对象，例如 论据,节点列表和类似的。但它是通过duck-type工作的，所以避免用一个数字长度属性。值得注意的是每个循环无法中断-要中断，请使用_.查找而不是。

地图_.map（列表、迭代、[上下文]） 别名：收集 来源
通过映射中的每个值生成新的值数组列表通过转换函数(迭代).向iterate传递三个参数：价值,然后指数（或钥匙)迭代的，最后是对整个列表。

_.map（[1,2,3]，函数（num）{返回num*3；}）；=> [3, 6, 9]_.map（{one:1，two:2，three:3}，function（num，key）{return num*3；}）；=> [3, 6, 9]_.映射（[[1,2]，[3,4]]，_.first）；=> [1, 3]

减少_.reduce（list，iterate，[memo]，[context]） 别名：注入,折页 来源
也称为注入和折叠，减少归结a列表值转换为单个值。备忘录是还原的初始状态，它的每个连续步骤都应该由迭代。将向iterate传递四个参数：备忘录，然后是价值和指数迭代的（或键），最后是对整个列表。

如果没有向reduce的初始调用传递memo，那么不会对第一个元素调用iterate列表中的。第一个元素在下一个元素的iterate调用中作为备忘录传递元素。

var sum=.reduce（[1,2,3]，函数（memo，num）{return memo+num；}，0）；=> 6

减少右侧_.reduceRight（list，iterate，[memo]，[context]） 别名：文件夹 来源
的正确关联版本减少。文件夹在JavaScript中不如在惰性语言中有用评价。

var列表=[[0，1]，[2，3]，[4，5]]；var flat=_.reduceRight（列表，函数（a，b）{return a.concat（b）；}，[]）；=> [4, 5, 2, 3, 0, 1]

找到_.find（列表，谓词，[上下文]） 别名：发现 来源
查看中的每个值列表，返回第一个通过真相测试(谓语)，或未定义如果没有值通过测试。函数返回为只要它找到一个可接受的元素，并且不遍历整个列表。谓语通过转换迭代以简化简写语法。

var even=_.find（[1,2,3,4,5,6]，函数（num）{返回num%2==0；}）；=> 2

滤波器_.filter（列表，谓词，[上下文]） 别名：选择 来源
查看中的每个值列表，返回所有的数组通过真理测试的价值观(谓语).谓语通过转换迭代以简化简写语法。

var evens=_.filter（[1,2,3,4,5,6]，函数（num）{返回num%2==0；}）；=> [2, 4, 6]

查找位置_.findWhere（列表，属性） 来源
浏览列表并返回第一重视比赛中列出的所有键值对属性。

如果找不到匹配项，或者如果列表为空，未定义将返回。

_.findWhere（publicServicePulitzers，{新闻编辑室：《纽约时报》}）；=>{年份：1918年，新闻编辑室：《纽约时报》，理由是：“为了公共服务，它发布了如此多的官方报告，欧洲政治家关于进展和战争的进行。"}

哪里_.where（列表，属性） 来源
查看中的每个值列表，返回所有价值观比赛中列出的键值对属性。

_where（listOfPlays，{作者：“莎士比亚”，年份：1611}）；=>[{标题：“辛白林”，作者：“莎士比亚”，年份：1611}，{标题：《暴风雨》，作者：《莎士比亚》，年份：1611}]

拒绝_.reject（列表，谓词，[上下文]） 来源
返回中的值列表没有真相的因素测试(谓语)传球。与…相反滤波器。谓语通过转换迭代以简化简写语法。

var赔率=_.reject（[1,2,3,4,5,6]，函数（num）{return num%2==0；}）；=> [1, 3, 5]

每一个_.every（列表，[谓词]，[上下文]） 别名：全部的 来源
退换商品真的如果列表通过谓语真相测试。短路并停止遍历列表如果发现错误元素。谓语通过转换迭代以简化简写语法。

_.every（[2,4,5]，函数（num）{返回num%2==0；}）；=>假

一些_.some（列表，[谓词]，[上下文]） 别名：任何 来源
退换商品真的如果列表通过谓语真相测试。短路并停止遍历列表如果找到真元素。谓语通过迭代以简化简写语法。

_.some（[null，0，'yes'，false]）；=>真

包含_.contains（列表，值，[fromIndex]） 别名：包括,包括 来源
退换商品真的如果价值存在于列表。使用索引属于内部，如果列表是数组。使用来自索引从给定索引开始搜索。

_.包含（[1，2，3]，3）；=>真

援引_.invoke（list、methodName、*参数） 来源
调用由命名的方法调用的方法名中的每个值列表。传递给的任何额外参数援引将转发给方法调用。

_.调用（[[5，1，7]，[3，2，1]]，“排序”）；=> [[1, 5, 7], [1, 2, 3]]

摘下_.pull（列表，属性名称） 来源
最常见的用途可能是什么地图：提取属性值列表。

var stooges=[{name：'moe'，age:40}，{name：'拉里'，age:50}，}，[name：'卷发'，age：60}]；_.pull（助手，“name”）；=>[“moe”，“larry”，“curly”]

最大值_.max（列表，[迭代]，[上下文]） 来源
返回中的最大值列表。如果迭代函数，它将用于每个值以生成对值进行排序的标准。-无限已返回如果列表为空，因此栈空警卫可能需要。此函数目前只能可靠地比较数字。此函数使用运算符<(笔记).

var stooges=[｛name：“moe”，年龄：40｝，｛name：“larry”，年龄：50｝，｛name：“curly”，年龄：60｝]；_.max（stooges，function（stooge）{return stooge.age；}）；=>{name:'卷曲'，年龄：60}；

最小值_.min（列表，[迭代]，[上下文]） 来源
返回中的最小值列表。如果迭代函数，它将用于每个值以生成对值进行排序的标准。无穷已返回如果列表为空，因此栈空警卫可能需要。此函数目前只能可靠地比较数字。此函数使用运算符<(笔记).

var数=[10,5,100,2,1000]；_最小值（数字）；=> 2

排序依据_.sortBy（list，iterate，[context]） 来源
返回的（稳定）排序副本列表，按升序排列按运行每个值的结果排序迭代。iterate也可以是要排序的属性的字符串名（例如。长度). 此函数使用运算符<(笔记).

_.sortBy（[1,2,3,4,5,6]，函数（num）{return Math.sin（num；}）；=> [5, 4, 6, 3, 1, 2]var stooges=[｛name：“moe”，年龄：40｝，｛name：“larry”，年龄：50｝，｛name：“curly”，年龄：60｝]；_.sortBy（助手，“name”）；=>[{name:‘curly’，年龄：60}，{name:'larry'，年龄：50}，}name:‘moe’，年龄:40}]；

分组依据_.groupBy（list，iterate，[context]） 来源
将集合拆分为多个集合，并按运行每个集合的结果进行分组值通过迭代.如果迭代是字符串，而不是函数，按命名的属性分组迭代在每个这些值。

_.groupBy（[1.3，2.1，2.4]，函数（num）{return Math.floor（num）；}）；=> {1: [1.3], 2: [2.1, 2.4]}_.groupBy（['one'，'two'，'three']，'length'）；=>{3:[“一”，“二”]，5:[“三”]}

索引依据_.indexBy（list，iteratee，[context]） 来源
给定一个列表、和迭代功能返回列表中每个元素的键（或属性名），返回一个对象，其中包含每个项的索引。就像这样分组依据，但当你知道你的密钥是唯一的。

var stooges=[{name：'moe'，age:40}，{name：'拉里'，age:50}，}，[name：'卷发'，age：60}]；_.indexBy（助手，“年龄”）；=> {“40”：{姓名：'moe'，年龄：40}，“50”：{姓名：'larry'，年龄：50}，“60”：{姓名：'卷发'，年龄：60}}

计数依据_.countBy（list，iterate，[context]） 来源
将列表排序为组并返回对象数计数在每组中。类似分组依据，但不是返回值列表，返回该组中值的数量计数。

_.countBy（[1,2,3,4,5]，函数（num）{返回num%2==0？'偶数'：'奇数'；});=>{奇数：3，偶数：2}

洗牌_.shuffle（列表） 来源
返回列表，使用的版本渔夫-耶茨洗牌。

_.洗牌（[1,2,3,4,5,6]）；=> [4, 1, 6, 3, 5, 2]

样品_.sample（列表，[n]） 来源
从列表。将数字传递给返回n个列表中的随机元素。否则为单一随机项目将被退回。

_样品（[1,2,3,4,5,6]）；=>4_样品（[1,2,3,4,5,6]，3）；=> [1, 6, 2]

到阵列_.toArray（列表） 来源
从列表（任何可以迭代）。用于转换论据对象。

（function（）{return_.toArray（arguments）.slice（1）；}）（1，2，3，4）；=> [2, 3, 4]

大小_.size（列表） 来源
返回列表。

_.尺寸（[1,2,3,4,5]）；=> 5_.大小（{one:1，two:2，three:3}）；=> 3

隔板_.partition（列表，谓词） 来源
拆分列表分成两个数组：一个数组的元素都满足谓语还有一个元素都不满足谓语。谓语通过转换迭代以简化简写语法。

_.分区（[0,1,2,3,4,5]，isOdd）；=> [[1, 3, 5], [0, 2, 4]]

契约_.compact（列表） 来源
返回列表删除所有错误的值。在JavaScript中，假,无效的,0,"",未定义和NaN公司都是假的。

_紧凑（[0，1，false，2，''，3]）；=> [1, 2, 3]

数组函数

注意：所有数组函数也将在论据对象。然而，Undercore函数并非设计用于“稀疏”阵列。

第一_.first（数组，[n]） 别名：头,拿 来源
返回阵列.超车n个将返回第一个n个数组的元素。

_.第一个（[5,4,3,2,1]）；=> 5

最初的_.initial（数组，[n]） 来源
返回除数组最后一个项之外的所有项。特别适用于arguments对象。通过n个排除最后一个n个元素从结果来看。

_.首字母（[5,4,3,2,1]）；=> [5, 4, 3, 2]

最后的_.last（数组，[n]） 来源
返回阵列.超车n个将返回最后n个数组的元素。

_.最后（[5,4,3,2,1]）；=> 1

休息_.rest（数组，[索引]） 别名：尾,滴 来源
返回休息数组中元素的数量。传递一个指数从该索引开始返回数组的值。

_休息（[5、4、3、2、1]）；=> [4, 3, 2, 1]

压扁_.flature（数组，[depth]） 来源
展平嵌套阵列。如果你通过了真的或1作为深度，数组将只展平一个级别。通过较大的数字将导致压扁下降得更深到嵌套层次结构中。省略深度参数，或经过假或无穷，将数组全部展平到达最深的嵌套层。

_.压扁（[1，[2]，[3]，[[4]]]）；=> [1, 2, 3, 4];_.压扁（[1，[2]，[3]，[[4]]]]，真）；=> [1, 2, 3, [[4]]];_.压扁（[1，[2]，[3]，[[4]]]，2）；=> [1, 2, 3, [4]];

没有_.without（数组，*值） 来源
返回阵列的所有实例值远离的。

_.没有（[1，2，1，0，3，1，4]，0，1）；=> [2, 3, 4]

联盟_.union（*数组） 来源
计算传入的并集阵列：唯一项列表，按顺序，出现在一个或多个阵列。

_.联合（[1，2，3]，[101，2，1，10]，[2，1]）；=> [1, 2, 3, 101, 10]

交叉_交集（*数组） 来源
计算所有阵列。结果中的每个值都存在于阵列。

_交叉口（[1，2，3]，[101，2，1，10]，[2，1]）；=> [1, 2]

差异_.difference（数组，*其他） 来源
类似没有，但返回的值来自阵列那个不存在于其他数组。

_差异（[1,2,3,4,5]，[5,2,10]）；=> [1, 3, 4]

uniq公司_.uniq（数组，[isSorted]，[iterate]） 别名：独特的 来源
生成的重复免费版本阵列，使用===进行测试对象相等。特别是，只保留每个值的第一次出现。如果你事先知道阵列已排序，经过真的对于已排序将运行更快的算法。如果要基于转换计算唯一项，请传递迭代功能。

_.uniq（[1,2,1,4,1,3]）；=> [1, 2, 4, 3]

拉链_.zip（*阵列） 来源
将每个阵列使用相应位置的值。当你有单独的通过匹配数组索引进行协调的数据源。

_.zip（['moe'，'larry'，'curly']，[30,40,50]，[true，false，false]）；=>[[“moe”，30，true]，[“larry”，40，false]，[（“卷曲”，50，false）]

解压缩_.unzip（数组） 别名：转置 来源
与…相反拉链。给定一个阵列属于数组，返回一系列新数组，其中第一个数组包含所有输入数组中的第一个元素，第二个元素包含所有第二个元素，依此类推。如果使用矩阵对于嵌套数组，这可以用于转置矩阵。

_.unzip（[[“moe”，30，true]，[“larry”，40，false]，[（“卷曲”，50，false）]）；=>[['moe'，'larry'，'curly']，[30，40，50]，[true，false，false]]

对象_.object（列表，[值]） 来源
将数组转换为对象。传递单个列表[键，值]对、键列表和值列表。经过by pairs与对。如果存在重复的密钥，最后一个值获胜。

_.对象（['moe'，'larry'，'curly']，[30,40,50]）；=>{moe:30，larry:40，卷曲：50}_.对象（[['moe'，30]，['arry'，40]，[curly'，50]]）；=>｛moe:30，larry:40，curly:50｝

块_.chunk（数组，长度） 来源
Chunks和阵列分成多个数组，每个数组包含长度或更少的项目。

varpartners=.chunk（_.shuffle（幼儿园），2）；=>[[“泰龙”，“伊利”]，[“艾丹”，“山姆”]，[[“卡特里娜”，“比利”]

索引属于_.indexOf（数组，值，[isSorted]） 来源
返回索引价值可以在中找到阵列,或-1如果值不在阵列。如果您使用大数组，并且您知道数组已经排序，请传递真的对于已排序使用更快的二进制搜索。。。或者，将数字传递为第三个参数，以便在给定索引后的数组。如果已排序是真的,此函数使用运算符<(笔记).

_.索引Of（[1,2,3]，2）；=> 1

最后索引_.lastIndexOf（数组，值，[fromIndex]） 来源
返回的最后一次出现的索引价值在中阵列,或-1如果值不存在。通过来自索引开始搜索给定索引。

_.lastIndexOf（[1,2,3,1,2,3]，2）；=> 4

排序索引_.sortedIndex（数组，值，[迭代]，[上下文]） 来源
使用二进制搜索确定价值 应该插入阵列为了保持阵列的排序的顺序。如果迭代提供功能，它将用于计算每个值的排序排序，包括价值你过去了。iterate也可以是要排序的属性的字符串名（例如。长度). 此函数使用运算符<(笔记).

_排序索引（[10,20,30,40,50]，35）；=> 3var stooges=[{name：'moe'，年龄：40}，{name：'卷发'，年龄:60}]；_.sortedIndex（stooges，{name:'larry'，age:50}，'age'）；=> 1

findIndex（查找索引）_.findIndex（数组，谓词，[上下文]） 来源
类似_.索引属于，返回第一个索引其中谓语真理测试通过；否则返回-1。

_.findIndex（[4,6,8,12]，isPrime）；=>未找到-1//_.findIndex（[4,6,7,12]，isPrime）；=> 2

查找最后索引_.findLastIndex（数组，谓词，[上下文]） 来源
喜欢_.find索引但反向迭代数组，返回最接近于谓语真实性测试传球。

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（用户{name:'特德'});=> 3

范围_范围（[开始]、停止、[步骤]） 来源
一个创建灵活编号的整数列表的函数，便于每个和地图循环。开始，如果省略，默认为0;步默认为1如果开始在之前停止，否则-1。返回列表的整数开始（含）至停止（不含），增加（或减少）步。

_.范围（10）；=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]_.范围（1，11）；=>[1,2,3,4,5,6,7,8,9,10]_.范围（0、30、5）；=> [0, 5, 10, 15, 20, 25]_.范围（0，-10，-1）；=> [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]_.范围（0）；=> []

函数（uh，ahem）函数

绑定_.bind（函数、对象、*参数） 来源
绑定功能到对象意味着无论何时调用函数时这将是对象。（可选）通过论据到功能预先填充，亦称为部分应用程序.对于不带上下文绑定，使用部分。

var func=函数（问候语）{return greeting+'：'+this.name}；func=_.bind（func，{名称：'moe'}，'hi'）；func（）；=>'hi:moe'

绑定所有_.bindAll（对象，*methodNames） 来源
在对象，由指定方法名称，无论何时在该对象的上下文中运行被调用。对于即将使用的绑定函数非常方便作为事件处理程序，否则将调用相当无用的这。方法名称是必需的。

var按钮视图={label:“下划线”，onClick:function（）{alert（'clicked:'+this.label）；}，onHover:function（）{console.log（'hovering:'+this.label）；}};_.bindAll（buttonView，'onClick'，'onHover'）；//单击按钮时，this.label将具有正确的值。jQuery（'#underscore_button'）.on（'click'，buttonView.onClick）；

部分_.partial（函数，*参数） 来源
通过填写任意数量的论据,没有改变其动态这值。的近亲绑定.你可以通过_在您的列表中论据指定一个参数不应预先填充，但应在调用时开放供提供。注：如果需要_占位符和这同时绑定，使用两者_.部分和_.绑定。

var减法=函数（a，b）{返回b-a；}；sub5=部分（减，5）；子条款5（20）；=> 15//使用占位符subFrom20=部分（减去，_，20）；subFrom20（5）；=> 15

记下_.memoize（函数，[hashFunction]） 来源
记忆给定的功能通过缓存计算结果。有用的加快缓慢运行的计算。如果通过了可选hashFunction（哈希函数），它将用于计算用于存储的哈希键结果，基于原始函数的参数。默认值hashFunction（哈希函数）只对已记忆的函数使用第一个参数作为关键。存储值的缓存可用作隐藏物属性。

var fibonacci=_.memorize（函数（n）{返回n<2？n： 斐波那契（n-1）+斐波那奇（n-2）；});

延迟_.delay（函数、等待、*参数） 来源
很像设置超时，调用功能之后等待毫秒。如果您通过了可选论据，他们会转发给功能当它被调用时。

var log=_.bind（console.log，console）；_.delay（log，1000，“稍后记录”）；=>“logged later”//一秒钟后出现。

推迟_.defer（函数，*参数） 来源
延迟调用功能直到清除当前调用堆栈，类似于使用设置超时延迟为0。有助于执行在不阻塞UI线程的情况下进行昂贵的计算或分块呈现HTML无法更新。如果您通过了可选论据，他们会的转发到功能当它被调用时。

_.defer（function（）{alert（'deferred'）；}）；//在警报运行之前从函数返回。

节气门_.throttle（功能、等待、[选项]） 来源
创建并返回传递的函数的新的节流版本，当重复调用时，它实际上只调用原始函数每个最多一次等待毫秒。对于发生速度比您快的速率限制事件非常有用可以跟上。

默认情况下，节气门将在调用函数后立即执行第一次，如果你再打几次在等待这段时间一结束。如果你想禁用前缘呼叫，传球{前导：假}，如果您想禁用在后缘执行死刑，传球
{尾随：false}。

var throttled=_.trottle（updatePosition，100）；$（窗口）滚动（节流）；

如果您需要取消预定的油门，您可以致电.cancel（）关于节流函数。

消除颤抖_.debounce（函数，等待，[立即]） 来源
创建并返回传递函数的一个新的去边界版本将推迟执行等待自上次以来已过毫秒已调用。用于实现只应发生的行为之后输入已停止到达。例如：渲染预览降价注释，在窗口后重新计算布局已停止调整大小，等等。

在结束时等待间隔，函数将被调用通过传递的参数最近到去抖功能。

通过真的对于立即的引起的论点消除颤抖以触发前导上的函数，而不是后缘等待间隔。在以下情况下有用防止意外双击“提交”按钮触发第二次。

var lazyLayout=_.deboush（calculateLayout，300）；$（window）.resize（lazyLayout）；

如果您需要取消预定的退抖，您可以致电.cancel（）关于去抖函数。

一旦_.once（函数） 来源
创建只能调用一次的函数版本。重复调用修改的函数将无效，返回原始调用的值。用于初始化功能，而不必设置一个布尔标志，然后再检查它。

var initialize=_.once（创建应用程序）；initialize（）；initialize（）；//应用程序只创建一次。

之后_.after（计数，函数） 来源
创建的包装功能一开始什么都没有。发件人这个计数-呼叫之后，它实际上开始呼叫功能。用于分组异步响应，其中您可以希望确保在之前完成所有异步调用诉讼程序。

var renderNotes=_.after（notes.length，render）；_.each（注释、函数（注释）{note.asyncSave（{success:renderNotes}）；});//renderNotes在保存所有注释后运行一次。

之前_.before（计数，函数） 来源
创建的包装功能它会存储其返回值。从计数-第次呼叫继续，最后一次的记忆结果调用立即返回，而不是调用功能再一次。因此包装器将调用功能至多计数-1次。

var monthlyMeeting=_.before（3，askForRaise）；月度会议（）；月度会议（）；月度会议（）；//任何后续调用的结果都与第二次调用的结果相同

包_.wrap（函数，包装器） 来源
包装第一个功能的内部包装器功能，将其作为第一个参数传递。这允许包装器到在功能运行，调整参数，并有条件地执行它。

var hello=函数（名称）{return“hello:”+name；}；hello=_.wrap（hello，函数（func）{return“before”+函数（“moe”）+“，after”；});你好（）；=>'之前，您好：moe，之后'

否定_.negate（谓词） 来源
返回的新否定版本谓语功能。

var isFalsy=_.negate（布尔值）；_.fund（[-2，-1，0，1，2]，isFalsy）；=> 0

组成_.compose（*函数） 来源
返回功能，其中每个函数使用后面函数的返回值。在数学方面，组成功能f（）,g（）、和h（）生产f（g（h（）））。

var问候语=函数（名称）{return“hi:”+name；}；var惊叹号=函数（语句）{return statement.toUpperCase（）+“！”；}；var welcome=_.compose（问候，惊叹）；欢迎（‘me’）；=>“嗨：MOE！”

rest参数_.restArguments（函数，[startIndex]） 来源
返回的版本功能当被呼叫时，接收所有来自和超越的论点启动索引收集到单个数组中。如果不传递显式启动索引，它将由查看功能自身。类似至ES6休息参数语法。

var raceResults=_.restArguments（函数（金、银、铜、everyoneElse）{_.each（everyoneElse，sendConsolations）；});raceResults（“Dopey”、“Grumpy”、“Happy”、《Sneezy》、《Bashful》、《Sleepy》、“Doc”）；

对象函数

钥匙_.keys（对象） 来源
检索的所有名称对象自己的可枚举属性。

_.键（{one:1，two:2，three:3}）；=>[“一”、“二”、“三”]

所有密钥_.allKeys（对象） 来源
检索全部的的名称对象的自己和继承的属性。

函数Stooge（name）{this.name=名称；}Stooge.prototype.silly=真；_.allKeys（新Stooge（“Moe”））；=>[“name”，“silly”]

值_.values（对象） 来源
返回的所有值对象自己的属性。

_.值（{one:1，two:2，three:3}）；=> [1, 2, 3]

mapObject（映射对象）_.mapObject（对象，iteratee，[context]） 来源
喜欢地图，但对于对象。转换价值观每个属性的顺序。

_.mapObject（{开始：5，结束：12}，函数（val，键）{返回值+5；});=>{开始：10，结束：17}

对_.pairs（对象） 来源
将对象转换为列表[键，值]对。相反属于对象。

_.对（{one:1，two:2，three:3}）；=>[[“一”，1]，[“二”，2]，[“三”，3]]

使转化_反转（对象） 来源
返回对象其中键已成为值和键的值。为了实现这一点，对象的所有值应该是唯一的，并且可以序列化字符串。

_反转（{Moe：“摩西”，Larry：“路易”，Curly：“杰罗姆”}）；=>{摩西：“莫”，路易斯：“拉里”，杰罗姆：“卷毛”}；

创造_.create（原型、道具） 来源
使用给定的原型创建新对象，可以选择附加道具作为拥有属性。基本上，对象.创建,但没有所有的属性描述符jazz。

var-moe=_.create（Stooge.prototype，{name:“moe”}）；

功能_.functions（对象） 别名：方法 来源
返回对象中每个方法的名称的排序列表-也就是说，对象的每个函数属性的名称。

_.功能（_）；=>[“all”，“any”，“bind”，“bindAll”，“clone”，“compact”，”compose“。。。

查找密钥_.findKey（对象，谓词，[上下文]） 来源
类似_.find索引但对于对象中的键。返回钥匙其中谓语真实性测试通过或未定义。谓语通过转换迭代以简化简写语法。

延伸_.extend（目标，*源） 来源
简单复制所有属性在里面这个来源对象转移到目的地对象，并返回目的地对象。任何嵌套的对象或数组都将通过引用进行复制，而不是复制。它是有序的，所以最后一个源将覆盖相同的属性前面参数中的name。

_扩展（{name:'moe'}，{age:50}）；=>{姓名：'moe'，年龄：50}

扩展拥有_.extendOwn（目标，*源） 别名：分配 来源
喜欢延伸，但只有副本拥有属性转移到目标对象。

挑选_.pick（对象，*键） 来源
返回对象，已筛选为只有的值允许的钥匙（或有效键数组）。或者接受一个谓词，指示要选取的键。

_.pick（{name:“moe”，年龄：50，用户ID:“moe1”}，“name”，“age”）；=>｛姓名：“moe”，年龄：50岁｝_.pick（{名称：'moe'，年龄：50，用户ID:'moe1'}，函数（值，键，对象）{return _.isNumber（值）；});=>{年龄：50}

省略_.imit（对象，*键） 来源
返回对象，筛选以忽略不允许的钥匙（或键数组）。或者接受谓词指示要忽略的键。

_省略（{姓名：“moe”，年龄：50岁，用户ID：“moe1”}，“用户ID”）；=>{姓名：'moe'，年龄：50}_.omit（{名称：'moe'，年龄：50，用户ID:'moe1'}，函数（值，键，对象）{return _.isNumber（值）；});=>{名称：'moe'，用户ID:'moe1'}

默认值_.defaults（对象，*默认值） 来源
退换商品对象填写后未定义属性第一个值出现在以下列表中默认值物体。

var冰淇淋={口味：“巧克力”}；_.defaults（冰淇淋，{口味：“香草”，喷雾：“很多”}）；=>{味道：“巧克力”，洒：“很多”}

克隆_.clone（对象） 来源
创建所提供的的浅拷贝克隆平原 对象。任何嵌套的对象或数组都将通过引用进行复制，而不是复制。

_.clone（{name:'moe'}）；=>{name:'moe'}；

水龙头_.tap（对象，拦截器） 来源
调用拦截器使用对象，然后返回对象。此方法的主要目的是“进入”方法链，以便对链中的中间结果执行操作。

_链（[1,2,3200]）.filter（函数（num）{返回num%2==0；}）.tap（警报）.map（函数（num）{return num*num}）.value（）；=>//[2200]（已发出警报）=> [4, 40000]

到路径_.toPath（路径） 来源
确保路径是一个数组。如果路径是一个字符串，它是封装在单个元素阵列中；如果它已经是一个数组，那么它就是未经修改返回。

_.toPath（'key'）；=>[“键”]_.toPath（['a'，0，'b']）；=>['a'，0，'b']//（相同数组）

_.to路径在内部使用有,得到,援引,财产,属性和结果，以及迭代以及所有依赖它的函数，以便进行深度规范化属性路径。您可以覆盖_.to路径如果你想的话自定义此行为，例如启用Lodash-like字符串路径人手不足。建议更改_.to路径将不可避免地导致一些密钥无法访问；自行承担风险。

//支持虚线路径速记。var originalToPath=_.toPath；_.混合蛋白({toPath：函数（路径）{return _.isString（路径）？path.split（'.'）：原始路径（path）；}});_.get（{a:[{b:5}]}，'a.0.b'）；=> 5

得到_.get（对象，路径，[默认]） 来源
返回的指定属性对象。路径可能是指定为简单键或对象键数组或数组索引，用于深层属性提取。如果属性不存在或是未定义，可选违约返回。

_.get（{a:10}，'a'）；=> 10_.get（{a:[{b:2}]}，['a'，0，'b']）；=> 2_.get（{a:10}，'b'，100）；=> 100

有_.has（对象，键） 来源
对象是否包含给定的键？与相同object.hasOwnProperty（密钥），但使用对拥有自己的财产功能，以防意外覆盖。

_具有（{a:1，b:2，c:3}，“b”）；=>真

财产_.property（路径） 来源
返回一个函数，该函数将返回任何传入对象。路径可以指定为简单键，或作为对象键或数组索引的数组，用于深层属性提取。

var stooge=｛name:“moe”｝；'moe'===_.property（'name'）（助手）；=>真var stooges={moe:{恐惧：{最坏：‘蜘蛛’}}，卷曲：{恐惧:{最糟糕：‘moe’}}}；var curlysWorstFear=_.property（['curly'，'fears'，'worst']）；卷发最可怕的恐惧（走狗）；=>“Moe”

属性_.propertyOf（对象） 来源
的反转_.属性。获取对象并返回函数它将返回所提供属性的值。

var stooge={名称：'moe'}；_.propertyOf（助手）（“姓名”）；=>“移动”

匹配器_.matcher（属性） 别名：比赛 来源
返回一个谓词函数，该函数将告诉您传入的对象包含中存在的所有键/值属性属性。

var ready=_.matcher（{selected:true，visible:true}）；var readyToGoList=_.filter（列表，就绪）；

等于_.isEqual（对象，其他） 来源
在两个对象之间执行优化的深入比较，以确定如果他们应该被认为是平等的。

var stooge={name:'moe'，luckyNumbers:[13,27,34]}；var克隆={名称：'moe'，幸运数字：[13，27，34]}；stooge==克隆；=>假_.isEqual（stooge，clone）；=>真

isMatch（isMatch）_.isMatch（对象、属性） 来源
告诉您中的键和值属性包含在里面对象。

var stooge={name：'moe'，年龄：32}；_.isMatch（助手，{年龄：32}）；=>真

栈空_.isEmpty（集合） 来源
退换商品真的如果收集没有元素。对于字符串和类似阵列的对象_.is空检查长度属性为0。对于其他对象，它返回真的如果对象没有可列举的所有权。请注意，原始数字、布尔值和根据这个定义，符号总是空的。

_.is空（[1,2,3]）；=>假_.isEmpty（{}）；=>真

is元素_.isElement（对象） 来源
退换商品真的如果对象是DOM元素。

_.isElement（jQuery（'body'）[0]）；=>真

isArray（isArray）_.isArray（对象） 来源
退换商品真的如果对象是数组。

（函数（）{return_.isArray（参数）；}）（）；=>假_.isArray（[1,2,3]）；=>真

is对象_.isObject（值） 来源
退换商品真的如果价值是一个对象。请注意，JavaScript数组和函数是对象，而（正常）字符串和数字不是对象。

_.isObject（｛｝）；=>真_.is对象（1）；=>假

是参数_.isArguments（对象） 来源
退换商品真的如果对象是Arguments对象。

（函数（）{return_.isArguments（参数）；}）（1，2，3）；=>真_.is参数（[1,2,3]）；=>假

is函数_.isFunction（对象） 来源
退换商品真的如果对象是一个函数。

_.isFunction（警报）；=>真

isString（isString）_.isString（对象） 来源
退换商品真的如果对象是字符串。

_.isString（“moe”）；=>真

is编号_.isNumber（对象） 来源
退换商品真的如果对象是一个数字（包括NaN公司).

_.is编号（8.4*5）；=>真

测试数值是否为有限数_.isFinite（对象） 来源
退换商品真的如果对象是一个有限的数字。

_.is有限（-101）；=>真_.is有限（-无限）；=>假

isBoolean（布尔值）_.isBoolean（对象） 来源
退换商品真的如果对象是其中之一真的或假。

_.isBoolean（空）；=>假

isDate（是日期）_.isDate（对象） 来源
退换商品真的如果对象是日期。

_.isDate（新日期（））；=>真

isRegExp公司_.isRegExp（对象） 来源
退换商品真的如果对象是RegExp。

_.isRegExp（/moe/）；=>真

is错误_.isError（对象） 来源
退换商品真的如果对象继承自错误。

尝试{throw new TypeError（“示例”）；}捕获（o_o）{_.is错误（o_o）；}=>真

IS符号_.isSymbol（对象） 来源
退换商品真的如果对象是一个符号。

_.isSymbol（符号（））；=>真

isMap地图_.isMap（对象） 来源
退换商品真的如果对象是一个地图。

_.isMap（新Map（））；=>真

isWeakMap（isWeak地图）_.isWeakMap（对象） 来源
退换商品真的如果对象是一个WeakMap（弱点地图）。

_.isWeakMap（新的WeakMap（））；=>真

isSet（设置）_.isSet（对象） 来源
退换商品真的如果对象是一个设置。

_.isSet（新Set（））；=>真

isWeakSet（弱集）_.isWeakSet（对象） 来源
退换商品真的如果对象是一个弱集。

_.isWeakSet（弱集（））；=>真

isArrayBuffer（isArray缓冲区）_.isArrayBuffer（对象） 来源
退换商品真的如果对象是一个阵列缓冲区。

_.isArrayBuffer（新的ArrayBuffer（8））；=>真

isDataView（isDataView）_.isDataView（对象） 来源
退换商品真的如果对象是一个数据视图。

_.isDataView（新数据视图（新ArrayBuffer（8）））；=>真

isTypedArray_.isTypedArray（对象） 来源
退换商品真的如果对象是一个类型数组。

_.isTypedArray（新的Int8Array（8））；=>真

是NaN_.isNaN（对象） 来源
退换商品真的如果对象是NaN公司。
注意：这不是和本地人一样是NaN函数，该函数也将返回对于许多其他非数字值，例如未定义。

_.isNaN（NaN）；=>真isNaN（未定义）；=>真_.isNaN（未定义）；=>假

为Null_.isNull（对象） 来源
退换商品真的如果的值对象是无效的。

_.isNull（null）；=>真_.isNull（未定义）；=>假

未定义_.is未定义（值） 来源
退换商品真的如果价值是未定义。

_.isUndefined（window.missingVariable）；=>真

实用程序功能

无冲突_.noConflict（）（无冲突） 来源
控制全球_变量返回到上一个所有者。返回对强调对象。

var下划线=_.noConflict（）；

这个_.no冲突如果使用EcmaScript 6、AMD或CommonJS模块系统导入Undercore，则函数不存在。

身份_.identity（值） 来源
返回用作参数的相同值。数学方面：f（x）=x
此函数看起来没有用处，但在整个Undercore中用作默认迭代。

var stooge={名称：'moe'}；助手===_.身份（助手）；=>真

常数_.常量（值） 来源
创建一个函数，该函数返回与的论点_.常量。

var stooge={名称：'moe'}；弯曲===_.常数（弯曲）（）；=>真

noop公司_.noop（） 来源
退换商品未定义不管传递给它的参数是什么。用作可选回调参数的默认值。

obj.initialize=_.noop；

次_.times（n，iteratee，[context]） 来源
调用给定的迭代函数n个次。每次调用迭代调用时使用指数参数。生成返回值的数组。

_.times（3，函数（n）{genie.grantWishNumber（n）；}）；

随机的，随机的_随机（最小值，最大值） 来源
返回一个介于最小值和最大值，包括在内。如果只传递一个参数，它将返回一个介于0以及这个数字。

_.随机（0，100）；=> 42

混合蛋白_.mixin（对象） 来源
允许您使用自己的实用函数扩展Undercore。通过的散列{name:函数}定义以实现您的功能添加到Undercore对象以及OOP包装器。返回下划线对象以便于链接。

_.混合蛋白({大写：函数（字符串）{return string.charAt（0）.toUpperCase（）+string.substring（1）.toLowerCase（；}});_（“fabio”）.大写（）；=>“法比奥”

迭代_.interate（值，[context]） 来源
生成可应用于中每个元素的回调收藏。_.迭代支持多种速记常见回调用例的语法。取决于价值的类型，_.迭代将返回：

//没有价值_.interate（）；=>_.identity（）//功能_.iterate（函数（n）{return n*2；}）；=>函数（n）{return n*2；}//对象_.iterate（{firstName:'Chelsea'}）；=>_.matcher（{firstName:'Chelsea'}）；//还有别的吗_.interate（'firstName'）；=>_.property（'firstName'）；

以下Undercore方法通过_.迭代以下为：计数依据,每一个,滤波器,找到,findIndex（查找索引）,查找密钥,查找最后索引,分组依据,索引依据,地图,mapObject（映射对象）,最大值,最小值,隔板,拒绝,一些,排序依据,排序索引、和uniq公司

您可以覆盖_.迭代使用您自己的自定义功能，如果需要其他或不同的速记语法：

//支持`RegExp`谓词简写。var builtinIteratee=_.interate；_.interate=函数（值，上下文）{if（_.isRegExp（value））返回函数（obj）｛return value.test（obj）｝；return builtinIterate（value，context）；};

唯一ID_.uniqueId（[前缀]） 来源
为客户端模型或DOM元素生成全局唯一id那需要一个。如果前缀传递时，id将附加到其上。

_.uniqueId（“联系人”）；=>“contact_104”

逃跑_.escape（字符串） 来源
转义字符串以插入HTML，替换&,<,>,",`、和'字符。

_.逃避（“Curly，Larry&Moe”）；=>“Curly，Larry&Moe”

联合国环境规划署_.unescape（字符串） 来源
与…相反逃跑，替换&amp；,&它；,&gt；,&quot；,&#x60；和&#x27；和他们的同龄人。

_.unescape（“Curly，Larry&Moe”）；=>“Curly，Larry&Moe”

结果_.result（对象、属性、[defaultValue]） 来源
如果指定的财产是一个函数，然后调用它使用对象作为上下文；否则，返回它。如果是默认值提供，而属性不存在或未定义，则默认值为将返回。如果默认值是将返回其结果的函数。

var对象={cheese:“crumpets”，stuff:function（）{return“无意义”；}}；_.result（对象，'cheese'）；=>“面包屑”_.result（object，'stuff'）；=>“胡说八道”_.result（object，“肉类”，“火腿”）；=>“火腿”

现在_.now（） 来源
返回当前时间的整数时间戳，使用最快的方法。用于实现计时/动画功能。

_.now（）；=>1392066795351

模板_.template（templateString，[设置]） 来源
将JavaScript模板编译为可评估的函数用于呈现。用于从JSON呈现复杂的HTML位数据源。模板函数可以使用<%= … %>，以及执行任意JavaScript代码<% … %>。如果您希望插入一个值它是HTML扫描的，使用<%- … %>。当您评估模板函数，传入数据具有属性的对象对应于模板的自由变量。这个设置论点应为包含任何_.templateSettings（.template设置）这应该被推翻。

varcompiled=_.template（“hello:<%=name%>”）；已编译（{name:'moe'}）；=>“你好：moe”var-template=_.template（“<b><%-value%></b>”）；模板（{value:'<script>'}）；=>“<b>&lt；脚本&gt；</b>”

您还可以使用打印从JavaScript代码中。这是有时比使用更方便<%= ... %>。

var compiled=_.template（“<%print（'Hello'+epithet）；%>”）；编译（{修饰语：“走狗”}）；=>“你好，走狗”

如果ERB样式的分隔符不是您喜欢的，您可以更改Undercore的模板设置，使用不同的符号来设置插值代码。定义插值正则表达式匹配插入的逐字、逃跑正则表达式匹配在HTML-escape后插入，并且评价要匹配的正则表达式应在不插入结果的情况下计算的表达式字符串。请注意，如果模板的一部分与其中多个匹配正则表达式，第一个将按以下优先级顺序应用：(1)逃跑, (2)插入, (3)评价.你可以定义或省略三者的任何组合。例如，要执行胡须.js-风格模板制作：

_.templateSettings={插值：/\{\{（.+？）\}\}/g};var-template=_.template（“你好{{name}}！”）；模板（{name:“Mustache”}）；=>“你好，胡子！”

默认情况下，模板将数据中的值放入本地范围通过具有声明。但是，您可以指定单个变量名使用变量设置。这可以显著提高速度模板能够渲染的位置。

_.template（“Using‘with’：<%=data.answer%>”，{variable:‘data’}）（{answer:‘no”}）；=>“使用‘with’：no”

预编译模板对调试无法调试的错误有很大帮助复制。这是因为预编译模板可以提供行号和堆栈跟踪，这在客户端编译模板时是不可能的。这个来源属性在编译的模板上可用函数，便于预编译。

<脚本>JST.project=<%=_.template（jstText）.source%>；</script>

面向对象样式

您可以在面向对象或函数样式中使用Undercore，取决于你的喜好。以下两行代码是将数字列表加倍的相同方法。来源,来源

_.map（[1,2,3]，函数（n）{return n*2；}）；_（[1,2,3]）.map（函数（n）{return n*2；}）；

链传动

打电话链将导致所有未来的方法调用返回包裹的对象。完成计算后，调用价值以检索最终值。下面是链接的一个示例一起a映射/展平/缩小，以便获得字数一首歌中的每个词。

var歌词=[{行：1，单词：“我是个伐木工人，我很好”}，{行：2，单词：“我睡了一夜，工作了一整天”}，{第3行，单词：“他是个伐木工人，没事”}，{第4行，单词：“他整夜睡觉，整天工作”}];_.chain（歌词）.map（函数（行）{返回行.words.split（''）；}）.展平（）.reduce（函数（计数，字）{counts[word]=（counts[word]|0）+1；返回计数；}，｛｝）.value（）；=>{伐木工人：2，全部：4，晚上：2…}

此外阵列原型的方法通过链接的Undercore对象进行代理，因此可以使用颠倒或a推进入你的链条，并继续修改数组。

链_.chain（对象） 来源
返回包装的对象。将继续对此对象调用方法返回包裹的对象，直到价值被调用。

var stooges=[{name：‘curly’，年龄：25}，{name：'moe'，年龄：21}，[name：‘larry’，年纪：23}]；var younger=_.chain（弯道）.sortBy（函数（stooge）{return stooge.age；}）.map（函数（stooge）｛return stooge.name+‘is’+stooge.age；｝）.first（）.value（）；=>“moe是21”

价值_.chain（对象）.value（） 来源
提取包裹对象的值。

_.链（[1,2,3]）.reverse（）.value（）；=> [3, 2, 1]

链接和建议阅读

下划线.lua,两种语言都适用的函数的Lua端口。包括OOP-包装和链接。(来源)

多拉·斯威夫特，Swift端口许多Underscore.js函数以及更多。(来源)

强调。米，一个Objective-C端口许多Underscore.js函数中，使用的语法鼓励链接。(来源)

_.米，另一种选择Objective-C端口尝试与原始端口更接近Underscore.js API。(来源)

下划线.php,两种语言都适用的函数的PHP端口。为PHP 5.4量身定制，并考虑到数据类型容差。(来源)

下划线,许多Underscore.js函数的Perl端口，针对Perl哈希和数组。(来源)

下划线.cfc,许多Undercore.js函数的Coldfusion端口。(来源)

下芯管柱,添加字符串操作功能的Undercore扩展：修剪,启动方式,包含,资本化,颠倒,把格式数据写成串等等。

底层java,适用于两种语言的函数的java端口。包括OOP-包装和链接。(来源)

鲁比的可枚举模块。

原型.js，提供以最接近Ruby Enumerable的方式使用集合函数的JavaScript。

奥利弗·斯蒂尔的功能JavaScript,它包括全面的高阶函数支持以及字符串lambdas。

迈克尔·奥弗雷特的数据.js,JavaScript的数据操作+持久性库。

Python的itertools软件。

PyToolz公司，Python端口它扩展了itertools和functools，以包括底层API。

有趣，一个实用的Python的函数助手集合，部分灵感来自Undercore。

笔记

关于使用<在下芯
底层依赖于排序的函数，例如_排序依据和_.sorted索引，使用JavaScript的内置关系运算符,特别是“小于”运算符<。它是重要的是要理解这些运算符只对数字和字符串。您可以向它们抛出任何值，但JavaScript将首先将操作数转换为字符串或数字，然后再执行实际比较。如果传递的操作数不能有意义地转换为字符串或数字，结果是NaN公司默认情况下。这个值不可靠。

理想情况下，您要排序的值应该是全部（意指可转换为）字符串或全部（意指可兑换至）编号。如果不是这样，您有两个选项：

• _.过滤器排除所有不可靠的值第一。
• 选择目标类型，即字符串或数字，并传递迭代到你的下腹部函数，将其参数转换为目标类型。例如，如果您有一个数字数组您想要排序，它可能偶尔包含无效的或未定义，您可以控制是否要对这些进行排序通过传递迭代到_排序依据那就回来了-无限或+无限对于这些值。或者你想将其视为零；这取决于你。相同的迭代也可以传递给其他Undercore函数，以确保行为是一致的。

更改日志

1.13.6—2022年9月24日—差异—文件
1.13.5版的修补程序，用于删除安装后脚本来自package.json意外地破坏了许多人的构建。

1.13.5—2022年9月23日—差异—文件

• 添加一个模块json包的子条目导出.要求条件。当绑定工具（例如Rollup with recent versions of）@汇总/插件节点解析，从字面上理解导出映射，这应该可以避免最终包中包含不同模块格式的Undercore的多个副本的情况。
• 测试基础设施和开发依赖性的更新。
• 无代码更改。

1.13.4—2022年6月2日—差异—文件

• 修复了WebPack模块联合的兼容性问题。
• 文档改进。

1.13.3—2022年4月23日—差异—文件

• 修复了ExtendScript的兼容性问题。
• 对测试和持续集成的各种改进，包括增加安全扫描和减少碳排放足迹。

1.13.2—2021年12月16日—差异—文件

• 修复了1.9.0中引入的导致_.样品和_.洗牌不再工作字符串。
• 修复了IE8兼容代码中的一个问题。
• 使网站具有移动友好性。
• 各种其他次要文档增强和新测试。

1.13.1—2021年4月15日—差异—文件

• 恢复undercore.js下提交给GitHub的别名存储库。
• 向文档中添加一些构建说明。
• 无代码更改。

1.13.0—2021年4月9日—差异—文件

• 合并从1.13.0-0到1.13.0-3预览的更改发布到版本1.12.1之后的主发布流中。作为在此版本中，ESM支持率为100%。
• 添加一个安全策略到文档。
• 将资金信息添加到文档中。

1.13.0-3—2021年3月31日—差异—文件

• 添加一个“模块”将条件导出到软件包.json理论上应该有助于避免重复代码绑定出口-感知构建工具。
• 将一些注释和文档文本与1.12.x支管。

1.13.0-2—2021年3月15日—差异—文件

• 修复了中的相同安全问题_.模板作为并行1.12.1版本。

1.12.1—2021年3月15日—差异—文件

• 修复了中的安全问题_.模板可以实现第三方在编译的模板中注入代码。这个问题影响1.3.2和1.12.0之间的所有版本的Undercore，包括1.13.0-0和1.13.0-1预览版。这个此版本中的修复也包含在并行预览中版本1.13.0-2。CVE-2021-23358
• 恢复中的优化_.去抖动那是在版本1.9.0中意外丢失（与并行预览中相同版本1.13.0-0）。
• 各种测试和文档增强功能（与并行功能相同预览版本1.13.0-0和1.13.0-1）。

1.13.0-1—2021年3月11日—差异—文件

• 修复了导致命名的在Node.js 12+的新本机ESM入口点中导出。
• 更多测试和文档修复及增强。

1.13.0-0—2021年3月9日—差异—文件

• 在Node.js中添加对本机ESM导入的实验支持。你现在还可以直接执行命名导入甚至深层模块导入Node.js版本12及更高版本中的Node.js进程。整体式建议在生产中使用进口产品。状态（例如混合功能）在CommonJS和ESM用户之间共享。
• 将UMD包重命名为下核-umd.js对于与其他包名称的一致性。名为的别名undercore.js下保留以实现向后兼容性。
• 恢复中的优化_.去抖动那是在1.9.0版中意外丢失。
• 各种测试和文档增强功能。

1.12.0—2020年11月24日—差异—文件

• 添加_.获取和_.to路径功能。后者可以重写以自定义deep的解释Undercore中的属性路径。的未来版本Undercore-contrib将为此提供现成的功能目的；用户将能够选择基于字符串的路径人手不足，如“a.0.b”和'a[0][“b”]'通过使用Underscore-contrib中的函数覆盖_.to路径。
• 修复中的错误_.等于导致类型化数组查看相同的不同片段时比较相等潜在的阵列缓冲区。
• 改进了的兼容性_.等于,_.is数据视图,_.is地图,_.is弱映射和_.is设置使用一些较旧的浏览器，尤其是IE 11。
• 显著提高了_.is空和isType函数系列的几个成员。
• 加速_.等于类型化数组与数据视图s与恒等式缓冲器,字节偏移量和字节长度。
• 在持续集成期间恢复跨浏览器测试并添加了有关引擎兼容性的文档。
• 精简测试的开发依赖性。

1.11.0—2020年8月28日—差异—文件—第条

• 将每个函数的源代码放在单独的模块中，如下所示升级到EcmaScript 6出口表示法版本1.10.0的.AMD和CommonJS版本还提供了功能模块。这带来了完美为所有用户创建树并解锁创建无代码大小开销的任意自定义Undercore构建。模块/index.js仍然存在，并且UMD捆绑包是仍然建议大多数用户使用。
  由于模块化使差异变得模糊，下面提供了分段差异。
  • 模块化前的更改
  • 模块化本身
  • 模块化后的变化
• 添加EcmaScript 6模块格式的单片束，下芯-esm.js，作为现代替代品单片UMD束。要在中使用ES模块导入的用户建议浏览器使用这个新捆绑包，而不是模块/index.js，因为下芯-esm.js在一次下载中提供了完整的Undercore接口。
• 添加带注释源的模块化版本，反映完整的主要源代码的内部结构。
• 添加_.isArrayBuffer（.isArray缓冲区）,_.is数据视图和_.isTypedArray功能，以及对对应的值类型_.等于。
• 添加将数组展平到特定深度的选项：_.展平（anArray，3）。
• 添加_.转置作为的别名_.unzip文件。
• 修复了以下情况下的不一致阵列原型上的方法当包装值为无效的或未定义。这些方法现在执行与其他Undercore函数一样，在null值上使用no-op。
• 修复了导致_.首先和_.最后到返回[]而不是未定义对于空数组用作迭代时。
• 修复了1.9.0版中引入的导致_.bindAll（全部绑定）返回未定义而不是绑定对象。
• 使用Travis CI恢复持续集成测试。
• 取代污名化中的“白名单”/“黑名单”术语中立方的意见和文件“允许”/“不允许”术语。
• 对文档、源代码注释和测试。

1.10.2—2020年3月30日—差异—文件

• 修复了引入的错误1.10.0，同时使用旧版Node.js需要API：var _=require（“下划线”）_

1.10.1—2020年3月30日—差异—文件

• 修复了ES模块之间的相对链接以包含文件扩展，用于web浏览器支持。

1.10.0—2020年3月30日—差异—文件

• 重新格式化源代码以使用EcmaScript 6出口符号。这个undercore.js下UMD捆绑包现在已编译从基础源模块，而不是存在这个来源。从现在起，Rollup用户可以选择从导入基础源模块，以便启用树生成。
• 在文档中显式声明，并在单元测试，即_.sortedIndex（数组，值）总是返回下限，即最小指数，其中价值可以插入阵列。
• 将_最大值unittest与一致其他单元测试。
• 修复了一个错误，如果重写实施_.迭代试图回到原始实现。
• 恢复与EcmaScript 3和ExtendScript的兼容性。

1.9.2—2020年1月6日—差异—文件

• 无代码更改。更新测试以提供帮助CITGM公司。

1.9.1—2018年5月31日—差异—文件

• 修复了1.9.0中的边案例回归，包括某些形式的呼叫_.首先和_.最后在空数组上，并将数组作为键传递给_.countBy（计数依据）和_.分组依据。

1.9.0—2018年4月18日—差异—文件

• 添加_.restArguments参数变函数的函数处理。
• 添加_.区块用于将数组分块的函数。
• 添加一个_.is符号,_.is地图,_.is弱映射,_.is设置和_.is弱集功能。
• _.节气门和_.去抖动现在返回的函数有一个.cancel（）方法，可用于取消任何定时通话。
• _.属性现在接受键和索引数组作为路径说明符，用于查找值的深层属性。
• _.范围现在接受负范围生成降序数组。
• 添加了对以下几种环境的支持：WebWorkers、，浏览和ES6导入。
• 删除组件.json作为组件包管理系统中断。
• 现在可以通过设置来配置用于部分的占位符_.部分.占位符。
• _.bindAll（全部绑定）现在接受键的数组或参数。
• 三年的绩效改进。

1.8.3—2015年4月2日—差异—文件

• 添加_.创建方法，作为精简版本的对象.创建。
• 解决iOS错误，该错误可能会导致类似阵列进行JIT-ed.还修复了传递时的错误0到类似阵列。

1.8.2—2015年2月22日—差异—文件

• 恢复以前在中更改的旧Internet Explorer边缘案例1.8.1.
• 添加一个来自索引的参数_.包含。

1.8.1—2015年2月19日—差异—文件

• 修复/更改一些旧的Internet Explorer和相关的边缘案例行为。在旧IE中使用Undercore 1.8.1测试您的应用程序，并让我们知道它在做什么。。。

1.8.0—2015年2月19日—差异—文件

• 补充_.map对象，类似于_.map（地图），但只是对象中的值。（真的很讨人喜欢。）
• 补充_.all键它返回全部的可枚举属性对象上的名称。
• 还原了1.7.0更改，其中_.延伸只复制了“自己的”属性。希望这能让你不受伤害——如果它伤害了你我再次道歉。
• 补充_.extendOwn（扩展本机）-一种不太有用的形式_.延伸那个仅复制“自己的”属性。
• 补充_.find索引和_.find最后索引功能，这很好地补充了他们的双赢_.索引属于和_.lastIndexOf。
• 添加了一个_.is匹配谓词函数，告诉您对象匹配键值属性。亲吻的堂兄弟_.等于和_匹配器。
• 添加了一个_.is错误功能。
• 恢复了_.unzip文件函数作为的逆函数拉链。翻转。我知道。
• _.结果现在接受一个可选的回退值（或函数提供回退值）。
• 添加了_.属性属于作为镜像世界的函数生成器的版本_.属性。
• 已弃用_.个匹配项现在，它被称为更和谐的姓名-_匹配器。
• 各种各样的代码简化，为改进而进行的更改跨平台兼容性和边缘案例错误修复。

1.7.0—2014年8月26日—差异—文件

• 为了保持浏览器之间的一致性和速度，Underscore现在忽略了的本机数组方法对于每个,地图,减少,减少右侧,滤波器,每一个,一些,索引属于、和最后索引。“稀疏”阵列是在Undercore正式死亡。
• 补充_.迭代自定义集合使用的迭代器功能。许多Undercore方法将采用字符串参数以更容易_.属性-样式查找，对象_.其中-风格筛选，或将函数作为自定义回调。
• 补充_.之前作为对应项_.之后。
• 补充_.否定反转传入的真实值谓语。
• 补充_.无作为一个方便的空占位符函数。
• _.is空现在与一起工作论据物体。
• _.具有现在可以防止nursh对象。
• _.省略现在可以使用iterate函数。
• _.分区现在用调用指数和对象。
• _.个匹配项创建对象的浅层克隆并仅迭代超过自己的财产。
• 更好地与即将推出的ECMA6保持一致对象分配,_.延伸只迭代对象自己的属性。
• 不再需要假警卫_.延伸和_.defaults（默认值）-如果传入的参数不是JavaScript对象，它刚刚返回。
• 修复了中的一些边缘情况_最大值和_最小值到句柄数组包含NaN公司（如字符串或其他对象）和无穷和-无限。
• 覆盖基本方法，如每个和一些其他Undercore函数也将在内部使用它们。
• 转义函数处理反勾号(`)，以处理IE≤8缺陷。
• 为了一致性，_.活接头和_.差异现在只能使用数组，而不能使用可变参数。
• _.备忘录将存储值的缓存公开为属性在返回的函数上。
• _.选择接受迭代和上下文参数用于更高级的回调。
• 下划线模板不再接受首字母数据对象。_.模板现在总是返回一个函数。
• 大量优化和代码清理。

1.6.0—2014年2月10日—差异—文件

• Undercore现在为AMD（Require.js）、Bower和Component注册，以及CommonJS模块和常规（Java）脚本。丑陋，但可能是必要的。
• 补充_.分区，一种将集合拆分为两个列表的方法结果-那些通过的和那些不通过特定谓词的。
• 补充_.属性，便于创建拉式迭代器对象的特定属性。与其他工具结合使用底层收集功能。
• 补充_.个匹配项，一个将为您提供谓词的函数可以用来判断给定对象是否与指定的列表匹配键/值属性。
• 补充_.常量，作为高阶_.标识。
• 补充_.现在，一种获得时间戳的优化方法-已使用内部加速消除颤抖和节气门。
• 这个_.部分函数现在可用于部分应用它的任何参数，通过传递_无论你想去哪里占位符变量，稍后填写。
• 这个_.每个函数现在返回对链表的引用。
• 这个_.键函数现在为返回一个空数组不要扔东西。
• …以及其他各种重构。

1.5.2—2013年9月7日—差异—文件

• 添加了一个索引依据功能，与表亲，计数依据和分组依据。
• 添加了一个样品函数，用于从数组。
• 与可以实现的函数相关的一些优化依据_.键（主要包括：，每个对象上）。也适用于消除颤抖在一个紧密的循环中。
• 这个_.逃生函数不再转义“/”。

1.5.1—2013年7月8日—差异—文件

• 远离的解压缩，因为它只是应用拉链到参数数组。使用_.zip.apply（_，列表）到改为换位。

1.5.0—2013年7月6日—差异—文件

• 添加了一个新解压缩函数，作为_.zip。
• 这个节气门函数现在接受选项参数，允许您禁用对任一这个主要的或拖尾边缘。
• 现在提供了一个源映射，以便更容易调试缩小的Undercore的生产构建。
• 这个默认值函数现在仅覆盖未定义值，而不是无效的个。
• 删除了呼叫功能_.bindAll（全部绑定）没有方法名称论据。允许要绑定的方法。
• 删除了呼叫功能_.之后具有调用计数为零。现在（自然）最少通话次数为1。

1.4.4—2013年1月30日—差异—文件

• 已添加_.find位置，用于查找列表中的第一个元素匹配一组特定键和值的。
• 补充_.部分，用于部分应用函数没有将其动态引用更改为这。
• 简化绑定通过删除一些涉及构造函数函数。简而言之：不要_.绑定你的建造师。
• 对援引。
• 修复缩小版中由于缩小器错误而导致的错误优化路径is函数。

1.4.3—2012年12月4日—差异—文件

• 改进了与Adobe JS引擎的Undercore兼容性用于编写Illustrator、Photoshop和朋友的脚本。
• 添加了默认值_.标识迭代器到计数依据和分组依据。
• 这个uniq公司函数现在可以接受数组，迭代器，上下文作为参数列表。
• 这个次函数现在返回迭代器的映射数组结果。
• 简化并修复了中的错误节气门。

1.4.2—2012年10月6日—差异—文件

• 为了向后兼容性，当经过无效的迭代函数。他们现在成了无赖再一次。

1.4.1—2012年10月1日—差异—文件

• 修复了中的1.4.0回归最后索引功能。

1.4.0—2012年9月27日—差异—文件

• 添加了一个对函数，用于旋转JavaScript对象进入之内[键，值]对。。。以及一个对象函数，用于转换[键，值]对到一个对象中。
• 添加了一个计数依据函数，用于计算对象数在符合特定标准的列表中。
• 添加了使转化函数，用于执行简单的反转对象中的键和值。
• 添加了一个哪里函数，用于筛选列表的简单情况用于具有特定值的对象。
• 添加了一个省略函数，用于过滤要删除的对象某些键。
• 添加了一个随机的，随机的函数，返回给定范围。
• _.去抖动'd函数现在返回其上次更新的值，就像是_.节气门'd函数。
• 这个排序依据函数现在运行稳定的排序算法。
• 添加了可选来自索引选择索引属于和最后索引。
• Undercore迭代中不再支持“稀疏”数组功能。使用对于而不是循环（或者更好的是，一个对象）。
• 这个最小值和最大值现在可以调用函数非常大型阵列。
• 模板中的插值现在表示无效的和未定义作为空字符串。
• 底层迭代函数不再接受无效的值作为no-op参数。你会得到一个早期错误。
• 许多边盒修复和调整，您可以在差异。根据您使用Undercore的方式，1.4.0可能会更多后端与通常不兼容，请在升级时进行测试。

1.3.3—2012年4月10日—差异—文件

• 许多改进_.模板，现在提供来源将模板函数作为属性在服务器端进行更高效的预编译。你现在可以还设置变量选项，这将使您的传入数据在命名的变量，而不是使用具有声明-显著提高了渲染模板的速度。
• 添加了挑选函数，它允许您筛选带有允许属性名称列表的对象文字。
• 添加了结果功能，便于工作使用允许函数或原始属性的API。
• 添加了测试数值是否为有限数功能，因为有时知道值是一个数字，只是还不够。
• 这个排序依据函数现在也可以传递字符串名要用作每个对象的排序顺序的属性。
• 固定的uniq公司使用稀疏数组。
• 这个差异函数现在执行浅层展平而不是在计算数组差异时进行深层计算。
• 这个消除颤抖函数现在接受立即的参数，这将导致对前导函数触发回调而不是后缘。

1.3.1—2012年1月23日—差异—文件

• 添加了一个_.具有功能，作为一种更安全的使用方式拥有自己的财产。
• 补充_.收集作为的别名_.map（地图）小说家们，高兴吧。
• 恢复了旧更改，以便_.延伸将正确复制再次覆盖具有未定义值的键。
• 修复了中的插值中停止转义斜杠的错误_.模板。

1.3.0—2012年1月11日—差异—文件

• 从Undercore中删除了AMD（RequireJS）支持。如果您想使用使用RequireJS作为底层，可以将其作为普通脚本加载或者修补副本，或者下载分叉版本。

1.2.4—2012年1月4日—差异—文件

• 你现在可以（而且可能应该，因为它更简单）写_.chain（列表）而不是_（列表）.chain（）。
• 修复Underscore模板中的转义字符，并支持自定义_.templateSettings（.template设置）只定义一个或两个必需的正则表达式。
• 修复将数组作为第一个参数传递给_.wrap（包裹）'d函数。
• 改进了与ClojureScript的兼容性，它添加了呼叫函数到字符串模式。

1.2.3—2011年12月7日—差异—文件

• 现在保留动态范围以供编译_.模板功能，所以您可以使用这如果你愿意的话。
• 稀疏阵列支持_.索引属于,_.lastIndexOf。
• 两者都有_.减少和_.reduce右侧现在可以传递一个明确地未定义值。（你没有理由想这样做。）

1.2.2—2011年11月14日—差异—文件

• 继续调整_.等于语义。现在JS原语是将其视为等效于其包装版本，并对数组进行比较仅通过其数字属性(#351)。
• _.逃生不再试图聪明地避免双重逃避已经跳过的HTML实体。现在不管怎样，它只是逃走了(#350)。
• 在_.模板，您现在可以将分号排除在评估之外声明（如果您愿意）：<% }) %> (#369)。
• _.after（回调，0）现在将立即触发回调，使“after”更易于与异步API一起使用(#366)。

1.2.1—2011年10月24日—差异—文件

• 几个重要的错误修复_.等于，现在应该在变异数组上做得更好，在非数组对象上用长度属性。(#329)
• 詹姆斯·布克为AMD模块加载器提供Undercore导出，以及托尼·卢卡萨瓦吉适用于Appcelerator Titanium。(#335, #338)
• 你现在可以了_.groupBy（列表，“属性”）作为的快捷方式按特定的公共属性对值进行分组。
• _.节气门'd函数现在在调用时立即触发，并在之后以速率限制(#170, #266)。
• 大多数_.是[类型]不再检查ducktype。
• 这个_.绑定函数现在也适用于构造函数a-laES5。。。但你永远不会想用_.绑定在上构造函数。
• _.clone（克隆）不再包装对象中的非对象类型。
• _.查找和_.过滤器现在是的首选名称_.检测和_.选择。

1.2.0—2011年10月5日—差异—文件

• 这个_.等于立即运行支持真正的深度相等比较，并检查循环结构，感谢Kit Cambridge。
• Underscore模板现在支持HTML转义插值，使用<%- ... %>语法。
• Ryan Tenney贡献了_.洗牌，它使用修改的Fisher-Yates给你一个数组的洗牌副本。
• _.uniq文件现在可以传递一个可选迭代器，由对象应该被视为唯一的标准。
• _.最后现在接受一个可选参数，它将返回最后一个列表中的N个元素。
• 一个新的_.初始添加了函数，作为_.休息,它返回列表的所有初始值（最后一个N除外）。

1.1.7—2011年7月13日—差异—文件
补充_.分组依据，它将集合聚合为类似项目的组。补充_.活接头和_.差异，以补充（重新命名）_.十字路口。支持稀疏阵列的各种改进。_.toArray（阵列）现在，如果直接传递数组，则返回克隆。_.函数现在还返回当前函数的名称在原型链中。

1.1.6—2011年4月18日—差异—文件
补充_.之后，它将返回一个只在以下时间之后运行的函数第一次被调用指定次数。_.调用现在可以直接引用函数。_.每现在需要传递迭代器函数，该函数镜像ES5 API。_.延伸当值未定义时，不再复制键。_.绑定现在，尝试绑定未定义的值时出错。

1.1.5—2011年3月20日—差异—文件
添加了一个_.defaults（默认值）函数，用于合并JS对象表示默认选项。添加了_.一次功能，对于应该只执行一次。_.绑定现在委托本机ES5版本，如果可用。_.键现在在非对象值上使用时会抛出错误，如ES5。修复了一个错误_.键在稀疏数组上使用时。

1.1.4—2011年1月9日—差异—文件
提高了在通过时对ES5的Array方法的遵从性无效的作为一个值。_.wrap（包裹）现在设置正确这对于包装函数。_.索引属于现在为在保证已经存在的数组中查找插入索引进行排序。避免使用.被调用者，以允许_.is阵列在ES5的严格模式下正常工作。

1.1.3—2010年12月1日—差异—文件
在CommonJS中，现在可能需要Undercore，只需：
var _=要求（“下划线”）。补充_.节气门和_.去抖动功能。远离的_.break循环，支持ES5样式的un-打破-能够每个实现—这将删除try/catch，现在您将拥有更好地跟踪Undercore迭代器中抛出的异常的堆栈。改进了is类型实现更好互操作性的函数系列使用Internet Explorer主机对象。_.模板现在可以正确转义模板中的反斜杠。改进_.减少与ES5版本的兼容性：如果不传递初始值，则使用集合中的第一项。_.每个不再返回迭代集合，用于改进与ES5的一致性对于每个。

1.1.2—2010年10月15日—差异—文件
固定的_.包含，错误地指向_.相交而不是_.包括，就像它应该的那样一直都是。补充_.独一无二作为的别名_.uniq文件。

1.1.1—2010年10月5日—差异—文件
提高了_.模板，及其对多行的处理插值。Ryan Tenney为许多Undercore贡献了优化功能。源代码的注释版本现在可用。

1.1.0—2010年8月18日—差异—文件
的方法签名_.减少已更改为匹配ES5签名，而不是Ruby/Prototype.js版本。这是一个落后且不兼容的变化。_.模板现在可能是调用时不带参数，并保留空白。_.包含是的新别名_.包括。

1.0.4—2010年6月22日—差异—文件
安德里·莫尔贡献了_.备忘录函数，可用于加快昂贵的重复计算通过缓存结果。

1.0.3—2010年6月14日—差异—文件
修补程序，使_.等于返回假如果有财产比较对象的NaN公司值。从技术上讲是正确的要做的事情，但语义有问题。注意NaN比较。

1.0.2—2010年3月23日—差异—文件
修复_.is参数在最新版本的Opera中参数对象作为真实数组。

1.0.1—2010年3月19日—差异—文件
的Bugfix_.等于，将两个对象与同一对象进行比较时未定义键的数量，但名称不同。

1.0.0—2010年3月18日—差异—文件
事情已经稳定了好几个月了，所以Underscore现在被认为已经过测试期1自年以来的改进0.6包括_.is布尔值以及_.延伸获取多个源对象。

0.6.0—2010年2月24日—差异—文件
主要版本。包含多个Mile Frawley的重构在收集函数上使用更安全的duck-type，内部更干净。一个新的_.混合蛋白方法，该方法允许您使用实用程序扩展Undercore您自己的功能。补充_.次，其工作原理与中相同Ruby或Prototype.js。ES5的本机支持阵列.isArray,和对象.键。

0.5.8—2010年1月28日—差异—文件
修复了Undercore的收集功能节点列表和HTML集合再次感谢贾斯汀·塔洛斯。

0.5.7—2010年1月20日—差异—文件
更安全地实现_.is参数、和更快_.is编号,
多亏了杰德·施密特。

0.5.6—2010年1月18日—差异—文件
可自定义的分隔符_.模板，出资人诺亚·斯隆。

0.5.5—2010年1月9日—差异—文件
使用arguments对象修复MobileSafari的OOP-wrapper中的错误。

0.5.4—2010年1月5日—差异—文件
修复模板字符串中的多个单引号_.模板参见：Rick Strahl的博客帖子。

0.5.2—2010年1月1日—差异—文件
的新实现isArray（isArray）,isDate（是日期）,is函数,is编号,isRegExp公司、和isString（isString），多亏了来自的建议罗伯特·基弗。而不是做对象#toString比较，他们现在检查预期属性，这不太安全，但速度要快一个数量级以上。大多数其他底纹结果，函数的速度略有提高。Evgeniy Dolzhenko公司贡献_.tap（点击）,类似于Ruby 1.9,这对于将副作用（如日志记录）注入到链式调用中很方便。

0.5.1—2009年12月9日—差异—文件
添加了一个_.is参数功能。大量的小安全检查和优化贡献于诺亚·斯隆和安德里·莫尔。

0.5.0—2009年12月7日—差异—文件
[API更改] _.bindAll（全部绑定）现在将上下文对象作为它的第一个参数。如果没有传递方法名称，则所有上下文对象的方法被绑定到它，从而实现链接和更容易的绑定。_.函数现在接受一个参数并返回名称它的函数属性。打电话_.函数（_）会抓住你的之前的行为。补充_.isRegExp接口以便等于现在可以测试RegExp相等性。所有的“is”函数都被缩减为一个单独的定义。卡尔·格廷贡献的补丁。

0.4.7—2009年12月6日—差异—文件
已添加isDate（是日期）,是NaN、和为Null，以确保完整性。优化等于检查数组之间的相等性时或日期。_.键现在是25%–2倍更快（取决于您的浏览器），它可以加速依赖它的功能，例如_.每个。

0.4.6—2009年11月30日—差异—文件
添加了范围函数的端口蟒蛇同名函数，用于生成灵活编号的列表整数的。原始修补程序由贡献基里尔·伊沙诺夫。

0.4.5—2009年11月19日—差异—文件
补充休息对于数组和参数对象，以及别名第一作为头、和休息作为尾,多亏了卢克·萨顿的修补程序。增加了测试，确保所有Undercore Array函数也适用于论据物体。

0.4.4—2009年11月18日—差异—文件
补充isString（isString）、和is编号，以保持一致性。固定的_.is相等（NaN，NaN）返回真的（这是有争议的）。

0.4.3—2009年11月9日—差异—文件
开始使用本机停止迭代对象。修复了CommonJS环境的Undercore设置。

0.4.2—2009年11月9日—差异—文件
将展开函数重命名为价值，以便清楚。

0.4.1—2009年11月8日—差异—文件
Chained Undercore对象现在支持Array原型方法，因此可以对包装好的数组执行全部操作而不必打破你的链条。添加了一个breakLoop（断环）方法到打破在任何Undercore迭代的中间。添加了一个栈空用于数组和对象的函数。

0.4.0—2009年11月7日—差异—文件
所有Undercore函数现在都可以以面向对象的方式调用，如此：_（[1,2,3]）.地图（…）；。原始补丁由提供马克·安德雷·库诺耶。包裹的对象可以通过多个链接方法调用。A类功能方法添加了，提供了Undercore中所有函数的排序列表。

0.3.3—2009年10月31日—差异—文件
添加了JavaScript 1.8功能减少右侧.别名作为文件夹和别名减少作为折页。

0.3.2—2009年10月29日—差异—文件
现在有库存犀牛口译员：加载（“underline.js”）。补充身份作为实用函数。

0.3.1—2009年10月29日—差异—文件
所有迭代器现在都作为第三个迭代器在原始集合中传递参数，与JavaScript 1.6相同对于每个.迭代对象现在用调用（值、键、集合），了解详细信息看见_.每个。

0.3.0—2009年10月29日—差异—文件
补充德米特里·巴拉诺夫斯基的综合优化，并入克里斯·科瓦尔的补丁制作Undercore通用JS和独角鲸符合。

0.2.0—2009年10月28日—差异—文件
补充组成和最后索引，已重命名注入到减少，为添加了别名注入,滤波器,每一个,一些、和对于每个。

0.1.1—2009年10月28日—差异—文件
补充无冲突，以便可以将“Undercore”对象指定给其他变量。

0.1.0—2009年10月28日—文件
Underscore.js的首次发布。