From b3442dfa81f7f2516322c46478f1a74feb79d900 Mon Sep 17 00:00:00 2001
From: Homero304 <homeromaring@gmail.com>
Date: Sun, 16 Aug 2020 23:55:21 -0500
Subject: [PATCH 01/13] Object to primitive conversion

---
 .../09-object-toprimitive/article.md          | 180 +++++++++---------
 1 file changed, 90 insertions(+), 90 deletions(-)

diff --git a/1-js/04-object-basics/09-object-toprimitive/article.md b/1-js/04-object-basics/09-object-toprimitive/article.md
index f6b715ce5..6648081fe 100644
--- a/1-js/04-object-basics/09-object-toprimitive/article.md
+++ b/1-js/04-object-basics/09-object-toprimitive/article.md
@@ -1,93 +1,93 @@
 
-# Object to primitive conversion
+# Conversión de objeto a valor primitivo
 
-What happens when objects are added `obj1 + obj2`, subtracted `obj1 - obj2` or printed using `alert(obj)`?
+¿Qué sucede cuando los objetos se suman `obj1 + obj2`, se restan `obj1 - obj2` o se imprimen utilizando `alert(obj)`?
 
-In that case, objects are auto-converted to primitives, and then the operation is carried out.
+En ese caso, los objetos se convierten automáticamente en valores primitivos, y luego se lleva a cabo la operación.
 
-In the chapter <info:type-conversions> we've seen the rules for numeric, string and boolean conversions of primitives. But we left a gap for objects. Now, as we know about methods and symbols it becomes possible to fill it.
+En el capítulo <info:type-conversions>, hemos visto las reglas para las conversiones de valores primitivos numéricos, strings y booleanos. Pero dejamos un hueco en los objetos. Ahora, como sabemos sobre métodos y símbolos, es posible completarlo.
 
-1. All objects are `true` in a boolean context. There are only numeric and string conversions.
-2. The numeric conversion happens when we subtract objects or apply mathematical functions. For instance, `Date` objects (to be covered in the chapter <info:date>) can be subtracted, and the result of `date1 - date2` is the time difference between two dates.
-3. As for the string conversion -- it usually happens when we output an object like `alert(obj)` and in similar contexts.
+1. Todos los objetos son `true` en un contexto booleano. Solo hay conversiones numéricas y de strings.
+2. La conversión numérica ocurre cuando restamos objetos o aplicamos funciones matemáticas. Por ejemplo, los objetos de tipo `Date` (que se cubrirán en el capítulo <info:date>) se pueden restar, y el resultado de `date1 - date2` es la diferencia horaria entre dos fechas.
+3. En cuanto a la conversión de strings : generalmente ocurre cuando imprimimos un objeto como en `alert(obj)` y en contextos similares.
 
 ## ToPrimitive
 
-We can fine-tune string and numeric conversion, using special object methods.
+Podemos ajustar la conversión de tipo string y numérica, utilizando métodos especiales del objeto.
 
