From 0e5b7e476c0bbb0e052b9c018b2c2bccc383bf9b Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Wed, 22 Jul 2020 01:53:46 -0300
Subject: [PATCH 01/28] The old "var"

---
 1-js/06-advanced-functions/04-var/article.md | 167 ++++++++++---------
 1 file changed, 89 insertions(+), 78 deletions(-)

diff --git a/1-js/06-advanced-functions/04-var/article.md b/1-js/06-advanced-functions/04-var/article.md
index 2a9dbc636..8f7559e15 100644
--- a/1-js/06-advanced-functions/04-var/article.md
+++ b/1-js/06-advanced-functions/04-var/article.md
@@ -1,71 +1,62 @@
 
-# The old "var"
+# La vieja "var"
 
-```smart header="This article is for understanding old scripts"
-The information in this article is useful for understanding old scripts.
+```smart header="Este artículo es para entender el código viejo"
+La información en este artículo es útil para entender el código viejo.
 
-That's not how we write a new code.
+No es como escribimos código nuevo.
 ```
 
-In the very first chapter about [variables](info:variables), we mentioned three ways of variable declaration:
+En el primer capítulo acerca de [variables](info:variables), mencionamos tres formas de declarar una variable:
 
 1. `let`
 2. `const`
 3. `var`
 
-`let` and `const` behave exactly the same way in terms of Lexical Environments.
-
-But `var` is a very different beast, that originates from very old times. It's generally not used in modern scripts, but still lurks in the old ones.
-
-If you don't plan on meeting such scripts you may even skip this chapter or postpone it, but then there's a chance that it bites you later.
-
-From the first sight, `var` behaves similar to `let`. That is, declares a variable:
+La declaración `var` es similar a `let`. La mayoría de las veces podemos reemplazar `let` por `var` o viceversa y esperar que las cosas funcionen: 
 
 ```js run
-function sayHi() {
-  var phrase = "Hello"; // local variable, "var" instead of "let"
-
-  alert(phrase); // Hello
-}
+var message = "Hola";
+alert(message); // Hola
+```
 
-sayHi();
+Pero internamente `var` es un animal diferente, originario de muy viejas épocas. Generalmente no es usado en código moderno, pero aún habita en el viejo.
 
-alert(phrase); // Error, phrase is not defined
-```
+Si no planeas encontrarte con tal código bien puedes saltear este capítulo o posponerlo, pero chances hay de que pueda morderte más tarde.
 
-...But here are the differences.
+Por otro lado, es importante entender las diferencias cuando se migra viejo código de `var` a `let` para evitar extraños errores.
 
-## "var" has no block scope
+# "var" no tiene visibilidad de bloque.
 
-Variables, declared with `var`, are either function-wide or global. They are visible through blocks.
+Las variables declaradas con `var` tienen como entorno de visibilidad la función o bien son globales. Su visibilidad atraviesa los bloques.
 
-For instance:
+Por ejemplo:
 
 ```js run
 if (true) {
-  var test = true; // use "var" instead of "let"
+  var test = true; // uso de "var" en lugar de "let"
 }
 
 *!*
-alert(test); // true, the variable lives after if
+alert(test); // true, la variable vive después del if
 */!*
 ```
 
-As `var` ignores code blocks, we've got a global variable `test`.
+Como `var` ignora los bloques de código, tenemos una variable global `test`.  
 
-If we used `let test` instead of `var test`, then the variable would only be visible inside `if`:
+Si usáramos `let test` en vez de `var test`, la variable sería visible solamente dentro del `if`:
 
 ```js run
 if (true) {
-  let test = true; // use "let"
+  let test = true; // uso de "let"
 }
 
 *!*
-alert(test); // Error: test is not defined
+alert(test); // Error: test no está definido
 */!*
 ```
 
-The same thing for loops: `var` cannot be block- or loop-local:
+Lo mismo para los bucles: `var` no puede ser local en los bloques ni en los bucles:
 
 ```js
 for (var i = 0; i < 10; i++) {
@@ -73,11 +64,11 @@ for (var i = 0; i < 10; i++) {
 }
 
 *!*
-alert(i); // 10, "i" is visible after loop, it's a global variable
+alert(i); // 10, "i" es visible después del bucle, es una variable global
 */!*
 ```
 
-If a code block is inside a function, then `var` becomes a function-level variable:
+Si un bloque de código está dentro de una función, `var` se vuelve una variable a nivel de función:
 
 ```js run
 function sayHi() {
@@ -85,22 +76,42 @@ function sayHi() {
     var phrase = "Hello";
   }
 
-  alert(phrase); // works
+  alert(phrase); // funciona
 }
 
 sayHi();
-alert(phrase); // Error: phrase is not defined (Check the Developer Console)
+alert(phrase); // Error: phrase no está definida (Revise consola de desarrollador)
+```
+
+Como podemos ver, `var` atraviesa `if`, `for` u otros bloques. Esto es porque mucho tiempo atrás los bloques en JavaScript no tenían ambientes léxicos. Y `var` es un remanente de aquello.
+
+## "var" tolera redeclaraciones
+
+Declarar la misma variable con `let` dos veces en el mismo entorno es un error:
+
+```js run
+let user;
+let user; // SyntaxError: 'user' ya fue declarado
 ```
 
-As we can see, `var` pierces through `if`, `for` or other code blocks. That's because a long time ago in JavaScript blocks had no Lexical Environments. And `var` is a remnant of that.
+Con `var` podemos redeclarar una variable muchas veces. Si usamos `var` con una variable ya declarada, simplemente se ignora:
+
+```js run
+var user = "Pete";
+
+var user = "John"; // este "var" no hace nada (ya estaba declarado)
+// ...no dispara ningún error
+
+alert(user); // John
+```
 
-## "var" declarations are processed at the function start
+## Las variables "var" pueden ser declaradas debajo de su uso
 
-`var` declarations are processed when the function starts (or script starts for globals).
+Las declaraciones `var` son procesadas cuando se inicia la función (o se inicia el script para las globales).
 
