Aquí está mi objeto literal:

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

¿Cómo puedo añadir campo key3con value3el objeto?

Hay dos formas de agregar nuevas propiedades a un objeto:

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

Usando notación de punto:

obj.key3 = "value3";

Usando la notación de corchetes:

obj["key3"] = "value3";

El primer formulario se usa cuando conoce el nombre de la propiedad. La segunda forma se usa cuando el nombre de la propiedad se determina dinámicamente. Como en este ejemplo:

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

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

Se puede construir una matriz de JavaScript real usando:

La notación literal de la matriz:

var arr = [];

La notación de constructor de matriz:

var arr = new Array();

Respuesta del año 2017: Object.assign()

Object.assign (dest, src1, src2, ...) combina objetos.

Se sobrescribe destcon propiedades y valores de (sin importar cuántos) objetos fuente, luego regresa dest.

El Object.assign()método se utiliza para copiar los valores de todas las propiedades propias enumerables de uno o más objetos de origen a un objeto de destino. Devolverá el objeto de destino.

Ejemplo en vivo

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

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

Respuesta del año 2018: operador de propagación de objetos {...}

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

De MDN :

Copia propiedades enumerables propias de un objeto proporcionado en un nuevo objeto.

La clonación superficial (excluyendo el prototipo) o la fusión de objetos ahora es posible usando una sintaxis más corta que Object.assign().

Nótese que los Object.assign()disparadores set mientras que la sintaxis de propagación no lo hace.

Ejemplo en vivo

Funciona en Chrome actual y Firefox actual. Dicen que no funciona en Edge actual.

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

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

Respuesta año 2019

Operador de asignación de objetos += :

obj += {key3: "value3"};

Vaya ... me dejé llevar. El contrabando de información del futuro es ilegal. Debidamente oscurecido!

Me he encariñado con LoDash / Underscore cuando escribo proyectos más grandes.

Agregar por obj['key']o obj.keyson todas respuestas de JavaScript puro y sólido. Sin embargo, las bibliotecas LoDash y Underscore proporcionan muchas funciones convenientes adicionales cuando se trabaja con objetos y matrices en general.

.push()es para matrices , no para objetos .

Dependiendo de lo que esté buscando, hay dos funciones específicas que pueden ser agradables de utilizar y brindan una funcionalidad similar a la de la sensación arr.push(). Para obtener más información, consulte los documentos, que tienen algunos excelentes ejemplos allí.

_.merge (solo Lodash)

El segundo objeto sobrescribirá o agregará al objeto base. undefinedlos valores no se copian.

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

El segundo objeto sobrescribirá o agregará al objeto base. undefinedserá copiado

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}

_defectos

El segundo objeto contiene valores predeterminados que se agregarán al objeto base si no existen. undefinedlos valores se copiarán si la clave ya existe.

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

$ .extend

Además, puede valer la pena mencionar jQuery.extend, funciona de manera similar a _.merge y puede ser una mejor opción si ya está usando jQuery.

El segundo objeto sobrescribirá o agregará al objeto base. undefinedlos valores no se copian.

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

Vale la pena mencionar el Object.assign ES6 / ES2015, funciona de manera similar a _.merge y puede ser la mejor opción si ya está utilizando un polyfill ES6 / ES2015 como Babel si desea rellenarlo usted mismo .

El segundo objeto sobrescribirá o agregará al objeto base. undefinedserá copiado

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}

Puede usar cualquiera de estos (siempre que la tecla 3 sea la tecla aguda que desea usar)

arr[ 'key3' ] = value3;

o

arr.key3 = value3;

Si key3 es una variable, entonces debe hacer:

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

Después de esto, solicitar arr.a_keydevolvería el valor de value3, un literal 3.

arr.key3 = value3;

porque su arr no es realmente una matriz ... Es un objeto prototipo. La matriz real sería:

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

Pero todavía no está bien. En realidad debería ser:

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

Simplemente agregando propiedades:

Y queremos agregar prop2 : 2a este objeto, estas son las opciones más convenientes:

1. Operador de punto: object.prop2 = 2;
2. corchetes: object['prop2'] = 2;

Entonces, ¿cuál usamos entonces?

El operador de punto es una sintaxis más limpia y se debe usar de manera predeterminada (imo). Sin embargo, el operador de puntos no es capaz de agregar claves dinámicas a un objeto, lo que puede ser muy útil en algunos casos. Aquí hay un ejemplo:

const obj = {
  prop1: 1
}

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

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

console.log(obj);

Fusionar objetos:

Cuando queremos fusionar las propiedades de 2 objetos, estas son las opciones más convenientes:

1. Object.assign(), toma un objeto de destino como argumento y uno o más objetos de origen y los fusionará. Por ejemplo:

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

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

console.log(object2);

2. Operador de propagación de objetos ...

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

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

console.log(newObj);

¿Cuál usamos?

• La sintaxis de propagación es menos detallada y debe usarse como una imo predeterminada. No olvides transpilar esta sintaxis a sintaxis que es compatible con todos los navegadores porque es relativamente nueva.
• Object.assign() es más dinámico porque tenemos acceso a todos los objetos que se pasan como argumentos y podemos manipularlos antes de que se asignen al nuevo Objeto.

Sé que ya hay una respuesta aceptada para esto, pero pensé que documentaría mi idea en alguna parte. Por favor, [la gente] no dude en hacer agujeros en esta idea, ya que no estoy seguro de si es la mejor solución ... pero acabo de armar esto hace unos minutos:

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

