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' }
 }

আমি এস 6 ব্যবহার করে এটি সম্পাদন করার জন্য একটি পরিষ্কার উপায় খুঁজছি, সুতরাং স্প্রেড অপারেটরগুলি আমার কাছে উপলব্ধ available

Comments

ES6 এর কোনও অবজেক্ট স্প্রেড অপারেটর নেই, এবং আপনার এখানে কোনওভাবেই প্রয়োজন নেই

— বার্গি

জাভাস্ক্রিপ্টের

— জনাথন এইচ

@ ড্যানডাসকলেস্কু তবে এই উত্তরটি ওএস যা বলেছে তা সম্পাদনের একটি ES6 উপায় দেয়, তাই না?

— জোনাথন এইচ

যদি আমি কোনও কী / মান দিয়ে ফিল্টার করতে চাই?

— 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 শুধুমাত্র অনুমোদিত বৈশিষ্ট্য সহ একটি নতুন অবজেক্ট তৈরি করতে।

এটি অনুমোদিত বৈশিষ্ট্যগুলির সাথে একটি অগভীর অনুলিপি তৈরি করবে (তবে সম্পত্তিগুলি সেগুলি অনুলিপি করবে না)।

আপনি বস্তুর স্প্রেড অপারেটরকে পরিবর্তন না করেই ধারাবাহিক অবজেক্ট তৈরি করতেও ব্যবহার করতে পারেন (এটি উল্লেখ করার জন্য rjerue ধন্যবাদ ):

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

ধন্যবাদ যে দুর্দান্ত কাজ করেছে। আমি 'ডিকনস্ট্রাকশন সিনট্যাক্স ব্যবহার করেও একটি পন্থা পেয়েছি। অর্থাৎ, const {ITEM1, ITEM3} কাঁচা const = newObject = {ITEM1, ITEM3}

— 29er

ডিকনস্ট্রাকশন (কেবল সূক্ষ্ম) কাজ করবে তবে খাঁটি সংকলন-কাল is আপনি এটিকে বৈশিষ্ট্যের গতিশীল তালিকা তৈরি করতে বা কোনও জটিল বিধি সরবরাহ করতে পারবেন না (উদাহরণস্বরূপ একটি লুপে বৈধতা কলব্যাকস সংযুক্ত থাকতে পারে)।

— ssube

আমি এটিকে যথেষ্ট ভোট দিতে পারি না! ফিল্টার ব্যবহার করার জন্য এবং লুপের জন্য একটি থেকে অন্য কোনও অবজেক্টটি কমিয়ে আনতে এবং তৈরির জন্য ভাল। এবং দুর্দান্ত যে আপনি অপরিবর্তনীয় এবং পরিবর্তনীয় সংস্করণগুলিকে স্পষ্টভাবে আলাদা করেছেন। +1

— সুকিমা

দ্রুত সতর্কতা: Array.prototype.includesES6 এর অংশ নয়। এটি ECMAScript 2016 (ES7) এ প্রবর্তিত হয়েছে।

— ভিনিত

: যদি আপনি একটি অপরিবর্তনীয় ভাবে কমাতে কাজ করতে চান, তাহলে আপনি রিটার্ন {কাঁচা [Key] ... obj, [Key]} সাথে ফাংশন বিষয়বস্তু প্রতিস্থাপন করতে পারে

— 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

" _একটি থ্রো অ্যাওয়েল ভ্যালু উপস্থাপন করে" এটি কোথায় আসে? আমি প্রথমবার এটি দেখতে

— পেয়েছি

আমি বিশ্বাস করি এটি জেএস সম্প্রদায় দ্বারা গৃহীত একটি কনভেনশন। একটি _হ'ল একটি বৈধ পরিবর্তনশীল নাম যা জেএসে ব্যবহার করা যেতে পারে তবে এটি যেহেতু বেশ নামহীন, তাই আপনি যদি অভিপ্রায় জানাতে আগ্রহী হন তবে সত্যই সেভাবে এটি ব্যবহার করা উচিত নয়। সুতরাং, আপনার কোনও যত্নশীল নয় এমন পরিবর্তনশীল বোঝানোর উপায় হিসাবে এটি গ্রহণ করা হয়েছে। এটি সম্পর্কে আরও আলোচনা এখানে রয়েছে: stackoverflow.com/questions/11406823/…

— রায়ান এইচ।

