जावास्क्रिप्ट: ऑब्जेक्ट का नाम बदलें

Question

क्या जावास्क्रिप्ट ऑब्जेक्ट में एक कुंजी का नाम बदलने का एक चतुर (यानी अनुकूलित) तरीका है?

एक गैर-अनुकूलित तरीका होगा:

o[ new_key ] = o[ old_key ];
delete o[ old_key ];

Comments

"अनुकूलित" से आपका क्या मतलब है? मुझे नहीं लगता कि इससे अधिक कोई भी पद मिल सकता है; कोई "नाम बदलें" अंतर्निहित कार्रवाई नहीं है।

— नुकीले

वह सब आपको मिल सकता है। मुझे अपने आवेदन में अन्य बातों की चिंता होगी। और btw, आप वस्तुओं के साथ काम कर रहे हैं, सरणियों नहीं। जावास्क्रिप्ट में (सख्त अर्थ में) कोई सहयोगी सरणियाँ नहीं हैं।

— फेलिक्स क्लिंग

@ जीन विंसेंट: क्या यह धीमा है?

— फेलिक्स क्लिंग

यह

— लिविंगस्टन सैमुअल

आपका संस्करण सफारी, नमूना परीक्षण मामले @ jsperf.com/livi-006

— लिविंगस्टन सैमुअल

Answer 1

ऐसा करने का सबसे पूर्ण (और सही) तरीका होगा, मेरा मानना ​​है:

if (old_key !== new_key) {
    Object.defineProperty(o, new_key,
        Object.getOwnPropertyDescriptor(o, old_key));
    delete o[old_key];
}

यह विधि यह सुनिश्चित करती है कि नामांकित संपत्ति मूल रूप से समान व्यवहार करती है ।

इसके अलावा, यह मुझे लगता है कि इसे एक फ़ंक्शन / विधि में लपेटने और इसे डालने की संभावना Object.prototypeआपके प्रश्न के संबंध में अप्रासंगिक है।

Comments

यह सभी गुणों को संरक्षित करने के वास्तविक प्लस के साथ एक अच्छा ईएस 5-एकमात्र समाधान है। तो यह "अनुकूलित" नहीं है, लेकिन ES5 पर निश्चित रूप से अधिक सटीक है।

— जीन विंसेंट

राइटिंग के प्रति कुछ संशय के साथ up_otings_wings_with_underscores की ओर बढ़ा, लेकिन निश्चित रूप से यह सवाल पूछने वाले व्यक्ति के कारण था। मेरे विचार में यह सही प्रतिक्रिया है।

— बेंट कार्डन

यदि यह मायने रखता है, तो मेरा मानना ​​है कि ES5 का यह विशेष उपयोग एक IE9 और नया समाधान है।

— स्कॉट स्टैफ़ोर्ड

मैं एक मान्यता जोड़ने का सुझाव देता हूं कि o.old_key मौजूद है। बदल रहा है: if (old_key !== new_key)करने के लिए: if (old_key !== new_key && o[old_key])

— जोस

Answer 2

आप एक फ़ंक्शन में काम लपेट सकते हैं और इसे Objectप्रोटोटाइप को असाइन कर सकते हैं । शायद कई नाम बदलने प्रवाह बनाने के लिए धाराप्रवाह इंटरफ़ेस शैली का उपयोग करें।

Object.prototype.renameProperty = function (oldName, newName) {
     // Do nothing if the names are the same
     if (oldName === newName) {
         return this;
     }
    // Check for the old property name to avoid a ReferenceError in strict mode.
    if (this.hasOwnProperty(oldName)) {
        this[newName] = this[oldName];
        delete this[oldName];
    }
    return this;
};

ECMAScript 5 विशिष्ट

काश सिंटैक्स यह जटिल नहीं होता, लेकिन निश्चित रूप से अधिक नियंत्रण होने पर अच्छा लगता है।

Object.defineProperty(
    Object.prototype, 
    'renameProperty',
    {
        writable : false, // Cannot alter this property
        enumerable : false, // Will not show up in a for-in loop.
        configurable : false, // Cannot be deleted via the delete operator
        value : function (oldName, newName) {
            // Do nothing if the names are the same
            if (oldName === newName) {
                return this;
            }
            // Check for the old property name to 
            // avoid a ReferenceError in strict mode.
            if (this.hasOwnProperty(oldName)) {
                this[newName] = this[oldName];
                delete this[oldName];
            }
            return this;
        }
    }
);

