Return to Answer

On object literals, the key is always interpreted literally, as a string. To use a "dynamic" key, you have to use bracket notation:

var obj = {}; obj[myKey] = value; 

In your case:

stuff = function (thing, callback) { var inputs = $('div.quantity > input').map(function(){ var key = this.attr('name') , value = this.attr('value') , ret = {}; ret[key] = value;   return ret; }) callback(null, inputs); } 

Edit: In the new ES2015 standard for JavaScript (formerly called ES6), objects can be created with computed keys: Object Initializer spec. The syntax is:

var obj = {   [myKey]: value, } 

If applied to the OP's scenario, it would turn into:

stuff = function (thing, callback) { var inputs = $('div.quantity > input').map(function(){   return {  [this.attr('name')]: this.attr('value'), }; }) callback(null, inputs); } 

Using Babel or Google's traceur, it is possible to try this syntax today

In the new ES2015 standard for JavaScript (formerly called ES6), objects can be created with computed keys: Object Initializer spec.

The syntax is:

var obj = { [myKey]: value, } 

If applied to the OP's scenario, it would turn into:

stuff = function (thing, callback) { var inputs = $('div.quantity > input').map(function(){ return {   [this.attr('name')]: this.attr('value'),   }; }) callback(null, inputs); } 

Note: A transpiler is still required for browser compatiblity.

Using Babel or Google's traceur, it is possible to use this syntax today.

In earlier JavaScript specifications (ES5 and below), the key in an object literal is always interpreted literally, as a string.

To use a "dynamic" key, you have to use bracket notation:

var obj = {}; obj[myKey] = value; 

In your case:

stuff = function (thing, callback) { var inputs = $('div.quantity > input').map(function(){ var key = this.attr('name')  , value = this.attr('value')   , ret = {};    ret[key] = value;  return ret; }) callback(null, inputs); } 

On object literals, the key is always interpreted literally, as a string. To use a "dynamic" key, you have to use bracket notation:

var obj = {}; obj[myKey] = value; 

In your case:

stuff = function (thing, callback) { var inputs = $('div.quantity > input').map(function(){ var key = this.attr('name') , value = this.attr('value') , ret = {}; ret[key] = value; return ret; }) callback(null, inputs); } 

Edit: For ES6 (the next version of Javascript), there's a proposal (as of Nov. 2013) for a syntax to create objects with computed keys: Object Literal Computed Property Keys. The syntax is:

var obj = { [myKey]: value, } 

If applied to the OP's scenario, it would turn into:

stuff = function (thing, callback) { var inputs = $('div.quantity > input').map(function(){ return { [this.attr('name')]: this.attr('value'), }; }) callback(null, inputs); } 

Using Babel or Google's traceur, it is possible to try this syntax today

On object literals, the key is always interpreted literally, as a string. To use a "dynamic" key, you have to use bracket notation:

var obj = {}; obj[myKey] = value; 

In your case:

stuff = function (thing, callback) { var inputs = $('div.quantity > input').map(function(){ var key = this.attr('name') , value = this.attr('value') , ret = {}; ret[key] = value; return ret; }) callback(null, inputs); } 

Edit: In the new ES2015 standard for JavaScript (formerly called ES6), objects can be created with computed keys: Object Initializer spec. The syntax is:

var obj = { [myKey]: value, } 

If applied to the OP's scenario, it would turn into:

stuff = function (thing, callback) { var inputs = $('div.quantity > input').map(function(){ return { [this.attr('name')]: this.attr('value'), }; }) callback(null, inputs); } 

Using Babel or Google's traceur, it is possible to try this syntax today

On object literals, the key is always interpreted literally, as a string. To use a "dynamic" key, you have to use bracket notation:

var obj = {}; obj[myKey] = value; 

In your case:

stuff = function (thing, callback) { var inputs = $('div.quantity > input').map(function(){ var key = this.attr('name') , value = this.attr('value') , ret = {}; ret[key] = value; return ret; }) callback(null, inputs); } 

Edit: For ES6 (the next version of Javascript), there's a proposal (as of Nov. 2013) for a syntax to create objects with computed keys: Object Literal Computed Property Keys. The syntax is:

var obj = { [myKey]: value, } 

If applied to the OP's scenario, it would turn into:

stuff = function (thing, callback) { var inputs = $('div.quantity > input').map(function(){ return { [this.attr('name')]: this.attr('value'), }; }) callback(null, inputs); } 

Using Google's traceur, it is possible to try this syntax today

On object literals, the key is always interpreted literally, as a string. To use a "dynamic" key, you have to use bracket notation:

var obj = {}; obj[myKey] = value; 

In your case:

stuff = function (thing, callback) { var inputs = $('div.quantity > input').map(function(){ var key = this.attr('name') , value = this.attr('value') , ret = {}; ret[key] = value; return ret; }) callback(null, inputs); } 

Edit: For ES6 (the next version of Javascript), there's a proposal (as of Nov. 2013) for a syntax to create objects with computed keys: Object Literal Computed Property Keys. The syntax is:

var obj = { [myKey]: value, } 

If applied to the OP's scenario, it would turn into:

stuff = function (thing, callback) { var inputs = $('div.quantity > input').map(function(){ return { [this.attr('name')]: this.attr('value'), }; }) callback(null, inputs); } 

Using Babel or Google's traceur, it is possible to try this syntax today