/**

         * 集合 ( 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); //

        /**

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

        /**

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

        /**

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

        _.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}); //

        /**

         * partition

         * _.partition(array, predicate)

         * 拆分一个数组（array）为两个数组：

         * 第一个数组其元素都满足predicate迭代函数，

         * 而第二个的所有元素均不能满足predicate迭代函数。

         */

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