Comments

इसके बारे में @ChaosPandion को खेद है, लेकिन मैं बग रेज़्ड JS कोड से बहुत थक गया हूँ, मैं वर्तमान में सभी quirks के बारे में एक गाइड ( github.com/BonsaiDen/JavaScript-Garden ) लिख रहा हूं (अब आप जो भी तय किया गया है, सहित) इसने मुझे किसी प्रकार के रैंट मोड में डाल दिया होगा;) (अब -1 को हटा दिया गया है)

— इवो ​​वेटजेल

@ इवो - क्या आप बता सकते हैं कि आपको क्यों लगता है कि प्रोटोटाइप का विस्तार बुरा है? बच्चे को निकालने के लिए प्रोटोटाइप बनाए गए थे!

— चोसपांडियन

@ मैं- मैं सहमत हूं कि यह जोखिम भरा है, लेकिन ऐसा कुछ भी नहीं है जो मुझे प्रोटोटाइप को विस्तारित करने से रोक देगा अगर मुझे लगा कि यह अधिक अभिव्यंजक कोड को जन्म देगा। हालांकि मैं एक ECMAScript 5 मानसिकता से आ रहा हूं जहां आप एक संपत्ति को गैर-गणना योग्य के रूप में चिह्नित कर सकते हैं Object.defineProperty।

— ChaosPandion 16

@ इवो - अगर hasOwnPropertyसंपत्तियों की जांच के लिए और for ... inलूप के भीतर हमेशा उपयोग करने के लिए यह उचित अभ्यास है , तो अगर हम ऑब्जेक्ट का विस्तार करते हैं तो यह क्यों मायने रखता है?

— डेविड टैंग

यह कोड काम करता है, लेकिन चेतावनी यह है कि यदि नया कुंजी नाम पहले से मौजूद है, तो इसका मान ट्रूडेन से

— ब्रैंडन मिंटन

Answer 3

यदि आप अपने स्रोत ऑब्जेक्ट को म्यूट कर रहे हैं, तो ES6 इसे एक पंक्ति में कर सकता है।

delete Object.assign(o, {[newKey]: o[oldKey] })[oldKey];

या दो लाइनें यदि आप एक नई वस्तु बनाना चाहते हैं।

const newObject = {};
delete Object.assign(newObject, o, {[newKey]: o[oldKey] })[oldKey];

Comments

कोशिश करें: Object.assign (o, {newKey: o.oldKey}) हटाएं। OldKey; मेरे लिए अच्छी तरह से काम किया

— टिम

[]चारों ओर चौकोर कंस क्यों है newKey? समाधान वास्तव में इसके बिना काम करता है।

— सौम्य कांति

ठीक है - मुझे मेरा जवाब मिल गया। यह ES6 फीचर है। मेरे जैसे किसी और के लिए ठोकर खाई, यहाँ एक अच्छा जवाब है ।

— सौम्य कांति

यदि आपका चर नाम अधिक क्रियाशील था, तो यह उत्तर अधिक मजबूत होगा।

— लोक्रावरर

शायद? क्षमा करें, मैं भूल गया कि मैं अपनी प्रारंभिक टिप्पणी के साथ क्या सोच रहा था।

— लोक्रेलर

Answer 4

यदि किसी को गुणों की सूची का नाम बदलने की आवश्यकता है:

function renameKeys(obj, newKeys) {
  const keyValues = Object.keys(obj).map(key => {
    const newKey = newKeys[key] || key;
    return { [newKey]: obj[key] };
  });
  return Object.assign({}, ...keyValues);
}

उपयोग:

const obj = { a: "1", b: "2" };
const newKeys = { a: "A", c: "C" };
const renamedObj = renameKeys(obj, newKeys);
console.log(renamedObj);
// {A:"1", b:"2"}

Comments

