जवाबों:
यदि आप सभी गलत मूल्यों को दूर करना चाहते हैं तो सबसे कॉम्पैक्ट तरीका है:
के लिए Lodash 4.x और बाद में :
_.pickBy({ a: null, b: 1, c: undefined }, _.identity);
>> Object {b: 1}
के लिए विरासत Lodash 3.x:
_.pick(obj, _.identity);
_.pick({ a: null, b: 1, c: undefined }, _.identity);
>> Object {b: 1}
falsevalu
आप बस और रचनाओं के _.omit()साथ श्रृंखला बना सकते हैं , और आलसी मूल्यांकन के साथ परिणाम प्राप्त कर सकते हैं।_.isUndefined_.isNull
var result = _(my_object).omit(_.isUndefined).omit(_.isNull).value();14 मार्च 2016 को अपडेट करें :
जैसा कि टिप्पणी अनुभाग में dylants द्वारा उल्लेख किया गया है , आपको _.omitBy()फ़ंक्शन का उपयोग करना चाहिए क्योंकि यह एक संपत्ति के बजाय एक विधेय का उपयोग करता है। आपको इसे लॉश संस्करण 4.0.0और इसके बाद के संस्करण के लिए उपयोग करना चाहिए ।
var result = _(my_object).omitBy(_.isUndefined).omitBy(_.isNull).value();अपडेट 1 जून 2016 :
मैक्स ट्रूक्स द्वारा टिप्पणी के रूप में , लॉश ने पहले से ही एक विकल्प प्रदान किया है _.isNil, जो दोनों के लिए जांच करता है nullऔर undefined:
var result = _.omitBy(my_object, _.isNil);omitByइसके बजाय फ़ंक्शन का उपयोग करना चाहिए omit। तो_(my_object).omitBy(_.isUndefined).omitBy(_.isNull).value();
_.isNilचेनिंग के बजाय उपयोग कर सकते हैं _.isUndefinedऔर _.isNull। यह इसे और भी छोटा बनाता है:var result = _.omitBy(my_object, _.isNil);
omitByतुलना में कम प्रदर्शन है pickBy, इसलिए उत्तरार्द्ध को प्राथमिकता दी जानी चाहिए, और पुनरावृति समारोह में स्थिति उलट गई। ऊपर दिए गए स्वीकृत उत्तर को वह अधिकार मिल गया।
nullऔर undefinedमूल्य है। identityविधेय को भी निकाल देंगे falseमूल्यों, इसलिए यदि आप बस सवाल का मेरा उत्तर के साथ एक समस्या के इरादे तो मैं नहीं दिख रहा है पर यह आधारित है। इसके अतिरिक्त, यदि हम "प्रदर्शन" के बारे में सोच रहे हैं, तो omitByबस pickByएक नकारात्मक identityभविष्यवाणी के साथ, डिफ़ॉल्ट रूप से कॉल करता है । इसलिए, प्रदर्शन के मामले में, यह महत्वपूर्ण होने के लिए बहुत छोटा है।
यदि आप लॉश का उपयोग कर रहे हैं, तो आप _.compact(array)एक सरणी से सभी मिथ्या मूल्यों को हटाने के लिए उपयोग कर सकते हैं ।
_.compact([0, 1, false, 2, '', 3]);
// => [1, 2, 3]
_.pickBy(object, _.isNumber)उस स्थिति में उपयोग कर सकते हैं ।
सही जवाब है:
_.omitBy({ a: null, b: 1, c: undefined, d: false }, _.isNil)यह परिणाम है:
{b: 1, d: false}अन्य लोगों द्वारा यहां दिया गया विकल्प:
_.pickBy({ a: null, b: 1, c: undefined, d: false }, _.identity);उन falseमूल्यों को भी हटा देगा जो यहां वांछित नहीं हैं।
{"a":1,"b":{"a":1,"b":null,"c":undefined}}, वस्तु। बी संपत्ति b, 'ग' को हटाया नहीं जाएगा
बस:
_.omit(my_object, _.isUndefined)उपरोक्त nullमानों को ध्यान में नहीं रखा गया है, क्योंकि वे मूल उदाहरण से गायब हैं और केवल विषय में उल्लेख किया गया है, लेकिन मैं इसे छोड़ देता हूं क्योंकि यह सुरुचिपूर्ण है और इसके उपयोग हो सकते हैं।
यहाँ पूरा उदाहरण है, कम संक्षिप्त, लेकिन अधिक पूर्ण।
var obj = { a: undefined, b: 2, c: 4, d: undefined, e: null, f: false, g: '', h: 0 };
console.log(_.omit(obj, function(v) { return _.isUndefined(v) || _.isNull(v); }));
_.omitBy।
अन्य उत्तरों को पूरा करने के लिए, केवल अपरिभाषित और अशक्त (और इस तरह के गुण नहीं false) को अनदेखा करने के लिए 4 लॉश में _.pickBy: आप एक विधेय का उपयोग कर सकते हैं :
_.pickBy(obj, v !== null && v !== undefined)
नीचे उदाहरण:
const obj = { a: undefined, b: 123, c: true, d: false, e: null};
const filteredObject = _.pickBy(obj, v => v !== null && v !== undefined);
console.log = (obj) => document.write(JSON.stringify(filteredObject, null, 2));
console.log(filteredObject);<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.10/lodash.js"></script>0, '', falseमान। इसके अलावा आप कॉलबैक को छोटा कर सकते हैं v => v != null।
गहरी नेस्टेड ऑब्जेक्ट के लिए आप लॉश> 4 के लिए मेरे स्निपेट का उपयोग कर सकते हैं
const removeObjectsWithNull = (obj) => {
return _(obj)
.pickBy(_.isObject) // get only objects
.mapValues(removeObjectsWithNull) // call only for values as objects
.assign(_.omitBy(obj, _.isObject)) // save back result that is not object
.omitBy(_.isNil) // remove null and undefined from object
.value(); // get value
};
मैंने undefinedएक वस्तु (गहराई से) को हटाने के साथ एक समान समस्या का सामना किया , और पाया कि यदि आप अपनी पुरानी पुरानी वस्तु को परिवर्तित करने और JSON का उपयोग करने के लिए ठीक हैं, तो एक त्वरित और गंदा सहायक फ़ंक्शन इस तरह दिखाई देगा:
function stripUndefined(obj) {
return JSON.parse(JSON.stringify(obj));
}
"... यदि अपरिभाषित, रूपांतरण के दौरान एक फ़ंक्शन, या प्रतीक का सामना किया जाता है, तो इसे या तो छोड़ दिया जाता है (जब यह एक वस्तु में पाया जाता है) या नल के लिए सेंसर किया जाता है (जब यह एक सरणी में पाया जाता है)।"
शुद्ध जावास्क्रिप्ट के साथ: (हालांकि Object.entries ES7 है, Object.assign ES6 है; लेकिन समतुल्य ES5 Object.keys का उपयोग केवल करने योग्य होना चाहिए); v != nullअशक्त और अनिर्धारित दोनों के लिए चेक की सूचना भी ;
> var d = { a:undefined, b:2, c:0, d:undefined, e: null, f: 0.3, s: "", t: false };
undefined
> Object.entries(d)
.filter(([ k, v ]) => (v != null))
.reduce((acc, [k, v]) => Object.assign(acc, {[k]: v}), {})
{ b: 2, c: 0, f: 0.3, s: '', t: false }
संपादित करें: यह नीचे केवल ES5 Object.keys के साथ संस्करण है: लेकिन आम तौर पर नोड v8 में ES7 के साथ बहुत सुखद और;
> Object.keys(d)
.filter(function(k) { return d[k] != null; })
.reduce(function(acc, k) { acc[k] = d[k]; return acc; }, {});
{ b: 2, c: 0, f: 0.3, s: '', t: false }
अक्टूबर 2017 में अपडेट : नोड v8 के साथ (v8.3 या इसके बाद से) अब इसमें निर्माण फैलाने वाली वस्तु है:
> var d = { a:undefined, b:2, c:0, d:undefined,
e: null, f: -0.0, s: "", t: false, inf: +Infinity, nan: NaN };
undefined
> Object.entries(d)
.filter(([ k, v ]) => (v != null))
.reduce((acc, [k, v]) => ({...acc, [k]: v}), {})
{ b: 2, c: 0, f: -0, s: '', t: false, inf: Infinity, nan: NaN }
या केवल एक कमी के भीतर:
> Object.entries(d)
.reduce((acc, [k, v]) => (v==null ? acc : {...acc, [k]: v}), {})
{ b: 2, c: 0, f: -0, s: '', t: false, inf: Infinity, nan: NaN }
अद्यतन: किसी को पुनरावर्ती चाहिए? यह कठिन नहीं है, बस isObject के एक अतिरिक्त चेक की जरूरत है, और खुद को पुन: कॉल करें:
> function isObject(o) {
return Object.prototype.toString.call(o) === "[object Object]"; }
undefined
> function dropNullUndefined(d) {
return Object.entries(d)
.reduce((acc, [k, v]) => (
v == null ? acc :
{...acc, [k]: (isObject(v) ? dropNullUndefined(v) : v) }
), {});
}
> dropNullUndefined({a: 3, b:null})
{ a: 3 }
> dropNullUndefined({a: 3, b:null, c: { d: 0, e: undefined }})
{ a: 3, c: { d: 0 } }
मेरा निष्कर्ष: यदि शुद्ध जावास्क्रिप्ट कर सकते हैं, मैं किसी भी तीसरे पक्ष के पुस्तकालय निर्भरता से बचना होगा:
चूँकि आप में से कुछ लोग विशेष रूप से केवल हटाने के लिए प्रश्न पर आ undefinedसकते हैं, आप इसका उपयोग कर सकते हैं:
लोदश विधियों का संयोजन
_.omitBy(object, _.isUndefined)rundefपैकेज है, जो केवल निकालता है undefinedगुण
rundef(object)यदि आपको पुनरावर्तीundefined गुणों को हटाने की आवश्यकता है , तो rundefपैकेज में एक recursiveविकल्प भी है ।
rundef(object, false, true);देखें प्रलेखन अधिक जानकारी के लिए।
यहाँ लॉश दृष्टिकोण मैं ले जाएगा:
_(my_object)
.pairs()
.reject(function(item) {
return _.isUndefined(item[1]) ||
_.isNull(item[1]);
})
.zipObject()
.value()जोड़े () समारोह कुंजी / मान सरणियों की एक सरणी में इनपुट वस्तु बदल जाता है। आप इस इतना है कि यह आसान है करने के लिए उपयोग करना अस्वीकार () को खत्म करने undefinedऔर nullमूल्यों। के बाद, आप उन जोड़ियों के साथ रह गए हैं जिन्हें अस्वीकार नहीं किया गया था, और ये zipObject () के लिए इनपुट हैं , जो आपके लिए आपकी ऑब्जेक्ट को फिर से संगठित करता है।
ध्यान में रखते हुए कि undefined == nullहम इस प्रकार लिख सकते हैं:
let collection = {
a: undefined,
b: 2,
c: 4,
d: null,
}
console.log(_.omit(collection, it => it == null))
// -> { b: 2, c: 4 }सबसे छोटा तरीका (लॉश v4):
_.pickBy(my_object)लॉश (या अंडरस्कोर) के साथ आप कर सकते हैं
var my_object = { a:undefined, b:2, c:4, d:undefined, e:null };
var passedKeys = _.reject(Object.keys(my_object), function(key){ return _.isUndefined(my_object[key]) || _.isNull(my_object[key]) })
newObject = {};
_.each(passedKeys, function(key){
newObject[key] = my_object[key];
});अन्यथा, वेनिला जावास्क्रिप्ट के साथ, आप कर सकते हैं
var my_object = { a:undefined, b:2, c:4, d:undefined };
var new_object = {};
Object.keys(my_object).forEach(function(key){
if (typeof my_object[key] != 'undefined' && my_object[key]!=null){
new_object[key] = my_object[key];
}
});फाल्सी टेस्ट का उपयोग न करने के लिए, क्योंकि न केवल "अपरिभाषित" या "अशक्त" को अस्वीकार कर दिया जाएगा , यह भी अन्य गलत मूल्य है जैसे "झूठे", "0", खाली स्ट्रिंग, {}। इस प्रकार, बस इसे सरल और समझने योग्य बनाने के लिए, मैंने स्पष्ट तुलना का उपयोग करने का विकल्प चुना जैसा कि ऊपर कोडित है।
सभी गलत मूल्यों को छोड़ना है लेकिन बूलियन प्राइमेटिव्स को बनाए रखें जिससे यह समाधान मदद करता है।
_.omitBy(fields, v => (_.isBoolean(v)||_.isFinite(v)) ? false : _.isEmpty(v));let fields = {
str: 'CAD',
numberStr: '123',
number : 123,
boolStrT: 'true',
boolStrF: 'false',
boolFalse : false,
boolTrue : true,
undef: undefined,
nul: null,
emptyStr: '',
array: [1,2,3],
emptyArr: []
};
let nobj = _.omitBy(fields, v => (_.isBoolean(v)||_.isFinite(v)) ? false : _.isEmpty(v));
console.log(nobj);<script src="https://cdn.jsdelivr.net/npm/lodash@4.17.11/lodash.min.js"></script>var my_object = { a:undefined, b:2, c:4, d:undefined };
var newObject = _.reject(my_collection, function(val){ return _.isUndefined(val) })
//--> newCollection = { b: 2, c: 4 }मैं अंडरस्कोर का उपयोग करूंगा और खाली तारों का भी ध्यान रखूंगा:
var my_object = { a:undefined, b:2, c:4, d:undefined, k: null, p: false, s: '', z: 0 };
var result =_.omit(my_object, function(value) {
return _.isUndefined(value) || _.isNull(value) || value === '';
});
console.log(result); //Object {b: 2, c: 4, p: false, z: 0}jsbin ।
गहरी नेस्टेड ऑब्जेक्ट और सरणियों के लिए। और स्ट्रिंग और NaN से खाली मूल्यों को बाहर करें
function isBlank(value) {
return _.isEmpty(value) && !_.isNumber(value) || _.isNaN(value);
}
var removeObjectsWithNull = (obj) => {
return _(obj).pickBy(_.isObject)
.mapValues(removeObjectsWithNull)
.assign(_.omitBy(obj, _.isObject))
.assign(_.omitBy(obj, _.isArray))
.omitBy(_.isNil).omitBy(isBlank)
.value();
}
var obj = {
teste: undefined,
nullV: null,
x: 10,
name: 'Maria Sophia Moura',
a: null,
b: '',
c: {
a: [{
n: 'Gleidson',
i: 248
}, {
t: 'Marta'
}],
g: 'Teste',
eager: {
p: 'Palavra'
}
}
}
removeObjectsWithNull(obj)परिणाम:
{
"c": {
"a": [
{
"n": "Gleidson",
"i": 248
},
{
"t": "Marta"
}
],
"g": "Teste",
"eager": {
"p": "Palavra"
}
},
"x": 10,
"name": "Maria Sophia Moura"
}मुझे _.pickBy का उपयोग करना पसंद है, क्योंकि आप जो हटा रहे हैं उस पर आपका पूरा नियंत्रण है:
var person = {"name":"bill","age":21,"sex":undefined,"height":null};
var cleanPerson = _.pickBy(person, function(value, key) {
return !(value === undefined || value === null);
});स्रोत: https://www.codegrepper.com/?search_term=lodash+remove+undefined+values+from+object
आप में से उन लोगों के लिए जो वस्तुओं की एक सरणी से निकालना चाहते हैं और लॉश का उपयोग करके आप ऐसा कुछ कर सकते हैं:
const objects = [{ a: 'string', b: false, c: 'string', d: undefined }]
const result = objects.map(({ a, b, c, d }) => _.pickBy({ a,b,c,d }, _.identity))
// [{ a: 'string', c: 'string' }]
नोट: यदि आप नहीं चाहते हैं तो आपको विनाश नहीं करना है।
_.pickBy(obj, _.identity);