ES6 में कुंजी द्वारा फ़िल्टर ऑब्जेक्ट गुण

Question

मान लीजिए कि मेरे पास एक वस्तु है:

{
  item1: { key: 'sdfd', value:'sdfd' },
  item2: { key: 'sdfd', value:'sdfd' },
  item3: { key: 'sdfd', value:'sdfd' }
}

मैं ऊपर की वस्तु को फ़िल्टर करके एक और ऑब्जेक्ट बनाना चाहता हूं ताकि मेरे पास कुछ ऐसा हो।

 {
    item1: { key: 'sdfd', value:'sdfd' },
    item3: { key: 'sdfd', value:'sdfd' }
 }

मैं Es6 का उपयोग करके इसे पूरा करने के लिए एक स्वच्छ तरीके की तलाश कर रहा हूं, इसलिए प्रसार ऑपरेटर मेरे लिए उपलब्ध हैं।

Comments

ईएस 6 का कोई प्रसार प्रसार संचालक नहीं है, और आपको वैसे भी इनकी आवश्यकता नहीं है

— बर्गी

जावास्क्रिप्ट

— जोनाथन एच

@DanDascalescu लेकिन यह जवाब ओपी जो पूछता है, उसे पूरा करने का ईएस 6 तरीका देता है, है न?

— जोनाथन एच।

क्या होगा यदि मैं एक कुंजी / मान से फ़िल्टर करना चाहता हूं?

— jmchauv

Answer 1

यदि आपके पास अनुमत मानों की सूची है, तो आप आसानी से उन्हें किसी ऑब्जेक्ट में उपयोग करके बनाए रख सकते हैं:

const raw = {
  item1: { key: 'sdfd', value:'sdfd' },
  item2: { key: 'sdfd', value:'sdfd' },
  item3: { key: 'sdfd', value:'sdfd' }
};

const allowed = ['item1', 'item3'];

const filtered = Object.keys(raw)
  .filter(key => allowed.includes(key))
  .reduce((obj, key) => {
    obj[key] = raw[key];
    return obj;
  }, {});

console.log(filtered);

यह उपयोग करता है:

1. Object.keysraw(मूल डेटा) में सभी गुणों को सूचीबद्ध करने के लिए
2. Array.prototype.filter उन कुंजियों का चयन करने के लिए जो अनुमत सूची में मौजूद हैं, का उपयोग कर
   1. Array.prototype.includes यह सुनिश्चित करने के लिए कि वे मौजूद हैं
3. Array.prototype.reduce केवल अनुमत गुणों के साथ एक नई वस्तु का निर्माण करने के लिए।

यह अनुमति प्राप्त संपत्तियों के साथ एक उथले प्रतिलिपि बना देगा (लेकिन स्वयं संपत्तियों की नकल नहीं करेगा)।

आप ऑब्जेक्ट को फैलाने के लिए ऑब्जेक्ट की एक श्रृंखला बनाने के लिए उनका उपयोग किए बिना उन्हें उत्परिवर्तित करने के लिए भी उपयोग कर सकते हैं ( यह उल्लेख करने के लिए पुनरावृत्ति के लिए धन्यवाद ):

const raw = {
  item1: { key: 'sdfd', value:'sdfd' },
  item2: { key: 'sdfd', value:'sdfd' },
  item3: { key: 'sdfd', value:'sdfd' }
};

const allowed = ['item1', 'item3'];

const filtered = Object.keys(raw)
  .filter(key => allowed.includes(key))
  .reduce((obj, key) => {
    return {
      ...obj,
      [key]: raw[key]
    };
  }, {});

console.log(filtered);

सामान्य ज्ञान के प्रयोजनों के लिए, यदि आप मूल डेटा से अवांछित क्षेत्रों को हटाना चाहते थे (जो कि मैं ऐसा करने की सलाह नहीं दूंगा, क्योंकि इसमें कुछ बदसूरत परिवर्तन शामिल हैं), तो आप includesचेक को उल्टा कर सकते हैं:

const raw = {
  item1: { key: 'sdfd', value:'sdfd' },
  item2: { key: 'sdfd', value:'sdfd' },
  item3: { key: 'sdfd', value:'sdfd' }
};

const allowed = ['item1', 'item3'];

Object.keys(raw)
  .filter(key => !allowed.includes(key))
  .forEach(key => delete raw[key]);

console.log(raw);

