From c0198202fc12e888bc023c424e5a76c17f0fdd7d Mon Sep 17 00:00:00 2001
From: ezzep66 <51804994+ezzep66@users.noreply.github.com>
Date: Mon, 22 Jun 2020 17:08:17 -0300
Subject: [PATCH 01/10] =?UTF-8?q?traducci=C3=B3n=20Object.keys?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../1-two-functions-one-object/solution.md    |   6 +-
 .../1-two-functions-one-object/task.md        |   6 +-
 .../2-calculator-constructor/_js.view/test.js |   6 +-
 .../2-calculator-constructor/task.md          |  12 +-
 .../3-accumulator/_js.view/test.js            |   8 +-
 .../3-accumulator/solution.md                 |   2 +-
 .../06-constructor-new/3-accumulator/task.md  |  22 +--
 .../06-constructor-new/article.md             | 142 +++++++++---------
 8 files changed, 102 insertions(+), 102 deletions(-)

diff --git a/1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/solution.md b/1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/solution.md
index 7d8edd7ca..59f037447 100644
--- a/1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/solution.md
+++ b/1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/solution.md
@@ -1,8 +1,8 @@
-Yes, it's possible.
+Si, es posible.
 
-If a function returns an object then `new` returns it instead of `this`.
+Si una función devuelve un objeto, entonces `new` lo devuelve en vez de `this`.
 
-So they can, for instance, return the same externally defined object `obj`:
+Por lo tanto pueden, por ejemplo, devolver el mismo objeto definido externamente `obj`:
 
 ```js run no-beautify
 let obj = {};
diff --git a/1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/task.md b/1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/task.md
index 8c1fea8eb..5d1ef6fff 100644
--- a/1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/task.md
+++ b/1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/task.md
@@ -2,9 +2,9 @@ importance: 2
 
 ---
 
-# Two functions – one object
+# Dos funciones – un objeto
 
-Is it possible to create functions `A` and `B` such as `new A()==new B()`?
+Es posible crear las funciones `A` y `B` como `new A()==new B()`?
 
 ```js no-beautify
 function A() { ... }
@@ -16,4 +16,4 @@ let b = new B;
 alert( a == b ); // true
 ```
 
-If it is, then provide an example of their code.
+Si es posible, entonces proporcione un ejemplo de su código.
diff --git a/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/_js.view/test.js b/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/_js.view/test.js
index 036053927..465cf40bd 100644
--- a/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/_js.view/test.js
+++ b/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/_js.view/test.js
@@ -11,15 +11,15 @@ describe("calculator", function() {
     calculator.read();
   });
 
-  it("when 2 and 3 are entered, the sum is 5", function() {
+  it("cuando se ingresa 2 y 3, la suma es 5", function() {
     assert.equal(calculator.sum(), 5);
   });
 
-  it("when 2 and 3 are entered, the product is 6", function() {
+  it("cuandose ingresa 2 y 3, el producto es 6", function() {
     assert.equal(calculator.mul(), 6);
   });
 
   after(function() {
     prompt.restore();
   });
-});
+});
\ No newline at end of file
diff --git a/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/task.md b/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/task.md
index 60e7c373e..85bd70438 100644
--- a/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/task.md
+++ b/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/task.md
@@ -2,15 +2,15 @@ importance: 5
 
 ---
 
-# Create new Calculator
+# Crear nueva Calculadora
 
-Create a constructor function `Calculator` that creates objects with 3 methods:
+Crear una función constructora `Calculator` que crea objetos con 3 métodos:
 
-- `read()` asks for two values using `prompt` and remembers them in object properties.
-- `sum()` returns the sum of these properties.
-- `mul()` returns the multiplication product of these properties.
+- `read()` pide dos valores usando `prompt` y los recuerda en las propiedades del objeto.
+- `sum()` devuelve la suma de estas propiedades.
+- `mul()` devuelve el producto de multiplicación de estas propiedades.
 
-For instance:
+Por ejemplo:
 
 ```js
 let calculator = new Calculator();
