জাভাস্ক্রিপ্টের কোনও অবজেক্ট থেকে ফাঁকা বৈশিষ্ট্যগুলি সরান

Question

আমি সব বৈশিষ্ট্যাবলী যা কীভাবে অপসারণ না undefinedবা nullএকটি JavaScript বস্তু?

(প্রশ্ন অনুরূপ এই এক অ্যারেগুলির জন্য)

Comments

অত্যন্ত মানুষ ES6 / ES7 সংস্করণ টপ র্যাঙ্ক এবং পদক্ষেপ এখানে উপেক্ষা সুপারিশ stackoverflow.com/a/38340730/124486

— ইভান ক্যারল

পরিবর্তনকারী অবজেক্ট ছাড়াই ES6 এর একটি লাইনার এখানে রয়েছে: stackoverflow.com/a/57625661/1602301

— মুরগি

Answer 1

আপনি বস্তুর মাধ্যমে লুপ করতে পারেন:

var test = {
    test1 : null,
    test2 : 'somestring',
    test3 : 3,
}

function clean(obj) {
  for (var propName in obj) { 
    if (obj[propName] === null || obj[propName] === undefined) {
      delete obj[propName];
    }
  }
}

clean(test);

যদি আপনি এই সম্পত্তি অপসারণের বিষয়ে অবজেক্টের প্রোপাইপ শৃঙ্খলা না চালা সম্পর্কে উদ্বিগ্ন হন তবে আপনি এটি করতে পারেন:

function clean(obj) {
  var propNames = Object.getOwnPropertyNames(obj);
  for (var i = 0; i < propNames.length; i++) {
    var propName = propNames[i];
    if (obj[propName] === null || obj[propName] === undefined) {
      delete obj[propName];
    }
  }
}

নাল বনাম কিছু নোট বনাম সংজ্ঞায়িত:

test.test1 === null; // true
test.test1 == null; // true

test.notaprop === null; // false
test.notaprop == null; // true

test.notaprop === undefined; // true
test.notaprop == undefined; // true

Comments

একটি দ্রুত সংশোধন যুক্ত করা হয়েছে। এই স্নিপেটটি যদি কোনও ফাংশনে ব্যবহৃত হত তবে অঘোষিত "আই" পরিবর্তনশীল বাহ্যিক স্কোপে ফাঁস হবে।

— এরিক এনগুইন

আপনি (পরীক্ষা [i] === নাল || পরীক্ষা [i] ===

— অপরিজ্ঞাত

হাই, @EricNguyen, সি এবং অন্যান্য অনেকগুলি ভাষায় অসদৃশ, জাভাস্ক্রিপ্ট নেই না ভেরিয়েবলের জন্য ব্লক সুযোগ (শুধুমাত্র ফাংশন সুযোগ) থাকতে, এইভাবে পরিবর্তনশীল আমি সবসময় পর সুযোগ মধ্যে ফুটা করা হবে জন্য ব্লক।

— জেরার্ডো লিমা

@ জেরার্ডোলিমা, হ্যাঁ আমি অনুমান করেছিলাম যে এটি একটি ফাংশনে আবৃত হবে। আমি যা বোঝাতে চাইছিলাম (ধরে নিলাম এটি সমস্ত একটি ফাংশন দিয়ে আবৃত) এটি হ'ল আপনার ভেরার ঘোষণার দরকার হয় অথবা আমি এমনকি ফাংশনের সুযোগের বাইরেও ফাঁস হয়ে যাব।

— এরিক

এটি আদিম বস্তুর প্রোটোটাইপটিও লুপ করবে - যা বেশিরভাগ ক্ষেত্রেই পছন্দসই নয়। stackoverflow.com/a/2869372/1612318

— Rotareti

Answer 2

কিছু ES6 / ES2015 ব্যবহার করে :

1) অ্যাসাইনমেন্ট ছাড়াই আইটেমগুলিকে ইনলাইন করার জন্য একটি সহজ ওয়ানলাইনার:

Object.keys(myObj).forEach((key) => (myObj[key] == null) && delete myObj[key]);

jsbin

2) এই উদাহরণটি সরানো হয়েছিল ...

3) প্রথম উদাহরণ একটি ফাংশন হিসাবে লেখা:

const removeEmpty = obj => {
  Object.keys(obj).forEach(key => obj[key] == null && delete obj[key]);
};

jsbin

4) এই ফাংশনটি নীড়যুক্ত বস্তুগুলি থেকে আইটেমগুলি মুছতে পুনরাবৃত্তি ব্যবহার করে :

const removeEmpty = obj => {
  Object.keys(obj).forEach(key => {
    if (obj[key] && typeof obj[key] === "object") removeEmpty(obj[key]); // recurse
    else if (obj[key] == null) delete obj[key]; // delete
  });
};

jsbin

4 বি) এটি 4) এর সমান, তবে উত্স অবজেক্টটি সরাসরি রূপান্তরিত করার পরিবর্তে এটি একটি নতুন অবজেক্ট ফিরিয়ে দেয়।

const removeEmpty = obj => {
  const newObj = {};

  Object.keys(obj).forEach(key => {
    if (obj[key] && typeof obj[key] === "object") {
      newObj[key] = removeEmpty(obj[key]); // recurse
    } else if (obj[key] != null) {
      newObj[key] = obj[key]; // copy value
    }
  });

  return newObj;
};

5) 4 বি-তে কার্যকরী পন্থা) @ মাইকেল জে.জয়েডেলের উত্তর ব্যবহারের ভিত্তিতে filter()এবং reduce()। এটি একটি নতুন বস্তুও ফেরত দেয়:

const removeEmpty = obj =>
  Object.keys(obj)
    .filter(k => obj[k] != null) // Remove undef. and null.
    .reduce(
      (newObj, k) =>
        typeof obj[k] === "object"
          ? { ...newObj, [k]: removeEmpty(obj[k]) } // Recurse.
          : { ...newObj, [k]: obj[k] }, // Copy value.
      {}
    );

jsbin

6) একই হিসাবে 4) তবে ES7 / 2016 এর সাথে Object.entries() ।

const removeEmpty = (obj) => 
  Object.entries(obj).forEach(([key, val]) => {
    if (val && typeof val === 'object') removeEmpty(val)
    else if (val == null) delete obj[key]
})

5 বি) আর একটি কার্যকরী সংস্করণ যা পুনরাবৃত্তি ব্যবহার করে এবং ES2019 সহ একটি নতুন অবজেক্ট ফেরত দেয়Object.fromEntries() :

const removeEmpty = obj =>
  Object.fromEntries(
    Object.entries(obj)
      .filter(([k, v]) => v != null)
      .map(([k, v]) => (typeof v === "object" ? [k, removeEmpty(v)] : [k, v]))
  );

7) 4 হিসাবে একই) তবে সরল ES5 এ :

function removeEmpty(obj) {
  Object.keys(obj).forEach(function(key) {
    if (obj[key] && typeof obj[key] === 'object') removeEmpty(obj[key])
    else if (obj[key] == null) delete obj[key]
  });
};

jsbin

Comments

@ অগাস্টিনরিডিংগার যখন আমাকে লাইন-ব্রেক এবং একটি সংক্ষেপণের মধ্যে সিদ্ধান্ত নিতে হয় আমি মাঝে মাঝে সংক্ষিপ্তকরণের জন্য যাই যদি আমি মনে করি সংক্ষিপ্ততাটি কম খারাপ হয়। 5 কোড) সম্পর্কে কারণ কঠিন নয় এবং এটি একটি ফাংশন যা খালি সরিয়ে ফেলা হচ্ছে keysএকটি থেকে object, তাই oএবং kস্পষ্ট। তবে আমার ধারণা এটি স্বাদের বিষয়।

— রোটারেটি

ES5 স্বাদযুক্ত প্রথম সংস্করণ:Object.keys(myObj).forEach(function (key) {(myObj[key] == null) && delete myObj[key]});

— নিউরোট্রান্সমিটার

একটি লাইন, ফাংশন ছাড়াই:Object.entries(myObj).reduce((acc, [key, val]) => { if (val) acc[key] = val; return acc; }, {})

— পল স্ল্যাম

যেহেতু আমরা পুঙ্খানুপুঙ্খভাবে চেষ্টা করার চেষ্টা করছি তাই এক অচল সমাধান দেখতে ভাল লাগবে। এগুলি উত্স অবজেক্টটিকে রূপান্তরিত করছে এবং প্রতারণামূলকভাবে অবজেক্টটি ফিরিয়ে দিচ্ছে যা আসলে অপ্রয়োজনীয় কারণ বস্তুটি রূপান্তরিত করা হয়েছে। নতুনরা প্রত্যাবর্তিত অবজেক্টের মানটি ক্যাপচার করবে এবং ভাববে কেন তাদের উত্স অবজেক্টটিও সংশোধিত হয়েছে।

— মাইক ম্যাকলিন

5) অ্যারে দিয়ে কাজ করে না (অবজেক্ট.কিজ উপাদানগুলির মূল হিসাবে অ্যারের অবস্থান নম্বরগুলি ফিরিয়ে দেবে)। সম্ভবত জন এই সমস্যা আছে, কিন্তু 5. পরীক্ষা যখন আমি এই পাওয়া

— Eelco

Answer 3

যদি আপনি লোডাশ বা আন্ডারস্কোর.জে ব্যবহার করেন তবে এখানে একটি সহজ সমাধান রয়েছে:

var obj = {name: 'John', age: null};

var compacted = _.pickBy(obj);