मैं म्यूटेशन-आधारित समाधान दिखाने के लिए इस उदाहरण को शामिल कर रहा हूं, लेकिन मैं इसका उपयोग करने का सुझाव नहीं देता।

Comments

धन्यवाद कि महान काम किया। मुझे 'डिकंस्ट्रक्शन सिंटैक्स' का उपयोग करके एक दृष्टिकोण भी मिला। IE: const {item1, item3} = कच्ची const newObject = {item1, item3}

— 29er

Deconstruction काम करेगा (ठीक है), लेकिन विशुद्ध रूप से संकलन-समय है। आप इसे गुणों की एक गतिशील सूची नहीं बना सकते हैं या कोई भी जटिल नियम प्रदान कर सकते हैं (एक लूप में सत्यापन कॉलबैक संलग्न हो सकता है, उदाहरण के लिए)।

— ssube

मैं इसे पर्याप्त वोट नहीं कर सकता! अच्छी तरह से फिल्टर का उपयोग करने और कम करने और लूप के लिए किसी अन्य ऑब्जेक्ट का निर्माण नहीं करने के लिए किया जाता है। और भयानक कि आपने स्पष्ट रूप से अपरिवर्तनीय और परिवर्तनशील संस्करणों को अलग कर दिया। +1

— सुकिमा

त्वरित चेतावनी: Array.prototype.includesES6 का हिस्सा नहीं है। इसे ECMAScript 2016 (ES7) में पेश किया गया है।

— विनीत

यदि आप एक अपरिवर्तनीय तरीके से कम करना चाहते हैं, तो आप फ़ंक्शन सामग्री को रिटर्न {... obj, [कुंजी]: रॉ [की]] के साथ बदल सकते हैं

— rjerue

Answer 2

यदि आप ES6 सिंटैक्स का उपयोग करने के साथ ठीक हैं, तो मुझे लगता है कि ऐसा करने का सबसे साफ तरीका, जैसा कि यहां और यहां बताया गया है:

const data = {
  item1: { key: 'sdfd', value:'sdfd' },
  item2: { key: 'sdfd', value:'sdfd' },
  item3: { key: 'sdfd', value:'sdfd' }
};

const { item2, ...newData } = data;

अब, newDataइसमें शामिल हैं:

{
  item1: { key: 'sdfd', value:'sdfd' },
  item3: { key: 'sdfd', value:'sdfd' }
};

या, यदि आपके पास कुंजी एक स्ट्रिंग के रूप में संग्रहीत है:

const key = 'item2';
const { [key]: _, ...newData } = data;

बाद के मामले में, [key]इसे परिवर्तित कर दिया जाता है, item2लेकिन चूंकि आप constअसाइनमेंट का उपयोग कर रहे हैं , इसलिए आपको असाइनमेंट के लिए एक नाम निर्दिष्ट करना होगा। _एक फेंक दूर मूल्य का प्रतिनिधित्व करता है।

आम तौर पर:

const { item2, ...newData } = data; // Assign item2 to item2
const { item2: someVarName, ...newData } = data; // Assign item2 to someVarName
const { item2: _, ...newData } = data; // Assign item2 to _
const { ['item2']: _, ...newData } = data; // Convert string to key first, ...

यह न केवल आपके ऑपरेशन को एक-लाइनर तक कम कर देता है, बल्कि आपको यह जानने की भी आवश्यकता नहीं है कि अन्य कुंजी क्या हैं (जिन्हें आप संरक्षित करना चाहते हैं)।

Comments

" _थ्रो दूर मूल्य का प्रतिनिधित्व करता है" यह कहां आता है? पहली बार मैं इसे देखता हूँ

— yhabib

मेरा मानना ​​है कि यह जेएस समुदाय द्वारा अपनाया गया सम्मेलन है। एक _बस एक वेरिएबल वेरिएबल नाम है जिसे जेएस में इस्तेमाल किया जा सकता है लेकिन चूंकि यह बहुत ज्यादा बेकार है, इसलिए इसे वास्तव में उस तरह से इस्तेमाल नहीं किया जाना चाहिए यदि आप इरादे व्यक्त करना चाहते हैं। इसलिए, यह एक चर के रूप में अपनाया गया है, जिसके बारे में आप परवाह नहीं करते। इसके बारे में और चर्चा यहाँ है: stackoverflow.com/questions/11406823/…

— रयान एच।

