underscore 笔记

 //reduce是汇总 递归
     var perDesc=[
         {name: "haha",   "email": "haha@email.com"},
         {"height":173,"weight":100},
         {"gender":"female","phone":"13888888888"}
     ]

    var aa=_.reduce(perDesc,function(memo,value,index,list){
        return _.extend(memo,value);
    });
    console.info(aa);

    var arr=["a","b","c","d","e"]
    var bb= _.reduce(arr,function(memo,value){
     return memo+value;
    },"拼接完的字符串是：")

   console.info(bb);

　

/*Underscore默认使用_（下划线）来访问和建立对象，*/
var zzn=_.noConflict()
console.dir(zzn)

/*Underscore支持链式操做，但你须要先调用chain()方法进行声明：*/
var leyi=[1,2,3,4,5]
var results=_(leyi).chain().map(function(item){
	return item+1
}).value()
console.info(results)//[2, 3, 4, 5, 6]
console.info(_.isEqual(_({"aa":"bb"}),_.chain({"aa":"bb"})))
-------------------------------------------------------------------

//集合函数 (数组 或对象) Collections
each_.each(list, iteratee, [context])  
遍历list中的全部元素，按顺序用遍历输出每一个元素。若是传递了context参数，则把iteratee绑定到context对象上。每次调用iteratee都会传递三个参数：(element, 

index, list)。若是list是个JavaScript对象，iteratee的参数是 (value, key, list))。返回list以方便链式调用。
var arr=[1,2,3,4,5,6]
var obj={"name":"aa","age":"bb","gender":"cc"}
_.each(arr,function(element,index,list){
console.info(element+"------"+index+"-----"+list)
})
/*
1------0-----1,2,3,4,5,6
2------1-----1,2,3,4,5,6
3------2-----1,2,3,4,5,6
4------3-----1,2,3,4,5,6
5------4-----1,2,3,4,5,6
6------5-----1,2,3,4,5,6
*/

_.each(obj,function(value,key,list){
console.info(value+"------"+key+"-----"+list)
})
/*
aa------name-----[object Object]
bb------age-----[object Object]
cc------gender-----[object Object]
*/


//map_.map(list, iteratee, [context])
经过转换函数(iteratee迭代器)映射列表中的每一个值产生价值的新数组。iteratee传递三个参数：value，而后是迭代 index(或 key 若是list是个JavaScript对象是，这个

参数就是key)，最后一个是引用指向整个list。
var arr=[1,2,3,4,5]
var obj={"name":"aa","age":"bb","gender":"cc"}
var newArr=_.map(arr,function(element,index,list){
return element+1
})

var newObj=_.map(obj,function(value,key,list){
return value+"^_^"
})

console.info(newArr)//[2, 3, 4, 5, 6]
console.info(newObj)//["aa^_^", "bb^_^", "cc^_^"]

//each和map区别
/*each()函数在操做时，只是执行按照过滤条件遍历每一个列表元素的动做，该动做并没有返回内容；而map()函数在操做时，不只按照过滤条件执行遍历元素的动做，并且返回

一个新的过滤后的集合内容*/

//every方法判断数组的全部元素是否都知足某个条件。若是都知足则返回true，不然返回false。
alert(_.every([1,2,3,4,5,6],function(num){
return num<10
}))
//true

//some方法则是只要有一个元素知足，就返回true，不然返回false。
var b=_.some([1,2,3,4,5,11],function(num){
	return num>10
})
alert(b)//true

//shuffle方法返回一个打乱次序的集合。
console.info(_.shuffle([1, 2, 3, 4, 5, 6]))


/*max / min 这两个函数直接返回集合中最大和最小的数：*/
var arr=[1,2,3,4,5]
console.info(_.max(arr))//5
console.info(_.min(arr))//1

//返回集合的数量
var arr=[1,2,3,{"num":"aa"}]
alert(_.size(arr))
//4

//数组过滤
//Underscore.js提供了一系列方法，用于过滤数组，找到符合要求的成员。
//filter方法依次对集合的每一个成员进行某种操做，只返回操做结果为true的成员。
var arr=[1,2,3,4]
console.info(_.filter(arr,function(item){
return item==2
}))
//[2]

