මෙන්න මගේ වස්තුව වචනාර්ථයෙන්:

var obj = {key1: value1, key2: value2};

වස්තුව key3සමඟ ක්ෂේත්‍රය එකතු කරන්නේ කෙසේද value3?

වස්තුවකට නව ගුණාංග එකතු කිරීමට ක්‍රම දෙකක් තිබේ :

var obj = {
    key1: value1,
    key2: value2
};

තිත් අංකනය භාවිතා කිරීම:

obj.key3 = "value3";

වර්ග වරහන් අංකනය භාවිතා කිරීම:

obj["key3"] = "value3";

ඔබ දේපලෙහි නම දන්නා විට පළමු පෝරමය භාවිතා කරයි. දේපලෙහි නම ගතිකව තීරණය කළ විට දෙවන ආකෘතිය භාවිතා වේ. මෙම උදාහරණයේ දී මෙන්:

var getProperty = function (propertyName) {
    return obj[propertyName];
};

getProperty("key1");
getProperty("key2");
getProperty("key3");

ඒ සැබෑ JavaScript අරා භාවිතා කර නිර්මාණය කළ හැක:

අරාව වචනානුසාරයෙන් අංකනය:

var arr = [];

අරා ඉදිකිරීම්කරු අංකනය:

var arr = new Array();

2017 වසර පිළිතුර: Object.assign()

Object.assign (dest, src1, src2, ...) වස්තු ඒකාබද්ධ කරයි.

එය dest(කෙසේ වෙතත්) ප්‍රභව වස්තූන්ගේ ගුණාංග සහ අගයන් සමඟ නැවත ලියයි , පසුව නැවත පැමිණේ dest.

Object.assign()සියළුම ගණනය කළ හැකි දේපලවල අගයන් ප්‍රභව වස්තු එකක් හෝ වැඩි ගණනක සිට ඉලක්කගත වස්තුවකට පිටපත් කිරීමට මෙම ක්‍රමය භාවිතා කරයි. එය ඉලක්කගත වස්තුව නැවත ලබා දෙනු ඇත.

සජීවී උදාහරණය

var obj = {key1: "value1", key2: "value2"};
Object.assign(obj, {key3: "value3"});

document.body.innerHTML = JSON.stringify(obj);

වර්ෂය 2018 පිළිතුර: වස්තු පැතිරුම් ක්‍රියාකරු {...}

obj = {...obj, ...pair};

MDN වෙතින් :

එය සපයා ඇති වස්තුවකින් තමන්ගේම ගණන් කළ නොහැකි ගුණාංග නව වස්තුවකට පිටපත් කරයි.

නොගැඹුරු ක්ලෝනකරණය (මූලාකෘති හැර) හෝ වස්තු ඒකාබද්ධ කිරීම දැන් වඩා කෙටි වාක්‍ය ඛණ්ඩයක් භාවිතා කළ හැකිය Object.assign().

බව සටහන Object.assign()ප්රේරක ස්ථානගත වන්නන් පැතිර කාරක රීති ඇති ෙහයින්ද නැහැ.

සජීවී උදාහරණය

එය වත්මන් ක්‍රෝම් සහ වත්මන් ෆයර්ෆොක්ස් වල ක්‍රියා කරයි. ඔවුන් පවසන්නේ එය වර්තමාන එජ් හි ක්‍රියාත්මක නොවන බවයි.

var obj = {key1: "value1", key2: "value2"};
var pair = {key3: "value3"};
obj = {...obj, ...pair};

document.body.innerHTML = JSON.stringify(obj);

2019 වසර පිළිතුර

වස්තු පැවරුම් ක්‍රියාකරු += :

obj += {key3: "value3"};

අපොයි ... මම රැගෙන ගියා. අනාගතයේ සිට තොරතුරු ජාවාරම නීති විරෝධී ය. නිසි ලෙස අපැහැදිලි!

මම LoDash / Underscore වලට ඇලුම් කළෙමිවිශාල ව්‍යාපෘති ලිවීමේදී .

