Adicionando elementos ao objeto

Eu preciso preencher um arquivo json, agora tenho algo parecido com isto:

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

E eu preciso adicionar outro "elemento". Meu primeiro passo é colocar esse json em um tipo de objeto usando cart = JSON.parse, agora eu preciso adicionar o novo elemento. Eu deveria usar cart.pushpara adicionar outro elemento, tentei o seguinte:

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

Mas recebi o erro "O objeto não tem método de envio" quando tento fazer element.push, e acho que estou fazendo algo MUITO errado, porque não estou dizendo o "elemento" em lugar algum.

Como eu posso fazer isso?

Edit: desculpe a todos, eu tinha muita confusão na minha cabeça.

Eu pensei que poderia obter apenas o tipo de objeto ao obter dados JSON.parse, mas recebo o que coloquei no JSON em primeiro lugar.

Colocar array em vez de objeto resolveu meu problema, usei muitas sugestões aqui também, obrigado a todos!

Seu elemento não é uma matriz, no entanto, seu carrinho precisa ser uma matriz para suportar muitos objetos de elemento. Exemplo de código:

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

Se você deseja que o carrinho seja uma matriz de objetos no formulário { element: { id: 10, quantity: 1} }, execute:

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

JSON.stringify() foi mencionado como uma preocupação no comentário:

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

Com essa linha

var element = {};

você define elementcomo um objeto simples. O objeto JavaScript nativo não possui push()método. Para adicionar novos itens a um objeto simples, use esta sintaxe:

element[ yourKey ] = yourValue;

Por outro lado, você pode definir elementcomo uma matriz usando

var element = [];

Então você pode adicionar elementos usando push().

Se o carrinho tiver que ser armazenado como um objeto e não como uma matriz (embora eu recomendo armazenar como um []), você sempre poderá alterar a estrutura para usar o ID como chave:

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

Isso permite que você adicione vários itens ao carrinho da seguinte maneira:

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

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

Para acrescentar a um objeto, use Object.assign

var ElementList ={}

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

Resultado:

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

você deve escrever var element = [];
em javascript {}é um objeto vazio e []é uma matriz vazia.

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

Eu estava lendo algo relacionado a essa tentativa, se for útil.

1. Defina uma função push dentro de um objeto.

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

Agora você pode enviar elementos como uma matriz

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

Isso produzirá esse objeto

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

Observe que os elementos são adicionados com índices e também observe que há uma nova propriedade de comprimento adicionada ao objeto. Isso também será útil para encontrar o comprimento do objeto. Isso funciona devido à natureza genérica da push()função

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 é trabalhado.

Tente o seguinte:

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

Adicionando novos elementos de chave / par ao 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 novo valor:

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

Se alguém procura criar um JSON semelhante, apenas sem usar cartcomo uma matriz, aqui vai:

Eu tenho uma matriz de objetos myArrcomo:

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

e tentarei criar um JSON com a seguinte estrutura:

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

você pode simplesmente fazer

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

Para quem ainda procura uma solução, acho que os objetos deveriam ter sido armazenados em uma matriz como ...

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

Então, quando você quiser usar um elemento como objeto, poderá fazer isso ...

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

Coloque uma variável em "id_that_we_want" e forneça o ID do elemento que queremos da nossa matriz. Um objeto "elemnt" é retornado. É claro que não precisamos nos identificar para encontrar o objeto. Poderíamos usar qualquer outra propriedade para fazer a descoberta.

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

OU:

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

obj.key2 = 'value2';

push é um método de matrizes, portanto, para objeto, você pode obter o índice do último elemento e provavelmente pode fazer o mesmo trabalho que push para objeto, conforme abaixo

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

Em seguida, adicione o objeto ao novo índice do elemento

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

se você não deseja fazer loop em JS, por exemplo, passe para PHP para fazer loop para você

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

esse conceito pode ajudar um pouco

Essa é uma pergunta antiga. Hoje, a melhor prática é 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