लॉश: ऑब्जेक्ट के लिए मैपिंग सरणी

Question

क्या इसे लेने के लिए एक अंतर्निहित लॉश समारोह है:

var params = [
    { name: 'foo', input: 'bar' },
    { name: 'baz', input: 'zle' }
];

और यह उत्पादन:

var output = {
    foo: 'bar',
    baz: 'zle'
};

अभी मैं सिर्फ उपयोग कर रहा हूं Array.prototype.reduce():

function toHash(array, keyName, valueName) {
    return array.reduce(function(dictionary, next) {
        dictionary[next[keyName]] = next[valueName];
        return dictionary;
    }, {});
}

toHash(params, 'name', 'input');

आश्चर्य है कि अगर कोई लॉकेट शॉर्ट-कट है।

Answer 1

एक और तरीका है, जो रकबा 4.17.2 है

_.chain(params)
    .keyBy('name')
    .mapValues('input')
    .value();

या

_.mapValues(_.keyBy(params, 'name'), 'input')

या के साथ _.reduce

_.reduce(
    params,
    (acc, { name, input }) => ({ ...acc, [name]: input }),
    {}
)

Comments

@ एरिकोस _.keyByपूरे एरे को एक ऑब्जेक्ट में बदल देगा, जबकि सवाल ज्यादातर एरे में प्रत्येक ऑब्जेक्ट से एक आइटम के रूप में कुंजी और एक अन्य आइटम के मूल्य के रूप में होता है। यदि _.keyByउपयोग किया जाता है, तो सभी मूल्य ऑब्जेक्ट होंगे।

— मुस्तफा एहसान अलोकोज़े

धन्यवाद @MustafaEhsanAlokozay तुम सही हो, वह जवाब सही सही काम नहीं करता है। मैं अपनी टिप्पणी हटा दूंगा क्योंकि यह मददगार नहीं है। यह आपकी टिप्पणी को अजीब लग सकता है, लेकिन इससे बेहतर है कि मेरी गलत टिप्पणी किसी भी समय तक बनी रहे।

— १

Answer 2

आप आसानी से किसी ऑब्जेक्ट को एक सरणी में परिवर्तित करने के लिए _.keyBy का उपयोग कर रहे होंगे।

यहां डॉक्स

नीचे उपयोग उदाहरण:

var params = [
    { name: 'foo', input: 'bar' },
    { name: 'baz', input: 'zle' }
];
console.log(_.keyBy(params, 'name'));

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

यदि आवश्यक हो, तो आप सटीक वांछित परिणाम प्राप्त करने के लिए _.keyBy का उपयोग करने के बाद _.keyBy या ऑब्जेक्ट का उपयोग करने से पहले सरणी में हेरफेर कर सकते हैं।

Comments

स्टैसोवालस द्वारा सबसे अधिक मतदान के उत्तर को समझने के लिए इसे देखें।

— रोमन सूसी

यह एक अच्छा जवाब है, लेकिन यह सवाल का जवाब नहीं है । मूल्य वस्तुओं नहीं होना चाहिए तार होना चाहिए।

— डेम पिलाफियन

Answer 3

हाँ, यह यहाँ है , का उपयोग कर_.reduce

var params = [
    { name: 'foo', input: 'bar' },
    { name: 'baz', input: 'zle' }
];

_.reduce(params , function(obj,param) {
 obj[param.name] = param.input
 return obj;
}, {});

Comments

फिर भी reduce()एक और उपयोग के मामले में झपट्टा। इसे करने का स्मार्ट तरीका!

— डैन

किसी को भी इस के प्रकार संस्करण मिला है?

— mr.bjerre

