阵列 _.区块 _.紧凑 _.concat文件 _.差异 _差异依据 _.差异与 _.下降 _.drop右 _.drop右对齐 _.dropWhile（删除时） _.填充 _.find索引 _.find最后索引 _.首先 头 _.展平 _.展平深度 _.展平深度 _.from配对 _.头部 _.索引属于 _.初始 _.十字路口 _交点依据 _.相交于 _.加入 _.最后 _.lastIndexOf _.nth（第个） _.拉动 _.pull全部 _.全部拖动 _.pull全部包含 _.拉动位置 _.删除 _.反转 _.切片 _.sorted索引 _.sortedIndexBy排序依据 _.sortedIndexOf _.sorted最后索引 _排序上次索引依据 _.sorted最后索引 _.排序Uniq _.排序UniqBy _.尾部 _.采取 _.take向右 _.takeRightWhile _.takeWhile _.活接头 _.union依据 _.union包含 _.uniq文件 _.uniq依据 _.uniq包含 _.unzip文件 _.unzipWith解压缩 _.无 _.xor（异或） _.xor依据 _.xor与 _.zip文件 _.zip对象 _.zip对象深度 _.zip带有 收藏 日期 功能 冗长的 _.castArray格式 _.clone（克隆） _.cloneDeep（克隆深度） _.cloneDeepWith（克隆深度） _.Clone包含 _.确认至 _.当量 _。gt _.gte标准 _.is参数 _.is阵列 _.isArrayBuffer（.isArray缓冲区） _.is类似数组 _.isArrayLike对象 _.is布尔值 _.is缓冲区 _.is日期 _.is元素 _.is空 _.等于 _.is等于 _.is错误 _.is有限 _.is函数 _.isInteger _.is长度 _.is地图 _.is匹配 _.is匹配 _.是NaN _.is本机 _.为零 _.is空 _.is编号 _.is对象 _.is类对象 _.isPlain对象 _.isRegExp接口 _.is安全整数 _.is设置 _.is字符串 _.is符号 _.isTypedArray _.is未定义 _.is弱映射 _.is弱集 _.它 _.lte文件 _.toArray（阵列） _.to有限 _.to整数 _.to长度 _.to编号 _.toPlain对象 _.to安全整数 _.to字符串 对象 _.分配 _.assignIn（分配） _.分配InWith _.分配方式 _.在 _.创建 _.defaults（默认值） _.defaultsDeep（默认深度） _.个条目 到配对 _中的条目 对输入 _.延伸 分配In _扩展方式 分配InWith _.find密钥 _.find最后一个键 _.forIn（输入） _.对于InRight _.forOwn（自己的） _.forOwnRight（所有权） _.函数 _.函数位于 _.获取 _.具有 _.hasIn _.反转 _.反转方式 _.调用 _.键 _.keys输入 _.map键 _.map值 _.合并 _.合并与 _.省略 _.忽略者 _.选择 _.选择依据 _.结果 _.set（设置） _.set使用 _.to对 _.to输入对 _.转换 _.未设置 _.update（更新） _.updateWith（更新方式） _.值 _.值in 顺序 字符串 Util公司 属性 “数组”方法 _.chunk（数组，[大小=1]） 阵列 [大小=1] _ 。 块 ([ “a” , “b” , “c” , “d” ] , 2 ); //=>[[’a'，'b']，['c'，'d']] _ 。 块 ([ “a” , “b” , “c” , “d” ] , 三 ); //=>[['a'，'b'，'c']，[d']] _.compact（数组） 阵列 _ 。 契约 ([ 0 , 1 , 假 , 2 , '' , 三 ]); // => [1, 2, 3] _.concat（数组，[值]） 阵列 [值] 无功功率，无功功率 数组=[ 1 ]; 无功功率，无功功率 其他=_ 。 凹面（concat） （数组 , 2 , [ 三 ] , [[ 4 ]]); 慰问 。 日志 （其他）； //=>[1，2，3，[4] 慰问 。 日志 （数组）； // => [1] _.difference（数组，[values]） 阵列 [值] _ 。 差异 ([ 2 , 1 ] , [ 2 , 三 ]); // => [1] _.differenceBy（数组，[values]，[iterate=_.identity]） 阵列 [数值] [迭代=_.identity] _ 。 差异依据 ([ 2 。 1 , 1 。 2 ] , [ 2 。 三 , 三 。 4 ] , 数学 。 地板）； // => [1.2] //`_.property`迭代速记。 _ 。 差异依据 ([{ “x” : 2 } , { “x” : 1 }] , [{ “x” : 1 }] , “x” ); //=>[{“x”：2}] _.differenceWith（数组，[值]，[比较器]） 阵列 [值] [比较器] 无功功率，无功功率 对象=[{ “x” : 1 , “是” : 2 } , { “x” : 2 , “是” : 1 }]; _ 。 差异与 （对象 , [{ “x” : 1 , “是” : 2 }] , _ 。 等于）； //=>[{“x”：2，“y”：1}] _.drop（数组，[n=1]） 阵列 [n=1] _ 。 滴 ([ 1 , 2 , 三 ]); // => [2, 3] _ 。 滴 ([ 1 , 2 , 三 ] , 2 ); // => [3] _ 。 滴 ([ 1 , 2 , 三 ] , 5 ); //=>[] _ 。 滴 ([ 1 , 2 , 三 ] , 0 ); // => [1, 2, 3] _.dropRight（数组，[n=1]） 阵列 [n=1] _ 。 向右拖放 ([ 1 , 2 , 三 ]); // => [1, 2] _ 。 向右拖放 ([ 1 , 2 , 三 ] , 2 ); // => [1] _ 。 向右拖放 ([ 1 , 2 , 三 ] , 5 ); // => [] _ 。 向右拖放 ([ 1 , 2 , 三 ] , 0 ); // => [1, 2, 3] _.dropRightWhile（数组，[谓词=_.identity]） 阵列 [谓词=_.identity] 无功功率，无功功率 用户=[ { “用户” : “巴尼” , “活动” ：true} , ｛ “用户” : “弗雷德” , “活动” ：false｝ , { “用户” : “鹅卵石” , “活动” ：假} ]; _ 。 在右侧放置 （个用户 , 功能 （o） {返回！o 。 活性； }); //=>['barney']的对象 //`_.matches`迭代速记。 _ 。 在右侧放置 （个用户 , { “用户” : “鹅卵石” , “活动” ：false}）； //=>['barney'，'fred']的对象 //`_.matchesProperty`迭代速记。 _ 。 在右侧放置 （个用户 , [ “活动” , 错误]）； //=>['barney']的对象 //`_.property`迭代速记。 _ 。 在右侧放置 （个用户 , “活动” ); //=>['barney'，'fred'，'pebble']的对象 _.dropWhile（数组，[谓词=_.identity]） 阵列 [谓词=_.identity] 无功功率，无功功率 用户=[ { “用户” : “巴尼” , “活动” ：假} , { “用户” : “弗雷德” , “活动” ：假} , { “用户” : “鹅卵石” , “活动” ：true} ]; _ 。 dropWhile（删除While） （个用户 , 功能 （o） {返回！o 。 活性； }); //=>['pebbles']的对象 //`_.matches`迭代速记。 _ 。 dropWhile（删除While） （用户 , { “用户” : “巴尼” , “活动” ：false}）； //=>['fred'，'pebbles']的对象 //`_.matchesProperty`迭代缩写。 _ 。 dropWhile（删除While） （个用户 , [ “活动” , 错误]）； //=>['pebbles']的对象 //`_.property`迭代速记。 _ 。 dropWhile（删除While） （个用户 , “活动” ); //=>['barney'，'fred'，'pebbles']的对象 _.fill（数组，值，[start=0]，[end=array.length]） 阵列 价值 阵列 [开始=0] [end=array.length] 无功功率，无功功率 数组=[ 1 , 2 , 三 ]; _ 。 填满 （数组 , “a” ); 慰问 。 日志 （数组）； //=>[‘a’，‘a’，‘a’] _ 。 填满 ( 阵列 ( 三 ) , 2 ); // => [2, 2, 2] _ 。 填满 ([ 4 , 6 , 8 , 10 ] , '*' , 1 , 三 ); // => [4, '*', '*', 10] _.findIndex（数组，[谓词=_.identity]，[源索引=0]） 阵列 [谓词=_.identity] [fromIndex=0] 无功功率，无功功率 用户=[ { “用户” : “巴尼” , “活动” ：假} , { “用户” : “弗雷德” , “活动” ：假} , { “用户” : “鹅卵石” , “活动” ：true} ]; _ 。 查找索引 （个用户 , 功能 （o） {返回o 。 用户== “巴尼” ; }）； // => 0 //`_.matches`迭代速记。 _ 。 查找索引 （个用户 , { “用户” : “弗雷德” , “活动” ：false}）； //=>1 //`_.matchesProperty`迭代速记。 _ 。 查找索引 （个用户 , [ “活动” , 错误]）； // => 0 //`_.property`迭代速记。 _ 。 查找索引 （个用户 , “活动” ); // => 2 _.findLastIndex（数组，[谓词=_.identity]，[fromIndex=数组.length-1]） 阵列 [谓词=_.identity] [fromIndex=array.length-1] 无功功率，无功功率 用户=[ { “用户” : “巴尼” , “活动” ：true} , { “用户” : “弗雷德” , “活动” ：假} , ｛ “用户” : “鹅卵石” , “活动” ：假} ]; _ 。 查找最后索引 （个用户 , 功能 （o） {返回o 。 用户== “鹅卵石” ; }); // => 2 //`_.matches`迭代速记。 _ 。 查找最后索引 （个用户 , { “用户” : “巴尼” , “活动” ：true}）； // => 0 //`_.matchesProperty`迭代速记。 _ 。 查找最后索引 （个用户 , [ “活动” , 错误]）； // => 2 //`_.property`迭代速记。 _ 。 查找最后索引 （个用户 , “活动” ); //=>0 _.flature（数组） 阵列 _ 。 压扁 ([ 1 , [ 2 , [ 三 , [ 4 ]] , 5 ]]); // => [1, 2, [3, [4]], 5] _.flature Deep（数组） 阵列 _ 。 压扁深度 ([ 1 , [ 2 , [ 三 , [ 4 ]] , 5 ]]); // => [1, 2, 3, 4, 5] _.flature深度（数组，[depth=1]） 阵列 [深度=1] 无功功率，无功功率 数组=[ 1 , [ 2 , [ 三 , [ 4 ]] , 5 ]]; _ 。 展平深度 （数组 , 1 ); // => [1, 2, [3, [4]], 5] _ 。 展平深度 （数组 , 2 ); //=>[1，2，3，[4]，5] _.fromPairs（对） 对 _ 。 来自配对 ([[ “a” , 1 ] , [ “b” , 2 ]]); //=>{“a”：1，“b”：2} _.head（数组） 阵列 _ 。 头 ([ 1 , 2 , 三 ]); // => 1 _ 。 头 ([]); //=>未定义 _.indexOf（数组，值，[fromIndex=0]） 阵列 价值 [fromIndex=0] _ 。 索引属于 ([ 1 , 2 , 1 , 2 ] , 2 ); // => 1 //从“fromIndex”中搜索。 _ 。 索引属于 ([ 1 , 2 , 1 , 2 ] , 2 , 2 ); // => 3 _.initial（数组） 阵列 _ 。 最初的 ([ 1 , 2 , 三 ]); // => [1, 2] _交集（[数组]） [数组] _ 。 交叉 ([ 2 , 1 ] , [ 2 , 三 ])； // => [2] _.intersectionBy（[arrays]，[iterate=_.identity]） [数组] [迭代=_.identity] _ 。 交集依据 ([ 2 。 1 , 1 。 2 ] , [ 2 。 三 , 三 。 4 ] , 数学 。 地板）； // => [2.1] //`_.property`迭代速记。 _ 。 交集依据 ([{ “x” : 1 }] , [{ “x” : 2 } , { “x” : 1 }] , “x” ); //=>[｛'x'：1｝] _.intersectionWith（[数组]，[比较器]） [数组] [比较器] 无功功率，无功功率 对象=[{ “x” : 1 , “是” : 2 } , { “x” : 2 , “是” : 1 }]; 无功功率，无功功率 其他=[{ “x” : 1 , “是” : 1 } , { “x” : 1 , “是” : 2 }]; _ 。 与…相交 （对象 , 其他 , _ 。 等于）； //=>[{“x”：1，“y”：2}] _.join（数组，[分隔符='，']） 阵列 [分隔符='，'] _ 。 参加 ([ “a” , “b” , “c” ] , '~' ); //=>“a~b~c” _.lastIndexOf（数组，值，[fromIndex=array.length-1]） 阵列 价值 [fromIndex=array.length-1] _ 。 最后索引 ([ 1 , 2 , 1 , 2 ] , 2 ); // => 3 //从“fromIndex”中搜索。 _ 。 最后索引 ([ 1 , 2 , 1 , 2 ] , 2 , 2 ); // => 1 _.nth（数组，[n=0]） 阵列 [n=0] 无功功率，无功功率 数组=[ “a” , “b” , “c” , “d” ]; _ 。 第n个 （数组 , 1 ); //=>“b” _ 。 第n个 （数组 , - 2 ); //=>“c”； _.pull（数组，[值]） 阵列 [值] 无功功率，无功功率 数组=[ “a” , “b” , “c” , “a” , “b” , “c” ]; _ 。 拉 （数组 , “a” , “c” ); 慰问 。 日志 （数组）； //=>['b'，'b'] _.pullAll（数组，值） 阵列 值 无功功率，无功功率 数组=[ “a” , “b” , “c” , “a” , “b” , “c” ]; _ 。 pull全部 （数组 , [ “a” , “c” ]); 慰问 。 日志 （数组）； //=>['b'，'b'] _.pullAllBy（数组，值，[iterate=_.identity]） 阵列 值 [迭代=_.identity] 无功功率，无功功率 数组=[{ “x” : 1 } , { “x” : 2 } , { “x” : 三 } , { “x” : 1 }]; _ 。 拉动所有人 （数组 , [{ “x” : 1 } , { “x” : 三 }] , “x” ); 慰问 。 日志 （数组）； //=>[{“x”：2}] _.pullAllWith（数组，值，[比较器]） 阵列 值 [比较器] 无功功率，无功功率 数组=[{ “x” : 1 , “是” : 2 } , ｛ “x” : 三 , “是” : 4 } , { “x” : 5 , “是” : 6 }]; _ 。 拉动全部With （数组 , [{ “x” : 三 , “是” : 4 }] , _ 。 等于）； 慰问 。 日志 （数组）； //=>[{'x'：1，'y'：2}，{'x':5，'y':6}] _.pullAt（数组，[索引]） 阵列 [索引] 无功功率，无功功率 数组=[ “a” , “b” , “c” , “d” ]; 无功功率，无功功率 拉动=_ 。 拉动At （数组 , [ 1 , 三 ]); 慰问 。 日志 （数组）； //=>['a'，'c'] 慰问 。 日志 （拉动）； //=>['b'，'d'] _.remove（数组，[谓词=_.identity]） 阵列 [谓词=_.identity] 无功功率，无功功率 数组=[ 1 , 2 , 三 , 4 ]; 无功功率，无功功率 偶数=_ 。 去除 （数组 , 功能 （n）{ 返回n% 2 == 0 ; }); 慰问 。 日志 （数组）； // => [1, 3] 慰问 。 日志 （均匀）； // => [2, 4] _.reverse（数组） 阵列 无功功率，无功功率 数组=[ 1 , 2 , 三 ]; _ 。 颠倒 （数组）； // => [3, 2, 1] 慰问 。 日志 （数组）； // => [3, 2, 1] _.slice（数组，[start=0]，[end=array.length]） 阵列 [开始=0] [end=array.length] _.sortedIndex（数组，值） 阵列 价值 _ 。 排序索引 ([ 30 , 50 ] , 40 ); // => 1 _.sortedIndexBy（数组，值，[迭代=_.identity]） 阵列 价值 [迭代=_.identity] 无功功率，无功功率 对象=[{ “x” : 4 } , { “x” : 5 }]; _ 。 排序索引依据 （对象 , ｛ “x” : 4 } , 功能 （o） {返回o 。 x ; }); // => 0 //`_.property`迭代速记。 _ 。 排序索引依据 （对象 , { “x” : 4 } , “x” ); // => 0 _.sortedIndexOf（数组，值） 阵列 价值 _ 。 排序索引 ([ 4 , 5 , 5 , 5 , 6 ] , 5 ); // => 1 _.sortedLastIndex（数组，值） 阵列 价值 _ 。 排序的最后一个索引 ([ 4 , 5 , 5 , 5 , 6 ] , 5 ); // => 4 _.sortedLastIndexBy（数组，值，[迭代=_.identity]） 阵列 价值 [迭代=_.identity] 无功功率，无功功率 对象=[{ “x” : 4 } , { “x” : 5 }]; _ 。 最后索引排序依据 （对象 , { “x” : 4 } , 功能 （o） {返回o 。 x ; }); // => 1 //`_.property`迭代速记。 _ 。 最后索引排序依据 （对象 , { “x” : 4 } , “x” ); // => 1 _.sortedLastIndexOf（数组，值） 阵列 价值 _ 。 排序的最后索引 ([ 4 , 5 , 5 , 5 , 6 ] , 5 ); // => 3 _.sortedUniq（数组） 阵列 _ 。 排序Uniq ([ 1 , 1 , 2 ]); // => [1, 2] _.sortedUniqBy（数组，[迭代]） 阵列 [迭代] _ 。 排序UniqBy ([ 1 。 1 , 1 。 2 , 2 。 三 , 2 。 4 ] , 数学 。 地板）； // => [1.1, 2.3] _.take（数组，[n=1]） 阵列 [n=1] _ 。 拿 ([ 1 , 2 , 三 ]); // => [1] _ 。 拿 ([ 1 , 2 , 三 ] , 2 ); // => [1, 2] _ 。 拿 ([ 1 , 2 , 三 ] , 5 ); // => [1, 2, 3] _ 。 拿 ([ 1 , 2 , 三 ] , 0 ); // => [] _.takeRight（数组，[n=1]） 阵列 [n=1] _ 。 取得权利 ([ 1 , 2 , 三 ]); //=>[3] _ 。 取得权利 ([ 1 , 2 , 三 ] , 2 ); // => [2, 3] _ 。 取得权利 ([ 1 , 2 , 三 ] , 5 ); // => [1, 2, 3] _ 。 取得权利 ([ 1 , 2 , 三 ] , 0 ); // => [] _.takeRightWhile（数组，[谓词=_.identity]） 阵列 [谓词=_.identity] 无功功率，无功功率 用户=[ { “用户” : “巴尼” , “活动” ：true} , { “用户” : “弗雷德” , “活动” ：假} , { “用户” : “鹅卵石” , “活动” ：false｝ ]; _ 。 在右侧移动 （个用户 , 功能 （o） ｛返回！o 。 活性； }); //=>['fred'，'pebbles']的对象 //`_.matches`迭代速记。 _ 。 在右侧移动 （个用户 , { “用户” : “鹅卵石” , “活动” ：false}）； //=>['pebbles']的对象 //`_.matchesProperty`迭代速记。 _ 。 在右侧移动 （个用户 , [ “活动” , 错误]）； //=>['fred'，'pebbles']的对象 //`_.property`迭代速记。 _ 。 在右侧移动 （个用户 , “活动” ); // => [] _.takeWhile（数组，[谓词=_.identity]） 阵列 [谓词=_.identity] 无功功率，无功功率 用户=[ { “用户” : “巴尼” , “活动” ：假} , { “用户” : “弗雷德” , “活动” ：假} , { “用户” : “鹅卵石” , “活动” ：true} ]; _ 。 takeWhile（拍摄时） （个用户 , 功能 （o） {返回！o 。 活性； }); //=>['barney'，'fred']的对象 //`_.matches`迭代速记。 _ 。 takeWhile（拍摄时） （个用户 , { “用户” : “巴尼” , “活动” ：false}）； //=>['barney']的对象 //`_.matchesProperty`迭代速记。 _ 。 takeWhile （个用户 , [ “活动” , 错误]）； //=>['barney'，'fred']的对象 //`_.property`迭代速记。 _ 。 takeWhile （个用户 , “活动” ); //=>[] _.union（[数组]） [数组] _ 。 联盟 ([ 2 ] , [ 1 , 2 ]); // => [2, 1] _.unionBy（[arrays]，[iterate=_.identity]） [数组] [迭代=_.identity] _ 。 统一依据 ([ 2 。 1 ] , [ 1 。 2 , 2 。 三 ] , 数学 。 地板）； // => [2.1, 1.2] //“_.properties”迭代为简写。 _ 。 联合依据 ([{ “x” : 1 }] , [{ “x” : 2 } , { “x” : 1 }] , “x” ); //=>[{'x'：1}，{'x':2}] _.unionWith（[数组]，[比较器]） [数组] [比较器] 无功功率，无功功率 对象=[{ “x” : 1 , “是” : 2 } , { “x” : 2 , “是” : 1 }]; 无功功率，无功功率 其他=[｛ “x” : 1 , “是” : 1 } , { “x” : 1 , “是” : 2 }]; _ 。 与联合 （对象 , 其他 , _ 。 等于）； //=>[{'x'：1，'y'：2}，{'x':2，'y':1}，}'x':1，'y''：1}] _.uniq（数组） 阵列 _ 。 uniq公司 ([ 2 , 1 , 2 ]); // => [2, 1] _.uniqBy（数组，[iterate=_.identity]） 阵列 [iteratee=_.identity] _ 。 uniqBy（唯一依据） ([ 2 。 1 , 1 。 2 , 2 。 三 ] , 数学 。 地板）； // => [2.1, 1.2] //`_.property`迭代速记。 _ 。 唯一依据 ([{ “x” : 1 } , { “x” : 2 } , { “x” : 1 }] , “x” ); //=>[{'x'：1}，{'x':2}] _.uniqWith（数组，[比较器]） 阵列 [比较器] 无功功率，无功功率 对象=[{ “x” : 1 , “是” : 2 } , { “x” : 2 , “是” : 1 } , { “x” : 1 , “是” : 2 }]; _ 。 uniq与 （对象 , _ 。 等于）； //=>[{'x'：1，'y'：2}，{'x':2，'y':1}] _.unzip（数组） 阵列 无功功率，无功功率 zipped=_ 。 拉链 ([ “a” , “b” ] , [ 1 , 2 ] , [正确 , 错误]）； //=>[['a'，1，真]，['b'，2，假]] _ 。 解压缩 （拉链）； //=>[['a'，'b']，[1,2]，[true，false]] _.unzipWith（数组，[iterate=_.identity]） 阵列 [迭代=_.identity] 无功功率，无功功率 zipped=压缩=_ 。 拉链 ([ 1 , 2 ] , [ 10 , 20 ] , [ 100 , 200 ]); // => [[1, 10, 100], [2, 20, 200]] _ 。 用解压缩 （拉链 , _ 。 添加）； // => [3, 30, 300] _.without（数组，[值]） 阵列 [值] _ 。 没有 ([ 2 , 1 , 2 , 三 ] , 1 , 2 ); // => [3] _.xor（[数组]） [数组] _ 。 异或 ([ 2 , 1 ] , [ 2 , 三 ]); // => [1, 3] _.xorBy（[arrays]，[iterate=_.identity]） [数组] [迭代=_.identity] _ 。 xor依据 ([ 2 。 1 , 1 。 2 ] , [ 2 。 三 , 三 。 4 ] , 数学 。 地板）； // => [1.2, 3.4] //`_.property`迭代速记。 _ 。 xor依据 ([{ “x” : 1 }] , [{ “x” : 2 } , { “x” : 1 }] , “x” ); //=>[{“x”：2}] _.xorWith（[数组]，[比较器]） [阵列] [比较器] 无功功率，无功功率 对象=[{ “x” : 1 , “是” : 2 } , { “x” : 2 , “是” : 1 }]; 无功功率，无功功率 其他=[{ “x” : 1 , “是” : 1 } , { “x” : 1 , “是” : 2 }]; _ 。 xor与 （对象 , 其他 , _ 。 等于）； //=>[{'x'：2，'y'：1}，{'x':1，'y':1}] _.zip（[数组]） [数组] _ 。 拉链 ([ “a” , “b” ] , [ 1 , 2 ] , [正确 , 错误]）； //=>[['a'，1，true]，['b'，2，false]] _.zipObject（[道具=[]]，[值=[]]） [道具=[]] [值=[]] _ 。 zip对象 ([ “a” , “b” ] , [ 1 , 2 ]); //=>{“a”：1，“b”：2} _.zipObjectDeep（[道具=[]]，[值=[]]） [道具=[]] [值=[]] _ 。 zip对象深度 ([ “a.b[0].c” , “a.b[1].d” ] , [ 1 , 2 ]); //=>{“a”：{“b”：[{“c”：1}，{“d”：2}]} “集合”方法 _.countBy（集合，[iterate=_.identity]） 收集 [迭代=_.identity] _ 。 计数依据 ([ 6 。 1 , 4 。 2 , 6 。 三 ] , 数学 。 地板）； // => { '4': 1, '6': 2 } //“_.properties”迭代为简写。 _ 。 计数依据 ([ “一个” , “两个” , “三” ] , “长度” ); // => { '3': 2, '5': 1 } _.every（集合，[谓词=_.identity]） 收集 [谓词=_.identity] _ 。 每一个 （[正确 , 1 , 空 , “是” ] , 布尔值 ); //=>假 无功功率，无功功率 用户=[ { “用户” : “巴尼” , “年龄” : 36 , “活动” ：假} , ｛ “用户” : “弗雷德” , “年龄” : 40 , “活动” ：假} ]; //`_.matches`迭代速记。 _ 。 每一个 （个用户 , { “用户” : “巴尼” , “活动” ：false}）； //=>假 //`_.matchesProperty`迭代速记。 _ 。 每一个 （个用户 , [ “活动” , 错误]）； //=>真 //`_.property`迭代速记。 _ 。 每一个 （个用户 , “活动” ); //=>假 _.filter（集合，[谓词=_.identity]） 收集 [谓词=_.identity] 无功功率，无功功率 用户=[ ｛ “用户” : “巴尼” , “年龄” : 36 , “活动” ：true} , { “用户” : “弗雷德” , “年龄” : 40 , “活动” ：假} ]; _ 。 滤波器 （个用户 , 功能 （o） {返回！o 。 活性； }); //=>['fred']的对象 //`_.matches`迭代速记。 _ 。 滤波器 （个用户 , { “年龄” : 36 , “活动” ：true}）； //=>['barney']的对象 //`_.matchesProperty`迭代速记。 _ 。 滤波器 （个用户 , [ “活动” , 错误]）； //=>['fred']的对象 //`_.property`迭代速记。 _ 。 滤波器 （个用户 , “活动” ); //=>['barney']的对象 _.find（集合，[谓词=_.identity]，[fromIndex=0]） 收集 [谓词=_.identity] [fromIndex=0] 无功功率，无功功率 用户=[ { “用户” : “巴尼” , “年龄” : 36 , “活动” ：true} , { “用户” : “弗雷德” , “年龄” : 40 , “活动” ：假} , { “用户” : “鹅卵石” , “年龄” : 1 , “活动” ：true} ]; _ 。 找到 （个用户 , 功能 （o） ｛返回o 。 年龄< 40 ; }); //=>“barney”对象 //`_.matches`迭代速记。 _ 。 找到 （个用户 , ｛ “年龄” : 1 , “活动” ：true｝）； //=>“鹅卵石”对象 //`_.matchesProperty`迭代速记。 _ 。 找到 （个用户 , [ “活动” , 错误]）； //=>“fred”的对象 //`_.property`迭代速记。 _ 。 找到 （个用户 , “活动” ); //=>“barney”对象 _.findLast（集合，[谓词=_.identity]，[fromIndex=collection.length-1]） 收集 [谓词=_.identity] [fromIndex=集合长度-1] _ 。 查找最后一个 ([ 1 , 2 , 三 , 4 ] , 功能 （n）{ 返回n% 2 == 1 ; }); // => 3 _.flatMap（集合，[迭代=_.identity]） 收集 [迭代=_.identity] 功能 重复 （n）{ 返回[n , n]； } _ 。 平面地图 ([ 1 , 2 ] , 副本）； // => [1, 1, 2, 2] _.flatMapDeep（集合，[iterate=_.identity]） 收集 [迭代=_.identity] 功能 重复 （n）{ 返回[[[n , n]]]； } _ 。 平面贴图深度 ([ 1 , 2 ] , 副本）； //=>[1，1，2，2] _.flatMapDepth（集合，[iterate=_.identity]，[depth=1]） 收集 [迭代=_.identity] [深度=1] 功能 重复 （n）{ 返回[[[n , n]]]； } _ 。 平面贴图深度 ([ 1 , 2 ] , 重复 , 2 ); // => [[1, 1], [2, 2]] _.forEach（集合，[iterate=_.identity]） 收集 [迭代=_.identity] _ 。 对于每个 ([ 1 , 2 ] , 功能 （值）{ 慰问 。 日志 （价值）； }); //=>日志`1'，然后`2`。 _ 。 对于每个 ({ “a” : 1 , “b” : 2 } , 功能 （值 , 键）{ 慰问 。 日志 （关键）； }); //=>记录“a”，然后记录“b”（不保证迭代顺序）。 _.forEachRight（集合，[iterate=_.identity]） 收集 [迭代=_.identity] _ 。 用于每个右侧 ([ 1 , 2 ] , 功能 （值）{ 慰问 。 日志 （价值）； }); //=>日志`2`，然后`1`。 _.groupBy（集合，[iterate=_.identity]） 收集 [迭代=_.identity] _ 。 分组依据 ([ 6 。 1 , 4 。 2 , 6 。 三 ] , 数学 。 地板）； // => { '4': [4.2], '6': [6.1, 6.3] } //`_.property`迭代速记。 _ 。 分组依据 ([ “一个” , “两个” , “三个” ] , “长度” ); //=>{“3”：['one'，'two']，'5'：['tree']} _.includes（集合，值，[fromIndex=0]） 收集 价值 [fromIndex=0] _ 。 包括 ([ 1 , 2 , 三 ] , 1 ); //=>真 _ 。 包括 ([ 1 , 2 , 三 ] , 1 , 2 ); //=>假 _ 。 包括 ({ “a” : 1 , “b” : 2 } , 1 ); //=>真 _ 。 包括 ( “abcd” , “bc” ); //=>真 _.invokeMap（集合，路径，[args]） 收集 路径 [参数] _ 。 调用映射 ([[ 5 , 1 , 7 ] , [ 三 , 2 , 1 ]] , “排序” ); // => [[1, 5, 7], [1, 2, 3]] _ 。 invokeMap（调用映射） ([ 123 , 456 ] , 字符串 。 原型 。 分裂 , '' ); // => [['1', '2', '3'], ['4', '5', '6']] _.keyBy（集合，[iteratee=_.identity]） 收集 [迭代=_.identity] 无功功率，无功功率 数组=[ { “目录” : “左侧” , “代码” : 97 } , { “目录” : “正确” , “代码” : 100 } ]; _ 。 keyBy键 （数组 , 功能 （o）{ 返回 字符串 。 来自字符代码 （o） 。 代码 ); }); //=>{“a”：{“dir”：“left”，“code”：97}，“d”：{'dir'：“right”，“code”：100}} _ 。 keyBy键 （数组 , “目录” ); //=>{“左”：{“目录”：“左”，“代码”：97}，“右”：{'dir'：“右”，“编码”：100}} _.map（集合，[迭代=_.identity]） 收集 [迭代=_.identity] 功能 广场 （n）{ 返回n*n； } _ 。 地图 ([ 4 , 8 ] , 正方形）； // => [16, 64] _ 。 地图 ({ “a” : 4 , “b” : 8 } , 正方形）； //=>[16，64]（不保证迭代顺序） 无功功率，无功功率 用户=[ { “用户” : “巴尼” } , ｛ “用户” : “弗雷德” } ]; //`_.property`迭代速记。 _ 。 地图 （个用户 , “用户” ); //=>[“巴尼”，“弗雷德”] _.orderBy（集合，[迭代=[_.identity]]，[订单]） 收集 [迭代=[_.identity]] [订单] 迭代 无功功率，无功功率 用户=[ { “用户” : “弗雷德” , “年龄” : 48 } , { “用户” : “巴尼” , “年龄” : 34 } , { “用户” : “弗雷德” , “年龄” : 40 } , { “用户” : “巴尼” , “年龄” : 36 } ]; //按“用户”升序排序，按“年龄”降序排序。 _ 。 订购人 （个用户 , [ “用户” , “年龄” ] , [ “asc” , '描述' ]); //=>[['barney'，36]，['barnery'，34]，['红色'，48]，[红色'，40]]的对象 _.partition（集合，[谓词=_.identity]） 收集 [谓词=_.identity] 无功功率，无功功率 用户=[ { “用户” : “巴尼” , “年龄” : 36 , “活动” ：假} , { “用户” : “弗雷德” , “年龄” : 40 , “活动” ：true} , { “用户” : “鹅卵石” , “年龄” : 1 , “活动” ：假} ]; _ 。 隔板 （用户 , 功能 （o） {返回o 。 活性； }); //=>[['fred']，['barney'，'pebbles']]的对象 //`_.matches`迭代速记。 _ 。 隔板 （个用户 , { “年龄” : 1 , “活动” ：false}）； //=>[['pebbles']，['barney'，'fred']]的对象 //`_.matchesProperty`迭代速记。 _ 。 隔板 （个用户 , [ “活动” , 错误]）； //=>[['barney'，'pebbles']，['fred']]的对象 //`_.property`迭代速记。 _ 。 隔板 （个用户 , “活动” ); //=>[['fred']，['barney'，'pebbles']]的对象 _.reduce（集合，[迭代=_.identity]，[累加器]） 收集 [迭代=_.identity] [累加器] _ 。 减少 ([ 1 , 2 ] , 功能 （总额 , n）{ 返回和+n； } , 0 ); // => 3 _ 。 减少 ({ “a” : 1 , “b” : 2 , “c” : 1 } , 功能 （结果 , 价值 , 键）{ （结果[value]||（结果[value]=[]） 。 推 （关键）； 返回结果； } , {}); //=>{'1'：['a'，'c']，'2'：['b']}（不保证迭代顺序） _.reducedRight（集合，[iteratee=_.identity]，[accumulator]） 收集 [迭代=_.identity] [累加器] 无功功率，无功功率 数组=[[ 0 , 1 ] , [ 2 , 三 ] , [ 4 , 5 ]]; _ 。 减少右侧 （数组 , 功能 （扁平 , 其他）{ 回程变平 。 凹面（concat） （其他）； } , []); // => [4, 5, 2, 3, 0, 1] _.reject（集合，[谓词=_.identity]） 收集 [谓词=_.identity] 无功功率，无功功率 用户=[ ｛ “用户” : “巴尼” , “年龄” : 36 , “活动” ：假} , { “用户” : “弗雷德” , “年龄” : 40 , “活动” ：true} ]; _ 。 拒绝 （个用户 , 功能 （o） {返回！o 。 活性； }); //=>['fred']的对象 //`_.matches`迭代速记。 _ 。 拒绝 （个用户 , { “年龄” : 40 , “活动” ：true}）； //=>['barney']的对象 //`_.matchesProperty`迭代速记。 _ 。 拒绝 （个用户 , [ “活动” , 错误]）； //=>['fred']的对象 //`_.property`迭代速记。 _ 。 拒绝 （用户 , “活动” ); //=>['barney']的对象 _.sampleSize（集合，[n=1]） 收集 [n=1] _ 。 样本大小 ([ 1 , 2 , 三 ] , 2 ); // => [3, 1] _ 。 样本大小 ([ 1 , 2 , 三 ] , 4 ); // => [2, 3, 1] _.洗牌（集合） 收集 _ 。 洗牌 ([ 1 , 2 , 三 , 4 ]); // => [4, 1, 3, 2] _.size（集合） 收集 _ 。 大小 ([ 1 , 2 , 三 ]); // => 3 _ 。 大小 ({ “a” : 1 , “b” : 2 }); // => 2 _ 。 大小 ( “鹅卵石” ); // => 7 _.some（集合，[谓词=_.identity]） 收集 [谓词=_.identity] _ 。 一些 （[无效 , 0 , “是” , 错误] , 布尔值 ); //=>真 无功功率，无功功率 用户=[ { “用户” : “巴尼” , “活动” ：true} , ｛ “用户” : “弗雷德” , “活动” ：假} ]; //`_.matches`迭代速记。 _ 。 一些 （个用户 , { “用户” : “巴尼” , “活动” ：false}）； //=>假 //`_.matchesProperty`迭代速记。 _ 。 一些 （个用户 , [ “活动” , 错误]）； //=>真 //`_.property`迭代速记。 _ 。 一些 （个用户 , “活动” ); //=>真 _.sortBy（集合，[迭代=[_.identity]]） 收集 [迭代=[_.identity]] 无功功率，无功功率 用户=[ { “用户” : “弗雷德” , “年龄” : 48 } , { “用户” : “巴尼” , “年龄” : 36 } , { “用户” : “弗雷德” , “年龄” : 40 } , { “用户” : “巴尼” , “年龄” : 34 } ]; _ 。 排序依据 （个用户 , [ 功能 （o） {返回o 。 用户； }]); //=>[['barney'，36]，['barnery'，34]，['红色'，48]，[红色'，40]]的对象 _ 。 排序依据 （个用户 , [ “用户” , “年龄” ]); //=>[['barney'，34]，['barnery'，36]，['红色'，40]，[红色'，48]]的对象 “日期”方法 “函数”方法 _.在（n，func）之后 n个 函数 函数 无功功率，无功功率 保存=[ '配置文件' , '设置' ]; 无功功率，无功功率 完成=_ 。 之后 （保存 。 长度 , 功能 () { 慰问 。 日志 ( '保存完成！' ); }); _ 。 对于每个 （保存 , 功能 （类型）{ 异步保存 ({ “类型” ：类型 , “完成” ：已完成}）； }); //=>日志“保存完毕！” 两次异步保存完成后。 _.ary（函数，[n=函数长度]） 函数 [n=函数长度] _ 。 地图 ([ '6' , '8' , '10' ] , _ 。 ary系列 （解析Int , 1 )); // => [6, 8, 10] _.before（n，函数） n个 函数 函数 jQuery（jQuery） （元素） 。 在 ( '单击' , _ 。 之前 ( 5 , addContactToList））； //=>允许向列表中添加最多4个联系人。 _.bind（函数，thisArg，[部分]） 函数 这个Arg 这 函数 [部分] 功能 打招呼 （问候 , 标点符号）{ 回复问候语+ ' ' +这个 。 用户+标点符号； } 无功功率，无功功率 对象={ “用户” : “弗雷德” }; 无功功率，无功功率 绑定=_ 。 绑定 （问候 , 对象 , “嗨” ); 跳跃 ( '!' ); //=>“你好，弗雷德！” //用占位符绑定。 无功功率，无功功率 绑定=_ 。 绑定 （问候 , 对象 , _ , '!' ); 跳跃 ( “嗨” ); //=>“你好，弗雷德！” _.bindKey（对象、键、[部分]） 对象 钥匙 [部分] 无功功率，无功功率 对象={ “用户” : “弗雷德” , “问候” : 功能 （问候 , 标点符号）{ 回复问候语+ ' ' +这个 。 用户+标点符号； } }; 无功功率，无功功率 绑定=_ 。 绑定键 （对象 , “问候” , “嗨” ); 跳跃 ( '!' ); //=>“你好，弗雷德！” 对象 。 打招呼 = 功能 （问候 , 标点符号）{ 回复问候语+ “你” +这个 。 用户+标点符号； }; 跳跃 ( '!' ); //=>“你好，弗雷德！” //用占位符绑定。 无功功率，无功功率 绑定=_ 。 绑定密钥 （对象 , “问候” , _ , '!' ); 跳跃 ( “嗨” ); //=>“你好，弗雷德！” _.curry（函数，[arity=函数长度]） 函数 [arity=函数长度] 函数 无功功率，无功功率 美国广播公司 = 功能 （a） , b条 , c）{ 返回[a , b条 , c）； }; 无功功率，无功功率 curried=_ 。 咖喱 （美国广播公司）； 咖喱的 ( 1 )( 2 )( 三 ); // => [1, 2, 3] 咖喱的 ( 1 , 2 )( 三 ); // => [1, 2, 3] 咖喱的 ( 1 , 2 , 三 ); // => [1, 2, 3] //用占位符烹饪。 咖喱的 ( 1 )(_ , 三 )( 2 ); // => [1, 3, 2] _.curryRight（函数，[arity=函数长度]） 函数 [arity=函数长度] 函数 无功功率，无功功率 美国广播公司 = 功能 （a） , b条 , c）{ 返回[a , b条 , c）； }; 无功功率，无功功率 curried=_ 。 咖喱没错 （美国广播公司）； 咖喱的 ( 三 )( 2 )( 1 ); // => [1, 2, 3] 咖喱的 ( 2 , 三 )( 1 ); // => [1, 2, 3] 咖喱的 ( 1 , 2 , 三 ); // => [1, 2, 3] //用占位符烹饪。 咖喱的 ( 三 )( 1 , _)( 2 ); // => [1, 2, 3] _.deboush（函数，[wait=0]，[options={}]） 函数 [等待=0] [选项={}] [options.leading=false] [选项.maxWait] 函数 [options.training=true] //避免在窗口大小不断变化时进行昂贵的计算。 jQuery（jQuery） ( 窗口 ) 。 在 ( '调整大小' , _ 。 消除颤抖 （计算布局 , 150 )); //单击时调用“sendMail”，取消后续调用。 jQuery（jQuery） （元素） 。 在 ( '单击' , _ 。 消除颤抖 （发送邮件 , 300 , { “领先” ：true , '尾随' ：false（错误） })); //确保在1秒解除阻塞的调用后调用一次“batchLog”。 无功功率，无功功率 脱粘=_ 。 消除颤抖 （批处理日志 , 250 , { “maxWait” : 1000 }); 无功功率，无功功率 source=新 事件源 ( “/stream” ); jQuery（jQuery） （来源） 。 在 ( '消息' , 去抖动）； //取消尾随的解除绑定调用。 jQuery（jQuery） ( 窗口 ) 。 在 ( “popstate” , 解除抵押 。 取消）； _.dedefer（函数，[args]） 函数 [参数] 函数 _ 。 推迟 ( 功能 （文本）{ 慰问 。 日志 （文本）； } , “延迟” ); //=>日志在一毫秒后“延迟”。 _.delay（函数，等待，[args]） 函数 等待 [参数] 函数 _ 。 延迟 ( 功能 （文本）{ 慰问 。 日志 （文本）； } , 1000 , '稍后' ); //=>一秒钟后“稍后”记录。 _.flip（函数） 函数 无功功率，无功功率 翻转=_ 。 轻弹 ( 功能 () { 返回_ 。 到阵列 （参数）； }); 轻弹 ( “a” , “b” , “c” , “d” ); //=>[d'，'c'，'b'，'a'] _.memoize（函数，[解析器]） 函数 [解析器] 无功功率，无功功率 对象=｛ “a” : 1 , “b” : 2 }; 无功功率，无功功率 其他={ “c” : 三 , “d” : 4 }; 无功功率，无功功率 值=_ 。 记下 (_ 。 值）； 值 （目标）； // => [1, 2] 值 （其他）； // => [3, 4] 对象 。 a= 2 ; 值 （目标）； // => [1, 2] //修改结果缓存。 值 。 隐藏物 。 设置 （对象 , [ “a” , “b” ]); 值 （目标）； //=>['a'，'b'] //替换`_.memorize。 缓存`。 _ 。 记下 。 缓存= WeakMap（弱点地图） ; _.negate（谓词）
谓语 功能 是偶数 （n）{ 返回n% 2 == 0 ; } _ 。 滤波器 ([ 1 , 2 , 三 , 4 , 5 , 6 ] , _ 。 否定 （为偶数）； // => [1, 3, 5] _.once（函数） 函数 无功功率，无功功率 初始化=_ 。 一旦 （创建应用程序）； 初始化 (); 初始化 (); //=>调用一次`createApplication` _.overArgs（函数，[transforms=[_.identity]]） 函数 [转换=[_.identity]] 功能 加倍 （n）{ 返回n* 2 ; } 功能 广场 （n）{ 返回n*n； } 无功功率，无功功率 函数=_ 。 超过Args ( 功能 （x） , 年）{ 返回[x , y]； } , [正方形 , 加倍]）； 函数 ( 9 , 三 ); // => [81, 6] 函数 ( 10 , 5 ); // => [100, 10] _.partial（函数，[部分]） 函数 [部分] 功能 打招呼 （问候 , 名称）{ 回复问候语+ ' ' +名称； } 无功功率，无功功率 说HelloTo=_ 。 部分 （问候 , “你好” ); 说HelloTo ( “弗雷德” ); //=>“你好，弗雷德” //部分应用于占位符。 无功功率，无功功率 问候Fred=_ 。 部分 （问候 , _ , “弗雷德” ); 问候弗雷德 ( “嗨” ); //=>“你好，弗雷德” _.partialRight（函数，[部分]） 函数 [部分] 功能 打招呼 （问候 , 姓名）{ 回复问候语+ ' ' +名称； } 无功功率，无功功率 问候Fred=_ 。 部分正确 （问候 , “弗雷德” ); 问候弗雷德 ( “嗨” ); //=>“嗨，弗雷德” //部分应用于占位符。 无功功率，无功功率 说HelloTo=_ 。 部分正确 （问候 , “你好” , _); 说Hello To ( “弗雷德” ); //=>“你好，弗雷德” _.rearg（函数，索引） 函数 索引 无功功率，无功功率 后部=_ 。 后背 ( 功能 （a） , b条 , c）{ 返回[a , b条 , c）； } , [ 2 , 0 , 1 ]); 向后的 ( “b” , “c” , “a” ) //=>['a'，'b'，'c'] _.rest（函数，[start=func.length-1]） 函数 [开始=功能长度-1] 无功功率，无功功率 说=_ 。 休息 ( 功能 （什么 , 名称）{ 返回什么+ ' ' + _ 。 最初的 （姓名） 。 参加 ( ', ' ) + (_ 。 大小 （姓名）> 1 ？ ', & ' 以下为： '' ) + _ 。 最后的 （姓名）； }); 说 ( “你好” , “弗雷德” , “巴尼” , “鹅卵石” ); //=>“你好，弗雷德、巴尼和佩布尔斯” _.prade（函数，[start=0]） 函数 [开始=0] 无功功率，无功功率 说=_ 。 传播 ( 功能 （谁 , 什么）{ 返回who+ “说” +什么； }); 说 ([ “弗雷德” , “你好” ]); //=>“弗雷德打招呼” 无功功率，无功功率 numbers=承诺 。 全部的 ([ 承诺 。 决定 ( 40 ) , 承诺 。 决定 ( 36 ) ]); 数字 。 然后 (_ 。 传播 ( 功能 （x） , 年）{ 返回x+y； })); //=>76岁的承诺 _.throttle（函数，[wait=0]，[options={}]） 函数 [等待=0] [选项={}] [options.leading=true] [options.training=true] //滚动时避免过度更新位置。 jQuery（jQuery） ( 窗口 ) 。 在 ( “滚动” , _ 。 节气门 （更新位置 , 100 )); //在触发单击事件时调用“renewToken”，但每5分钟调用一次。 无功功率，无功功率 节流=_ 。 节气门 （续订代币 , 300000 , { '尾随' ：false}）； jQuery（jQuery） （元素） 。 在 ( '单击' , 节流）； //取消尾部受限调用。 jQuery（jQuery） ( 窗口 ) 。 在 ( “popstate” , 节流的 。 取消）； “Lang”方法 _.castArray（值） 价值 _ 。 cast数组 ( 1 ); // => [1] _ 。 castArray（castArray） ({ “a” : 1 }); //=>[{“a”：1}] _ 。 cast数组 ( “abc” ); //=>['abc'] _ 。 cast数组 （空）； //=>[空] _ 。 cast数组 （未定义）； //=>[未定义] _ 。 cast数组 (); // => [] 无功功率，无功功率 数组=[ 1 , 2 , 三 ]; 慰问 。 日志 (_ 。 cast数组 （数组）===数组）； //=>真 _.clone（值） 价值 无功功率，无功功率 对象=[{ “a” : 1 } , { “b” : 2 }]； 无功功率，无功功率 浅层=_ 。 克隆 （对象）； 慰问 。 日志 （浅层[ 0 ]===对象[ 0 ])； //=>真 _.cloneDeep（值） 价值 无功功率，无功功率 对象=[{ “a” : 1 } , { “b” : 2 }]; 无功功率，无功功率 深度=_ 。 克隆深度 （对象）； 慰问 。 日志 （深[ 0 ]===对象[ 0 ]); //=>假 _.cloneDeepWith（值，[自定义项]） 价值 [自定义程序] 功能 自定义程序 （值）{ 如果(_ 。 is元素 （值））{ 返回值 。 克隆节点 （正确）； } } 无功功率，无功功率 标高=_ 。 克隆深度 ( 文件 。 身体 , 定制程序）； 慰问 。 日志 （el=== 文件 。 身体 ); //=>假 慰问 。 日志 （标高 。 节点名称 ); //=>“车身” 慰问 。 日志 （标高 。 子节点 。 长度 ); // => 20 _.cloneWith（值，[自定义项]） 价值 [自定义程序] 功能 自定义程序 （值）{ 如果(_ 。 is元素 （值）{ 返回值 。 克隆节点 （错误）； } } 无功功率，无功功率 标高=_ 。 克隆方式 ( 文件 。 身体 , 定制程序）； 慰问 。 日志 （el=== 文件 。 身体 ); //=>假 慰问 。 日志 （标高 。 节点名称 ); //=>“车身” 慰问 。 日志 （标高 。 子节点 。 长度 ); // => 0 _.conformsTo（对象，源） 对象 来源 无功功率，无功功率 对象={ “a” : 1 , “b” : 2 }; _ 。 符合要求 （对象 , { “b” : 功能 （n） ｛返回n> 1 ; } }); //=>真 _ 。 符合 （对象 , { “b” : 功能 （n） {返回n> 2 ; } }); //=>假 _.eq（值，其他） 价值 其他 无功功率，无功功率 对象={ “a” : 1 }; 无功功率，无功功率 其他={ “a” : 1 }; _ 。 等式 （对象 , 对象）； //=>真 _ 。 等式 （对象 , 其他）； //=>假 _ 。 等式 ( “a” , “a” ); //=>真 _ 。 等式 ( “a” , 对象 ( “a” )); //=>假 _ 。 等式 （NaN , NaN）； //=>真 _.gt（值，其他） 价值 其他 _ 。 gt公司 ( 三 , 1 ); //=>真 _ 。 gt公司 ( 三 , 三 ); //=>假 _ 。 gt公司 ( 1 , 三 ); //=>假 _.gte（值，其他） 价值 其他 _ 。 全球技术工程师 ( 三 , 1 ); //=>真 _ 。 全球技术工程师 ( 三 , 三 ); //=>真 _ 。 全球技术工程师 ( 1 , 三 ); //=>假 _.isArguments（值） 价值 _ 。 是参数 ( 功能 （）{返回参数；}（））； //=>真 _ 。 是参数 ([ 1 , 2 , 三 ]); //=>假 _.isArray（值） 价值 _ 。 isArray（isArray） ([ 1 , 2 , 三 ]); //=>真 _ 。 isArray（isArray） ( 文件 。 身体 。 儿童）； //=>假 _ 。 isArray（isArray） ( “abc” ); //=>假 _ 。 isArray（isArray） (_ 。 noop）； //=>假 _.isArrayBuffer（值） 价值 _ 。 isArrayBuffer（isArray缓冲区） （新 阵列缓冲区 ( 2 )); //=>真 _ 。 isArrayBuffer（isArray缓冲区） （新 阵列 ( 2 )); //=>假 _.isArrayLike（值） 价值 _ 。 类似阵列 ([ 1 , 2 , 三 ]); //=>真 _ 。 类似阵列 ( 文件 。 身体 。 儿童）； //=>真 _ 。 类似阵列 ( “abc” ); //=>真 _ 。 类似阵列 (_ 。 noop）； //=>假 _.isArrayLikeObject（值） 价值 _ 。 isArrayLike对象 ([ 1 , 2 , 三 ]); //=>真 _ 。 isArrayLike对象 ( 文件 。 身体 。 儿童）； //=>真 _ 。 isArrayLike对象 ( “abc” ); //=>假 _ 。 isArrayLike对象 (_ 。 noop）； //=>假 _.isBoolean（值） 价值 _ 。 is布尔值 （错误）； //=>真 _ 。 isBoolean（布尔值） （空）； //=>假 _.isBuffer（值） 价值 _ 。 isBuffer（缓冲区） （新 缓冲器 ( 2 )); //=>真 _ 。 isBuffer（缓冲区） （新 Uint8阵列 ( 2 )); //=>假 _.isDate（值） 价值 _ 。 isDate（是日期） （新增 日期 ); //=>真 _ 。 isDate（是日期） ( “2012年4月23日星期一” ); //=>假 _.isElement（值） 价值 _ 。 is元素 ( 文件 。 身体 ); //=>真 _ 。 is元素 ( “<正文>” ); //=>假 _.isEmpty（值） 价值 _ 。 栈空 （空）； //=>真 _ 。 栈空 （真实）； //=>真 _ 。 栈空 ( 1 ); //=>真 _ 。 栈空 ([ 1 , 2 , 三 ])； //=>假 _ 。 栈空 ({ “a” : 1 }); //=>假 _.isEqual（值，其他） 价值 其他 无功功率，无功功率 对象={ “a” : 1 }; 无功功率，无功功率 其他={ “a” : 1 }; _ 。 等于 （对象 , 其他）； //=>真 对象===其他； //=>假 _.isEqualWith（值，其他，[自定义项]） 价值 其他 [自定义程序] 功能 正在问候 （值）{ 返回 /^h（？：i|ello）$/ 。 测试 （价值）； } 功能 自定义程序 （对象值 , othValue）{ 如果( 正在问候 （对象值）&& 正在问候 （其他值）{ 返回true； } } 无功功率，无功功率 数组=[ “你好” , “再见” ]; 无功功率，无功功率 其他=[ “嗨” , “再见” ]; _ 。 isEqual与 （数组 , 其他 , 定制器）； //=>真 _.is错误（值） 价值 _ 。 is错误 （新 错误 ); //=>真 _ 。 is错误 （错误）； //=>假 _.isFinite（值） 价值 _ 。 测试数值是否为有限数 ( 三 ); //=>真 _ 。 测试数值是否为有限数 ( 编号 。 最小值（_V） ); //=>真 _ 。 测试数值是否为有限数 （无限）； //=>假 _ 。 测试数值是否为有限数 ( '3' ); //=>假 _.is函数（值） 价值 _ 。 is功能 (_); //=>真 _ 。 is功能 ( /美国广播公司/ ); //=>假 _.isInteger（值） 价值 _ 。 是整数 ( 三 ); //=>真 _ 。 is整数 ( 编号 。 最小值（_V） ); //=>假 _ 。 是整数 （无限）； //=>假 _ 。 是整数 ( '3' ); //=>假 _.isLength（值） 价值 _ 。 is长度 ( 三 ); //=>真 _ 。 is长度 ( 编号 。 最小值（_V） ); //=>假 _ 。 is长度 （无限）； //=>假 _ 。 is长度 ( '3' ); //=>假 _.isMap（值） 价值 _ 。 isMap地图 （新 地图 ); //=>真 _ 。 isMap地图 （新 WeakMap（弱点地图） ); //=>假 _.isMatch（对象，源） 对象 来源 无功功率，无功功率 对象={ “a” : 1 , “b” : 2 }; _ 。 isMatch（isMatch） （对象 , ｛ “b” : 2 }); //=>真 _ 。 isMatch（匹配） （对象 , { “b” : 1 }); //=>假 _.isMatchWith（对象、源、[自定义项]） 对象 来源 [自定义程序] 功能 正在问候 （值）{ 返回 /^h（？：i|ello）$/ 。 测试 （价值）； } 功能 自定义程序 （对象值 , src值）{ 如果( 正在问候 （objValue）&& 正在问候 （srcValue）{ 返回true； } } 无功功率，无功功率 对象={ “问候语” : “你好” }; 无功功率，无功功率 源={ “问候语” : “嗨” }; _ 。 与匹配 （对象 , 源 , 定制程序）； //=>真 _.isNaN（值） 价值 _ 。 是NaN （NaN）； //=>真 _ 。 是NaN （新 编号 （NaN））； //=>真 是NaN （未定义）； //=>真 _ 。 是NaN （未定义）； //=>假 _.isNative（值） 价值 _ 。 isNative（本机） ( 阵列 。 原型 。 推动）； //=>真 _ 。 isNative（本机） (_); //=>假 _.isNil（值） 价值 _ 。 为零 （空）； //=>真 _ 。 为零 （无效 0 ); //=>真 _ 。 为零 （NaN）； //=>假 _.isNull（值） 价值 _ 。 为Null （空）； //=>真 _ 。 为Null （无效 0 ); //=>假 _.isNumber（值） 价值 _ 。 is编号 ( 三 ); //=>真 _ 。 is编号 ( 编号 。 最小值（_V） ); //=>真 _ 。 is编号 （无限）； //=>真 _ 。 is编号 ( '3' ); //=>假 _.isObject（值） 价值 _ 。 is对象 ({}); //=>真 _ 。 is对象 ([ 1 , 2 , 三 ])； //=>真 _ 。 is对象 (_ 。 noop）； //=>真 _ 。 is对象 （空）； //=>假 _.isObjectLike（值） 价值 _ 。 类对象 ({}); //=>真 _ 。 类对象 ([ 1 , 2 , 三 ]); //=>真 _ 。 类对象 (_ 。 noop）； //=>假 _ 。 类对象 （空）； //=>假 _.isPlainObject（值） 价值 功能 富 （）{ 这个 。 a= 1 ; } _ 。 isPlain对象 （新 富 ); //=>假 _ 。 isPlain对象 ([ 1 , 2 , 三 ]); //=>假 _ 。 isPlain对象 ({ “x” : 0 , “是” : 0 }); //=>真 _ 。 isPlain对象 ( 对象 。 创造 （空））； //=>真 _.isRegExp（值） 价值 _ 。 isRegExp公司 ( /作业成本法/ ); //=>真 _ 。 isRegExp公司 ( '/abc/' ); //=>假 _.isSafeInteger（值） 价值 _ 。 是安全整数 ( 三 ); //=>真 _ 。 是安全整数 ( 编号 。 最小值（_V） ); //=>假 _ 。 是安全整数 （无限）； //=>假 _ 。 是安全整数 ( '3' ); //=>假 _.isSet（值） 价值 _ 。 isSet（设置） （新 设置 ); //=>真 _ 。 isSet（设置） （新 弱点集 ); //=>假 _.isString（值） 价值 _ 。 isString（isString） ( “abc” ); //=>真 _ 。 isString（isString） ( 1 ); //=>假 _.isSymbol（值） 价值 _ 。 IS符号 ( 符号 。 迭代器）； //=>真 _ 。 IS符号 ( “abc” ); //=>假 _.isTypedArray（值） 价值 _ 。 isTypedArray （新 Uint8阵列 ); //=>真 _ 。 isTypedArray ([]); //=>假 _.is未定义（值） 价值 _ 。 未定义 （无效 0 ); //=>真 _ 。 未定义 （空）； //=>假 _.isWeakMap（值） 价值 _ 。 isWeakMap（isWeakMap） （新 WeakMap（弱点地图） ); //=>真 _ 。 isWeakMap（isWeak地图） （新 地图 ); //=>假 _.isWeakSet（值） 价值 _ 。 isWeakSet（弱集） （新 弱集 ); //=>真 _ 。 isWeakSet（弱集） （新 设置 ); //=>错误 _.lt（值，其他） 价值 其他 _ 。 lt（左） ( 1 , 三 ); //=>真 _ 。 lt（左） ( 三 , 三 ); //=>假 _ 。 lt（左） ( 三 , 1 ); //=>错误 _.lte（值，其他） 价值 其他 _ 。 lte公司 ( 1 , 三 ); //=>真 _ 。 lte公司 ( 三 , 三 ); //=>真 _ 。 lte公司 ( 三 , 1 ); //=>假 _.toArray（值） 价值 _ 。 到阵列 ({ “a” : 1 , “b” : 2 }); // => [1, 2] _ 。 到阵列 ( “abc” ); //=>['a'，'b'，'c'] _ 。 到阵列 ( 1 ); // => [] _ 。 到阵列 （空）； //=>[] _.toFinite（值） 价值 _ 。 到有限 ( 三 。 2 ); // => 3.2 _ 。 到有限 ( 编号 。 最小值（_V） ); //=>5e-324 _ 。 到有限 （无限）； //=>1.7976931348623157e+308 _ 。 到有限 ( '3.2' ); // => 3.2 _.toInteger（值） 价值 _ 。 到整数 ( 三 。 2 ); //=>3 _ 。 到整数 ( 编号 。 最小值（_V） ); // => 0 _ 。 到整数 （无限）； //=>1.7976931348623157e+308 _ 。 到整数 ( '3.2' ); //=>3 _.toLength（值） 价值 _ 。 to长度 ( 三 。 2 ); // => 3 _ 。 to长度 ( 编号 。 最小值（_V） ); // => 0 _ 。 to长度 （无限）； // => 4294967295 _ 。 to长度 ( '3.2' ); // => 3 _.toNumber（值） 价值 _ 。 toNumber（目标编号） ( 三 。 2 ); // => 3.2 _ 。 toNumber（目标编号） ( 编号 。 最小值（_V） ); //=>5e-324 _ 。 至编号 （无限）； //=>无限 _ 。 至编号 ( '3.2' ); // => 3.2 _.toPlainObject（值） 价值 功能 富 () { 这个 。 b= 2 ; } 富 。 原型 。 c= 三 ; _ 。 分配 ({ “a” : 1 } , 新 富 ); //=>{“a”：1，“b”：2} _ 。 分配 ({ “a” : 1 } , _ 。 toPlain对象 （新 富 )); //=>{“a”：1，“b”：2，“c”：3} “数学”方法 _.add（被加数，被加数） 被加数 加数 _ 。 添加 ( 6 , 4 ); // => 10 _.ceil（数字，[精度=0]） 数 [精度=0] _ 。 天花板 ( 4 。 006 ); // => 5 _ 。 天花板 ( 6 。 004 , 2 ); // => 6.01 _ 。 天花板 ( 6040 , - 2 ); // => 6100 _.floor（数字，[精度=0]） 数 [精度=0] _ 。 地板 ( 4 。 006 ); // => 4 _ 。 地板 ( 0 。 046 , 2 ); // => 0.04 _ 。 地板 ( 4060 , - 2 ); // => 4000 _.max（数组） 阵列 _ 。 最大值 ([ 4 , 2 , 8 , 6 ]); //=>8 _ 。 最大值 ([]); //=>未定义 _.maxBy（数组，[iterate=_.identity]） 阵列 [迭代=_.identity] 无功功率，无功功率 对象=[{ “n” : 1 } , { “n” : 2 }]; _ 。 maxBy（最大值） （对象 , 功能 （o） {返回o 。 n； }); //=>｛n｝：2｝ //`_.property`迭代速记。 _ 。 maxBy（最大值） （对象 , “n” ); //=>{“n”：2} _.meanBy（数组，[iterate=_.identity]） 阵列 [迭代=_.identity] 无功功率，无功功率 对象=[{ “n” : 4 } , { “n” : 2 } , { “n” : 8 } , { “n” : 6 }]; _ 。 意思是通过 （对象 , 功能 （o） {返回o 。 n； }); // => 5 //`_.property`迭代速记。 _ 。 意思是通过 （对象 , “n” ); // => 5 _.min（数组） 阵列 _ 。 最小值 ([ 4 , 2 , 8 , 6 ]); // => 2 _ 。 最小值 ([]); //=>未定义 _.minBy（数组，[iterate=_.identity]） 阵列 [迭代=_.identity] 无功功率，无功功率 对象=[{ “n” : 1 } , { “n” : 2 }]; _ 。 minBy（最小值） （对象 , 功能 （o） ｛返回o 。 n； }); //=>{“n”：1} //`_.property`迭代速记。 _ 。 minBy（最小值） （对象 , “n” ); //=>｛“n”：1｝ _.multiply（乘数，被乘数） 乘数，乘数 被乘数 _ 。 乘 ( 6 , 4 ); // => 24 _.round（数字，[精度=0]） 数 [精度=0] _ 。 圆 ( 4 。 006 ); // => 4 _ 。 圆 ( 4 。 006 , 2 ); // => 4.01 _ 。 圆 ( 4060 , - 2 ); //=>4100 _减法（被减数、减数） 被减数 减数 _ 。 减去 ( 6 , 4 ); // => 2 _.sumBy（数组，[iterate=_.identity]） 阵列 [迭代=_.identity] 无功功率，无功功率 对象=[{ “n” : 4 } , { “n” : 2 } , { “n” : 8 } , { “n” : 6 }]； _ 。 汇总依据 （对象 , 功能 （o） ｛返回o 。 n； }); // => 20 //`_.property`迭代速记。 _ 。 汇总依据 （对象 , “n” ); // => 20 “数字”方法 _.夹钳（编号，[下]，上） 数 [下方] 上面的 _ 。 夹紧 (- 10 , - 5 , 5 ); // => -5 _ 。 夹紧 ( 10 , - 5 , 5 ); //=>5 _.inRange（数字，[开始=0]，结束） 数 [开始=0] 结束 _ 。 英寸范围 ( 三 , 2 , 4 ); //=>真 _ 。 英寸范围 ( 4 , 8 ); //=>真 _ 。 英寸范围 ( 4 , 2 ); //=>假 _ 。 英寸范围 ( 2 , 2 ); //=>假 _ 。 英寸范围 ( 1 。 2 , 2 ); //=>真 _ 。 英寸范围 ( 5 。 2 , 4 ); //=>假 _ 。 英寸范围 (- 三 , - 2 , - 6 ); //=>真 _随机（[下=0]，[上=1]，[浮动]） [下=0] [上部=1] [浮动] _ 。 随机的，随机的 ( 0 , 5 ); //=>0到5之间的整数 _ 。 随机的，随机的 ( 5 ); //=>也是0到5之间的整数 _ 。 随机的，随机的 ( 5 , true）； //=>介于0和5之间的浮点数 _ 。 随机的，随机的 ( 1 。 2 , 5 。 2 ); //=>介于1.2和5.2之间的浮点数 “对象”方法 _.assign（对象，[源]） 对象 [来源] 功能 富 () { 这个 。 a= 1 ; } 功能 酒吧 () { 这个 。 c= 三 ; } 富 。 原型 。 b= 2 ; 酒吧 。 原型 。 d=天 4 ; _ 。 分配 ({ “a” : 0 } , 新 富 , 新 酒吧 ); //=>{“a”：1，“c”：3} _.assignIn（对象，[源]） 对象 [来源] 功能 富 () { 这个 。 a= 1 ; } 功能 酒吧 （）{ 这个 。 c= 三 ; } 富 。 原型 。 b= 2 ; 酒吧 。 原型 。 d=天 4 ; _ 。 分配In （｛ “a” : 0 } , 新 富 , 新 酒吧 ); //=>｛“a”：1，“b”：2，“c”：3，“d”：4｝ _.assignInWith（对象、源、[自定义程序]） 对象 来源 [自定义程序] 功能 自定义程序 （对象值 , srcValue）{ 返回_ 。 is未定义 （对象值）？ srcValue：对象值； } 无功功率，无功功率 默认值=_ 。 部分正确 (_ 。 assignInWith分配 , 定制程序）； 默认值 ({ “a” : 1 } , ｛ “b” : 2 } , { “a” : 三 }); //=>{“a”：1，“b”：2} _.assignWith（对象、源、[自定义程序]） 对象 来源 [自定义程序] 功能 自定义程序 （对象值 , src值）{ 返回_ 。 未定义 （对象值）？ srcValue：对象值； } 无功功率，无功功率 默认值=_ 。 偏右 (_ 。 赋值为 , 定制器）； 默认值 ({ “a” : 1 } , { “b” : 2 } , ｛ “a” : 三 }); //=>{“a”：1，“b”：2} _.at（对象，[路径]） 对象 [路径] 无功功率，无功功率 对象={ “a” : [{ “b” : { “c” : 三 } } , 4 ] }; _ 。 在 （对象 , [ “a[0].b.c” , “一[1]” ]); // => [3, 4] _.create（原型，[属性]） 原型 [属性] 功能 形状 () { 这个 。 x = 0 ; 这个 。 年 = 0 ; } 功能 圆形 () { 形状 。 呼叫 （本）； } 圆形 。 原型 = _ 。 创造 （形状 。 原型 , { “构造函数” ：圆形 }); 无功功率，无功功率 圆=新 圆形 ; circle的circle实例； //=>真 圆形实例； //=>真 _.defaults（对象，[源]） 对象 [来源] _ 。 默认值 ({ “a” : 1 } , ｛ “b” : 2 } , { “a” : 三 }); //=>｛“a”：1，“b”：2｝ _.defaultsDeep（对象，[源]） 对象 [来源] _ 。 默认深度 ({ “a” : { “b” : 2 } } , { “a” : { “b” : 1 , “c” : 三 } }); //=>{“a”：{“b”：2，“c”：3}} _.findKey（对象，[谓词=_.identity]） 对象 [谓词=_.identity] 无功功率，无功功率 用户={ “巴尼” : { “年龄” : 36 , “活动” ：true} , “弗雷德” : { “年龄” : 40 , “活动” ：假} , “鹅卵石” : { “年龄” : 1 , “活动” ：true} }; _ 。 查找密钥 （个用户 , 功能 （o） {返回o 。 年龄< 40 ; }); //=>“barney”（不保证迭代顺序） //`_.matches`迭代速记。 _ 。 查找密钥 （个用户 , { “年龄” : 1 , “活动” ：true}）； //=>“卵石” //`_.matchesProperty`迭代速记。 _ 。 查找密钥 （个用户 , [ “活动” , 错误]）； //=>“弗雷德” //`_.property`迭代速记。 _ 。 查找密钥 （用户 , “活动” ); //=>“巴尼” _.findLastKey（对象，[谓词=_.identity]） 对象 [谓词=_.identity] 无功功率，无功功率 用户={ “巴尼” : { “年龄” : 36 , “活动” ：true} , “弗雷德” : { “年龄” : 40 , “活动” ：假} , “鹅卵石” : { “年龄” : 1 , “活动” ：true} }; _ 。 查找最后一个键 （个用户 , 功能 （o） {返回o 。 年龄< 40 ; }); //=>返回“pebbles”，假设“_.findKey”返回“barney” //`_.matches`迭代速记。 _ 。 查找最后一个键 （个用户 , { “年龄” : 36 , “活动” ：true｝）； //=>“巴尼” //`_.matchesProperty`迭代速记。 _ 。 查找最后一个键 （个用户 , [ “活动” , 错误]）； //=>“弗雷德” //`_.property`迭代速记。 _ 。 查找最后一个键 （个用户 , “活动” ); //=>“鹅卵石” _.forIn（对象，[iterate=_.identity]） 对象 [迭代=_.identity] 功能 富 () { 这个 。 a= 1 ; 这个 。 b= 2 ; } 富 。 原型 。 c= 三 ; _ 。 对于In （新 富 , 功能 （值 , 键）{ 慰问 。 日志 （关键）； }); //=>记录“a”、“b”，然后记录“c”（不保证迭代顺序）。 _.forInRight（对象，[iterate=_.identity]） 对象 [迭代=_.identity] 功能 富 () { 这个 。 a= 1 ; 这个 。 b= 2 ; } 富 。 原型 。 c= 三 ; _ 。 用于InRight （新 富 , 功能 （值 , 键）{ 慰问 。 日志 （关键）； }); //=>假设`_.forIn`Logs'a'，'b'，然后'c'，则记录'c'，'b'，然后'a'。 _.forOwn（对象，[iterate=_.identity]） 对象 [迭代=_.identity] 功能 富 () { 这个 。 a= 1 ; 这个 。 b= 2 ; } 富 。 原型 。 c= 三 ; _ 。 为自己 （新 富 , 功能 （值 , 键）{ 慰问 。 日志 （关键）； }); //=>记录“a”，然后记录“b”（不保证迭代顺序）。 _.forOwnRight（对象，[iterate=_.identity]） 对象 [迭代=_.identity] 功能 富 () { 这个 。 a= 1 ; 这个 。 b= 2 ; } 富 。 原型 。 c= 三 ; _ 。 对于OwnRight （新 富 , 功能 （值 , 键）{ 慰问 。 日志 （关键）； }); //=>日志“b”，然后是“a”，假设“_.forOwn”日志“a”然后是“b”。 _.functions（对象） 对象 功能 富 () { 这个 。 a=_ 。 常数 ( “a” ); 这个 。 b=_ 。 常数 ( “b” ); } 富 。 原型 。 c=_ 。 常数 ( “c” ); _ 。 功能 （新 富 ); //=>['a'，'b'] _.functionsIn（对象） 对象 功能 富 () { 这个 。 a=_ 。 常数 ( “a” ); 这个 。 b=_ 。 常数 ( “b” ); } 富 。 原型 。 c=_ 。 常数 ( “c” ); _ 。 函数In （新 富 ); //=>['a'，'b'，'c'] _.get（对象，路径，[defaultValue]） 对象 路径 [默认值] 未定义 无功功率，无功功率 对象={ “a” ：[｛ “b” : { “c” : 三 } }] }; _ 。 得到 （对象 , “a[0].b.c” ); // => 3 _ 。 得到 （对象 , [ “a” , '0' , “b” , “c” ]); // => 3 _ 。 得到 （对象 , “a.b.c” , “默认” ); //=>“默认” _.has（对象，路径） 对象 路径 无功功率，无功功率 对象={ “a” ：｛ “b” : 2 } }; 无功功率，无功功率 其他=_ 。 创造 ({ “a” : _ 。 创造 （｛ “b” : 2 }) }); _ 。 有 （对象 , “a” ); //=>真 _ 。 有 （对象 , “a.b” ); //=>真 _ 。 有 （对象 , [ “a” , “b” ]); //=>真 _ 。 有 （其他 , “a” ); //=>假 _.hasIn（对象、路径） 对象 路径 无功功率，无功功率 对象=_ 。 创造 ({ “a” : _ 。 创造 ({ “b” : 2 }) }); _ 。 哈斯（hasIn） （对象 , “a” ); //=>真 _ 。 哈斯（hasIn） （对象 , “a.b” ); //=>真 _ 。 哈斯（hasIn） （对象 , [ “a” , “b” ])； //=>真 _ 。 哈斯（hasIn） （对象 , “b” ); //=>假 _反转（对象） 对象 无功功率，无功功率 对象={ “a” : 1 , “b” : 2 , “c” : 1 }; _ 。 使转化 （目标）； //=>{“1”：“c”，“2”：“b”} _.invertBy（对象，[iterate=_.identity]） 对象 [迭代=_.identity] 无功功率，无功功率 对象={ “a” : 1 , “b” : 2 , “c” : 1 }; _ 。 逆变器 （目标）； //=>{“1”：['a'，'c']，'2'：['b']} _ 。 反转依据 （对象 , 功能 （值）{ 返回 “组” +值； }); //=>｛“组1”：[‘a’，“c’]，“组2”：[‘b’]｝ _.invoke（对象、路径、[参数]） 对象 路径 [参数] 无功功率，无功功率 对象={ “a” : [{ “b” : { “c” : [ 1 , 2 , 三 , 4 ] } }] }; _ 。 援引 （对象 , 'a[0].b.c.切片' , 1 , 三 ); // => [2, 3] _.keys（对象） 对象 功能 富 () { 这个 。 a= 1 ; 这个 。 b= 2 ; } 富 。 原型 。 c= 三 ; _ 。 钥匙 （新 富 ); //=>['a'，'b']（不保证迭代顺序） _ 。 钥匙 ( “嗨” ); // => ['0', '1'] _.keysIn（对象） 对象 功能 富 () { 这个 。 a= 1 ; 这个 。 b= 2 ; } 富 。 原型 。 c= 三 ; _ 。 按键输入 （新 富 ); //=>['a'，'b'，'c']（不保证迭代顺序） _.mapKeys（对象，[iterate=_.identity]） 对象 [迭代=_.identity] _ 。 映射键 ({ “a” : 1 , “b” : 2 } , 功能 （值 , 键）{ 返回键+值； }); //=>{“a1”：1，“b2”：2} _.mapValues（对象，[迭代=_.identity]） 对象 [迭代=_.identity] 无功功率，无功功率 用户={ “弗雷德” : { “用户” : “弗雷德” , “年龄” : 40 } , “鹅卵石” : { “用户” : “鹅卵石” , “年龄” : 1 } }; _ 。 mapValues（映射值） （用户 , 功能 （o） {返回o 。 年龄； }）； //=>{“fred”：40，“pebbles”：1}（不保证迭代顺序） //`_.property`迭代速记。 _ 。 mapValues（映射值） （个用户 , “年龄” ); //=>{“fred”：40，“pebbles”：1}（不保证迭代顺序） _.merge（对象，[源]） 对象 [来源] 无功功率，无功功率 对象={ “a” : [{ “b” : 2 } , ｛ “d” : 4 }] }; 无功功率，无功功率 其他={ “a” : [{ “c” : 三 } , { “e” : 5 }] }; _ 。 合并 （对象 , 其他）； //=>{“a”：[{“b”：2，“c”：3}，{“d”：4，“e”：5}]} _.mergeWith（对象、源、自定义程序） 对象 来源 自定义程序 功能 自定义程序 （对象值 , srcValue）{ 如果(_ 。 isArray（isArray） （对象值）{ 返回objValue 。 凹面（concat） （srcValue）； } } 无功功率，无功功率 对象={ “a” : [ 1 ] , “b” 以下为：[ 2 ] }; 无功功率，无功功率 其他={ “a” : [ 三 ] , “b” : [ 4 ] }; _ 。 与合并 （对象 , 其他 , 定制程序）； //=>{“a”：[1,3]，“b”：[2,4]} _.imit（对象，[路径]） 对象 [路径] 无功功率，无功功率 对象={ “a” : 1 , “b” : '2' , “c” : 三 }; _ 。 省略 （对象 , [ “a” , “c” ]); //=>{“b”：“2”} _.omitBy（对象，[谓词=_.identity]） 对象 [谓词=_.identity] 无功功率，无功功率 对象={ “a” : 1 , “b” : '2' , “c” : 三 }; _ 。 省略方式 （对象 , _ 。 是数字）； //=>{“b”：“2”} _.pick（对象，[路径]） 对象 [路径] 无功功率，无功功率 对象={ “a” : 1 , “b” : '2' , “c” : 三 }; _ 。 挑选 （对象 , [ “a” , “c” ]); //=>｛“a”：1，“c”：3｝ _.pickBy（对象，[谓词=_.identity]） 对象 [谓词=_.identity] 无功功率，无功功率 对象={ “a” : 1 , “b” : '2' , “c” : 三 }; _ 。 选择依据 （对象 , _ 。 是数字）； //=>{“a”：1，“c”：3} _.result（对象、路径、[defaultValue]） 对象 路径 [默认值] 未定义 无功功率，无功功率 对象=｛ “a” : [{ “b” : { “c1” : 三 , “c2” : _ 。 常数 ( 4 ) } }] }; _ 。 结果 （对象 , “a[0].b.c1” ); // => 3 _ 。 结果 （对象 , “a[0].b.c2” ); // => 4 _ 。 结果 （对象 , “a[0].b.c3” , “默认” ); //=>“默认” _ 。 结果 （对象 , “a[0].b.c3” , _ 。 常数 ( “默认” )); //=>“默认” _.set（对象、路径、值） 对象 路径 价值 无功功率，无功功率 对象={ “a” : [{ “b” : { “c” : 三 } }] }; _ 。 设置 （对象 , “a[0].b.c” , 4 ); 慰问 。 日志 （对象 。 一个[ 0 ] 。 b 。 c） ； // => 4 _ 。 设置 （对象 , [ “x” , '0' , “是” , “z” ] , 5 ); 慰问 。 日志 （对象 。 x [ 0 ] 。 年 。 z（z） ); // => 5 _.setWith（对象、路径、值、[自定义项]） 对象 路径 价值 [自定义程序] 无功功率，无功功率 对象={}； _ 。 设置为 （对象 , '[0][1]' , “a” , 对象 ); //=>{“0”：{“1”：“a”}} _.toPairs（对象） 对象 功能 富 () { 这个 。 a= 1 ; 这个 。 b= 2 ; } 富 。 原型 。 c= 三 ; _ 。 到配对 （新增 富 ); //=>[['a'，1]，['b'，2]（不保证迭代顺序） _.toPairsIn（对象） 对象 功能 富 () { 这个 。 a= 1 ; 这个 。 b= 2 ; } 富 。 原型 。 c= 三 ; _ 。 对输入 （新 富 ); //=>[['a'，1]，['b'，2]，['c'，3]]（不保证迭代顺序） _.transform（对象，[迭代=_.identity]，[累加器]） 对象 [迭代=_.identity] [累加器] _ 。 转型 ([ 2 , 三 , 4 ] , 功能 （结果 , n）{ 结果 。 推 （n*=n）； 返回n% 2 == 0 ; } , []); // => [4, 9] _ 。 转型 ({ “a” : 1 , “b” : 2 , “c” : 1 } , 功能 （结果 , 价值 , 键）{ （结果[value]||（结果[value]=[]） 。 推 （关键）； } , {}); //=>{“1”：['a'，'c']，'2'：['b']} _.unset（对象，路径） 对象 路径 无功功率，无功功率 对象={ “a” : [{ “b” : { “c” : 7 } }] }; _ 。 未设置 （对象 , “a[0].b.c” ); //=>真 慰问 。 日志 （对象）； //=>{“a”：[{“b”：{}}]}； _ 。 未设置 （对象 , [ “a” , '0' , “b” , “c” ]); //=>真 慰问 。 日志 （目标）； //=>{“a”：[{“b”：{}}]}； _.update（对象、路径、更新程序） 对象 路径 更新程序 无功功率，无功功率 对象=｛ “a” : [{ “b” : { “c” : 三 } }] }; _ 。 更新 （对象 , “a[0].b.c” , 功能 （n） ｛return n*n；｝）； 慰问 。 日志 （对象 。 一个[ 0 ] 。 b 。 c） ； // => 9 _ 。 更新 （对象 , 'x[0].y.z' , 功能 （n） {返回n？n+ 1 以下为： 0 ; }); 慰问 。 日志 （对象 。 x [ 0 ] 。 年 。 z（z） ); // => 0 _.updateWith（对象、路径、更新程序、[自定义程序]） 对象 路径 更新程序 [自定义程序] 无功功率，无功功率 对象={}； _ 。 更新方式 （对象 , '[0][1]' , _ 。 常数 ( “a” ) , 对象 ); //=>{“0”：{“1”：“a”}} “顺序”方法 _（值） 价值 洛达什 功能 广场 （n）{ 返回n*n； } 无功功率，无功功率 包裹= _ ([ 1 , 2 , 三 ]); //返回未包装的值。 包裹 。 减少 (_ 。 添加）； // => 6 //返回一个换行的值。 无功功率，无功功率 方块=包裹 。 地图 （正方形）； _ 。 isArray（isArray） （正方形）； //=>假 _ 。 isArray（is阵列） （正方形 。 价值 ()); //=>真 _.chain（价值） 价值 无功功率，无功功率 用户=[ { “用户” : “巴尼” , “年龄” : 36 } , { “用户” : “弗雷德” , “年龄” : 40 } , { “用户” : “鹅卵石” , “年龄” : 1 } ]; 无功功率，无功功率 最小=_ 。 链 （用户） 。 排序依据 ( “年龄” ) 。 地图 ( 功能 （o）{ 返回o 。 用户+ “是” +o个 。 年龄； }) 。 头 （） 。 价值 (); //=>“鹅卵石为1” _.tap（值，拦截器） 价值 拦截器 拦截器 _ ([ 1 , 2 , 三 ]) 。 水龙头 ( 功能 （数组）{ //改变输入数组。 阵列 。 流行音乐 (); }) 。 颠倒 （） 。 价值 (); // => [2, 1] _.thru（值，拦截器） 价值 拦截器 拦截器 _ ( “abc” ) 。 链 （） 。 修剪 （） 。 通过 ( 功能 （值）{ 返回[值]； }) 。 价值 (); //=>['abc'] _.prototype[Symbol.iterator]（） 无功功率，无功功率 包裹= _ ([ 1 , 2 ]); 包装好的[ 符号 。 迭代器]（）===包装； //=>真 阵列 。 从 （包裹）； // => [1, 2] _.prototype.at（[路径]） [路径] 无功功率，无功功率 对象={ “a” : [{ “b” : { “c” : 三 } } , 4 ] }; _ （对象） 。 在 ([ “a[0].b.c” , “一[1]” ]) 。 价值 (); // => [3, 4] _.prototype.chain（） 无功功率，无功功率 用户=[ { “用户” : “巴尼” , “年龄” : 36 } , { “用户” : “弗雷德” , “年龄” : 40 } ]; //没有显式链接的序列。 _ （用户） 。 头 (); //=>{“用户”：“巴尼”，“年龄”：36} //具有显式链接的序列。 _ （用户） 。 链 （） 。 头 （） 。 挑选 ( “用户” ) 。 价值 (); //=>{“用户”：“巴尼”} _.prototype.commit（） 无功功率，无功功率 数组=[ 1 , 2 ]; 无功功率，无功功率 包裹= _ （数组） 。 推 ( 三 ); 慰问 。 日志 （数组）； // => [1, 2] wrapped=已包装 。 犯罪 (); 慰问 。 日志 （数组）； // => [1, 2, 3] 包裹 。 最后的 (); // => 3 慰问 。 日志 （数组）； // => [1, 2, 3] _.prototype.next（） 无功功率，无功功率 包裹= _ ([ 1 , 2 ]); 包裹 。 下一个 (); //=>{“done”：false，“value”：1} 包裹 。 下一个 (); //=>{“done”：false，“value”：2} 包裹 。 下一个 (); //=>{“done”：true，“value”：未定义} _原型工厂（价值） 价值 功能 广场 （n）{ 返回n*n； } 无功功率，无功功率 包裹= _ ([ 1 , 2 ]) 。 地图 （正方形）； 无功功率，无功功率 其他=包裹 。 植物 ([ 三 , 4 ]); 其他 。 价值 (); // => [9, 16] 包裹 。 价值 (); // => [1, 4] _.prototype.reverse（） 无功功率，无功功率 数组=[ 1 , 2 , 三 ]; _ （数组） 。 颠倒 （） 。 价值 （） // => [3, 2, 1] 慰问 。 日志 （数组）； // => [3, 2, 1] “字符串”方法 _.camelCase（[string='']） [字符串=“”] _ 。 骆驼皮箱 ( “Foo酒吧” ); //=>“fooBar” _ 。 骆驼皮箱 ( '--foo-bar--' ); //=>“fooBar” _ 。 骆驼皮箱 ( '__FOO_BAR__' ); //=>“fooBar” _.大写（[字符串=“”]） [字符串=“”] _ 。 资本化 ( “FRED” ); //=>“弗雷德” _.deburr（[字符串=“”]） [字符串=“”] _ 。 去毛刺 ( “似曾相识” ); //=>“似曾相识” _.endsWith（[string='']，[target]，[position=string.length]） [字符串=“”] [目标] [位置=字符串长度] _ 。 结尾为 ( “abc” , “c” ); //=>真 _ 。 结尾为 ( “abc” , “b” ); //=>假 _ 。 结尾为 ( “abc” , “b” , 2 ); //=>真 _.escape（[字符串=“”]） [字符串=“”] _ 。 逃跑 ( “弗雷德、巴尼和鹅卵石” ); //=>弗雷德、巴尼； 鹅卵石 _.escapeRegExp（[字符串=“”]） [字符串=“”] _ 。 逃逸RegExp ( '[lodash]( https://lodash.com/ )' ); //=>'\[lodash\]\( https://lodash网址 \.com/\）' _.kebabCase（[string=''） [字符串=“”] _ 。 烤肉串 ( “Foo酒吧” ); //=>“foo-bar” _ 。 烤肉串 ( “fooBar” ); //=>“foo bar”（foo bar） _ 。 烤肉串 ( '__FOO_BAR__' ); //=>“foo-bar” _.lowerCase（[string=''） [字符串=“”] _ 。 小写字母 ( “——Foo-Bar——” ); //=>“foo bar” _ 。 小写字母 ( “fooBar” ); //=>“foo bar” _ 。 小写字母 ( '__FOO_BAR__' ); //=>“foo bar” _.lowerFirst（[string=''） [字符串=“”] _ 。 lower第一 ( “弗雷德” ); //=>“弗雷德” _ 。 lower第一 ( “FRED” ); //=>“fRED” _.pad（[string='']，[length=0]，[chars='']） [字符串=“”] [长度=0] [字符=“”] _ 。 衬垫 ( “abc” , 8 ); //=>“abc” _ 。 衬垫 ( “abc” , 8 , '_-' ); //=>'_-abc_-_' _ 。 衬垫 ( “abc” , 三 ); //=>“abc” _.padEnd（[string='']，[length=0]，[chars='']） [字符串=“”] [长度=0] [字符=“”] _ 。 焊盘端 ( “abc” , 6 ); //=>“abc” _ 。 焊盘端 ( “abc” , 6 , '_-' ); //=>“abc_-_” _ 。 焊盘端 ( “abc” , 三 ); //=>“abc” _.padStart（[string='']，[length=0]，[chars='']） [字符串=“”] [长度=0] [字符=“”] _ 。 pad开始 ( “abc” , 6 ); //=>“abc” _ 。 pad开始 ( “abc” , 6 , '_-' ); //=>“_-_abc” _ 。 pad开始 ( “abc” , 三 ); //=>“abc” _.parseInt（字符串，[基数=10]） 一串 [基数=10] 价值 _ 。 解析Int ( '08' ); //=>8 _ 。 地图 ([ '6' , '08' , '10' ] , _ 。 parseInt）； //=>[6，8，10] _.repeat（[string=''，[n=1]） [字符串=“”] [n=1] _ 。 重复 ( '*' , 三 ); // => '***' _ 。 重复 ( “abc” , 2 ); //=>“abcabc” _ 。 重复 ( “abc” , 0 ); // => '' _.replace（[string='']，模式，替换） [字符串=“”] 图案 更换 _ 。 代替 ( “你好，弗雷德” , “弗雷德” , “巴尼” ); //=>“你好，巴尼” _.snakeCase（[string=''） [字符串=“”] _ 。 蛇箱 ( “Foo酒吧” ); //=>“foo_bar” _ 。 蛇箱 ( “fooBar” ); //=>“foo_bar” _ 。 蛇箱 ( “--FOO-BAR---” ); //=>“foo_bar” _.split（[string='']，分隔符，[limit]） [字符串=“”] 分离器 [限制] _ 。 分裂 ( “a-b-c” , '-' , 2 ); //=>['a'，'b'] _.startCase（[string='']） [字符串=“”] _ 。 启动案例 ( '--foo-bar--' ); //=>“Foo酒吧” _ 。 启动案例 ( “fooBar” ); //=>“Foo酒吧” _ 。 启动案例 ( '__FOO_BAR__' ); //=>“FOO酒吧” _.startsWith（[string='']，[target]，[position=0]） [字符串=“”] [目标] [位置=0] _ 。 启动方式 ( “abc” , “a” ); //=>真 _ 。 启动方式 ( “abc” , “b” ); //=>假 _ 。 启动方式 ( “abc” , “b” , 1 ); //=>真 _.template（[string=''，[options={}]） [字符串=“”] [选项={}] [options.escape=_.templateSettings.escape] [options.evaluate=_.templateSettings.evaluate] [options.imports=_.templateSettings.imports] [options.interpolate=_.templateSettings.interplate] [options.sourceURL='lodash.templateSources[n]'] [options.variable='obj'] //使用“插值”分隔符创建编译的模板。 无功功率，无功功率 已编译=_ 。 模板 ( '您好<%=user%>！' ); 已编译 ({ “用户” : “弗雷德” }); //=>“你好，弗雷德！” //使用HTML“转义”分隔符转义数据属性值。 无功功率，无功功率 已编译=_ 。 模板 ( “<b><%-value%></b>” ); 已编译 ({ “值” : “<脚本>” }); //=>“<b><； 脚本></ b> ' //使用“evaluate”分隔符执行JavaScript并生成HTML。 无功功率，无功功率 已编译=_ 。 模板 ( '<%_.forEach（用户，函数（用户）{%><li><%-user%></li><%}）； %>' ); 已编译 ({ '用户' 以下为：[ “弗雷德” , “巴尼” ] }); //=>“弗雷德</li>barney</li>” //在“evaluate”分隔符中使用内部的“print”函数。 无功功率，无功功率 已编译=_ 。 模板 ( '<%print（“hello”+用户）； %>!' ); 编译的 ({ “用户” : “巴尼” }); //=>“你好，巴尼！” //使用ES模板文字分隔符作为“插值”分隔符。 //通过替换“插值”分隔符禁用支持。 无功功率，无功功率 已编译=_ 。 模板 ( '你好${user}！' ); 已编译 ({ “用户” : “鹅卵石” }); //=>“你好，鹅卵石！” //使用反斜杠将分隔符视为纯文本。 无功功率，无功功率 已编译=_ 。 模板 ( '<%=“\\<%-value%\\>”%>' ); 已编译 ({ “值” : “已忽略” }); //=>“<%-value%>” //使用`imports`选项将`jQuery`导入为`jq`。 无功功率，无功功率 文本= '<%jq.each（用户，函数（用户）{%><li><%-user%></li><%}）； %>' ; 无功功率，无功功率 已编译=_ 。 模板 （文本 , ｛ '导入' : { “jq” ：jQuery}}）； 已编译 （｛ '用户' : [ “弗雷德” , “巴尼” ] }); //=>“弗雷德</li>barney</li>” //使用“sourceURL”选项指定模板的自定义sourceURL。 无功功率，无功功率 已编译=_ 。 模板 ( '您好<%=user%>！' , { '源URL' : '/basic/greeting.jst' }); 已编译 （数据）； //=>在web检查器的Sources选项卡或Resources面板下查找“greeting.jst”的源代码。 //使用“variable”选项确保编译的模板中不使用with-statement。 无功功率，无功功率 已编译=_ 。 模板 ( '嗨<%=data.user%>！' , { '变量' : '数据' }); 已编译 。 来源 ; //=>函数（数据）{ //变量__t，__p=“”； //__p+=“hi”+（（__t=（data.user））==空？ “”：__t）+“！”； //返回__p； // } //使用自定义模板分隔符。 _ 。 模板设置 。 插值=/{{（[\s\s]+？）}}/g； 无功功率，无功功率 已编译=_ 。 模板 ( '你好{{user}}！' ); 已编译 ({ “用户” : “胡子” }); //=>“你好，胡子！” //使用“source”属性内联已编译的模板以获得有意义的模板 //错误消息和堆栈跟踪中的行号。 英尺 。 写入文件同步 （路径 。 参加 ( 过程 。 无缝线路 （） , “jst.js” ) , '\ var JST={\ “主要”：' + _ 。 模板 （主文本） 。 来源 + '\ };\ ' ); _.toLower（[string=''） [字符串=“”] _ 。 到更低 ( “——Foo-Bar——” ); //=>“--foo-bar” _ 。 到更低 ( “fooBar” ); //=>“foobar” _ 。 到更低 ( '__FOO_BAR__' ); //=>'__foo_bar__' _.toUpper（[string=''） [string=''] _ 。 到上部 ( '--foo-bar--' ); //=>“--FOO-BAR---” _ 。 到上部 ( “fooBar” ); //=>“FOOBAR” _ 。 到上部 ( '__foo_bar__' ); //=>'__FOO_BAR__' _.trim（[string=''，[chars=whitespace]） [字符串=“”] [字符=空白] _ 。 修剪 ( “abc” ); //=>“abc” _ 。 修剪 ( '-_-abc-_-' , '_-' ); //=>“abc” _ 。 地图 ([ “foo” , “bar” ] , _ 。 修剪）； //=>['foo'，'bar'] _.trimEnd（[string=''，[chars=whitespace]） [字符串=“”] [字符=空白] _ 。 修剪结束 ( “abc” ); //=>“abc” _ 。 修剪结束 ( '-_-abc-_-' , '_-' ); //=>“-_-abc” _.trimStart（[string=''，[chars=whitespace]） [字符串=“”] [字符=空白] _ 。 修剪开始 ( “abc” ); //=>“abc” _ 。 修剪开始 ( '-_-abc--_-' , '_-' ); //=>“abc-_-” _.ttruncate（[string='']，[选项=｛｝]） [字符串=“”] [选项={}] [选项长度=30] [options.importation=“…”] [选项.分隔符] _ 。 截断 ( “你好，邻居” ); //=>“你好，邻居……” _ 。 截断 ( “你好，邻居” , { “长度” : 24 , '分隔符' : “” }); //=>“嗨，呵呵，……” _ 。 截断 ( “你好，邻居” , { “长度” : 24 , '分隔符' 以下为： /，？ +/ }); //=>“嗨，你好……” _ 。 截断 ( “你好，邻居” , { “遗漏” : ' [...]' }); //=>“你好，奈格[…]” _.unescape（[字符串=“”]） [字符串=“”] _ 。 联合国环境规划署 ( “弗雷德、巴尼和； 鹅卵石 ); //=>“弗雷德、巴尼和鹅卵石” _.upperCase（[string=''） [string=''] _ 。 大写 ( '--foo bar' ); //=>“FOO酒吧” _ 。 大写 ( “fooBar” ); //=>“FOO酒吧” _ 。 大写 ( '__foo_bar__' ); //=>“FOO酒吧” “实用”方法 _尝试（函数，[args]） 函数 [参数] 函数 //避免抛出无效选择器的错误。 无功功率，无功功率 元素=_ 。 尝试 ( 功能 （选择器）{ 返回 文件 。 查询选择器或全部 （选择器）； } , '>_>' ); 如果(_ 。 is错误 （元素））{ 元素=[]； } _.bindAll（对象，方法名） 对象 方法名称 无功功率，无功功率 视图={ '标签' : '文档' , '单击' : 功能 () { 慰问 。 日志 ( “单击” +这个 。 标签 ); } }; _ 。 绑定所有 （查看 , [ '单击' ]); jQuery（jQuery） （元素） 。 在 ( '单击' , 视图 。 单击）； //=>单击时日志“clicked docs”。 _.cond（对） 对 无功功率，无功功率 函数=_ 。 康德 ([ [_ 。 比赛 ({ “a” : 1 }) , _ 。 常数 ( '匹配A' )] , [_ 。 符合 ({ “b” : _ 。 isNumber}） , _ 。 常数 ( '匹配B' )] , [_ 。 存根为真 , _ 。 常数 ( '无匹配项' )] ]); 函数 ({ “a” : 1 , “b” : 2 }); //=>“匹配A” 函数 ({ “a” : 0 , “b” : 1 }); //=>“匹配B” 函数 ({ “a” : '1' , “b” : “2” }); //=>“无匹配项” _.conform（源） 来源 无功功率，无功功率 对象=[ { “a” : 2 , “b” : 1 } , { “a” : 1 , “b” : 2 } ]; _ 。 滤波器 （对象 , _ 。 符合 ({ “b” : 功能 （n） {返回n> 1 ; } })); //=>[{“a”：1，“b”：2}] _.常量（值） 价值 无功功率，无功功率 对象=_ 。 次 ( 2 , _ 。 常数 ({ “a” : 1 })); 慰问 。 日志 （对象）； //=>[{'a'：1}，{'a':1}] 慰问 。 日志 （对象[ 0 ]===对象[ 1 ]); //=>真 _.defaultTo（值，defaultValue） 价值 默认值 _ 。 默认收件人 ( 1 , 10 ); // => 1 _ 。 默认收件人 （未定义 , 10 ); // => 10 _.flow（[funcs]） [功能] 功能 广场 （n）{ 返回n*n； } 无功功率，无功功率 addSquare=添加方形_ 。 流 ([_ 。 添加 , 方形]）； addSquare（添加正方形） ( 1 , 2 ); // => 9 _.flowRight（[funcs]） [功能] 功能 广场 （n）{ 返回n*n； } 无功功率，无功功率 addSquare=添加方形_ 。 流向右侧 （[正方形 , _ 。 添加]）； 加法平方 ( 1 , 2 ); // => 9 _.identity（值） 价值 无功功率，无功功率 对象={ “a” : 1 }; 慰问 。 日志 (_ 。 身份 （对象）===对象）； //=>真 _.iterate（[func=_.identity]） [func=_.标识] 无功功率，无功功率 用户=[ { “用户” : “巴尼” , “年龄” : 36 , “活动” ：true｝ , { “用户” : “弗雷德” , “年龄” : 40 , “活动” ：假} ]; //`_.matches`迭代速记。 _ 。 滤波器 （个用户 , _ 。 迭代 ({ “用户” : “巴尼” , “活动” ：true}）； //=>[{“用户”：“巴尼”，“年龄”：36，“活动”：true}] //`_.matchesProperty`迭代速记。 _ 。 滤波器 （个用户 , _ 。 迭代 ([ “用户” , “弗雷德” ])); //=>[{“用户”：“弗雷德”，“年龄”：40}] //`_.property`迭代速记。 _ 。 地图 （个用户 , _ 。 迭代 ( “用户” )); //=>[“巴尼”，“弗雷德”] //创建自定义迭代速记。 _ 。 迭代=_ 。 包 (_ 。 迭代 , 功能 （迭代 , 功能）{ 返回_ 。 isRegExp公司 （函数）？ 迭代 （功能）： 功能 （字符串）{ 返回函数 。 测试 （字符串）； }; }); _ 。 滤波器 ([ “abc” , “定义” ] , /ef（参考文献）/ ); //=>['def'] _.matches（源） 来源 无功功率，无功功率 对象=[ { “a” : 1 , “b” : 2 , “c” : 三 } , { “a” : 4 , “b” : 5 , “c” : 6 } ]; _ 。 滤波器 （对象 , _ 。 比赛 ({ “a” : 4 , “c” : 6 })); //=>[{“a”：4，“b”：5，“c”：6}] _.matchesProperty（路径，srcValue） 路径 src值 无功功率，无功功率 对象=[ { “a” : 1 , “b” : 2 , “c” : 三 } , { “a” : 4 , “b” : 5 , “c” : 6 } ]; _ 。 找到 （对象 , _ 。 matchesProperty（匹配属性） ( “a” , 4 )); //=>{“a”：4，“b”：5，“c”：6} _.method（路径，[args]） 路径 [参数] 无功功率，无功功率 对象=[ { “a” ：｛ “b” : _ 。 常数 ( 2 ) } } , { “a” : { “b” : _ 。 常数 ( 1 ) } } ]; _ 。 地图 （对象 , _ 。 方法 ( “a.b” )); // => [2, 1] _ 。 地图 （对象 , _ 。 方法 ([ “a” , “b” ])); // => [2, 1] _.methodOf（对象，[args]） 对象 [参数] 无功功率，无功功率 数组=_ 。 次 ( 三 , _ 。 常数） , 对象={ “a” ：阵列 , “b” ：数组 , “c” ：数组}； _ 。 地图 ([ “a[2]” , “c[0]” ] , _ 。 方法 （目标）； // => [2, 0] _ 。 地图 ([[ “a” , '2' ] , [ “c” , '0' ]] , _ 。 方法 （目标）； // => [2, 0] _.mixin（[object=lodash]，源，[options={}]） [对象=lodash] 来源 [选项={}] [options.chain=true] 功能 元音 （字符串）{ 返回_ 。 滤波器 （字符串 , 功能 （v）{ 返回 /[aeiou]/i 。 测试 （v） ； }); } _ 。 混合蛋白 ({ '元音' ：元音}）； _ 。 元音 ( “弗雷德” ); //=>[“e”] _ ( “弗雷德” ) 。 元音 （） 。 价值 (); //=>[“e”] _ 。 混合蛋白 ({ '元音' ：元音} , { “链” ：false}）； _ ( “弗雷德” ) 。 元音 (); //=>[“e”] _.nthArg（[n=0]） [n=0] 无功功率，无功功率 函数=_ 。 第n个Arg ( 1 ); 函数 ( “a” , “b” , “c” , “d” ); //=>“b” 无功功率，无功功率 函数=_ 。 第n个Arg (- 2 ); 函数 ( “a” , “b” , “c” , “d” ); //=>“c” _.over（[迭代=[_.identity]]） [迭代=[_.identity]] 无功功率，无功功率 函数=_ 。 结束 ([ 数学 。 最大值 , 数学 。 最小值]）； 函数 ( 1 , 2 , 三 , 4 ); // => [4, 1] _.overEvery（[谓词=[_.identity]]） [谓词=[_.identity]] 无功功率，无功功率 函数=_ 。 覆盖每个 ([ 布尔值 , isFinite]）； 函数 ( '1' ); //=>真 函数 （空）； //=>假 函数 （NaN）； //=>假 _.overSome（[谓词=[_.identity]]） [谓词=[_.identity]] 无功功率，无功功率 函数=_ 。 超过一些 ([ 布尔值 , 是有限的]）； 函数 ( '1' ); //=>真 函数 （空）； //=>真 函数 （NaN）； //=>假 _.property（路径） 路径 无功功率，无功功率 对象=[ { “a” : { “b” : 2 } } , { “a” : { “b” : 1 } } ]; _ 。 地图 （对象 , _ 。 财产 ( “a.b” )); // => [2, 1] _ 。 地图 (_ 。 排序依据 （对象 , _ 。 财产 ([ “a” , “b” ])) , “a.b” ); // => [1, 2] _.propertyOf（对象） 对象 无功功率，无功功率 数组=[ 0 , 1 , 2 ] , 对象={ “a” ：数组 , “b” ：数组 , “c” ：数组}； _ 。 地图 ([ “a[2]” , “c[0]” ] , _ 。 属性 （目标）； // => [2, 0] _ 。 地图 ([[ “a” , '2' ] , [ “c” , '0' ]] , _ 。 属性 （目标）； // => [2, 0] _.range（[开始=0]，结束，[步骤=1]） [开始=0] 结束 [步长=1] _ 。 范围 ( 4 ); // => [0, 1, 2, 3] _ 。 范围 (- 4 ); // => [0, -1, -2, -3] _ 。 范围 ( 1 , 5 ); // => [1, 2, 3, 4] _ 。 范围 ( 0 , 20 , 5 ); // => [0, 5, 10, 15] _ 。 范围 ( 0 , - 4 , - 1 ); // => [0, -1, -2, -3] _ 。 范围 ( 1 , 4 , 0 ); // => [1, 1, 1] _ 。 范围 ( 0 ); // => [] _.rangeRight（[开始=0]，结束，[步骤=1]） [开始=0] 结束 [步长=1] _ 。 范围向右 ( 4 ); // => [3, 2, 1, 0] _ 。 范围向右 (- 4 ); // => [-3, -2, -1, 0] _ 。 范围右侧 ( 1 , 5 ); // => [4, 3, 2, 1] _ 。 范围向右 ( 0 , 20 , 5 ); // => [15, 10, 5, 0] _ 。 范围向右 ( 0 , - 4 , - 1 ); // => [-3, -2, -1, 0] _ 。 范围向右 ( 1 , 4 , 0 ); // => [1, 1, 1] _ 。 范围向右 ( 0 ); // => [] _.runInContext（[context=root]） [context=root] _ 。 混合蛋白 ({ “foo” : _ 。 常数 ( “foo” ) }); 无功功率，无功功率 洛达什=_ 。 运行上下文 (); 洛达什 。 混合蛋白 ({ '酒吧' ：洛达什 。 常数 ( '酒吧' ) }); _ 。 is功能 (_ 。 foo）； //=>真 _ 。 is函数 (_ 。 巴）； //=>假 洛达什 。 is功能 （洛达什 。 foo）； //=>假 洛达什 。 is功能 （洛达什 。 巴）； //=>真 //在Node.js中创建一个supedup“defer”。 无功功率，无功功率 延迟=_ 。 运行上下文 ({ “setTimeout” ：setImmediate}） 。 推迟 ; _.stubArray（） 无功功率，无功功率 数组=_ 。 次 ( 2 , _ 。 stubArray）； 慰问 。 日志 （数组）； // => [[], []] 慰问 。 日志 （阵列[ 0 ]===数组[ 1 ])； //=>假 _.stub对象（） 无功功率，无功功率 对象=_ 。 次 ( 2 , _ 。 存根对象）； 慰问 。 日志 （对象）； // => [{}, {}] 慰问 。 日志 （对象[ 0 ]===对象[ 1 ]); //=>假 _.times（n，[iteratee=_.identity]） n个 迭代 [迭代=_.identity] _ 。 次 ( 三 , 字符串 ); // => ['0', '1', '2'] _ 。 次 ( 4 , _ 。 常数 ( 0 )); // => [0, 0, 0, 0] 属性 方法