//reject方法只返回操做结果为false的成员。
console.info(_.reject(arr,function(item){
return item==2
}))
//[1, 3, 4]

//find方法依次对集合的每一个成员进行某种操做，返回第一个操做结果为true的成员。若是全部成员的操做结果都为false，则返回undefined。
var arr2=[2,3,4,5,6,76,5]
console.info(_.find(arr2,function(item){
return item==5
}))
//5

//contains方法表示若是某个值在数组内，则返回true，不然返回false。
console.info(_.contains([3,4,5],3))//true

//countBy方法依次对集合的每一个成员进行某种操做，将操做结果相同的成员算做一类，最后返回一个对象，代表每种操做结果对应的成员数量。
var arr3=[1,2,3,4,5]
console.info(_.countBy(arr3,function(item){
return item%2==0?"偶数":"奇数"
}))
//Object {奇数: 3, 偶数: 2}

var obj=[1,2,3,4,5]
console.info(_.groupBy(obj,function(item){
return item%2==0?"偶数":"奇数"
}))

//返回返回列表的值 Object {偶数:[2,4], 奇数:[1,3,5]}


//对象相关方法
//toArray方法将对象转为数组，只包含对象成员的值。典型应用是将对相似数组的对象转为真正的数组。
var obj={"aa":"11","bb":"22"}
console.info(_.toArray(obj))
// /["11", "22"]

//pluck方法将多个对象的某一个属性的值，提取成一个数组。
var obj={"aa":"11","bb":"22"}
var obj2={"aa":"33","bb":"44"}
console.info(_.pluck([obj,obj2],'aa'))
// /["11", "33"]

/*sample_.sample(list, [n]) 
从 list中产生一个随机样本。传递一个数字表示从list中返回n个随机元素。不然将返回一个单一的随机项。*/
console.info(_.sample([1, 2, 3, 4, 5, 6]))
//1
console.info(_.sample([1, 2, 3, 4, 5, 6], 3))
//2 6 1

//reduce_.reduce(list, iteratee, [memo], [context]) 
Memo是reduce函数的初始值，reduce的每一步都须要由iteratee返回。这个迭代传递4个参数：memo,value 和 迭代的index（或者 key）和最后一个引用的整个 list。
//memo若是没有初始值, 则将第一个元素做为初始值(数组); 若是被处理的是对象集合, 则默认值为第一个属性的值  
/*var obj=[1,2,3,4,5]*/
var obj={"aa":1,"bb":5,"cc":3}
var mm=_.reduce(obj,function(memo,value,index,list){ 
	console.info(memo+"-------"+value)
	return memo+value 
},0) 
console.info(mm)//9
/*
0-------1
1-------5
6-------3
*/

reduceRight从右边开始向左边进行操做
var obj={"aa":1,"bb":5,"cc":3}
var mm=_.reduceRight(obj,function(memo,value,index,list){ 
	console.info(memo+"-------"+value)
	return memo+value 
},0) 
console.info(mm)//9
/*
0-------3
3-------5
8-------1
*/

var obj=[[0, 1], [2, 3], [4, 5]];
var mm=_.reduceRight(obj,function(memo,value,index,list){ 
	console.info(memo)
/*	[4, 5]
    [4, 5, 2, 3]
    [4, 5, 2, 3, 0, 1]*/
	return memo.concat(value) //初始值没有设置memo,会取obj里的第一个元素[4, 5]进行数组合并操做
}) 
console.info(mm)

var obj=[{name: 'moe', age: 40}, {name: 'larry', age: 50}, {name: 'curly', age: 60}];
console.dir(_.indexBy(obj,"age"))
//根据索引分类 返回每一个索引的对象
/*
40: Object [age: 40,name: "moe"]
50: Object [age: 50,name: "larry"]
60: Object [age: 60,name: "curly"]
*/

/*partition_.partition(array, predicate) 
拆分一个数组（array）为两个数组：  第一个数组其元素都知足predicate迭代函数， 而第二个的全部元素均不能知足predicate迭代函数。*/
console.info(_.partition([0, 1, 2, 3, 4, 5], function(item){
return item%2==0
})
)
//[[0,2,4],[1,3,5]]