यह स्वीकृत उत्तर की तुलना में बहुत अधिक कठिन है, Object.keys () के साथ एक नया सरणी बनाने के ओवरहेड से बचा जाता है, और सरणी के साथ पुनरावृति के ओवरहेड filterऔर reduce।

— एराइकोस्को

@ अहाब _कोई फर्क नहीं पड़ता, यह सिर्फ एक चर नाम है, आप इसे अपनी इच्छानुसार किसी भी चीज़ का नाम बदल सकते हैं

— विक

@ मुझे नहीं लगता कि एक सामान्यीकृत समाधान एक तुच्छ वन-लाइनर होगा। उसके लिए, मैं लॉडश omitफ़ंक्शन का उपयोग करूंगा : लॉडश.com / docs / 4.17.10#omit या यहां दिए गए अन्य समाधानों में से एक।

— रयान एच।

Answer 3

सबसे साफ तरीका जो आप पा सकते हैं, वह है लोदश # पिक

const _ = require('lodash');

const allowed = ['item1', 'item3'];

const obj = {
  item1: { key: 'sdfd', value:'sdfd' },
  item2: { key: 'sdfd', value:'sdfd' },
  item3: { key: 'sdfd', value:'sdfd' }
}

const filteredObj = _.pick(obj, allowed)

Comments

यह इंगित करना महत्वपूर्ण है कि इसके लिए अतिरिक्त परियोजना निर्भरता को रनटाइम पर डाउनलोड करना होगा।

— एस। एस्टेव्स

_.omit (obj, ["item2"]) - lodash.omit, lodash.pick के विपरीत है

— अलेक्जेंडर सोलोयेव

Answer 4

ऐसा कुछ भी नहीं है जो पहले नहीं कहा गया है, लेकिन कुछ जवाबों को एक सामान्य ईएस 6 के उत्तर से जोड़ना है:

const raw = {
  item1: { key: 'sdfd', value: 'sdfd' },
  item2: { key: 'sdfd', value: 'sdfd' },
  item3: { key: 'sdfd', value: 'sdfd' }
};

const filteredKeys = ['item1', 'item3'];

const filtered = filteredKeys
  .reduce((obj, key) => ({ ...obj, [key]: raw[key] }), {});

console.log(filtered);

Comments

); इस दूसरों की तुलना में एक अधिक सरल और performant समाधान है

— pomeh

Answer 5

आधुनिक जेएस की एक पंक्ति में बस एक और समाधान जिसमें कोई बाहरी पुस्तकालय नहीं है ।

मैं " विनाशकारी " सुविधा के साथ खेल रहा था :

const raw = {
    item1: { key: 'sdfd', value: 'sdfd' },
    item2: { key: 'sdfd', value: 'sdfd' },
    item3: { key: 'sdfd', value: 'sdfd' }
  };
var myNewRaw = (({ item1, item3}) => ({ item1, item3 }))(raw);
console.log(myNewRaw);

Comments

var myNewRaw = (({ item1, item3}) => ({ item1, item3 }))(raw);सिंटेक्स मुद्दा

— अवलो

यहां संघनित चीजों की एक जोड़ी है: पहली बात, पहले समारोह की घोषणा है। यह एक तीर फ़ंक्शन है (यह ऑब्जेक्ट लेता है और ऑब्जेक्ट लौटाता है)। यह फ़ंक्शन (obj) {वापसी obj;} के समान है। दूसरी बात यह है कि ES6 भविष्य को नष्ट करने की अनुमति देता है। अपने फ़ंक्शन घोषणा में मैं अपनी वस्तु {आइटम 1, आइटम 3} को नष्ट कर देता हूं। और आखिरी बात यह है कि मैं स्वयं अपने कार्य का आह्वान करता हूं। उदाहरण के लिए अपना दायरा प्रबंधित करने के लिए आप सेल्फ इनवोक फ़ंक्शन का उपयोग कर सकते हैं। लेकिन यहाँ यह सिर्फ कोड को सम्मिलित करने के लिए था। मुझे उम्मीद है कि यह स्पष्ट है। अगर मैं कुछ और अधिक जोड़ने के लिए स्वतंत्र महसूस याद आती है।

— नोवी

यह पसंदीदा आधुनिक दृष्टिकोण imho

— mattdlockyer

Answer 6

अब आप Object.fromEntries विधि (ब्राउज़र समर्थन की जाँच करें) का उपयोग करके इसे छोटा और सरल बना सकते हैं :