वास्तविकता यह है कि गणितीय रूप से सच है कि आप कम / इंजेक्शन का उपयोग करके वस्तुतः किसी भी पुनरावृत्ति कार्रवाई को लागू कर सकते हैं, क्योंकि कम एक सूची में आइसोमोर्फिक है। हालांकि, यह लचीलापन पठनीयता में एक मूल्य के साथ आता है। _.reduceतब तक उपयोग न करें जब तक कि आप जो करना चाह रहे हैं उसे ठीक से व्यक्त न करें : यह किसी अन्य मामले में कोड के बिंदु को महत्वपूर्ण रूप से अस्पष्ट करता है। मैं व्यक्तिगत रूप _.zipObjectसे @djechlin द्वारा समाधान पसंद कर रहा हूं - यह विफल, _.keyBy/ _.mapValuesदृष्टिकोण।

— रॉबर्ट फिशर

Answer 4

यह Object.assign के लिए एक नौकरी की तरह लगता है:

const output = Object.assign({}, ...params.map(p => ({[p.name]: p.input})));

ओपी के समान एक फ़ंक्शन के रूप में लपेटने के लिए संपादित, यह होगा:

const toHash = (array, keyName, valueName) => 
    Object.assign({}, ...array.map(o => ({[o[keyName]]: o[valueName]})));

(बेन स्टीवर्ड के लिए धन्यवाद, अच्छी सोच ...)

Comments

हो सकता है कि एक पैरेंट फ़ंक्शन में लपेटें ताकि उपयोगकर्ता यह निर्धारित कर सके कि उन्हें किस तरह से पास करके उपयोग किया जाएगा, जैसे ओपी के पास था।

— बेन स्टीवर्ड

Answer 5

आप ऐरे कम विधि और ES6 डिस्ट्रक्ट्यूरिंग के साथ एक लाइनर जावास्क्रिप्ट का उपयोग कर सकते हैं ।

arr.reduce((map, { name, input }) => ({ ...map, [name]: input }), {});

Comments

दुर्भाग्य से, यह O (n ^ 2) है।

— jimrandomh

Answer 6

यह संभवतः आप की तुलना में अधिक क्रिया है, लेकिन आप थोड़ा जटिल ऑपरेशन के लिए पूछ रहे हैं ताकि वास्तविक कोड शामिल हो सके (डरावनी)।

मेरी सिफारिश, zipObjectजो बहुत तार्किक है:

_.zipObject(_.map(params, 'name'), _.map(params, 'input'));

एक और विकल्प, अधिक हैक, का उपयोग कर fromPairs:

_.fromPairs(_.map(params, function(val) { return [val['name'], val['input']));

अनाम फ़ंक्शन हैकिंग दिखाता है - मुझे विश्वास नहीं है कि जेएस वस्तु पुनरावृत्ति में तत्वों के आदेश की गारंटी देता है, इसलिए कॉलिंग .values()नहीं करेगा।

Comments

मैं उपयोग करने के बारे में कुछ भी नहीं देख सकता fromPairs, और कॉलिंग values()वास्तव में नहीं करेगा। कम से कम पठनीयता के दृष्टिकोण से।

— x-yuri

Answer 7

एक अन्य तरीका

जोड़े बनाना, और फिर या तो एक वस्तु का निर्माण या ES6 Mapआसानी से

_(params).map(v=>[v.name, v.input]).fromPairs().value()

या

_.fromPairs(params.map(v=>[v.name, v.input]))

यहाँ एक कार्य उदाहरण है

var params = [
    { name: 'foo', input: 'bar' },
    { name: 'baz', input: 'zle' }
];

var obj = _(params).map(v=>[v.name, v.input]).fromPairs().value();

console.log(obj);

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

Comments

: इस समाधान का अच्छा हिस्सा है कि यह भी सादे ES में संभव है हैObject.fromEntries(params.map(v => [v.name, v.input]))

— fregante

@fregante, Chrome 73+ केवल caniuse.com/?search=fromEntries

— d9k

Answer 8

यह भी इस तरह किसी भी दर्ज समारोह का उपयोग किए बिना हल कर सकते हैं:

let paramsVal = [
    { name: 'foo', input: 'bar' },
    { name: 'baz', input: 'zle' }
];
let output = {};

paramsVal.forEach(({name, input})=>{
  output[name] = input;
})


console.log(output);