এটি কেবল লোডাস 4, প্রাক লোডাস 4 বা আন্ডারস্কোর.জেএস, ব্যবহার সহ কাজ করবে _.pick(obj, _.identity);

Comments

উজ্জ্বল! ধন্যবাদ! এফওয়াইআই, যা আমার কাছে স্পষ্ট ছিল না তা হ'ল আপনি এটিও এর মতো ব্যবহার করতে পারেন: foo ()। তারপর (_। পিকবি); // খালি ফলাফলগুলি

— ছাঁটাই

নোট করুন যে বস্তুটিতে 0 বা ফাঁকা স্ট্রিংয়ের মতো মিথ্যা মান রয়েছে তবে এর পছন্দসই ফলাফল হবে না। তারপরে _.omit(obj, _.isUndefined)আরও ভাল।

— জেএইচ এইচ

@JHH _.isUndefinedফেরত NULLs, ব্যবহার করে না _.omitBy(obj, _.isNil)উভয় বর্জন করতে undefinedএবংnull

— Lukasz Wiktor

@ লুকাস উইক্টর সঠিক, প্রশ্নটি অপরিজ্ঞাত বা বাতিল করার জন্য জিজ্ঞাসা করেছিল।

— জেএইচ এইচ

Answer 4

ES6 + এর জন্য সংক্ষিপ্ততম একটি লাইনার

সব falsy মান ফিল্টার ( "", 0, false, null, undefined)

Object.entries(obj).reduce((a,[k,v]) => (v ? (a[k]=v, a) : a), {})

ফিল্টার nullএবং undefinedমান:

Object.entries(obj).reduce((a,[k,v]) => (v == null ? a : (a[k]=v, a)), {})

কেবল ফিল্টার করুন null

Object.entries(obj).reduce((a,[k,v]) => (v === null ? a : (a[k]=v, a)), {})

কেবল ফিল্টার করুন undefined

Object.entries(obj).reduce((a,[k,v]) => (v === undefined ? a : (a[k]=v, a)), {})

পুনরাবৃত্তির সমাধান: ফিল্টার nullএবংundefined

অবজেক্টের জন্য:

const cleanEmpty = obj => Object.entries(obj)
        .map(([k,v])=>[k,v && typeof v === "object" ? cleanEmpty(v) : v])
        .reduce((a,[k,v]) => (v == null ? a : (a[k]=v, a)), {});

অবজেক্টস এবং অ্যারেগুলির জন্য:

const cleanEmpty = obj => {
  if (Array.isArray(obj)) { 
    return obj
        .map(v => (v && typeof v === 'object') ? cleanEmpty(v) : v)
        .filter(v => !(v == null)); 
  } else { 
    return Object.entries(obj)
        .map(([k, v]) => [k, v && typeof v === 'object' ? cleanEmpty(v) : v])
        .reduce((a, [k, v]) => (v == null ? a : (a[k]=v, a)), {});
  } 
}

Comments

এই একমাত্র উত্তর হওয়া উচিত! এই স্নিপেটগুলির প্রত্যেকটি একটি নতুন অবজেক্ট তৈরি করবে যেখানে পুরানোটি রূপান্তরিত হবে না। এই ভাল! একটু নোট যদি আপনি ব্যবহার শুধু v == nullআপনার বিরুদ্ধে চেক করবে undefinedএবং null।

— মেগাজিন

cleanEmptyrecursve সমাধান একটি খালি বস্তুর ফিরে আসবে {}তারিখ অবজেক্টের জন্য

— এমানুয়েল এন কে

এক লাইনের আরও কিছুটা সুগম্যতা তাদের দুর্দান্ত করে তুলবে !!

— জারডিলিয়র

Answer 5

কারও যদি ওউনের (এবং এরিকের) উত্তরটির পুনরাবৃত্ত সংস্করণ প্রয়োজন হয় তবে তা এখানে:

/**
 * Delete all null (or undefined) properties from an object.
 * Set 'recurse' to true if you also want to delete properties in nested objects.
 */
function delete_null_properties(test, recurse) {
    for (var i in test) {
        if (test[i] === null) {
            delete test[i];
        } else if (recurse && typeof test[i] === 'object') {
            delete_null_properties(test[i], recurse);
        }
    }
}

Comments

লুপটির জন্য শুরু হওয়ার পরে, আপনার অবশ্যই পরীক্ষা করা উচিত যে অবজেক্টটি hasOwnPropertyব্যবহার করছেif(test.hasOwnProperty(i)) { ... }

— অগি গার্ডনার

@ অজিগার্ডনার আপনি কেন এটি পরীক্ষা করতে চান তা আমি আগ্রহী - যদি আপনি চান তবে দয়া করে এটি ব্যাখ্যা করুন। (উত্তরাধিকারসূত্রে প্রাপ্ত সম্পত্তিগুলি পরীক্ষা করা কি এটি আটকাতে পারে না?)

