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)