-------------------------------------------------------------------
与函数有关的函数（Function (uh, ahem) Functions）

first_.first(array, [n]) Alias: head, take 
返回array（数组）的第一个元素。传递 n参数将返回数组中从第一个元素开始的n个元素（返回数组中前 n 个元素.）。
console.info(_.first([1,2,3,4,5]))
//1
console.info(_.first([1,2,3,4,5],3))
//[1,2,3]

console.info(_.last([1,2,3,4]))
//4
console.info(_.last([1,2,3,4],3))
//[2, 3, 4]

/*initial_.initial(array, [n]) 
返回数组中除了最后一个元素外的其余所有元素。 在arguments对象上特别有用。传递 n参数将从结果中排除从最后一个开始的n个元素（排除数组后面的 n 个元素）。*/
console.info(_.initial([1,2,3,4,5]))
//[1, 2, 3, 4]
console.info(_.initial([1,2,3,4,5],3))
//[1,2]

rest_.rest(array, [index]) Alias: tail, drop 
返回数组中除了第一个元素外的其余所有元素。传递 index 参数将返回从index开始的剩余全部元素 。
console.info(_.rest([1,2,3,4,5]))
//[2, 3, 4, 5]
console.info(_.rest([1,2,3,4,5],3))
//[4, 5]

//compact 压紧压缩 返回一个除去全部false值的 array副本。 在javascript中, false, null, 0, "", undefined 和 NaN 都是false值.
console.info(_.compact([false,1,2,3,"",NaN,0,4,5]))

//flatten 扁平化 
//将一个嵌套多层的数组 array（数组） (嵌套能够是任何层数)转换为只有一层的数组。 若是你传递 shallow参数，数组将只减小一维的嵌套。
console.info(_.flatten([1,2,3,[[[5]]]])) //[1, 2, 3, 5]
console.info(_.flatten([1,2,3,[[[5]]]],true))//[1,2,3,[[5]]]

//without _.without(array, *values) 
//返回一个删除全部values值后的 array副本。
console.info(_.without([1,2,3,4,5],2,3))//[1, 4, 5]

/*union_.union(*arrays) 
返回传入的 arrays（数组）并集：按顺序返回，返回数组的元素是惟一的，能够传入一个或多个 arrays（数组）。*/
console.info(_.union([1,2,3,4],[5,6,7])) //[1, 2, 3, 4, 5, 6, 7]

//intersection 交叉交集 返回传入 arrays（数组）交集。结果中的每一个值是存在于传入的每一个arrays（数组）里。
console.info(_.intersection([1,2,3,4,5],[1,2,3,4],[3])) //[3]

/*difference_.difference(array, *others) 
相似于without，但返回的值来自array参数数组，而且不存在于other 数组.*/
console.info(_.difference([1,2,3,4,5],[1,2,3])) //[4, 5]

//unique 惟一的  _.uniq  返回 array去重后的副本, 使用 === 作相等测试. 若是您肯定 array 已经排序, 那么给 isSorted 参数传递 true值, 此函数将运行的更快的

算法. 若是要处理对象元素, 传递 iteratee函数来获取要对比的属性.
console.info(_.uniq([1,2,3,4,4,4,5])) //[1, 2, 3, 4, 5]

/*zip_.zip(*arrays)  unzip 相反
将 每一个arrays中相应位置的值合并在一块儿。在合并分开保存的数据时颇有用. 若是你用来处理矩阵嵌套数组时, _.zip.apply 能够作相似的效果。*/
 console.info(_.zip([1,2,3,4],["aa","bb","cc","dd"]))
//[[1,"aa"],[2,"bb"],[3,"cc"],[4,"dd"]]

/*object_.object(list, [values]) 
将数组转换为对象。传递任何一个单独[key, value]对的列表，或者一个键的列表和一个值得列表。 若是存在重复键，最后一个值将被返回。*/
console.info(_.object(["a","b","c","d"],[1,2,3,4]))