— Wumms

Answer 6

JSON.stringify অপরিবর্তিত কীগুলি সরিয়ে দেয়।

removeUndefined = function(json){
  return JSON.parse(JSON.stringify(json))
}

Comments

এটি একটি গভীর অবজেক্টের জন্য আমার পক্ষে কাজ করে নি, তবে উপরে ওমমের উত্তরটি দিয়েছে ।

— সুমন

আপনার যদি প্রতিস্থাপন ফাংশনটি ব্যবহার nullহিসাবে বিবেচনা করা হয় undefinedতবে আরও তথ্যের জন্য এই উত্তরটি দেখুন: stackoverflow.com/questions/286141/…

— হুমান আসকারি

এই বিষয়টি nullমানগুলি সরিয়ে দেয় না কেবল সচেতন হন । চেষ্টা করুন: let a = { b: 1, c: 0, d: false, e: null, f: undefined, g: [], h: {} }এবং তারপর console.log(removeUndefined(a))। প্রশ্ন সম্পর্কে undefinedএবং nullমান ছিল।

— মায়িড

Answer 7

আপনি সম্ভবত deleteকীওয়ার্ডটি সন্ধান করছেন।

var obj = { };
obj.theProperty = 1;
delete obj.theProperty;

Comments

এটি তিনি উপরে যা করছেন, এটি এখনও অবজেক্টে অপরিবর্তিত রয়েছে।

— জোশ বেদো

Answer 8

ফিল্টার আউট nullএবং undefinedমানগুলির সাহায্যে কোনও অবজেক্ট ফিরিয়ে দিতে সহজতম লোডাশ সমাধান ।

_.omitBy(obj, _.isNil)

Comments

এটি এ পর্যন্ত সবচেয়ে পরিষ্কার সমাধান!

— জী মোক

Answer 9

আপনি JSON.stringifyএর সংশোধনকারী প্যারামিটার এবং এর সমন্বয় ব্যবহার করতে পারেন useJSON.parse এটিকে আবার কোনও বস্তুতে পরিণত করতে পারেন। এই পদ্ধতিটি ব্যবহারের অর্থ হ'ল নেস্টেড অবজেক্টগুলির মধ্যে সমস্ত নেস্টেড কীগুলিতে প্রতিস্থাপনটি করা হয়।

উদাহরণ বস্তু

var exampleObject = {
  string: 'value',
  emptyString: '',
  integer: 0,
  nullValue: null,
  array: [1, 2, 3],
  object: {
    string: 'value',
    emptyString: '',
    integer: 0,
    nullValue: null,
    array: [1, 2, 3]
  },
  arrayOfObjects: [
    {
      string: 'value',
      emptyString: '',
      integer: 0,
      nullValue: null,
      array: [1, 2, 3]
    },
    {
      string: 'value',
      emptyString: '',
      integer: 0,
      nullValue: null,
      array: [1, 2, 3]
    }
  ]
};

Replacer ফাংশন

function replaceUndefinedOrNull(key, value) {
  if (value === null || value === undefined) {
    return undefined;
  }

  return value;
}

অবজেক্টটি পরিষ্কার করুন

exampleObject = JSON.stringify(exampleObject, replaceUndefinedOrNull);
exampleObject = JSON.parse(exampleObject);

কোডপেন উদাহরণ

Answer 10

ব্যবহার ramda # pickBy আপনি সব মুছে ফেলা হবে null, undefinedএবং falseমান:

const obj = {a:1, b: undefined, c: null, d: 1}
R.pickBy(R.identity, obj)

@ মানরো যেমন উল্লেখ করেছেন, falseমানগুলি ব্যবহারের জন্য isNil():

const obj = {a:1, b: undefined, c: null, d: 1, e: false}
R.pickBy(v => !R.isNil(v), obj)

Comments

(v) => !R.isNil(v)falseওপির প্রশ্নের পক্ষে সম্ভবত একটি ভাল পছন্দ, এই বা অন্যান্য মিথ্যা মূল্যবোধগুলিও প্রত্যাখ্যান করা হবেR.identity

— manroe

Answer 11

.filterপ্রয়োজনের চেয়ে বেশি অবজেক্ট তৈরি করা বা না ছাড়াই কার্যকরী এবং অপরিবর্তনীয় পদ্ধতি

Object.keys(obj).reduce((acc, key) => (obj[key] === undefined ? acc : {...acc, [key]: obj[key]}), {})

Comments

খুব সংক্ষিপ্ত উত্তর। নাল চেকটি যুক্ত করতে কেবল প্রতিস্থাপন obj[key] === undefinedকরুনobj[key] === undefined || obj[key] === null

— ব্যবহারকারীর 65651010

