1 5 1 t5

Author: joaquinelio

1-js/05-data-types/01-primitives-methods/1-string-new-property/solution.md

@@ -1,5 +1,5 @@
 
-Try running it:
+Prueba a ejecutar:
 
 ```js run
 let str = "Hello";
@@ -9,23 +9,16 @@ str.test = 5; // (*)
 alert(str.test); 
 ```
 
-There may be two kinds of result:
-1. `undefined`
-2. An error.
+Dependiendo del uso o no del modo estricto "use strict", el resultado puede ser:
+1. `undefined` (sin strict mode)
+2. Un error  (strict mode)
 
-Why? Let's replay what's happening at line `(*)`:
+¿Por qué? Repasemos qué ocurre en la línea `(*)`:
 
-1. When a property of `str` is accessed, a "wrapper object" is created.
-2. The operation with the property is carried out on it. So, the object gets the `test` property.
-3. The operation finishes and the "wrapper object" disappears.
+1. Cuando se accede a una propiedad de `str`, un "wrapper object" es creado.
+2. Con modo estricto, alterarlo produce error. 
+3. De otra manera, la operación es llevada a cabo y el objeto obtiene la propiedad `test`, pero después de ello el "wrapper object" desaparece, entonces en la última linea `str` queda sin rastros de la propiedad.
 
-So, on the last line, `str` has no trace of the property. A new wrapper object for every object operation on a string.
-
-Some browsers though may decide to further limit the programmer and disallow to assign properties to primitives at all. That's why in practice we can also see errors at line `(*)`. It's a little bit farther from the specification though.
-
-**This example clearly shows that primitives are not objects.**
-
-They just can not store data. 
-
-All property/method operations are performed with the help of temporary objects.
+**Este ejemlplo claramente muestra que los tipos primitivos no son objetos.**
 
+Ellos no pueden almacenar datos adicionales. 

1-js/05-data-types/01-primitives-methods/1-string-new-property/task.md

@@ -2,17 +2,17 @@ importance: 5
 
 ---
 
-# Can I add a string property?
+# ¿Puedo agregar un propiedad a un string?
 
 
-Consider the following code:
+Considera el siguiente código:
 
 ```js
 let str = "Hello";
 
-str.test = 5;
+str.test = 5; 
 
 alert(str.test);
 ```
 
-How do you think, will it work? What will be shown?
+Qué piensas, ¿funcionará? ¿Qué mostrará?

1-js/05-data-types/01-primitives-methods/article.md

@@ -1,10 +1,8 @@
-# Métodos de primitivos 
+# Métodos en datos primitivos 
 
-JavaScript nos permite trabajar con datos primitivos (strings, numbers, etc.) como si fueran objetos.
+JavaScript nos permite trabajar con datos primitivos (strings, numbers, etc.) como si fueran objetos.  Ellos también proveen métodos para ser llamados como tales.  Los estudiaremos pronto, pero primero veamos cómo trabajan porque, por supuesto, los primitivos no son objetos (y aquí lo haremos más evidente).
 
-También proveen, como aquellos, métodos para ser llamados.  Los estudiaremos pronto, pero primero veamos cómo trabajan porque, por supuesto, los primitivos no son objetos (y aquí lo haremos más evidente).
-
-Veamos las diferencias clave entre primitivos y objetos.
+Veamos las principales diferencias entre primitivos y objetos.
 
 Un primitivo
 
@@ -14,7 +12,7 @@ Un primitivo
 Un objeto
 
 - Es capaz de almacenar múltiples valores como propiedades.
-- Puede ser creado con `{}`, por ejemplo: `{name: "John", age: 30}`. Hay otras clases de objetos en JavaScript; por ejemplo, las funciones (`function`) son objetos .
+- Puede ser creado con `{}`, por ejemplo: `{name: "John", age: 30}`. Hay otros tipos de objetos en JavaScript; por ejemplo, las funciones son objetos.
 
 Una de las mejores cosas de los objetos es que podemos almacenar una función como una de sus propiedades.
 
