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)