উপরোক্ত পদ্ধতির সামান্য পরিবর্তন: আপনি শর্তাধীন সত্য সত্য বস্তুতেও ছড়িয়ে দিতে পারেনconst omitFalsy = obj => Object.keys(obj).reduce((acc, key) => ({ ...acc, ...(obj[key] && { [key]: obj[key] }) }), {});

— কেভিন কে।

Answer 12

আপনি !শর্ত দিয়ে খাটো করতে পারেন

var r = {a: null, b: undefined, c:1};
for(var k in r)
   if(!r[k]) delete r[k];

ব্যবহারের ক্ষেত্রে মনে রাখবেন: @ সেমিকালার মন্তব্যগুলিতে যেমন ঘোষণা করেন: মানটি যদি খালি স্ট্রিং, মিথ্যা বা শূন্য হয় তবে এটি বৈশিষ্ট্যও মুছে ফেলবে

Comments

মানটি যদি খালি স্ট্রিং, মিথ্যা বা শূন্য হয় তবে এটি বৈশিষ্ট্যও মুছে ফেলবে।

— সেমিকোলন

এটি হ'ল আমি জেএসএন অনুরোধ থেকে অযাচিত ক্ষেত্রগুলি সরাতে ঠিক কী খুঁজছিলাম। ধন্যবাদ!

— ফিরোজেন

[null, undefined].includes(r[k])পরিবর্তে ব্যবহার করুন !r[k]।

— সেলম্যানসমেট

Answer 13

সংক্ষিপ্ত ES6 খাঁটি সমাধান, এটিকে একটি অ্যারেতে রূপান্তর করুন, ফিল্টার ফাংশনটি ব্যবহার করুন এবং এটিকে আবার কোনও বস্তুতে রূপান্তর করুন। একটি ফাংশন করা সহজ হবে ...

BTW। এটি দিয়ে .length > 0আমি খালি স্ট্রিং / অ্যারে আছে কিনা তা পরীক্ষা করে দেখি, তাই এটি খালি কীগুলি সরিয়ে ফেলবে।

const MY_OBJECT = { f: 'te', a: [] }

Object.keys(MY_OBJECT)
 .filter(f => !!MY_OBJECT[f] && MY_OBJECT[f].length > 0)
 .reduce((r, i) => { r[i] = MY_OBJECT[i]; return r; }, {});

জেএস বিআইএন https://jsbin.com/kugoyinora/edit?js,console

Comments

চমৎকার কার্যকরী সমাধান

— পিউইউ

আমি এই পছন্দ! তবে আমি সমস্ত মুছে ফেলার চিন্তা করি nullএবং undefinedএটি কেবল ব্যবহার করা সহজ MY_OBJECT[f] != null। আপনার বর্তমান সমাধানটি খালি স্ট্রিং / তালিকাগুলি ব্যতীত সমস্ত কিছু সরিয়ে ফেলে এবং মানগুলি যখন হয় ত্রুটি নিক্ষেপ করেnull

— রোটারেটি

ডান, আপনি একাধিক filterএর চেইন / চেন ব্যবহার করতে পারেন , আরও পঠনযোগ্য হবে।

— মাইকেল জে। জয়েডেল

আপনি যদি এটিকে কিছুটা সাধারণ করেন তবে আমি মনে করি যে লোডাশের কাজটি আপনি কাছে এসেছেন omit, কল করার আগে আপনার Object.keysconst omit = (obj, filter) => obj && Object.keys(obj).filter(key => !filter(obj[key])).reduce((acc,key) => {acc[key] = obj[key]; return acc}, {});

— আপত্তি

দুর্দান্ত, তবে যে কোনও পূর্ণসংখ্যার মানটি এই পদ্ধতির সাথে মুছে ফেলা হবে।

— গিস

Answer 14

আপনি json.stringify এর replacer আর্গুমেন্ট ব্যবহার করে এক লাইনে পুনরাবৃত্তি অপসারণ করতে পারেন

const removeNullValues = obj => (
  JSON.parse(JSON.stringify(obj, (k,v) => v ?? undefined))
)

ব্যবহার:

removeNullValues({a:{x:1,y:null,z:undefined}}) // Returns {a:{x:1}}

ইমানুয়েলের মন্তব্যে যেমন উল্লেখ করা হয়েছে, এই কৌশলটি কেবল তখনই কাজ করে যদি আপনার ডেটা স্ট্রাকচারে কেবলমাত্র ডেটা টাইপ থাকে যা জেএসএন ফর্ম্যাট (স্ট্রিংস, সংখ্যা, তালিকা ইত্যাদি) এ রাখা যেতে পারে।

(এই উত্তরটি নতুন নুলিশ কোলসিং অপারেটরটি ব্যবহার করার জন্য আপডেট করা হয়েছে browser ব্রাউজার সমর্থনের প্রয়োজনের উপর ভিত্তি করে আপনি পরিবর্তে এই ফাংশনটি ব্যবহার করতে পারেন (k,v) => v!=null ? v : undefined:)

