Agregar elementos al objeto

Necesito completar un archivo json, ahora tengo algo como esto:

{"element":{"id":10,"quantity":1}}

Y necesito agregar otro "elemento". Mi primer paso es poner ese json en un tipo de objeto usando cart = JSON.parse, ahora necesito agregar el nuevo elemento. Supuse que debía usar cart.pushpara agregar otro elemento, probé esto:

var element = {};
element.push({ id: id, quantity: quantity });
cart.push(element);

Pero recibí el error "El objeto no tiene método de inserción" cuando intento hacerlo element.push, y creo que estoy haciendo algo MUY mal porque no estoy diciendo el "elemento" en ninguna parte.

¿Cómo puedo hacer eso?

Editar: lo siento por todo lo que tenía mucha confusión en mi cabeza.

Pensé que solo podía obtener el tipo de objeto al tomar datos JSON.parse, pero en primer lugar obtengo lo que puse en el JSON.

Poner una matriz en lugar de un objeto resolvió mi problema, también utilicé muchas sugerencias, ¡gracias a todos!

Su elemento no es una matriz, sin embargo, su carrito debe ser una matriz para admitir muchos objetos de elemento. Ejemplo de código:

var element = {}, cart = [];
element.id = id;
element.quantity = quantity;
cart.push(element);

Si desea que el carrito sea una matriz de objetos en el formulario { element: { id: 10, quantity: 1} }, realice:

var element = {}, cart = [];
element.id = id;
element.quantity = quantity;
cart.push({element: element});

JSON.stringify() fue mencionado como una preocupación en el comentario:

>> JSON.stringify([{a: 1}, {a: 2}]) 
      "[{"a":1},{"a":2}]" 

Con esa fila

var element = {};

usted define elementpara ser un objeto simple. El objeto JavaScript nativo no tiene push()método. Para agregar nuevos elementos a un objeto plano, use esta sintaxis:

element[ yourKey ] = yourValue;

Por otro lado, podría definir elementcomo una matriz utilizando

var element = [];

Luego puede agregar elementos usando push().

Si el carrito debe almacenarse como un objeto y no como una matriz (aunque recomendaría almacenarlo como []), siempre puede cambiar la estructura para usar la ID como clave:

var element = { quantity: quantity };
cart[id] = element;

Esto le permite agregar múltiples artículos al carrito de la siguiente manera:

cart["1"] = { quantity: 5};
cart["2"] = { quantity: 10};

// Cart is now:
// { "1": { quantity: 5 }, "2": { quantity: 10 } }

Para anexar a un objeto use Object.assign

var ElementList ={}

function addElement (ElementList, element) {
    let newList = Object.assign(ElementList, element)
    return newList
}
console.log(ElementList)

Salida:

{"elemento": {"id": 10, "cantidad": 1}, "elemento": {"id": 11, "cantidad": 2}}

Estaba leyendo algo relacionado con este intento si es útil.

1. Defina una función de inserción dentro de un objeto.

let obj={push:function push(element){ [].push.call(this,element)}};

Ahora puedes empujar elementos como una matriz

obj.push(1)
obj.push({a:1})
obj.push([1,2,3])

Esto producirá este objeto

obj={
 0: 1
 1: {a: 1}
 2: (3) [1, 2, 3]
 length: 3
}

Observe que los elementos se agregan con índices y también vea que hay una nueva propiedad de longitud agregada al objeto. Esto será útil para encontrar la longitud del objeto también. Esto funciona debido a la naturaleza genérica de la push()función

debe escribir var element = [];
en javascript {}es un objeto vacío y []es una matriz vacía.

cart.push({"element":{ id: id, quantity: quantity }});

function addValueInObject(object, key, value) {
    var res = {};
    var textObject = JSON.stringify(object);
    if (textObject === '{}') {
        res = JSON.parse('{"' + key + '":"' + value + '"}');
    } else {
        res = JSON.parse('{' + textObject.substring(1, textObject.length - 1) + ',"' + key + '":"' + value + '"}');
    }
    return res;
}

Este código está trabajado.

Prueba esto:

var data = [{field:"Data",type:"date"},  {field:"Numero",type:"number"}];

var columns = {};

var index = 0;

$.each(data, function() {

    columns[index] = {
        field : this.field,
        type : this.type
    };

    index++;
});

console.log(columns);

Agregar nuevos elementos clave / par en el objeto original:

const obj = { a:1, b:2 }
const add = { c:3, d:4, e: ['x','y','z'] }

Object.entries(add).forEach(([key,value]) => {obj[key] = value })

obj nuevo valor:

{a: 1, b: 2, c: 3, d: 4, e: ["x", "y", "z"] }

Si alguien busca crear un JSON similar, simplemente sin usarlo cartcomo una matriz, aquí va:

Tengo una variedad de objetos myArrcomo:

var myArr = [{resourceType:"myRT",
            id: 1,
            value:"ha"},
            {resourceType:"myRT",
            id: 2,
            value:"he"},
            {resourceType:"myRT",
            id: 3,
            value:"Li"}];

e intentaré crear un JSON con la siguiente estructura:

{
 "1":{"resourceType":"myRT","id":"1","value":"ha"},
 "2":{"resourceType":"myRT","id":"2","value":"he"},
 "3":{"resourceType":"myRT","id":"3","value":"Li"}
}

simplemente puedes hacer-

var cart = {};
myArr.map(function(myObj){
                    cart[myObj.id]= myObj;
                    });

Para cualquiera que todavía esté buscando una solución, creo que los objetos deberían haberse almacenado en una matriz como ...

var element = {}, cart = [];
element.id = id;
element.quantity = quantity;
cart.push(element);

Luego, cuando desee utilizar un elemento como un objeto, puede hacer esto ...

var element = cart.find(function (el) { return el.id === "id_that_we_want";});

Pon una variable en "id_that_we_want" y dale la identificación del elemento que queremos de nuestra matriz. Se devuelve un objeto "elemnt". Por supuesto, no tenemos que identificarnos para encontrar el objeto. Podríamos usar cualquier otra propiedad para hacer el hallazgo.

 function addValueInObject(value, object, key) {

        var addMoreOptions = eval('{"'  + key + '":' +  value + '}');

        if(addMoreOptions != null) {
            var textObject = JSON.stringify(object);
            textObject = textObject.substring(1,textObject.length-1);
            var AddElement = JSON.stringify(addMoreOptions);
            object = eval('{' + textObject +','+  AddElement.substring(1,AddElement.length-1) + '}');
        }
        return object;
    }

addValueInObject('sdfasfas', yourObject, 'keyname');

O:

var obj = {'key':'value'};

obj.key2 = 'value2';

push es un método de matrices, por lo que para el objeto puede obtener el índice del último elemento, y probablemente pueda hacer el mismo trabajo que push para el objeto como se muestra a continuación

var lastIndex = Object.keys(element)[Object.keys(element).length-1];

luego agregue el objeto al nuevo índice del elemento

element[parseInt(lastIndex) +1] = { id: id, quantity: quantity };

si no diseñas para hacer un bucle en JS, por ejemplo, pasa a PHP para hacer un bucle por ti

let decision = {}
decision[code+'#'+row] = event.target.value

este concepto puede ayudar un poco

Esta es una vieja pregunta, de todos modos hoy en día la mejor práctica es usar Object.defineProperty

const object1 = {};

Object.defineProperty(object1, 'property1', {
  value: 42,
  writable: false
});

object1.property1 = 77;
// throws an error in strict mode

console.log(object1.property1);
// expected output: 42