/*indexOf_.indexOf(array, value, [isSorted]) 
返回value在该 array 中的索引值，若是value不存在 array中就返回-1。使用原生的indexOf 函数，除非它失效。若是您正在使用一个大数组，你知道数组已经排序，传递

true给isSorted将更快的用二进制搜索..,或者，传递一个数字做为第三个参数，为了在给定的索引的数组中寻找第一个匹配值。*/
console.info(_.indexOf([1,2,3,4,5,6],3)) //2

lastIndexOf_.lastIndexOf(array, value, [fromIndex]) 
返回value在该 array 中的从最后开始的索引值，若是value不存在 array中就返回-1。若是支持原生的lastIndexOf，将使用原生的lastIndexOf函数。传递fromIndex将从

你给定的索性值开始搜索。
var arr=[1,2,3,4,5,2,3,6]
console.info(_.lastIndexOf(arr,3)) //6

/*sortedIndex_.sortedIndex(list, value, [iteratee], [context]) 
使用二分查找肯定value在list中的位置序号，value按此序号插入能保持list原有的排序。若是提供iterator函数，iterator将做为list排序的依据，包括你传递的value 

。iterator也能够是字符串的属性名用来排序(好比length)。*/
var arr=[1,2,3,4,5,6,8]
console.info(_.sortedIndex(arr,7)) //6

/*findIndex_.findIndex(array, predicate, [context]) 
相似于_.indexOf，当predicate经过真检查时，返回第一个索引值；不然返回-1。*/
var arr=[1,2,3,4,2,5,6,8]
console.info(_.findIndex(arr,function(value){
return value==2
}))

/*findLastIndex_.findLastIndex(array, predicate, [context]) 
和_.findIndex相似，但反向迭代数组，当predicate经过真检查时，最接近末端的索引值将被返回。*/
console.info(_.findLastIndex(arr,function(value){
return value==2
}))


/*range_.range([start], stop, [step]) 
一个用来建立整数灵活编号的列表的函数，便于each 和 map循环。若是省略start则默认为 0；step 默认为 1.返回一个从start 到stop的整数的列表，用step来增长 （或

减小）独占。值得注意的是，若是stop值在start前面（也就是stop值小于start值），那么值域会被认为是零长度，而不是负增加。-若是你要一个负数的值域 ，请使用负

数step.
*/
console.info(_.range(10)) //[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
console.info(_.range(1,20,2))  //[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]

-------------------------------------------------------------------
与函数有关的函数（Function (uh, ahem) Functions）

// bind_.bind(function, object, *arguments)  bind方法 该方法绑定函数运行时的上下文，返回一个新函数。
var haha=function(ag1){
	console.info(this.name+"-----"+this.age+"-----"+ag1)
}
_.bind(haha,{"name":"leyi","age":100},'123')()
//leyi-----100-----123


bindAll_.bindAll(object, *methodNames) 
把methodNames参数指定的一些方法绑定到object上，这些方法就会在对象的上下文环境中执行。绑定函数用做事件处理函数时很是便利，不然函数被调用时this一点用也没

有。methodNames参数是必须的。
<input type="button" value='111' class="query"/> 
var methodArr={
	'onClick':function(){
		console.info(1)
	},
	'onHover':function(){
		console.info(2)
	}
}

_.bindAll(methodArr,'onClick','onHover')

$('.query').on('click',function(){
	methodArr.onClick()
})


/*delay_.delay(function, wait, *arguments) 
相似setTimeout，等待wait毫秒后调用function。若是传递可选的参数arguments，当函数function执行时， arguments 会做为参数传入。*/
_.delay(function(ag1){
	alert(ag1)
},1000,'hehe')  //hehe


/*defer_.defer(function, *arguments) 
延迟调用function直到当前调用栈清空为止，相似使用延时为0的setTimeout方法。对于执行开销大的计算和无阻塞UI线程的HTML渲染时候很是有用。 若是传递arguments参

数，当函数function执行时， arguments 会做为参数传入。*/


/*throttle_.throttle(function, wait, [options]) 
建立并返回一个像节流阀同样的函数，当重复调用函数的时候，至少每隔 wait毫秒调用一次该函数。对于想控制一些触发频率较高的事件有帮助。*/
var throttled=_.throttle(function(){
	console.info(11)
},200)
$(window).scroll(throttled)


