Adding elements to an object

The line of code below defines element as a plain object.

let element = {}

This type of JavaScript object with {} around it has no push() method. To add new items to an object like this, use this syntax:

element[yourKey] = yourValue

To put it all together, see the example below:

let element = {} // make an empty object

/* --- Add Things To The Object --- */

element['active'] = true // 'active' is the key, and 'true' is the value
console.log(element) // Expected result -> {active: true}


element['state'] = 'slow' // 'state' is the key and 'slow' is the value
console.log(element) // Expected result -> {active: true, state: 'slow'}

On the other hand, if you defined the object as an array (i.e. using [] instead of {}), then you can add new elements using the push() method.

To append to an object use Object.assign

var ElementList ={}

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

Output:

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

If the cart has to be stored as an object and not array (Although I would recommend storing as an []) you can always change the structure to use the ID as the key:

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

This allows you to add multiple items to the cart like so:

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

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

Adding new key/pair elements into the original object:

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 new value:

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

I was reading something related to this try if it is useful.

1.Define a push function inside a object.

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

Now you can push elements like an array

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

This will produce this object

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

Notice the elements are added with indexes and also see that there is a new length property added to the object.This will be useful to find the length of the object too.This works because of the generic nature of push() function

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

you should write var element = [];
in javascript {} is an empty object and [] is an empty array.

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

this code is worked.

Try this:

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

If anyone comes looking to create a similar JSON, just without using cart as an array, here goes:

I have an array of objects myArr as:

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

and I will attempt to create a JSON with the following structure:

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

you can simply do-

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

In ES9, you can add multiple elements to an object using object spread syntax, which has the benefit of avoiding repeated code:

let myObj = { 
  name: "John", 
  age: 30,
};

myObj = {
  ...myObj, // spread the original myObj elements
  city: "New York", 
  country: "USA",
};

console.log(myObj); // { name: "John", age: 30, city: "New York", country: "USA" }

In this example, we added two new properties city and country to the myObj object using object spread syntax.

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

OR:

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

obj.key2 = 'value2';

push is an method of arrays , so for object you can get the index of last element ,and you can probably do the same job as push for object as below

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

then add object to the new index of element

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

For anyone still looking for a solution, I think that the objects should have been stored in an array like...

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

Then when you want to use an element as an object you can do this...

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

Put a variable at "id_that_we_want" and give it the id of the element that we want from our array. An "elemnt" object is returned. Of course we dont have to us id to find the object. We could use any other property to do the find.

My proposition is to use different data structure that proposed already in other answers - it allows you to make push on card.elements and allow to expand card properties:

let card = {
  elements: [
    {"id":10,"quantity":1}
  ],

  //other card fields like 'owner' or something...
}

card.elements.push({"id":22,"quantity":3})

console.log(card);

if you not design to do loop with in JS e.g. pass to PHP to do loop for you

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

this concept may help a bit

This is an old question, anyway today the best practice is by using 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

Maybe everyone has taken this for granted:

const array = new Array("Saab", "Volvo");
const object_as_value = new Object({firstName:"John", lastName:"Doe", age:50, eyeColor:"blue"});

function function_returns(){
    return "value 2"
}

var obj = {
    key1: array,
    key2: object_as_value,
    key3: function_returns()
}

console.log(obj)

Form a blog post:

ES6 computed property names feature allows you to assign an expression as the property name to an object within object literal notation. There is no need to create an object first.

You can also use template literals (string interpolation) as an expression for the computed property names:

const key = 'name';
const value = 'Atta';
> 
const user = {
    [key + '34']: value
};

console.log(user.name34); // Atta

Please also check https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer#computed_property_names

In case anyone else needs this, I finally found a good way to add objects or arrays of objects:

var myobj = {}

// These two options only work for single-valued keys, not arrays or objects
myobj["a"] = 1
myobj.b = 2

// This one works for everyting:
Object.assign(myobj, {"key": "value"});  // single-value

// Add object
Object.assign(myobj, {"subobj": 
  {
    "c": 3
  }
});

// Add array of objects
Object.assign(myobj, {"subarr": 
  [
    {
      "d": 4,
    },
    {
      "e": 5
    }
  ]
});