-There are three variants of type conversion, so-called "hints", described in the [specification](https://tc39.github.io/ecma262/#sec-toprimitive):
+Hay tres variantes de conversión de tipos, denominadas "hints", que se describen en la [especificación](https://tc39.github.io/ecma262/#sec-toprimitive):
 
 `"string"`
-: For an object-to-string conversion, when we're doing an operation on an object that expects a string, like `alert`:
+: Para una conversión de objeto a string, cuando hacemos una operación que espera un string en un objeto, como `alert`:
 
     ```js
-    // output
+    // salida
     alert(obj);
 
-    // using object as a property key
+    // utilizando un objeto como key
     anotherObj[obj] = 123;
     ```
 
 `"number"`
-: For an object-to-number conversion, like when we're doing maths:
+: Para una conversión de objeto a numérico, como cuando hacemos operaciones matemáticas:
 
     ```js
-    // explicit conversion
+    // conversión explícita
     let num = Number(obj);
 
-    // maths (except binary plus)
-    let n = +obj; // unary plus
+    // matemáticas (excepto + binario)
+    let n = +obj; // + unitario
     let delta = date1 - date2;
 
-    // less/greater comparison
+    // comparación menor que / mayor que
     let greater = user1 > user2;
     ```
 
 `"default"`
-: Occurs in rare cases when the operator is "not sure" what type to expect.
+: Ocurre en casos raros cuando el operador "no está seguro" de qué tipo esperar.
 
-    For instance, binary plus `+` can work both with strings (concatenates them) and numbers (adds them), so both strings and numbers would do. So if the a binary plus gets an object as an argument, it uses the `"default"` hint to convert it.
+    Por ejemplo, el operador binario `+` puede funcionar con strings (los concatena) y números (los suma), por lo que tanto los strings como los números servirían. Entonces, si el + binario obtiene un objeto como argumento, utiliza el hint `"default"` para convertirlo.
 
-    Also, if an object is compared using `==` with a string, number or a symbol, it's also unclear which conversion should be done, so the `"default"` hint is used.
+    También, si un objeto es comparado utilizando `==` con un string, un número o un símbolo, tampoco está claro qué conversión se debe realizar, por lo que se utiliza el hint `"default"`.
 
     ```js
-    // binary plus uses the "default" hint
+    // + binario utiliza el hint "default"
     let total = obj1 + obj2;
 
-    // obj == number uses the "default" hint
+    // obj == número utiliza el hint "default"
     if (user == 1) { ... };
     ```
 
-    The greater and less comparison operators, such as `<` `>`, can work with both strings and numbers too. Still, they use the `"number"` hint, not `"default"`. That's for historical reasons.
+    Los operadores de comparación mayor que y menor que, como `<` `>`, también pueden funcionar con strings y números. Aún así, utilizan el hint `"number"`, y no `"default"`. Eso es por razones históricas.
 
-    In practice though, we don't need to remember these peculiar details, because all built-in objects except for one case (`Date` object, we'll learn it later) implement `"default"` conversion the same way as `"number"`. And we can do the same.
+    Sin embargo, en la práctica, no necesitamos recordar estos detalles peculiares, porque todos los objetos incorporados excepto un caso (el objeto `Date`, lo aprenderemos más adelante) implementan la conversión `"default"` de la misma manera que `"number"`. Y podemos hacer lo mismo.
 
-```smart header="No `\"boolean\"` hint"
-Please note -- there are only three hints. It's that simple.
+```smart header="No hay hint `\"boolean\"`"
+Tenga en cuenta : Solo hay tres hints. Es así de simple.
 
-There is no "boolean" hint (all objects are `true` in boolean context) or anything else. And if we treat `"default"` and `"number"` the same, like most built-ins do, then there are only two conversions.
+No hay ningún hint "boolean" (todos los objetos son `true` en el contexto booleano) ni nada más. Y si tratamos `"default"` y `"number"` de la misma manera, como lo hacen la mayoría de las funciones incorporadas, entonces solo hay dos conversiones.
 ```
 
-**To do the conversion, JavaScript tries to find and call three object methods:**
+**Para realizar la conversión, JavaScript intenta buscar y llamar a tres métodos del objeto:**
 
-1. Call `obj[Symbol.toPrimitive](hint)` - the method with the symbolic key `Symbol.toPrimitive` (system symbol), if such method exists,
-2. Otherwise if hint is `"string"`
-    - try `obj.toString()` and `obj.valueOf()`, whatever exists.
-3. Otherwise if hint is `"number"` or `"default"`
-    - try `obj.valueOf()` and `obj.toString()`, whatever exists.
+1. Llamar a `obj[Symbol.toPrimitive](hint)` : el método con el key simbólico `Symbol.toPrimitive` (símbolo del sistema), si tal método existe,
+2. De lo contrario, si el hint es `"string"`
+    - intentar `obj.toString()` y `obj.valueOf()`, lo que exista.
+3. De lo contrario, si el hint es `"number"` o `"default"`
+    - intentar `obj.valueOf()` y `obj.toString()`, lo que exista.
 
 ## Symbol.toPrimitive
 
-Let's start from the first method. There's a built-in symbol named `Symbol.toPrimitive` that should be used to name the conversion method, like this:
+Empecemos por el primer método. Hay un símbolo incorporado llamado `Symbol.toPrimitive` que debe utilizarse para nombrar el método de conversión, así:
 
 ```js
 obj[Symbol.toPrimitive] = function(hint) {
-  // must return a primitive value
-  // hint = one of "string", "number", "default"
+  // debe regresar un valor primitivo
+  // hint = uno de "string", "number", "default"
 };
 ```
 
-For instance, here `user` object implements it:
+Por ejemplo, aquí el objeto `user` lo implementa:
 
 ```js run
 let user = {
@@ -100,32 +100,32 @@ let user = {
   }
 };
 
-// conversions demo:
+// demostración de conversiones:
 alert(user); // hint: string -> {name: "John"}
 alert(+user); // hint: number -> 1000
 alert(user + 500); // hint: default -> 1500
 ```
 
-As we can see from the code, `user` becomes a self-descriptive string or a money amount depending on the conversion. The single method `user[Symbol.toPrimitive]` handles all conversion cases.
+Como podemos ver en el código, `user` se convierte en un string autodescriptivo o en una cantidad de dinero dependiendo de la conversión. El único método `user[Symbol.toPrimitive]` maneja todos los casos de conversión.
 
 
 ## toString/valueOf
 
-Methods `toString` and `valueOf` come from ancient times. They are not symbols (symbols did not exist that long ago), but rather "regular" string-named methods. They provide an alternative "old-style" way to implement the conversion.
+Los métodos `toString` y `valueOf` provienen de la antigüedad. No son símbolos (los símbolos no existían en aquel tiempo), sino métodos "regulares" nombrados con string. Proporcionan una forma alternativa "al viejo estilo" de implementar la conversión.
 
-If there's no `Symbol.toPrimitive` then JavaScript tries to find them and try in the order:
+Si no hay `Symbol.toPrimitive`, JavaScript intenta encontrar los hints e intenta en este orden:
 
-- `toString -> valueOf` for "string" hint.
-- `valueOf -> toString` otherwise.
+- `toString -> valueOf` para el hint "string".
+- `valueOf -> toString` de lo contrario.
 
-These methods must return a primitive value. If `toString` or `valueOf` returns an object, then it's ignored (same as if there were no method).
+Estos métodos deben devolver un valor primitivo. Si `toString` o `valueOf` devuelve un objeto, entonces se ignora (lo mismo que si no hubiera un método).
 
-By default, a plain object has following `toString` and `valueOf` methods:
+De forma predeterminada, un objeto simple tiene los siguientes métodos `toString` y `valueOf`:
 
-- The `toString` method returns a string `"[object Object]"`.
-- The `valueOf` method returns the object itself.
+- El método `toString` devuelve un string `"[object Object]"`.
+- El método `valueOf` devuelve el objeto en sí.
 
-Here's the demo:
+Aquí está la demostración:
 
 ```js run
 let user = {name: "John"};
@@ -134,25 +134,25 @@ alert(user); // [object Object]
 alert(user.valueOf() === user); // true
 ```
 
-So if we try to use an object as a string, like in an `alert` or so, then by default we see `[object Object]`.
+Entonces, si intentamos utilizar un objeto como un string, como en un `alert` o algo así, entonces por defecto vemos `[object Object]`.
 
-And the default `valueOf` is mentioned here only for the sake of completeness, to avoid any confusion. As you can see, it returns the object itself, and so is ignored. Don't ask me why, that's for historical reasons. So we can assume it doesn't exist.
+Y el `valueOf` predeterminado se menciona aquí solo en favor de la integridad, para evitar confusiones. Como puede ver, devuelve el objeto en sí, por lo que se ignora. No me pregunte por qué, es por razones históricas. Entonces podemos asumir que no existe.
 
-Let's implement these methods.
+Implementemos estos métodos.
 
-For instance, here `user` does the same as above using a combination of `toString` and `valueOf` instead of `Symbol.toPrimitive`:
+Por ejemplo, aquí `user` hace lo mismo que el ejemplo anterior utilizando una combinación de `toString` y `valueOf` en lugar de `Symbol.toPrimitive`:
 
 ```js run
 let user = {
   name: "John",
   money: 1000,
 
-  // for hint="string"
+  // para hint="string"
   toString() {
     return `{name: "${this.name}"}`;
   },
 
-  // for hint="number" or "default"
+  // para hint="number" o "default"
   valueOf() {
     return this.money;
   }
@@ -164,9 +164,9 @@ alert(+user); // valueOf -> 1000
 alert(user + 500); // valueOf -> 1500
 ```
 
-As we can see, the behavior is the same as the previous example with `Symbol.toPrimitive`.
+Como podemos ver, el comportamiento es el mismo que en el ejemplo anterior con `Symbol.toPrimitive`.
 
-Often we want a single "catch-all" place to handle all primitive conversions. In this case, we can implement `toString` only, like this:
+A menudo queremos un único lugar "general" para manejar todas las conversiones primitivas. En este caso, podemos implementar solo `toString`, así:
 
 ```js run
 let user = {
@@ -181,47 +181,47 @@ alert(user); // toString -> John
 alert(user + 500); // toString -> John500
 ```
 
-In the absence of `Symbol.toPrimitive` and `valueOf`, `toString` will handle all primitive conversions.
+En ausencia de `Symbol.toPrimitive` y `valueOf`, `toString` manejará todas las conversiones primitivas.
 
-## Return types
+## Tipos de devolución
 
-The important thing to know about all primitive-conversion methods is that they do not necessarily return the "hinted" primitive.
+Lo importante que debe saber acerca de todos los métodos de conversión primitiva es que no necesariamente devuelven la primitiva "insinuada".
 
-There is no control whether `toString` returns exactly a string, or whether `Symbol.toPrimitive` method returns a number for a hint `"number"`.
+No hay control sobre si `toString` devuelve exactamente un string, o si el método `Symbol.toPrimitive` devuelve un número para un hint `"number"`.
 
-The only mandatory thing: these methods must return a primitive, not an object.
+Lo único obligatorio: estos métodos deben devolver un valor primitivo, no un objeto.
 
-```smart header="Historical notes"
-For historical reasons, if `toString` or `valueOf` returns an object, there's no error, but such value is ignored (like if the method didn't exist). That's because in ancient times there was no good "error" concept in JavaScript.
+```smart header="Notas históricas"
+Por razones históricas, si `toString` o `valueOf` devuelve un objeto, no hay ningún error, pero dicho valor se ignora (como si el método no existiera). Esto se debe a que en la antigüedad no existía un buen concepto de "error" en JavaScript.
 
-In contrast, `Symbol.toPrimitive` *must* return a primitive, otherwise there will be an error.
+Por el contrario, `Symbol.toPrimitive` *debe* devolver un valor primitivo, de lo contrario habrá un error.
 ```
 
-## Further conversions
+## Más conversiones
 
-As we know already, many operators and functions perform type conversions, e.g. multiplication `*` converts operands to numbers.
+Como ya sabemos, muchos operadores y funciones realizan conversiones de tipo, por ejemplo la multiplicación `*` convierte operandos en números.
 
-If we pass an object as an argument, then there are two stages:
-1. The object is converted to a primitive (using the rules described above).
-2. If the resulting primitive isn't of the right type, it's converted.
+Si pasamos un objeto como argumento, entonces hay dos etapas:
+1. El objeto se convierte en un valor primitivo (utilizando las reglas descritas anteriormente).
+2. Si el valor primitivo resultante no es del tipo correcto, se convierte.
 
-For instance:
+Por ejemplo:
 
 ```js run
 let obj = {
-  // toString handles all conversions in the absence of other methods
+  // toString maneja todas las conversiones en ausencia de otros métodos
   toString() {
     return "2";
   }
 };
 
-alert(obj * 2); // 4, object converted to primitive "2", then multiplication made it a number
+alert(obj * 2); // 4, objeto convertido a valor primitivo "2", luego la multiplicación lo convirtió en un número
 ```
 
-1. The multiplication `obj * 2` first converts the object to primitive (that's a string `"2"`).
-2. Then `"2" * 2` becomes `2 * 2` (the string is converted to number).
+1. La multiplicación `obj * 2` primero convierte el objeto en valor primitivo (que es un string `"2"`).
+2. Luego `"2" * 2` se convierte en `2 * 2` (el string se convierte en número).
 
-Binary plus will concatenate strings in the same situation, as it gladly accepts a string:
+`+` binario concatenará los strings en la misma situación, ya que acepta con gusto un string:
 
 ```js run
 let obj = {
@@ -230,26 +230,26 @@ let obj = {
   }
 };
 
-alert(obj + 2); // 22 ("2" + 2), conversion to primitive returned a string => concatenation
+alert(obj + 2); // 22 ("2" + 2), la conversión a valor primitivo devolvió un string => concatenación
 ```
 
-## Summary
+## Resumen
 
-The object-to-primitive conversion is called automatically by many built-in functions and operators that expect a primitive as a value.
+La conversión de objeto a valor primitivo es llamada automáticamente por muchas funciones y operadores incorporados que esperan un valor primitivo.
 
-There are 3 types (hints) of it:
-- `"string"` (for `alert` and other operations that need a string)
-- `"number"` (for maths)
-- `"default"` (few operators)
+Hay 3 tipos (hints) de esto:
+- `"string"` (para `alert` y otras operaciones que necesitan un string)
+- `"number"` (para matemáticas)
+- `"default"` (pocos operadores)
 
-The specification describes explicitly which operator uses which hint. There are very few operators that "don't know what to expect" and use the `"default"` hint. Usually for built-in objects `"default"` hint is handled the same way as `"number"`, so in practice the last two are often merged together.
+La especificación describe explícitamente qué operador utiliza qué hint. Hay muy pocos operadores que "no saben qué esperar" y utilizan el hint `"default"`. Por lo general, para los objetos incorporados, el hint `"default"` se maneja de la misma manera que `"number"`, por lo que en la práctica los dos últimos a menudo se combinan.
 
-The conversion algorithm is:
+El algoritmo de conversión es:
 
-1. Call `obj[Symbol.toPrimitive](hint)` if the method exists,
-2. Otherwise if hint is `"string"`
-    - try `obj.toString()` and `obj.valueOf()`, whatever exists.
-3. Otherwise if hint is `"number"` or `"default"`
-    - try `obj.valueOf()` and `obj.toString()`, whatever exists.
+1. Llamar a `obj[Symbol.toPrimitive](hint)` si el método existe,
+2. De lo contrario, si el hint es `"string"`
+    - intentar `obj.toString()` y `obj.valueOf()`, lo que exista.
+3. De lo contrario, si el hint es `"number"` o `"default"`
+    - intentar `obj.valueOf()` y `obj.toString()`, lo que exista.
 
-In practice, it's often enough to implement only `obj.toString()` as a "catch-all" method for all conversions that return a "human-readable" representation of an object, for logging or debugging purposes.  
+En la práctica, a menudo es suficiente implementar solo `obj.toString()` como un método "general" para todas las conversiones que devuelven una representación "legible por humanos" de un objeto, con fines de registro o depuración.

From 11c646bdf1fd1f961b7dc9ae94bf14fc68a80818 Mon Sep 17 00:00:00 2001
From: Homero Enrique Marin Galindo <homeromaring@gmail.com>
Date: Mon, 17 Aug 2020 07:29:21 -0500
Subject: [PATCH 02/13] Update
 1-js/04-object-basics/09-object-toprimitive/article.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

numérico->número

Co-authored-by: joaquinelio <joaquinelio@gmail.com>
---
 1-js/04-object-basics/09-object-toprimitive/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/04-object-basics/09-object-toprimitive/article.md b/1-js/04-object-basics/09-object-toprimitive/article.md
index 6648081fe..6035e1e08 100644
--- a/1-js/04-object-basics/09-object-toprimitive/article.md
+++ b/1-js/04-object-basics/09-object-toprimitive/article.md
@@ -29,7 +29,7 @@ Hay tres variantes de conversión de tipos, denominadas "hints", que se describe
     ```
 
 `"number"`
-: Para una conversión de objeto a numérico, como cuando hacemos operaciones matemáticas:
+: Para una conversión de objeto a número, como cuando hacemos operaciones matemáticas:
 
     ```js
     // conversión explícita

From 7e9f02b8b36c40737574cff3fa75c2cdb0d5ce74 Mon Sep 17 00:00:00 2001
From: Homero Enrique Marin Galindo <homeromaring@gmail.com>
Date: Mon, 17 Aug 2020 07:30:15 -0500
Subject: [PATCH 03/13] Update
 1-js/04-object-basics/09-object-toprimitive/article.md

unitario->unario

Co-authored-by: joaquinelio <joaquinelio@gmail.com>
---
 1-js/04-object-basics/09-object-toprimitive/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/04-object-basics/09-object-toprimitive/article.md b/1-js/04-object-basics/09-object-toprimitive/article.md
index 6035e1e08..0af1ddecb 100644
--- a/1-js/04-object-basics/09-object-toprimitive/article.md
+++ b/1-js/04-object-basics/09-object-toprimitive/article.md
@@ -36,7 +36,7 @@ Hay tres variantes de conversión de tipos, denominadas "hints", que se describe
     let num = Number(obj);
 
     // matemáticas (excepto + binario)
-    let n = +obj; // + unitario
+    let n = +obj; // + unario
     let delta = date1 - date2;
 
     // comparación menor que / mayor que

From 82b1f227594edd656d8401b1c34f270665e9ff8c Mon Sep 17 00:00:00 2001
From: Homero Enrique Marin Galindo <homeromaring@gmail.com>
Date: Mon, 17 Aug 2020 07:31:45 -0500
Subject: [PATCH 04/13] Update
 1-js/04-object-basics/09-object-toprimitive/article.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

el key simbólico-> la clave simbólica

Co-authored-by: joaquinelio <joaquinelio@gmail.com>
---
 1-js/04-object-basics/09-object-toprimitive/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/04-object-basics/09-object-toprimitive/article.md b/1-js/04-object-basics/09-object-toprimitive/article.md
index 0af1ddecb..b625dc4d8 100644
--- a/1-js/04-object-basics/09-object-toprimitive/article.md
+++ b/1-js/04-object-basics/09-object-toprimitive/article.md
@@ -70,7 +70,7 @@ No hay ningún hint "boolean" (todos los objetos son `true` en el contexto boole
 
 **Para realizar la conversión, JavaScript intenta buscar y llamar a tres métodos del objeto:**
 
-1. Llamar a `obj[Symbol.toPrimitive](hint)` : el método con el key simbólico `Symbol.toPrimitive` (símbolo del sistema), si tal método existe,
+1. Llamar a `obj[Symbol.toPrimitive](hint)` : el método con la clave simbólica `Symbol.toPrimitive` (símbolo del sistema), si tal método existe,
 2. De lo contrario, si el hint es `"string"`
     - intentar `obj.toString()` y `obj.valueOf()`, lo que exista.
 3. De lo contrario, si el hint es `"number"` o `"default"`

From 781a82e271d0fe9a0c762dde64d9c35147bcda78 Mon Sep 17 00:00:00 2001
From: Homero Enrique Marin Galindo <homeromaring@gmail.com>
Date: Mon, 17 Aug 2020 07:32:42 -0500
Subject: [PATCH 05/13] Update
 1-js/04-object-basics/09-object-toprimitive/article.md

El->Un

Co-authored-by: joaquinelio <joaquinelio@gmail.com>
---
 1-js/04-object-basics/09-object-toprimitive/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/04-object-basics/09-object-toprimitive/article.md b/1-js/04-object-basics/09-object-toprimitive/article.md
index b625dc4d8..0708326c4 100644
--- a/1-js/04-object-basics/09-object-toprimitive/article.md
+++ b/1-js/04-object-basics/09-object-toprimitive/article.md
@@ -106,7 +106,7 @@ alert(+user); // hint: number -> 1000
 alert(user + 500); // hint: default -> 1500
 ```
 
-Como podemos ver en el código, `user` se convierte en un string autodescriptivo o en una cantidad de dinero dependiendo de la conversión. El único método `user[Symbol.toPrimitive]` maneja todos los casos de conversión.
+Como podemos ver en el código, `user` se convierte en un string autodescriptivo o en una cantidad de dinero dependiendo de la conversión. Un único método `user[Symbol.toPrimitive]` maneja todos los casos de conversión.
 
 
 ## toString/valueOf

From f444ef0b033b643e80130550f6d710782bf5b107 Mon Sep 17 00:00:00 2001
From: Homero Enrique Marin Galindo <homeromaring@gmail.com>
Date: Mon, 17 Aug 2020 07:34:00 -0500
Subject: [PATCH 06/13] Update
 1-js/04-object-basics/09-object-toprimitive/article.md

insinuada->sugerida

Co-authored-by: joaquinelio <joaquinelio@gmail.com>
---
 1-js/04-object-basics/09-object-toprimitive/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/04-object-basics/09-object-toprimitive/article.md b/1-js/04-object-basics/09-object-toprimitive/article.md
index 0708326c4..4ce088132 100644
--- a/1-js/04-object-basics/09-object-toprimitive/article.md
+++ b/1-js/04-object-basics/09-object-toprimitive/article.md
@@ -185,7 +185,7 @@ En ausencia de `Symbol.toPrimitive` y `valueOf`, `toString` manejará todas las
 
 ## Tipos de devolución
 
-Lo importante que debe saber acerca de todos los métodos de conversión primitiva es que no necesariamente devuelven la primitiva "insinuada".
+Lo importante que debe saber acerca de todos los métodos de conversión primitiva es que no necesariamente devuelven la primitiva "sugerida".
 
 No hay control sobre si `toString` devuelve exactamente un string, o si el método `Symbol.toPrimitive` devuelve un número para un hint `"number"`.
 

From 1e0be0a0fe15d571963f72d525dbd8089ce1f0ba Mon Sep 17 00:00:00 2001
From: Homero Enrique Marin Galindo <homeromaring@gmail.com>
Date: Mon, 17 Aug 2020 07:34:32 -0500
Subject: [PATCH 07/13] Update
 1-js/04-object-basics/09-object-toprimitive/article.md

de lo contrario->en caso contrario

Co-authored-by: joaquinelio <joaquinelio@gmail.com>
---
 1-js/04-object-basics/09-object-toprimitive/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/04-object-basics/09-object-toprimitive/article.md b/1-js/04-object-basics/09-object-toprimitive/article.md
index 4ce088132..31acf10f5 100644
--- a/1-js/04-object-basics/09-object-toprimitive/article.md
+++ b/1-js/04-object-basics/09-object-toprimitive/article.md
@@ -116,7 +116,7 @@ Los métodos `toString` y `valueOf` provienen de la antigüedad. No son símbolo
 Si no hay `Symbol.toPrimitive`, JavaScript intenta encontrar los hints e intenta en este orden:
 
 - `toString -> valueOf` para el hint "string".
-- `valueOf -> toString` de lo contrario.
+- `valueOf -> toString` en caso contrario.
 
 Estos métodos deben devolver un valor primitivo. Si `toString` o `valueOf` devuelve un objeto, entonces se ignora (lo mismo que si no hubiera un método).
 

From fa8d53184bf171d9510ebf4a0df732abf87c3d57 Mon Sep 17 00:00:00 2001
From: Homero304 <homeromaring@gmail.com>
Date: Mon, 17 Aug 2020 07:53:37 -0500
Subject: [PATCH 08/13] hint->sugerencia

---
 .../09-object-toprimitive/article.md          | 48 +++++++++----------
 1 file changed, 24 insertions(+), 24 deletions(-)

diff --git a/1-js/04-object-basics/09-object-toprimitive/article.md b/1-js/04-object-basics/09-object-toprimitive/article.md
index 31acf10f5..a118a4297 100644
--- a/1-js/04-object-basics/09-object-toprimitive/article.md
+++ b/1-js/04-object-basics/09-object-toprimitive/article.md
@@ -15,7 +15,7 @@ En el capítulo <info:type-conversions>, hemos visto las reglas para las convers
 
 Podemos ajustar la conversión de tipo string y numérica, utilizando métodos especiales del objeto.
 
-Hay tres variantes de conversión de tipos, denominadas "hints", que se describen en la [especificación](https://tc39.github.io/ecma262/#sec-toprimitive):
+Hay tres variantes de conversión de tipos, denominadas "sugerencias", que se describen en la [especificación](https://tc39.github.io/ecma262/#sec-toprimitive):
 
 `"string"`
 : Para una conversión de objeto a string, cuando hacemos una operación que espera un string en un objeto, como `alert`:
@@ -46,34 +46,34 @@ Hay tres variantes de conversión de tipos, denominadas "hints", que se describe
 `"default"`
 : Ocurre en casos raros cuando el operador "no está seguro" de qué tipo esperar.
 
-    Por ejemplo, el operador binario `+` puede funcionar con strings (los concatena) y números (los suma), por lo que tanto los strings como los números servirían. Entonces, si el + binario obtiene un objeto como argumento, utiliza el hint `"default"` para convertirlo.
+    Por ejemplo, el operador binario `+` puede funcionar con strings (los concatena) y números (los suma), por lo que tanto los strings como los números servirían. Entonces, si el + binario obtiene un objeto como argumento, utiliza la sugerencia `"default"` para convertirlo.
 
-    También, si un objeto es comparado utilizando `==` con un string, un número o un símbolo, tampoco está claro qué conversión se debe realizar, por lo que se utiliza el hint `"default"`.
+    También, si un objeto es comparado utilizando `==` con un string, un número o un símbolo, tampoco está claro qué conversión se debe realizar, por lo que se utiliza la sugerencia `"default"`.
 
     ```js
-    // + binario utiliza el hint "default"
+    // + binario utiliza la sugerencia "default"
     let total = obj1 + obj2;
 
-    // obj == número utiliza el hint "default"
+    // obj == número utiliza la sugerencia "default"
     if (user == 1) { ... };
     ```
 
-    Los operadores de comparación mayor que y menor que, como `<` `>`, también pueden funcionar con strings y números. Aún así, utilizan el hint `"number"`, y no `"default"`. Eso es por razones históricas.
+    Los operadores de comparación mayor que y menor que, como `<` `>`, también pueden funcionar con strings y números. Aún así, utilizan la sugerencia `"number"`, y no `"default"`. Eso es por razones históricas.
 
     Sin embargo, en la práctica, no necesitamos recordar estos detalles peculiares, porque todos los objetos incorporados excepto un caso (el objeto `Date`, lo aprenderemos más adelante) implementan la conversión `"default"` de la misma manera que `"number"`. Y podemos hacer lo mismo.
 
-```smart header="No hay hint `\"boolean\"`"
-Tenga en cuenta : Solo hay tres hints. Es así de simple.
+```smart header="No hay sugerencia `\"boolean\"`"
+Tenga en cuenta : Solo hay tres sugerencias. Es así de simple.
 
-No hay ningún hint "boolean" (todos los objetos son `true` en el contexto booleano) ni nada más. Y si tratamos `"default"` y `"number"` de la misma manera, como lo hacen la mayoría de las funciones incorporadas, entonces solo hay dos conversiones.
+No hay ninguna sugerencia "boolean" (todos los objetos son `true` en el contexto booleano) ni nada más. Y si tratamos `"default"` y `"number"` de la misma manera, como lo hacen la mayoría de las funciones incorporadas, entonces solo hay dos conversiones.
 ```
 
 **Para realizar la conversión, JavaScript intenta buscar y llamar a tres métodos del objeto:**
 
 1. Llamar a `obj[Symbol.toPrimitive](hint)` : el método con la clave simbólica `Symbol.toPrimitive` (símbolo del sistema), si tal método existe,
-2. De lo contrario, si el hint es `"string"`
+2. De lo contrario, si la sugerencia es `"string"`
     - intentar `obj.toString()` y `obj.valueOf()`, lo que exista.
-3. De lo contrario, si el hint es `"number"` o `"default"`
+3. De lo contrario, si la sugerencia es `"number"` o `"default"`
     - intentar `obj.valueOf()` y `obj.toString()`, lo que exista.
 
 ## Symbol.toPrimitive
@@ -95,15 +95,15 @@ let user = {
   money: 1000,
 
   [Symbol.toPrimitive](hint) {
-    alert(`hint: ${hint}`);
+    alert(`sugerencia: ${hint}`);
     return hint == "string" ? `{name: "${this.name}"}` : this.money;
   }
 };
 
 // demostración de conversiones:
-alert(user); // hint: string -> {name: "John"}
-alert(+user); // hint: number -> 1000
-alert(user + 500); // hint: default -> 1500
+alert(user); // sugerencia: string -> {name: "John"}
+alert(+user); // sugerencia: number -> 1000
+alert(user + 500); // sugerencia: default -> 1500
 ```
 
 Como podemos ver en el código, `user` se convierte en un string autodescriptivo o en una cantidad de dinero dependiendo de la conversión. Un único método `user[Symbol.toPrimitive]` maneja todos los casos de conversión.
@@ -113,9 +113,9 @@ Como podemos ver en el código, `user` se convierte en un string autodescriptivo
 
 Los métodos `toString` y `valueOf` provienen de la antigüedad. No son símbolos (los símbolos no existían en aquel tiempo), sino métodos "regulares" nombrados con string. Proporcionan una forma alternativa "al viejo estilo" de implementar la conversión.
 
-Si no hay `Symbol.toPrimitive`, JavaScript intenta encontrar los hints e intenta en este orden:
+Si no hay `Symbol.toPrimitive`, JavaScript intenta encontrar las sugerencias e intenta en este orden:
 
-- `toString -> valueOf` para el hint "string".
+- `toString -> valueOf` para la sugerencia "string".
 - `valueOf -> toString` en caso contrario.
 
 Estos métodos deben devolver un valor primitivo. Si `toString` o `valueOf` devuelve un objeto, entonces se ignora (lo mismo que si no hubiera un método).
@@ -147,12 +147,12 @@ let user = {
   name: "John",
   money: 1000,
 
-  // para hint="string"
+  // para sugerencia="string"
   toString() {
     return `{name: "${this.name}"}`;
   },
 
-  // para hint="number" o "default"
+  // para sugerencia="number" o "default"
   valueOf() {
     return this.money;
   }
@@ -187,7 +187,7 @@ En ausencia de `Symbol.toPrimitive` y `valueOf`, `toString` manejará todas las
 
 Lo importante que debe saber acerca de todos los métodos de conversión primitiva es que no necesariamente devuelven la primitiva "sugerida".
 
-No hay control sobre si `toString` devuelve exactamente un string, o si el método `Symbol.toPrimitive` devuelve un número para un hint `"number"`.
+No hay control sobre si `toString` devuelve exactamente un string, o si el método `Symbol.toPrimitive` devuelve un número para una sugerencia `"number"`.
 
 Lo único obligatorio: estos métodos deben devolver un valor primitivo, no un objeto.
 
@@ -237,19 +237,19 @@ alert(obj + 2); // 22 ("2" + 2), la conversión a valor primitivo devolvió un s
 
 La conversión de objeto a valor primitivo es llamada automáticamente por muchas funciones y operadores incorporados que esperan un valor primitivo.
 
-Hay 3 tipos (hints) de esto:
+Hay 3 tipos (sugerencias) de esto:
 - `"string"` (para `alert` y otras operaciones que necesitan un string)
 - `"number"` (para matemáticas)
 - `"default"` (pocos operadores)
 
-La especificación describe explícitamente qué operador utiliza qué hint. Hay muy pocos operadores que "no saben qué esperar" y utilizan el hint `"default"`. Por lo general, para los objetos incorporados, el hint `"default"` se maneja de la misma manera que `"number"`, por lo que en la práctica los dos últimos a menudo se combinan.
+La especificación describe explícitamente qué operador utiliza qué sugerencia. Hay muy pocos operadores que "no saben qué esperar" y utilizan la sugerencia `"default"`. Por lo general, para los objetos incorporados, la sugerencia `"default"` se maneja de la misma manera que `"number"`, por lo que en la práctica los dos últimos a menudo se combinan.
 
 El algoritmo de conversión es:
 
 1. Llamar a `obj[Symbol.toPrimitive](hint)` si el método existe,
-2. De lo contrario, si el hint es `"string"`
+2. De lo contrario, si la sugerencia es `"string"`
     - intentar `obj.toString()` y `obj.valueOf()`, lo que exista.
-3. De lo contrario, si el hint es `"number"` o `"default"`
+3. De lo contrario, si la sugerencia es `"number"` o `"default"`
     - intentar `obj.valueOf()` y `obj.toString()`, lo que exista.
 
 En la práctica, a menudo es suficiente implementar solo `obj.toString()` como un método "general" para todas las conversiones que devuelven una representación "legible por humanos" de un objeto, con fines de registro o depuración.

From a438bb6cb5f83c3b42fae054e2f949615e360540 Mon Sep 17 00:00:00 2001
From: Homero304 <homeromaring@gmail.com>
Date: Mon, 17 Aug 2020 07:56:48 -0500
Subject: [PATCH 09/13] de lo contrario -> en caso contrario

---
 1-js/04-object-basics/09-object-toprimitive/article.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/1-js/04-object-basics/09-object-toprimitive/article.md b/1-js/04-object-basics/09-object-toprimitive/article.md
index a118a4297..a9eac2c4e 100644
--- a/1-js/04-object-basics/09-object-toprimitive/article.md
+++ b/1-js/04-object-basics/09-object-toprimitive/article.md
@@ -71,9 +71,9 @@ No hay ninguna sugerencia "boolean" (todos los objetos son `true` en el contexto
 **Para realizar la conversión, JavaScript intenta buscar y llamar a tres métodos del objeto:**
 
 1. Llamar a `obj[Symbol.toPrimitive](hint)` : el método con la clave simbólica `Symbol.toPrimitive` (símbolo del sistema), si tal método existe,
-2. De lo contrario, si la sugerencia es `"string"`
+2. En caso contrario, si la sugerencia es `"string"`
     - intentar `obj.toString()` y `obj.valueOf()`, lo que exista.
-3. De lo contrario, si la sugerencia es `"number"` o `"default"`
+3. En caso contrario, si la sugerencia es `"number"` o `"default"`
     - intentar `obj.valueOf()` y `obj.toString()`, lo que exista.
 
 ## Symbol.toPrimitive
@@ -194,7 +194,7 @@ Lo único obligatorio: estos métodos deben devolver un valor primitivo, no un o
 ```smart header="Notas históricas"
 Por razones históricas, si `toString` o `valueOf` devuelve un objeto, no hay ningún error, pero dicho valor se ignora (como si el método no existiera). Esto se debe a que en la antigüedad no existía un buen concepto de "error" en JavaScript.
 
-Por el contrario, `Symbol.toPrimitive` *debe* devolver un valor primitivo, de lo contrario habrá un error.
+Por el contrario, `Symbol.toPrimitive` *debe* devolver un valor primitivo, en caso contrario habrá un error.
 ```
 
 ## Más conversiones
@@ -247,9 +247,9 @@ La especificación describe explícitamente qué operador utiliza qué sugerenci
 El algoritmo de conversión es:
 
 1. Llamar a `obj[Symbol.toPrimitive](hint)` si el método existe,
-2. De lo contrario, si la sugerencia es `"string"`
+2. En caso contrario, si la sugerencia es `"string"`
     - intentar `obj.toString()` y `obj.valueOf()`, lo que exista.
-3. De lo contrario, si la sugerencia es `"number"` o `"default"`
+3. En caso contrario, si la sugerencia es `"number"` o `"default"`
     - intentar `obj.valueOf()` y `obj.toString()`, lo que exista.
 
 En la práctica, a menudo es suficiente implementar solo `obj.toString()` como un método "general" para todas las conversiones que devuelven una representación "legible por humanos" de un objeto, con fines de registro o depuración.

From 7123e3e2f35f3fc8029ef5d674978b80c11fcffd Mon Sep 17 00:00:00 2001
From: Homero304 <homeromaring@gmail.com>
Date: Mon, 17 Aug 2020 07:58:30 -0500
Subject: [PATCH 10/13] key->clave

---
 1-js/04-object-basics/09-object-toprimitive/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/04-object-basics/09-object-toprimitive/article.md b/1-js/04-object-basics/09-object-toprimitive/article.md
index a9eac2c4e..5a8da001c 100644
--- a/1-js/04-object-basics/09-object-toprimitive/article.md
+++ b/1-js/04-object-basics/09-object-toprimitive/article.md
@@ -24,7 +24,7 @@ Hay tres variantes de conversión de tipos, denominadas "sugerencias", que se de
     // salida
     alert(obj);
 
-    // utilizando un objeto como key
+    // utilizando un objeto como clave
     anotherObj[obj] = 123;
     ```
 

From 6910632cbfdc94e1eac60b8b19c30a3947a248c7 Mon Sep 17 00:00:00 2001
From: Homero Enrique Marin Galindo <homeromaring@gmail.com>
Date: Tue, 18 Aug 2020 19:31:25 -0500
Subject: [PATCH 11/13] Update
 1-js/04-object-basics/09-object-toprimitive/article.md

string->strings

Co-authored-by: Maksumi Murakami <maksumimurakami@gmail.com>
---
 1-js/04-object-basics/09-object-toprimitive/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/04-object-basics/09-object-toprimitive/article.md b/1-js/04-object-basics/09-object-toprimitive/article.md
index 5a8da001c..35c629e15 100644
--- a/1-js/04-object-basics/09-object-toprimitive/article.md
+++ b/1-js/04-object-basics/09-object-toprimitive/article.md
@@ -111,7 +111,7 @@ Como podemos ver en el código, `user` se convierte en un string autodescriptivo
 
 ## toString/valueOf
 
-Los métodos `toString` y `valueOf` provienen de la antigüedad. No son símbolos (los símbolos no existían en aquel tiempo), sino métodos "regulares" nombrados con string. Proporcionan una forma alternativa "al viejo estilo" de implementar la conversión.
+Los métodos `toString` y `valueOf` provienen de la antigüedad. No son símbolos (los símbolos no existían en aquel tiempo), sino métodos "regulares" nombrados con strings. Proporcionan una forma alternativa "al viejo estilo" de implementar la conversión.
 
 Si no hay `Symbol.toPrimitive`, JavaScript intenta encontrar las sugerencias e intenta en este orden:
 

From ad3442e87c48a1eed49ac0afb3e21c67e02f7942 Mon Sep 17 00:00:00 2001
From: Homero Enrique Marin Galindo <homeromaring@gmail.com>
Date: Tue, 18 Aug 2020 19:32:21 -0500
Subject: [PATCH 12/13] Update
 1-js/04-object-basics/09-object-toprimitive/article.md

Entonces->Por lo tanto

Co-authored-by: Maksumi Murakami <maksumimurakami@gmail.com>
---
 1-js/04-object-basics/09-object-toprimitive/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/04-object-basics/09-object-toprimitive/article.md b/1-js/04-object-basics/09-object-toprimitive/article.md
index 35c629e15..0cee0fd05 100644
--- a/1-js/04-object-basics/09-object-toprimitive/article.md
+++ b/1-js/04-object-basics/09-object-toprimitive/article.md
@@ -134,7 +134,7 @@ alert(user); // [object Object]
 alert(user.valueOf() === user); // true
 ```
 
-Entonces, si intentamos utilizar un objeto como un string, como en un `alert` o algo así, entonces por defecto vemos `[object Object]`.
+Por lo tanto, si intentamos utilizar un objeto como un string, como en un `alert` o algo así, entonces por defecto vemos `[object Object]`.
 
 Y el `valueOf` predeterminado se menciona aquí solo en favor de la integridad, para evitar confusiones. Como puede ver, devuelve el objeto en sí, por lo que se ignora. No me pregunte por qué, es por razones históricas. Entonces podemos asumir que no existe.
 

From b3a35675705708ff295c64f9dc0714828b9b62f6 Mon Sep 17 00:00:00 2001
From: Homero Enrique Marin Galindo <homeromaring@gmail.com>
Date: Tue, 18 Aug 2020 19:33:23 -0500
Subject: [PATCH 13/13] Update
 1-js/04-object-basics/09-object-toprimitive/article.md

"`+`"->"El `+`"

Co-authored-by: Maksumi Murakami <maksumimurakami@gmail.com>
---
 1-js/04-object-basics/09-object-toprimitive/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/04-object-basics/09-object-toprimitive/article.md b/1-js/04-object-basics/09-object-toprimitive/article.md
index 0cee0fd05..9a820704c 100644
--- a/1-js/04-object-basics/09-object-toprimitive/article.md
+++ b/1-js/04-object-basics/09-object-toprimitive/article.md
@@ -221,7 +221,7 @@ alert(obj * 2); // 4, objeto convertido a valor primitivo "2", luego la multipli
 1. La multiplicación `obj * 2` primero convierte el objeto en valor primitivo (que es un string `"2"`).
 2. Luego `"2" * 2` se convierte en `2 * 2` (el string se convierte en número).
 
-`+` binario concatenará los strings en la misma situación, ya que acepta con gusto un string:
+El `+` binario concatenará los strings en la misma situación, ya que acepta con gusto un string:
 
 ```js run
 let obj = {