ES6 in Action: Enhanced Object Literals

This article looks at what’s possible with object literals in JavaScript, especially in the light of recent ECMAScript updates.
The ability to create JavaScript objects using literal notation is powerful. New features introduced from ES2015 (ES6) make object handling even easier in all modern browsers (not IE) and Node.js.
Creating objects in some languages can be expensive in terms of development time and processing power when a class must be declared before anything can be achieved. In JavaScript, it’s easy to create objects on the fly. For example:
// ES5-compatible code
var myObject = {
prop1: ‘hello’,
prop2: ‘world’,
output: function() {
console.log(this.prop1 + ‘ ‘ + this.prop2);
}
};

myObject.output(); // hello world

Single-use objects are used extensively. Examples include configuration settings, module definitions, method parameters, return values from functions, etc. ES2015 (ES6) added a range of features to enhance object literals.
Object Initialization From Variables
Objects’ properties are often created from variables with the same name. For example:
// ES5 code
var
a = 1, b = 2, c = 3;
obj = {
a: a,
b: b,
c: c
};

// obj.a = 1, obj.b = 2, obj.c = 3

There’s no need for nasty repetition in ES6!…
// ES6 code
const
a = 1, b = 2, c = 3;
obj = {
a
b
c
};

// obj.a = 1, obj.b = 2, obj.c = 3

This could be useful for returned objects when using a revealing module pattern, which (effectively) namespaces code in order to avoid naming conflicts. For example:
// ES6 code
const lib = (() => {

function sum(a, b) { return a + b; }
function mult(a, b) { return a * b; }

return {
sum,
mult
};

}());

console.log( lib.sum(2, 3) ); // 5
console.log( lib.mult(2, 3) ); // 6

You’ve possibly seen it used in ES6 modules:
// lib.js
function sum(a, b) { return a + b; }
function mult(a, b) { return a * b; }

export { sum, mult };

Object Method Definition Shorthand
Object methods in ES5 require the function statement. For example:
// ES5 code
var lib = {
sum: function(a, b) { return a + b; },
mult: function(a, b) { return a * b; }
};

console.log( lib.sum(2, 3) ); // 5
console.log( lib.mult(2, 3) ); // 6

This is no longer necessary in ES6; it permits the following shorthand syntax:
// ES6 code
const lib = {
sum(a, b) { return a + b; },
mult(a, b) { return a * b; }
};

console.log( lib.sum(2, 3) ); // 5
console.log( lib.mult(2, 3) ); // 6

It’s not possible to use ES6 fat arrow => function syntax here, because the method requires a name. That said, you can use arrow functions if you name each method directly (like ES5). For example:
// ES6 code
const lib = {
sum: (a, b) => a + b,
mult: (a, b) => a * b
};

console.log( lib.sum(2, 3) ); // 5
console.log( lib.mult(2, 3) ); // 6

Continue reading %ES6 in Action: Enhanced Object Literals%

Link: https://www.sitepoint.com/es6-enhanced-object-literals/