Jul 5, 2020 · Jun 13, 2020 · Jun 16, 2020 · Jun 16, 2020 · Jun 16, 2020 · Jul 2, 2020
diff --git a/1-js/04-object-basics/08-symbol/article.md b/1-js/04-object-basics/08-symbol/article.md

 #Symbol type
 #Tipo Symbol

 By specification, object property keys may be either of string type, or of symbol type. Not numbers, not booleans, only strings or symbols, these two types.
 Por especificación, las claves (Keys) de un objeto deben ser solamente del tipo String o Symbol.  Solamente esos dos: String o Symbol.

 Till now we've been using only strings. Now let's see the benefits that symbols can give us.
 Hasta ahora sólo hemos aprendido acerca de los Strings, por lo que es momento de conocer las ventajas que Symbol nos puede dar.

 ## Symbols

 A "symbol" represents a unique identifier.
 El valor de "Symbol" representa un identificador único.

 A value of this type can be created using `Symbol()`:
 Un valor de este tipo puede ser creado usando `Symbol()`:

 ```js
 // idis a new symbol
 // ides un nuevo symbol
 let id = Symbol();
 ```

 Upon creation, we can give symbol a description (also called asymbol name),mostly useful for debugging purposes:
 También le podemos agregar una descripción (también llamadasymbol name),que será útil en la depuración de código:

 ```js
 // idis a symbolwith the description "id"
 ```js run
 // ides un symbolcon la descripción "id"
 let id = Symbol("id");
 ```

 Symbols are guaranteed to be unique. Even if we create many symbols with the same description, they are different values. The description is just a label that doesn't affect anything.
 Se garantiza que los símbolos son únicos. Aunque declaremos varios Symbols con la misma descripción, éstos tendrán valores distintos. La descripción es solamente una etiqueta que no afecta nada más.

 For instance, here are two symbols with the same description --they are not equal:
 Por ejemplo, aquí hay dos Symbols con la misma descripción --pero no son iguales:

 ```js run
 let id1 = Symbol("id");
 */!*
 ```

 If you are familiar withRubyor another language that also has some sort of "symbols" --please don't be misguided. JavaScript symbols are different.
 Si estás familiarizado conRubyu otro lenguaje que también tienesymbols --por favor no te confundas. Los Symbols de Javascript son diferentes.

 ````warn header="Symbolsdon't auto-convert to astring"
 Most values inJavaScriptsupport implicit conversion to a string.For instance, we can `alert` almost any value, and it will work.Symbolsare special. They don'tauto-convert.
 ````warn header="Symbolsno se autoconvierten aString"
 La mayoría de los valores enJavaScriptsoportan la conversión implícita a string.Por ejemplo, podemos hacer un ´alert´ con casi cualquier valor y funcionará. LosSymbolsson distintos, éstos no seauto-convierten.

 For instance, this `alert`will show an error:
 Por ejemplo, este `alert`mostrará un error:

 ```js run
 let id = Symbol("id");
 *!*
 alert(id); // TypeError:Cannot convert a Symbol value to a string
 alert(id); // TypeError:No puedes convertir un valor Symbol en string
 */!*
 ```

 That's a "language guard" against messing up, because strings and symbols are fundamentally different and should not accidentally convert one into another.
 Esa es una "protección del lenguaje" para evitar errores ya que los String y los Symbol son diferentes y no deberían convertirse ocasionalmente uno en otro.

 If we really want to show a symbol, we need to explicitly call`.toString()`on it, like here:
 Si realmente queremos mostrar un Symbol, necesitamos llamar el método`.toString()`de la siguiente manera:
 ```js run
 let id = Symbol("id");
 *!*
 alert(id.toString()); // Symbol(id),now it works
 alert(id.toString()); // Symbol(id),ahora sí funciona
 */!*
 ```

 Or get`symbol.description`property to show the description only:
 O se puede utilizar`symbol.description`para obtener la descripción solamente:
 ```js run
 let id = Symbol("id");
 *!*

 ````

 ##"Hidden" properties
 ##Claves "Ocultas"

 Symbolsallow us to create "hidden" properties of an object, that no other part of code can accidentally access or overwrite.
 LosSymbolsnos permiten crear claves "ocultas" en un objeto, a las cuales ninguna otra parte del código puede accesar ni sobrescribir.

 For instance, if we're working with `user` objects, that belong to a third-party code. We'd like to add identifiers to them.

 Let's use a symbol key for it:
 Por ejemplo, si queremos guardar un "identificador" para el objeto `user`, podemos asignar un symbol como clave del objeto:

 ```js run
 let user = { //belongs to another code
 let user = { //pertenece a otro código
  name: "John"
 };

 let id = Symbol("id");

 user[id] = 1;

 alert( user[id] ); //we can access the data using thesymbolas the key
 alert( user[id] ); //podemos accesar a la información utilizando  elsymbolcomo nombre de clave
 ```

 What's the benefit of using`Symbol("id")`over a string `"id"`?
 ¿Cuál es la ventaja de usar`Symbol("id")`y no un string `"id"`?

 As `user` objects belongs to another code, and that code also works with them, we shouldn't just add any fields to it. That's unsafe. But a symbol cannot be accessed accidentally, the third-party code probably won't even see it, so it's probably all right to do.
 Vamos a profundizar en el ejemplo para que sea más claro.

 Also, imagine that anotherscriptwants to have its own identifier inside `user`, for its own purposes. That may be another JavaScript library, so that the scripts are completely unaware of each other.
 Imagina que otroscriptquiere tener la clave "id" dentro de `user` para sus propios fines. Puede ser otra librería de JavaScript, por lo cual ninguno de los scripts saben de su coexistencia.

 Then thatscriptcan create its own `Symbol("id")`,like this:
 Y entonces esescriptpuede crear su propio `Symbol("id")`,como este:

 ```js
 // ...
 let id = Symbol("id");

 user[id] = "Their id value";
 user[id] = "Su id";
 ```

 There will be no conflict between our and their identifiers, because symbols are always different, even if they have the same name.
 No habrá conflicto porque los Symbols siempre son diferentes, incluso si tienen el mismo nombre.

 ...But if we used astring `"id"`instead of a symbol for the same purpose, then there *would* be a conflict:
 Ahora ten en cuenta que si utilizamos unstring `"id"`en lugar de un Symbol para el mismo propósito, entonces SÍ *habría* un conflicto:

 ```js run
 let user = { name: "John" };

 //Our scriptuses"id"property
 user.id = "Our id value";
 //Nuestro scriptusa la clave"id"
 user.id = "Nuestro valor id";

 // ...Another scriptalso wants"id"for its purposes...
 // ...Otro scripttambién quiere usar"id"...

 user.id = "Their id value"
 // Boom!overwritten by another script!
 user.id = "Su valor de id"
 // Boom!sobreescrito para otro script!
 ```

 ### Symbolsin a literal
 ### Symbolsen objetos literales

 If we want to use a symbol in an objectliteral `{...}`, we need square brackets around it.
 Si queremos usar un Symbol en un objetoliteral, debemos usar llaves.

 Like this:
 Como se muestra a continuación:

 ```js
 let id = Symbol("id");

 let user = {
  name: "John",
 *!*
  [id]: 123 //not "id: 123"
  [id]: 123 //no "id: 123"
 */!*
 };
 ```
 That's because we need the value from thevariable `id`as the key, not the string "id".
 Se hace así porque necesitamos que el valor de lavariable `id`sea la clave, no el string "id".

 ### Symbolsare skipped by for..in
 ###LosSymbolsson omitidos en for..in

 Symbolic properties do not participate in`for..in` loop.
 Las claves de Symbol no participan dentro de los ciclos`for..in`.

 For instance:
 Por ejemplo:

 ```js run
 let id = Symbol("id");
 };

 *!*
 for (let key in user) alert(key); //name, age (no symbols)
 for (let key in user) alert(key); //nombre, edad (no symbols)
 */!*

 //the direct access by thesymbolworks
 //el acceso directo a la clave desymbolfunciona
 alert( "Direct: " + user[id] );
 ```

 `Object.keys(user)` also ignores them. That's a part of thegeneral"hiding symbolic properties" principle. If another scriptor a library loops over our object, it won't unexpectedly access a symbolic property.
 Esto forma parte del conceptogeneralde "ocultamiento". Si otro scripto si otra librería itera el objeto este no accesará a la  clave de Symbol.

 In contrast, [Object.assign](mdn:js/Object/assign)copies bothstringand symbol properties:
 En contraste, [Object.assign](mdn:js/Object/assign)copia las claves tanto delstringcomo las del symbol:

 ```js run
 let id = Symbol("id");
 alert( clone[id] ); // 123
 ```

 There's no paradox here. That's by design. The idea is that when we clone an object or merge objects, we usually want *all* properties to be copied (including symbols like `id`).
 No hay paradoja aquí, es así por diseño. La idea es que cuando clonamos un objeto o cuando fusionamos objetos, generalmente queremos que se copien *todas* las claves (incluidos los Symbol como `id`).

 ## Symbols Globales

 ## Global symbols
 Como hemos visto, normalmente todos los Symbols son diferentes aunque tengan el mismo nombre. Pero algunas veces necesitamos que los symbol con el mismo nombre sean las mismas entidades.

 As we've seen, usually all symbols are different, even if they have the same name. But sometimes we want same-named symbols to be same entities. For instance, different parts of our application want to accesssymbol `"id"`meaning exactly the same property.
 Por ejemplo, distintas partes de nuestra aplicación quieren accesar asymbol `"id"`queriendo obtener el mismo valor de la clave.

 To achieve that, there exists a*global symbol registry*.We can create symbolsin it and access them later, and it guarantees that repeated accesses by the same name return exactly the same symbol.
 Para lograr esto, existe un*global symbol registry*.Ahí podemos crear symbolsy acceder después a ellos, lo cual nos garantiza que cada vez que se acceda a la clave con el mismo nombre, esta te devuelva exactamente el mismo symbol.

 In order to read (create if absent) asymbolfrom the registry, use `Symbol.for(key)`.
 Para crear u accesar a unsymbolen el registro global, usa `Symbol.for(key)`.

 That call checks the global registry, and if there's a symboldescribed as `key`,then returns it, otherwise creates a newsymbol `Symbol(key)`and stores it in the registry by the given `key`.
 Esta llamada revisa el registro global, y si existe un symboldescrito como `key`,lo retornará, de lo contrario creará un nuevosymbol `Symbol(key)`y lo almacenará en el registro por su `key`.

 For instance:
 Por ejemplo:

 ```js run
 //read from the global registry
 let id = Symbol.for("id"); //if the symbol did not exist, it is created
 //leer desde el registro global
 let id = Symbol.for("id"); //si el símbolo no existe, se crea

 //read it again (maybe from another part of the code)
 //léelo nuevamente (tal vez de otra parte del código)
 let idAgain = Symbol.for("id");

 //the same symbol
 //el mismo symbol
 alert( id === idAgain ); // true
 ```

 Symbolsinside the registry are called*global symbols*. If we want an application-wide symbol, accessible everywhere in the code -- that's what they are for.
 LosSymbolsdentro de este registro son llamados*global symbols* y están disponibles y al alcance de todo el código en la aplicación.

 ```smart header="That sounds like Ruby"
 In some programming languages, likeRuby,there's a single symbol per name.
 ```smart header="Eso suena a Ruby"
 En algunos lenguajes de programación comoRuby,hay un solo Symbol por cada nombre.

 In JavaScript, as we can see, that's right for global symbols.
 En Javascript, como podemos ver, existen los global symbols.
 ```

 ### Symbol.keyFor

 Forglobal symbols,not only `Symbol.for(key)`returns a symbolby name, but there's a reverse call: `Symbol.keyFor(sym)`, that does the reverse: returns a name by a global symbol.
 Para losglobal symbols,no solo `Symbol.for(key)`devuelve un symbolpor su nombre, sino que existe una llamada inversa: `Symbol.keyFor(sym)` que hace lo contrario: devuelve el nombre de un global symbol.

 For instance:
 Por ejemplo:

 ```js run
 //get symbolby name
 let sym = Symbol.for("name");
 //tomar symbolpor nombre
 let sym = Symbol.for("nombre");
 let sym2 = Symbol.for("id");

 //get nameby symbol
 alert( Symbol.keyFor(sym) ); //name
 //tomar namepor symbol
 alert( Symbol.keyFor(sym) ); //nombre
 alert( Symbol.keyFor(sym2) ); // id
 ```

 The `Symbol.keyFor`internally uses theglobal symbol registry to look up the key for the symbol. So it doesn't work for non-global symbols. If the symbolis not global,it won't be able to find it and returns `undefined`.
 El `Symbol.keyFor`utiliza internamente el registro "global symbol registry" para buscar la clave del symbol, por lo tanto, no funciona para los symbol que no están dentro del registro. Si el symbolno es global,no será capaz de encontrarlo y por lo tanto devolverá `undefined`.

 That said, any symbols have `description`property.
 Dicho esto, todo symbol tiene `description`de clave.

 For instance:
 Por ejemplo:

 ```js run
 let globalSymbol = Symbol.for("name");
 let localSymbol = Symbol("name");
 let globalSymbol = Symbol.for("nombre");
 let localSymbol = Symbol("nombre");

 alert( Symbol.keyFor(globalSymbol) ); //name, global symbol
 alert( Symbol.keyFor(localSymbol) ); // undefined,not global
 alert( Symbol.keyFor(globalSymbol) ); //nombre, global symbol
 alert( Symbol.keyFor(localSymbol) ); // undefined,no global

 alert( localSymbol.description ); //name
 alert( localSymbol.description ); //nombre
 ```

 ## System symbols

 There exist many "system" symbols that JavaScriptuses internally, and we can use them to fine-tune various aspects of our objects.
 Existen varios symbols del sistema que JavaScriptutiliza internamente, y que podemos usar para ajustar varios aspectos de nuestros objetos.

 They are listed in the specification in the[Well-known symbols](https://tc39.github.io/ecma262/#sec-well-known-symbols)table:
 Se encuentran listados en[Well-known symbols](https://tc39.github.io/ecma262/#sec-well-known-symbols) :

 - `Symbol.hasInstance`
 - `Symbol.isConcatSpreadable`
 - `Symbol.iterator`
 - `Symbol.toPrimitive`
 - ...and so on.
 - ...y así.

 For instance, `Symbol.toPrimitive`allows us to describe object to primitive conversion. We'll see its use very soon.
 Por ejemplo, `Symbol.toPrimitive`nos permite describir el objeto para su conversión primitiva. Más adelante veremos su uso.

 Other symbolswill also become familiar when we study the corresponding language features.
 Otros symbolstambién te serán más familiares cuando estudiemos las características correspondientes.

 ##Summary
 ##Resumen

 `Symbol`is a primitive type for unique identifiers.
 `Symbol`es un tipo de dato primitivo para identificadores únicos.

 Symbolsare created with`Symbol()`call with an optional description (name).
 Symbolsson creados al llamar`Symbol()`con una descripción opcional.

 Symbolsare always different values, even if they have the same name. If we want same-named symbols to be equal, then we should use the global registry: `Symbol.for(key)`returns (creates if needed) a global symbol with`key`as the name. Multiple calls of `Symbol.for`with the same `key` return exactly the same symbol.
 Symbolsson siempre valores distintos aunque tengan el mismo nombre. Si queremos que symbols con el mismo nombre tengan el mismo valor, entonces debemos guardarlos en el registro global: `Symbol.for(key)`retornará un symbol (en caso de no existir, lo creará) con el`key`como su nombre. Múltiples llamadas de `Symbol.for`retornarán siempre el mismo symbol.

 Symbolshave two main use cases:
 Symbolsse utilizan principalmente en dos casos:

 1."Hidden" object properties.
    If we want to add a property into an object that "belongs" to another scriptor a library, we can create asymboland use it as a property key. A symbolic property does not appear in`for..in`, so it won't be accidentally processed together with other properties. Also it won't be accessed directly, because anotherscriptdoes not have oursymbol. So the property will be protected from accidental use or overwrite.
 1.Claves(keys) "Ocultas" dentro de un objeto.
 Si queremos agregar una clave a un objeto que "pertenezca" a otro scriptu otra librería, podemos crear unsymboly usarlo como clave. Una clave de symbol no aparecerá en los ciclos`for..in`,por lo que no aparecerá listada. Tampoco podrá ser accesada directamente por otroscriptporque este no tendrá nuestrosymbol y no podrá intervenir en sus acciones.

    So we can "covertly" hide something into objects that we need, but others should not see, using symbolic properties.
 Podemos "ocultar" ciertos valores dentro de un objeto que solo estarán disponibles dentro de ese script usando las claves de symbol.

 2.There are many system symbols used by JavaScript which are accessible as`Symbol.*`.We can use them to alter some built-in behaviors. For instance, later in thetutorial we'll use`Symbol.iterator`for [iterables](info:iterable), `Symbol.toPrimitive`to setup [object-to-primitive conversion](info:object-toprimitive) and so on.
 2.Existen diversos symbols del sistema que utiliza Javascript, a los cuales podemos accesar por medio de`Symbol.*`.Podemos usarlos para alterar algunos comportamientos. Por ejemplo, más adelante en eltutorial, usaremos`Symbol.iterator`para [iterables](info:iterable), `Symbol.toPrimitive`para configurar [object-to-primitive conversion](info:object-toprimitive).

 Technically,symbolsare not 100%hidden. There is a built-in method[Object.getOwnPropertySymbols(obj)](mdn:js/Object/getOwnPropertySymbols)that allows us to get all symbols.Also there is a method named[Reflect.ownKeys(obj)](mdn:js/Reflect/ownKeys)that returns *all* keys of an object including symbolic ones. So they are not really hidden. But most libraries, built-in functions and syntax constructs don't use these methods.
 Técnicamente, lossymbolsno están 100%ocultos. Existe un método incorporado[Object.getOwnPropertySymbols(obj)](mdn:js/Object/getOwnPropertySymbols)que nos permite obtener todos los symbols.También existe un método llamado[Reflect.ownKeys(obj)](mdn:js/Reflect/ownKeys)que devuelve *todas* las claves de un objeto, incluyendo las que son de tipo symbol. Por lo tanto, no están realmente ocultos, aunque la mayoría de las librerías, los métodos incorporados y las construcciones de sintaxis se adhieren a un acuerdo común de  que sí lo están. Y el que explícitamente llama a los métodos antes mencionados probablemente entiende bien lo que está haciendo.
Original file line number	Diff line number	Diff line change
		@@ -1,31 +1,31 @@

		#Symbol type
		#Tipo Symbol

		By specification, object property keys may be either of string type, or of symbol type. Not numbers, not booleans, only strings or symbols, these two types.
		Por especificación, las claves (Keys) de un objeto deben ser solamente del tipo String o Symbol. Solamente esos dos: String o Symbol.

		Till now we've been using only strings. Now let's see the benefits that symbols can give us.
		Hasta ahora sólo hemos aprendido acerca de los Strings, por lo que es momento de conocer las ventajas que Symbol nos puede dar.

		## Symbols

		A "symbol" represents a unique identifier.
		El valor de "Symbol" representa un identificador único.

		A value of this type can be created using `Symbol()`:
		Un valor de este tipo puede ser creado usando `Symbol()`:

		```js
		// idis a new symbol
		// ides un nuevo symbol
		let id = Symbol();
		```

		Upon creation, we can give symbol a description (also called asymbol name),mostly useful for debugging purposes:
		También le podemos agregar una descripción (también llamadasymbol name),que será útil en la depuración de código:

		```js
		// idis a symbolwith the description "id"
		```js run
		// ides un symbolcon la descripción "id"
		let id = Symbol("id");
		```

		Symbols are guaranteed to be unique. Even if we create many symbols with the same description, they are different values. The description is just a label that doesn't affect anything.
		Se garantiza que los símbolos son únicos. Aunque declaremos varios Symbols con la misma descripción, éstos tendrán valores distintos. La descripción es solamente una etiqueta que no afecta nada más.

		For instance, here are two symbols with the same description --they are not equal:
		Por ejemplo, aquí hay dos Symbols con la misma descripción --pero no son iguales:

		```js run
		let id1 = Symbol("id");
Expand All		@@ -36,31 +36,31 @@ alert(id1 == id2); // false
		/!
		```

		If you are familiar withRubyor another language that also has some sort of "symbols" --please don't be misguided. JavaScript symbols are different.
		Si estás familiarizado conRubyu otro lenguaje que también tienesymbols --por favor no te confundas. Los Symbols de Javascript son diferentes.

		````warn header="Symbolsdon't auto-convert to astring"
		Most values inJavaScriptsupport implicit conversion to a string.For instance, we can `alert` almost any value, and it will work.Symbolsare special. They don'tauto-convert.
		````warn header="Symbolsno se autoconvierten aString"
		La mayoría de los valores enJavaScriptsoportan la conversión implícita a string.Por ejemplo, podemos hacer un ´alert´ con casi cualquier valor y funcionará. LosSymbolsson distintos, éstos no seauto-convierten.

		For instance, this `alert`will show an error:
		Por ejemplo, este `alert`mostrará un error:

		```js run
		let id = Symbol("id");
		!
		alert(id); // TypeError:Cannot convert a Symbol value to a string
		alert(id); // TypeError:No puedes convertir un valor Symbol en string
		/!
		```

		That's a "language guard" against messing up, because strings and symbols are fundamentally different and should not accidentally convert one into another.
		Esa es una "protección del lenguaje" para evitar errores ya que los String y los Symbol son diferentes y no deberían convertirse ocasionalmente uno en otro.

		If we really want to show a symbol, we need to explicitly call`.toString()`on it, like here:
		Si realmente queremos mostrar un Symbol, necesitamos llamar el método`.toString()`de la siguiente manera:
		```js run
		let id = Symbol("id");
		!
		alert(id.toString()); // Symbol(id),now it works
		alert(id.toString()); // Symbol(id),ahora sí funciona
		/!
		```

		Or get`symbol.description`property to show the description only:
		O se puede utilizar`symbol.description`para obtener la descripción solamente:
		```js run
		let id = Symbol("id");
		!
Expand All		@@ -70,80 +70,78 @@ alert(id.description); // id

		````

		##"Hidden" properties
		##Claves "Ocultas"

		Symbolsallow us to create "hidden" properties of an object, that no other part of code can accidentally access or overwrite.
		LosSymbolsnos permiten crear claves "ocultas" en un objeto, a las cuales ninguna otra parte del código puede accesar ni sobrescribir.

		For instance, if we're working with `user` objects, that belong to a third-party code. We'd like to add identifiers to them.

		Let's use a symbol key for it:
		Por ejemplo, si queremos guardar un "identificador" para el objeto `user`, podemos asignar un symbol como clave del objeto:

		```js run
		let user = { //belongs to another code
		let user = { //pertenece a otro código
		name: "John"
		};

		let id = Symbol("id");

		user[id] = 1;

		alert( user[id] ); //we can access the data using thesymbolas the key
		alert( user[id] ); //podemos accesar a la información utilizando elsymbolcomo nombre de clave
		```

		What's the benefit of using`Symbol("id")`over a string `"id"`?
		¿Cuál es la ventaja de usar`Symbol("id")`y no un string `"id"`?

		As `user` objects belongs to another code, and that code also works with them, we shouldn't just add any fields to it. That's unsafe. But a symbol cannot be accessed accidentally, the third-party code probably won't even see it, so it's probably all right to do.
		Vamos a profundizar en el ejemplo para que sea más claro.

		Also, imagine that anotherscriptwants to have its own identifier inside `user`, for its own purposes. That may be another JavaScript library, so that the scripts are completely unaware of each other.
		Imagina que otroscriptquiere tener la clave "id" dentro de `user` para sus propios fines. Puede ser otra librería de JavaScript, por lo cual ninguno de los scripts saben de su coexistencia.

		Then thatscriptcan create its own `Symbol("id")`,like this:
		Y entonces esescriptpuede crear su propio `Symbol("id")`,como este:

		```js
		// ...
		let id = Symbol("id");

		user[id] = "Their id value";
		user[id] = "Su id";
		```

		There will be no conflict between our and their identifiers, because symbols are always different, even if they have the same name.
		No habrá conflicto porque los Symbols siempre son diferentes, incluso si tienen el mismo nombre.

		...But if we used astring `"id"`instead of a symbol for the same purpose, then there would be a conflict:
		Ahora ten en cuenta que si utilizamos unstring `"id"`en lugar de un Symbol para el mismo propósito, entonces SÍ habría un conflicto:

		```js run
		let user = { name: "John" };

		//Our scriptuses"id"property
		user.id = "Our id value";
		//Nuestro scriptusa la clave"id"
		user.id = "Nuestro valor id";

		// ...Another scriptalso wants"id"for its purposes...
		// ...Otro scripttambién quiere usar"id"...

		user.id = "Their id value"
		// Boom!overwritten by another script!
		user.id = "Su valor de id"
		// Boom!sobreescrito para otro script!
		```

		### Symbolsin a literal
		### Symbolsen objetos literales

		If we want to use a symbol in an objectliteral `{...}`, we need square brackets around it.
		Si queremos usar un Symbol en un objetoliteral, debemos usar llaves.

		Like this:
		Como se muestra a continuación:

		```js
		let id = Symbol("id");

		let user = {
		name: "John",
		!
		[id]: 123 //not "id: 123"
		[id]: 123 //no "id: 123"
		/!
		};
		```
		That's because we need the value from thevariable `id`as the key, not the string "id".
		Se hace así porque necesitamos que el valor de lavariable `id`sea la clave, no el string "id".

		### Symbolsare skipped by for..in
		###LosSymbolsson omitidos en for..in

		Symbolic properties do not participate in`for..in` loop.
		Las claves de Symbol no participan dentro de los ciclos`for..in`.

		For instance:
		Por ejemplo:

		```js run
		let id = Symbol("id");
Expand All		@@ -154,16 +152,16 @@ let user = {
		};

		!
		for (let key in user) alert(key); //name, age (no symbols)
		for (let key in user) alert(key); //nombre, edad (no symbols)
		/!

		//the direct access by thesymbolworks
		//el acceso directo a la clave desymbolfunciona
		alert( "Direct: " + user[id] );
		```

		`Object.keys(user)` also ignores them. That's a part of thegeneral"hiding symbolic properties" principle. If another scriptor a library loops over our object, it won't unexpectedly access a symbolic property.
		Esto forma parte del conceptogeneralde "ocultamiento". Si otro scripto si otra librería itera el objeto este no accesará a la clave de Symbol.

		In contrast, [Object.assign](mdn:js/Object/assign)copies bothstringand symbol properties:
		En contraste, [Object.assign](mdn:js/Object/assign)copia las claves tanto delstringcomo las del symbol:

		```js run
		let id = Symbol("id");
Expand All		@@ -176,102 +174,104 @@ let clone = Object.assign({}, user);
		alert( clone[id] ); // 123
		```

		There's no paradox here. That's by design. The idea is that when we clone an object or merge objects, we usually want all properties to be copied (including symbols like `id`).
		No hay paradoja aquí, es así por diseño. La idea es que cuando clonamos un objeto o cuando fusionamos objetos, generalmente queremos que se copien todas las claves (incluidos los Symbol como `id`).

		## Symbols Globales

		## Global symbols
		Como hemos visto, normalmente todos los Symbols son diferentes aunque tengan el mismo nombre. Pero algunas veces necesitamos que los symbol con el mismo nombre sean las mismas entidades.

		As we've seen, usually all symbols are different, even if they have the same name. But sometimes we want same-named symbols to be same entities. For instance, different parts of our application want to accesssymbol `"id"`meaning exactly the same property.
		Por ejemplo, distintas partes de nuestra aplicación quieren accesar asymbol `"id"`queriendo obtener el mismo valor de la clave.

		To achieve that, there exists aglobal symbol registry.We can create symbolsin it and access them later, and it guarantees that repeated accesses by the same name return exactly the same symbol.
		Para lograr esto, existe unglobal symbol registry.Ahí podemos crear symbolsy acceder después a ellos, lo cual nos garantiza que cada vez que se acceda a la clave con el mismo nombre, esta te devuelva exactamente el mismo symbol.

		In order to read (create if absent) asymbolfrom the registry, use `Symbol.for(key)`.
		Para crear u accesar a unsymbolen el registro global, usa `Symbol.for(key)`.

		That call checks the global registry, and if there's a symboldescribed as `key`,then returns it, otherwise creates a newsymbol `Symbol(key)`and stores it in the registry by the given `key`.
		Esta llamada revisa el registro global, y si existe un symboldescrito como `key`,lo retornará, de lo contrario creará un nuevosymbol `Symbol(key)`y lo almacenará en el registro por su `key`.

		For instance:
		Por ejemplo:

		```js run
		//read from the global registry
		let id = Symbol.for("id"); //if the symbol did not exist, it is created
		//leer desde el registro global
		let id = Symbol.for("id"); //si el símbolo no existe, se crea

		//read it again (maybe from another part of the code)
		//léelo nuevamente (tal vez de otra parte del código)
		let idAgain = Symbol.for("id");

		//the same symbol
		//el mismo symbol
		alert( id === idAgain ); // true
		```

		Symbolsinside the registry are calledglobal symbols. If we want an application-wide symbol, accessible everywhere in the code -- that's what they are for.
		LosSymbolsdentro de este registro son llamadosglobal symbols y están disponibles y al alcance de todo el código en la aplicación.

		```smart header="That sounds like Ruby"
		In some programming languages, likeRuby,there's a single symbol per name.
		```smart header="Eso suena a Ruby"
		En algunos lenguajes de programación comoRuby,hay un solo Symbol por cada nombre.

		In JavaScript, as we can see, that's right for global symbols.
		En Javascript, como podemos ver, existen los global symbols.
		```

		### Symbol.keyFor

		Forglobal symbols,not only `Symbol.for(key)`returns a symbolby name, but there's a reverse call: `Symbol.keyFor(sym)`, that does the reverse: returns a name by a global symbol.
		Para losglobal symbols,no solo `Symbol.for(key)`devuelve un symbolpor su nombre, sino que existe una llamada inversa: `Symbol.keyFor(sym)` que hace lo contrario: devuelve el nombre de un global symbol.

		For instance:
		Por ejemplo:

		```js run
		//get symbolby name
		let sym = Symbol.for("name");
		//tomar symbolpor nombre
		let sym = Symbol.for("nombre");
		let sym2 = Symbol.for("id");

		//get nameby symbol
		alert( Symbol.keyFor(sym) ); //name
		//tomar namepor symbol
		alert( Symbol.keyFor(sym) ); //nombre
		alert( Symbol.keyFor(sym2) ); // id
		```

		The `Symbol.keyFor`internally uses theglobal symbol registry to look up the key for the symbol. So it doesn't work for non-global symbols. If the symbolis not global,it won't be able to find it and returns `undefined`.
		El `Symbol.keyFor`utiliza internamente el registro "global symbol registry" para buscar la clave del symbol, por lo tanto, no funciona para los symbol que no están dentro del registro. Si el symbolno es global,no será capaz de encontrarlo y por lo tanto devolverá `undefined`.

		That said, any symbols have `description`property.
		Dicho esto, todo symbol tiene `description`de clave.

		For instance:
		Por ejemplo:

		```js run
		let globalSymbol = Symbol.for("name");
		let localSymbol = Symbol("name");
		let globalSymbol = Symbol.for("nombre");
		let localSymbol = Symbol("nombre");

		alert( Symbol.keyFor(globalSymbol) ); //name, global symbol
		alert( Symbol.keyFor(localSymbol) ); // undefined,not global
		alert( Symbol.keyFor(globalSymbol) ); //nombre, global symbol
		alert( Symbol.keyFor(localSymbol) ); // undefined,no global

		alert( localSymbol.description ); //name
		alert( localSymbol.description ); //nombre
		```

		## System symbols

		There exist many "system" symbols that JavaScriptuses internally, and we can use them to fine-tune various aspects of our objects.
		Existen varios symbols del sistema que JavaScriptutiliza internamente, y que podemos usar para ajustar varios aspectos de nuestros objetos.

		They are listed in the specification in the[Well-known symbols](https://tc39.github.io/ecma262/#sec-well-known-symbols)table:
		Se encuentran listados en[Well-known symbols](https://tc39.github.io/ecma262/#sec-well-known-symbols) :

		- `Symbol.hasInstance`
		- `Symbol.isConcatSpreadable`
		- `Symbol.iterator`
		- `Symbol.toPrimitive`
		- ...and so on.
		- ...y así.

		For instance, `Symbol.toPrimitive`allows us to describe object to primitive conversion. We'll see its use very soon.
		Por ejemplo, `Symbol.toPrimitive`nos permite describir el objeto para su conversión primitiva. Más adelante veremos su uso.

		Other symbolswill also become familiar when we study the corresponding language features.
		Otros symbolstambién te serán más familiares cuando estudiemos las características correspondientes.

		##Summary
		##Resumen

		`Symbol`is a primitive type for unique identifiers.
		`Symbol`es un tipo de dato primitivo para identificadores únicos.

		Symbolsare created with`Symbol()`call with an optional description (name).
		Symbolsson creados al llamar`Symbol()`con una descripción opcional.

		Symbolsare always different values, even if they have the same name. If we want same-named symbols to be equal, then we should use the global registry: `Symbol.for(key)`returns (creates if needed) a global symbol with`key`as the name. Multiple calls of `Symbol.for`with the same `key` return exactly the same symbol.
		Symbolsson siempre valores distintos aunque tengan el mismo nombre. Si queremos que symbols con el mismo nombre tengan el mismo valor, entonces debemos guardarlos en el registro global: `Symbol.for(key)`retornará un symbol (en caso de no existir, lo creará) con el`key`como su nombre. Múltiples llamadas de `Symbol.for`retornarán siempre el mismo symbol.

		Symbolshave two main use cases:
		Symbolsse utilizan principalmente en dos casos:

		1."Hidden" object properties.
		If we want to add a property into an object that "belongs" to another scriptor a library, we can create asymboland use it as a property key. A symbolic property does not appear in`for..in`, so it won't be accidentally processed together with other properties. Also it won't be accessed directly, because anotherscriptdoes not have oursymbol. So the property will be protected from accidental use or overwrite.
		1.Claves(keys) "Ocultas" dentro de un objeto.
		Si queremos agregar una clave a un objeto que "pertenezca" a otro scriptu otra librería, podemos crear unsymboly usarlo como clave. Una clave de symbol no aparecerá en los ciclos`for..in`,por lo que no aparecerá listada. Tampoco podrá ser accesada directamente por otroscriptporque este no tendrá nuestrosymbol y no podrá intervenir en sus acciones.

		So we can "covertly" hide something into objects that we need, but others should not see, using symbolic properties.
		Podemos "ocultar" ciertos valores dentro de un objeto que solo estarán disponibles dentro de ese script usando las claves de symbol.

		2.There are many system symbols used by JavaScript which are accessible as`Symbol.*`.We can use them to alter some built-in behaviors. For instance, later in thetutorial we'll use`Symbol.iterator`for [iterables](info:iterable), `Symbol.toPrimitive`to setup [object-to-primitive conversion](info:object-toprimitive) and so on.
		2.Existen diversos symbols del sistema que utiliza Javascript, a los cuales podemos accesar por medio de`Symbol.*`.Podemos usarlos para alterar algunos comportamientos. Por ejemplo, más adelante en eltutorial, usaremos`Symbol.iterator`para [iterables](info:iterable), `Symbol.toPrimitive`para configurar [object-to-primitive conversion](info:object-toprimitive).

		Technically,symbolsare not 100%hidden. There is a built-in method[Object.getOwnPropertySymbols(obj)](mdn:js/Object/getOwnPropertySymbols)that allows us to get all symbols.Also there is a method named[Reflect.ownKeys(obj)](mdn:js/Reflect/ownKeys)that returns all keys of an object including symbolic ones. So they are not really hidden. But most libraries, built-in functions and syntax constructs don't use these methods.
		Técnicamente, lossymbolsno están 100%ocultos. Existe un método incorporado[Object.getOwnPropertySymbols(obj)](mdn:js/Object/getOwnPropertySymbols)que nos permite obtener todos los symbols.También existe un método llamado[Reflect.ownKeys(obj)](mdn:js/Reflect/ownKeys)que devuelve todas las claves de un objeto, incluyendo las que son de tipo symbol. Por lo tanto, no están realmente ocultos, aunque la mayoría de las librerías, los métodos incorporados y las construcciones de sintaxis se adhieren a un acuerdo común de que sí lo están. Y el que explícitamente llama a los métodos antes mencionados probablemente entiende bien lo que está haciendo.