/*debounce_.debounce(function, wait, [immediate]) 
返回 function 函数的防反跳版本, 将延迟函数的执行(真正的执行)在函数最后一次调用时刻的 wait 毫秒以后. 对于必须在一些输入（可能是一些用户操做）中止到达以后

执行的行为有帮助。*/
//当调用动做n毫秒后，才会执行该动做，若在这n毫秒内又调用此动做则将从新计算执行时间。
var lazyLoad=_.dobounce(function(){
	console.info('加载数据')
},100)


/*once_.once(function) 
建立一个只能调用一次的函数。重复调用改进的方法也没有效果，只会返回第一次执行时的结果。 做为初始化函数使用时很是有用, 不用再设一个boolean值来检查是否已

经初始化完成.*/

-------------------------------------------------------------------

对象函数（Object Functions）/*keys_.keys(object) 
检索object拥有的全部可枚举属性的键名称。*/
console.info(_.keys({one: 1, two: 2, three: 3})) //["one", "two", "three"]

/*allKeys_.allKeys(object) 
检索object拥有的和继承的全部属性的名称。*/

function Haha(){
	this.name='leyi'
}
Haha.prototype.age=100
console.info(_.allKeys(new Haha())) //["name", "age"]

/*values_.values(object) 
返回object对象全部的属性值。
*/
console.info(_.values({one: 1, two: 2, three: 3}))//[1, 2, 3]


/*mapObject_.mapObject(object, iteratee, [context]) 
它相似于map，可是这用于对象。转换每一个属性的值。*/

console.info(_.mapObject({one: 1, two: 2, three: 3},function(val,key){
return val+10
}))////Object {one: 11, two: 12, three: 13} 返回对象

console.info(_.map({one: 1, two: 2, three: 3},function(val,key,list){
return val+10
})) //[11, 12, 13] 返回集合


/*pairs_.pairs(object) 
把一个对象转变为一个[key, value]形式的数组。*/
console.info(_.pairs({one: 1, two: 2, three: 3})) //[Array[2], Array[2], Array[2]]

/*invert_.invert(object) 
返回一个object副本，使其键（keys）和值（values）对换。对于这个操做，必须确保object里全部的值都是惟一的且能够序列号成字符串.*/
console.info(_.invert({one: 1, two: 2, three: 3})) //Object {1: "one", 2: "two", 3: "three"}

/*functions_.functions(object) Alias: methods 
返回一个对象里全部的方法名, 并且是已经排序的 — 也就是说, 对象里每一个方法(属性值是一个函数)的名称.*/
console.info(_.functions($))
//["Animation", "Callbacks", "Deferred", "Event", "Tween", "_data", "_evalUrl", "_queueHooks", "_removeData", "acceptData", "access", "ajax", 

"ajaxPrefilter", "ajaxSetup", "ajaxTransport", "attr", "buildFragment", "camelCase", "cleanData", "clone", "contains", "css", "data", "dequeue", "dir", 

"each", "error", "extend", "filter", "find", "fx", "get", "getJSON", "getScript", "globalEval", "grep", "hasData", "holdReady", "inArray", "isArray", 

"isEmptyObject", "isFunction", "isNumeric", "isPlainObject", "isWindow", "isXMLDoc", "makeArray", "map", "merge", "noConflict", "nodeName", "noop", 

"now", "param", "parseHTML", "parseJSON", "parseXML", "post", "prop", "proxy", "queue", "ready", "removeAttr", "removeData", "removeEvent", "sibling", 

"speed", "style", "swap", "text", "trim", "type", "unique", "when"]

/*findKey*/
console.info(_.findKey({one: 1, two: 2, three: 3},function(val,key,list){
return val==3
})) //three

/*extend_.extend(destination, *sources) 
复制source对象中的全部属性覆盖到destination对象上，而且返回 destination 对象. 复制是按顺序的, 因此后面的对象属性会把前面的对象属性覆盖掉(若是有重复).*/
console.info(_.extend({one: 1, two: 2, three: 3},{four: 4, five: 5}))//Object {one: 1, two: 2, three: 3, four: 4, five: 5}
console.info(_.extend({one: 1, two: 2, three: 3},{one: 1, two: 2, three: 4}))//Object {one: 1, two: 2, three: 4}


/*pick_.pick(object, *keys) 
返回一个object副本，只过滤出keys(有效的键组成的数组)参数指定的属性值。或者接受一个判断函数，指定挑选哪一个key。*/
console.info(_.pick({one: 1, two: 2, three: 3},'two'))//Object {two: 2}
console.info(_.pick({one: 1, two: 2, three: 3},function(val,key,list){
return val==2
})) //Object {two: 2}


/*omit_.omit(object, *keys) 跟pick相反
返回一个object副本，只过滤出除去keys(有效的键组成的数组)参数指定的属性值。 或者接受一个判断函数，指定忽略哪一个key。*/

/*clone_.clone(object) 
建立 一个浅复制（浅拷贝）的克隆object。任何嵌套的对象或数组都经过引用拷贝，不会复制。*/
var cObject=_.clone({one: 1, two: 2, three: 3})
console.info(cObject) //Object {one: 1, two: 2, three: 3}


/*has_.has(object, key) 
对象是否包含给定的键吗？等同于object.hasOwnProperty(key)，可是使用hasOwnProperty 函数的一个安全引用，以防意外覆盖。*/
console.info(_.has({one: 1, two: 2, three: 3},'one')) //true
console.info({one: 1, two: 2, three: 3}.hasOwnProperty('two')) //true

/*
isEqual_.isEqual(object, other) 
执行两个对象之间的优化深度比较，肯定他们是否应被视为相等。*/
var a = {one: 1, two: 2, three: 3}
var b  = {one: 1, two: 2, three: 3}

console.info(a==b)//false
console.info(_.isEqual(a,b))//trueual(a,b))//true

/*isEmpty_.isEmpty(object) 
若是object 不包含任何值(没有可枚举的属性)，返回true。 对于字符串和类数组（array-like）对象，若是length属性为0，那么_.isEmpty检查返回true。*/
console.info(_.isEmpty([1, 2, 3])) //true
console.info(_.isEmpty([]))//true


/*isElement_.isElement(object) 
若是object是一个DOM元素，返回true。*/
console.info(_.isElement($('body'))) //false
console.info(_.isElement($('body').get(0))) //true


/*isArray_.isArray(object) 
若是object是一个数组，返回true。*/
console.info(_.isArray([1,2,3]))//true

/*isObject_.isObject(value) 
若是object是一个对象，返回true。须要注意的是JavaScript数组和函数是对象，字符串和数字不是。*/
console.info(_.isArray({"aa":"bb"}))//true

/*isArguments_.isArguments(object) 
若是object是一个参数对象，返回true。*/
function haha(a,b,c){
console.info(_.isArguments(arguments)) //true
} 
haha(1,2,3)

/*isFunction  若是object是一个函数（Function），返回true*/
console.info(_.isFunction(_))

/*isString_.isString(object) 
若是object是一个字符串，返回true。*/
console.info(_.isString("leyi"))


/*isNumber_.isNumber(object) 
若是object是一个数值，返回true (包括 NaN)。*/
console.info(_.isNumber(1))

/*isFinite_.isFinite(object) 
若是object是一个有限的数字，返回true。*/
console.info(_.isFinite(101))

/*isBoolean_.isBoolean(object) 
若是object是一个布尔值，返回true，不然返回false。*/
console.info(_.isBoolean(true))

/*isDate*/
console.info(_.isDate(new Date))


/*isRegExp 若是object是一个正则表达式，返回true。*/
console.info(_.isRegExp(/"leyi"/))

/*isError*/
try{
	throw new Error('^_^')
}catch(error){
	console.info(_.isError(error))
}


/*isNaN_.isNaN(object) 
若是object是 NaN，返回true。 
注意： 这和原生的isNaN 函数不同，若是变量是undefined，原生的isNaN 函数也会返回 true 。*/
console.info(_.isNaN(NaN))

/*isNull_.isNull(object) 
若是object的值是 null，返回true。*/ 
console.info(_.isNull(null))


/*isUndefined_.isUndefined(value) 
若是value是undefined，返回true。*/
console.info(_.isUndefined(_.leyi))

