Objetos

Funciones más comunes

La clase Object representa uno de los tipos de datos en Javascript. Es usado para guardar una colección de datos definidos y entidades más complejas.

Métodos estáticos

Object.assign()

Copia los valores de todas las propiedades enumerables propias de uno o más objetos fuente al objeto asignado.

const target = { a: 1, b: 2 };
const source = { b: 4, c: 5 };

const returnedTarget = Object.assign(target, source);

console.log(target);
// Expected output: Object { a: 1, b: 4, c: 5 }

console.log(returnedTarget === target);
// Expected output: true

Object.entries()

Devuelve un array que contiene todos los pares [key, value] de las propiedades enumerables en formato cadena de texto que le pertenecen a un objeto dado.

const obj = { foo: 'bar', baz: 42 };
console.log(Object.entries(obj)); // [ ['foo', 'bar'], ['baz', 42] ]

Object.fromEntries()

Devuelve un nuevo objeto de los pares iterables [key, value]. (Este método hace lo contrario a Object.entries).

const entries = new Map([
  ['foo', 'bar'],
  ['baz', 42]
]);

const obj = Object.fromEntries(entries);

console.log(obj);
// Expected output: Object { foo: "bar", baz: 42 }

Object.keys()

Devuelve un arreglo que contiene todos los keys de las propiedades enumerables de tipo cadena de texto pertenecientes al objeto dado.

const object1 = {
  a: 'somestring',
  b: 42,
  c: false
};

console.log(Object.keys(object1));
// Expected output: Array ["a", "b", "c"]

Object.values()

Devuelve un arreglo que contiene todos los valores correspondientes a las propiedades enumerables de tipo cadena de texto pertenecientes a un objeto dado.

const object1 = {
  a: 'somestring',
  b: 42,
  c: false
};

console.log(Object.values(object1));
// Expected output: Array ["somestring", 42, false]

Set

El objeto Set le permite almacenar valores únicos de cualquier tipo, ya sea valores primitivos o referencias a objetos.

const mySet1 = new Set()

mySet1.add(1)             // Set [ 1 ]
mySet1.add(5)             // Set [ 1, 5 ]
mySet1.add(5)             // Set [ 1, 5 ]
mySet1.add('algún texto') // Set [ 1, 5, 'algún texto' ]
const o = {a: 1, b: 2}
mySet1.add(o)

mySet1.add({a: 1, b: 2})   // o está haciendo referencia a un objeto diferente, 
                           // por lo que está bien

mySet1.has(1)              // true
mySet1.has(3)              // false, ya que 3 no se ha agregado al conjunto
mySet1.has(5)              // true
mySet1.has(Math.sqrt(25))  // true
mySet1.has('Algún Texto'.toLowerCase()) // true
mySet1.has(o)       // true

mySet1.size         // 5

mySet1.delete(5)    // elimina 5 del conjunto
mySet1.has(5)       // false, 5 ha sido eliminado

mySet1.size         // 4, ya que acabamos de eliminar un valor

console.log(mySet1)
// output: Set(4) { 1, 'algún texto', { a: 1, b: 2 }, { a: 1, b: 2 } }

Mapas

Un mapa (sustantivo) es una estructura de datos que asocia valores (las llaves) con otros valores. Por ejemplo, es posible que desees mapear nombres a edades. Es posible usar objetos para esto.

let edades = {
  Boris: 39,
  Liang: 22,
  Júlia: 62
};

console.log(`Júlia tiene ${edades["Júlia"]}`);
// → Júlia tiene 62
console.log("Se conoce la edad de Jack?", "Jack" in edades);
// → Se conoce la edad de Jack? false
console.log("Se conoce la edad de toString?", "toString" in edades);
// → Se conoce la edad de toString? true

Como tal, usar objetos simples como mapas es peligroso. Hay varias formas posibles de evitar este problema.

JavaScript viene con una clase llamada Map que esta escrita para este propósito exacto. Esta almacena un mapeo y permite cualquier tipo de llaves.

let edades = new Map();
edades.set("Boris", 39);
edades.set("Liang", 22);
edades.set("Júlia", 62);

console.log(`Júlia tiene ${edades.get("Júlia")}`);
// → Júlia tiene 62
console.log("Se conoce la edad de Jack?", edades.has("Jack"));
// → Se conoce la edad de Jack? false
console.log(edades.has("toString"));
// → false

Los métodos set,get, y has son parte de la interfaz del objeto Map. Escribir una estructura de datos que pueda actualizarse rápidamente y buscar en un gran conjunto de valores no es fácil, pero no tenemos que preocuparnos acerca de eso. Alguien más lo hizo por nosotros, y podemos utilizar esta simple interfaz para usar su trabajo.

Si tienes un objeto simple que necesitas tratar como un mapa por alguna razón, es útil saber que Object.keys solo retorna las llaves propias del objeto, no las que estan en el prototipo. Como alternativa al operador in, puedes usar el métodohasOwnProperty, el cual ignora el prototipo del objeto.

console.log({x: 1}.hasOwnProperty("x"));
// → true
console.log({x: 1}.hasOwnProperty("toString"));
// → false