එකතු කිරීම obj['key']හෝ obj.keyසියල්ලම පිරිසිදු ජාවාස්ක්‍රිප්ට් පිළිතුරු වේ. කෙසේ වෙතත්, ලොඩාෂ් සහ අන්ඩර්ස්කෝර් පුස්තකාල දෙකම පොදුවේ වස්තු සහ අරා සමඟ වැඩ කිරීමේදී අමතර පහසු කාර්යයන් රාශියක් සපයයි.

.push()අරාව සඳහා මිස වස්තු සඳහා නොවේ .

ඔබ සොයන දේ මත පදනම්ව, හැඟීමකට සමාන ක්‍රියාකාරීත්වයක් භාවිතා කිරීමට සහ ලබා දීමට හොඳ විය හැකි විශේෂිත කාර්යයන් දෙකක් තිබේ arr.push() . වැඩි විස්තර සඳහා ලියකියවිලි පරීක්ෂා කරන්න, ඔවුන්ට එහි විශිෂ්ට උදාහරණ කිහිපයක් තිබේ.

_.මර්ජ් (ලෝඩාෂ් පමණි)

දෙවන වස්තුව නැවත ලිවීම හෝ මූලික වස්තුවට එකතු කිරීම සිදු කරයි. undefinedඅගයන් පිටපත් නොවේ.

var obj = {key1: "value1", key2: "value2"};
var obj2 = {key2:"value4", key3: "value3", key4: undefined};
_.merge(obj, obj2);
console.log(obj);
// → {key1: "value1", key2: "value4", key3: "value3"} 

_.extend / _.assign

දෙවන වස්තුව නැවත ලිවීම හෝ මූලික වස්තුවට එකතු කිරීම සිදු කරයි. undefinedපිටපත් කරනු ලැබේ.

var obj = {key1: "value1", key2: "value2"};
var obj2 = {key2:"value4", key3: "value3", key4: undefined};
_.extend(obj, obj2);
console.log(obj);
// → {key1: "value1", key2: "value4", key3: "value3", key4: undefined}

_. දෝෂ

දෙවන වස්තුවෙහි පෙරනිමි අඩංගු වන අතර ඒවා නොපවතී නම් මූලික වස්තුවට එකතු වේ. undefinedයතුර දැනටමත් තිබේ නම් අගයන් පිටපත් වේ.

var obj = {key3: "value3", key5: "value5"};
var obj2 = {key1: "value1", key2:"value2", key3: "valueDefault", key4: "valueDefault", key5: undefined};
_.defaults(obj, obj2);
console.log(obj);
// → {key3: "value3", key5: "value5", key1: "value1", key2: "value2", key4: "valueDefault"}

$. දිගු කරන්න

ඊට අමතරව, එය jQuery.extend ගැන සඳහන් කිරීම වටී, එය _.merge හා සමාන වන අතර ඔබ දැනටමත් jQuery භාවිතා කරන්නේ නම් වඩා හොඳ විකල්පයක් විය හැකිය.

දෙවන වස්තුව නැවත ලිවීම හෝ මූලික වස්තුවට එකතු කිරීම සිදු කරයි. undefinedඅගයන් පිටපත් නොවේ.

var obj = {key1: "value1", key2: "value2"};
var obj2 = {key2:"value4", key3: "value3", key4: undefined};
$.extend(obj, obj2); 
console.log(obj);
// → {key1: "value1", key2: "value4", key3: "value3"}

Object.assign ()

එය ES6 / ES2015 Object.assign සඳහන් කරනු වටී විය හැක, එය _.merge සමාන ක්රියාත්මක සහ ඔබ දැනටමත් වැනි ES6 / ES2015 polyfill භාවිතා කරන්නේ නම් හොඳම විකල්පය විය හැකිය බාබෙල් ඔබට අවශ්ය නම් ඔබ polyfill .

දෙවන වස්තුව නැවත ලිවීම හෝ මූලික වස්තුවට එකතු කිරීම සිදු කරයි. undefinedපිටපත් කරනු ලැබේ.

var obj = {key1: "value1", key2: "value2"};
var obj2 = {key2:"value4", key3: "value3", key4: undefined};
Object.assign(obj, obj2); 
console.log(obj);
// → {key1: "value1", key2: "value4", key3: "value3", key4: undefined}