এই গৃহীত উত্তর তুলনায় অনেক tidier হয়,) Object.keys (সাথে একটি নতুন অ্যারে তৈরি করার ওভারহেড, এবং অ্যারের iterating এর ওভারহেড এড়াতে filterএবং reduce।

— এরিকসোক

@ ইহাবিব এতে কিছু যায় _আসে না, এটি কেবলমাত্র একটি পরিবর্তনশীল নাম, আপনি নিজের ইচ্ছামত যেকোন কিছুতে এটির নাম পরিবর্তন করতে পারেন

— ভিক

@ জেরাত আমি মনে করি না যে একটি সাধারণ সমাধানটি একটি তুচ্ছ ওয়ান-লাইনার হবে। তার জন্য, আমি লোড্যাশের omitফাংশনটি ব্যবহার করব : লড্যাশ ডকস / ডকস / ৪.১10.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

এটি উল্লেখ করা গুরুত্বপূর্ণ যে এর জন্য রানটাইমের সময় একটি অতিরিক্ত প্রকল্প নির্ভরতা ডাউনলোড করতে হবে।

— এস এস্টেভস

_.অমিট (আপত্তি, ["আইটেম 2"]) - লদ্যাশ.মিত লডাশ.পিকের বিপরীত

— আলেকজান্ডার

Answer 4

এমন কিছু যা আগে বলা হয়নি, তবে সাধারণ ES6 উত্তরের কয়েকটি উত্তর একত্রিত করার জন্য:

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

এটি অন্যের তুলনায় অনেক বেশি সহজ এবং পারফরম্যান্স সমাধান;)

— পোমেহ

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);সিনট্যাক্স ইস্যু

— আওল

এখানে বেশ কয়েকটি জিনিস ঘনীভূত রয়েছে: প্রথমে প্রথম কথাটি হল ফাংশনটির ঘোষণা। এটি একটি তীর ফাংশন (এটি একটি বস্তু নেয় এবং কোনও বস্তু ফেরত দেয়)। এটি ফাংশন (আপত্তি) হিসাবে একই জিনিস {রিটার্ন আপত্তি;}। দ্বিতীয় জিনিসটি হ'ল ES6 ভবিষ্যতের ধ্বংসাত্মক সুযোগ দেয়। আমার ফাংশন ঘোষণায় আমি আমার অবজেক্ট dest আইটেম 1, আইটেম 3 dest গঠন করি} এবং শেষ কথাটি হ'ল আমি নিজেই আমার ফাংশনটি প্রার্থনা করি। উদাহরণস্বরূপ আপনার সুযোগটি পরিচালনা করতে আপনি স্ব-অনুরোধ ফাংশনটি ব্যবহার করতে পারেন। তবে এখানে কেবল কোডটি ঘনীভূত করা ছিল। আমি আশা করি এটি পরিষ্কার হয়ে গেছে আমি যদি কিছু মিস করি তবে নির্দ্বিধায় আরও যুক্ত করুন।

— নভেম্বর

এটি পছন্দসই আধুনিক পদ্ধতির

— ইমো

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ছায়াবৃত্ত হয় কিন্তু এটি সবসময় একই ইনপুট Var স্থানটিকে; এই কারণেই এখানে এর ছায়া গোছানো হয়েছে, কারণ এটি একই the আহরণকারী ( 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 }। এছাড়াও, পরবর্তীকালে মোটেও প্রয়োজনীয় নয়, যেহেতু পরে আপনি সরাসরি ডামিওবিজে কাজ করতে পারেন।

— অ্যান্ডি

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 এর answeranswer ।

এখানে একটি পুনরায় ব্যবহারযোগ্য সংস্করণ।

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/References/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

এটি সম্পাদন করার জন্য অনেকগুলি উপায় রয়েছে। গৃহীত উত্তর একটি কী-ফিল্টার-কমাতে পদ্ধতি, যা সর্বাধিক performant নয় ব্যবহার করে।

পরিবর্তে, 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

---

^{ক। সাধারণ ব্যবহারের মামলার মানদণ্ডের জন্য jscreen দেখুন । ব্রাউজারগুলির উপর ভিত্তি করে ফলাফলগুলি পৃথক হবে।}

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

উইল্ট, আপনার দ্বিতীয় পন্থাটি গত বছরের সরবরাহ করা এই উত্তরের হুবহু প্রতিলিপি: স্ট্যাকওভারফ্লো.com

— আর্ট শ্মিড্ট

@ আর্টসচমিট আপনার মন্তব্যের জন্য আপনাকে ধন্যবাদ: দীর্ঘ তালিকায় এটি মিস করেছেন। পরিবর্তে আমি উত্তরটি উল্লেখ করব।

— উইল

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

এই ফাংশনটি কীগুলির তালিকার উপর ভিত্তি করে কোনও বস্তু ফিল্টার করবে, এটি আগের উত্তরগুলির চেয়ে বেশি দক্ষ কারণ কল কমানোর আগে অ্যারে.ফিল্টার ব্যবহার করতে হবে না। সুতরাং এর ও (এন) ও (এন + ফিল্টার) এর বিপরীতে

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;
}