const raw = { item1: { prop:'1' }, item2: { prop:'2' }, item3: { prop:'3' } };

const allowed = ['item1', 'item3'];

const filtered = Object.fromEntries(
   Object.entries(raw).filter(
      ([key, val])=>allowed.includes(key)
   )
);

इसके बारे में अधिक पढ़ें: Object.fromEntries

Comments

यह अब मुझे लगता है कि सबसे अच्छा तरीका है। कम करने की तुलना में अधिक सहज।

— डेमन

Answer 7

आप एक जेनेरिक जोड़ सकते हैं ofilter( जेनेरिक के साथ लागू किया गया है oreduce) ताकि आप आसानी से उसी तरह से वस्तुओं को फ़िल्टर कर सकें जिस तरह से आप एरेज़ कर सकते हैं -

const oreduce = (f, acc, o) =>
  Object
    .entries (o)
    .reduce
      ( (acc, [ k, v ]) => f (acc, v, k, o)
      , acc
      )

const ofilter = (f, o) =>
  oreduce
    ( (acc, v, k, o)=>
        f (v, k, o)
          ? Object.assign (acc, {[k]: v})
          : acc
    , {}
    , o
    )

हम इसे यहाँ काम करते हुए देख सकते हैं -

const data =
  { item1: { key: 'a', value: 1 }
  , item2: { key: 'b', value: 2 }
  , item3: { key: 'c', value: 3 }
  }

console.log
  ( ofilter
      ( (v, k) => k !== 'item2'
      , data
      )
      // [ { item1: { key: 'a', value: 1 } }
      // , { item3: { key: 'c', value: 3 } }
      // ]

  , ofilter
      ( x => x.value === 3
      , data
      )
      // [ { item3: { key: 'c', value: 3 } } ]
  )

नीचे अपने स्वयं के ब्राउज़र में परिणाम सत्यापित करें -

const oreduce = (f, acc, o) =>
  Object
    .entries (o)
    .reduce
      ( (acc, [ k, v ]) => f (acc, v, k, o)
      , acc
      )

const ofilter = (f, o) =>
  oreduce
    ( (acc, v, k, o)=>
        f (v, k, o)
          ? Object.assign (acc, { [k]: v })
          : acc
    , {}
    , o
    )

const data =
  { item1: { key: 'a', value: 1 }
  , item2: { key: 'b', value: 2 }
  , item3: { key: 'c', value: 3 }
  }

console.log
  ( ofilter
      ( (v, k) => k !== 'item2'
      , data
      )
      // [ { item1: { key: 'a', value: 1 } }
      // , { item3: { key: 'c', value: 3 } }
      // ]

  , ofilter
      ( x => x.value === 3
      , data
      )
      // [ { item3: { key: 'c', value: 3 } } ]
  )

इन दो कार्यों को कई तरीकों से लागू किया जा सकता है। मैंने Array.prototype.reduceअंदर संलग्न करना चुना, oreduceलेकिन आप इसे आसानी से खरोंच से लिख सकते हैं

Comments

मुझे आपका समाधान पसंद है, लेकिन मुझे नहीं पता कि यह इस की तुलना में कितना स्पष्ट / अधिक कुशल है ।

— जोनाथन एच

यहाँ एक बेंचमार्क दिखाया गया है कि आपका समाधान सबसे तेज़ है।

— जोनाथन एच

में oreduce, पहले accमें आच्छादित है .reduce(acc, k), और में आच्छादित है - एक चर के साथ कहा जाता है कहा जाता है और साथ ही - जो है जो? ofilterooreduceo

— जर्रोड मोसेन

में ofilterचर oआच्छादित है लेकिन यह हमेशा एक ही इनपुट वर की ओर इशारा करता; इसीलिए इसकी छाया यहाँ है, क्योंकि यह एक ही है - संचायक ( acc) भी छाया हुआ है क्योंकि यह अधिक स्पष्ट रूप से दिखाता है कि डेटा लंबो को कैसे आगे बढ़ाता है; accहमेशा एक ही बंधन नहीं है , लेकिन यह हमेशा उस कम्प्यूटेशनल परिणाम की वर्तमान निरंतर स्थिति का प्रतिनिधित्व करता है जिसे हम वापस करना चाहते हैं

— धन्यवाद

हालांकि कोड अच्छी तरह से काम करता है और विधि बहुत अच्छी है, मुझे आश्चर्य होता है कि कोड लिखने में क्या मदद मिलती है जैसे किसी को स्पष्ट रूप से जावास्क्रिप्ट के साथ मदद की आवश्यकता हो। मैं सभी संक्षिप्तता के लिए हूँ, लेकिन यह कम से कम कोड के रूप में कॉम्पैक्ट है।

— पॉल जी मिहाई

Answer 8

यह मैंने हाल ही में कैसे किया है:

const dummyObj = Object.assign({}, obj);
delete dummyObj[key];
const target = Object.assign({}, {...dummyObj});

Comments

हम्म। ऐसा लगता है कि आप पुराने और नए वाक्यविन्यास को मिला रहे हैं। Object.assign == ...आप लिख सकते हैं const dummyObj = { ...obj }और const target = { ...dummyObj }। इसके अलावा, उत्तरार्द्ध बिल्कुल भी आवश्यक नहीं है, क्योंकि आप सीधे dummyObj के साथ काम कर सकते हैं।

— एंडी

Answer 9

ठीक है, यह एक-लाइनर के बारे में कैसे

    const raw = {
      item1: { key: 'sdfd', value: 'sdfd' },
      item2: { key: 'sdfd', value: 'sdfd' },
      item3: { key: 'sdfd', value: 'sdfd' }
    };

    const filteredKeys = ['item1', 'item3'];

    const filtered = Object.assign({}, ...filteredKeys.map(key=> ({[key]:raw[key]})));

Comments

सभी उत्तरों का सबसे अद्भुत समाधान। +1

— गेरू होर्वाथ

क्या होगा यदि आप केवल उन कुंजियों को जानते हैं जिन्हें आप हटाना चाहते हैं ... न कि उन कुंजियों को जिन्हें आप रखना चाहते हैं?

— जेसन

Answer 10

यहां उत्तर निश्चित रूप से उपयुक्त हैं, लेकिन वे थोड़े धीमे हैं क्योंकि उन्हें ऑब्जेक्ट में हर संपत्ति के लिए श्वेतसूची के माध्यम से लूपिंग की आवश्यकता होती है। नीचे दिए गए समाधान बड़े डेटासेट के लिए बहुत जल्दी है क्योंकि यह केवल एक बार श्वेतसूची के माध्यम से लूप करता है:

const data = {
  allowed1: 'blah',
  allowed2: 'blah blah',
  notAllowed: 'woah',
  superSensitiveInfo: 'whooooah',
  allowed3: 'bleh'
};

const whitelist = ['allowed1', 'allowed2', 'allowed3'];

function sanitize(data, whitelist) {
    return whitelist.reduce(
      (result, key) =>
        data[key] !== undefined
          ? Object.assign(result, { [key]: data[key] })
          : result,
      {}
    );
  }

  sanitize(data, whitelist)

Answer 11

Ssube के उत्तर पते पर गुल्लक ।

यहाँ एक पुन: प्रयोज्य संस्करण है।

Object.filterByKey = function (obj, predicate) {
  return Object.keys(obj)
    .filter(key => predicate(key))
    .reduce((out, key) => {
      out[key] = obj[key];
      return out;
    }, {});
}

इसका उपयोग करने के लिए कॉल करने के लिए

const raw = {
  item1: { key: 'sdfd', value:'sdfd' },
  item2: { key: 'sdfd', value:'sdfd' },
  item3: { key: 'sdfd', value:'sdfd' }
};

const allowed = ['item1', 'item3'];

var filtered = Object.filterByKey(raw, key => 
  return allowed.includes(key));
});

console.log(filtered);

ES6 तीर फ़ंक्शन के बारे में सुंदर बात यह है कि आपको allowedएक पैरामीटर के रूप में पास नहीं करना है ।

Answer 12

आप ऐसा कुछ कर सकते हैं:

const base = {
  item1: { key: 'sdfd', value:'sdfd' },
  item2: { key: 'sdfd', value:'sdfd' },
  item3: { key: 'sdfd', value:'sdfd' }
};

const filtered = (
    source => { 
        with(source){ 
            return {item1, item3} 
        } 
    }
)(base);

// one line
const filtered = (source => { with(source){ return {item1, item3} } })(base);

यह काम करता है लेकिन बहुत स्पष्ट नहीं है, साथ ही withकथन की सिफारिश नहीं की गई है ( https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/with )।

Answer 13

बिना उपयोग के एक सरल समाधान filterके Object.entries()बजाय के साथ प्राप्त किया जा सकता हैObject.keys()