@@ -29,28 +27,28 @@ let john = {
 john.sayHi(); // Hi buddy!
 ```
 
-Aquí hemos hecho un función `john` con el método `sayHi` (saludar).
+Aquí hemos hecho un función `john` con el método `sayHi`(saludar).
 
 Ya existen muchos objetos incorporados, como aquellos que trabajan con fechas, errores, elementos HTML, etc.  Ellos tienen diferentes propiedades y métodos.
 
 ¡Pero estas características vienen con un costo!
 
-Los objetos son más "pesados" que los primitivos. Requieren recursos adicionales para soportar su maquinaria interna. Pero como las propiedades y los métodos son tan útiles en programación, los motores JavaScript tratan de optimizarlos para reducir su carga adiional.
+Los objetos son más "pesados" que los tipos primitivos. Requieren recursos adicionales para soportar su maquinaria interna.
 
 ## Un primitivo como objeto
 
 Aquí la paradoja que enfrentó el creador de JavaScript:
 
-- Hay muchas cosas que uno quisiera hacer con primitivos como string o number. Sería grandioso acceder a métodos.
+- Hay muchas cosas que uno quisiera hacer con primitivos como string o number. Sería grandioso accederlas como métodos.
 - Los Primitivos deben ser tan rápidos y livianos como sea posible.
 
-La solución se ve algo enrevesada, pero aquí está:
+La solución es algo enrevesada, pero aquí está:
 
-1. Los primitivos son aún primitivos. Con un valor único, como es deseable.
+1. Los primitivos siguen siendo primitivos. Con un valor único, como es deseable.
 2. El lenguaje permite acceder a métodos y propiedades de strings, numbers, booleans y symbols.
-3. Cuando esto ocurre, un "object wrapper" (objeto envoltura) especial que provee la funcionalidad extra es creado y luego destruido.
+3. Para que esto funcione, un "object wrapper" (objeto envoltura) especial que provee la funcionalidad extra es creado, y luego destruido.
 
-Los "object wrappers" son diferentes para cada tipo primitivo y son llamados: `String`, `Number`, `Boolean` y `Symbol`.  Así proveen diferentes sets de métodos.
+Los "object wrappers" son diferentes para cada tipo primitivo y son llamados: `String`, `Number`, `Boolean` y `Symbol`.  Así, proveen diferentes sets de métodos.
 
 Por ejemplo, hay un método [str.toUpperCase()](https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/String/toUpperCase) que devuelve un string en mayúsculas.
 
@@ -68,7 +66,7 @@ Simple, ¿no es así?  Lo que realmente ocurre en `str.toUpperCase()`:
 2. El método se ejecuta y devuelve un nuevo string (el mostrado con `alert`).
 3. El objeto especial es destruido, dejando solo el primitivo `str`.
 
-Así las primitivas pueden proveer métodos y aún permanecer livianas.
+Así las primitivas pueden proporcionar métodos y aún permanecer livianas.
 
 El motor JavaScript optimiza este proceso enormemente.  Puede incluso saltear la creación del objeto extra por completo.  Pero aún debe adherir a la especificación y comportarse como si creara uno.
 
@@ -83,10 +81,10 @@ alert( n.toFixed(2) ); // 1.23
 Veremos más métodos específicos en los capítulos <info:number> y <info:string>.
 
 
-````warn header="Constructors `String/Number/Boolean` son de uso interno solamente"
-Algunos lenguajes como JAva permiten crear "wrapper objects" para primitivas explícitamente usando una sintaxis como `new Number(1)` o `new Boolean(false)`.
+````warn header="Los class constructor  `String/Number/Boolean` son de uso interno solamente"
+Algunos lenguajes como Java nos permiten crear explícitamente "wrapper objects" para primitivas usando una sintaxis como `new Number(1)` o `new Boolean(false)`.
 
-En JavaScript, eso también es posible por razones históricas, pero firmemente  **no recomendado**. Las cosas enloquecerán en varios lugares.
+En JavaScript, eso también es posible por razones históricas, pero firmemente  **desaconsejado**. Las cosas enloquecerán en varios lugares.
 
 Por ejemplo:
 
@@ -96,17 +94,17 @@ alert( typeof 1 ); // "number"
 alert( typeof new Number(1) ); // "object"!
 ```
 
-Los objetos son siempre verdaderos en un if, por ello el alert se mostrará:
+Los objetos son siempre verdaderos en un `if`, por ello el alert se mostrará:
 
 ```js run
 let zero = new Number(0);
 
 if (zero) { // zero es true, porque es un objeto
-  alert( "zero es verdadero?!?" );
+  alert( "¡zero es verdadero!?" );
 }
 ```
 
-Por otro lado, usar las mismas funciones `String/Number/Boolean` sin `new` es totalmente sano y útil. Ellos convierten un valor al tipo correspondiente: a un string, number, o boolean (primitivo).
+Por otro lado, usar las mismas funciones `String/Number/Boolean` sin `new` es totalmente sano y útil. Ellos convierten un valor al tipo correspondiente: a un string, un number o un boolean (primitivos).
 
 Por ejemplo, esto es perfectamente válido:
 ```js
@@ -115,8 +113,8 @@ let num = Number("123"); // convierte string a number
 ````
 
 
-````warn header="null/undefined have no methods"
-Las primitivas especiales `null` y `undefined` son excepciones. No tienen "wrapper objects" correspondientes y no proveen métodos. En ese sentido son "lo más primitivo".
+````warn header="null/undefined no tienen métodos"
+Las primitivas especiales `null` y `undefined` son excepciones. No tienen los "wrapper objects" correspondientes y no proporcionan métodos. En ese sentido son "lo más primitivo".
 
 El intento de acceder a una propiedad de tal valor daría error:
 
@@ -126,5 +124,5 @@ alert(null.test); // error
 
 ## Resumen
 
-- Las primitivas excepto `null` y `undefined` proveen muchos métodos útiles.  Los estudiaremos en los próximos capítulos.
-- Formalmente, estos métodos trabajan a través de objetos temporales, pero los motores de JavaScript están bien afinados para optimizarlos internamente, así que llamarlos no es costoso.
+- Los tipos primitivos excepto `null` y `undefined` proporcionan muchos métodos útiles.  Los estudiaremos en los próximos capítulos.
+- Oficialmente, estos métodos trabajan a través de objetos temporales, pero los motores de JavaScript están bien afinados para optimizar esto internamente así que llamarlos no es costoso.