-In other words, `var` variables are defined from the beginning of the function, no matter where the definition is (assuming that the definition is not in the nested function).
+En otras palabras, las variables `var` son definidas desde el inicio de la función, no importa dónde tal definición está (asumiendo que la definición no está en una función anidada).
 
-So this code:
+Entonces el código:
 
 ```js run
 function sayHi() {
@@ -115,7 +126,7 @@ function sayHi() {
 sayHi();
 ```
 
-...Is technically the same as this (moved `var phrase` above):
+...es técnicamente lo mismo que esto (se movió `var phrase` hacia arriba):
 
 ```js run
 function sayHi() {
@@ -130,7 +141,7 @@ function sayHi() {
 sayHi();
 ```
 
-...Or even as this (remember, code blocks are ignored):
+...O incluso esto (recuerda, los códigos de bloque son ignorados):
 
 ```js run
 function sayHi() {
@@ -147,13 +158,13 @@ function sayHi() {
 sayHi();
 ```
 
-People also call such behavior "hoisting" (raising), because all `var` are "hoisted" (raised) to the top of the function.
+Este comportamiento también se llama "hoisting" (elevamiento), porque todos los `var` son "hoisted" (elevados) hacia el tope de la función.
 
-So in the example above, `if (false)` branch never executes, but that doesn't matter. The `var` inside it is processed in the beginning of the function, so at the moment of `(*)` the variable exists.
+Entonces, en el ejemplo anterior, la rama `if (false)` nunca se ejecuta pero eso no tiene importancia. El `var` dentro es procesado al al iniciar la función, entonces al momento de `(*)` la variable existe.
 
-**Declarations are hoisted, but assignments are not.**
+**Las declaraciones son "hoisted", pero las asignaciones no lo son.**
 
-That's best demonstrated with an example:
+Es mejor demostrarlo con un ejemplo:
 
 ```js run
 function sayHi() {
@@ -167,40 +178,40 @@ function sayHi() {
 sayHi();
 ```
 
-The line `var phrase = "Hello"` has two actions in it:
+La línea `var phrase = "Hello"` tiene dentro dos acciones:
 
-1. Variable declaration `var`
-2. Variable assignment `=`.
+1. La declaración `var`
+2. La asignación `=`.
 
-The declaration is processed at the start of function execution ("hoisted"), but the assignment always works at the place where it appears. So the code works essentially like this:
+La declaración es procesada al inicio de la ejecución de la función ("hoisted"), pero la asignación siempre se hace en el lugar donde aparece. Entonces lo que en escencia hace el código es:
 
 ```js run
 function sayHi() {
 *!*
-  var phrase; // declaration works at the start...
+  var phrase; // la declaración se hace en el inicio...
 */!*
 
   alert(phrase); // undefined
 
 *!*
-  phrase = "Hello"; // ...assignment - when the execution reaches it.
+  phrase = "Hello"; // ...asignación - cuando la ejecución la alcanza.
 */!*
 }
 
 sayHi();
 ```
 
-Because all `var` declarations are processed at the function start, we can reference them at any place. But variables are undefined until the assignments.
+Como todas las declaraciones `var` son procesadas al inicio de la función, podemos referenciarlas en cualquier lugar. Pero las variables serán indefinidas hasta que alcancen su asignación.
 
-In both examples above `alert` runs without an error, because the variable `phrase` exists. But its value is not yet assigned, so it shows `undefined`.
+En ambos ejemplos de arriba `alert` ejecuta sin un error, porque la variable `phrase` existe. Pero su valor no fue asignado aún, entonces muestra `undefined`.
 
 ### IIFE
 
-As in the past there was only `var`, and it has no block-level visibility, programmers invented a way to emulate it. What they did was called "immediately-invoked function expressions" (abbreviated as IIFE).
+Como en el pasado solo existía `var`, y no había visibilidad a nivel de bloque, los programadores inventaronuna manera de emularla. Lo que hicieron fue el llamado "expresiones de función inmediatamente invocadas (abreviado IIFE en inglés).
 
-That's not something we should use nowadays, but you can find them in old scripts.
+No es algo que debiéramos usar estos días, pero puedes encontrarlas en viejo código.
 
-An IIFE looks like this:
+Un IIFE se ve así:
 
 ```js run
 (function() {
@@ -212,13 +223,13 @@ An IIFE looks like this:
 })();
 ```
 
-Here a Function Expression is created and immediately called. So the code executes right away and has its own private variables.
+Aquí la expresión de función es creada e inmediatamente llamada. Entonces el código se ejecuta enseguida y con sus variables privadas propias.
 
-The Function Expression is wrapped with parenthesis `(function {...})`, because when JavaScript meets `"function"` in the main code flow, it understands it as the start of a Function Declaration. But a Function Declaration must have a name, so this kind of code will give an error:
+La expresión de función es encerrada en paréntesis `(function {...})`, porque cuando JavaScript se encuentra con `"function"` en el flujo de código principal lo entiende como el principio de una declaración de función. Pero una declaración de función debe tener un nombre, entonces ese código daría error:
 
 ```js run
-// Try to declare and immediately call a function
-function() { // <-- Error: Function statements require a function name
+// Trata de declarar e inmediatamente llamar una función
+function() { // <-- Error: la intrucción de función requiere un nombre de función
 
   let message = "Hello";
 
@@ -227,48 +238,48 @@ function() { // <-- Error: Function statements require a function name
 }();
 ```
 
-Even if we say: "okay, let's add a name", that won't work, as JavaScript does not allow Function Declarations to be called immediately:
+Incluso si decimos: "okay, agreguémosle un nombre", no funcionaría, porque JavaScript no permite que las declaraciones de función sean llamadas inmediatamente:
 
 ```js run
-// syntax error because of parentheses below
+// error de sintaxis por causa de los paréntesis debajo
 function go() {
 
-}(); // <-- can't call Function Declaration immediately
+}(); // <-- no puede llamarse una declaración de función inmediatamente 
 ```
 
