当前位置:首页 > 开发 > Web前端 > JavaScript > 正文

underscore.js 学习(一)

发表于: 2013-08-19   作者:bijian1013   来源:转载   浏览:
摘要:         工作中需要用到underscore.js,发现这是一个包括了很多基本功能函数的js库,里面有很多实用的函数。而且它没有扩展 javascript的原生对象。主要涉及对Collection、Object、Array、Function的操作。       学

        工作中需要用到underscore.js,发现这是一个包括了很多基本功能函数的js库,里面有很多实用的函数。而且它没有扩展 javascript的原生对象。主要涉及对Collection、Object、Array、Function的操作。
       学习官方网址:http://underscorejs.org

       Collection Functions (Arrays or Objects) 【集合函数】

        1.each   _.each(list, iterator, [context]) Alias: forEach

        迭代list中的所有元素,按顺序用迭代器输出每个元素。如果传递了context参数,则把iterator绑定到context对象上。每次调用iterator都会传递三个参数:(element, index, list)。如果list是个JavaScript对象,iterator的参数是 (value, key, list)。存在原生的forEach方法,Underscore就委托给forEach。

//_.each
_.each([1, 2, 3], function(num){ console.log(num); });
//  1,2,3
_.each({one : 1, two : 2, three : 3}, function(num, key){ console.log(num); });
//  1,2,3
_.each({one : 1, two : 2, three : 3}, function(num, key){ console.log(key); });
//  one,two,three

        

        2.map  _.map(list, iterator, [context]) Alias: collect

用转换函数把list中的每个值映射到一个新的数组。如果list是个JavaScript对象,iterator的参数是(value, key, list),这里的用法和each一样。 mapeach 的区别就是map可以接受返回值。

//_.map
var r = _.map([1, 2, 3], function(num){ return num * 3; });
console.log(r); //   [3, 6, 9]
var r = _.map({one : 1, two : 2, three : 3}, function(num, key){ return num * 3; });
console.log(r); //   [3, 6, 9]
var r = _.map({one : 1, two : 2, three : 3}, function(num, key) {
    return key;
});
console.log(r); //["one", "two", "three"]

        

        3.reduce  _.reduce(list, iterator, memo, [context]) Aliases: inject, foldl

reduce方法把列表中元素归结为一个简单的数值,。Memo是reduce函数的初始值,reduce的每一步都需要由iterator返回。

//_.reduce
var sum = _.reduce([1, 2, 3], function(memo, num){ return memo + num; }, 0);
console.log(sum); //6
var sum = _.reduce([2, 4, 8], function(memo, num){ return memo + num; }, 11);
console.log(sum); //25

         这个函数有些浏览器提供了原生的,如下的underscore源代码可以很好的帮忙理解此函数。

// 代码的前面就声明了一个变量,检测是否支持原生reduce:
var nativeReduce = ArrayProto.reduce;

 

// **Reduce** builds up a single result from a list of values, aka `inject`,
  // or `foldl`. Delegates to **ECMAScript 5**'s native `reduce` if available.
  _.reduce = _.foldl = _.inject = function(obj, iterator, memo, context) {
    var initial = arguments.length > 2;
    if (obj == null) obj = [];
    if (nativeReduce && obj.reduce === nativeReduce) {
      if (context) iterator = _.bind(iterator, context);
      return initial ? obj.reduce(iterator, memo) : obj.reduce(iterator);
    }
    each(obj, function(value, index, list) {
      if (!initial) {
        memo = value;
        initial = true;
      } else {
        memo = iterator.call(context, memo, value, index, list);
      }
    });
    if (!initial) throw new TypeError(reduceError);
    return memo;
  };

         解释上面的例子1就是:试用迭代器把obj(1,2,3)里面的元素相加,由于设置了初始值(0),那就先加初始值,每次的相加的值都存储在memo里面。所以结果是0+1+2+3=6。

       

        4.reduceRight  _.reduceRight(list, iterator, memo, [context]) Alias: foldr

        reducRight是从右侧开始组合的元素的reduce函数,如果存在JavaScript 1.8版本的reduceRight,则用其代替。Foldr在javascript中不像其它有懒计算的语言那么有用(lazy evaluation:一种求值策略,只有当表达式的值真正需要时才对表达式进行计算)。

//_.reduceRight
var list = [[0, 1], [2, 3], [4, 5]];
var flat = _.reduceRight(list, function(a, b) { return a.concat(b); }, []);
console.log(flat); // [4, 5, 2, 3, 0, 1]
    
var list = [[0],[11,22],[33,44,55]];
var flat = _.reduceRight(list, function(a, b) { return a.concat(b); }, []);
console.log(flat); // [33, 44, 55, 11, 22, 0]

 

        5.find  _.find(list, iterator, [context]) Alias: detect

        遍历list,返回第一个通过iterator真值检测的元素值。如果找到匹配的元素立即返回,不会遍历整个list。

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

 

        6.filter  _.filter(list, iterator, [context]) Alias: select

        遍历list,返回包含所有通过iterator真值检测的元素值。如果存在原生filter方法,则委托给filter,

和find不同的是,它返回所有符合条件的值,返回一个数组。

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

 

        7.where   _.where(list, properties)

        遍历list,返回properties中所有键值对都相等的对象数组。

//_.where
var listOfPlays = [{title: "Cymbeline", author: "Shakespeare", year: 1611},
        {title: "The Tempest", author: "Shakespeare", year: 1631},
        {title: "The Tempest2", author: "Shakespeare", year: 1661},
        {title: "The Tempest3", author: "Shakespeare3", year: 1611},
        {title: "The Tempest4", author: "Shakespeare", year: 1611}];
var r = _.where(listOfPlays, {author: "Shakespeare", year: 1611});
console.log(r);
//[{title: "Cymbeline", author: "Shakespeare", year: 1611},{title: "The Tempest4", author: "Shakespeare", year: 1611}]

 

        8.findWhere   _.findWhere(list, properties)

        遍历list,返回properties中所有键值对都相等的第一个对象。

//_.findWhere
var listOfPlays = [{title: "Cymbeline", author: "Shakespeare0", year: 1611},
        {title: "The Tempest", author: "Shakespeare", year: 1611},
        {title: "The Tempest2", author: "Shakespeare", year: 1661},
        {title: "The Tempest3", author: "Shakespeare3", year: 1611},
        {title: "The Tempest4", author: "Shakespeare", year: 1611}];
var r = _.findWhere(listOfPlays, {author: "Shakespeare", year: 1611});
console.log(r); //{title: "The Tempest", author: "Shakespeare", year: 1611} 

 

        9.reject   _.reject(list, iterator, [context])

        返回那么没有通过iterator真值检测的元素数组,filter的相反函数。

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

 

        10.every    _.every(list, [iterator], [context]) Alias: all

        如果list中的所有元素都通过iterator的真值检测就返回true。如果存在原生的every方法,则委托给every。

//_.every
var r = _.every([2, 22, 12, 4, 34, 68], function(num){ return num % 2 == 0; });
console.log(r); //true
var r = _.every([2, 22, 12, 3, 34, 68], function(num){ return num % 2 == 0; });
console.log(r); //false

 

        11.some  _.some(list, [iterator], [context])  Alias: any

        如果有任何一个元素通过通过 iterator 的真值检测就返回true。如果存在原生的some方法,则委托给some。

//_.some
var r = _.some([null, 0, 'yes', false]);
console.log(r); //true
var r = _.some([2, 1, 13, 6, 37, 68], function(num){ return num % 2 == 0; });
console.log(r); //true
var r = _.some([2, 1, 13, 7, 37, 68], function(num){ return num % 3 == 0; });
console.log(r); //false

 

        12.contains    _.contains(list, value)    Alias: include

        如果list包含指定的value则返回true,使用===检测是否相等。如果list 是数组,内部使用indexOf判断。

//_contains
var r = _.contains([1, 2, 3], 3);
console.log(r); //true
var r = _.contains({one:1,two:2},1);
console.log(r); //true
var r = _.contains({one:2,two:3},1);
console.log(r); //false

 

        13.invoke   _.invoke(list, methodName, [*arguments])

        在list的每个元素上执行methodName方法。如果有额外的参数,则在调用methodName方法的时候传给它。

//_invoke
var r = _.invoke([[5,1,7],[3,2,1]],'sort');//进行排序操作
console.log(r); //[[1, 5, 7], [1, 2, 3]]

 

        14.pluck   _.pluck(list, propertyName)

        提取对象中的一个属性,返回一个数组。

//_.pluck
var stooges = [{name : 'moe', age : 40}, {name : 'larry', age : 50}, {name : 'curly', age : 60}];
var r = _.pluck(stooges, 'name');
console.log(r);	//["moe", "larry", "curly"] 
var r = _.pluck(stooges, 'age');
console.log(r); //[40, 50, 60]

 

        15.max   _.max(list, [iterator], [context])

        返回list中的最大值,迭代器可选,如果有,则以迭代器作为排序依据。

//_.max
var stooges = [{name : 'moe', age : 40}, {name : 'larry', age : 50}, {name : 'curly', age : 60}];
var r = _.max(stooges, function(stooge){ return stooge.age; });
console.log(r); //{name: "curly", age: 60}

 

        16.min   _.min(list, [iterator], [context])

        返回list中的最小值,迭代器可选,如果有,则以迭代器作为排序依据。

//_.min
var numbers = [10, 5, 100, 2, 1000];
var r = _.min(numbers);
console.log(r); //2
var stooges = [{name : 'moe', age : 40}, {name : 'larry', age : 50}, {name : 'curly', age : 60}];
var r = _.min(stooges, function(stooge){ return stooge.age; });
console.log(r); //{name: "moe", age: 40}

 

        17.sortBy   _.sortBy(list, iterator, [context])

        返回一个通过升序排序后的一个数组(新的数组),如果有迭代器,以迭代器作为排序依据。

//_.sortBy
var r = _.sortBy([1, 2, 3, 4, 5, 6], function(num){ return Math.sin(num); }); 
console.log(r); //[5, 4, 6, 3, 1, 2]

 

        18.groupBy   _.groupBy(list, iterator, [context])

        通过迭代器返回的值分组,生成一个json对象。迭代器也可以是一个字符串,通过调用元素对应的属性分组。

//_.groupBy
var r = _.groupBy([1.3, 2.1, 2.4], function(num){ return Math.floor(num); }); 
console.log(r); //{1: [1.3], 2: [2.1, 2.4]}
var r = _.groupBy(['one', 'two', 'three'], 'length'); 
console.log(r); //{3: ["one", "two"], 5: ["three"]}

  

        19.countBy   _.countBy(list, iterator, [context])

        对list进行分组,返回一个json对象,对应的键值对是:分组名(在迭代器里面设置)和数量。

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

 

        20.shuffle   _.shuffle(list)

        返回一个打乱了的list数组副本。

//_.shuffle
var r = _.shuffle([1, 2, 3, 4, 5, 6]); 
console.log(r); //[5, 2, 6, 1, 4, 3]

  

        21.toArray   _.toArray(list)

        转换list为数组,对有参数对象的转换很有用。

//_.toArray
var r = (function(){
    return _.toArray(arguments).slice(1); 
})(1, 2, 3, 4); 
console.log(r); //[2, 3, 4]

        说明:slice() 方法可从已有的数组中返回选定的元素。arrayObject.slice(start,end) :返回一个新的数组,包含从 start 到 end (不包括该元素)的 arrayObject 中的元素。

 

        22.size   _.size(list)

        返回list的长度

//_.size
var r = _.size({one : 1, two : 2, three : 3});
console.log(r); //3

 

underscore.js 学习(一)

  • 0

    开心

    开心

  • 0

    板砖

    板砖

  • 0

    感动

    感动

  • 0

    有用

    有用

  • 0

    疑问

    疑问

  • 0

    难过

    难过

  • 0

    无聊

    无聊

  • 0

    震惊

    震惊

编辑推荐
学习新知识有时候很难决定是做深度遍历还是广度遍历,比如那么多javascript框架,是先都走马观花看
如果您有任何建议,或者拍砖,欢迎在微博上@愚人码头 联系我。 <iframe style="font-family: 'He
_.each() _.each(list, iterator, [context]); 按顺序遍历输出每个元素。如果传递了context参数,则
underscore是一个非常实用的JavaScript库,提供许多编程时需要的功能的支持,他在不扩展任何JavaScr
underscore是一个非常实用的JavaScript库,提供许多编程时需要的功能的支持,他在不扩展任何JavaScr
函数节流在日常的DOM界面数据交互中有比较大的作用,可以减少服务器的请求,同时减少客户端的内存影
最近看了几本书,发现过了几天都忘了。写这个也是为了能够把每天看到的知识罗列在这里,偶尔温故一
_.find(); _.find(list, predicate, [context]); 在list中逐项查找,返回第一个通过predicate迭代函
_.every() 匹配所有,所有通过返回真,返回布尔 _every(list, pre); list中所有元素都通过pre的真值
_.max() 返回list中最大值,作为iterator排序的依据 _.max(list, [iterator], [context]); _.min()返
版权所有 IT知识库 CopyRight © 2009-2015 IT知识库 IT610.com , All Rights Reserved. 京ICP备09083238号