यह जवाब स्वीकार किया जाना चाहिए, मेरे उपयोग के मामले के लिए बहुत अच्छा काम किया। मुझे एक एपीआई प्रतिक्रिया को रूपांतरित करना था जो अनावश्यक स्ट्रिंग के साथ देश के नाम का उपसर्ग कर रही थी। ऑब्जेक्ट को कुंजियों के सरणी में बदल दिया और प्रत्येक कुंजी के माध्यम से विकल्प विधि के साथ मैप किया गया और मूल कुंजी द्वारा अनुक्रमित नई कुंजी और मूल्य के साथ एक नई वस्तु लौटा दी

— अकिन हवन

यह अच्छा है क्योंकि यह पुरानी कुंजी को नहीं हटाता है। पुरानी कुंजी को हटाने से कुंजी पूरी तरह से ऑब्जेक्ट से हट जाएगी यदि कुंजी का नाम नहीं बदला है। मेरे उदाहरण में, मैं परिवर्तित my_object_propertyकर रहा था myObjectProperty, हालांकि, अगर मेरी संपत्ति एकल-शब्द थी, तो कुंजी को हटा दिया गया था। +1

— ब्लूप्रिंट

Answer 5

मैं सिर्फ ES6(ES2015)रास्ते का उपयोग करना चाहूंगा !

हम समय के साथ रखने की जरूरत है!

const old_obj = {
    k1: `111`,
    k2: `222`,
    k3: `333`
};
console.log(`old_obj =\n`, old_obj);
// {k1: "111", k2: "222", k3: "333"}


/**
 * @author xgqfrms
 * @description ES6 ...spread & Destructuring Assignment
 */

const {
    k1: kA, 
    k2: kB, 
    k3: kC,
} = {...old_obj}

console.log(`kA = ${kA},`, `kB = ${kB},`, `kC = ${kC}\n`);
// kA = 111, kB = 222, kC = 333

const new_obj = Object.assign(
    {},
    {
        kA,
        kB,
        kC
    }
);

console.log(`new_obj =\n`, new_obj);
// {kA: "111", kB: "222", kC: "333"}

Comments

इस एक को क्लीनर समाधान के रूप में मिला जब आप एक विकृत वस्तु को एक नए पुनर्गठन में बदलना चाहते हैं।

— NJInamdar

अच्छा है, लेकिन मुझे लगता है कि const {k1: kA, k2: kB, k3: kC,} = old_obj पर्याप्त है? फैलने की कोई आवश्यकता नहीं है (जब तक कि आप old_obj की एक प्रति नहीं चाहते हैं)।

— हंस

@ हाँ, हाँ आप सही हैं। लेकिन इस स्थिति में, मैं कुछ चाबियों का नाम बदलना चाहता हूं, इसलिए मुझे उन्हें फैलाना चाहिए।

— xgqfrms-gildata

इसके लिए बहुत अधिक कोड की आवश्यकता होती है, कम कुशल होगा, और एक नई वस्तु बनाता है। एक संपत्ति का नामकरण का अर्थ है वस्तु को बदलना। नया हमेशा बेहतर नहीं होता है।

— जीन विंसेंट

Answer 6

यदि आप अपने डेटा को म्यूट नहीं करना चाहते हैं, तो इस फ़ंक्शन पर विचार करें ...

renameProp = (oldProp, newProp, {[oldProp]:old, ...others}) => ({
    [newProp]: old,
    ...others
})

Yazeed Bzadough https://medium.com/front-end-hacking/immutably-rename-object-keys-in-javascript-5f6353c7b6dd द्वारा गहन व्याख्या

---

Comments

यह सबसे अच्छा उपाय है। लेकिन प्रसार ऑपरेटर के बारे में कुछ समझने की जरूरत है।

— फ्रेंको फोंग

Answer 7

यहाँ अधिकांश उत्तर JS Object की-वैल्यू पेयर ऑर्डर को बनाए रखने में विफल हैं। यदि आपके पास स्क्रीन पर ऑब्जेक्ट कुंजी-मूल्य जोड़े का एक रूप है जिसे आप संशोधित करना चाहते हैं, उदाहरण के लिए, ऑब्जेक्ट प्रविष्टियों के क्रम को संरक्षित करना महत्वपूर्ण है।

JS ऑब्जेक्ट के माध्यम से लूपिंग का ES6 तरीका और नई जोड़ी के साथ की-वैल्यू पेयर को बदलने के साथ संशोधित कुंजी का नाम कुछ इस प्रकार होगा:

let newWordsObject = {};

Object.keys(oldObject).forEach(key => {
  if (key === oldKey) {
    let newPair = { [newKey]: oldObject[oldKey] };
    newWordsObject = { ...newWordsObject, ...newPair }
  } else {
    newWordsObject = { ...newWordsObject, [key]: oldObject[key] }
  }
});

समाधान पुराने के स्थान पर नई प्रविष्टि जोड़कर प्रविष्टियों के क्रम को संरक्षित करता है।

Comments

बिल्कुल सही, यह वही है जो मुझे चाहिए

— p0358

Answer 8

आप लॉश को आजमा सकते हैं _.mapKeys।

var user = {
  name: "Andrew",
  id: 25,
  reported: false
};

var renamed = _.mapKeys(user, function(value, key) {
  return key + "_" + user.id;
});

console.log(renamed);

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

Comments

इस समाधान ने मेरे लिए काम किया, लेकिन हमेशा एक 'कुंजी' चर वापस करने के लिए ध्यान दें। उदाहरण: अगर (कुंजी === 'ओल्डके') {रिटर्न 'न्यूकेय'; } वापसी कुंजी;

— टॉमोमीहा

Answer 9

ऑब्जेक्ट डिस्ट्रक्टिंग और प्रसार ऑपरेटर का उपयोग करके भिन्नता:

    const old_obj = {
        k1: `111`,
        k2: `222`,
        k3: `333`
    };


// destructuring, with renaming. The variable 'rest' will hold those values not assigned to kA, kB, or kC.
    const {
        k1: kA, 
        k2: kB, 
        k3: kC,
        ...rest
    } = old_obj;


// now create a new object, with the renamed properties kA, kB, kC; 
// spread the remaining original properties in the 'rest' variable
const newObj = {kA, kB, kC, ...rest};

Comments

शायद आप समझा सकते हैं कि यह क्या कर रहा है और यह कैसे काम करता है?

— जॉन एडम्स

@Jeffower क्या अगर यह वस्तुओं की एक सरणी था? क्या मुझे फोरच करना है या क्या मैं स्प्रेड के साथ भी कर सकता हूं?

— user3808307

@ user3808307 आप किसी सरणी में और ऑब्जेक्ट को सरणी में फैला सकते हैं।

— जेफ लोरी

Answer 10

व्यक्तिगत रूप से, अतिरिक्त भारी प्लगइन्स और पहियों को लागू किए बिना ऑब्जेक्ट में नाम बदलने का सबसे प्रभावी तरीका:

var str = JSON.stringify(object);
str = str.replace(/oldKey/g, 'newKey');
str = str.replace(/oldKey2/g, 'newKey2');

object = JSON.parse(str);

आप इसे भी लपेट सकते हैं try-catchयदि आपकी वस्तु में अमान्य संरचना है। अच्छी तरह से काम :)

Comments

ओह! var ऑब्जेक्ट = {b: '123', 'c': 'bbb'}; var str = JSON.stringify (ऑब्जेक्ट); str = str.replace (/ b / g, 'newKey'); str = str.replace (/ c / g, 'newKey2'); ऑब्जेक्ट = JSON.parse (str);

— BlondinkaBrain

यह गति के लिए तुलना कैसे करता है?

— मिश्रण

इसके अलावा डेटावल्स में कहीं न कहीं एक संभावित मुद्दे पर चलता है जो पुराने कुंजी नाम के समान स्ट्रिंग है।

— मिक्स

"पूरी तरह से" की कुछ परिभाषाओं के लिए "पूरी तरह से काम करता है"। नाम बदलने की कोशिश करें 'a'में { a: 1, aa: 2, aaa: 3}या मूल्यों है कि तार या नंबर या बूलियन्स से ज्यादा कुछ भी कर रहे हैं के साथ एक वस्तु का नाम बदलने का प्रयास करें, या वृत्तीय संदर्भ के साथ प्रयास करें।

— आरपी

यदि ऑब्जेक्ट में फ़ंक्शन या दिनांक ऑब्जेक्ट शामिल है, तो यह काम नहीं करेगा

— çsan

Answer 11

प्रत्येक कुंजी में उपसर्ग जोड़ने के लिए:

const obj = {foo: 'bar'}

