# 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
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://shimozurdo.gitbook.io/frontend/html5/javascript/objetos.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.