ඔබට මේවායින් එකක් හෝ භාවිතා කළ හැකිය (සපයා ඇති key3 යනු ඔබට භාවිතා කිරීමට අවශ්‍ය acutal යතුරයි)

arr[ 'key3' ] = value3;

හෝ

arr.key3 = value3;

Key3 විචල්යයක් නම්, ඔබ කළ යුත්තේ:

var key3 = 'a_key';
var value3 = 3;
arr[ key3 ] = value3;

මෙයින් පසු, ඉල්ලීමෙන් වචනයේ පරිසමාප්ත අර්ථයෙන්ම arr.a_keyආපසු ලැබෙනු ඇත .value33

arr.key3 = value3;

ඔබේ අර්‍ථය සැබවින්ම අරාවක් නොවන නිසා ... එය මූලාකෘති වස්තුවකි. සැබෑ අරාව වනුයේ:

var arr = [{key1: value1}, {key2: value2}];

නමුත් එය තවමත් නිවැරදි නැත. එය ඇත්ත වශයෙන්ම විය යුත්තේ:

var arr = [{key: key1, value: value1}, {key: key2, value: value2}];

var employees = []; 
employees.push({id:100,name:'Yashwant',age:30});
employees.push({id:200,name:'Mahesh',age:35});

කාර්ය සාධනය

අද 2020.01.14 තෝරාගත් විසඳුම් සඳහා මම මැක් ඕස් හයිසෙයිරා 10.13.6 ක්‍රෝම් v78.0.0, සෆාරි v13.0.4 සහ ෆයර්ෆොක්ස් v71.0.0 මත පරීක්ෂණ සිදු කරමි. මම විකෘති (පළමු අකුර M) සහ වෙනස් කළ නොහැකි (පළමු අකුර I) සඳහා විසඳුම් බෙදා දෙමි. මෙම ප්‍රශ්නයට පිළිතුරු වශයෙන් තවමත් ප්‍රකාශයට පත් කර නොමැති වෙනස් කළ නොහැකි විසඳුම් කිහිපයක් (IB, IC, ID / IE) මම ලබා දෙමි

නිගමන

• වේගවත්ම විකෘති විසඳුම් වේගවත් වෙනස් කළ නොහැකි (> 10x) වඩා වේගවත් වේ
• obj.key3 = "abc"(MA, MB) වැනි සම්භාව්‍ය විකෘති ප්‍රවේශය වේගවත් ය
• වෙනස් කළ නොහැකි විසඳුම් සඳහා {...obj, key3:'abc'}සහ Object.assign(IA, IB) වේගවත්ම වේ
• පුදුමයට කරුණක් නම් ක්‍රෝම් (MC-IA) සහ සෆාරි (MD-IB) සඳහා විකෘති කළ හැකි විසඳුම් වලට වඩා වේගයෙන් වෙනස් කළ නොහැකි විසඳුම් තිබේ.

විස්තර

පහත දැක්වෙන ස්නිපටයේ පෙර සැකසූ පරීක්‍ෂා කළ විසඳුමක් ඇත, ඔබට ඔබේ යන්ත්‍රය මත පරීක්‍ෂණයෙන් පූර්ව පරීක්‍ෂා කළ හැකිය මෙතැන

var o = {
    key1: true,
    key2: 3,
};

var log= (s,f)=> console.log(`${s} --> ${JSON.stringify(f({...o}))}`);



function MA(obj) {
  obj.key3 = "abc";
  return obj;
}

function MB(obj) {
  obj['key3'] = "abc";
  return obj;
}

function MC(obj) {
  Object.assign(obj, {key3:'abc'});
  return obj;
}

function MD(obj) {
  Object.defineProperty(obj, 'key3', {
    value: "abc",       // undefined by default
    enumerable: true,      // false by default
    configurable: true,    // false by default
    writable: true         // false by default
  });
  return obj;
}

function IA(obj) {
  return {...obj, key3:'abc'};
}

function IB(obj) {
  return Object.assign({key3:'abc'}, obj);
}

function IC(obj) {
  let ob= JSON.parse(JSON.stringify(obj))
  ob.key3 = 'abc';
  return ob;
}


function ID(obj) {
	let ob= Object.fromEntries(Object.entries(obj));
  ob.key3 = 'abc';
  return ob;
}

function IE(obj) {
	return Object.fromEntries(Object.entries(obj).concat([['key3','abc']]))
}



log('MA',MA);
log('MB',MB);
log('MC',MC);
log('MD',MD);
log('IA',IA);
log('IB',IB);
log('IC',IC);
log('ID',ID);
log('IE',IE);

This snippet only presents code - it not perform tests itself!

ගුණාංග එකතු කිරීම:

අපට prop2 : 2මෙම වස්තුවට එකතු කිරීමට අවශ්‍යයි , මේවා වඩාත් පහසු විකල්ප වේ:

1. තිත් ක්‍රියාකරු: object.prop2 = 2;
2. වර්ග වරහන්: object['prop2'] = 2;

එහෙනම් අපි භාවිතා කරන්නේ කුමන එකද?

තිත් ක්‍රියාකරු වඩාත් පිරිසිදු වාක්‍ය ඛණ්ඩයක් වන අතර එය පෙරනිමියක් ලෙස භාවිතා කළ යුතුය (ඉමෝ). කෙසේ වෙතත්, තිත් ක්‍රියාකරුට වස්තුවකට ගතික යතුරු එක් කිරීමට හැකියාවක් නොමැති අතර එය සමහර අවස්ථාවල ඉතා ප්‍රයෝජනවත් වේ. මෙන්න උදාහරණයක්:

const obj = {
  prop1: 1
}

const key = Math.random() > 0.5 ? 'key1' : 'key2';

obj[key] = 'this value has a dynamic key';

console.log(obj);

වස්තු ඒකාබද්ධ කිරීම:

වස්තු 2 ක ගුණාංග ඒකාබද්ධ කිරීමට අපට අවශ්‍ය වූ විට මේවා වඩාත් පහසු විකල්ප වේ:

1. Object.assign(), ඉලක්කගත වස්තුවක් තර්කයක් ලෙස ගෙන, ප්‍රභව වස්තු එකක් හෝ කිහිපයක් ගෙන ඒවා එකට ඒකාබද්ධ කරයි. උදාහරණයක් වශයෙන්:

const object1 = {
  a: 1,
  b: 2,
};

const object2 = Object.assign({
  c: 3,
  d: 4
}, object1);

console.log(object2);

2. වස්තු පැතිරුම් ක්‍රියාකරු ...

const obj = {
  prop1: 1,
  prop2: 2
}

const newObj = {
  ...obj,
  prop3: 3,
  prop4: 4
}

console.log(newObj);

අපි භාවිතා කරන්නේ කුමන එකද?

• පැතිරීමේ වාක්‍ය ඛණ්ඩය අඩු වාචික වන අතර එය පෙරනිමි imo ලෙස භාවිතා කළ යුතුය. මෙම සින්ටැක්ස් සින්ටැක්ස් වෙත සම්ප්‍රේෂණය කිරීමට අමතක නොකරන්න, එය සියලු බ්‍රව්සර් මගින් සහය දක්වයි.
• Object.assign() වඩාත් ගතික වන්නේ අපට තර්ක ලෙස සම්මත කර ඇති සියලුම වස්තූන් වෙත ප්‍රවේශය ඇති බැවින් ඒවා නව වස්තුවට පැවරීමට පෙර ඒවා හැසිරවිය හැකි බැවිනි.

මේ සඳහා දැනටමත් පිළිගත් පිළිතුරක් ඇති බව මම දනිමි, නමුත් මගේ අදහස කොතැනක හෝ ලේඛනගත කිරීමට සිතුවෙමි. කරුණාකර [මිනිසුන්ට] මෙම අදහසෙහි සිදුරු කිරීමට නිදහස්ව සිටින්න, එය හොඳම විසඳුම දැයි මට විශ්වාස නැත ... නමුත් මම මෙය මිනිත්තු කිහිපයකට පෙර එකට තැබුවෙමි:

Object.prototype.push = function( key, value ){
   this[ key ] = value;
   return this;
}

ඔබ එය මේ ආකාරයෙන් භාවිතා කරනු ඇත:

var obj = {key1: value1, key2: value2};
obj.push( "key3", "value3" );

මූලාකෘති ශ්‍රිතය නැවත පැමිණෙන බැවින්, ඔබේ විචල්‍යයේ අවසානය thisදක්වා දාමය දිගටම කරගෙන යා හැකිය :.pushobjobj.push(...).push(...).push(...);

තවත් අංගයක් නම්, තල්ලු ශ්‍රිත තර්ක වල අගය ලෙස ඔබට අරාවක් හෝ වෙනත් වස්තුවක් සමත් විය හැකිය. වැඩ කරන උදාහරණයක් සඳහා මගේ ෆෙඩල් බලන්න: http://jsfiddle.net/7tEme/

@ අයෝනු ජී. ස්ටැන්ගේ පිළිතුර සමඟ ඔබට පන්තියක් නිර්මාණය කළ හැකිය

function obj(){
    obj=new Object();
    this.add=function(key,value){
        obj[""+key+""]=value;
    }
    this.obj=obj
}

අවසාන පන්තිය සමඟ නව වස්තුවක් නිර්මාණය කිරීම:

my_obj=new obj();
my_obj.add('key1', 'value1');
my_obj.add('key2', 'value2');
my_obj.add('key3','value3');

වස්තුව මුද්‍රණය කිරීම

console.log(my_obj.obj) // Return {key1: "value1", key2: "value2", key3: "value3"} 

යතුරක් මුද්‍රණය කිරීම

console.log(my_obj.obj["key3"]) //Return value3

මම ජාවාස්ක්‍රිප්ට් හි නවකයෙක්, අදහස් පිළිගැනීම. මා වෙනුවෙන් වැඩ කරයි.

බොහෝ පිළිතුරු වල දැනටමත් සඳහන් කර ඇති වඩාත් භාවිතා කළ ක්‍රම දෙකක්

obj.key3 = "value3";

obj["key3"] = "value3";

දේපලක් අර්ථ දැක්වීමට තවත් එක් ක්‍රමයක් වන්නේ Object.defineProperty () භාවිතා කිරීමයි.

Object.defineProperty(obj, 'key3', {
  value: "value3",       // undefined by default
  enumerable: true,      // false by default
  configurable: true,    // false by default
  writable: true         // false by default
});

දේපල නිර්වචනය කිරීමේදී ඔබට වැඩි පාලනයක් අවශ්‍ය විට මෙම ක්‍රමය ප්‍රයෝජනවත් වේ. අර්ථ දක්වා ඇති දේපල පරිශීලකයාට ගණන් කළ හැකි, වින්‍යාසගත කළ හැකි සහ ලිවිය හැකි ලෙස සැකසිය හැකිය.

ඔබේ උදාහරණයෙන් දැක්වෙන්නේ වස්තුවක් මිස අරාවක් නොවේ. එවැනි අවස්ථාවකදී, වස්තුවකට ක්ෂේත්‍රයක් එක් කිරීමට වඩාත් සුදුසු ක්‍රමය වන්නේ එයට අනුයුක්ත කිරීමයි.

arr.key3 = value3;

var arrOfObj = [{name: 'eve'},{name:'john'},{name:'jane'}];
    var injectObj = {isActive:true, timestamp:new Date()};

    // function to inject key values in all object of json array

    function injectKeyValueInArray (array, keyValues){
        return new Promise((resolve, reject) => {
            if (!array.length)
                return resolve(array);

            array.forEach((object) => {
                for (let key in keyValues) {
                    object[key] = keyValues[key]
                }
            });
            resolve(array);
        })
    };

//call function to inject json key value in all array object
    injectKeyValueInArray(arrOfObj,injectObj).then((newArrOfObj)=>{
        console.log(newArrOfObj);
    });

මේ වගේ ප්‍රතිදානය: -

[ { name: 'eve',
    isActive: true,
    timestamp: 2017-12-16T16:03:53.083Z },
  { name: 'john',
    isActive: true,
    timestamp: 2017-12-16T16:03:53.083Z },
  { name: 'jane',
    isActive: true,
    timestamp: 2017-12-16T16:03:53.083Z } ]

වස්තුව ප්රධාන ගත හෝ ඔබ නම්, එකතු කිරීමට අවශ්ය නොවේ නම් ඒ වෙබ් බ්රව්සර බොහෝ, සහ චෙක්පත් සහයෝගය ලබා ගත හැකි එය දැනට පවතින ප්රධාන වටිනාකම overides එය ලබා ගත නොහැකි එය අගය සමග යතුරු එකතු

උදාහරණ 1

let my_object = {};

// now i want to add something in it  

my_object.red = "this is red color";

// { red : "this is red color"}

උදාහරණ 2

let my_object = { inside_object : { car : "maruti" }}

// now i want to add something inside object of my object 

my_object.inside_object.plane = "JetKing";

// { inside_object : { car : "maruti" , plane : "JetKing"} }

උදාහරණ 3

let my_object = { inside_object : { name : "abhishek" }}

// now i want to add something inside object with new keys birth , gender 

my_object.inside_object.birth = "8 Aug";
my_object.inside_object.gender = "Male";


    // { inside_object : 
//             { name : "abhishek",
//               birth : "8 Aug",
//               gender : "Male" 
//            }   
//       }

ඔබට වස්තුවක් තුළ බහුවිධ නිර්නාමික වස්තු සාහිත්‍යයක් තිබේ නම් සහ යතුරු / අගය යුගල අඩංගු තවත් වස්තුවක් එක් කිරීමට අවශ්‍ය නම්, මෙය කරන්න:

ෆයර්බග් 'වස්තුව:

console.log(Comicbook);

ප්‍රතිලාභ:

.

කේතය:

if (typeof Comicbook[3]=='undefined') {
    private_formArray[3] = new Object();
    private_formArray[3]["name"] = "Peanuts";
    private_formArray[3]["value"] = "12";
}

Object {name="Peanuts", value="12"}Comicbook වස්තුවට එකතු කරනු ඇත

එක්කෝ obj['key3'] = value3හෝ obj.key3 = value3නව යුගලය එකතු කරයිobj .

කෙසේ වෙතත්, මම දන්නවා jQuery ගැන සඳහන් කර නැති නමුත් ඔබ එය භාවිතා කරන්නේ නම්, ඔබට එම වස්තුව හරහා එකතු කළ හැකිය $.extend(obj,{key3: 'value3'}). උදා:

var obj = {key1: 'value1', key2: 'value2'};
$('#ini').append(JSON.stringify(obj));

$.extend(obj,{key3: 'value3'});

$('#ext').append(JSON.stringify(obj));

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<p id="ini">Initial: </p>
<p id="ext">Extended: </p>

jQuery. දිගු කිරීම (ඉලක්කය [, වස්තුව 1] [, වස්තුව එන්]) පළමු වස්තුවට වස්තු දෙකක හෝ වැඩි ගණනක අන්තර්ගතය ඒකාබද්ධ කරයි.

තවද මෙය පුනරාවර්තන එකතු කිරීම් / වෙනස් කිරීම් වලට ඉඩ දෙයි $.extend(true,object1,object2);:

var object1 = {
  apple: 0,
  banana: { weight: 52, price: 100 },
  cherry: 97
};
var object2 = {
  banana: { price: 200 },
  durian: 100
};
$("#ini").append(JSON.stringify(object1));    

$.extend( true, object1, object2 );
 
$("#ext").append(JSON.stringify(object1));

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<p id="ini">Initial: </p>
<p id="ext">Extended: </p>

ඊළඟ ජාවාස්ක්‍රිප්ට් පිරිවිතරයේ (අපේක්ෂක අදියර 3) කෙටි හා අලංකාර ක්‍රමයක් වන්නේ:

obj = { ... obj, ... { key3 : value3 } }

Object.assign එදිරිව Object.assign සහ ආචාර්ය ඇක්සෙල් රවුෂ්මේයර්ස් වෙබ් අඩවියෙන් ගැඹුරු සාකච්ඡාවක් සොයාගත හැකිය .

8.6.0 නිකුතුවේ සිට එය දැනටමත් node.js හි ක්‍රියාත්මක වේ.

