underscore api 概览

underscore

集合函数(数组或对象)

_.each(list, iteratee, [context]);
_.map(list, iteratee, [context]);
_.reduce(list, iteratee, [memo], [context]); //foldl
_.reduceRight(list, iteratee, [memo], [context]); //foldr
_.find(list, predicate, [context]); //detect
_.filter(list, predicate, [context]); //select
_.where(list, properties);//返回对象数组，每个对象包含指定的properties
_.findWhere(list, properties);
_.reject(list, predicate, [context]); //与filter相反
_.every(list, [predicate], [context]); //all
_.some(list, [predicate], [context]); //any
_.contains(list, value); //include
_.invoke(list, methodName, *arguments);
_.pluck(list, propertyName);
_.max(list, iteratee, [context]);
_.min(list, iteratee, [context]);
_.sortBy(list, iteratee, [context]);
_.groupBy(list, iteratee, [context]); //=> return obj
_.indexBy(list, iteratee, [context]); //=> return obj
_.countBy(list, iteratee, [context]); //=> return obj
_.shuffle(list);
_.sample(list,[n]);
_.toArray(list); // like $.makeArray
_.size(list);
_.partition(list, predicate);//数组分成2个子数组为true, 为false

数组函数

_.first(array, [n]); //默认 n=1
_.initial(array, [n]); //从末尾删除n个元素后的子数组默认n=1
_.last(array, [n]); //保留最后n个元素，形成的新数组
_.rest(array, [n]);//去掉前面n个元素，形成新的数组 _.tail(), _.drop();
_.compact(array); //删除所有false值后的数组副本
_.flatten(array, [shallow]);//扁平化数组 shallow=true则只扁平1层
.without(array, *values); //返回删除values值后的数组副本
_.union(*arrays);//数组合并会去掉重复项
_.intersection(*arrays); //数组的交集
_.difference(array, *others); //在源数组中有，其他数组没有的元素组成新数组
.uniq(array); //.unique(array); 数组去重
_.zip(*arrays); //每个数组相应位置的值合并在一起，返回二维数组
_.object(list, [values]); //两个数组转换为对象，或二维数组转换为对象[['name1','val1'],['name2', 'val2']]
_.indexOf(array, value, [isSorted]);
_.lastIndexOf(array, value, [fromIndex]);
_.sortedIndex(list, value, [iteratee], [context]); //返回value在list中的位置序号
_.range([start], stop, [step]); //返回整数数组

函数相关的函数

_.bind(function, object, *arguments); //绑定上下文和部分参数返回偏函数

    var func = function(greeting){ return greeting + ': ' + this.name; };
    func = _.bind(func, {name:'sindy'}, 'hi');
    func();

_.bindAll(object, *methodNames);

    var buttonView = {
        label: 'underscore',
        onClick: function(){ alert('clicked ' + this.label); },
        onHover: function(){ console.log('hovering ' + this.label); }
    };
    _.bindAll(buttonView, 'onClick', 'onHover');
    $('#underscoreBtn').bind('click', buttonView.onClick);

_.partial(function, *arguments); //类似bind，只是不绑定上下文对象, 返回偏函数

    var add = function(a, b){ return a+b; };
    var add5 = _.partial(add, 5);
    add5(10); //15

_.memoize(function, [hashFunction]); //缓存某函数的计算结果

    var fibonacci = _.memoize(function(n){
        return n<2?n:fibonacci(n-1) + fibonacci(n-2);
    });

_.delay(function, wait, *arguments); //类似setTimeout, 但是可以传递参数给回调函数

    var log = _.bind(console.log, console);
    _.delay(log, 1000, 'logged later');

_.defer(function, *arguments);//延迟调用函数直到调用栈为空, 类似setTimeout(function, 0); 只是可传入参数

    _.defer(alert, 'some deferred tips');

_.throttle(function, wait, [options]); //限制执行频率

    var throttled = _.throttle(updatePosition, 100);
    $(window).scroll(throttled);

_.debounce(function, wait, [immediate]);//将函数的执行真正延迟到最后一次调用的wait秒之后

    var lazyLayout = _.debounce(calculateLayout, 300);
    $(window).resize(lazyLayout);

_.once(function); //创建一个只能调用一次的函数，重复调用，只会返回第一次调用的结果

    var init = _.once(createApplication);
    init();
    init();

_.after(count, function); 只有在执行了count次之后，才真正执行function

    var renderNotes = _.after(notes.length, render);
    _.each(notes, function(){
        note.asyncSave({success: renderNotes});
    });// renderNotes is run once, after all notes have saved

_.before(count, function); //count次之前正常执行函数，count次以及其后的调用返回最后一次调用的结果

    var monthlyMeeting = _.before(3, raise);
    monthlyMeeting();
    monthlyMeeting();

