这是我的对象文字：

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()触发设置器，而扩展语法则不会。

现场例子

它可以在当前的Chrome和Firefox中运行。他们说它在当前Edge中不起作用。

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

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

2019年答案

对象分配运算符 +=：

obj += {key3: "value3"};

糟糕...我被带走了。从未来走私信息是非法的。完全模糊！

我越来越喜欢了的LoDash / 下划线写较大的项目时。

加上obj['key']或obj.key都是纯JavaScript纯答案。但是，通常在处理对象和数组时，LoDash库和Underscore库确实提供了许多其他方便的功能。

.push()适用于数组，不适用于对象。

根据您要查找的内容，有两个特定的功能可能会很好地利用，并提供与相似的功能arr.push()。有关更多信息，请检查文档，那里有一些很棒的示例。

_.merge（仅Lodash）

第二个对象将覆盖或添加到基础对象。 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}

_.defaults

第二个对象包含默认值，如果不存在默认值，则会将其添加到基础对象。 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，如果您想自己填充，则最好使用Babel等ES6 / ES2015填充。

第二个对象将覆盖或添加到基础对象。 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是您要使用的自动键）

arr[ 'key3' ] = value3;

要么

arr.key3 = value3;

如果key3是变量，则应该执行以下操作：

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

在此之后，请求arr.a_key将返回value3文字的值3。

arr.key3 = value3;

因为您的arr并不是一个数组...它是一个原型对象。真正的数组是：

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

只需添加属性：

我们想要添加prop2 : 2到该对象中，这是最方便的选择：

1. 点运算符： object.prop2 = 2;
2. 方括号： object['prop2'] = 2;

那么，我们该使用哪一个呢？

点运算符是更简洁的语法，应将其用作默认值（imo）。但是，点运算符不能将动态键添加到对象，这在某些情况下可能非常有用。这是一个例子：

const obj = {
  prop1: 1
}

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

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

console.log(obj);

合并对象：

当我们要合并两个对象的属性时，这些是最方便的选择：

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您可以继续将的链连接.push到obj变量的末尾：obj.push(...).push(...).push(...);

另一个功能是，您可以传递一个数组或另一个对象作为push函数参数中的值。请参阅我的小提琴以获取工作示例：http : //jsfiddle.net/7tEme/

性能

今天2020.01.14，我针对选定的解决方案在Chrome v78.0.0，Safari v13.0.4和Firefox v71.0.0的MacOs HighSierra 10.13.6上进行了测试。我将解决方案分为可变的（第一个字母M）和不可变的（第一个字母I）。我还提供了一些不变的解决方案（IB，IC，ID / IE），尚未在此问题的答案中发布

结论

• 最快的可变解决方案比最快的可变解决方案（> 10x）快得多
• obj.key3 = "abc"（MA，MB）之类的经典可变方法最快
• 对于不可变的解决方案，{...obj, key3:'abc'}和Object.assign（IA，IB）最快
• 令人惊讶的是，比起可变的解决方案，铬（MC-IA）和野生动物园（MD-IB）的不可变解决方案的速度更快

细节

在下面的代码片段有presended测试解决方案，可以在机器上prefrom测试HERE

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!

您可以使用@ Ionuț G. Stan的答案创建课程

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

我是javascript新手，欢迎发表评论。为我工作。

大多数答案中已经提到的两种最常用的方法

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;

多数浏览器的它检查对象键可用与否要添加的支持，而且，如果可用它会取代现有的键值，并没有提供它添加具有价值的关键

例子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" 
//            }   
//       }

如果一个对象中有多个匿名对象文字，并且想要添加另一个包含键/值对的对象，请执行以下操作：

Firebug的对象：

console.log(Comicbook);

返回：

[对象{name =“ Spiderman”，value =“ 11”}，对象{name =“ Marsipulami”，value =“ 18”}，对象{name =“ Garfield”，value =“ 2”}]

码：

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"}到漫画对象

无论是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的。扩展（target [，object1] [，objectN]）将两个或更多对象的内容合并到第一个对象中。

它还允许使用以下内容进行递归添加/修改$.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>

下一个Javascript规范（候选阶段3）中的一种简短简洁的方法是：

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

可以在对象传播与Object.assign以及Axel Rauschmayers博士站点上找到更深入的讨论。

自版本8.6.0起，它已经可以在node.js中使用。

最新版本的Vivaldi，Chrome，Opera和Firefox也知道此功能，但是Mirosoft直到今天才知道，Internet Explorer和Edge都没有。

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

您可以通过以下方式添加它：

arr['key3'] = value3;

或者这样：

arr.key3 = value3;

提示使用变量键入对象的答案key3只有在key3was 的值时才有效'key3'。

根据ECMA-262（http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf，P67）中定义的属性访问器，可以使用两种方法将属性添加到存在对象。所有这两种方式，Javascript引擎将对它们进行相同的处理。

第一种方法是使用点表示法：

obj.key3 = value3;

但是这样，您应该在点符号后使用IdentifierName。

第二种方法是使用括号表示法：

obj["key3"] = value3;

另一种形式：

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

这样，您可以在方括号表示法中使用Expression（包括IdentifierName）。

我们也可以通过这种方式做到这一点。

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

既然是过去的问题，而是现在的问题。会建议另一个解决方案：只需将键和值传递给函数，您将获得一个map对象。

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

为了前面加上一个键-值对的一个对象，因此在与该元件作品首次做到这一点：

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

您可以使用以下{[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