-So, the parentheses around the function is a trick to show JavaScript that the function is created in the context of another expression, and hence it's a Function Expression: it needs no name and can be called immediately.
+Entonces, los paréntesis alrededor de la funciónen es un truco para mostrarle a JavaScript que la función es creada en el contexto de otra expresión, y de allí lo de "expresión de función": no necesita un nombre y puede ser llamada inmediatamente.
 
-There exist other ways besides parentheses to tell JavaScript that we mean a Function Expression:
+Existen otra maneras de además de los paréntesis para decirle a JavaScript que queremos un expresión de función:
 
 ```js run
-// Ways to create IIFE
+// Formas de crear IIFE
 
 (function() {
-  alert("Parentheses around the function");
+  alert("Paréntesis alrededor de la función");
 }*!*)*/!*();
 
 (function() {
-  alert("Parentheses around the whole thing");
+  alert("Paréntesis alrededor de todo");
 }()*!*)*/!*;
 
 *!*!*/!*function() {
-  alert("Bitwise NOT operator starts the expression");
+  alert("Operador 'Bitwise NOT' como comienzo de la expresión");
 }();
 
 *!*+*/!*function() {
-  alert("Unary plus starts the expression");
+  alert("'más unario' como comienzo de la expresión");
 }();
 ```
 
-In all the above cases we declare a Function Expression and run it immediately. Let's note again: nowadays there's no reason to write such code.
+En todos los casos de arriba declaramos una expresión de función y la ejecutamos inmediatamente. Tomemos nota de nuevo: Ahora no hay motivo para escribir semejante código.
 
-## Summary
+## Resumen
 
-There are two main differences of `var` compared to `let/const`:
+Hay dos diferencias principales entre `var` y `let/const`:
 
-1. `var` variables have no block scope, they are visible minimum at the function level.
-2. `var` declarations are processed at function start (script start for globals).
+1. Las variables `var` no tienen visibilidad de bloque, su mínimo de visibilidad es a nivel de función.
+2. Las declaraciones `var` son procesadas al inicio de la función (o del script para las globales) .
 
-There's one more very minor difference related to the global object, that we'll cover in the next chapter.
+Hay otra diferencia menor relacionada al objeto global que cubriremos en el siguiente capítulo.
 
-These differences make `var` worse than `let` most of the time. Block-level variables is such a great thing. That's why `let` was introduced in the standard long ago, and is now a major way (along with `const`) to declare a variable.
+Estas diferencias hacen a `var` peor que `let` la mayoría de las veces. Las variables a nivel de bloque son una muy buena cosa. Es por ello que `let` fue presentado en el estándar mucho tiempo atrás, y es ahora la forma principal (junto con `const`) de declarar una variable.

From c5533f615414801c9ed8ac7cd922a40608692891 Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Wed, 22 Jul 2020 02:14:31 -0300
Subject: [PATCH 02/28] esencia ortograf

---
 1-js/06-advanced-functions/04-var/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/06-advanced-functions/04-var/article.md b/1-js/06-advanced-functions/04-var/article.md
index 8f7559e15..9266c4718 100644
--- a/1-js/06-advanced-functions/04-var/article.md
+++ b/1-js/06-advanced-functions/04-var/article.md
@@ -183,7 +183,7 @@ La línea `var phrase = "Hello"` tiene dentro dos acciones:
 1. La declaración `var`
 2. La asignación `=`.
 
-La declaración es procesada al inicio de la ejecución de la función ("hoisted"), pero la asignación siempre se hace en el lugar donde aparece. Entonces lo que en escencia hace el código es:
+La declaración es procesada al inicio de la ejecución de la función ("hoisted"), pero la asignación siempre se hace en el lugar donde aparece. Entonces lo que en esencia hace el código es:
 
 ```js run
 function sayHi() {

From c346db9da29fd72461b1682261511711fa44d716 Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Wed, 22 Jul 2020 02:16:43 -0300
Subject: [PATCH 03/28] sep palabras

---
 1-js/06-advanced-functions/04-var/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/06-advanced-functions/04-var/article.md b/1-js/06-advanced-functions/04-var/article.md
index 9266c4718..94de37c82 100644
--- a/1-js/06-advanced-functions/04-var/article.md
+++ b/1-js/06-advanced-functions/04-var/article.md
@@ -207,7 +207,7 @@ En ambos ejemplos de arriba `alert` ejecuta sin un error, porque la variable `ph
 
 ### IIFE
 
-Como en el pasado solo existía `var`, y no había visibilidad a nivel de bloque, los programadores inventaronuna manera de emularla. Lo que hicieron fue el llamado "expresiones de función inmediatamente invocadas (abreviado IIFE en inglés).
+Como en el pasado solo existía `var`, y no había visibilidad a nivel de bloque, los programadores inventaron una manera de emularla. Lo que hicieron fue el llamado "expresiones de función inmediatamente invocadas (abreviado IIFE en inglés).
 
 No es algo que debiéramos usar estos días, pero puedes encontrarlas en viejo código.
 

From 5419f98c63ccec6d4bdad386aff41dbef8296752 Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Wed, 22 Jul 2020 02:19:44 -0300
Subject: [PATCH 04/28] ortogr 3

---
 1-js/06-advanced-functions/04-var/article.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/1-js/06-advanced-functions/04-var/article.md b/1-js/06-advanced-functions/04-var/article.md
index 94de37c82..92b145949 100644
--- a/1-js/06-advanced-functions/04-var/article.md
+++ b/1-js/06-advanced-functions/04-var/article.md
@@ -225,7 +225,7 @@ Un IIFE se ve así:
 
 Aquí la expresión de función es creada e inmediatamente llamada. Entonces el código se ejecuta enseguida y con sus variables privadas propias.
 