_.wrap(function, wrapper); //装饰者模式..

    var hello = function(name){ return 'hello ' + name; };
    hello = _.wrap(hello, function(func){
        return 'before ' + func('moe') + ' after';
    };
    hello();

_.negate(predicate); //返回predicate函数的否定版本

    var isFalsy = _.negate(Boolean);
    _.find([1,2,0,33,11], isFalsy); //0

_.compose(*functions); //返回函数集组合后的复合函数

    // _.compose(f,g,h); => h(g(f()))
    var greet = function(name){ return 'hello ' + name; };
    var exclaim = function(statement){ return statement.toUpperCase() + '!';};
    var welcome = _.compose(greet, exclaim);
    welcome('sindy');

对象相关函数

_.keys(object); //返回key组成的数组
_.values(object); //返回value组成的数组
_.pairs(object); //对象转换为[[key1,val1],[key2, val2]]这样的二维数组
_.invert(object); //返回key-value对调后的对象

    var obj =  {'one':1, 'two': 2 , 'three':3};
    _.invert(obj);

_.functions(object); //返回对象里所有的方法名组成的数组 _.methods()
_.extend(dest, *objects);
.pick(object, *keys); //.pick(object, predicate);
.omit(object, *keys); //.omit(object, predicate); //返回从object删除一些属性后的副本和pick相反
_.defaults(object, *defaults);//用defaults对象填充object对象中的undefined属性，有点非覆盖版的extend的感觉

    var student = {name:'coco', grade:'one'};
    _.defaults(student, {grade:'two', teach: 'sisi'});
    //=>{name:'coco', teach:'sisi', grade:'one'}

_.clone(object); //创建一个浅拷贝的对象
_.tap(object, interceptor); //用object作为参数调用拦截器函数，然后返回object，以便链式调用

    _.tap(sindy, function(sindy){ console.log(sindy.name + ' say hi');});
    //=> return sindy

_.has(object, key); //like object.hasOwnProperty(key)
_.property(key);//返回一个函数，接受一个对象参数，返回该对象key对应的值

    var sindy = {name:'sindy', age: 18, major:'singer'};
    var getName = _.property('name');
    var val = getName(sindy);

_.matches(attrs); //返回一个断言函数，判断入参的对象是否满足 attrs

    var matcher = _.matches({major:'singer'});
    matcher(sindy); //=> true

_.isEqual(object1, object2);//按值深度比较两个对象
_.isEmpty(object); //object是否为空(即: 不包含任何可枚举的属性)
_.isElement(object); //是否dom元素
_.isArray(param);
_.isObject(val);//是否对象数组和对象都为true
_.isArguments(object); //是否参数对象

    (function(){ return _.isArguments(arguments);})(1,2,3);
    //=>return true;

_.isFunction(object); //是否函数
_.isString(object); //是否字符串
_.isFinite(val); //是否有限数字
_.isBoolean(val); //是否逻辑值
_.isDate(val); //是否日期
_.isRegExp(val); //是否正则对象
_.isNaN(val);
_.isNull(val);
_.isUndefined(val);

功能函数(utility functions)

.noConflict(); //让出变量名"",避免命名空间冲突

    var underscore = _.noConflict();

_.identity(value); //返回与传入参数相等的值用作默认的迭代函数

    var moe = {name:'moe'};
    _.identity(moe); //=> {name: 'moe'}

_.constant(value); //创建总是返回入参值的函数

    var moe = {name: 'moe'};
    moe === _.constant(moe)(); //=>true

_.noop(); //什么都不做用作默认的回调函数
_.times(n, iteratee, [context]);//调用迭代函数n次返回函数返回值的数组

    var grow = function(){ this.age += 1; return this.age; }
    var arr = _.times(10, grow, sindy);

_.random(min, [max]); //返回两个值之间的随机整数
_.mixin(object); //{name:fn, name2: fn2}用类似的函数集扩展underscore，并可用面向对象的方式调用

    _.mixin({
        capitalize: function(str){
            return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
        }
    });
    _('sindy').capitalize(); //Sindy

_.iteratee(val, [context], [argCount]);//重要的内部函数，返回可应用到集合中每个元素的回调

    var roles = [{name:'alice', age: 18}, {name: 'walmei', age:20}];
    _.map(roles, iteratee('age'));

_.uniqueId([prefix]);//生成全局唯一id
_.escape(str); //转义 &, <, >, " ,', /
_.unescape(str); //取消转义
_.result(object, property); //若object.property是函数则返回函数执行结果，否则直接返回object.property
_.now(); //返回当前时间戳
_.template(templateString, [setting]); //返回模板函数，等待数据填充

    //template语法: <%= ... %>插入变量, <%- ... %>插入做html转义后的变量
    //<% ... %>中间可以包含js代码(用 print(str) 来输出)
    var compiled = _.template('hello: <%= name %>');
    compiled({name:'sidy'}); //=> 'hello sindy'

    var template = _.template('<b><%- value %></b>');
    template({value: '<script>'});//=>'<b>&lt;script&gt;</b>'

    var compiled = _.template('<% print("hello " + name); %>');
    compiled({name:'sinner'}); //=>'hello sinner'

    //用interpolate参数修改默认定界符
    _.templateSettings = { interpolate: /{{(.+?)}}/g };
    var template = _.template("hello {{name}}");
    template({name: 'wendy'});//=> hello wendy

_.chain(obj);//链式语法

    //underscore提供了函数风格语法和面向对象语法，可选择使用，如：
    _.map([1,2,3], function(n){ return n*2; }); //下面等价
    _([1,2,3]).map(function(n){ return n*2; });

    //_.chain(object); chain方法会把对象封装，让后续方法都返回封装后的对象，最好通过.value()方法取出实际的值。
    //如： 取出歌词中每个单词出现的次数
    var lyrics = [
        {line:1, words: "i am a lumberjack and i am okay"},
        {line:2, words: "He is a lumberjack and he is okey"},
        {line:3, words: "He sleeps all night and works all day"}
    ];
    _.chain(lyrics)
     .map(function(line){ return line.words.split(' ')})
     .flatten()
     .reduce(function(counts, word){
        counts[word] = (counts[word] || 0) + 1;
        return counts;
     },{});

_(object).value(); //返回封装对象的最终值