Comments

এটি তারিখের অবজেক্টগুলিকে স্ট্রিংয়ে রূপান্তরিত করবে, রূপান্তরিত NaNকরবে nullযা সরানো হয়নি।

— ইমানুয়েল এনকে

Answer 15

আপনি যদি খাঁটি ES7 সমাধানের 4 টি লাইন চান:

const clean = e => e instanceof Object ? Object.entries(e).reduce((o, [k, v]) => {
  if (typeof v === 'boolean' || v) o[k] = clean(v);
  return o;
}, e instanceof Array ? [] : {}) : e;

অথবা আপনি যদি আরও পাঠযোগ্য সংস্করণ পছন্দ করেন:

function filterEmpty(obj, [key, val]) {
  if (typeof val === 'boolean' || val) {
    obj[key] = clean(val)
  };

  return obj;
}

function clean(entry) {
  if (entry instanceof Object) {
    const type = entry instanceof Array ? [] : {};
    const entries = Object.entries(entry);

    return entries.reduce(filterEmpty, type);
  }

  return entry;
}

এটি বুলিয়ান মানগুলি সংরক্ষণ করবে এবং এটি অ্যারেগুলিও পরিষ্কার করবে। এটি একটি পরিষ্কার অনুলিপি ফিরে আসল বস্তু সংরক্ষণ করে।

Answer 16

আমার প্রকল্পে আমার একই দৃশ্য রয়েছে এবং নিম্নলিখিত পদ্ধতিটি ব্যবহার করে অর্জন করেছি।

এটি সমস্ত ডেটা ধরণের সাথে কাজ করে, উপরে উল্লিখিত কয়েকটি সংখ্যক তারিখ এবং খালি অ্যারে নিয়ে কাজ করে না।

removeEmptyKeysFromObject.js

removeEmptyKeysFromObject(obj) {
   Object.keys(obj).forEach(key => {
  if (Object.prototype.toString.call(obj[key]) === '[object Date]' && (obj[key].toString().length === 0 || obj[key].toString() === 'Invalid Date')) {
    delete obj[key];
  } else if (obj[key] && typeof obj[key] === 'object') {
    this.removeEmptyKeysFromObject(obj[key]);
  } else if (obj[key] == null || obj[key] === '') {
    delete obj[key];
  }

  if (obj[key]
    && typeof obj[key] === 'object'
    && Object.keys(obj[key]).length === 0
    && Object.prototype.toString.call(obj[key]) !== '[object Date]') {
    delete obj[key];
  }
});
  return obj;
}

এই ফাংশনটিতে কোনও বস্তু সরানEmptyKeysFromObject ()

Answer 17

গভীর অনুসন্ধানের জন্য আমি নিম্নলিখিত কোডটি ব্যবহার করেছি, সম্ভবত এই প্রশ্নটি দেখার জন্য যে কেউ এটি কার্যকর হবে (এটি চক্র নির্ভরতার জন্য কার্যকর নয়):

function removeEmptyValues(obj) {
        for (var propName in obj) {
            if (!obj[propName] || obj[propName].length === 0) {
                delete obj[propName];
            } else if (typeof obj[propName] === 'object') {
                removeEmptyValues(obj[propName]);
            }
        }
        return obj;
    }

Answer 18

আপনি যদি জায়গায় পরিবর্তিত করতে না চান, তবে নাল / অপরিবর্তিত অপসারণযুক্ত একটি ক্লোন ফিরিয়ে দেন, আপনি ES6 হ্রাস ফাংশনটি ব্যবহার করতে পারেন।

// Helper to remove undefined or null properties from an object
function removeEmpty(obj) {
  // Protect against null/undefined object passed in
  return Object.keys(obj || {}).reduce((x, k) => {
    // Check for null or undefined
    if (obj[k] != null) {
      x[k] = obj[k];
    }
    return x;
  }, {});
}

Answer 19

সম্পত্তি মুছে ফেলার পরিবর্তে, আপনি কীগুলি নাল নয় তা দিয়ে একটি নতুন অবজেক্টও তৈরি করতে পারেন।

const removeEmpty = (obj) => {
  return Object.keys(obj).filter(key => obj[key]).reduce(
    (newObj, key) => {
      newObj[key] = obj[key]
      return newObj
    }, {}
  )
}

Answer 20

উপর piggypack করার বেন এর উত্তর কীভাবে এই সমস্যার lodash এর ব্যবহার সমাধানের উপর _.pickBy: আপনার কাছে বোন লাইব্রেরিতে এই সমস্যার সমাধান করতে পারে Underscore.js এর _.pick।

var obj = {name: 'John', age: null};

var compacted = _.pick(obj, function(value) {
  return value !== null && value !== undefined;
});

দেখুন: জেএসফিডাল উদাহরণ

