From 6f952dcf205d7041e668784f69d88923f708d49e Mon Sep 17 00:00:00 2001 From: mariabp Date: Tue, 22 Oct 2019 10:28:40 -0500 Subject: [PATCH 01/11] First translation --- 1-js/04-object-basics/03-symbol/article.md | 230 ++++++++++----------- 1 file changed, 115 insertions(+), 115 deletions(-) diff --git a/1-js/04-object-basics/03-symbol/article.md b/1-js/04-object-basics/03-symbol/article.md index 8323d6643..63037b052 100644 --- a/1-js/04-object-basics/03-symbol/article.md +++ b/1-js/04-object-basics/03-symbol/article.md @@ -1,47 +1,47 @@ -# 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 propiedades de un objeto deben ser solamente del tipo String o Symbol, NO pueden ser Numbers o Booleans. -Till now we've only seen strings. Now let's see the advantages 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 -"Symbol" value 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 -// id is a new symbol -let id = Symbol(); +// id es un nuevo symbol +let id = Symbol(); ``` -We can also give symbol a description (also called a symbol name), mostly useful for debugging purposes: +También le podemos agregar una descripción (también llamada symbol name), que será útil en la depuración de código: ```js run -// id is a symbol with the description "id" -let id = Symbol("id"); +// id es un symbol con 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. +Los Symbols están garantizados a ser ú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"); -let id2 = Symbol("id"); +let id1 = Symbol("id"); +let id2 = Symbol("id"); *!* alert(id1 == id2); // false */!* ``` -If you are familiar with Ruby or another language that also has some sort of "symbols" -- please don't be misguided. JavaScript symbols are different. +Si estás familiarizado con Ruby u otro lenguaje que también tiene symbols -- por favor no te confundas. Los Symbols de Javascript son diferentes. -````warn header="Symbols don't auto-convert to a string" -Most values in JavaScript support implicit conversion to a string. For instance, we can `alert` almost any value, and it will work. Symbols are special. They don't auto-convert. +````warn header="Symbols no se auto convierten a String" +La mayoría de los valores en JavaScript soportan la conversión implícita a string. Por ejemplo, podemos hacer un ´alert´ con casi cualquier valor y funcionará. Los Symbols son distintos, éstos no se auto-convierten. -For instance, this `alert` will show an error: +Por ejemplo, este `alert` mostrará un error: ```js run let id = Symbol("id"); @@ -50,17 +50,17 @@ alert(id); // TypeError: Cannot convert a Symbol value to a string */!* ``` -That's a "language guard" against messing up, because strings and symbols are fundamentally different and should not occasionally 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 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 si funciona */!* ``` -Or get `symbol.description` property to get the description only: +O se puede utilizar `symbol.description` para obtener la descripción solamente: ```js run let id = Symbol("id"); *!* @@ -70,213 +70,213 @@ alert(id.description); // id ```` -## "Hidden" properties +## Propiedades "Ocultas" -Symbols allow us to create "hidden" properties of an object, that no other part of code can occasionally access or overwrite. +Los Symbols nos permiten crear propiedades "ocultas" en un objeto, las cuales ninguna otra parte del código puede accesar ni sobre-escribir. -For instance, if we want to store an "identifier" for the object `user`, we can use a symbol as a key for it: +Por ejemplo, si queremos guardar un "identificador" para el objeto `usuario`, podemos asignar un symbol como propiedad del objeto: ```js run -let user = { name: "John" }; -let id = Symbol("id"); +let usuario = { nombre: "Juan" }; +let id = Symbol("id"); -user[id] = "ID Value"; -alert( user[id] ); // we can access the data using the symbol as the key +usuario[id] = "ID Value"; +alert( usuario[id] ); // podemos accesar a la información utilizando symbol como propiedad ``` -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"`? -Let's make the example a bit deeper to see that. +Vamos a profundizar en el ejemplo para que sea más claro. -Imagine that another script wants to have its own "id" property inside `user`, for its own purposes. That may be another JavaScript library, so the scripts are completely unaware of each other. +Imagina que otro script quiere tener la propiedad "id" dentro de `usuario` para sus propios fines. Puede ser otra librería de JavaScript, por lo cual ninguno de los scripts saben de su coexistencia. -Then that script can create its own `Symbol("id")`, like this: +Y entonces ese script puede crear su propio `Symbol("id")`, como este: ```js // ... -let id = Symbol("id"); +let id = Symbol("id"); -user[id] = "Their id value"; +usuario[id] = "Valor de id"; ``` -There will be no conflict, 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. -Now note that if we used a string `"id"` instead of a symbol for the same purpose, then there *would* be a conflict: +Ahora ten en cuenta que si utilizamos un string `"id"` en lugar de un Symbol, para el mismo propósito, entonces SI *habría* un conflicto: ```js run -let user = { name: "John" }; +let usuario = { nombre: "Juan" }; -// our script uses "id" property -user.id = "ID Value"; +// nuestro script usa la propiedad "id" +usuario.id = "ID Value"; -// ...if later another script the uses "id" for its purposes... +// ...si luego otro script usa "id" para sus propósitos... -user.id = "Their id value" -// boom! overwritten! it did not mean to harm the colleague, but did it! +usuario.id = "Valor de id" +// ¡Boom, queda sobreescrito! ``` -### Symbols in a literal +### Symbols en objetos literales -If we want to use a symbol in an object literal, we need square brackets. +Si queremos usar un Symbol en un objeto literal, debemos usar llaves. -Like this: +Como se muestra a continuación: ```js -let id = Symbol("id"); +let id = Symbol("id"); -let user = { - name: "John", +let user = { + nombre: "Juan", *!* - [id]: 123 // not just "id: 123" +[id]: 123 // no solo "id: 123" */!* }; ``` -That's because we need the value from the variable `id` as the key, not the string "id". +Se hace así porque necesitamos que el valor de la variable `id` sea la propiedad, no el string "id". -### Symbols are skipped by for..in +### Los Symbols son omitidos en for..in -Symbolic properties do not participate in `for..in` loop. +Las propiedades de Symbol no participan dentro de los ciclos `for..in`. -For instance: +Por ejemplo: ```js run -let id = Symbol("id"); -let user = { - name: "John", - age: 30, - [id]: 123 +let id = Symbol("id"); +let usuario = { + nombre: "Juan", + edad: 30, + [id]: 123 }; *!* -for (let key in user) alert(key); // name, age (no symbols) +for (let key in usuario) alert(key); // nombre, edad (no symbols) */!* -// the direct access by the symbol works +// el acceso directo a la propiedad de symbol funciona alert( "Direct: " + user[id] ); ``` -That's a part of the general "hiding" concept. If another script or a library loops over our object, it won't unexpectedly access a symbolic property. +Esto forma parte del concepto general de "ocultamiento". Si otro script o si otra librería itera el objeto este no accesará a la propiedad de Symbol. -In contrast, [Object.assign](mdn:js/Object/assign) copies both string and symbol properties: +En contraste, [Object.assign](mdn:js/Object/assign) copia las propiedades tanto del string como las del symbol: ```js run -let id = Symbol("id"); -let user = { - [id]: 123 +let id = Symbol("id"); +let usuario = { +[id]: 123 }; -let clone = Object.assign({}, user); +let clone = Object.assign({}, usuario); 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 propiedades (incluidos los Symbol como `id`). ````smart header="Property keys of other types are coerced to strings" -We can only use strings or symbols as keys in objects. Other types are converted to strings. +Podemos usar solamente strings o symbols como propiedades de los objetos. Otros tipos de datos son convertidos a string. -For instance, a number `0` becomes a string `"0"` when used as a property key: +Por ejemplo, el número `0` se convierte al string `'0'` cuando es usado como propiedad de un objeto: ```js run let obj = { - 0: "test" // same as "0": "test" + 0: "test" // igual que "0": "test" }; -// both alerts access the same property (the number 0 is converted to string "0") +// los dos alerts pueden accesar a la misma propiedad (el número 0 es convertido a string "0") alert( obj["0"] ); // test -alert( obj[0] ); // test (same property) +alert( obj[0] ); // test (misma propiedad) ``` ```` -## Global symbols +## Symbols Globales -As we've seen, usually all symbols are different, even if they have the same names. But sometimes we want same-named symbols to be same entities. +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. -For instance, different parts of our application want to access symbol `"id"` meaning exactly the same property. +Por ejemplo, distintas partes de nuestra aplicación quieren accesar a symbol `"id"` queriendo obtener el mismo valor de la propiedad. -To achieve that, there exists a *global symbol registry*. We can create symbols in 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 symbols y acceder después a ellos, lo cual nos garantiza que cada vez que se acceda a la propiedad con el mismo nombre, esta te devuelva exactamente el mismo symbol. -In order to create or read a symbol in the registry, use `Symbol.for(key)`. +Para crear u accesar a un symbol en el registro global, usa `Symbol.for(key)`. -That call checks the global registry, and if there's a symbol described as `key`, then returns it, otherwise creates a new symbol `Symbol(key)` and stores it in the registry by the given `key`. +Esta llamada revisa el registro global, y si existe un symbol descrito como `key`, lo retornará, de lo contrario creará un nuevo symbol `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 +// accesar al registro global +let id = Symbol.for("id"); // si symbol no existe, será creado -// read it again -let idAgain = Symbol.for("id"); +// accesar una vez más +let idOtraVez = Symbol.for("id"); -// the same symbol -alert( id === idAgain ); // true +// el mismo symbol +alert(id === idOtraVez); // true ``` -Symbols inside the registry are called *global symbols*. If we want an application-wide symbol, accessible everywhere in the code -- that's what they are for. +Los Symbols dentro 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, like Ruby, there's a single symbol per name. +```smart header="Eso suena a Ruby" +En algunos lenguajes de programación como Ruby, 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 -For global symbols, not only `Symbol.for(key)` returns a symbol by name, but there's a reverse call: `Symbol.keyFor(sym)`, that does the reverse: returns a name by a global symbol. +Para los global symbols, no solo `Symbol.for(key)` retorna un symbol por su nombre, si no que existe una llamada inversa: `Symbol.keyFor(sym)`, que hace lo contrario: retorna el nombre de un global symbol. -For instance: +Por ejemplo: ```js run -let sym = Symbol.for("name"); -let sym2 = Symbol.for("id"); +let sym = Symbol.for("nombre"); +let sym2 = Symbol.for("id"); -// get name from symbol -alert( Symbol.keyFor(sym) ); // name +// obtener nombre de un symbol +alert( Symbol.keyFor(sym) ); // nombre alert( Symbol.keyFor(sym2) ); // id ``` -The `Symbol.keyFor` internally uses the global symbol registry to look up the key for the symbol. So it doesn't work for non-global symbols. If the symbol is not global, it won't be able to find it and return `undefined`. +El `Symbol.keyFor` utiliza internamente el global symbol registry para buscar la propiedad del symbol, por lo tanto, no funciona para los symbol que no están dentro del registro. Si el symbol no es global, no será capaz de encontrarlo y por lo tanto retornará `undefined`. -For instance: +Por ejemplo: ```js run -alert( Symbol.keyFor(Symbol.for("name")) ); // name, global symbol +alert( Symbol.keyFor(Symbol.for("nombre")) ); // nombre, global symbol -alert( Symbol.keyFor(Symbol("name2")) ); // undefined, the argument isn't a global symbol +alert( Symbol.keyFor(Symbol("nombre2")) ); // undefined, el argumento no es un global symbol ``` ## System symbols -There exist many "system" symbols that JavaScript uses internally, and we can use them to fine-tune various aspects of our objects. +Existen varios symbols del sistema que JavaScript utiliza 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 symbols will also become familiar when we study the corresponding language features. +Otros symbols tambié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. -Symbols are created with `Symbol()` call with an optional description. +Symbols son creados al llamar `Symbol()` con una descripción opcional. -Symbols are 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` return exactly the same symbol. +Symbols son 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. -Symbols have two main use cases: +Symbols se utilizan principalmente en dos casos: -1. "Hidden" object properties. - If we want to add a property into an object that "belongs" to another script or a library, we can create a symbol and use it as a property key. A symbolic property does not appear in `for..in`, so it won't be occasionally listed. Also it won't be accessed directly, because another script does not have our symbol, so it will not occasionally intervene into its actions. +1. Propiedades "Ocultas" dentro de un objeto. + Si queremos agregar una propiedad a un objeto que "pertenezca" a otro script u otra librería,podemos crear un symbol y usarlo como propiedad. Una propiedad de symbol no aparecerá en los ciclos `for..in`,por lo que no aparecerá listada. Tampoco podrá ser accedada directamente por otro script porque este no tendrá nuestro symbol 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 propiedades 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 the tutorial 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, mas adelante en el tutorial, usaremos `Symbol.iterator` para [iterables](info:iterable), `Symbol.toPrimitive` para configurar [object-to-primitive conversion](info:object-toprimitive). -Technically, symbols are 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 methods and syntax constructs adhere to a common agreement that they are. And the one who explicitly calls the aforementioned methods probably understands well what he's doing. +Técnicamente, los symbols no 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 retorna *todas* las propiedades 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 sintáxis se adhieren a un acuerdo común de lo que si lo están. Y el que explícitamente llama a los métodos antes mencionados probablemente entiende bien lo que está haciendo. From de0b438674de0136888be28baec0da59db60460d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Maria=20Bola=C3=B1os?= <47005612+mariabp@users.noreply.github.com> Date: Fri, 1 Nov 2019 11:35:38 -0600 Subject: [PATCH 02/11] Update article.md MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Listo! Ya eliminé los espacios extras, que raro que los puse 🤔 . Me dices que te parece :) --- 1-js/04-object-basics/03-symbol/article.md | 42 +++++++++++----------- 1 file changed, 21 insertions(+), 21 deletions(-) diff --git a/1-js/04-object-basics/03-symbol/article.md b/1-js/04-object-basics/03-symbol/article.md index 63037b052..2507b221d 100644 --- a/1-js/04-object-basics/03-symbol/article.md +++ b/1-js/04-object-basics/03-symbol/article.md @@ -13,14 +13,14 @@ Un valor de este tipo puede ser creado usando `Symbol()`: ```js // id es un nuevo symbol -let id = Symbol(); +let id = Symbol(); ``` También le podemos agregar una descripción (también llamada symbol name), que será útil en la depuración de código: ```js run // id es un symbol con la descripción "id" -let id = Symbol("id"); +let id = Symbol("id"); ``` Los Symbols están garantizados a ser ú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. @@ -28,8 +28,8 @@ Los Symbols están garantizados a ser únicos. Aunque declaremos varios Symbols Por ejemplo, aquí hay dos Symbols con la misma descripción -- pero no son iguales: ```js run -let id1 = Symbol("id"); -let id2 = Symbol("id"); +let id1 = Symbol("id"); +let id2 = Symbol("id"); *!* alert(id1 == id2); // false @@ -77,8 +77,8 @@ Los Symbols nos permiten crear propiedades "ocultas" en un objeto, las cuales ni Por ejemplo, si queremos guardar un "identificador" para el objeto `usuario`, podemos asignar un symbol como propiedad del objeto: ```js run -let usuario = { nombre: "Juan" }; -let id = Symbol("id"); +let usuario = { nombre: "Juan" }; +let id = Symbol("id"); usuario[id] = "ID Value"; alert( usuario[id] ); // podemos accesar a la información utilizando symbol como propiedad @@ -94,7 +94,7 @@ Y entonces ese script puede crear su propio `Symbol("id")`, como este: ```js // ... -let id = Symbol("id"); +let id = Symbol("id"); usuario[id] = "Valor de id"; ``` @@ -104,7 +104,7 @@ No habrá conflicto porque los Symbols siempre son diferentes, incluso si tienen Ahora ten en cuenta que si utilizamos un string `"id"` en lugar de un Symbol, para el mismo propósito, entonces SI *habría* un conflicto: ```js run -let usuario = { nombre: "Juan" }; +let usuario = { nombre: "Juan" }; // nuestro script usa la propiedad "id" usuario.id = "ID Value"; @@ -122,12 +122,12 @@ Si queremos usar un Symbol en un objeto literal, debemos usar llaves. Como se muestra a continuación: ```js -let id = Symbol("id"); +let id = Symbol("id"); -let user = { +let user = { nombre: "Juan", *!* -[id]: 123 // no solo "id: 123" +[id]: 123 // no solo "id: 123" */!* }; ``` @@ -140,8 +140,8 @@ Las propiedades de Symbol no participan dentro de los ciclos `for..in`. Por ejemplo: ```js run -let id = Symbol("id"); -let usuario = { +let id = Symbol("id"); +let usuario = { nombre: "Juan", edad: 30, [id]: 123 @@ -160,12 +160,12 @@ Esto forma parte del concepto general de "ocultamiento". Si otro script o si otr En contraste, [Object.assign](mdn:js/Object/assign) copia las propiedades tanto del string como las del symbol: ```js run -let id = Symbol("id"); -let usuario = { -[id]: 123 +let id = Symbol("id"); +let usuario = { +[id]: 123 }; -let clone = Object.assign({}, usuario); +let clone = Object.assign({}, usuario); alert( clone[id] ); // 123 ``` @@ -204,10 +204,10 @@ Por ejemplo: ```js run // accesar al registro global -let id = Symbol.for("id"); // si symbol no existe, será creado +let id = Symbol.for("id"); // si symbol no existe, será creado // accesar una vez más -let idOtraVez = Symbol.for("id"); +let idOtraVez = Symbol.for("id"); // el mismo symbol alert(id === idOtraVez); // true @@ -228,8 +228,8 @@ Para los global symbols, no solo `Symbol.for(key)` retorna un symbol por su nomb Por ejemplo: ```js run -let sym = Symbol.for("nombre"); -let sym2 = Symbol.for("id"); +let sym = Symbol.for("nombre"); +let sym2 = Symbol.for("id"); // obtener nombre de un symbol alert( Symbol.keyFor(sym) ); // nombre From 0a786f0897320d2eaeaa314f2cf16156c2d1dbb4 Mon Sep 17 00:00:00 2001 From: Developer Date: Fri, 8 Nov 2019 08:29:40 -0600 Subject: [PATCH 03/11] Deleted extra space between declaration and name of variable --- 1-js/04-object-basics/03-symbol/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/04-object-basics/03-symbol/article.md b/1-js/04-object-basics/03-symbol/article.md index 2507b221d..5d06b9e1a 100644 --- a/1-js/04-object-basics/03-symbol/article.md +++ b/1-js/04-object-basics/03-symbol/article.md @@ -279,4 +279,4 @@ Symbols se utilizan principalmente en dos casos: 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, mas adelante en el tutorial, usaremos `Symbol.iterator` para [iterables](info:iterable), `Symbol.toPrimitive` para configurar [object-to-primitive conversion](info:object-toprimitive). -Técnicamente, los symbols no 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 retorna *todas* las propiedades 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 sintáxis se adhieren a un acuerdo común de lo que si lo están. Y el que explícitamente llama a los métodos antes mencionados probablemente entiende bien lo que está haciendo. +Técnicamente, los symbols no 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 retorna *todas* las propiedades 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 sintáxis se adhieren a un acuerdo común de lo que si lo están. Y el que explícitamente llama a los métodos antes mencionados probablemente entiende bien lo que está haciendo. \ No newline at end of file From 239004b5849961567bd88dedef3aca5ebac90af6 Mon Sep 17 00:00:00 2001 From: Valentina VP <34555644+vplentinax@users.noreply.github.com> Date: Wed, 10 Jun 2020 00:54:01 -0400 Subject: [PATCH 04/11] Update 1-js/04-object-basics/03-symbol/article.md Co-authored-by: joaquinelio --- 1-js/04-object-basics/03-symbol/article.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/1-js/04-object-basics/03-symbol/article.md b/1-js/04-object-basics/03-symbol/article.md index 5d06b9e1a..30bafc264 100644 --- a/1-js/04-object-basics/03-symbol/article.md +++ b/1-js/04-object-basics/03-symbol/article.md @@ -273,10 +273,10 @@ Symbols son siempre valores distintos, aunque tengan el mismo nombre. Si queremo Symbols se utilizan principalmente en dos casos: 1. Propiedades "Ocultas" dentro de un objeto. - Si queremos agregar una propiedad a un objeto que "pertenezca" a otro script u otra librería,podemos crear un symbol y usarlo como propiedad. Una propiedad de symbol no aparecerá en los ciclos `for..in`,por lo que no aparecerá listada. Tampoco podrá ser accedada directamente por otro script porque este no tendrá nuestro symbol y no podrá intervenir en sus acciones. + Si queremos agregar una propiedad a un objeto que "pertenezca" a otro script u otra librería, podemos crear un symbol y usarlo como propiedad. Una propiedad de symbol no aparecerá en los ciclos `for..in`,por lo que no aparecerá listada. Tampoco podrá ser accesada directamente por otro script porque este no tendrá nuestro symbol y no podrá intervenir en sus acciones. Podemos "ocultar" ciertos valores dentro de un objeto que solo estarán disponibles dentro de ese script usando las propiedades de symbol. 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, mas adelante en el tutorial, usaremos `Symbol.iterator` para [iterables](info:iterable), `Symbol.toPrimitive` para configurar [object-to-primitive conversion](info:object-toprimitive). -Técnicamente, los symbols no 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 retorna *todas* las propiedades 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 sintáxis se adhieren a un acuerdo común de lo que si lo están. Y el que explícitamente llama a los métodos antes mencionados probablemente entiende bien lo que está haciendo. \ No newline at end of file +Técnicamente, los symbols no 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 retorna *todas* las propiedades 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 sintáxis se adhieren a un acuerdo común de lo que si lo están. Y el que explícitamente llama a los métodos antes mencionados probablemente entiende bien lo que está haciendo. From 969795aeee5d1cc0cad778d894738bcb11b6b688 Mon Sep 17 00:00:00 2001 From: Valentina VP <34555644+vplentinax@users.noreply.github.com> Date: Wed, 10 Jun 2020 00:54:21 -0400 Subject: [PATCH 05/11] Update 1-js/04-object-basics/03-symbol/article.md Co-authored-by: joaquinelio --- 1-js/04-object-basics/03-symbol/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/04-object-basics/03-symbol/article.md b/1-js/04-object-basics/03-symbol/article.md index 30bafc264..0ca88bf26 100644 --- a/1-js/04-object-basics/03-symbol/article.md +++ b/1-js/04-object-basics/03-symbol/article.md @@ -38,7 +38,7 @@ alert(id1 == id2); // false Si estás familiarizado con Ruby u otro lenguaje que también tiene symbols -- por favor no te confundas. Los Symbols de Javascript son diferentes. -````warn header="Symbols no se auto convierten a String" +````warn header="Symbols no se autoconvierten a String" La mayoría de los valores en JavaScript soportan la conversión implícita a string. Por ejemplo, podemos hacer un ´alert´ con casi cualquier valor y funcionará. Los Symbols son distintos, éstos no se auto-convierten. Por ejemplo, este `alert` mostrará un error: From 82a0bb0c91041e72393353d6e2cb798300c101a9 Mon Sep 17 00:00:00 2001 From: Valentina VP <34555644+vplentinax@users.noreply.github.com> Date: Wed, 10 Jun 2020 00:54:40 -0400 Subject: [PATCH 06/11] Update 1-js/04-object-basics/03-symbol/article.md Co-authored-by: joaquinelio --- 1-js/04-object-basics/03-symbol/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/04-object-basics/03-symbol/article.md b/1-js/04-object-basics/03-symbol/article.md index 0ca88bf26..f295b905a 100644 --- a/1-js/04-object-basics/03-symbol/article.md +++ b/1-js/04-object-basics/03-symbol/article.md @@ -23,7 +23,7 @@ También le podemos agregar una descripción (también llamada symbol name), que let id = Symbol("id"); ``` -Los Symbols están garantizados a ser ú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. +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. Por ejemplo, aquí hay dos Symbols con la misma descripción -- pero no son iguales: From 68d693cab0062d12aaef3680cbd9ebe165ceaae7 Mon Sep 17 00:00:00 2001 From: Valentina VP <34555644+vplentinax@users.noreply.github.com> Date: Wed, 10 Jun 2020 00:54:53 -0400 Subject: [PATCH 07/11] Update 1-js/04-object-basics/03-symbol/article.md Co-authored-by: joaquinelio --- 1-js/04-object-basics/03-symbol/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/04-object-basics/03-symbol/article.md b/1-js/04-object-basics/03-symbol/article.md index f295b905a..f0e9c35c1 100644 --- a/1-js/04-object-basics/03-symbol/article.md +++ b/1-js/04-object-basics/03-symbol/article.md @@ -101,7 +101,7 @@ usuario[id] = "Valor de id"; No habrá conflicto porque los Symbols siempre son diferentes, incluso si tienen el mismo nombre. -Ahora ten en cuenta que si utilizamos un string `"id"` en lugar de un Symbol, para el mismo propósito, entonces SI *habría* un conflicto: +Ahora ten en cuenta que si utilizamos un string `"id"` en lugar de un Symbol para el mismo propósito, entonces SÍ *habría* un conflicto: ```js run let usuario = { nombre: "Juan" }; From 505e32b42cbb6d9653b3c8059035785c978d6021 Mon Sep 17 00:00:00 2001 From: Valentina VP <34555644+vplentinax@users.noreply.github.com> Date: Wed, 10 Jun 2020 00:55:04 -0400 Subject: [PATCH 08/11] Update 1-js/04-object-basics/03-symbol/article.md Co-authored-by: joaquinelio --- 1-js/04-object-basics/03-symbol/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/04-object-basics/03-symbol/article.md b/1-js/04-object-basics/03-symbol/article.md index f0e9c35c1..304323f92 100644 --- a/1-js/04-object-basics/03-symbol/article.md +++ b/1-js/04-object-basics/03-symbol/article.md @@ -268,7 +268,7 @@ Otros symbols también te serán más familiares cuando estudiemos las caracter Symbols son creados al llamar `Symbol()` con una descripción opcional. -Symbols son 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. +Symbols son 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. Symbols se utilizan principalmente en dos casos: From 5015fc3d2bd169089d46ab30dc9809f1e31f878f Mon Sep 17 00:00:00 2001 From: Valentina VP <34555644+vplentinax@users.noreply.github.com> Date: Wed, 10 Jun 2020 19:34:37 -0400 Subject: [PATCH 09/11] Update 1-js/04-object-basics/03-symbol/article.md Co-authored-by: joaquinelio --- 1-js/04-object-basics/03-symbol/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/04-object-basics/03-symbol/article.md b/1-js/04-object-basics/03-symbol/article.md index 304323f92..0d8107185 100644 --- a/1-js/04-object-basics/03-symbol/article.md +++ b/1-js/04-object-basics/03-symbol/article.md @@ -56,7 +56,7 @@ Si realmente queremos mostrar un Symbol, necesitamos llamar el método `.toStrin ```js run let id = Symbol("id"); *!* -alert(id.toString()); // Symbol(id), ahora si funciona +alert(id.toString()); // Symbol(id), ahora sí funciona */!* ``` From 6ba4d07a986717c0fb22ab2d12039e79e3ab31a7 Mon Sep 17 00:00:00 2001 From: Valentina VP <34555644+vplentinax@users.noreply.github.com> Date: Wed, 10 Jun 2020 19:34:49 -0400 Subject: [PATCH 10/11] Update 1-js/04-object-basics/03-symbol/article.md Co-authored-by: joaquinelio --- 1-js/04-object-basics/03-symbol/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/04-object-basics/03-symbol/article.md b/1-js/04-object-basics/03-symbol/article.md index 0d8107185..f4c1be636 100644 --- a/1-js/04-object-basics/03-symbol/article.md +++ b/1-js/04-object-basics/03-symbol/article.md @@ -1,7 +1,7 @@ # Tipo Symbol -Por especificación, las propiedades de un objeto deben ser solamente del tipo String o Symbol, NO pueden ser Numbers o Booleans. +Por especificación, las "propiedades claves" (key) de un objeto deben ser solamente del tipo String o Symbol. No Number, no Boolean, solo esos dos: string o symbol. Hasta ahora sólo hemos aprendido acerca de los Strings, por lo que es momento de conocer las ventajas que Symbol nos puede dar. From 63349ea897cac54ea74b7c803070e0dbbe6d90b4 Mon Sep 17 00:00:00 2001 From: Valentina VP <34555644+vplentinax@users.noreply.github.com> Date: Wed, 10 Jun 2020 19:34:57 -0400 Subject: [PATCH 11/11] Update 1-js/04-object-basics/03-symbol/article.md Co-authored-by: joaquinelio --- 1-js/04-object-basics/03-symbol/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/04-object-basics/03-symbol/article.md b/1-js/04-object-basics/03-symbol/article.md index f4c1be636..ceca62cf4 100644 --- a/1-js/04-object-basics/03-symbol/article.md +++ b/1-js/04-object-basics/03-symbol/article.md @@ -72,7 +72,7 @@ alert(id.description); // id ## Propiedades "Ocultas" -Los Symbols nos permiten crear propiedades "ocultas" en un objeto, las cuales ninguna otra parte del código puede accesar ni sobre-escribir. +Los Symbols nos permiten crear propiedades "ocultas" en un objeto, a las cuales ninguna otra parte del código puede accesar ni sobrescribir. Por ejemplo, si queremos guardar un "identificador" para el objeto `usuario`, podemos asignar un symbol como propiedad del objeto: pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy