underscore中_.each与_.map的区别

版本一：

var number = ['ITEM000001','ITEM000003-2']
var obj_number = {}
var a = _.each(number,function(barcode){
        //没有‘-’的自身做key后正常统计数量,有‘-’的把‘-’后的作为数量,'-'前的作为key
	barcode = barcode.split('-')
	obj_number[barcode[0]] = ( obj_number[barcode[0]] || 0 ) + ( parseFloat(barcode[1]) || 1 )
})
console.log(a)
console.log(JSON.stringify(obj_number))

a = ITEM000001,ITEM000003-2

obj_number = {"ITEM000001":1,"ITEM000003":2}

each遍历原数组每一个元素后，按顺序依次输出每一个函数执行过后的元素，而此处我将所有结果都放在一个对象中所以直接输出对象

var obj_number = {}
var b = _.map(number,function(barcode){
	barcode = barcode.split('-')
	obj_number[barcode[0]] = ( obj_number[barcode[0]] || 0 ) + ( parseFloat(barcode[1]) || 1 )
})
console.log(b)
console.log(JSON.stringify(obj_number))

b = ,

obj_number = {"ITEM000001":1,"ITEM000003":2}

map将数组中的每一个元素经函数执行后，放入新数组，可如果不设置返回值，会为空(具体如下)

var c = _.map(number,function(barcode){
        '结果'+barcode
        })
console.log(c)

c = ,

map创建了一个新数组,函数执行完每一个值就给新数组赋值一次，但没有返回值，所以是空的

var d = _.map(number,function(barcode){
        return '结果'+barcode
        })
console.log(d)

d = 结果ITEM000001,结果ITEM000003-2

设置返回值

var e =  _.each(number,function(barcode){
        '结果'+barcode
        })
var f = _.each(number,function(barcode){
        return g = '结果'+barcode
        })
console.log(e)
console.log(f)
console.log(g)

e = ITEM000001,ITEM000003-2

f = ITEM000001,ITEM000003-2

g = 结果ITEM000003-2

each对每一个元素遍历，如果用户不自己建立一个数组保存，函数执行结果会全部消失

g只输出一个结果，因为each依次输出每一个元素，以这种形式定义数组输出的话，会将每一个结果依次赋值给g，就会覆盖,目前本人使用push推入新数组（对象）

版本二：

map会先创建一个与输入数组等长的数组，再将return的内容赋进去，因此当需要的结果不是数组形式时使用each更好，而哪怕是数组形式的结果，需要的长度不一致时，比如只有输入数组中的几个作为结果时会产生underfind

var a = _.map([1,2,3,4,5,6],function(num){
	if( num > 3 ){
		return num
	}
})
=>[undefined, undefined, undefined, 4, 5, 6]

搭配compact去除所有false值之后，才能得到需要的结果

compact_.compact(array) 
在javascript中, false, null, 0, "", undefined 和 NaN 都是false值.

_.compact([undefined, undefined, undefined, 4, 5, 6]);
=>[4,5,6]

一般用不到map的一一对应映射的特性时使用each就好

http://www.bootcss.com/

包含bootcss相关优质项目

最后附上each和map的源码：

// The cornerstone, an `each` implementation, aka `forEach`.

// Handles raw objects in addition to array-likes. Treats all

// sparse array-likes as if they were dense.

_.each = _.forEach = function(obj, iteratee, context) {

if (obj == null) return obj;

iteratee = createCallback(iteratee, context);

var i, length = obj.length;

if (length === +length) {

for (i = 0; i < length; i++) {

iteratee(obj[i], i, obj);

}

} else {

var keys = _.keys(obj);

for (i = 0, length = keys.length; i < length; i++) {

iteratee(obj[keys[i]], keys[i], obj);

}

return obj;

};

// 返回将iteratee（迭代）应用于每个元素的结果。

_.map = _.collect = function(obj, iteratee, context) {

if (obj == null) return [];

iteratee = _.iteratee(iteratee, context);

var keys = obj.length !== +obj.length && _.keys(obj),

length = (keys || obj).length,

results = Array(length),

currentKey;

for (var index = 0; index < length; index++) {

currentKey = keys ? keys[index] : index;

results[index] = iteratee(obj[currentKey], currentKey, obj);

}

return results;

};

underscore中_.each与_.map的区别

猜你喜欢