Con la entrada de ES6, el objeto Object ha sufrido una actualización, incorporando nuevos métodos estáticos que lo complementan. Vamos a explorarlos.

Object.assign()

Con este método, podemos copiar todas las propiedades enumerables propias de uno o varios objetos (que denominaremos source) a otro objeto (que llamaremos target).

Object.assign(target, source_1, ..., source_n)

Veamos como funciona:

var targetObj = {}; 
var sourceObj1 = {}; 
var sourceObj2 = {}; 
target.a = 1;
sourceObj1.b = 2;
sourceObj2.c = 3;
Object.assign(targetObj, sourceObj1, sourceObj2);
console.log(targetObj.b, targetObj.c) //2, 3

//example with returned object
var copy = Object.assign({}, sourceObj1);
console.log(copy); // { b: 2 }

Object.is()

El método Object.is() determina si dos objetos son iguales.

Object.assign(target, source_1, ..., source_n)

El método Object.is() es similar al operador === con la diferencia qe que éste último trata los valores -0 y +0 como iguales, y además, trata Number.NaN como no igual a NaN.

Veamos unos ejemplos:

Object.is('foo', 'foo');     // true
Object.is(window, window);   // true

Object.is('foo', 'bar');     // false
Object.is([], []);           // false

var test = { a: 1 };
Object.is(test, test);       // true

Object.is(null, null);       // true
Object.is(undefined, undefined);       // true

// Special Cases
Object.is(0, -0);            // false
Object.is(-0, -0);           // true
Object.is(NaN, 0/0);         // true

Object.setPrototypeOf()

El método Object.setPrototypeOf() establece el prototype de un objeto especificado (lo llamaremos prototype) a otro objeto (lo llamaremos target) o sino establece null.

Object.setPrototypeOf(target, prototype)

Veamos un par de ejemplos:

//example 1, prototype null
var dict = Object.setPrototypeOf({}, null);

//example 2
var bicycle = {
 //ES6 way to define method
 speed() { console.log('15km/h')}
};

var mountainBike = {
  trial() { return true; }
};

Object.setPrototypeOf(mountainBike, bicycle);
mountainBike.speed(); //15km/h

Puedes mirar la documentación de Mozilla para casos más complejos como agregar una cadena entera de prototipos a el prototipo nuevo del objeto.

Object.getOwnPropertySymbols()

ES6 incorpora un nuevo tipo de datos llamado Symbol, que son únicos (en la mayoría de casos) e inmutables.

Veamos unos pocos ejemplos de de como crear símbolos:

var sym1 = Symbol();
var sym2 = Symbol("foo");
var sym3 = Symbol("foo");
Symbol("foo") === Symbol("foo"); // false

Desde mi punto de vista, el uso de símbolos en Javascript le dota de mucha potencia de cara a la metaprogramación, pero eso es otro tema que da para varios artículos. De momento, podemos pensar en Symbol como una forma de crear etiquetas realmente únicas. Me explicaré mejor con un ejemplo:

//ES5
log.levels = {  
    DEBUG: 'debug',
    INFO: 'info'
};
log(log.levels.DEBUG, 'debug message');  
log(log.levels.INFO, 'info message');
log('info', 'info message'); //this is logged like log.levels.INFO

//ES6
log.levels = {  
    DEBUG: Symbol('debug'),
    INFO: Symbol('info')
};
log(log.levels.DEBUG, 'debug message');  
log(log.levels.INFO, 'info message');
log(Symbol('info'), 'info message'); //this log level is not recognized

Los Symbols no se listan con la llamada Object.getOwnPropertyNames(), sino que tienen su propio método: Object.getOwnPropertySymbols(obj)

Veamos como funciona Object.getOwnPropertySymbols(obj):

var obj = {};
var a = Symbol('a');
var b = Symbol('b');

obj[a] = 'Symbol1';
obj[b] = 'Symbol2';

var objectSymbols = Object.getOwnPropertySymbols(obj);

console.log(objectSymbols.length); // 2
console.log(objectSymbols);        // [Symbol(a), Symbol(b)]
console.log(objectSymbols[0]);     // Symbol(a)

Abreviación de Object.prototype

No es propiamente un método, pero ya que hablamos de las novedades que incorpora ES6 a la clase Object, aprovecho para comentarlo: podemos usar {} como abreviación de Object.prototype..

Con ES6, puedes acceder a los métodos de Object.prototype a través de un objeto literal vacío, es decir, {}.

Es decir, las dos lineas a continuación son equivalentes:

Object.prototype.hasOwnProperty.call(obj, 'propKey')
{}.hasOwnProperty.call(obj, 'propKey')

Esas son las novedades que aporta ES6 sobre la clase Object. ¿Qué te parecen? ¿A cuál le vas a sacar más provecho?

¡¡Saludos!!