const altObj = Object.fromEntries(
  Object.entries(obj).map(([key, value]) => 
    // Modify key here
    [`x-${key}`, value]
  )
)

// altObj = {'x-foo': 'bar'}

Answer 12

मैं ऐसा कुछ करूँगा:

function renameKeys(dict, keyMap) {
  return _.reduce(dict, function(newDict, val, oldKey) {
    var newKey = keyMap[oldKey] || oldKey
    newDict[newKey] = val 
    return newDict
  }, {})
}

Comments

आपके समाधान का एक अद्यतन संस्करण बनाया गया है, जो यहां स्थिर कुंजी को 'अपरिभाषित' में परिवर्तित नहीं करता है: gist.github.com/diasdavid/f8997fb0bdf4dc1c3543 फिर भी, यह अभी भी JSON के कई स्तरों पर चाबियाँ रीमैप करने के लिए इच्छुक नहीं है। ऑब्जेक्ट (नेस्टेड कुंजियों को फिर से बनाना), विचार?

— डेविड डायस

Answer 13

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

var myObj = {
    field1: theirObj.FIELD1, 
    field2: theirObj.FIELD2,
    (etc)
}

बेशक, मैं यहाँ सभी तरह की धारणाएँ बना रहा हूँ, जो शायद सच न हों। यदि यह आपके लिए लागू नहीं होता है, या यदि यह बहुत धीमा है (क्या यह है? मैंने परीक्षण नहीं किया है, लेकिन मुझे लगता है कि अंतर छोटे हो जाते हैं क्योंकि खेतों की संख्या बढ़ जाती है), कृपया इस सब को अनदेखा करें :)

यदि आप ऐसा नहीं करना चाहते हैं, और आपको केवल विशिष्ट ब्राउज़रों का समर्थन करना है, तो आप नए गेटर्स का उपयोग "अपरकेस (फ़ील्ड)" पर लौटने के लिए भी कर सकते हैं: http://robertnyman.com/2009/05/28 देखें अधिक जानकारी के लिए उस पृष्ठ पर / geters-and-setters-with-javascript-code-नमूने-and-demos / और लिंक।

संपादित करें:

अविश्वसनीय रूप से, यह भी लगभग दो बार तेज है, कम से कम मेरे FF3.5 पर काम पर। देखें: http://jsperf.com/spiny001

Comments

आपके प्रयासों के लिए आपका बहुत-बहुत धन्यवाद लेकिन उपयोग की स्थिति स्थैतिक वस्तुओं में हेरफेर नहीं करती है क्योंकि उनकी संरचना और गहराई अनकाउन्ट है। इसलिए यदि संभव हो तो मैं प्रश्न के मूल दायरे से चिपकना चाहूंगा।

— जीन विंसेंट

Answer 14

हालांकि यह कुंजी का नाम बदलने के लिए एक बेहतर समाधान नहीं देता है, लेकिन यह एक त्वरित और आसान ईएस 6 तरीका प्रदान करता है जो किसी ऑब्जेक्ट में सभी कुंजी का नाम बदलने के लिए होता है, जिसमें वे शामिल नहीं होते हैं।

let b = {a: ["1"], b:["2"]};
Object.keys(b).map(id => {
  b[`root_${id}`] = [...b[id]];
  delete b[id];
});
console.log(b);

Comments

यह कोड कैसे काम करता है यह समझाने के लिए कृपया संपादन लिंक का उपयोग करें और केवल कोड न दें, क्योंकि स्पष्टीकरण में भविष्य के पाठकों की मदद करने की अधिक संभावना है। इसका जवाब भी देखें । स्रोत

— जेड फॉक्स

मैं सहमत हूँ। यह विशेष रूप से प्रश्न का उत्तर नहीं देता है लेकिन इसने मुझे ऑब्जेक्ट में सभी कुंजियों के नाम बदलने के समाधान के रूप में काम करने में मदद की। शायद मैं इस विषय को याद कर रहा हूँ ..

— ट्यूडर मोरार

Answer 15

इस पृष्ठ पर सूचीबद्ध कुछ समाधानों के कुछ दुष्प्रभाव हैं:

1. ऑब्जेक्ट में कुंजी की स्थिति को प्रभावित करें, इसे नीचे से जोड़ दें (यदि यह आपके लिए मायने रखता है)
2. IE9 + में काम नहीं करेगा (फिर, अगर यह आपके लिए मायने रखता है)

