लॉश के साथ सरणी के लिए वस्तु बदलना

Question

कैसे मैं एक बड़ी बदल सकता है objectके लिए arraylodash साथ?

var obj = {
  22: {name:"John", id:22, friends:[5,31,55], works:{books:[], films:[],}
  12: {name:"Ivan", id:12, friends:[2,44,12], works:{books:[], films:[],}
}

// transform to 
var arr = [{name:"John", id:22...},{name:"Ivan", id:12...}]

Comments

@ मृत्युंजय हां क्योंकि डॉक्स में लाइब्रेरी का इतना बड़ा अवलोकन है ... नहीं। यह सिर्फ कार्यों की एक विस्तृत सूची है और हर एक के माध्यम से जा रहा है अगर वहाँ एक नहीं है समय की बर्बादी साबित कर सकता है। सवाल एक निष्पक्ष है।

— एपिरोक्स

Answer 1

तुम कर सकते हो

var arr = _.values(obj);

प्रलेखन के लिए देखें यहाँ ।

Comments

यदि आप संपत्ति के रूप में कुंजी को संरक्षित करना चाहते हैं तो क्या होगा? (इस उदाहरण में, यदि idसंपत्ति मौजूद नहीं थी और आप प्रत्येक वस्तु की कुंजी के आधार पर इसे बनाना चाहते थे।

— माइकल लिकोरी

आप ऐसा कुछ कर सकते हैं:var arr = _.values(_.mapKeys(obj, function(value, key) { value.id = key; return value; }));

— डैनियल श्मिट

@DanielSchmidt मुझे यकीन नहीं है कि मैंने क्या गलत किया लेकिन उस नमूने ने मेरे लिए केवल 1 पंक्ति लौटा दी। :( तो मैंने जो किया वह मैन्युअल रूप से returnइस तरह की एक सरणी के लिए मूल्य को धक्का है : const divisionsList = []; _.mapKeys(divisions, (value, key) => { divisionsList[key] = value; });मैं इस दृष्टिकोण में सुधार करने के लिए किसी भी टिप्पणी या सुझाव की सराहना करता हूं।

— जॉनीक्यू

@ जॉनी क्यू मुझे लगता है कि आपको इसके बजाय मैपवैल्यू का उपयोग करने की आवश्यकता होगीconst toArrayWithKey = (obj, keyAs) => _.values(_.mapValues(obj, (value, key) => { value[keyAs] = key; return value; }));

— 19:

@orjan हां, मुझे वास्तव में यह पता लगा, बस अपडेट करना भूल गया। उसके लिये आपका धन्यवाद।

— जॉनी क्यू

Answer 2

_.toArray(obj);

आउटपुट के रूप में:

[
  {
    "name": "Ivan",
    "id": 12,
    "friends": [
      2,
      44,
      12
    ],
    "works": {
      "books": [],
      "films": []
    }
  },
  {
    "name": "John",
    "id": 22,
    "friends": [
      5,
      31,
      55
    ],
    "works": {
      "books": [],
      "films": []
    }
  }
]"

Comments

_.toArray () ठीक @jivings

— सैयद ज़ैन अली

केवल एक अच्छे विकल्प को पाने के लिए, लेकिन toArrayयदि आवश्यक हो तो चाबी को संरक्षित करने का कोई तरीका नहीं है।

— कौशिक चटर्जी

Answer 3

एक आधुनिक देशी समाधान अगर किसी को दिलचस्पी है:

const arr = Object.keys(obj).map(key => ({ key, value: obj[key] }));

या (IE नहीं):

const arr = Object.entries(obj).map(([key, value]) => ({ key, value }));

Comments

क्यों नहींObject.keys(obj).map(key=>({key,value: obj[key]}))

— कौशिक चटर्जी

मुझे लगता है कि यह भी उपयोगकर्ता दर्ज नहीं है, अच्छी तरह से किया सर!

— हंग्रीपिपो

@Dominic अब आपने अपना पूरा उत्तर बदल दिया और मेरी टिप्पणी से लिया, यहां तक ​​कि एक उल्लेख के बिना (आपने इसे संपादित किया)। शाबाश ter 😁😁

— कौशिक चटर्जी

@KoushikChatterjee ने इसे वापस जोड़ा

— डोमिनिक

क्या यह अधिक सहायक होगा? const arr = Object.keys(obj).map(id => ({ id, ...obj[id] })); यह पूरी वस्तु को लौटाए गए डेटा नं में लाएगा? (मूल आईडी के बाद से 'आईडी' का उपयोग कर आईडी कुंजी के रूप में अपनी कुंजी को स्टोर करना चाहता था)

— zabaat

Answer 4

मेरे लिए, यह काम किया:

_.map(_.toPairs(data), d => _.fromPairs([d]));

यह बदलता है

{"a":"b", "c":"d", "e":"f"} 

में

[{"a":"b"}, {"c":"d"}, {"e":"f"}]

Comments

मुझे एक वस्तु को एक एरे में बदलने की ज़रूरत थी, इस तरह से कि मूल वस्तु का प्रत्येक कुंजी / मान सरणी में एक {key: value} -object होगा। _.toPairs (डेटा) ऑब्जेक्ट {"a": "b", "c": "d", "e": "f"} लेता है और इसे सरणियों की एक सरणी के रूप में लौटाता है जैसे [["a": " b "], [" c ":" d "], [" e ":" f "]]। _.fromPairs विपरीत करता है, यह 2 तत्वों के साथ एक सरणी लेता है: ["a", "b"] और इसे एक वस्तु के रूप में लौटाता है: {"a": "b"}। _.Map का उपयोग करते हुए मैंने सरणी पर पुनरावृत्त किया है, यदि _.toPairs द्वारा बनाई गई सरणियों को _.fromPairs की सहायता से ऑब्जेक्ट की एक सरणी में बदलने के लिए।

— 18

मुझे खुशी है कि मैंने इसे देखने के लिए नीचे स्क्रॉल किया। आपके समाधान ने मेरे लिए काम किया! धन्यवाद!

— Wale

@NoNine आपको किसी सरणी (सरणी) पर मानचित्र लागू करने की आवश्यकता नहीं है, आप इसे सीधे इनपुट ऑब्जेक्ट पर लागू कर सकते हैं, और प्रत्येक कुंजी मान जोड़ी _.map(data, (v,k)=>({[k]: v}))को विवरण के लिए मेरा उत्तर देख सकते हैं। _.toPairsऔर _fromPairsयहाँ अतिरिक्त और अनावश्यक है।

— कौशिक चटर्जी

यह वह नहीं है जो सवाल का मतलब है। क्योंकि परिणाम का उपयोग करने के लिए यह थोड़ा अलग है क्योंकि प्रत्येक प्रविष्टि में एक कुंजी होती है (जिसे आप जानते हैं) और फिर से आपको प्रत्येक अलग प्रविष्टि के लिए कुछ तर्क (जैसे Object.keys या Object.values) से गुजरने की आवश्यकता होती है ताकि मूल्य प्राप्त हो सके प्रत्येक, अगर खिलौना चाबियों को संरक्षित करना चाहता है तो आप वस्तुओं की एक सरणी बना सकते हैं जो कि स्ट्रेचर जैसी हैं[{key: 'someKey', val: 'The value'}, {....},...]

— कौशिक चटर्जी

Answer 5

आपके द्वारा किए गए परिणाम को प्राप्त करने के लिए कुछ तरीके हैं। उन्हें श्रेणियों में विभाजित करें:

ES6 मान केवल :

इसके लिए मुख्य विधि Object.values ​​है । लेकिन Object.keys और Array.map का उपयोग करके आप अपेक्षित परिणाम प्राप्त कर सकते हैं:

Object.values(obj)
Object.keys(obj).map(k => obj[k])

var obj = {
  A: {
    name: "John"
  },
  B: {
    name: "Ivan"
  }
}

console.log('Object.values:', Object.values(obj))
console.log('Object.keys:', Object.keys(obj).map(k => obj[k]))

ES6 कुंजी और मूल्य :

मानचित्र और ES6 गतिशील / गणना गुणों का उपयोग करना और विनाश करना आप कुंजी को बनाए रख सकते हैं और नक्शे से एक वस्तु वापस कर सकते हैं।

Object.keys(obj).map(k => ({[k]: obj[k]}))
Object.entries(obj).map(([k,v]) => ({[k]:v}))

var obj = {
  A: {
    name: "John"
  },
  B: {
    name: "Ivan"
  }
}

console.log('Object.keys:', Object.keys(obj).map(k => ({
  [k]: obj[k]
})))
console.log('Object.entries:', Object.entries(obj).map(([k, v]) => ({
  [k]: v
})))

केवल लोधश मान :

इसके लिए डिज़ाइन की गई विधि _.valuesहालांकि "शॉर्टकट" जैसी है _.mapऔर उपयोगिता विधि _.toArrayभी है जो ऑब्जेक्ट से केवल मान वाले सरणी को लौटाएगी। _.mapहालांकि आप नोटेशन _.keysका उपयोग करके ऑब्जेक्ट से मान प्राप्त कर सकते हैं और प्राप्त कर सकते obj[key]हैं।

नोट: _.mapजब कोई वस्तु पास होती है तो उसके baseMapहैंडलर का उपयोग किया जाएगा जो मूल रूप forEachसे ऑब्जेक्ट गुणों पर होता है।

_.values(obj)
_.map(obj)
_.toArray(obj)
_.map(_.keys(obj), k => obj[k])

var obj = {
  A: {
    name: "John"
  },
  B: {
    name: "Ivan"
  }
}

console.log('values:', _.values(obj))
console.log('map:', _.map(obj))
console.log('toArray:', _.toArray(obj))
console.log('keys:', _.map(_.keys(obj), k => obj[k]))

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.10/lodash.min.js"></script>

लोडश की और मूल्य :

// Outputs an array with [[KEY, VALUE]]
_.entries(obj)
_.toPairs(obj)

// Outputs array with objects containing the keys and values
_.map(_.entries(obj), ([k,v]) => ({[k]:v}))
_.map(_.keys(obj), k => ({[k]: obj[k]}))
_.transform(obj, (r,c,k) => r.push({[k]:c}), [])
_.reduce(obj, (r,c,k) => (r.push({[k]:c}), r), [])

var obj = {
  A: {
    name: "John"
  },
  B: {
    name: "Ivan"
  }
}

// Outputs an array with [KEY, VALUE]
console.log('entries:', _.entries(obj))
console.log('toPairs:', _.toPairs(obj))

// Outputs array with objects containing the keys and values
console.log('entries:', _.map(_.entries(obj), ([k, v]) => ({
  [k]: v
})))
console.log('keys:', _.map(_.keys(obj), k => ({
  [k]: obj[k]
})))
console.log('transform:', _.transform(obj, (r, c, k) => r.push({
  [k]: c
}), []))
console.log('reduce:', _.reduce(obj, (r, c, k) => (r.push({
  [k]: c
}), r), []))

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.10/lodash.min.js"></script>

ध्यान दें कि उपरोक्त उदाहरणों में ES6 का उपयोग किया जाता है (तीर फ़ंक्शन और गतिशील गुण)। _.fromPairsयदि कोई वस्तु ES6 एक समस्या है, तो आप लॉश और अन्य तरीकों का उपयोग कर सकते हैं ।

Answer 6

यदि आप चाहते हैं कि कुंजी (इस मामले में आईडी) एक सरणी आइटम की एक संपत्ति के रूप में संरक्षित हो जो आप कर सकते हैं

const arr = _(obj) //wrap object so that you can chain lodash methods
            .mapValues((value, id)=>_.merge({}, value, {id})) //attach id to object
            .values() //get the values of the result
            .value() //unwrap array of objects

Answer 7

2017 अद्यतन: Object.values , lodash मूल्यों और toArray करते हैं। और चाबियाँ मानचित्र को संरक्षित करने और ऑपरेटर को अच्छा खेलने के लिए:

// import { toArray, map } from 'lodash'
const map = _.map

const input = {
  key: {
    value: 'value'
  }
}

const output = map(input, (value, key) => ({
  key,
  ...value
}))

console.log(output)
// >> [{key: 'key', value: 'value'}])

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.4/lodash.js"></script>

Answer 8

सादे जावास्क्रिप्ट के साथ सरणी में रूपांतरण वस्तु ( ECMAScript-2016) Object.values:

var obj = {
    22: {name:"John", id:22, friends:[5,31,55], works:{books:[], films:[]}},
    12: {name:"Ivan", id:12, friends:[2,44,12], works:{books:[], films:[]}}
}

var values = Object.values(obj)

console.log(values);

यदि आप भी चाबियों का उपयोग Object.entriesऔर Array#mapइस तरह रखना चाहते हैं :

var obj = {
    22: {name:"John", id:22, friends:[5,31,55], works:{books:[], films:[]}},
    12: {name:"Ivan", id:12, friends:[2,44,12], works:{books:[], films:[]}}
}

var values = Object.entries(obj).map(([k, v]) => ({[k]: v}))

console.log(values);

Answer 9

var arr = _.map(obj)

आप _.mapफ़ंक्शन (दोनों lodashका underscore) का उपयोग कर सकते हैं और साथ objectही, यह आंतरिक रूप से उस मामले को संभालेंगे, प्रत्येक मूल्य पर अपने iteratee के साथ पुनरावृति, और अंत में एक सरणी वापस आ जाएगी। वास्तव में, आप इसे बिना किसी पुनरावृत्ति (सिर्फ _.map(obj)) के उपयोग कर सकते हैं यदि आप केवल एक मान चाहते हैं। अच्छी बात यह है कि, यदि आपको बीच में किसी भी परिवर्तन की आवश्यकता है, तो आप इसे एक बार में कर सकते हैं।

उदाहरण:

var obj = {
    key1: {id: 1, name: 'A'},
    key2: {id: 2, name: 'B'},
    key3: {id: 3, name: 'C'}
};

var array1 = _.map(obj, v=>v);
console.log('Array 1: ', array1);

/*Actually you don't need the callback v=>v if you
are not transforming anything in between, v=>v is default*/

//SO simply you can use
var array2 = _.map(obj);
console.log('Array 2: ', array2);

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.4/lodash.js"></script>

हालाँकि, यदि आप अपनी वस्तु को रूपांतरित करना चाहते हैं तो आप ऐसा कर सकते हैं, भले ही आपको कुंजी को संरक्षित करने की आवश्यकता हो, आप _.map(obj, (v, k) => {...}अतिरिक्त तर्क के साथ ऐसा ( ) कर सकते हैं mapऔर फिर इसका उपयोग कैसे कर सकते हैं।

हालांकि इसके लिए अन्य वेनिला जेएस समाधान हैं (जैसा कि हर lodashसमाधान को शुद्ध जेएस संस्करण होना चाहिए) जैसे:

• Object.keysऔर फिर mapउन्हें मूल्यों के लिए
• Object.values (ES-2017 में)
• Object.entriesऔर फिर mapप्रत्येक कुंजी / मूल्य जोड़े (ES-2017 में)
• for...in लूप और मूल्यों को प्राप्त करने के लिए प्रत्येक कुंजी का उपयोग करें

और भी काफी। लेकिन जब से यह सवाल है lodash(और किसी को पहले से ही इसका इस्तेमाल कर रहे हैं) मान रहे हैं, तो आपको संस्करण के बारे में बहुत कुछ सोचने की ज़रूरत नहीं है, यदि वे नहीं मिलते हैं, तो तरीकों और समर्थन से निपटने में त्रुटि।

अन्य लॉश समाधान हैं _.values( जैसे विशिष्ट पोज के लिए अधिक पठनीय), या जोड़े प्राप्त करना और फिर नक्शा वगैरह । लेकिन यदि आपके कोड को लचीलेपन की आवश्यकता है, तो आप इसे भविष्य में अपडेट कर सकते हैं क्योंकि आपको keysमूल्यों को थोड़ा संरक्षित करने या बदलने की आवश्यकता है , तो सबसे अच्छा उपाय यह है _.mapकि आप इस उत्तर में एक एकल का उपयोग कर सकते हैं । पठनीयता के अनुसार यह उतना कठिन नहीं होगा।

Comments

अच्छा, बहुत सरल और सबसे संक्षिप्त।

— edencorbin

Answer 10

ऐरे की वस्तु

सभी उत्तरों में से मुझे लगता है कि यह सबसे अच्छा है:

let arr = Object.entries(obj).map(([key, val]) => ({ key, ...val }))

वह रूपांतरित करता है:

{
  a: { p: 1, q: 2},
  b: { p: 3, q: 4}
}

सेवा:

[
  { key: 'a', p: 1, q: 2 }, 
  { key: 'b', p: 3, q: 4 }
]

ऐरे से ऐतराज करना

वापस बदलने के लिए:

let obj = arr.reduce((obj, { key, ...val }) => { obj[key] = { ...val }; return obj; }, {})

मूल्य में कुंजी रखते हुए वापस बदलने के लिए:

let obj = arr.reduce((obj, { key, ...val }) => { obj[key] = { key, ...val }; return obj; }, {})

दे देंगे:

{
  a: { key: 'a', p: 1, q: 2 },
  b: { key: 'b', p: 3, q: 4 }
}

अंतिम उदाहरण के लिए आप लॉश का उपयोग कर सकते हैं _.keyBy(arr, 'key')या _.keyBy(arr, i => i.key)।

Answer 11

यदि आप ऑब्जेक्ट के कुछ कस्टम मैपिंग (जैसे मूल Array.prototyp.map) को एक सरणी में चाहते हैं, तो आप बस उपयोग कर सकते हैं _.forEach:

let myObject = {
  key1: "value1",
  key2: "value2",
  // ...
};

let myNewArray = [];

_.forEach(myObject, (value, key) => {
  myNewArray.push({
    someNewKey: key,
    someNewValue: value.toUpperCase() // just an example of new value based on original value
  });
});

// myNewArray => [{ someNewKey: key1, someNewValue: 'VALUE1' }, ... ];

देखें lodash_.forEach के डॉक https://lodash.com/docs/#forEach