Comments

এটি খালি অ্যারে দেয়, আপনি আপত্তিতে আপত্তিটির নামও পরিবর্তন করেছেন

— স্টিফেন ডুমন্ট

ধন্যবাদ স্টিফেন! তোমার কি অবস্থা? আমি জেএসফিডাল লিঙ্কটি অন্তর্ভুক্ত করতে আমার উত্তর আপডেট করেছি।

— অ্যালেক্স জনসন

_.omit (আপত্তি, _.আইএসপি) ব্যবহার করে দেখুন; এটি আরও ধারণাগতভাবে খাঁটি এবং খালি স্ট্রিং অন্তর্ভুক্ত করবে।

— স্টিফেন ডুমন্ট

Answer 21

একটি হ্রাস সহায়ক সাহায্য করতে পারেন (প্রকার পরীক্ষা না করে) -

const cleanObj = Object.entries(objToClean).reduce((acc, [key, value]) => {
      if (value) {
        acc[key] = value;
      }
      return acc;
    }, {});

Answer 22

যদি কারও কাছে undefinedগভীর অনুসন্ধানের সাহায্যে কোনও অবজেক্ট থেকে মানগুলি সরিয়ে ফেলার প্রয়োজন হয় lodashতবে আমি ব্যবহার করছি কোডটি এখানে। সমস্ত খালি মান ( null/ undefined) মুছে ফেলার জন্য এটি সংশোধন করা বেশ সহজ ।

function omitUndefinedDeep(obj) {
  return _.reduce(obj, function(result, value, key) {
    if (_.isObject(value)) {
      result[key] = omitUndefinedDeep(value);
    }
    else if (!_.isUndefined(value)) {
      result[key] = value;
    }
    return result;
  }, {});
}

Answer 23

লোদাশ সহ:

_.omitBy({a: 1, b: null}, (v) => !v)

Answer 24

আপনি যদি এসলিন্ট ব্যবহার করেন এবং নো-প্যারাম-পুনরায় নিয়োগের নিয়মটি ট্রিপিং এড়াতে চান, তবে আপনি মোটামুটি মার্জিত ES6 সমাধানের জন্য .reduc এবং একটি গণিত সম্পত্তি নামের সাথে মিলিয়ে অবজেক্ট.সেসাইন ব্যবহার করতে পারেন:

const queryParams = { a: 'a', b: 'b', c: 'c', d: undefined, e: null, f: '', g: 0 };
const cleanParams = Object.keys(queryParams) 
  .filter(key => queryParams[key] != null)
  .reduce((acc, key) => Object.assign(acc, { [key]: queryParams[key] }), {});
// { a: 'a', b: 'b', c: 'c', f: '', g: 0 }

Answer 25

nullsES6 ব্যবহার করে কোনও অবজেক্টটি কেবলমাত্র অবয়ব ছাড়াই অপসারণের একটি কার্যকরী উপায় reduce:

const stripNulls = (obj) => {
  return Object.keys(obj).reduce((acc, current) => {
    if (obj[current] !== null) {
      return { ...acc, [current]: obj[current] }
    }
    return acc
  }, {})
}

Comments

ট্রোল মন্তব্য এটি সম্পর্কে একটি কার্যকরী প্যাটার্ন হওয়া সম্পর্কে দুটি জিনিস: stripNullsফাংশনের মধ্যে এটি সঞ্চয়ের ফাংশনের সুযোগের বাইরে থেকে একটি রেফারেন্স ব্যবহার করে; এবং এটি সংগ্রহকারী ফাংশনের মধ্যে ফিল্টার করে উদ্বেগগুলি মিশ্রিত করে। 😝 (উদাঃ Object.entries(o).filter(([k,v]) => v !== null).reduce((o, [k, v]) => {o[k] = v; return o;}, {});) হ্যাঁ, এটি ফিল্টার করা আইটেমগুলিতে দু'বার লুপ করবে তবে সেখানে অনুধাবন করা পারফেক লস নগণ্য।

— জেসন কাস্টম

Answer 26

আপনি এর জাতীয় কিছু ব্যবহার করে ...স্প্রেড সিনট্যাক্সও ব্যবহার forEachকরতে পারেন:

let obj = { a: 1, b: "b", c: undefined, d: null };
let cleanObj = {};

Object.keys(obj).forEach(val => {
  const newVal = obj[val];
  cleanObj = newVal ? { ...cleanObj, [val]: newVal } : cleanObj;
});

console.info(cleanObj);

Answer 27

জায়গায় পরিষ্কার বস্তু

// General cleanObj function
const cleanObj = (valsToRemoveArr, obj) => {
   Object.keys(obj).forEach( (key) =>
      if (valsToRemoveArr.includes(obj[key])){
         delete obj[key]
      }
   })
}

cleanObj([undefined, null], obj)

খাঁটি ফাংশন

const getObjWithoutVals = (dontReturnValsArr, obj) => {
    const cleanObj = {}
    Object.entries(obj).forEach( ([key, val]) => {
        if(!dontReturnValsArr.includes(val)){
            cleanObj[key]= val
        } 
    })
    return cleanObj
}

//To get a new object without `null` or `undefined` run: 
const nonEmptyObj = getObjWithoutVals([undefined, null], obj)

Comments

এটি একটি দুর্দান্ত, সম্ভবত এক-লাইনার, সমাধান

— 9:30

Answer 28

আমরা কোনও অবজেক্ট থেকে ফাঁকা বৈশিষ্ট্যগুলি সরাতে JSON.stringify এবং JSON.parse ব্যবহার করতে পারি।

jsObject = JSON.parse(JSON.stringify(jsObject), (key, value) => {
               if (value == null || value == '' || value == [] || value == {})
                   return undefined;
               return value;
           });

Comments

এই কৌশলটি আসলে বৈধ, যতক্ষণ না আপনি ওবিজে জেএসএন-সিরিয়ালাইজযোগ্য তা নিশ্চিত করেন। এবং এটি গভীরভাবে কাজ করে।

— পোলভ

অবৈধ অ্যারে এবং অবজেক্টের তুলনা ( {} != {}এবং [] != []), তবে অন্যথায় পদ্ধতিটি বৈধ

— আইভারাস

Answer 29

এখানে একটি বিস্তৃত পুনরাবৃত্তি ফাংশন (মূলত @ চিকেন দ্বারা নির্মিত উপর ভিত্তি করে) যা করবে:

• আপনি যা বলছেন তা পুনরাবৃত্তভাবে মুছে ফেলুন defaults=[undefined, null, '', NaN]
• নিয়মিত অবজেক্টস, অ্যারে এবং তারিখের বিষয়গুলি সঠিকভাবে পরিচালনা করুন

const cleanEmpty = function(obj, defaults = [undefined, null, NaN, '']) {
  if (!defaults.length) return obj
  if (defaults.includes(obj)) return

  if (Array.isArray(obj))
    return obj
      .map(v => v && typeof v === 'object' ? cleanEmpty(v, defaults) : v)
      .filter(v => !defaults.includes(v))

  return Object.entries(obj).length 
    ? Object.entries(obj)
        .map(([k, v]) => ([k, v && typeof v === 'object' ? cleanEmpty(v, defaults) : v]))
        .reduce((a, [k, v]) => (defaults.includes(v) ? a : { ...a, [k]: v}), {}) 
    : obj
}

ব্যবহার:

// based off the recursive cleanEmpty function by @chickens. 
// This one can also handle Date objects correctly 
// and has a defaults list for values you want stripped.

const cleanEmpty = function(obj, defaults = [undefined, null, NaN, '']) {
  if (!defaults.length) return obj
  if (defaults.includes(obj)) return

  if (Array.isArray(obj))
    return obj
      .map(v => v && typeof v === 'object' ? cleanEmpty(v, defaults) : v)
      .filter(v => !defaults.includes(v))

  return Object.entries(obj).length 
    ? Object.entries(obj)
        .map(([k, v]) => ([k, v && typeof v === 'object' ? cleanEmpty(v, defaults) : v]))
        .reduce((a, [k, v]) => (defaults.includes(v) ? a : { ...a, [k]: v}), {}) 
    : obj
}


// testing

console.log('testing: undefined \n', cleanEmpty(undefined))
console.log('testing: null \n',cleanEmpty(null))
console.log('testing: NaN \n',cleanEmpty(NaN))
console.log('testing: empty string \n',cleanEmpty(''))
console.log('testing: empty array \n',cleanEmpty([]))
console.log('testing: date object \n',cleanEmpty(new Date(1589339052 * 1000)))
console.log('testing: nested empty arr \n',cleanEmpty({ 1: { 2 :null, 3: [] }}))
console.log('testing: comprehensive obj \n', cleanEmpty({
  a: 5,
  b: 0,
  c: undefined,
  d: {
    e: null,
    f: [{
      a: undefined,
      b: new Date(),
      c: ''
    }]
  },
  g: NaN,
  h: null
}))
console.log('testing: different defaults \n', cleanEmpty({
  a: 5,
  b: 0,
  c: undefined,
  d: {
    e: null,
    f: [{
      a: undefined,
      b: '',
      c: new Date()
    }]
  },
  g: [0, 1, 2, 3, 4],
  h: '',
}, [undefined, null]))

Answer 30

আপনি যদি খাঁটি / কার্যকরী পদ্ধতির পছন্দ করেন

const stripUndef = obj => 
  Object.keys(obj)
   .reduce((p, c) => ({ ...p, ...(x[c] === undefined ? { } : { [c]: x[c] })}), {});