यहां एक समाधान है जो कुंजी की स्थिति को उसी स्थान पर रखता है और IE9 + में संगत है, लेकिन एक नई वस्तु बनाना है और सबसे तेज समाधान नहीं हो सकता है:

function renameObjectKey(oldObj, oldName, newName) {
    const newObj = {};

    Object.keys(oldObj).forEach(key => {
        const value = oldObj[key];

        if (key === oldName) {
            newObj[newName] = value;
        } else {
            newObj[key] = value;
        }
    });

    return newObj;
}

कृपया ध्यान दें: IE9 सख्त मोड में आगे का समर्थन नहीं कर सकता है

Answer 16

नामांकित कुंजी के साथ एक नई वस्तु बनाने के लिए यहां एक उदाहरण है।

let x = { id: "checkout", name: "git checkout", description: "checkout repository" };

let renamed = Object.entries(x).reduce((u, [n, v]) => {
  u[`__${n}`] = v;
  return u;
}, {});

Answer 17

फिर भी सबसे शक्तिशाली REDUCE विधि के साथ एक और तरीका ।

data = {key1: "value1", key2: "value2", key3: "value3"}; 

keyMap = {key1: "firstkey", key2: "secondkey", key3: "thirdkey"};

mappedData = Object.keys(keyMap).reduce((obj,k) => Object.assign(obj, { [keyMap[k]]: data[k] }),{});

console.log(mappedData);

Answer 18

यह एक छोटा संशोधन है जिसे मैंने पोम्बर के कार्य के लिए बनाया है; अकेले एक वस्तु के बजाय वस्तुओं का एक सरणी लेने में सक्षम होने के लिए और आप सूचकांक को सक्रिय कर सकते हैं। यह भी "कुंजी" एक सरणी द्वारा सौंपा जा सकता है

function renameKeys(arrayObject, newKeys, index = false) {
    let newArray = [];
    arrayObject.forEach((obj,item)=>{
        const keyValues = Object.keys(obj).map((key,i) => {
            return {[newKeys[i] || key]:obj[key]}
        });
        let id = (index) ? {'ID':item} : {}; 
        newArray.push(Object.assign(id, ...keyValues));
    });
    return newArray;
}

परीक्षा

const obj = [{ a: "1", b: "2" }, { a: "5", b: "4" } ,{ a: "3", b: "0" }];
const newKeys = ["A","C"];
const renamedObj = renameKeys(obj, newKeys);
console.log(renamedObj);

Answer 19

मेरी राय में आपका रास्ता अनुकूलित है। लेकिन आप reordered कीज़ के साथ समाप्त होंगे। नई बनाई गई कुंजी अंत में संलग्न की जाएगी। मुझे पता है कि आपको कभी भी महत्वपूर्ण आदेश पर भरोसा नहीं करना चाहिए, लेकिन अगर आपको इसे संरक्षित करने की आवश्यकता है, तो आपको सभी कुंजियों से गुजरना होगा और एक-एक करके नई वस्तु का निर्माण करना होगा, उस प्रक्रिया के दौरान प्रश्न की कुंजी को बदलना होगा।

ऐशे ही:

var new_o={};
for (var i in o)
{
   if (i==old_key) new_o[new_key]=o[old_key];
   else new_o[i]=o[i];
}
o=new_o;

Answer 20

• आप इसे संभालने के लिए एक उपयोगिता का उपयोग कर सकते हैं।

npm i paix

import { paix } from 'paix';

const source_object = { FirstName: "Jhon", LastName: "Doe", Ignored: true };
const replacement = { FirstName: 'first_name', LastName: 'last_name' };
const modified_object = paix(source_object, replacement);

console.log(modified_object);
// { Ignored: true, first_name: 'Jhon', last_name: 'Doe' };

Answer 21

बस अपने पसंदीदा संपादक <3 में इसे आज़माएं

const obj = {1: 'a', 2: 'b', 3: 'c'}

const OLD_KEY = 1
const NEW_KEY = 10

const { [OLD_KEY]: replaceByKey, ...rest } = obj
const new_obj = {
  ...rest,
  [NEW_KEY]: replaceByKey
}