const raw = {
  item1: { key: 'sdfd', value:'sdfd' },
  item2: { key: 'sdfd', value:'sdfd' },
  item3: { key: 'sdfd', value:'sdfd' }
};

const allowed = ['item1', 'item3'];

const filtered = Object.entries(raw).reduce((acc,elm)=>{
  const [k,v] = elm
  if (allowed.includes(k)) {
    acc[k] = v 
  }
  return acc
},{})

Answer 14

इसे पूरा करने के कई तरीके हैं। स्वीकार किए जाते हैं जवाब एक कुंजी-फ़िल्टर-कम दृष्टिकोण है, जो सबसे शक्तिशाली नहीं है का उपयोग करता है।

इसके बजाय, for...inकिसी ऑब्जेक्ट की कुंजियों के माध्यम से लूप का उपयोग करना , या अनुमत कुंजी के माध्यम से लूपिंग करना, और फिर एक नई वस्तु की रचना करना ~ 50% अधिक परफॉर्मेंट ^ए ।

const obj = {
  item1: { key: 'sdfd', value:'sdfd' },
  item2: { key: 'sdfd', value:'sdfd' },
  item3: { key: 'sdfd', value:'sdfd' }
};

const keys = ['item1', 'item3'];

function keysReduce (obj, keys) {
  return keys.reduce((acc, key) => {
    if(obj[key] !== undefined) {
      acc[key] = obj[key];
    }
    return acc;
  }, {});
};

function forInCompose (obj, keys) {
  const returnObj = {};
  for (const key in obj) {
    if(keys.includes(key)) {
      returnObj[key] = obj[key]
    }
  };
  return returnObj;
};

keysReduce(obj, keys);   // Faster if the list of allowed keys are short
forInCompose(obj, keys); // Faster if the number of object properties are low

---

^{ए। एक साधारण उपयोग मामले के मानदंड के लिए jsPerf देखें । परिणाम ब्राउज़र पर आधारित होंगे।}

Answer 15

आप अपनी वस्तु पर एक महत्वपूर्ण कुंजी निकाल सकते हैं

items={
  item1: { key: 'sdfd', value:'sdfd' },
  item2: { key: 'sdfd', value:'sdfd' },
  item3: { key: 'sdfd', value:'sdfd' }
}

// Example 1
var key = "item2";
delete items[key]; 

// Example 2
delete items["item2"];

// Example 3
delete items.item2;

Answer 16

const filteredObject = Object.fromEntries(Object.entries(originalObject).filter(([key, value]) => key !== uuid))

Comments

अन्य उत्तर हैं जो ओपी के प्रश्न प्रदान करते हैं, और उन्हें कुछ समय पहले पोस्ट किया गया था। उत्तर पोस्ट करते समय, कृपया सुनिश्चित करें कि आप या तो एक नया समाधान जोड़ते हैं, या काफी बेहतर स्पष्टीकरण, विशेष रूप से पुराने प्रश्नों का उत्तर देते समय।

— help-info.de

Answer 17

सरल तरीका! यह करने के लिए।

const myData = {
  item1: { key: 'sdfd', value:'sdfd' },
  item2: { key: 'sdfd', value:'sdfd' },
  item3: { key: 'sdfd', value:'sdfd' }
};
const{item1,item3}=myData
const result =({item1,item3})

Comments

आप वास्तव में यहां कुछ भी फ़िल्टर नहीं कर रहे हैं, बस दिए गए डेटा को नष्ट कर रहे हैं। लेकिन जब डेटा बदलता है तब क्या होता है?

— इदरीस डोपिको पेना

Answer 18

"नया" Array.reduceविधि का उपयोग कर एक और समाधान :

const raw = {
  item1: { key: 'sdfd', value:'sdfd' },
  item2: { key: 'sdfd', value:'sdfd' },
  item3: { key: 'sdfd', value:'sdfd' }
};

const allowed = ['item1', 'item3'];

const filtered = allowed.reduce((obj, key) => { 
  obj[key] = raw[key]; 
  return obj 
}, {})

console.log(filtered);

इस फिडेल में प्रदर्शन ...

---

लेकिन मुझे इस उत्तर में समाधान पसंद है जो यहाँ उपयोग कर रहा है और :Object.fromEntries Array.filterArray.includes

const object = Object.fromEntries( Object.entries(raw).filter(([key, value]) => allowed.includes(key)) );

