Underscore.js _.map फ़ंक्शन: मान

Question

छोड़ें मैं ऑब्जेक्ट्स की सरणी पर underscore.js _.map फ़ंक्शन का उपयोग करने की कोशिश कर रहा हूं, प्रत्येक ऑब्जेक्ट की संपत्ति के साथ सरणी प्राप्त करने के लिए। यही कारण है कि सामान्य परिदृश्य है, तो:

var finalArray = _.map(myArray, function(obj) { 
    return obj.myProperty; 
}); 

लेकिन कुछ मामलों में मुझे लगता है कि कुछ भी नहीं सरणी में जोड़ा जा की जरूरत है। यह हो सकता है कुछ की तरह: इसी का परिणाम

var finalArray = _.map(myArray, function(obj) { 
    if (!obj.ignore) { 
     return obj.myProperty; 
    } 
}); 

कि एक undefined मान सरणी है, जो कुछ भी धक्का बिल्कुल नहीं के समान नहीं है में धकेल दिया जाता है।

क्या नक्शा फ़ंक्शन के लिए मूल्य को धक्का न देने का कोई तरीका है, या क्या मुझे अवांछित undefined के निकालने के लिए मेरे finalArray को पोस्ट-प्रोसेस करने की आवश्यकता है?

Answer 1

आप() _.map से पहले _.filter() का उपयोग करना चाहिए

var filteredArray = _.filter(myArray,function(obj) { 
    return !obj.ignore; 
}); 

var finalArray = _.map(filteredArray, function(obj) { 
    return obj.myProperty; 
}); 

Answer 2

तो इसका मतलब यह आप फ़िल्टर करना चाहते है, तो अपने सरणी मैप करें।

underscore तरह से ऐसा करने के लिए, तो आप इस पाइप लाइन में अपने सरणी पारित करने के लिए की आवश्यकता होगी:

myArray ->फिल्टर ->नक्शा -> finalArray

var isIncluded = function(obj){ 
    return !obj.ignore 
} 
var takeProperty = function(obj){ 
    return obj.myProperty 
} 
var finalArray = _.map(_.filter(myArray, isIncluded), takeProperty ); 

Answer 3

.map सरणी के लिए एक नया मान मैप करेगा, आप सरणी फ़िल्टर करने के लिए .filter का उपयोग कर सकते हैं। FYI करें आप .pluck उपयोग कर सकते हैं एक वस्तु से एक संपत्ति मैप करने के लिए:

_.chain(myArray).where({ignore: false}).pluck('myProperty').value(); 

या::

_.chain(myArray).filter(function(obj) { return !obj.ignore; }).pluck('myProperty').value(); 

तुम भी .where इस तरह उपयोग कर सकते हैं

_.pluck(_.where(myArray, {ignore: false}), 'myProperty'); 

Answer 4

आप को कम इस्तेमाल कर सकते हैं:

myArray.reduce(function (acc, obj) { 
    if (!obj.ignore) { 
     acc.push(obj.myProperty); 
    } 
    return acc; 
}, []); 

या lodash साथ:

_.reduce(myArray, function (acc, obj) { 
    if (!obj.ignore) { 
    acc.push(obj.myProperty); 
    } 
    return acc; 
}, []); 

Answer 5

अकेले अंडरस्कोर तरीकों का उपयोग कर किया जा सकता है, points-free style:

var finalArray = _.chain(myArray) 
    .reject('ignore') 
    .pluck('myProperty') 
    .value(); 

Answer 6

यहाँ एक और तरीका है। यह अंडरस्कोर में रचना समारोह का उपयोग करता है। क्यों लिखें? रचना गणित में श्रेणी सिद्धांत द्वारा समर्थित है। इस तरह भी बिंदु मुक्त है।

var pluckMyProp = function(array) { 
    return _.pluck(array, 'myProperty') 
} 

var reject = function(array) { 
    return _.reject(array, function(element) { 
     return element['ignore'] === true 
    }) 
} 

var finalArray = _.compose(pluckMyProp, reject) 
var data = [{myProperty: 1, ignore: false}, {ignore: true}, {myProperty: 2}] 


finalArray(data) //=> [1,2] 

Answer 7

lodash के compact() का उपयोग करें। यह सभी झूठी मानों को हटाकर एक सरणी बनाता है।इस प्रकार, false, null, 0, "", undefined, और NaN हटा दिए गए हैं।

https://lodash.com/docs#compact

मैं उपयोग कर रहा हूँ यह-यह बहुत साफ है।