Underscore.js (1.7.0)-集合(Collections)(25)

稽核函数(数组或对象)

each_.each(list, iteratee, [context]) 别名: forEach 
遍历list中的所有元素,按顺序用遍历输出每个元素。如果传递了context参数,则把iteratee绑定到context对象上。每次调用iteratee都会传递三个参数:(element, index, list)。如果list是个JavaScript对象,iteratee的参数是 (value, key, list))。返回list以方便链式调用。(注:如果存在原生的forEach方法,Underscore就使用它代替。)

_.each([1, 2, 3], alert);
=> alerts each number in turn...
_.each({one: 1, two: 2, three: 3}, alert);
=> alerts each number value in turn...

注意:集合函数能在数组,对象,和类数组对象,比如argumentsNodeList和类似的数据类型上正常工作。 但是它通过鸭子类型工作,所以要避免传递一个不固定length属性的对象(注:对象或数组的长度(length)属性要固定的)。每个循环不能被破坏 - 打破, 使用_.find代替,这也是很好的注意。

map_.map(list, iteratee, [context]) 别名: collect 
通过变换函数(iteratee迭代器)把list中的每个值映射到一个新的数组中(注:产生一个新的数组)。如果存在原生的map方法,就用原生map方法来代替。如果list是个JavaScript对象,iteratee的参数是(value, 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]

reduce_.reduce(list, iteratee, [memo], [context]) Aliases: inject, foldl 
别名为 inject 和 foldlreduce方法把list中元素归结为一个单独的数值。Memo是reduce函数的初始值,reduce的每一步都需要由iteratee返回。这个迭代传递4个参数:memovalue 和 迭代的index(或者 key)和最后一个引用的整个 list

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

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

reduceRight_.reduceRight(list, iteratee, memo, [context]) 别名: foldr 
reducRight是从右侧开始组合的元素的reduce函数,如果存在JavaScript 1.8版本的reduceRight,则用其代替。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]

find_.find(list, predicate, [context]) 别名: detect 
list中逐项查找,返回第一个通过predicate迭代函数真值检测的元素值,如果没有值传递给测试迭代器将返回undefined。 如果找到匹配的元素,函数将立即返回,不会遍历整个list。

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

filter_.filter(list, predicate, [context]) 别名: select 
遍历list中的每个值,返回包含所有通过predicate真值检测的元素值。(注:如果存在原生filter方法,则用原生的filter方法。)

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

where_.where(list, properties) 
遍历list中的每一个值,返回一个数组,这个数组包含包含properties所列出的属性的所有的键 - 值对。

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

findWhere_.findWhere(list, properties) 
遍历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."}

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]

every_.every(list, [predicate], [context]) 别名: all 
如果list中的所有元素都通过predicate的真值检测就返回true。(注:如果存在原生的every方法,就使用原生的every。)

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

some_.some(list, [predicate], [context]) 别名: any 
如果list中有任何一个元素通过 predicate 的真值检测就返回true。一旦找到了符合条件的元素, 就直接中断对list的遍历. (注:如果存在原生的some方法,就使用原生的some。)

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

contains_.contains(list, value) 别名: include 
如果list包含指定的value则返回true(注:使用===检测)。如果list 是数组,内部使用indexOf判断。

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

invoke_.invoke(list, methodName, *arguments) 
list的每个元素上执行methodName方法。 任何传递给invoke的额外参数,invoke都会在调用methodName方法的时候传递给它。

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

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"]

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};

min_.min(list, [iteratee], [context]) 
返回list中的最小值。如果传递iteratee参数,iteratee将作为list中每个值的排序依据。如果list为空,将返回-Infinity,所以你可能需要事先用isEmpty检查 list 。

var numbers = [10, 5, 100, 2, 1000];
_.min(numbers);
=> 2

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]

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

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

countBy_.countBy(list, iteratee, [context]) 
排序一个列表组成一个组,并且返回各组中的对象的数量的计数。类似groupBy,但是不是返回列表的值,而是返回在该组中值的数目。

_.countBy([1, 2, 3, 4, 5], function(num) {
  return num % 2 == 0 ? 'even': 'odd';
});
=> {odd: 3, even: 2}