diff --git a/1-js/04-object-basics/06-constructor-new/3-accumulator/_js.view/test.js b/1-js/04-object-basics/06-constructor-new/3-accumulator/_js.view/test.js
index a719cf45c..61fe29bbb 100644
--- a/1-js/04-object-basics/06-constructor-new/3-accumulator/_js.view/test.js
+++ b/1-js/04-object-basics/06-constructor-new/3-accumulator/_js.view/test.js
@@ -8,23 +8,23 @@ describe("Accumulator", function() {
     prompt.restore();
   });
 
-  it("initial value is the argument of the constructor", function() {
+  it("valor inicial es el argumento del constructor", function() {
     let accumulator = new Accumulator(1);
 
     assert.equal(accumulator.value, 1);
   });
 
-  it("after reading 0, the value is 1", function() {
+  it("después de leer 0, el valor es 1", function() {
     let accumulator = new Accumulator(1);
     prompt.returns("0");
     accumulator.read();
     assert.equal(accumulator.value, 1);
   });
 
-  it("after reading 1, the value is 2", function() {
+  it("después de leer 1, el valor es 2", function() {
     let accumulator = new Accumulator(1);
     prompt.returns("1");
     accumulator.read();
     assert.equal(accumulator.value, 2);
   });
-});
+});
\ No newline at end of file
diff --git a/1-js/04-object-basics/06-constructor-new/3-accumulator/solution.md b/1-js/04-object-basics/06-constructor-new/3-accumulator/solution.md
index eb145e79d..8d1dfc5ca 100644
--- a/1-js/04-object-basics/06-constructor-new/3-accumulator/solution.md
+++ b/1-js/04-object-basics/06-constructor-new/3-accumulator/solution.md
@@ -5,7 +5,7 @@ function Accumulator(startingValue) {
   this.value = startingValue;
 
   this.read = function() {
-    this.value += +prompt('How much to add?', 0);
+    this.value += +prompt('Cuánto más agregar?', 0);
   };
 
 }
diff --git a/1-js/04-object-basics/06-constructor-new/3-accumulator/task.md b/1-js/04-object-basics/06-constructor-new/3-accumulator/task.md
index c2c44881e..7c11be7dc 100644
--- a/1-js/04-object-basics/06-constructor-new/3-accumulator/task.md
+++ b/1-js/04-object-basics/06-constructor-new/3-accumulator/task.md
@@ -2,26 +2,26 @@ importance: 5
 
 ---
 
-# Create new Accumulator
+# Crear nuevo Acumulador
 
-Create a constructor function `Accumulator(startingValue)`.
+Crear una función contructor `Accumulator(valorInicial)`.
 
-Object that it creates should:
+El objeto que crea debería:
 
-- Store the "current value" in the property `value`. The starting value is set to the argument of the constructor `startingValue`.
-- The `read()` method should use `prompt` to read a new number and add it to `value`.
+- Almacene el "valor actual" en la propiedad `value`. El valor inicial se establece en el argumento del constructor `valorInicial`.
+- El método `read()` debe usar `prompt` para leer un nuevo número y agregarlo a` value`.
 
-In other words, the `value` property is the sum of all user-entered values with the initial value  `startingValue`.
+En otras palabras, la propiedad `value` es la suma de todos los valores ingresados por el usuario con el valor inicial `startingValue`.
 
-Here's the demo of the code:
+Aquí está la demostración del código:
 
 ```js
-let accumulator = new Accumulator(1); // initial value 1
+let accumulator = new Accumulator(1); // valor inicial 1
 
-accumulator.read(); // adds the user-entered value
-accumulator.read(); // adds the user-entered value
+accumulator.read(); // agrega el valor introducido por el usuario
+accumulator.read(); // agrega el valor introducido por el usuario
 
-alert(accumulator.value); // shows the sum of these values
+alert(accumulator.value); // muestra la suma de estos valores
 ```
 
 [demo]
diff --git a/1-js/04-object-basics/06-constructor-new/article.md b/1-js/04-object-basics/06-constructor-new/article.md
index a885e35ff..1d50780d7 100644
--- a/1-js/04-object-basics/06-constructor-new/article.md
+++ b/1-js/04-object-basics/06-constructor-new/article.md
@@ -1,17 +1,17 @@
-# Constructor, operator "new"
+# Constructor, operador "new"
 
-The regular `{...}` syntax allows to create one object. But often we need to create many similar objects, like multiple users or menu items and so on.
+El sintaxis habitual `{...}` permite crear un objeto. Pero a menudo necesitamos crear varios objetos similares, como múltiples usuarios o elementos de menú, etcétera.
 
-That can be done using constructor functions and the `"new"` operator.
+Esto se puede realizar utilizando el constructor de funciones y el operador `"new"`.
 
-## Constructor function
+## Función constructora
 
-Constructor functions technically are regular functions. There are two conventions though:
+La función constructora es técnicamente una función normal. Aunque hay dos convenciones:
 
-1. They are named with capital letter first.
-2. They should be executed only with `"new"` operator.
+1. Son nombradas con la primera letra mayúscula.
+2. Sólo deben ejecutarse con el operador `"new"`.
 
-For instance:
+Por ejemplo:
 
 ```js run
 function User(name) {
@@ -27,31 +27,31 @@ alert(user.name); // Jack
 alert(user.isAdmin); // false
 ```
 
-When a function is executed with `new`, it does the following steps:
+Cuando una función es ejecutada con `new`, realiza los siguientes pasos:
 
-1. A new empty object is created and assigned to `this`.
-2. The function body executes. Usually it modifies `this`, adds new properties to it.
-3. The value of `this` is returned.
+1. Se crea un nuevo objeto vacío y se asigna a `this`.
+2. Se ejecuta el cuerpo de la función. Normalmente se modifica `this` y se le agrega nuevas propiedades.
+3. Se devuelve el valor de `this`.
 
-In other words, `new User(...)` does something like:
+En otras palabras, `new User(...)` realiza algo como:
 
 ```js
 function User(name) {
 *!*
-  // this = {};  (implicitly)
+  // this = {};  (implícitamente)
 */!*
 
-  // add properties to this
+  // agrega propiedades a this
   this.name = name;
   this.isAdmin = false;
 
 *!*
-  // return this;  (implicitly)
+  // return this;  (implícitamente)
 */!*
 }
 ```
 
-So `let user = new User("Jack")` gives the same result as:
+Entonces `let user = new User("Jack")` da el mismo resultado que:
 
 ```js
 let user = {
@@ -60,148 +60,148 @@ let user = {
 };
 ```
 
-Now if we want to create other users, we can call `new User("Ann")`, `new User("Alice")` and so on. Much shorter than using literals every time, and also easy to read.
+Ahora si queremos crear otros usuarios, podemos llamar a `new User("Ann")`, `new User("Alice")`, etcétera. Mucho más corto que usar literales todo el tiempo y también fácil de leer.
 
-That's the main purpose of constructors -- to implement reusable object creation code.
+Este es el principal propósito del constructor -- implementar código de creación de objetos re-utilizables.
 
-Let's note once again -- technically, any function can be used as a constructor. That is: any function can be run with `new`, and it will execute the algorithm above. The "capital letter first" is a common agreement, to make it clear that a function is to be run with `new`.
+Tomemos nota otra vez -- técnicamente cualquier función puede ser utilizada como constructor. Es decir: cualquier función puede ser ejecutada con `new`, y ejecutará el algoritmo de arriba. La "primera letra mayúscula" es un acuerdo común, para dejar en claro que la función debe ser ejecutada con `new`.
 
 ````smart header="new function() { ... }"
-If we have many lines of code all about creation of a single complex object, we can wrap them in constructor function, like this:
+Si tenemos muchas líneas de código todas sobre la creación de un único objeto complejo, podemos rodearlas en constructor de función, de ésta manera:
 
 ```js
 let user = new function() {
   this.name = "John";
   this.isAdmin = false;
 
-  // ...other code for user creation
-  // maybe complex logic and statements
-  // local variables etc
+  // ...otro código para creación de usuario
+  // tal vez lógica compleja y sentencias
+  // variables locales etc
 };
 ```
 
-The constructor can't be called again, because it is not saved anywhere, just created and called. So this trick aims to encapsulate the code that constructs the single object, without future reuse.
+El constructor no puede ser llamado de nuevo porque no es guardado en ninguna parte, sólo es creado y llamado. Por lo tanto este truco apunta a encapsular el código que construye el objeto individual, sin reutilización futura.
 ````
 
-## Constructor mode test: new.target
+## Constructor modo test: new.target
 
-```smart header="Advanced stuff"
-The syntax from this section is rarely used, skip it unless you want to know everything.
+```smart header="Temas avanzados"
+La sintaxis a partir de esta sección es raramente utilizada, puedes saltearla a menos que quieras saber todo.
 ```
 
-Inside a function, we can check whether it was called with `new` or without it, using a special `new.target` property.
+Dentro de una función, podemos verificar si ha sido llamada con o sin el `new`, utilizando una propiedad especial `new.target`.
 
-It is empty for regular calls and equals the function if called with `new`:
+Está vacía para llamadas normales y es equivalente a la función si es llamada con `new`:
 
 ```js run
 function User() {
   alert(new.target);
 }
 
-// without "new":
+// sin  "new":
 *!*
 User(); // undefined
 */!*
 
-// with "new":
+// con  "new":
 *!*
 new User(); // function User { ... }
 */!*
 ```
 
-That can be used inside the function to know whether it was called with `new`, "in constructor mode", or without it, "in regular mode".
+Esto puede ser utilizado dentro de la función para conocer si ha sido llamada con `new`, "en modo constructor ", o sin él, "en modo regular".
 
-We can also make both `new` and regular calls to do the same, like this:
+También podemos realizar ambas llamadas `new` y regular para que realicen lo mismo, de esta manera:
 
 ```js run
 function User(name) {
-  if (!new.target) { // if you run me without new
-    return new User(name); // ...I will add new for you
+  if (!new.target) { // isi me ejecutas sin new
+    return new User(name); // ...Yo te agrego new por ti
   }
 
   this.name = name;
 }
 
-let john = User("John"); // redirects call to new User
+let john = User("John"); // redirige llamado a new User
 alert(john.name); // John
 ```
 
-This approach is sometimes used in libraries to make the syntax more flexible. So that people may call the function with or without `new`, and it still works.
+Este enfoque es utilizado aveces para hacer el sintaxis más flexible. Para que la gente pueda llamar a la función con o sin `new`, y aun funciona.
 
-Probably not a good thing to use everywhere though, because omitting `new` makes it a bit less obvious what's going on. With `new` we all know that the new object is being created.
+Sin embargo, probablemente no sea algo bueno para usar en todas partes, porque omitir `new` hace que sea un poco menos obvio lo que está sucediendo. Con `new` todos sabemos que se está creando el nuevo objeto.
 
-## Return from constructors
+## Return desde constructores
 
-Usually, constructors do not have a `return` statement. Their task is to write all necessary stuff into `this`, and it automatically becomes the result.
+Normalmente, los constructores no tienen una sentencia `return`. Su tarea es escribir todo lo necesario al `this`, y automáticamente se convierte en el resultado.
 
-But if there is a `return` statement, then the rule is simple:
+Pero si hay una sentencia `return`, entonces la regla es simple:
 
-- If `return` is called with an object, then the object is returned instead of `this`.
-- If `return` is called with a primitive, it's ignored.
+- Si `return` es llamado con un objeto, entonces se devuelve el objeto en vez de `this`.
+- Si `return` es llamado con un tipo de dato primitivo, es ignorado.
 
-In other words, `return` with an object returns that object, in all other cases `this` is returned.
+En otras palabras, `return` con un objeto devuelve ese objeto, en todos los demás casos se devuelve `this`.
 
-For instance, here `return` overrides `this` by returning an object:
+Por ejemplo, aquí `return` anula `this` al devolver un objeto:
 
 ```js run
 function BigUser() {
 
   this.name = "John";
 
-  return { name: "Godzilla" };  // <-- returns this object
+  return { name: "Godzilla" };  // <-- devuelve este objeto
 }
 
-alert( new BigUser().name );  // Godzilla, got that object
+alert( new BigUser().name );  // Godzilla, recibió ese objeto
 ```
 
-And here's an example with an empty `return` (or we could place a primitive after it, doesn't matter):
+Y aquí un ejemplo con un `return` vacío (o podemos colocar un primitivo después de él, no importa):
 
 ```js run
 function SmallUser() {
 
   this.name = "John";
 
-  return; // <-- returns this
+  return; // <-- devuelve this
 }
 
 alert( new SmallUser().name );  // John
 ```
 
-Usually constructors don't have a `return` statement. Here we mention the special behavior with returning objects mainly for the sake of completeness.
+Normalmente los constructores no tienen una sentencia `return`. Aquí mencionamos el comportamiento especial con devolución de objetos principalmente por el bien de la integridad.
 
-````smart header="Omitting parentheses"
-By the way, we can omit parentheses after `new`, if it has no arguments:
+````smart header="Omitir paréntesis"
+Por cierto, podemos omitir paréntesis después de `new`, si no tiene argumentos:
 
 ```js
-let user = new User; // <-- no parentheses
-// same as
+let user = new User; // <-- sin paréntesis
+// lo mismo que
 let user = new User();
 ```
 
-Omitting parentheses here is not considered a "good style", but the syntax is permitted by specification.
+Omitir paréntesis aquí no se considera "buen estilo", pero el sintaxis es permitido por especificación.
 ````
 
-## Methods in constructor
+## Métodos en constructor
 
-Using constructor functions to create objects gives a great deal of flexibility. The constructor function may have parameters that define how to construct the object, and what to put in it.
+Utilizar constructor de funciones para crear objetos nos da mucha flexibilidad. La función constructor puede tener argumentos que definan cómo construir el objeto y qué colocar dentro.
 
-Of course, we can add to `this` not only properties, but methods as well.
+Por supuesto podemos agregar a `this` no sólo propiedades, sino también métodos.
 
-For instance, `new User(name)` below creates an object with the given `name` and the method `sayHi`:
+Por ejemplo, `new User(name)` de abajo, crea un objeto con el `name` dado y el método `sayHi`:
 
 ```js run
 function User(name) {
   this.name = name;
 
   this.sayHi = function() {
-    alert( "My name is: " + this.name );
+    alert( "Mi nombre es: " + this.name );
   };
 }
 
 *!*
 let john = new User("John");
 
-john.sayHi(); // My name is: John
+john.sayHi(); // Mi nombre es: John
 */!*
 
 /*
@@ -212,19 +212,19 @@ john = {
 */
 ```
 
-To create complex objects, there's a more advanced syntax, [classes](info:classes), that we'll cover later.
+Para crear objetos complejos, existe una sintaxis más compleja, [classes](info:classes), que cubriremos más adelante.
 
-## Summary
+## Resumen
 
-- Constructor functions or, briefly, constructors, are regular functions, but there's a common agreement to name them with capital letter first.
-- Constructor functions should only be called using `new`. Such a call implies a creation of empty `this` at the start and returning the populated one at the end.
+- Las funciones Constructoras o, más corto, constructores, son funciones normales, pero existe un común acuerdo para nombrarlas con la primera letra en mayúscula.
+- Las funciones Constructoras sólo deben ser llamadas utilizando `new`. Tal llamado implica la creación de un `this` vacío al comienzo y devolver el `this` rellenado al final.
 
-We can use constructor functions to make multiple similar objects.
+Podemos utilizar funciones constructoras para crear múltiples objetos similares.
 
-JavaScript provides constructor functions for many built-in language objects: like `Date` for dates, `Set` for sets and others that we plan to study.
+JavaScript proporciona funciones constructoras para varios objetos de lenguaje incorporados: como `Date` para fechas, `Set` para sets (conjuntos) y otros que planeamos estudiar.
 
-```smart header="Objects, we'll be back!"
-In this chapter we only cover the basics about objects and constructors. They are essential for learning more about data types and functions in the next chapters.
+```smart header="Objetos, volveremos!"
+En este capítulo solo cubrimos los conceptos básicos sobre objetos y constructores. Son esenciales para aprender más sobre tipos de datos y funciones en los próximos capítulos.
 
-After we learn that, we return to objects and cover them in-depth in the chapters <info:prototypes> and <info:classes>.
+Después de aprender eso, volvemos a los objetos y los cubrimos en profundidad en los capítulos <info:prototypes> y <info:classes>.
 ```

From 9e6442f857724d2cce8044b80b90ab5081409a1a Mon Sep 17 00:00:00 2001
From: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
Date: Sun, 28 Jun 2020 10:24:01 -0300
Subject: [PATCH 02/10] Update
 1-js/04-object-basics/06-constructor-new/2-calculator-constructor/_js.view/test.js
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Carlos Ortiz Gutiérrez <56600925+cortizg@users.noreply.github.com>
---
 .../2-calculator-constructor/_js.view/test.js                 | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/_js.view/test.js b/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/_js.view/test.js
index 465cf40bd..b83a3059c 100644
--- a/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/_js.view/test.js
+++ b/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/_js.view/test.js
@@ -15,11 +15,11 @@ describe("calculator", function() {
     assert.equal(calculator.sum(), 5);
   });
 
-  it("cuandose ingresa 2 y 3, el producto es 6", function() {
+  it("cuando se ingresa 2 y 3, el producto es 6", function() {
     assert.equal(calculator.mul(), 6);
   });
 
   after(function() {
     prompt.restore();
   });
-});
\ No newline at end of file
+});

From e7d5068d0e2c3028ff386fc7deb218e0271a9696 Mon Sep 17 00:00:00 2001
From: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
Date: Sun, 28 Jun 2020 10:25:57 -0300
Subject: [PATCH 03/10] Update
 1-js/04-object-basics/06-constructor-new/article.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Carlos Ortiz Gutiérrez <56600925+cortizg@users.noreply.github.com>
---
 1-js/04-object-basics/06-constructor-new/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/04-object-basics/06-constructor-new/article.md b/1-js/04-object-basics/06-constructor-new/article.md
index 1d50780d7..18edd5b69 100644
--- a/1-js/04-object-basics/06-constructor-new/article.md
+++ b/1-js/04-object-basics/06-constructor-new/article.md
@@ -86,7 +86,7 @@ El constructor no puede ser llamado de nuevo porque no es guardado en ninguna pa
 ## Constructor modo test: new.target
 
 ```smart header="Temas avanzados"
-La sintaxis a partir de esta sección es raramente utilizada, puedes saltearla a menos que quieras saber todo.
+La sintaxis a partir de esta sección es raramente utilizada, puedes omitirla a menos que quieras saber todo.
 ```
 
 Dentro de una función, podemos verificar si ha sido llamada con o sin el `new`, utilizando una propiedad especial `new.target`.

From 993dea0c7abcfe8f526178e21c1d6a5e10d9229c Mon Sep 17 00:00:00 2001
From: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
Date: Sun, 28 Jun 2020 10:26:57 -0300
Subject: [PATCH 04/10] Update
 1-js/04-object-basics/06-constructor-new/article.md

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

diff --git a/1-js/04-object-basics/06-constructor-new/article.md b/1-js/04-object-basics/06-constructor-new/article.md
index 18edd5b69..358b92f9c 100644
--- a/1-js/04-object-basics/06-constructor-new/article.md
+++ b/1-js/04-object-basics/06-constructor-new/article.md
@@ -67,7 +67,7 @@ Este es el principal propósito del constructor -- implementar código de creaci
 Tomemos nota otra vez -- técnicamente cualquier función puede ser utilizada como constructor. Es decir: cualquier función puede ser ejecutada con `new`, y ejecutará el algoritmo de arriba. La "primera letra mayúscula" es un acuerdo común, para dejar en claro que la función debe ser ejecutada con `new`.
 
 ````smart header="new function() { ... }"
-Si tenemos muchas líneas de código todas sobre la creación de un único objeto complejo, podemos rodearlas en constructor de función, de ésta manera:
+Si tenemos muchas líneas de código todas sobre la creación de un único objeto complejo, podemos agruparlas en un constructor de función, de ésta manera:
 
 ```js
 let user = new function() {

From 381668b93bcc71c8786894eba53149721dfbc200 Mon Sep 17 00:00:00 2001
From: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
Date: Sun, 28 Jun 2020 10:27:24 -0300
Subject: [PATCH 05/10] Update
 1-js/04-object-basics/06-constructor-new/article.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Carlos Ortiz Gutiérrez <56600925+cortizg@users.noreply.github.com>
---
 1-js/04-object-basics/06-constructor-new/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/04-object-basics/06-constructor-new/article.md b/1-js/04-object-basics/06-constructor-new/article.md
index 358b92f9c..5e66a3b91 100644
--- a/1-js/04-object-basics/06-constructor-new/article.md
+++ b/1-js/04-object-basics/06-constructor-new/article.md
@@ -115,7 +115,7 @@ También podemos realizar ambas llamadas `new` y regular para que realicen lo mi
 
 ```js run
 function User(name) {
-  if (!new.target) { // isi me ejecutas sin new
+  if (!new.target) { // si me ejecutas sin new
     return new User(name); // ...Yo te agrego new por ti
   }
 

From 0e4a7c74878a5ae97009b6edabaca0ce61897e0a Mon Sep 17 00:00:00 2001
From: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
Date: Sun, 28 Jun 2020 10:27:43 -0300
Subject: [PATCH 06/10] Update
 1-js/04-object-basics/06-constructor-new/article.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Carlos Ortiz Gutiérrez <56600925+cortizg@users.noreply.github.com>
---
 1-js/04-object-basics/06-constructor-new/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/04-object-basics/06-constructor-new/article.md b/1-js/04-object-basics/06-constructor-new/article.md
index 5e66a3b91..1898f5577 100644
--- a/1-js/04-object-basics/06-constructor-new/article.md
+++ b/1-js/04-object-basics/06-constructor-new/article.md
@@ -116,7 +116,7 @@ También podemos realizar ambas llamadas `new` y regular para que realicen lo mi
 ```js run
 function User(name) {
   if (!new.target) { // si me ejecutas sin new
-    return new User(name); // ...Yo te agrego new por ti
+    return new User(name); // ...Agregaré new por ti
   }
 
   this.name = name;

From 619b0cbed88112e4fb1a26a8c07b93b3fb7f3771 Mon Sep 17 00:00:00 2001
From: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
Date: Sun, 28 Jun 2020 10:31:21 -0300
Subject: [PATCH 07/10] Update
 1-js/04-object-basics/06-constructor-new/article.md

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

diff --git a/1-js/04-object-basics/06-constructor-new/article.md b/1-js/04-object-basics/06-constructor-new/article.md
index 1898f5577..bf140a3b1 100644
--- a/1-js/04-object-basics/06-constructor-new/article.md
+++ b/1-js/04-object-basics/06-constructor-new/article.md
@@ -126,7 +126,7 @@ let john = User("John"); // redirige llamado a new User
 alert(john.name); // John
 ```
 
-Este enfoque es utilizado aveces para hacer el sintaxis más flexible. Para que la gente pueda llamar a la función con o sin `new`, y aun funciona.
+Este enfoque es utilizado aveces en las librerías para hacer el sintaxis más flexible. Para que la gente pueda llamar a la función con o sin `new`, y aun funciona.
 
 Sin embargo, probablemente no sea algo bueno para usar en todas partes, porque omitir `new` hace que sea un poco menos obvio lo que está sucediendo. Con `new` todos sabemos que se está creando el nuevo objeto.
 

From 23c506a9fbe2a8a82edb7a7fcbb66e4e8ef60d3f Mon Sep 17 00:00:00 2001
From: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
Date: Sun, 28 Jun 2020 10:31:51 -0300
Subject: [PATCH 08/10] Update
 1-js/04-object-basics/06-constructor-new/3-accumulator/task.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Carlos Ortiz Gutiérrez <56600925+cortizg@users.noreply.github.com>
---
 1-js/04-object-basics/06-constructor-new/3-accumulator/task.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/04-object-basics/06-constructor-new/3-accumulator/task.md b/1-js/04-object-basics/06-constructor-new/3-accumulator/task.md
index 7c11be7dc..6607ddaff 100644
--- a/1-js/04-object-basics/06-constructor-new/3-accumulator/task.md
+++ b/1-js/04-object-basics/06-constructor-new/3-accumulator/task.md
@@ -9,7 +9,7 @@ Crear una función contructor `Accumulator(valorInicial)`.
 El objeto que crea debería:
 
 - Almacene el "valor actual" en la propiedad `value`. El valor inicial se establece en el argumento del constructor `valorInicial`.
-- El método `read()` debe usar `prompt` para leer un nuevo número y agregarlo a` value`.
+- El método `read()` debe usar `prompt` para leer un nuevo número y agregarlo a `value`.
 
 En otras palabras, la propiedad `value` es la suma de todos los valores ingresados por el usuario con el valor inicial `startingValue`.
 

From 3d556ea446a035d9fa98d7cee402da46215ded82 Mon Sep 17 00:00:00 2001
From: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
Date: Sun, 28 Jun 2020 10:34:22 -0300
Subject: [PATCH 09/10] Update
 1-js/04-object-basics/06-constructor-new/3-accumulator/task.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Carlos Ortiz Gutiérrez <56600925+cortizg@users.noreply.github.com>
---
 1-js/04-object-basics/06-constructor-new/3-accumulator/task.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/04-object-basics/06-constructor-new/3-accumulator/task.md b/1-js/04-object-basics/06-constructor-new/3-accumulator/task.md
index 6607ddaff..d76e20622 100644
--- a/1-js/04-object-basics/06-constructor-new/3-accumulator/task.md
+++ b/1-js/04-object-basics/06-constructor-new/3-accumulator/task.md
@@ -4,7 +4,7 @@ importance: 5
 
 # Crear nuevo Acumulador
 
-Crear una función contructor `Accumulator(valorInicial)`.
+Crear una función contructor `Accumulator(startingValue)`.
 
 El objeto que crea debería:
 

From a6dbf35cd1a363fb2fe657a3286b6c9b52619092 Mon Sep 17 00:00:00 2001
From: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com>
Date: Sun, 28 Jun 2020 10:34:40 -0300
Subject: [PATCH 10/10] Update
 1-js/04-object-basics/06-constructor-new/3-accumulator/task.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Carlos Ortiz Gutiérrez <56600925+cortizg@users.noreply.github.com>
---
 1-js/04-object-basics/06-constructor-new/3-accumulator/task.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/04-object-basics/06-constructor-new/3-accumulator/task.md b/1-js/04-object-basics/06-constructor-new/3-accumulator/task.md
index d76e20622..6046490a3 100644
--- a/1-js/04-object-basics/06-constructor-new/3-accumulator/task.md
+++ b/1-js/04-object-basics/06-constructor-new/3-accumulator/task.md
@@ -8,7 +8,7 @@ Crear una función contructor `Accumulator(startingValue)`.
 
 El objeto que crea debería:
 
-- Almacene el "valor actual" en la propiedad `value`. El valor inicial se establece en el argumento del constructor `valorInicial`.
+- Almacene el "valor actual" en la propiedad `value`. El valor inicial se establece en el argumento del constructor `startingValue`.
 - El método `read()` debe usar `prompt` para leer un nuevo número y agregarlo a `value`.
 
 En otras palabras, la propiedad `value` es la suma de todos los valores ingresados por el usuario con el valor inicial `startingValue`.