इस फिडेल में प्रदर्शन ...

Comments

विल्ट, आपका दूसरा दृष्टिकोण पिछले साल प्रदान किए गए इस जवाब का एक सटीक डुप्लिकेट है: stackoverflow.com/a/56081419/5522000

— कला श्मिट

@ArtSchmidt आपकी टिप्पणी के लिए धन्यवाद: एक लंबी सूची में शामिल है। मैं इसके बजाय उस उत्तर का उल्लेख करूंगा।

— विल्ट

Answer 19

ठीक है, इस बारे में कैसे:

const myData = {
  item1: { key: 'sdfd', value:'sdfd' },
  item2: { key: 'sdfd', value:'sdfd' },
  item3: { key: 'sdfd', value:'sdfd' }
};

function filteredObject(obj, filter) {
  if(!Array.isArray(filter)) {
   filter = [filter.toString()];
  }
  const newObj = {};
  for(i in obj) {
    if(!filter.includes(i)) {
      newObj[i] = obj[i];
    }
  }
  return newObj;
}

और इसे इस तरह से कॉल करें:

filteredObject(myData, ['item2']); //{item1: { key: 'sdfd', value:'sdfd' }, item3: { key: 'sdfd', value:'sdfd' }}

Answer 20

यह फ़ंक्शन कुंजियों की सूची के आधार पर किसी ऑब्जेक्ट को फ़िल्टर करेगा, पिछले उत्तर की तुलना में अधिक कुशल है क्योंकि इसमें कॉल कम करने से पहले Array.filter का उपयोग नहीं करना पड़ता है। इसलिए इसका O (n) O के विपरीत (n + फ़िल्टर्ड)

function filterObjectByKeys (object, keys) {
  return Object.keys(object).reduce((accum, key) => {
    if (keys.includes(key)) {
      return { ...accum, [key]: object[key] }
    } else {
      return accum
    }
  }, {})
}

Answer 21

लूप के दौरान, कुछ भी नहीं लौटाते हैं जब कुछ गुण / कुंजी सामने आते हैं और बाकी के साथ जारी रहते हैं:

const loop = product =>
Object.keys(product).map(key => {
    if (key === "_id" || key === "__v") {
        return; 
    }
    return (
        <ul className="list-group">
            <li>
                {product[key]}
                <span>
                    {key}
                </span>
            </li>
        </ul>
    );
});

Answer 22

मुझे आश्चर्य है कि कैसे किसी ने अभी तक यह सुझाव नहीं दिया है। यह सुपर क्लीन है और बहुत स्पष्ट है कि आप कौन सी कुंजी रखना चाहते हैं।

const unfilteredObj = {a: ..., b:..., c:..., x:..., y:...}

const filterObject = ({a,b,c}) => ({a,b,c})
const filteredObject = filterObject(unfilteredObject)

या यदि आप एक गंदा एक लाइनर चाहते हैं:

const unfilteredObj = {a: ..., b:..., c:..., x:..., y:...}

const filteredObject = (({a,b,c})=>({a,b,c}))(unfilteredObject);

Comments

यह विधि मूल सरणी में मौजूद कुंजी को नहीं जोड़ेगी। समस्या हो सकती है या नहीं, यह कम से कम बताया जाना चाहिए।

— पोंचिट्टो

Answer 23

एक अन्य दृष्टिकोण के Array.prototype.forEach()रूप में उपयोग किया जाएगा

const raw = {
  item1: {
    key: 'sdfd',
    value: 'sdfd'
  },
  item2: {
    key: 'sdfd',
    value: 'sdfd'
  },
  item3: {
    key: 'sdfd',
    value: 'sdfd'
  }
};

const allowed = ['item1', 'item3', 'lll'];

var finalObj = {};
allowed.forEach(allowedVal => {
  if (raw[allowedVal])
    finalObj[allowedVal] = raw[allowedVal]
})
console.log(finalObj)

इसमें केवल उन कुंजियों के मान शामिल हैं जो कच्चे डेटा में उपलब्ध हैं और इस प्रकार किसी भी जंक डेटा को जोड़ने से रोकते हैं।

Answer 24

यह मेरा समाधान होगा:

const filterObject = (obj, condition) => {
    const filteredObj = {};
    Object.keys(obj).map(key => {
      if (condition(key)) {
        dataFiltered[key] = obj[key];
      }
    });
  return filteredObj;
}