-La expresión de función es encerrada en paréntesis `(function {...})`, porque cuando JavaScript se encuentra con `"function"` en el flujo de código principal lo entiende como el principio de una declaración de función. Pero una declaración de función debe tener un nombre, entonces ese código daría error:
+La expresión de función es encerrada entre paréntesis `(function {...})`, porque cuando JavaScript se encuentra con `"function"` en el flujo de código principal lo entiende como el principio de una declaración de función. Pero una declaración de función debe tener un nombre, entonces ese código daría error:
 
 ```js run
 // Trata de declarar e inmediatamente llamar una función
@@ -247,7 +247,7 @@ function go() {
 }(); // <-- no puede llamarse una declaración de función inmediatamente 
 ```
 
-Entonces, los paréntesis alrededor de la funciónen es un truco para mostrarle a JavaScript que la función es creada en el contexto de otra expresión, y de allí lo de "expresión de función": no necesita un nombre y puede ser llamada inmediatamente.
+Entonces, los paréntesis alrededor de la función es un truco para mostrarle a JavaScript que la función es creada en el contexto de otra expresión, y de allí lo de "expresión de función", que no necesita un nombre y puede ser llamada inmediatamente.
 
 Existen otra maneras de además de los paréntesis para decirle a JavaScript que queremos un expresión de función:
 

From 91a73049ddcc6ed7912f381a21adc91ca0495ae5 Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Wed, 22 Jul 2020 02:21:39 -0300
Subject: [PATCH 05/28] ortogr 4

---
 1-js/06-advanced-functions/04-var/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/06-advanced-functions/04-var/article.md b/1-js/06-advanced-functions/04-var/article.md