shuffle_.shuffle(list) 
返回一个随机乱序的 list 副本, 使用 Fisher-Yates shuffle 来进行随机乱序.

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

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]

toArray_.toArray(list) 
list(任何可以迭代的对象)转换成一个数组,在转换 arguments 对象时非常有用。

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

size_.size(list) 
返回list的长度。

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

partition_.partition(array, predicate) 
拆分一个数组(array)为两个数组: 第一个数组其元素都满足predicate迭代函数, 而第二个的所有元素均不能满足predicate迭代函数。

_.partition([0, 1, 2, 3, 4, 5], isOdd);
=> [[1, 3, 5], [0, 2, 4]]
/**
         * 集合 ( Collections )
         *     - each
         *     - map
         *     - reduce
         *     - reduceRight
         *     - find
         *     - filter
         *     - where
         *     - findWhere
         *     - reject
         *     - every
         *     - some
         *     - contains
         *     - invoke
         *     - pluck
         *     - max
         *     - min
         *     - sortBy
         *     - groupBy
         *     - indexBy
         *     - countBy
         *     - shuffle
         *     - sample
         *     - toArray
         *     - size
         *     - partition
         */
        
        /**
         * each
         * _.each(list, iteratee, [context]) 别名: forEach 
         * 遍历list中的所有元素,按顺序用遍历输出每个元素。
         * 如果传递了context参数,则把iteratee绑定到context对象上。
         * 每次调用iteratee都会传递三个参数:(element, index, list)。
         * 如果list是个JavaScript对象,iteratee的参数是 (value, key, list))。
         * 返回list以方便链式调用。
         * (注:如果存在原生的forEach方法,Underscore就使用它代替。)
         */
        _.each([1,2,3],alert); // alerts each number in turn...
        _.each({one: 1,two: 2,three: 3},alert); // alerts each number value in turn...
        /**
         * 注意:
         *     集合函数能在数组,对象,和类数组对象,比如arguments, NodeList和类似的数据类型上正常工作。
         *     但是它通过鸭子类型工作,所以要避免传递一个不固定length属性的对象(注:对象或数组的长度(length)属性要固定的)。
         *     每个循环不能被破坏 - 打破, 使用_.find代替,这也是很好的注意。
         */
        
        /**
         * map
         * _.map(list, iteratee, [context]) 别名: collect 
         * 通过变换函数(iteratee迭代器)把list中的每个值映射到一个新的数组中
         * (注:产生一个新的数组)。
         * 如果存在原生的map方法,就用原生map方法来代替。
         * 如果list是个JavaScript对象,iteratee的参数是(value, 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]

        /**
         * reduce
         * _.reduce(list, iteratee, [memo], [context]) 别名: inject,foldl
         * reduce方法把list中元素归结为一个单独的数值。
         * Memo是reduce函数的初始值,reduce的每一步都需要由iteratee返回。
         * 这个迭代传递4个参数:memo, value 和 迭代的index(或者 key)和最后一个引用的整个 list。
         *
         * 如果没有memo传递给reduce的初始调用,iteratee不会被列表中的第一个元素调用。
         * 第一个元素将取代 传递给列表中下一个元素调用iteratee的memo参数
         */
        var sum = _.reduce([1,2,3],function(memo, num){return memo+num;},0); // 6

        /**
         * reduceRight
         * _.reduceRight(list, iteratee, memo, [context]) 别名: foldr
         * reducRight是从右侧开始组合的元素的reduce函数
         * 如果存在JavaScript 1.8版本的reduceRight,则用其代替。
         * 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]

        /**
         * find
         * _.find(list, predicate, [context]) 别名: detect 
         * 在list中逐项查找,返回第一个通过predicate迭代函数真值检测的元素值
         * 如果没有值传递给测试迭代器将返回undefined
         * 如果找到匹配的元素,函数将立即返回,不会遍历整个list。
         */
        var even = _.find([1,2,3,4,5,6],function(num){return num%2 == 0;}); // 2

        /**
         * filter
         * _.filter(list, predicate, [context]) 别名: select 
         * 遍历list中的每个值,返回包含所有通过predicate真值检测的元素值。
         * (注:如果存在原生filter方法,则用原生的filter方法。)
         */
        var evens = _.filter([1,2,3,4,5,6],function(num){return num%2 == 0;}); // [2, 4, 6]

        /**
         * where
         * _.where(list, properties) 
         * 遍历list中的每一个值,返回一个数组
         * 这个数组包含包含properties所列出的属性的所有的键 - 值对。
         */
        _.where(listOfPlays,{author: 'Shakespeare',year: 1611});
        // [{title: "Cymbeline", author: "Shakespeare", year: 1611},
        //  {title: "The Tempest", author: "Shakespeare", year: 1611}]
        
        /**
         * findWhere
         * _.findWhere(list, properties) 
         * 遍历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."}
        
        /**
         * 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]

        /**
         * every
         * _.every(list, [predicate], [context]) 别名: all 
         * 如果list中的所有元素都通过predicate的真值检测就返回true。
         * (注:如果存在原生的every方法,就使用原生的every。)
         */
        _.every([true,1,null,'yes'],_.identity); // false

        /**
         * some
         * _.some(list, [predicate], [context]) 别名: any 
         * 如果list中有任何一个元素通过 predicate 的真值检测就返回true。
         * 一旦找到了符合条件的元素, 就直接中断对list的遍历. 
         * (注:如果存在原生的some方法,就使用原生的some。)
         */
        _.some([null,0,'yes',false]); // true

        /**
         * contains
         * _.contains(list, value) 别名: include 
         * 如果list包含指定的value则返回true(注:使用===检测)。
         * 如果list 是数组,内部使用indexOf判断。
         */
        _.contains([1,2,3],3); // true

        /**
         * invoke
         * _.invoke(list, methodName, *arguments) 
         * 在list的每个元素上执行methodName方法。
         * 任何传递给invoke的额外参数,invoke都会在调用methodName方法的时候传递给它。
         */
        _.invoke([[5,1,7],[3,2,1]],'sort'); // [[1, 5, 7], [1, 2, 3]]

        /**
         * 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"]

        /**
         * 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};

        /**
         * min
         * _.min(list, [iteratee], [context]) 
         * 返回list中的最小值。
         * 如果传递iteratee参数,iteratee将作为list中每个值的排序依据。
         * 如果list为空,将返回-Infinity,所以你可能需要事先用isEmpty检查 list 。
         */
        var numbers = [10,5,100,2,1000];
        _.min(numbers); // 2

        /**
         * 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]

        /**
         * 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"]}

        /**
         * 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} }

        /**
         * countBy
         * _.countBy(list, iteratee, [context]) 
         * 排序一个列表组成一个组,并且返回各组中的对象的数量的计数。
         * 类似groupBy,但是不是返回列表的值,而是返回在该组中值的数目。
         */
        _.countBy([1,2,3,4,5],function(num){return num%2 == 0?'even':'odd';}); // {odd: 3, even: 2}

        /**
         * shuffle
         * _.shuffle(list) 
         * 返回一个随机乱序的 list 副本, 使用 Fisher-Yates shuffle 来进行随机乱序.
         */
        _.shuffle([1,2,3,4,5,6]); // [4, 1, 6, 3, 5, 2]

        /**
         * 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]

        /**
         * toArray
         * _.toArray(list) 
         * 把list(任何可以迭代的对象)转换成一个数组,在转换 arguments 对象时非常有用。
         */
        (function(){return _.toArray(arguments).slice(1);})(1,2,3,4); // [2,3,4]

        /**
         * size
         * _.size(list) 
         * 返回list的长度。
         */
        _.size({one: 1, two: 2, three: 3}); // 3

        /**
         * partition
         * _.partition(array, predicate) 
         * 拆分一个数组(array)为两个数组:
         * 第一个数组其元素都满足predicate迭代函数,
         * 而第二个的所有元素均不能满足predicate迭代函数。
         */
        _.partition([0,1,2,3,4,5],isOdd); //  [[1, 3, 5], [0, 2, 4]]

 

posted @ 2016-08-30 11:56  jiangxiaobo  阅读(504)  评论(0编辑  收藏  举报