Styjun

ES6 for the win!

const b = 'b';
const c = 'c';

const data = 
 a: true,
 [b]: true, // dynamic property
 [`interpolated-$c`]: true, // dynamic property + interpolation
 [`$b-$c`]: true

If you log data you get this:

 a: true,
 b: true,
 interpolated-c: true,
 b-c: true

This makes use of the new Computed Property syntax and Template Literals.

Yes it is possible. Assuming:

var data = 
 'PropertyA': 1,
 'PropertyB': 2,
 'PropertyC': 3
;
var propertyName = "someProperty";
var propertyValue = "someValue";

Either:

data[propertyName] = propertyValue;

or

eval("data." + propertyName + " = '" + propertyValue + "'");

The first method is preferred. eval() has the obvious security concerns if you're using values supplied by the user so don't use it if you can avoid it but it's worth knowing it exists and what it can do.

You can reference this with:

alert(data.someProperty);

or

data(data["someProperty"]);

or

alert(data[propertyName]);

I know that the question is answered perfectly, but I also found another way to add new properties and wanted to share it with you:

You can use the function Object.defineProperty()

Found on Mozilla Developer Network

Example:

var o = ; // Creates a new object

// Example of an object property added with defineProperty with a data property descriptor
Object.defineProperty(o, "a", value : 37,
 writable : true,
 enumerable : true,
 configurable : true);
// 'a' property exists in the o object and its value is 37

// Example of an object property added with defineProperty with an accessor property descriptor
var bValue;
Object.defineProperty(o, "b", get : function() return bValue; ,
 set : function(newValue) bValue = newValue; ,
 enumerable : true,
 configurable : true);
o.b = 38;
// 'b' property exists in the o object and its value is 38
// The value of o.b is now always identical to bValue, unless o.b is redefined

// You cannot try to mix both :
Object.defineProperty(o, "conflict", value: 0x9f91102, 
 get: function() return 0xdeadbeef; );
// throws a TypeError: value appears only in data descriptors, get appears only in accessor descriptors

Here, using your notation:

var data = 
 'PropertyA': 1,
 'PropertyB': 2,
 'PropertyC': 3
;
var propName = 'Property' + someUserInput
//imagine someUserInput was 'Z', how can I now add a 'PropertyZ' property to 
//my object?
data[propName] = 'Some New Property value'

in addition to all the previous answers, and in case you're wondering how we're going to write dynamic property names in the Future using Computed Property Names ( ECMAScript 6 ), here's how:

var person = "John Doe";
var personId = "person_" + new Date().getTime();
var personIndex = 
 [ personId ]: person
// ^ computed property name
;

personIndex[ personId ]; // "John Doe"

reference: Understanding ECMAScript 6 - Nickolas Zakas

You can add as many more properties as you like simply by using the dot notation:

var data = 
 var1:'somevalue'

data.newAttribute = 'newvalue'

or:

data[newattribute] = somevalue

for dynamic keys.

Just an addition to abeing's answer above. You can define a function to encapsulate the complexity of defineProperty as mentioned below.

var defineProp = function ( obj, key, value )
 var config = 
 value: value,
 writable: true,
 enumerable: true,
 configurable: true
 ;
 Object.defineProperty( obj, key, config );
;

//Call the method to add properties to any object
defineProp( data, "PropertyA", 1 );
defineProp( data, "PropertyB", 2 );
defineProp( data, "PropertyC", 3 );

reference: http://addyosmani.com/resources/essentialjsdesignpatterns/book/#constructorpatternjavascript

You can add properties dynamically using some of the options below:

In you example:

var data = 
 'PropertyA': 1,
 'PropertyB': 2,
 'PropertyC': 3
;

You can define a property with a dynamic value in the next two ways:

data.key = value;

or

data['key'] = value;

Even more..if your key is also dynamic you can define using the Object class with:

Object.defineProperty(data, key, withValue(value));

where data is your object, key is the variable to store the key name and value is the variable to store the value.

I hope this helps!

I know there are several answers to this post already, but I haven't seen one wherein there are multiple properties and they are within an array. And this solution by the way is for ES6.

For illustration, let's say we have an array named person with objects inside:

 let Person = [id:1, Name: "John", id:2, Name: "Susan", id:3, Name: "Jet"]

So, you can add a property with corresponding value. Let's say we want to add a Language with a default value of EN.

Person.map((obj)=>(...obj,['Language']:"EN"))

The Person array now would become like this:

Person = [id:1, Name: "John", Language:"EN", 
id:2, Name: "Susan", Language:"EN", id:3, Name: "Jet", Language:"EN"]

The simplest and most portable way is.

var varFieldName = "good";
var ob = ;
Object.defineProperty(ob, varFieldName , value: "Fresh Value" );

Based on #abeing answer!

ES6 introduces computed property names, which allow you to do

let a = 'key'
let myObj = [a]: 10;
// output will be key:10

A nice way to access from dynamic string names that contain objects (for example object.subobject.property)

function ReadValue(varname)

 var v=varname.split(".");
 var o=window;
 if(!v.length)
 return undefined;
 for(var i=0;i<v.length-1;i++)
 o=o[v[i]];
 return o[v[v.length-1]];


function AssignValue(varname,value)

 var v=varname.split(".");
 var o=window;
 if(!v.length)
 return;
 for(var i=0;i<v.length-1;i++)
 o=o[v[i]];
 o[v[v.length-1]]=value;

Example:

ReadValue("object.subobject.property");
WriteValue("object.subobject.property",5);

eval works for read value, but write value is a bit harder.

A more advanced version (Create subclasses if they dont exists, and allows objects instead of global variables)

function ReadValue(varname,o=window)

 if(typeof(varname)==="undefined" 

function AssignValue(varname,value,o=window)
 typeof(o)==="undefined" 

Example:

ReadValue("object.subobject.property",o);
WriteValue("object.subobject.property",5,o);

This is the same that o.object.subobject.property

Be careful while adding a property to the existing object using .(dot) method.

(.dot) method of adding a property to the object should only be used if you know the 'key' beforehand otherwise use the [bracket] method.

Example:

 var data = 
 'Property1': 1
 ;
 
 // Two methods of adding a new property [ key (Property4), value (4) ] to the
 // existing object (data)
 data['Property2'] = 2; // bracket method
 data.Property3 = 3; // dot method
 console.log(data); // Property1: 1, Property2: 2, Property3: 3 
 
 // But if 'key' of a property is unknown and will be found / calculated
 // dynamically then use only [bracket] method not a dot method 
 var key;
 for(var i = 4; i < 6; ++i) 
 	key = 'Property' + i; // Key - dynamically calculated
 	data[key] = i; // CORRECT !!!!
 
 console.log(data); 
 // Property1: 1, Property2: 2, Property3: 3, Property4: 4, Property5: 5 
 
 for(var i = 6; i < 2000; ++i) 
 	key = 'Property' + i; // Key - dynamically calculated
 	data.key = i; // WRONG !!!!!
 
 console.log(data); 
 // Property1: 1, Property2: 2, Property3: 3, 
 // Property4: 4, Property5: 5, key: 1999 

Note the problem in the end of console log -
'key: 1999' instead of Property6: 6, Property7: 7,.........,Property1999: 1999. So the best way of adding dynamically created property is the [bracket] method.

Here's how I solved the problem.

var obj = 

;
var field = "someouter.someinner.someValue";
var value = 123;

function _addField( obj, field, value )

 // split the field into tokens
 var tokens = field.split( '.' );

 // if there's more than one token, this field is an object
 if( tokens.length > 1 )
 
 var subObj = tokens[0];

 // define the object
 if( obj[ subObj ] !== undefined ) obj[ subObj ] = ;

 // call addfield again on the embedded object
 var firstDot = field.indexOf( '.' );
 _addField( obj[ subObj ], field.substr( firstDot + 1 ), value );

 
 else
 
 // no embedded objects, just field assignment
 obj[ field ] = value;
 


_addField( obj, field, value );
_addField(obj, 'simpleString', 'string');

console.log( JSON.stringify( obj, null, 2 ) );

Generates the following object:

 "someouter": 
 "someinner": 
 "someValue": 123
 
 ,
 "simpleString": "string"

A perfect easy way

var data = 
 'PropertyA': 1,
 'PropertyB': 2,
 'PropertyC': 3
;

var newProperty = 'getThisFromUser';
data[newProperty] = 4;

console.log(data);

If you want to apply it on an array of data (ES6/TS version)

const data = [
 'PropertyA': 1, 'PropertyB': 2, 'PropertyC': 3 ,
 'PropertyA': 11, 'PropertyB': 22, 'PropertyC': 33 
];

const newProperty = 'getThisFromUser';
data.map( (d) => d[newProperty] = 4 );

console.log(data);