index 92b145949..6990eeb50 100644
--- a/1-js/06-advanced-functions/04-var/article.md
+++ b/1-js/06-advanced-functions/04-var/article.md
@@ -249,7 +249,7 @@ function go() {
 
 Entonces, los paréntesis alrededor de la función es un truco para mostrarle a JavaScript que la función es creada en el contexto de otra expresión, y de allí lo de "expresión de función", que no necesita un nombre y puede ser llamada inmediatamente.
 
-Existen otra maneras de además de los paréntesis para decirle a JavaScript que queremos un expresión de función:
+Existen otras maneras además de los paréntesis para decirle a JavaScript que queremos un expresión de función:
 
 ```js run
 // Formas de crear IIFE

From b7ad4686648d35b6d7d009aef764cdbe21a8ea91 Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Fri, 24 Jul 2020 23:31:27 -0300
Subject: [PATCH 06/28] Update 1-js/06-advanced-functions/04-var/article.md

Co-authored-by: Valentina VP <34555644+vplentinax@users.noreply.github.com>
---
 1-js/06-advanced-functions/04-var/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/06-advanced-functions/04-var/article.md b/1-js/06-advanced-functions/04-var/article.md
index 6990eeb50..a20641789 100644
--- a/1-js/06-advanced-functions/04-var/article.md
+++ b/1-js/06-advanced-functions/04-var/article.md
@@ -1,7 +1,7 @@
 
 # La vieja "var"
 
-```smart header="Este artículo es para entender el código viejo"
+```smart header="Este artículo es para entender el código antiguo"
 La información en este artículo es útil para entender el código viejo.
 
 No es como escribimos código nuevo.

From d87f75372e7fd79c3544130c79d7e1bccaf56a19 Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Fri, 24 Jul 2020 23:32:02 -0300
Subject: [PATCH 07/28] Update 1-js/06-advanced-functions/04-var/article.md

Co-authored-by: Valentina VP <34555644+vplentinax@users.noreply.github.com>
---
 1-js/06-advanced-functions/04-var/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/06-advanced-functions/04-var/article.md b/1-js/06-advanced-functions/04-var/article.md
index a20641789..2b2306b18 100644
--- a/1-js/06-advanced-functions/04-var/article.md
+++ b/1-js/06-advanced-functions/04-var/article.md
@@ -2,7 +2,7 @@
 # La vieja "var"
 
 ```smart header="Este artículo es para entender el código antiguo"
-La información en este artículo es útil para entender el código viejo.
+La información en este artículo es útil para entender el código antiguo.
 
 No es como escribimos código nuevo.
 ```

From ef691eb5470c273c00b3c24fffe4858a2a25fe8c Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Fri, 24 Jul 2020 23:34:07 -0300
Subject: [PATCH 08/28] Update 1-js/06-advanced-functions/04-var/article.md

Co-authored-by: Valentina VP <34555644+vplentinax@users.noreply.github.com>
---
 1-js/06-advanced-functions/04-var/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/06-advanced-functions/04-var/article.md b/1-js/06-advanced-functions/04-var/article.md
index 2b2306b18..19c0e0f05 100644
--- a/1-js/06-advanced-functions/04-var/article.md
+++ b/1-js/06-advanced-functions/04-var/article.md
@@ -4,7 +4,7 @@
 ```smart header="Este artículo es para entender el código antiguo"
 La información en este artículo es útil para entender el código antiguo.
 
-No es como escribimos código nuevo.
+Así no es como escribimos código moderno.
 ```
 
 En el primer capítulo acerca de [variables](info:variables), mencionamos tres formas de declarar una variable:

From 924e9cb63df8b63857ad24a2270fc23b6da9f807 Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Fri, 24 Jul 2020 23:37:40 -0300
Subject: [PATCH 09/28] Update 1-js/06-advanced-functions/04-var/article.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Tuve que penarlo un poco...
No está nada mal "alcance"

Co-authored-by: Valentina VP <34555644+vplentinax@users.noreply.github.com>
---
 1-js/06-advanced-functions/04-var/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/06-advanced-functions/04-var/article.md b/1-js/06-advanced-functions/04-var/article.md
index 19c0e0f05..ac1b2c804 100644
--- a/1-js/06-advanced-functions/04-var/article.md
+++ b/1-js/06-advanced-functions/04-var/article.md
@@ -277,7 +277,7 @@ En todos los casos de arriba declaramos una expresión de función y la ejecutam
 
 Hay dos diferencias principales entre `var` y `let/const`:
 
-1. Las variables `var` no tienen visibilidad de bloque, su mínimo de visibilidad es a nivel de función.
+1. Las variables `var` no tienen alcance de bloque, su mínimo de alcance es a nivel de función.
 2. Las declaraciones `var` son procesadas al inicio de la función (o del script para las globales) .
 
 Hay otra diferencia menor relacionada al objeto global que cubriremos en el siguiente capítulo.

From dee39a757cfd2331a6428473f092b40e669250c6 Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Fri, 24 Jul 2020 23:41:03 -0300
Subject: [PATCH 10/28] Update 1-js/06-advanced-functions/04-var/article.md

De acuerdo, no me gusto cdo lo escribi.  No es lo que dice el original sino mejor.
Tamb voy a cambiar "mayoria" suena ffeo

Co-authored-by: Valentina VP <34555644+vplentinax@users.noreply.github.com>
---
 1-js/06-advanced-functions/04-var/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/06-advanced-functions/04-var/article.md b/1-js/06-advanced-functions/04-var/article.md
index ac1b2c804..c0e53dc6d 100644
--- a/1-js/06-advanced-functions/04-var/article.md
+++ b/1-js/06-advanced-functions/04-var/article.md
@@ -282,4 +282,4 @@ Hay dos diferencias principales entre `var` y `let/const`:
 
 Hay otra diferencia menor relacionada al objeto global que cubriremos en el siguiente capítulo.
 
-Estas diferencias hacen a `var` peor que `let` la mayoría de las veces. Las variables a nivel de bloque son una muy buena cosa. Es por ello que `let` fue presentado en el estándar mucho tiempo atrás, y es ahora la forma principal (junto con `const`) de declarar una variable.
+Estas diferencias hacen a `var` peor que `let` la mayoría de las veces. Las variables a nivel de bloque son mejores. Es por ello que `let` fue presentado en el estándar mucho tiempo atrás, y es ahora la forma principal (junto con `const`) de declarar una variable.

From d758e119a41fbf79da976c11d7ecb1f9f9221576 Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Fri, 24 Jul 2020 23:42:25 -0300
Subject: [PATCH 11/28] Update 1-js/06-advanced-functions/04-var/article.md

Co-authored-by: Valentina VP <34555644+vplentinax@users.noreply.github.com>
---
 1-js/06-advanced-functions/04-var/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/06-advanced-functions/04-var/article.md b/1-js/06-advanced-functions/04-var/article.md
index c0e53dc6d..87b005b13 100644
--- a/1-js/06-advanced-functions/04-var/article.md
+++ b/1-js/06-advanced-functions/04-var/article.md
@@ -26,7 +26,7 @@ Si no planeas encontrarte con tal código bien puedes saltear este capítulo o p
 
 Por otro lado, es importante entender las diferencias cuando se migra viejo código de `var` a `let` para evitar extraños errores.
 
-# "var" no tiene visibilidad de bloque.
+# "var" no tiene alcance(visibilidad) de bloque.
 
 Las variables declaradas con `var` tienen como entorno de visibilidad la función o bien son globales. Su visibilidad atraviesa los bloques.
 

From 3a9f23b027d9a7b920c011744dd4dfbde7d07aab Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Fri, 24 Jul 2020 23:44:03 -0300
Subject: [PATCH 12/28] Update 1-js/06-advanced-functions/04-var/article.md

mas animal que bestia, "soy animal de ciudad"..
me da igual, hecho.

Co-authored-by: Valentina VP <34555644+vplentinax@users.noreply.github.com>
---
 1-js/06-advanced-functions/04-var/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/06-advanced-functions/04-var/article.md b/1-js/06-advanced-functions/04-var/article.md
index 87b005b13..04563da00 100644
--- a/1-js/06-advanced-functions/04-var/article.md
+++ b/1-js/06-advanced-functions/04-var/article.md
@@ -20,7 +20,7 @@ var message = "Hola";
 alert(message); // Hola
 ```
 
-Pero internamente `var` es un animal diferente, originario de muy viejas épocas. Generalmente no es usado en código moderno, pero aún habita en el viejo.
+Pero internamente `var` es una bestia diferente, originaria de muy viejas épocas. Generalmente no es usado en código moderno, pero aún habita en el antiguo.
 
 Si no planeas encontrarte con tal código bien puedes saltear este capítulo o posponerlo, pero chances hay de que pueda morderte más tarde.
 

From e02c4f6a8ab8705858531ba74e32ad1a28ab36a8 Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Fri, 24 Jul 2020 23:47:26 -0300
Subject: [PATCH 13/28] Update 1-js/06-advanced-functions/04-var/article.md

Co-authored-by: Valentina VP <34555644+vplentinax@users.noreply.github.com>
---
 1-js/06-advanced-functions/04-var/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/06-advanced-functions/04-var/article.md b/1-js/06-advanced-functions/04-var/article.md
index 04563da00..51b6b26fe 100644
--- a/1-js/06-advanced-functions/04-var/article.md
+++ b/1-js/06-advanced-functions/04-var/article.md
@@ -24,7 +24,7 @@ Pero internamente `var` es una bestia diferente, originaria de muy viejas época
 
 Si no planeas encontrarte con tal código bien puedes saltear este capítulo o posponerlo, pero chances hay de que pueda morderte más tarde.
 
-Por otro lado, es importante entender las diferencias cuando se migra viejo código de `var` a `let` para evitar extraños errores.
+Por otro lado, es importante entender las diferencias cuando se migra antiguo código de `var` a `let` para evitar extraños errores.
 
 # "var" no tiene alcance(visibilidad) de bloque.
 

From 46bd6d057229dc6bb798803377b9b11662bd307d Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Fri, 24 Jul 2020 23:58:52 -0300
Subject: [PATCH 14/28] Update 1-js/06-advanced-functions/04-var/article.md

Co-authored-by: Valentina VP <34555644+vplentinax@users.noreply.github.com>
---
 1-js/06-advanced-functions/04-var/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/06-advanced-functions/04-var/article.md b/1-js/06-advanced-functions/04-var/article.md
index 51b6b26fe..41f6f96f8 100644
--- a/1-js/06-advanced-functions/04-var/article.md
+++ b/1-js/06-advanced-functions/04-var/article.md
@@ -22,7 +22,7 @@ alert(message); // Hola
 
 Pero internamente `var` es una bestia diferente, originaria de muy viejas épocas. Generalmente no es usado en código moderno, pero aún habita en el antiguo.
 
-Si no planeas encontrarte con tal código bien puedes saltear este capítulo o posponerlo, pero chances hay de que pueda morderte más tarde.
+Si no planeas encontrarte con tal código bien puedes saltar este capítulo o posponerlo, pero hay posibilidades de que esta bestia pueda morderte más tarde.
 
 Por otro lado, es importante entender las diferencias cuando se migra antiguo código de `var` a `let` para evitar extraños errores.
 

From a29e338006d1bc3a73af1c29c4481e08fe874f77 Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Sat, 25 Jul 2020 00:00:55 -0300
Subject: [PATCH 15/28] Update 1-js/06-advanced-functions/04-var/article.md

Co-authored-by: Valentina VP <34555644+vplentinax@users.noreply.github.com>
---
 1-js/06-advanced-functions/04-var/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/06-advanced-functions/04-var/article.md b/1-js/06-advanced-functions/04-var/article.md
index 41f6f96f8..7ff64045a 100644
--- a/1-js/06-advanced-functions/04-var/article.md
+++ b/1-js/06-advanced-functions/04-var/article.md
@@ -162,7 +162,7 @@ Este comportamiento también se llama "hoisting" (elevamiento), porque todos los
 
 Entonces, en el ejemplo anterior, la rama `if (false)` nunca se ejecuta pero eso no tiene importancia. El `var` dentro es procesado al al iniciar la función, entonces al momento de `(*)` la variable existe.
 
-**Las declaraciones son "hoisted", pero las asignaciones no lo son.**
+**Las declaraciones son "hoisted" (elevadas), pero las asignaciones no lo son.**
 
 Es mejor demostrarlo con un ejemplo:
 

From 84cbbe24243430cecc81c8c429df76e18df9dfc9 Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Sat, 25 Jul 2020 00:19:40 -0300
Subject: [PATCH 16/28] article mejorado

---
 1-js/06-advanced-functions/04-var/article.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/1-js/06-advanced-functions/04-var/article.md b/1-js/06-advanced-functions/04-var/article.md
index 7ff64045a..aeeeb9150 100644
--- a/1-js/06-advanced-functions/04-var/article.md
+++ b/1-js/06-advanced-functions/04-var/article.md
@@ -13,7 +13,7 @@ En el primer capítulo acerca de [variables](info:variables), mencionamos tres f
 2. `const`
 3. `var`
 
-La declaración `var` es similar a `let`. La mayoría de las veces podemos reemplazar `let` por `var` o viceversa y esperar que las cosas funcionen: 
+La declaración `var` es similar a `let`. Casi siempre podemos reemplazar `let` por `var` o viceversa y esperar que las cosas funcionen: 
 
 ```js run
 var message = "Hola";
@@ -26,9 +26,9 @@ Si no planeas encontrarte con tal código bien puedes saltar este capítulo o po
 
 Por otro lado, es importante entender las diferencias cuando se migra antiguo código de `var` a `let` para evitar extraños errores.
 
-# "var" no tiene alcance(visibilidad) de bloque.
+# "var" no tiene alcance (visibilidad) de bloque.
 
-Las variables declaradas con `var` tienen como entorno de visibilidad la función o bien son globales. Su visibilidad atraviesa los bloques.
+Las variables declaradas con `var` pueden: tener a la función como entorno de visibilidad, o bien ser globales. Su visibilidad atraviesa los bloques.
 
 Por ejemplo:
 
@@ -105,7 +105,7 @@ var user = "John"; // este "var" no hace nada (ya estaba declarado)
 alert(user); // John
 ```
 
-## Las variables "var" pueden ser declaradas debajo de su uso
+## Las variables "var" pueden ser usadas en líneas más arriba de donde son declaradas
 
 Las declaraciones `var` son procesadas cuando se inicia la función (o se inicia el script para las globales).
 
@@ -282,4 +282,4 @@ Hay dos diferencias principales entre `var` y `let/const`:
 
 Hay otra diferencia menor relacionada al objeto global que cubriremos en el siguiente capítulo.
 
-Estas diferencias hacen a `var` peor que `let` la mayoría de las veces. Las variables a nivel de bloque son mejores. Es por ello que `let` fue presentado en el estándar mucho tiempo atrás, y es ahora la forma principal (junto con `const`) de declarar una variable.
+Estas diferencias casi siempre hacen a `var` peor que `let`. Las variables a nivel de bloque son mejores. Es por ello que `let` fue presentado en el estándar mucho tiempo atrás, y es ahora la forma principal (junto con `const`) de declarar una variable.

From f1ec4e8b5b6c874f807df5d3f3a3180611352316 Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Sat, 25 Jul 2020 00:35:36 -0300
Subject: [PATCH 17/28] Update 1-js/06-advanced-functions/04-var/article.md

Co-authored-by: Valentina VP <34555644+vplentinax@users.noreply.github.com>
---
 1-js/06-advanced-functions/04-var/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/06-advanced-functions/04-var/article.md b/1-js/06-advanced-functions/04-var/article.md
index 64dd71ed4..5b260cf48 100644
--- a/1-js/06-advanced-functions/04-var/article.md
+++ b/1-js/06-advanced-functions/04-var/article.md
@@ -209,7 +209,7 @@ En ambos ejemplos de arriba `alert` ejecuta sin un error, porque la variable `ph
 
 Como en el pasado solo existía `var`, y no había visibilidad a nivel de bloque, los programadores inventaron una manera de emularla. Lo que hicieron fue el llamado "expresiones de función inmediatamente invocadas (abreviado IIFE en inglés).
 
-No es algo que debiéramos usar estos días, pero puedes encontrarlas en viejo código.
+No es algo que debiéramos usar estos días, pero puedes encontrarlas en código antiguo.
 
 Un IIFE se ve así:
 

From 051f388a403324f8231f61a0f110cc5af2657feb Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Sat, 25 Jul 2020 01:34:22 -0300
Subject: [PATCH 18/28] update line108- better I hope

---
 1-js/06-advanced-functions/04-var/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/06-advanced-functions/04-var/article.md b/1-js/06-advanced-functions/04-var/article.md
index 5b260cf48..facb54be2 100644
--- a/1-js/06-advanced-functions/04-var/article.md
+++ b/1-js/06-advanced-functions/04-var/article.md
@@ -105,7 +105,7 @@ var user = "John"; // este "var" no hace nada (ya estaba declarado)
 alert(user); // John
 ```
 
-## Las variables "var" pueden ser usadas en líneas más arriba que el lugar en donde son declaradas
+## Las variables "var" pueden ser declaradas debajo del lugar donde se usan
 
 Las declaraciones `var` son procesadas cuando se inicia la función (o se inicia el script para las globales).
 

From a87a5dd11ae4688f2f1444097e8f6652aeefea11 Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Sat, 25 Jul 2020 01:35:15 -0300
Subject: [PATCH 19/28] 108 v3

---
 1-js/06-advanced-functions/04-var/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/06-advanced-functions/04-var/article.md b/1-js/06-advanced-functions/04-var/article.md
index facb54be2..846e7dd2d 100644
--- a/1-js/06-advanced-functions/04-var/article.md
+++ b/1-js/06-advanced-functions/04-var/article.md
@@ -105,7 +105,7 @@ var user = "John"; // este "var" no hace nada (ya estaba declarado)
 alert(user); // John
 ```
 
-## Las variables "var" pueden ser declaradas debajo del lugar donde se usan
+## Las variables "var" pueden ser declaradas debajo del lugar en donde se usan
 
 Las declaraciones `var` son procesadas cuando se inicia la función (o se inicia el script para las globales).
 

From 169cc2b4383e7d456c654a6ea883822a438eba9f Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Sat, 25 Jul 2020 03:20:26 -0300
Subject: [PATCH 20/28] Update 1-js/06-advanced-functions/04-var/article.md

Co-authored-by: Maksumi Murakami <maksumimurakami@gmail.com>
---
 1-js/06-advanced-functions/04-var/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/06-advanced-functions/04-var/article.md b/1-js/06-advanced-functions/04-var/article.md
index 846e7dd2d..464edecee 100644
--- a/1-js/06-advanced-functions/04-var/article.md
+++ b/1-js/06-advanced-functions/04-var/article.md
@@ -26,7 +26,7 @@ Si no planeas encontrarte con tal código bien puedes saltar este capítulo o po
 
 Por otro lado, es importante entender las diferencias cuando se migra antiguo código de `var` a `let` para evitar extraños errores.
 
-# "var" no tiene alcance (visibilidad) de bloque.
+## "var" no tiene alcance (visibilidad) de bloque.
 
 Las variables declaradas con `var` pueden: tener a la función como entorno de visibilidad, o bien ser globales. Su visibilidad atraviesa los bloques.
 

From 44908275f0826f7a735e842dbb62145474ac5c43 Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Sat, 25 Jul 2020 03:20:53 -0300
Subject: [PATCH 21/28] Update 1-js/06-advanced-functions/04-var/article.md

Co-authored-by: Maksumi Murakami <maksumimurakami@gmail.com>
---
 1-js/06-advanced-functions/04-var/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/06-advanced-functions/04-var/article.md b/1-js/06-advanced-functions/04-var/article.md
index 464edecee..3b92bbec3 100644
--- a/1-js/06-advanced-functions/04-var/article.md
+++ b/1-js/06-advanced-functions/04-var/article.md
@@ -249,7 +249,7 @@ function go() {
 
 Entonces, los paréntesis alrededor de la función es un truco para mostrarle a JavaScript que la función es creada en el contexto de otra expresión, y de allí lo de "expresión de función", que no necesita un nombre y puede ser llamada inmediatamente.
 
-Existen otras maneras además de los paréntesis para decirle a JavaScript que queremos un expresión de función:
+Existen otras maneras además de los paréntesis para decirle a JavaScript que queremos una expresión de función:
 
 ```js run
 // Formas de crear IIFE

From a32ebdd24037bda019afe0baea6b6b7eecaff7c8 Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Sat, 25 Jul 2020 03:21:22 -0300
Subject: [PATCH 22/28] Update 1-js/06-advanced-functions/04-var/article.md

Co-authored-by: Maksumi Murakami <maksumimurakami@gmail.com>
---
 1-js/06-advanced-functions/04-var/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/06-advanced-functions/04-var/article.md b/1-js/06-advanced-functions/04-var/article.md
index 3b92bbec3..deab23734 100644
--- a/1-js/06-advanced-functions/04-var/article.md
+++ b/1-js/06-advanced-functions/04-var/article.md
@@ -229,7 +229,7 @@ La expresión de función es encerrada entre paréntesis `(function {...})`, por
 
 ```js run
 // Trata de declarar e inmediatamente llamar una función
-function() { // <-- Error: la intrucción de función requiere un nombre de función
+function() { // <-- Error: la instrucción de función requiere un nombre de función
 
   let message = "Hello";
 

From aa2bd3493673cd402b2b40edd7e5da11130c7efc Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Sat, 25 Jul 2020 03:21:50 -0300
Subject: [PATCH 23/28] Update 1-js/06-advanced-functions/04-var/article.md

Co-authored-by: Maksumi Murakami <maksumimurakami@gmail.com>
---
 1-js/06-advanced-functions/04-var/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/06-advanced-functions/04-var/article.md b/1-js/06-advanced-functions/04-var/article.md
index deab23734..57cb9e028 100644
--- a/1-js/06-advanced-functions/04-var/article.md
+++ b/1-js/06-advanced-functions/04-var/article.md
@@ -203,7 +203,7 @@ sayHi();
 
 Como todas las declaraciones `var` son procesadas al inicio de la función, podemos referenciarlas en cualquier lugar. Pero las variables serán indefinidas hasta que alcancen su asignación.
 
-En ambos ejemplos de arriba `alert` ejecuta sin un error, porque la variable `phrase` existe. Pero su valor no fue asignado aún, entonces muestra `undefined`.
+En ambos ejemplos de arriba `alert` se ejecuta sin un error, porque la variable `phrase` existe. Pero su valor no fue asignado aún, entonces muestra `undefined`.
 
 ### IIFE
 

From ce56e7580b5621d8779b09bdc5b3fe5cdf4d0e7e Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Sat, 25 Jul 2020 03:22:35 -0300
Subject: [PATCH 24/28] Update 1-js/06-advanced-functions/04-var/article.md

Co-authored-by: Maksumi Murakami <maksumimurakami@gmail.com>
---
 1-js/06-advanced-functions/04-var/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/06-advanced-functions/04-var/article.md b/1-js/06-advanced-functions/04-var/article.md
index 57cb9e028..629e14fc9 100644
--- a/1-js/06-advanced-functions/04-var/article.md
+++ b/1-js/06-advanced-functions/04-var/article.md
@@ -160,7 +160,7 @@ sayHi();
 
 Este comportamiento también se llama "hoisting" (elevamiento), porque todos los `var` son "hoisted" (elevados) hacia el tope de la función.
 
-Entonces, en el ejemplo anterior, la rama `if (false)` nunca se ejecuta pero eso no tiene importancia. El `var` dentro es procesado al al iniciar la función, entonces al momento de `(*)` la variable existe.
+Entonces, en el ejemplo anterior, la rama `if (false)` nunca se ejecuta pero eso no tiene importancia. El `var` dentro es procesado al iniciar la función, entonces al momento de `(*)` la variable existe.
 
 **Las declaraciones son "hoisted" (elevadas), pero las asignaciones no lo son.**
 

From 4afadec39a1db6483470bedfd4f666f41693321c Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Sat, 25 Jul 2020 03:23:24 -0300
Subject: [PATCH 25/28] Update 1-js/06-advanced-functions/04-var/article.md

Co-authored-by: Maksumi Murakami <maksumimurakami@gmail.com>
---
 1-js/06-advanced-functions/04-var/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/06-advanced-functions/04-var/article.md b/1-js/06-advanced-functions/04-var/article.md
index 629e14fc9..7a35480bb 100644
--- a/1-js/06-advanced-functions/04-var/article.md
+++ b/1-js/06-advanced-functions/04-var/article.md
@@ -109,7 +109,7 @@ alert(user); // John
 
 Las declaraciones `var` son procesadas cuando se inicia la función (o se inicia el script para las globales).
 
-En otras palabras, las variables `var` son definidas desde el inicio de la función, no importa dónde tal definición está (asumiendo que la definición no está en una función anidada).
+En otras palabras, las variables `var` son definidas desde el inicio de la función, no importa dónde esté tal definición (asumiendo que la definición no está en una función anidada).
 
 Entonces el código:
 

From a55388e7f3426f8583abb81268147e7828458b8f Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Sat, 25 Jul 2020 03:23:54 -0300
Subject: [PATCH 26/28] Update 1-js/06-advanced-functions/04-var/article.md

Co-authored-by: Maksumi Murakami <maksumimurakami@gmail.com>
---
 1-js/06-advanced-functions/04-var/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/06-advanced-functions/04-var/article.md b/1-js/06-advanced-functions/04-var/article.md
index 7a35480bb..54ea9d71b 100644
--- a/1-js/06-advanced-functions/04-var/article.md
+++ b/1-js/06-advanced-functions/04-var/article.md
@@ -20,7 +20,7 @@ var message = "Hola";
 alert(message); // Hola
 ```
 
-Pero internamente `var` es una bestia diferente, originaria de muy viejas épocas. Generalmente no es usado en código moderno, pero aún habita en el antiguo.
+Pero internamente `var` es una bestia diferente, originaria de muy viejas épocas. Generalmente no se usa en código moderno pero aún habita en el antiguo.
 
 Si no planeas encontrarte con tal código bien puedes saltar este capítulo o posponerlo, pero hay posibilidades de que esta bestia pueda morderte más tarde.
 

From b4d86ccc7be0901aa4acb1b35caa023e17553e66 Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Sat, 25 Jul 2020 03:27:44 -0300
Subject: [PATCH 27/28] Update 1-js/06-advanced-functions/04-var/article.md

Co-authored-by: Maksumi Murakami <maksumimurakami@gmail.com>
---
 1-js/06-advanced-functions/04-var/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/06-advanced-functions/04-var/article.md b/1-js/06-advanced-functions/04-var/article.md
index 54ea9d71b..d9ec748fd 100644
--- a/1-js/06-advanced-functions/04-var/article.md
+++ b/1-js/06-advanced-functions/04-var/article.md
@@ -1,7 +1,7 @@
 
 # La vieja "var"
 
-```smart header="Este artículo es para entender el código antiguo"
+```smart header="Este artículo es para entender código antiguo"
 La información en este artículo es útil para entender el código antiguo.
 
 Así no es como escribimos código moderno.

From 064588249a539b9b12f53376d8a09f4faed71711 Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Sat, 25 Jul 2020 03:27:58 -0300
Subject: [PATCH 28/28] Update 1-js/06-advanced-functions/04-var/article.md

Co-authored-by: Maksumi Murakami <maksumimurakami@gmail.com>
---
 1-js/06-advanced-functions/04-var/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/06-advanced-functions/04-var/article.md b/1-js/06-advanced-functions/04-var/article.md
index d9ec748fd..a0a304d06 100644
--- a/1-js/06-advanced-functions/04-var/article.md
+++ b/1-js/06-advanced-functions/04-var/article.md
@@ -2,7 +2,7 @@
 # La vieja "var"
 
 ```smart header="Este artículo es para entender código antiguo"
-La información en este artículo es útil para entender el código antiguo.
+La información en este artículo es útil para entender código antiguo.
 
 Así no es como escribimos código moderno.
 ```