# Objetos

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 <a href="#metodos_estaticos" id="metodos_estaticos"></a>

`Object.assign()`

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

```javascript
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.

```javascript
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`).

```javascript
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.

```javascript
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.

```javascript
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.

```javascript
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.&#x20;

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étodo`hasOwnProperty`, el cual ignora el prototipo del objeto.

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