යාවත්කාලීන නිකුතුවල ඇති විවාල්ඩි, ක්‍රෝම්, ඔපෙරා සහ ෆයර්ෆොක්ස් මෙම අංගය ද දනිති, නමුත් මිරෝසොෆ්ට් අද වන තුරුත්, ඉන්ටර්නෙට් එක්ස්ප්ලෝරර් හෝ එජ්හිවත් නැත.

ඔබට එය මේ ආකාරයෙන් එකතු කළ හැකිය:

arr['key3'] = value3;

හෝ මේ ආකාරයෙන්:

arr.key3 = value3;

විචල්ය සමඟ වස්තුව බවට අඟවන යෝජනා පිළිතුරු key3පමණක් වැඩ වටිනාකම නම් කරන key3ලදී 'key3'.

අනුව ඉඩකඩම් Accessors ECMA-262 අර්ථ ( http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf , P67), ඔබ ගුණ එකතු කිරීමට කළ හැකි ක්රම දෙකක් තිබේ පවතින වස්තුවක්. මේ දෙයාකාරයෙන්ම, ජාවාස්ක්‍රිප්ට් එන්ජිම ඔවුන්ට එක හා සමානව සලකනු ඇත.

පළමු ක්‍රමය වන්නේ තිත් අංකනය භාවිතා කිරීමයි:

obj.key3 = value3;

නමුත් මේ ආකාරයෙන්, ඔබ තිත් අංකනයෙන් පසුව හැඳුනුම්පතක් භාවිතා කළ යුතුය .

දෙවන ක්‍රමය වරහන් අංකනය භාවිතා කිරීමයි:

obj["key3"] = value3;

තවත් ආකාරයක්:

var key3 = "key3";
obj[key3] = value3;

මේ ආකාරයෙන්, ඔබට වරහන් අංකනයෙහි ප්‍රකාශනයක් ( හැඳුනුම්පත ඇතුළත් කරන්න ) භාවිතා කළ හැකිය.

අපට මෙයද මේ ආකාරයෙන් කළ හැකිය.

var myMap = new Map();
myMap.set(0, 'my value1');
myMap.set(1, 'my value2');
 for (var [key, value] of myMap) {
  console.log(key + ' = ' + value);
 }

{[key]: value}සින්ටැක්ස් භාවිතා කිරීමෙන් ඔබට නව වස්තුවක් නිර්මාණය කළ හැකිය :

const foo = {
  a: 'key',
  b: 'value'
}

const bar = {
  [foo.a]: foo.b
}

console.log(bar); // {key: 'value'}
console.log(bar.key); // value

const baz = {
  ['key2']: 'value2'
}

console.log(baz); // {key2: 'value2'}
console.log(baz.key2); // value2

පෙර වාක්‍ය ඛණ්ඩය සමඟින් ඔබට දැන් {...foo, ...bar}ඔබේ පැරණි අගය විකෘති නොකර නව වස්තුවක් එක් කිරීමට පැතිරෙන සින්ටැක්ස් භාවිතා කළ හැකිය :

const foo = {a: 1, b: 2};

const bar = {...foo, ...{['c']: 3}};

console.log(bar); // {a: 1, b: 2, c: 3}
console.log(bar.c); // 3

කිරීම සඳහා prepend එසේ වස්තුවක් ප්රධාන-අගය යුගල සඳහා බව අංගයක් සමග ක්රියා පළමු මෙය කරන්න:

    var nwrow = {'newkey': 'value' };
    for(var column in row){
        nwrow[column] = row[column];
    }
    row = nwrow;

එය සාක්ෂාත් කරගත හැකි හොඳම ක්‍රමය පහත දැක්වේ:

function getKey(key) {
  return `${key}`;
}

var obj = {key1: "value1", key2: "value2", [getKey('key3')]: "value3"};

//console.log(obj);

එය අතීතය පිළිබඳ ප්‍රශ්නයක් නමුත් වර්තමානයේ ගැටලුවයි. තවත් එක් විසඳුමක් යෝජනා කරයි: යතුර සහ අගයන් ශ්‍රිතයට යොමු කිරීමෙන් ඔබට සිතියම් වස්තුවක් ලැබෙනු ඇත.

var map = {};
function addValueToMap(key, value) {
map[key] = map[key] || [];
map[key].push(value);
}