//实用功能(Utility Functions)


/*mixin_.mixin(object) 
容许用您本身的实用程序函数扩展Underscore。传递一个 {name: function}定义的哈希添加到Underscore对象，以及面向对象封装。*/
_.mixin({
	"leyi":function(){
		console.info(12)
	}
})
_.leyi()//12


/*random_.random(min, max) 
返回一个min 和 max之间的随机整数。若是你只传递一个参数，那么将返回0和这个参数之间的整数。*/
console.info(_.random(1,10))


/*sortBy_.sortBy(list, iteratee, [context]) 
返回一个排序后的list拷贝副本。若是传递iteratee参数，iteratee将做为list中每一个值的排序依据。迭代器也能够是字符串的属性的名称进行排序的(好比 length)。*/
console.info(_.sortBy([1,2,3,4,5],function(val){
	return val
})) //[1, 2, 3, 4, 5]

console.info(_.sortBy([{name: 'moe', age: 70}, {name: 'larry', age: 50}, {name: 'curly', age: 60}],function(val,index,list){
	return val.age
}))//[{name: 'larry', age: 50}, {name: 'curly', age: 60},{name: 'moe', age: 70}]


/*escape_.escape(string) 
转义HTML字符串，替换&, <, >, ", ', 和 /字符。*/
console.info(_.escape(">")) //>
console.info(_.unescape(">")) //>

/*now_.now() 
一个优化的方式来得到一个当前时间的整数时间戳。可用于实现定时/动画功能。*/
console.info(_.now())

//获取封装对象的最终值.
console.info(_([1,2]).value()) //[1, 2]

/*chain_.chain(obj) 
返回一个封装的underscore对象. */
console.info(_.isEqual(_({"aa":"bb"}),_.chain({"aa":"bb"})))


/*uniqueId_.uniqueId([prefix]) 
为须要的客户端模型或DOM元素生成一个全局惟一的id。若是prefix参数存在， id 将附加给它。*/
console.info(_.uniqueId("prefix_"))//prefix_1

//主要方便在JS中拼HTML
var aa=_.template("<%= name %>")
console.info(aa({"name":"leyi"})) //leyi
var bb=_.template("<%- name %>")
console.info(bb({"name":"<b>leyi</b>"})) //<b>leyi</b>
var cc=_.template("<% alert(name) %>")
cc({"name":"leyi"})  //alert(leyi)

</script>

<script type="text/template" id="_template">
<% _.each(datas, function (item,idnex,list) { %>
  <ul class="container">
    <%= item.id %>
  </ul>
<% }); %>
</script>
<script>
var datas=[{"id":1},{"id":2},{"id":3}]
$('#leyi').html(_.template($("#_template").html(),datas))

</script>


/*result_.result(object, property, [defaultValue]) 
若是指定的property 的值是一个函数，那么将在object上下文内调用它;不然，返回它。若是提供默认值，而且属性不存在，那么默认值将被返回。若是设置defaultValue

是一个函数，它的结果将被返回。*/
var obj={"name":"leyi","fn":function(){
	alert('leyi')
}}
console.info(_.result(obj,"name")) //leyi
_.result(obj,"fn") //alert("leyi")

/*where_.where(list, properties) 
遍历list中的每个值，返回一个数组，这个数组包含properties所列出的属性的全部的 键 - 值对。*/
var obj2=[{"name":"leyi","age":"100"},{"name":"leyi","age":101,"height":175},{"name":"leyi","age":101,"height":176}]
console.info(_.where(obj2,{"age":101})) //[{"name":"leyi","age":101,"height":175},{"name":"leyi","age":101,"height":176}]

/*findWhere_.findWhere(list, properties) 
遍历整个list，返回匹配 properties参数所列出的全部 键 - 值 对的第一个值。*/
var obj2=[{"name":"leyi","age":"100"},{"name":"leyi","age":101,"height":175},{"name":"leyi","age":101,"height":176}]
console.info(_.findWhere(obj2,{"age":101}))//{"name":"leyi","age":100}

var mp=_.map(obj2,function(val,index,list){
return _.pick(val,function(val,key){
return key=="name"})
})
console.info(mp)