Lo utilizarías de esta manera:

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

Como la función prototipo está regresando this, puede continuar encadenando .pushhasta el final de su objvariable:obj.push(...).push(...).push(...);

Otra característica es que puede pasar una matriz u otro objeto como valor en los argumentos de la función de inserción. Vea mi violín para un ejemplo de trabajo: http://jsfiddle.net/7tEme/

Actuación

Hoy 2020.01.14 realizo pruebas en MacOs HighSierra 10.13.6 en Chrome v78.0.0, Safari v13.0.4 y Firefox v71.0.0, para las soluciones elegidas. Divido las soluciones en mutable (primera letra M) e inmutable (primera letra I). También proporciono algunas soluciones inmutables (IB, IC, ID / IE) aún no publicadas en las respuestas a esta pregunta

Conclusiones

• las soluciones mutables más rápidas son mucho más rápidas que las inmutables más rápidas (> 10x)
• enfoque mutable clásico como obj.key3 = "abc"(MA, MB) es el más rápido
• para soluciones inmutables, {...obj, key3:'abc'}y Object.assign(IA, IB) son más rápidas
• Sorprendentemente, hay soluciones inmutables más rápido que algunas soluciones mutables para cromo (MC-IA) y safari (MD-IB)

Detalles

En el fragmento a continuación hay una solución probada presentada, puede realizar una prueba previa en su máquina AQUÍ

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!

Puedes crear una clase con la respuesta de @ Ionuț G. Stan

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

Crear un nuevo objeto con la última clase:

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

Imprimir el objeto

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

Imprimir una llave

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

Soy novato en javascript, los comentarios son bienvenidos. Funciona para mi.

Dos formas más utilizadas ya mencionadas en la mayoría de las respuestas

obj.key3 = "value3";

obj["key3"] = "value3";

Una forma más de definir una propiedad es usar 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
});

Este método es útil cuando desea tener más control al definir la propiedad. La propiedad definida se puede establecer como enumerable, configurable y escribible por el usuario.

Su ejemplo muestra un objeto, no una matriz. En ese caso, la forma preferida de agregar un campo a un Objeto es simplemente asignarlo, así:

arr.key3 = value3;

compatible con la mayoría de los navegadores, y verifica si la clave de objeto está disponible o no, si está disponible , anula el valor de clave existente y no está disponible , agrega clave con valor

Ejemplo 1

let my_object = {};

// now i want to add something in it  

my_object.red = "this is red color";

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

ejemplo 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"} }

ejemplo 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" 
//            }   
//       }

En caso de que tenga varios literales de objeto anónimos dentro de un objeto y desee agregar otro objeto que contenga pares clave / valor, haga lo siguiente:

Firebug 'el objeto:

console.log(Comicbook);

devoluciones:

[Objeto {nombre = "Spiderman", valor = "11"}, Objeto {nombre = "Marsipulami", valor = "18"}, Objeto {nombre = "Garfield", valor = "2"}]

Código:

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

se agregará Object {name="Peanuts", value="12"}al objeto Comicbook

Ya sea obj['key3'] = value3o obj.key3 = value3agregará el nuevo par al obj.

Sin embargo, sé que jQuery no se mencionó, pero si lo está utilizando, puede agregar el objeto $.extend(obj,{key3: 'value3'}). P.ej:

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. extend (target [, object1] [, objectN]) combina el contenido de dos o más objetos en el primer objeto.

Y también permite adiciones / modificaciones recursivas con $.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>

Una forma corta y elegante en la próxima especificación de Javascript (candidato etapa 3) es:

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

Se puede encontrar una discusión más profunda en Object spread vs Object.assign y en el sitio del Dr. Axel Rauschmayers .

Funciona ya en node.js desde la versión 8.6.0.

Vivaldi, Chrome, Opera y Firefox en versiones actualizadas también conocen esta característica, pero Mirosoft no lo hace hasta hoy, ni en Internet Explorer ni en 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);
    });

Salida como esta: -

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

Puedes agregarlo de esta manera:

arr['key3'] = value3;

o de esta manera:

arr.key3 = value3;

Las respuestas que sugieren introducir el objeto con la variable key3solo funcionarían si el valor de key3fue 'key3'.

Según los descriptores de acceso a propiedades definidos en ECMA-262 ( http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf , P67), hay dos formas de agregar propiedades a existe un objeto Todos estos dos modos, el motor de Javascript los tratará igual.

La primera forma es usar la notación de puntos:

obj.key3 = value3;

Pero de esta manera, debe usar un IdentifierName después de la notación de puntos.

La segunda forma es usar la notación de corchetes:

obj["key3"] = value3;

y otra forma:

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

De esta manera, podría usar una Expresión (incluir IdentifierName ) en la notación de corchetes.

Podemos hacer esto de esta manera también.

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

Ya que es una cuestión del pasado pero el problema del presente. Sugeriría una solución más: simplemente pase la clave y los valores a la función y obtendrá un objeto de mapa.

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

Para anteponer un par clave-valor a un objeto, para que for for funcione con ese elemento primero haga esto:

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

La mejor manera de lograr lo mismo se indica a continuación:

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

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

//console.log(obj);

Puede crear un nuevo objeto utilizando la {[key]: value}sintaxis:

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

Con la sintaxis anterior, ahora puede usar la sintaxis de propagación {...foo, ...bar}para agregar un nuevo objeto sin mutar su valor anterior:

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