From 35a6c721cd7f924b3bcf96412eba692e241ebb05 Mon Sep 17 00:00:00 2001
From: Sjesc <silvinoje14@gmail.com>
Date: Thu, 16 May 2019 11:54:01 -0400
Subject: [PATCH 01/36] =?UTF-8?q?Traducci=C3=B3n=20de=20Logical=20Operator?=
 =?UTF-8?q?s?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../1-alert-null-2-undefined/solution.md      |   5 +-
 .../1-alert-null-2-undefined/task.md          |   7 +-
 .../2-alert-or/solution.md                    |  14 +-
 .../11-logical-operators/2-alert-or/task.md   |   7 +-
 .../3-alert-1-null-2/solution.md              |   5 +-
 .../3-alert-1-null-2/task.md                  |   7 +-
 .../4-alert-and/solution.md                   |   9 +-
 .../11-logical-operators/4-alert-and/task.md  |   7 +-
 .../5-alert-and-or/solution.md                |  11 +-
 .../5-alert-and-or/task.md                    |   7 +-
 .../6-check-if-in-range/task.md               |   6 +-
 .../7-check-if-out-range/solution.md          |   5 +-
 .../7-check-if-out-range/task.md              |   6 +-
 .../8-if-question/solution.md                 |  25 +-
 .../8-if-question/task.md                     |  13 +-
 .../9-check-login/solution.md                 |  32 +--
 .../9-check-login/task.md                     |  20 +-
 .../11-logical-operators/article.md           | 263 +++++++++---------
 18 files changed, 218 insertions(+), 231 deletions(-)

diff --git a/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/solution.md b/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/solution.md
index 8869d32e6..aa444844a 100644
--- a/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/solution.md
@@ -1,6 +1,5 @@
-The answer is `2`, that's the first truthy value.
+La respuesta es `2`, ese es el primer valor verdadero.
 
 ```js run
-alert( null || 2 || undefined );
+alert(null || 2 || undefined);
 ```
-
diff --git a/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/task.md b/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/task.md
index a7c9addfc..5988c96d3 100644
--- a/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/task.md
+++ b/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/task.md
@@ -2,11 +2,10 @@ importance: 5
 
 ---
 
-# What's the result of OR?
+# ¿Cuál es el resultado de OR?
 
-What is the code below going to output?
+¿Qué va a imprimir el codigo debajo?
 
 ```js
-alert( null || 2 || undefined );
+alert(null || 2 || undefined);
 ```
-
diff --git a/1-js/02-first-steps/11-logical-operators/2-alert-or/solution.md b/1-js/02-first-steps/11-logical-operators/2-alert-or/solution.md
index 8f4d664e8..c77908380 100644
--- a/1-js/02-first-steps/11-logical-operators/2-alert-or/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/2-alert-or/solution.md
@@ -1,13 +1,13 @@
-The answer: first `1`, then `2`.
+La repuesta: primero `1`, y entonces `2`.
 
 ```js run
-alert( alert(1) || 2 || alert(3) );
+alert(alert(1) || 2 || alert(3));
 ```
 
-The call to `alert` does not return a value. Or, in other words, it returns `undefined`.
+La llamada a `alert` no retorna un valor. O, en otras palabras, retorna `undefined`.
 
-1. The first OR `||` evaluates it's left operand `alert(1)`. That shows the first message with `1`.
-2. The `alert` returns `undefined`, so OR goes on to the second operand searching for a truthy value.
-3. The second operand `2` is truthy, so the execution is halted, `2` is returned and then shown by the outer alert.
+1. El primer OR `||` evaluá su operando a la izquierda `alert(1)`. Eso muestra el primer mensaje con `1`.
+2. El `alert` retorna `undefined`, asi que OR va hacia el segundo operando buscando un valor verdadero.
+3. El segundo operando `2` es un valor verdadero, asi que la ejecución es detenida, `2` es retornado y mostrado por la alerta exterior.
 
-There will be no `3`, because the evaluation does not reach `alert(3)`.
+No va a haber `3`, porque la evaluación no alcanza a `alert(3)`.
diff --git a/1-js/02-first-steps/11-logical-operators/2-alert-or/task.md b/1-js/02-first-steps/11-logical-operators/2-alert-or/task.md
index 3908fa2ec..d8d35c119 100644
--- a/1-js/02-first-steps/11-logical-operators/2-alert-or/task.md
+++ b/1-js/02-first-steps/11-logical-operators/2-alert-or/task.md
@@ -2,11 +2,10 @@ importance: 3
 
 ---
 
-# What's the result of OR'ed alerts?
+# ¿Cuál es el resultado de las alertas aplicadas al operador OR?
 
-What will the code below output?
+¿Qué va a imprimir el codigo debajo?
 
 ```js
-alert( alert(1) || 2 || alert(3) );
+alert(alert(1) || 2 || alert(3));
 ```
-
diff --git a/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/solution.md b/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/solution.md
index 5c2455ef4..4a0e0823e 100644
--- a/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/solution.md
@@ -1,6 +1,5 @@
-The answer: `null`, because it's the first falsy value from the list.
+La respuesta: `null`, porque es el primer valor falso de la lista.
 
 ```js run
-alert( 1 && null && 2 );
+alert(1 && null && 2);
 ```
-
diff --git a/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/task.md b/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/task.md
index 043d431e4..86d017b44 100644
--- a/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/task.md
+++ b/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/task.md
@@ -2,11 +2,10 @@ importance: 5
 
 ---
 
-# What is the result of AND?
+# ¿Cuál es el resultado de AND?
 
-What is this code going to show?
+¿Qué va a imprimir el codigo debajo?
 
 ```js
-alert( 1 && null && 2 );
+alert(1 && null && 2);
 ```
-
diff --git a/1-js/02-first-steps/11-logical-operators/4-alert-and/solution.md b/1-js/02-first-steps/11-logical-operators/4-alert-and/solution.md
index b6fb10d72..a4b90f400 100644
--- a/1-js/02-first-steps/11-logical-operators/4-alert-and/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/4-alert-and/solution.md
@@ -1,10 +1,9 @@
-The answer: `1`, and then `undefined`.
+La respuesta: `1` y entonces `undefined`.
 
 ```js run
-alert( alert(1) && alert(2) );
+alert(alert(1) && alert(2));
 ```
 
-The call to `alert` returns `undefined` (it just shows a message, so there's no meaningful return).
-
-Because of that, `&&` evaluates the left operand (outputs `1`), and immediately stops, because `undefined` is a falsy value. And `&&` looks for a falsy value and returns it, so it's done.
+La llamada a `alert`retorna `undefined` (solo muestra un mensaje, asi que no hay un valor que retornar significante)
 
+Debido a ello, `&&` evaluá el operando a la izquierda (imprime `1`), e inmediatamente se detiene, porque `undefined` es un valor falso. Y `&&` busca un valor falso y lo retorna, asi que ya está hecho.
diff --git a/1-js/02-first-steps/11-logical-operators/4-alert-and/task.md b/1-js/02-first-steps/11-logical-operators/4-alert-and/task.md
index 69f877b95..fd4847bd0 100644
--- a/1-js/02-first-steps/11-logical-operators/4-alert-and/task.md
+++ b/1-js/02-first-steps/11-logical-operators/4-alert-and/task.md
@@ -2,11 +2,10 @@ importance: 3
 
 ---
 
-# What is the result of AND'ed alerts?
+# ¿Cuál es el resultado de las alertas aplicadas al operador AND?
 
-What will this code show?
+¿Qué va a imprimir el codigo debajo?
 
 ```js
-alert( alert(1) && alert(2) );
+alert(alert(1) && alert(2));
 ```
-
diff --git a/1-js/02-first-steps/11-logical-operators/5-alert-and-or/solution.md b/1-js/02-first-steps/11-logical-operators/5-alert-and-or/solution.md
index 25e3568f8..818d4fd33 100644
--- a/1-js/02-first-steps/11-logical-operators/5-alert-and-or/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/5-alert-and-or/solution.md
@@ -1,16 +1,15 @@
-The answer: `3`.
+La respuesta: `3`.
 
 ```js run
-alert( null || 2 && 3 || 4 );
+alert(null || (2 && 3) || 4);
 ```
 
-The precedence of AND `&&` is higher than `||`, so it executes first.
+La precedencia de AND `&&` es mayor que la de `||`, asi que se ejecuta primero.
 
-The result of `2 && 3 = 3`, so the expression becomes:
+El resultado de `2 && 3 = 3`, asi que la expresión se convierte en:
 
 ```
 null || 3 || 4
 ```
 
-Now the result is the first truthy value: `3`.
-
+Ahora el resultado sera el primer valor verdadero: `3`.
diff --git a/1-js/02-first-steps/11-logical-operators/5-alert-and-or/task.md b/1-js/02-first-steps/11-logical-operators/5-alert-and-or/task.md
index b18bb9c51..a92f6691e 100644
--- a/1-js/02-first-steps/11-logical-operators/5-alert-and-or/task.md
+++ b/1-js/02-first-steps/11-logical-operators/5-alert-and-or/task.md
@@ -2,11 +2,10 @@ importance: 5
 
 ---
 
-# The result of OR AND OR
+# El resultado de OR AND OR
 
-What will the result be?
+¿Cuál sera el resultado?
 
 ```js
-alert( null || 2 && 3 || 4 );
+alert(null || (2 && 3) || 4);
 ```
-
diff --git a/1-js/02-first-steps/11-logical-operators/6-check-if-in-range/task.md b/1-js/02-first-steps/11-logical-operators/6-check-if-in-range/task.md
index cc00ca9fc..b3765e6c7 100644
--- a/1-js/02-first-steps/11-logical-operators/6-check-if-in-range/task.md
+++ b/1-js/02-first-steps/11-logical-operators/6-check-if-in-range/task.md
@@ -2,8 +2,8 @@ importance: 3
 
 ---
 
-# Check the range between
+# Comprueba el rango entre ellos
 
-Write an "if" condition to check that `age` is between `14` and `90` inclusively.
+Escribe una condición "if" para comprobar que `age`(edad) esta entre `14` y `90` inclusivemente.
 
-"Inclusively" means that `age` can reach the edges `14` or `90`.
+"Inclusivemente" significa que `age` puede llegar a ser uno de los extremos, `14` o `90`
diff --git a/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/solution.md b/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/solution.md
index d1946a967..35a1ba906 100644
--- a/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/solution.md
@@ -1,12 +1,11 @@
-The first variant:
+La primer variante:
 
 ```js
 if (!(age >= 14 && age <= 90))
 ```
 
-The second variant:
+La segunda variante:
 
 ```js
 if (age < 14 || age > 90)
 ```
-
diff --git a/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/task.md b/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/task.md
index 7c22d6ad1..b6b328295 100644
--- a/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/task.md
+++ b/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/task.md
@@ -2,8 +2,8 @@ importance: 3
 
 ---
 
-# Check the range outside
+# Comprueba el rango al exterior
 
-Write an `if` condition to check that `age` is NOT between 14 and 90 inclusively.
+Escribe una condición `if` para comprobar que `age` NO esta entre 14 y 90 inclusivemente.
 
-Create two variants: the first one using NOT `!`, the second one -- without it.
+Crea dos variantes: la primera usando NOT `!`, y la segunda -- sin usarlo.
diff --git a/1-js/02-first-steps/11-logical-operators/8-if-question/solution.md b/1-js/02-first-steps/11-logical-operators/8-if-question/solution.md
index 210509758..2017fa0dd 100644
--- a/1-js/02-first-steps/11-logical-operators/8-if-question/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/8-if-question/solution.md
@@ -1,20 +1,19 @@
-The answer: the first and the third will execute.
+La respuesta: el primero y el tercero serán ejecutados.
 
-Details:
+Detalles:
 
 ```js run
-// Runs.
-// The result of -1 || 0 = -1, truthy
-if (-1 || 0) alert( 'first' );
+// Corre.
+// El resultado de -1 || 0 = -1, valor verdadero
+if (-1 || 0) alert("primero");
 
-// Doesn't run
-// -1 && 0 = 0, falsy
-if (-1 && 0) alert( 'second' );
+// No corre.
+// -1 && 0 = 0, valor falso
+if (-1 && 0) alert("segundo");
 
-// Executes
-// Operator && has a higher precedence than ||
-// so -1 && 1 executes first, giving us the chain:
+// Se ejecuta
+// El operador && tiene mayor precedencia que ||
+// Asi que -1 && 1 se ejecuta primero, dandonos la cadena:
 // null || -1 && 1  ->  null || 1  ->  1
-if (null || -1 && 1) alert( 'third' );
+if (null || (-1 && 1)) alert("tercero");
 ```
-
diff --git a/1-js/02-first-steps/11-logical-operators/8-if-question/task.md b/1-js/02-first-steps/11-logical-operators/8-if-question/task.md
index 55987121b..4aeac7790 100644
--- a/1-js/02-first-steps/11-logical-operators/8-if-question/task.md
+++ b/1-js/02-first-steps/11-logical-operators/8-if-question/task.md
@@ -2,15 +2,14 @@ importance: 5
 
 ---
 
-# A question about "if"
+# Un pregunta acerca de "if"
 
-Which of these `alert`s are going to execute?
+¿Cualés de estos `alert`s va a ejecutarse?
 
-What will the results of the expressions be inside `if(...)`?
+¿Cualés van a ser los resultados de las expresiones dentro de `if(...)`?
 
 ```js
-if (-1 || 0) alert( 'first' );
-if (-1 && 0) alert( 'second' );
-if (null || -1 && 1) alert( 'third' );
+if (-1 || 0) alert("first");
+if (-1 && 0) alert("second");
+if (null || (-1 && 1)) alert("third");
 ```
-
diff --git a/1-js/02-first-steps/11-logical-operators/9-check-login/solution.md b/1-js/02-first-steps/11-logical-operators/9-check-login/solution.md
index b535650ec..2ac737471 100644
--- a/1-js/02-first-steps/11-logical-operators/9-check-login/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/9-check-login/solution.md
@@ -1,25 +1,21 @@
-
-
 ```js run demo
-let userName = prompt("Who's there?", '');
-
-if (userName == 'Admin') {
-
-  let pass = prompt('Password?', '');
+let userName = prompt("Quién esta alli?", "");
 
-  if (pass == 'TheMaster') {
-    alert( 'Welcome!' );
-  } else if (pass == '' || pass == null) {
-    alert( 'Canceled.' );
-  } else {
-    alert( 'Wrong password' );
-  }
+if (userName == "Admin") {
+	let pass = prompt("Contraseña?", "");
 
-} else if (userName == '' || userName == null) {
-  alert( 'Canceled' );
+	if (pass == "TheMaster") {
+		alert("Bienvenido!");
+	} else if (pass == "" || pass == null) {
+		alert("Cancelado.");
+	} else {
+		alert("Contraseña incorrecta");
+	}
+} else if (userName == "" || userName == null) {
+	alert("Canceledo");
 } else {
-  alert( "I don't know you" );
+	alert("No te conozco");
 }
 ```
 
-Note the vertical indents inside the `if` blocks. They are technically not required, but make the code more readable.
+Nota las sangrías verticales dentro de los bloques `if`. Tecnicamente no son necesarias, pero facilitan la redacción del código.
diff --git a/1-js/02-first-steps/11-logical-operators/9-check-login/task.md b/1-js/02-first-steps/11-logical-operators/9-check-login/task.md
index 780e674a9..ad9681f0a 100644
--- a/1-js/02-first-steps/11-logical-operators/9-check-login/task.md
+++ b/1-js/02-first-steps/11-logical-operators/9-check-login/task.md
@@ -2,24 +2,24 @@ importance: 3
 
 ---
 
-# Check the login
+# Comprueba el inicio de sesión
 
-Write the code which asks for a login with `prompt`.
+Escribe un código que pregunte por el inicio de sesión con `propmt`.
 
-If the visitor enters `"Admin"`, then `prompt` for a password, if the input is an empty line or `key:Esc` -- show "Canceled.", if it's another string -- then show "I don't know you".
+Si el visitante ingresa `Admin`, entonces `prompt`(pregunta) por una contraseña, si la entrada es una linea vacía o `key:Esc` -- muestra "Cancelado.", si es otra cadena de texto -- entonces muestra "No te conozco".
 
-The password is checked as follows:
+La contraseña es comprobada así:
 
-- If it equals "TheMaster", then show "Welcome!",
-- Another string -- show "Wrong password",
-- For an empty string or cancelled input, show "Canceled."
+-  Si iguala a "TheMaster", entonces muestra "Bienvenido!",
+-  Si es otra cadena de texto -- muetra "Contraseña incorrecta",
+-  Para una cadena de texto vacía o una entrada cancelada, muestra "Cancelado."
 
-The schema:
+El esquema:
 
 ![](ifelse_task.png)
 
-Please use nested `if` blocks. Mind the overall readability of the code.
+Por favor usa bloques anidados de `if`. Piensa en la legibilidad general del código.
 
-Hint:  passing an empty input to a prompt returns an empty string `''`. Pressing `key:ESC` during a prompt returns `null`.
+Pista: pasando una entrada vacía a un prompt retorna una cadena de texto vacía `''`. Presionando `key:ESC` durante un prompt retorna `null`.
 
 [demo]
diff --git a/1-js/02-first-steps/11-logical-operators/article.md b/1-js/02-first-steps/11-logical-operators/article.md
index 4932020ae..f01614b05 100644
--- a/1-js/02-first-steps/11-logical-operators/article.md
+++ b/1-js/02-first-steps/11-logical-operators/article.md
@@ -1,47 +1,48 @@
-# Logical operators
+# Operadores Lógicos
 
-There are three logical operators in JavaScript: `||` (OR), `&&` (AND), `!` (NOT).
+Hay tres operadores lógicos en JavaScript: `||` (OR (O)), `&&` (AND (Y)), `!` (NOT (NO)).
 
-Although they are called "logical", they can be applied to values of any type, not only boolean. Their result can also be of any type.
+Aun que sean llamados lógicos, pueden ser aplicados a valores de cualquier tipo, no solo booleanos. El resultado también puede ser de cualquier tipo.
 
-Let's see the details.
+Veamos los detalles.
 
 ## || (OR)
 
-The "OR" operator is represented with two vertical line symbols:
+El operador `OR` es represtando con dos simbolos de linea verticales:
 
 ```js
 result = a || b;
 ```
 
-In classical programming, the logical OR is meant to manipulate boolean values only. If any of its arguments are `true`, it returns `true`, otherwise it returns `false`.
+En la programación clasica, el OR lógico esta pensado para manipular solo valore booleanos. Si cualquiera de sus argumentos son `true`, retornara `true`, de lo contrario retornara `false`.
 
-In JavaScript, the operator is a little bit trickier and more powerful. But first, let's see what happens with boolean values.
+En JavaScript, el operador es un poco más complicado y poderoso. Pero primero, veamos que pasa con los valores booleanos.
 
-There are four possible logical combinations:
+Hay cuatro posibles combinaciones lógicas:
 
 ```js run
-alert( true || true );   // true
-alert( false || true );  // true
-alert( true || false );  // true
-alert( false || false ); // false
+alert(true || true); // true (verdadero)
+alert(false || true); // true
+alert(true || false); // true
+alert(false || false); // false (falso)
 ```
 
-As we can see, the result is always `true` except for the case when both operands are `false`.
+Como podemos ver, los resultados son siempre `true` excepto en el caso de que ambos operandos sean `false`
 
-If an operand is not a boolean, it's converted to a boolean for the evaluation.
+Si un operando no es un booleano, entonces es convertido a un booleano para la evaluación.
 
-For instance, the number `1` is treated as `true`, the number `0` as `false`:
+Por ejemplo, el número `1` es tratado como `true`, el número `0` como `false`:
 
 ```js run
-if (1 || 0) { // works just like if( true || false )
-  alert( 'truthy!' );
+if (1 || 0) {
+	// Funciona como if( true || false )
+	alert("valor verdadero!");
 }
 ```
 
-Most of the time, OR `||` is used in an `if` statement to test if *any* of the given conditions is `true`.
+La mayoría del tiempo, OR `||` es usando como una declaración de `if` para probar si _cualqueria_ de las condiciones dadas son `true`
 
-For example:
+Por ejemplo:
 
 ```js run
 let hour = 9;
@@ -49,255 +50,257 @@ let hour = 9;
 *!*
 if (hour < 10 || hour > 18) {
 */!*
-  alert( 'The office is closed.' );
+  alert( 'La oficina esta cerrada.' );
 }
 ```
 
-We can pass more conditions:
+Podemos pasar mas condiciones:
 
 ```js run
 let hour = 12;
 let isWeekend = true;
 
 if (hour < 10 || hour > 18 || isWeekend) {
-  alert( 'The office is closed.' ); // it is the weekend
+	alert("La oficina esta cerrada."); // Esta los fines de semana
 }
 ```
 
-## OR finds the first truthy value
+## OR encuentra el primer valor verdadero
 
-The logic described above is somewhat classical. Now, let's bring in the "extra" features of JavaScript.
+La lógica descrita arriba es algo clásica. Ahora, vamos a traer las caracteristicas "extra" de JavaScript.
 
-The extended algorithm works as follows.
+El algoritmo extendido trabajo de la siguiente forma.
 
-Given multiple OR'ed values:
+Dado múltiples valores aplicados al operador OR:
 
 ```js
 result = value1 || value2 || value3;
 ```
 
-The OR `||` operator does the following:
+El operador OR `||` realiza lo siguiente:
 
-- Evaluates operands from left to right.
-- For each operand, converts it to boolean. If the result is `true`, stops and returns the original value of that operand.
-- If all operands have been evaluated (i.e. all were `false`), returns the last operand.
+-  Evalua los operandos de izquierda a derecha.
+-  Para cada operando, convierte el valor a booleano. Si el resultado es `true`, se detiene y retorna el valor orginal de ese operando.
+-  Si todos los operandos han sido evaluados (todos eran `false`), retorna el ultimo operando.
 
-A value is returned in its original form, without the conversion.
+Un valor es retornado en su forma original, sin la conversión.
 
-In other words, a chain of OR `"||"` returns the first truthy value or the last one if no such value is found.
+En otras palabras, una cadenade OR `"||"` retorna el primer valor verdadero o el último valor en caso de que dicho valor no sea encontrado.
 
-For instance:
+Por ejemplo:
 
 ```js run
-alert( 1 || 0 ); // 1 (1 is truthy)
-alert( true || 'no matter what' ); // (true is truthy)
+alert(1 || 0); // 1 (1 es un valor verdado)
+alert(true || "no matter what"); // (true es un valor verdadero)
 
-alert( null || 1 ); // 1 (1 is the first truthy value)
-alert( null || 0 || 1 ); // 1 (the first truthy value)
-alert( undefined || null || 0 ); // 0 (all falsy, returns the last value)
+alert(null || 1); // 1 (1 es el primer valor verdadero)
+alert(null || 0 || 1); // 1 (el primer valor verdadero)
+alert(undefined || null || 0); // 0 (todos son valores falsos, retorna el último valor)
 ```
 
-This leads to some interesting usage compared to a "pure, classical, boolean-only OR".
+Esto lleva a varios usos interesantes comparados a el "puro, clásico, solo booleanos OR".
 
-1. **Getting the first truthy value from a list of variables or expressions.**
+1. **Consiguiendo el primer valor verdadero de una lista de expresiones.**
 
-    Imagine we have several variables which can either contain data or be `null/undefined`. How can we find the first one with data?
+   Imagina que tenemos varias variables que pueden contener datos o ser `null/undefined`. ¿Comó podemos encontrar el primero valor con datos?
 
-    We can use OR `||`:
+   Podemos usar OR `||`:
 
-    ```js run
-    let currentUser = null;
-    let defaultUser = "John";
+   ```js run
+   let currentUser = null;
+   let defaultUser = "John";
 
-    *!*
-    let name = currentUser || defaultUser || "unnamed";
-    */!*
+   *!*
+   let name = currentUser || defaultUser || "sin nombre";
+   */!*
 
-    alert( name ); // selects "John" – the first truthy value
-    ```
+   alert( name ); // seleccioná "John" – el primer valor verdadero
+   ```
 
-    If both `currentUser` and `defaultUser` were falsy, `"unnamed"` would be the result.
-2. **Short-circuit evaluation.**
+   Si tanto `currentUser` como `defaultUser` eran valores falsos, `"sin nombre"` hubiera sido el resultado.
 
-    Operands can be not only values, but arbitrary expressions. OR evaluates and tests them from left to right. The evaluation stops when a truthy value is reached, and the value is returned. This process is called "a short-circuit evaluation" because it goes as short as possible from left to right.
+2. **Evaluación de cortocircuito.**
 
-    This is clearly seen when the expression given as the second argument has a side effect like a variable assignment.
+   Los operandos no solo pueden ser valors, si no que tambien expresiones arbitrarias. OR los evalua y comprueba de izquierda a derecha. La evaluación termina cuando un valor verdadero es alcanzado, y dicho valor es retornado. Este proceso es llamado "evaluación de cortocircuito" porque va lo más corto posible de izquierda a derecha.
 
-    In the example below, `x` does not get assigned:
+   Esto es claramente visto cuando una expresión dada como segundo argumento tiene un efecto secundario como una asignación de variable.
 
-    ```js run no-beautify
-    let x;
+   En el ejemplo debajo, `x` no es asignada:
 
-    *!*true*/!* || (x = 1);
+   ```js run no-beautify
+   let x;
 
-    alert(x); // undefined, because (x = 1) not evaluated
-    ```
+   *!*true*/!* || (x = 1);
 
-    If, instead, the first argument is `false`, `||` evaluates the second one, thus running the assignment:
+   alert(x); // undefined, porque (x = 1) no es evaluado.
+   ```
 
-    ```js run no-beautify
-    let x;
+   Si, en vez, el primer argumento fuera `false`, `||` evaluaria el segundo, por tanto corriendo el asignamiento.
 
-    *!*false*/!* || (x = 1);
+   ```js run no-beautify
+   let x;
 
-    alert(x); // 1
-    ```
+   *!*false*/!* || (x = 1);
 
-    An assignment is a simple case. Other side effects can also be involved.
+   alert(x); // 1
+   ```
 
-    As we can see, such a use case is a "shorter way of doing `if`". The first operand is converted to boolean. If it's false, the second one is evaluated.
+   Un asignamiento es un caso simple. Otros efectos secundarios tambien puede ser usados.
 
-    Most of time, it's better to use a "regular" `if` to keep the code easy to understand, but sometimes this can be handy.
+   Como podemos ver, tal caso de uso es una "manera más corta de usar `if`". El primer operando es convertido a booleano. Si y el primero es falso, el segundo sera evaluado.
+
+   La mayoría del tiempo, es mejor usar un `if` "normal" para mantener el código fácil de entender, pero a veces esto puede ser útil.
 
 ## && (AND)
 
-The AND operator is represented with two ampersands `&&`:
+El operador AND es representado con `&&`:
 
 ```js
 result = a && b;
 ```
 
-In classical programming, AND returns `true` if both operands are truthy and `false` otherwise:
+En la programación clasica, AND retorna `true` si ambos operandos son valores verdaderos o de otro caso valores falsos.
 
 ```js run
-alert( true && true );   // true
-alert( false && true );  // false
-alert( true && false );  // false
-alert( false && false ); // false
+alert(true && true); // true
+alert(false && true); // false
+alert(true && false); // false
+alert(false && false); // false
 ```
 
-An example with `if`:
+Un ejemplo con `if`:
 
 ```js run
 let hour = 12;
 let minute = 30;
 
 if (hour == 12 && minute == 30) {
-  alert( 'The time is 12:30' );
+	alert("La hora es 12:30");
 }
 ```
 
-Just as with OR, any value is allowed as an operand of AND:
+Tal y como con OR, cualquier valor es permitido como operando de AND: Just as with OR, any value is allowed as an operand of AND:
 
 ```js run
 if (1 && 0) { // evaluated as true && false
-  alert( "won't work, because the result is falsy" );
+  alert( "no funcionara, por que el resultado es un valor falso );
 }
 ```
 
+## AND encuentra el primer valor verdadero y lo retorna
 
-## AND finds the first falsy value
-
-Given multiple AND'ed values:
+Dado varios múltiples valores aplicados al operador AND:
 
 ```js
 result = value1 && value2 && value3;
 ```
 
-The AND `&&` operator does the following:
+El operador AND `&&` realiza lo siguiente:
 
-- Evaluates operands from left to right.
-- For each operand, converts it to a boolean. If the result is `false`, stops and returns the original value of that operand.
-- If all operands have been evaluated (i.e. all were truthy), returns the last operand.
+-  Evalua los operandos de izquierda a derecha.
+-  Para cada operando, los convierte a un booleano. Si el resultado es `false`, se detiene y retorna el valor original de dicho operando.
+-  Si todos los operandos han sido evaluados (todos fueron valores verdaderos), retorna el último operando.
 
-In other words, AND returns the first falsy value or the last value if none were found.
+En otras palabras, AND retorna el primer valor falso o el último valor si ninguno fue encontrado.
 
-The rules above are similar to OR. The difference is that AND returns the first *falsy* value while OR returns the first *truthy* one.
+Las reglas de arriba son similares a las de OR. La difierence es que AND retorna el primer valor _falso_ mientras que OR retorna el primer valor _verdadero_.
 
-Examples:
+Ejemplo:
 
 ```js run
-// if the first operand is truthy,
-// AND returns the second operand:
-alert( 1 && 0 ); // 0
-alert( 1 && 5 ); // 5
-
-// if the first operand is falsy,
-// AND returns it. The second operand is ignored
-alert( null && 5 ); // null
-alert( 0 && "no matter what" ); // 0
+// si el primer operando es un valor verdadero,
+// AND retorna el segundo operando:
+alert(1 && 0); // 0
+alert(1 && 5); // 5
+
+// si el primer operando es un valor falso,
+// AND lo retorna. El segundo operando es ignorado
+alert(null && 5); // null
+alert(0 && "no matter what"); // 0
 ```
 
-We can also pass several values in a row. See how the first falsy one is returned:
+Tambien podemos pasar varios valores en una fila. Observa como el primer valor falso es retornado: We can also pass several values in a row. See how the first falsy one is returned:
 
 ```js run
-alert( 1 && 2 && null && 3 ); // null
+alert(1 && 2 && null && 3); // null
 ```
 
-When all values are truthy, the last value is returned:
+Cuando todos los valores son verdaderos, el último valor es retornado:
 
 ```js run
-alert( 1 && 2 && 3 ); // 3, the last one
+alert(1 && 2 && 3); // 3, el último.
 ```
 
-````smart header="Precedence of AND `&&` is higher than OR `||`"
-The precedence of AND `&&` operator is higher than OR `||`.
+`` smart header="La precedencia de AND `&&` es mayor que la de OR `||`" La precedencia del operador AND `&&` es mayor que la de OR `|| ``.
 
-So the code `a && b || c && d` is essentially the same as if the `&&` expressions were in parentheses: `(a && b) || (c && d)`.
-````
+Asi que el código `a && b || c && d` es esensialmente el mismo que si la expresiones `&&` estuvieran en parentesis: `(a && b) || (c && d)`
 
-Just like OR, the AND `&&` operator can sometimes replace `if`.
+Just como en OR, el operador AND `&&` puede ser algunas vece remplazado por `if`.
 
-For instance:
+Por ejemplo:
 
 ```js run
 let x = 1;
 
-(x > 0) && alert( 'Greater than zero!' );
+x > 0 && alert("Mayor que cero!");
 ```
 
-The action in the right part of `&&` would execute only if the evaluation reaches it. That is, only if `(x > 0)` is true.
+La acción en la parte derecha de `&&` seria ejecutada solo si la evaluación la alcanza. Eso es, solo si `(x > 0)` que es verdadero.
 
-So we basically have an analogue for:
+Asi que basicamente tenemos un análogo para:
 
 ```js run
 let x = 1;
 
 if (x > 0) {
-  alert( 'Greater than zero!' );
+	alert("Mayor que cero!");
 }
 ```
 
-The variant with `&&` appears shorter. But `if` is more obvious and tends to be a little bit more readable.
+La variante con `&&` parece más corta. Pero `if` es más obvio y tiende a ser un poco más legible.
 
-So we recommend using every construct for its purpose: use `if` if we want if and use `&&` if we want AND.
+Asi que recomendamos usar cada construcción para su propósito: usa `if` si queremos if y usa `&&` si queremos AND. So we recommend using every construct for its purpose: use `if` if we want if and use `&&` if we want AND.
 
 ## ! (NOT)
 
-The boolean NOT operator is represented with an exclamation sign `!`.
+El operador booleano NOT es representado con un signo de exclamación `!`.
 
-The syntax is pretty simple:
+La sintaxis es bastante simple:
 
 ```js
 result = !value;
 ```
 
-The operator accepts a single argument and does the following:
+El operador acepta un solo argumento y realiza lo siguiente:
 
-1. Converts the operand to boolean type: `true/false`.
-2. Returns the inverse value.
+1. Convierte el operando al tipo booleano: `true/false`.
+2. Retorna el valor contrario.
 
-For instance:
+Por ejemplo:
 
 ```js run
-alert( !true ); // false
-alert( !0 ); // true
+alert(!true); // false
+alert(!0); // true
 ```
 
-A double NOT `!!` is sometimes used for converting a value to boolean type:
+Un doble NOT `!!` es a veces usado para convertir un valor al tipo booleano:
 
 ```js run
-alert( !!"non-empty string" ); // true
-alert( !!null ); // false
+alert(!!"cadena de texto no vacía"); // true
+alert(!!null); // false
 ```
 
-That is, the first NOT converts the value to boolean and returns the inverse, and the second NOT inverses it again. In the end, we have a plain value-to-boolean conversion.
+Eso es, el primer NOT convierte el valor a booleano y retorna el inverso, y el sgundo NOT lo invierte de nuevo. Al final, tenemos una simple conversión a booleano.
 
-There's a little more verbose way to do the same thing -- a built-in `Boolean` function:
+Hay una manera un poco mas verbosa de realizar lo mismo -- una función integrada `Boolean`:
 
 ```js run
-alert( Boolean("non-empty string") ); // true
-alert( Boolean(null) ); // false
+alert(Boolean("cadena de texto no vacía")); // true
+alert(Boolean(null)); // false
+```
+
+La precedencia de NOT `!` es la mayor de todos los operadores lógicos, asi que siempre se ejecuta primero, antes de `&&` o `||`.
+
 ```
 
-The precedence of NOT `!` is the highest of all logical operators, so it always executes first, before `&&` or `||`.
+```

From f1ab3cccb2ae234eeb209f47c3e41e1782aa5a24 Mon Sep 17 00:00:00 2001
From: Sjesc <silvinoje14@gmail.com>
Date: Thu, 16 May 2019 12:07:22 -0400
Subject: [PATCH 02/36] Fix small details

---
 .../11-logical-operators/article.md               | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/1-js/02-first-steps/11-logical-operators/article.md b/1-js/02-first-steps/11-logical-operators/article.md
index f01614b05..fae99d2e2 100644
--- a/1-js/02-first-steps/11-logical-operators/article.md
+++ b/1-js/02-first-steps/11-logical-operators/article.md
@@ -40,7 +40,7 @@ if (1 || 0) {
 }
 ```
 
-La mayoría del tiempo, OR `||` es usando como una declaración de `if` para probar si _cualqueria_ de las condiciones dadas son `true`
+La mayoría del tiempo, OR `||` es usando como una declaración de `if` para probar si *cualqueria* de las condiciones dadas son `true`
 
 Por ejemplo:
 
@@ -203,7 +203,7 @@ El operador AND `&&` realiza lo siguiente:
 
 En otras palabras, AND retorna el primer valor falso o el último valor si ninguno fue encontrado.
 
-Las reglas de arriba son similares a las de OR. La difierence es que AND retorna el primer valor _falso_ mientras que OR retorna el primer valor _verdadero_.
+Las reglas de arriba son similares a las de OR. La difierence es que AND retorna el primer valor *falso* mientras que OR retorna el primer valor *verdadero*.
 
 Ejemplo:
 
@@ -231,11 +231,14 @@ Cuando todos los valores son verdaderos, el último valor es retornado:
 alert(1 && 2 && 3); // 3, el último.
 ```
 
-`` smart header="La precedencia de AND `&&` es mayor que la de OR `||`" La precedencia del operador AND `&&` es mayor que la de OR `|| ``.
+```smart header="La precedencia de AND `&&` es mayor que la de OR `||`"
 
-Asi que el código `a && b || c && d` es esensialmente el mismo que si la expresiones `&&` estuvieran en parentesis: `(a && b) || (c && d)`
+La precedencia del operador AND `&&` es mayor que la de OR `|| ``.
 
-Just como en OR, el operador AND `&&` puede ser algunas vece remplazado por `if`.
+Así que el código `a && b || c && d` es esensialmente el mismo que si la expresiones `&&` estuvieran en parentesis: `(a && b) || (c && d)`
+```
+
+Justo como en OR, el operador AND `&&` puede ser algunas vece remplazado por `if`.
 
 Por ejemplo:
 
@@ -243,7 +246,7 @@ Por ejemplo:
 let x = 1;
 
 x > 0 && alert("Mayor que cero!");
-```
+````
 
 La acción en la parte derecha de `&&` seria ejecutada solo si la evaluación la alcanza. Eso es, solo si `(x > 0)` que es verdadero.
 

From 85b9fcd915c33d31c2fcbdbf2089f3463d671da4 Mon Sep 17 00:00:00 2001
From: Sjesc <silvinoje14@gmail.com>
Date: Thu, 16 May 2019 12:10:18 -0400
Subject: [PATCH 03/36] Translate string Fix typo

---
 1-js/02-first-steps/11-logical-operators/article.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/1-js/02-first-steps/11-logical-operators/article.md b/1-js/02-first-steps/11-logical-operators/article.md
index fae99d2e2..0aa4ae651 100644
--- a/1-js/02-first-steps/11-logical-operators/article.md
+++ b/1-js/02-first-steps/11-logical-operators/article.md
@@ -85,13 +85,13 @@ El operador OR `||` realiza lo siguiente:
 
 Un valor es retornado en su forma original, sin la conversión.
 
-En otras palabras, una cadenade OR `"||"` retorna el primer valor verdadero o el último valor en caso de que dicho valor no sea encontrado.
+En otras palabras, una cadena de OR `"||"` retorna el primer valor verdadero o el último valor en caso de que dicho valor no sea encontrado.
 
 Por ejemplo:
 
 ```js run
 alert(1 || 0); // 1 (1 es un valor verdado)
-alert(true || "no matter what"); // (true es un valor verdadero)
+alert(true || "sin importar que"); // (true es un valor verdadero)
 
 alert(null || 1); // 1 (1 es el primer valor verdadero)
 alert(null || 0 || 1); // 1 (el primer valor verdadero)

From 865f4e762325146f6ccb93fbe3b003405f2be4d0 Mon Sep 17 00:00:00 2001
From: Tomas Scandalitta <38343557+tscandalitta@users.noreply.github.com>
Date: Sat, 18 May 2019 01:54:55 -0300
Subject: [PATCH 04/36] fixes

---
 .../11-logical-operators/article.md           | 79 +++++++++----------
 1 file changed, 39 insertions(+), 40 deletions(-)

diff --git a/1-js/02-first-steps/11-logical-operators/article.md b/1-js/02-first-steps/11-logical-operators/article.md
index 0aa4ae651..343c25991 100644
--- a/1-js/02-first-steps/11-logical-operators/article.md
+++ b/1-js/02-first-steps/11-logical-operators/article.md
@@ -2,23 +2,23 @@
 
 Hay tres operadores lógicos en JavaScript: `||` (OR (O)), `&&` (AND (Y)), `!` (NOT (NO)).
 
-Aun que sean llamados lógicos, pueden ser aplicados a valores de cualquier tipo, no solo booleanos. El resultado también puede ser de cualquier tipo.
+Aunque sean llamados lógicos, pueden ser aplicados a valores de cualquier tipo, no solo booleanos. El resultado también puede ser de cualquier tipo.
 
 Veamos los detalles.
 
 ## || (OR)
 
-El operador `OR` es represtando con dos simbolos de linea verticales:
+El operador `OR` se representa con dos simbolos de linea vertical:
 
 ```js
 result = a || b;
 ```
 
-En la programación clasica, el OR lógico esta pensado para manipular solo valore booleanos. Si cualquiera de sus argumentos son `true`, retornara `true`, de lo contrario retornara `false`.
+En la programación clasica, el OR lógico esta pensado para manipular solo valores booleanos. Si cualquiera de sus argumentos es `true`, retorna `true`, de lo contrario retorna `false`.
 
-En JavaScript, el operador es un poco más complicado y poderoso. Pero primero, veamos que pasa con los valores booleanos.
+En JavaScript, el operador es un poco más complicado y poderoso. Pero primero, veamos qué pasa con los valores booleanos.
 
-Hay cuatro posibles combinaciones lógicas:
+Hay cuatro combinaciones lógicas posibles:
 
 ```js run
 alert(true || true); // true (verdadero)
@@ -27,20 +27,19 @@ alert(true || false); // true
 alert(false || false); // false (falso)
 ```
 
-Como podemos ver, los resultados son siempre `true` excepto en el caso de que ambos operandos sean `false`
+Como podemos ver, los resultados son siempre `true` excepto cuando ambos operandos son `false`.
 
-Si un operando no es un booleano, entonces es convertido a un booleano para la evaluación.
+Si un operando no es un booleano, se lo convierte a booleano para la evaluación.
 
 Por ejemplo, el número `1` es tratado como `true`, el número `0` como `false`:
 
 ```js run
-if (1 || 0) {
-	// Funciona como if( true || false )
+if (1 || 0) { // Funciona como if( true || false )
 	alert("valor verdadero!");
 }
 ```
 
-La mayoría del tiempo, OR `||` es usando como una declaración de `if` para probar si *cualqueria* de las condiciones dadas son `true`
+La mayoría de las veces, OR `||` es usado en una declaración `if` para probar si *cualquiera* de las condiciones dadas es `true`.
 
 Por ejemplo:
 
@@ -61,15 +60,15 @@ let hour = 12;
 let isWeekend = true;
 
 if (hour < 10 || hour > 18 || isWeekend) {
-	alert("La oficina esta cerrada."); // Esta los fines de semana
+	alert("La oficina esta cerrada."); // Es fin de semana
 }
 ```
 
 ## OR encuentra el primer valor verdadero
 
-La lógica descrita arriba es algo clásica. Ahora, vamos a traer las caracteristicas "extra" de JavaScript.
+La lógica descrita arriba es algo clásica. Ahora, mostremos las características "extra" de JavaScript.
 
-El algoritmo extendido trabajo de la siguiente forma.
+El algoritmo extendido trabaja de la siguiente forma.
 
 Dado múltiples valores aplicados al operador OR:
 
@@ -91,18 +90,18 @@ Por ejemplo:
 
 ```js run
 alert(1 || 0); // 1 (1 es un valor verdado)
-alert(true || "sin importar que"); // (true es un valor verdadero)
+alert(true || "cualquier valor"); // (true es un valor verdadero)
 
 alert(null || 1); // 1 (1 es el primer valor verdadero)
 alert(null || 0 || 1); // 1 (el primer valor verdadero)
 alert(undefined || null || 0); // 0 (todos son valores falsos, retorna el último valor)
 ```
 
-Esto lleva a varios usos interesantes comparados a el "puro, clásico, solo booleanos OR".
+Esto brinda varios usos interesantes comparados al "OR puro, clásico, de solo booleanos".
 
-1. **Consiguiendo el primer valor verdadero de una lista de expresiones.**
+1. **Consiguiendo el primer valor verdadero de una lista de variables o expresiones.**
 
-   Imagina que tenemos varias variables que pueden contener datos o ser `null/undefined`. ¿Comó podemos encontrar el primero valor con datos?
+   Imagina que tenemos múltiples variables que pueden contener datos o ser `null/undefined`. ¿Cómo podemos encontrar el primer valor que contenga datos?
 
    Podemos usar OR `||`:
 
@@ -114,16 +113,16 @@ Esto lleva a varios usos interesantes comparados a el "puro, clásico, solo bool
    let name = currentUser || defaultUser || "sin nombre";
    */!*
 
-   alert( name ); // seleccioná "John" – el primer valor verdadero
+   alert( name ); // selecciona "John" – el primer valor verdadero
    ```
 
-   Si tanto `currentUser` como `defaultUser` eran valores falsos, `"sin nombre"` hubiera sido el resultado.
+   Si tanto `currentUser` como `defaultUser` hubieran sido valores falsos, `"sin nombre"` hubiera sido el resultado.
 
 2. **Evaluación de cortocircuito.**
 
-   Los operandos no solo pueden ser valors, si no que tambien expresiones arbitrarias. OR los evalua y comprueba de izquierda a derecha. La evaluación termina cuando un valor verdadero es alcanzado, y dicho valor es retornado. Este proceso es llamado "evaluación de cortocircuito" porque va lo más corto posible de izquierda a derecha.
+   Los operandos no solo pueden ser valores, sino que tambien expresiones arbitrarias. OR los evalua y comprueba de izquierda a derecha. La evaluación termina cuando un valor verdadero es alcanzado, y dicho valor es retornado. Este proceso es llamado "evaluación de cortocircuito" porque avanza lo menos posible de izquierda a derecha.
 
-   Esto es claramente visto cuando una expresión dada como segundo argumento tiene un efecto secundario como una asignación de variable.
+   Esto se ve claramente cuando la expresión dada como segundo argumento tiene un efecto secundario como una asignación de variable.
 
    En el ejemplo debajo, `x` no es asignada:
 
@@ -135,7 +134,7 @@ Esto lleva a varios usos interesantes comparados a el "puro, clásico, solo bool
    alert(x); // undefined, porque (x = 1) no es evaluado.
    ```
 
-   Si, en vez, el primer argumento fuera `false`, `||` evaluaria el segundo, por tanto corriendo el asignamiento.
+   Si, en cambio, el primer argumento fuera `false`, `||` evaluaría el segundo, realizando la asignación.
 
    ```js run no-beautify
    let x;
@@ -145,11 +144,11 @@ Esto lleva a varios usos interesantes comparados a el "puro, clásico, solo bool
    alert(x); // 1
    ```
 
-   Un asignamiento es un caso simple. Otros efectos secundarios tambien puede ser usados.
+   Una asignación es un caso simple. Puede haber efectos secundarios, los cuales no se notarán si la evaluación no los alcanza.
 
-   Como podemos ver, tal caso de uso es una "manera más corta de usar `if`". El primer operando es convertido a booleano. Si y el primero es falso, el segundo sera evaluado.
+   Como podemos ver, tal caso de uso es una "manera más corta de usar `if`". El primer operando es convertido a booleano. Si el primero es falso, el segundo sera evaluado.
 
-   La mayoría del tiempo, es mejor usar un `if` "normal" para mantener el código fácil de entender, pero a veces esto puede ser útil.
+   La mayor parte del tiempo, es mejor usar un `if` "normal" para mantener el código fácil de entender, pero a veces esto puede ser útil.
 
 ## && (AND)
 
@@ -159,7 +158,7 @@ El operador AND es representado con `&&`:
 result = a && b;
 ```
 
-En la programación clasica, AND retorna `true` si ambos operandos son valores verdaderos o de otro caso valores falsos.
+En la programación clasica, AND retorna `true` si ambos operandos son valores verdaderos y falso en cualquier otro caso.
 
 ```js run
 alert(true && true); // true
@@ -179,17 +178,17 @@ if (hour == 12 && minute == 30) {
 }
 ```
 
-Tal y como con OR, cualquier valor es permitido como operando de AND: Just as with OR, any value is allowed as an operand of AND:
+Al igual que con OR, cualquier valor es permitido como operando de AND: 
 
 ```js run
-if (1 && 0) { // evaluated as true && false
-  alert( "no funcionara, por que el resultado es un valor falso );
+if (1 && 0) { // evaluado como true && false
+  alert( "no funcionará porque el resultado es un valor falso" );
 }
 ```
 
-## AND encuentra el primer valor verdadero y lo retorna
+## AND encuentra el primer valor verdadero
 
-Dado varios múltiples valores aplicados al operador AND:
+Dado múltiples valores aplicados al operador AND:
 
 ```js
 result = value1 && value2 && value3;
@@ -203,7 +202,7 @@ El operador AND `&&` realiza lo siguiente:
 
 En otras palabras, AND retorna el primer valor falso o el último valor si ninguno fue encontrado.
 
-Las reglas de arriba son similares a las de OR. La difierence es que AND retorna el primer valor *falso* mientras que OR retorna el primer valor *verdadero*.
+Las reglas anteriores son similares a las de OR. La difierence es que AND retorna el primer valor *falso* mientras que OR retorna el primer valor *verdadero*.
 
 Ejemplo:
 
@@ -216,10 +215,10 @@ alert(1 && 5); // 5
 // si el primer operando es un valor falso,
 // AND lo retorna. El segundo operando es ignorado
 alert(null && 5); // null
-alert(0 && "no matter what"); // 0
+alert(0 && "cualquier valor"); // 0
 ```
 
-Tambien podemos pasar varios valores en una fila. Observa como el primer valor falso es retornado: We can also pass several values in a row. See how the first falsy one is returned:
+También podemos pasar varios valores de una vez. Observa como el primer valor falso es retornado: 
 
 ```js run
 alert(1 && 2 && null && 3); // null
@@ -233,12 +232,12 @@ alert(1 && 2 && 3); // 3, el último.
 
 ```smart header="La precedencia de AND `&&` es mayor que la de OR `||`"
 
-La precedencia del operador AND `&&` es mayor que la de OR `|| ``.
+La precedencia del operador AND `&&` es mayor que la de OR `||`.
 
-Así que el código `a && b || c && d` es esensialmente el mismo que si la expresiones `&&` estuvieran en parentesis: `(a && b) || (c && d)`
+Así que el código `a && b || c && d` es básicamente el mismo que si la expresiones `&&` estuvieran entre paréntesis: `(a && b) || (c && d)`
 ```
 
-Justo como en OR, el operador AND `&&` puede ser algunas vece remplazado por `if`.
+Justo como en OR, el operador AND `&&` puede reemplazar en ocasiones al `if`.
 
 Por ejemplo:
 
@@ -248,9 +247,9 @@ let x = 1;
 x > 0 && alert("Mayor que cero!");
 ````
 
-La acción en la parte derecha de `&&` seria ejecutada solo si la evaluación la alcanza. Eso es, solo si `(x > 0)` que es verdadero.
+La acción en la parte derecha de `&&` sería ejecutada sólo si la evaluación la alcanza. Eso es, solo si `(x > 0)` es verdadero.
 
-Asi que basicamente tenemos un análogo para:
+Así que básicamente tenemos un análogo para:
 
 ```js run
 let x = 1;
@@ -262,7 +261,7 @@ if (x > 0) {
 
 La variante con `&&` parece más corta. Pero `if` es más obvio y tiende a ser un poco más legible.
 
-Asi que recomendamos usar cada construcción para su propósito: usa `if` si queremos if y usa `&&` si queremos AND. So we recommend using every construct for its purpose: use `if` if we want if and use `&&` if we want AND.
+Así que recomendamos usar cada construcción para su propósito: usar `if` si queremos if y usar `&&` si queremos AND.
 
 ## ! (NOT)
 

From ec93c162d619115d5a5927c9135f7dd46a21489b Mon Sep 17 00:00:00 2001
From: Tomas Scandalitta <38343557+tscandalitta@users.noreply.github.com>
Date: Sun, 19 May 2019 21:02:10 -0300
Subject: [PATCH 05/36] fix 2

---
 1-js/02-first-steps/11-logical-operators/article.md | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/1-js/02-first-steps/11-logical-operators/article.md b/1-js/02-first-steps/11-logical-operators/article.md
index 343c25991..f63ca6d88 100644
--- a/1-js/02-first-steps/11-logical-operators/article.md
+++ b/1-js/02-first-steps/11-logical-operators/article.md
@@ -265,7 +265,7 @@ Así que recomendamos usar cada construcción para su propósito: usar `if` si q
 
 ## ! (NOT)
 
-El operador booleano NOT es representado con un signo de exclamación `!`.
+El operador booleano NOT se representa con un signo de exclamación `!`.
 
 La sintaxis es bastante simple:
 
@@ -292,9 +292,9 @@ alert(!!"cadena de texto no vacía"); // true
 alert(!!null); // false
 ```
 
-Eso es, el primer NOT convierte el valor a booleano y retorna el inverso, y el sgundo NOT lo invierte de nuevo. Al final, tenemos una simple conversión a booleano.
+Eso es, el primer NOT convierte el valor a booleano y retorna el inverso, y el segundo NOT lo invierte de nuevo. Al final, tenemos una simple conversión a booleano.
 
-Hay una manera un poco mas verbosa de realizar lo mismo -- una función integrada `Boolean`:
+Hay una manera un poco mas prolija de realizar lo mismo -- una función integrada `Boolean`:
 
 ```js run
 alert(Boolean("cadena de texto no vacía")); // true
@@ -303,6 +303,3 @@ alert(Boolean(null)); // false
 
 La precedencia de NOT `!` es la mayor de todos los operadores lógicos, asi que siempre se ejecuta primero, antes de `&&` o `||`.
 
-```
-
-```

From b109d94b375a6c14aa1145ac6edf536369275d14 Mon Sep 17 00:00:00 2001
From: Tomas Scandalitta <38343557+tscandalitta@users.noreply.github.com>
Date: Sun, 19 May 2019 21:14:07 -0300
Subject: [PATCH 06/36] fix 3

---
 .../11-logical-operators/1-alert-null-2-undefined/task.md       | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/task.md b/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/task.md
index 5988c96d3..49b2a56bd 100644
--- a/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/task.md
+++ b/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/task.md
@@ -4,7 +4,7 @@ importance: 5
 
 # ¿Cuál es el resultado de OR?
 
-¿Qué va a imprimir el codigo debajo?
+¿Cuál será la salida del siguiente código?
 
 ```js
 alert(null || 2 || undefined);

From 335ce5ff680dbab214f7db170bb4232d09fd43e2 Mon Sep 17 00:00:00 2001
From: Tomas Scandalitta <38343557+tscandalitta@users.noreply.github.com>
Date: Sun, 19 May 2019 21:21:22 -0300
Subject: [PATCH 07/36] fix 4

---
 .../11-logical-operators/2-alert-or/solution.md      | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/1-js/02-first-steps/11-logical-operators/2-alert-or/solution.md b/1-js/02-first-steps/11-logical-operators/2-alert-or/solution.md
index c77908380..e7ef801f5 100644
--- a/1-js/02-first-steps/11-logical-operators/2-alert-or/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/2-alert-or/solution.md
@@ -1,13 +1,13 @@
-La repuesta: primero `1`, y entonces `2`.
+La repuesta: primero `1`, después `2`.
 
 ```js run
-alert(alert(1) || 2 || alert(3));
+alert( alert(1) || 2 || alert(3) );
 ```
 
 La llamada a `alert` no retorna un valor. O, en otras palabras, retorna `undefined`.
 
-1. El primer OR `||` evaluá su operando a la izquierda `alert(1)`. Eso muestra el primer mensaje con `1`.
-2. El `alert` retorna `undefined`, asi que OR va hacia el segundo operando buscando un valor verdadero.
-3. El segundo operando `2` es un valor verdadero, asi que la ejecución es detenida, `2` es retornado y mostrado por la alerta exterior.
+1. El primer OR `||` evalua el operando de la izquierda `alert(1)`. Eso muestra el primer mensaje con `1`.
+2. El `alert` retorna `undefined`, por lo que OR se dirige al segundo operando buscando un valor verdadero.
+3. El segundo operando `2` es un valor verdadero, por lo que se detiene la ejecución, se retorna `2` y es mostrado por el alert exterior.
 
-No va a haber `3`, porque la evaluación no alcanza a `alert(3)`.
+No habrá `3` debido a que la evaluación no alcanza a `alert(3)`.

From 0bac3ae48452242afaf47650df9b7cb37a22dd6c Mon Sep 17 00:00:00 2001
From: Tomas Scandalitta <38343557+tscandalitta@users.noreply.github.com>
Date: Sun, 19 May 2019 21:23:04 -0300
Subject: [PATCH 08/36] fix 5

---
 1-js/02-first-steps/11-logical-operators/2-alert-or/task.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/1-js/02-first-steps/11-logical-operators/2-alert-or/task.md b/1-js/02-first-steps/11-logical-operators/2-alert-or/task.md
index d8d35c119..804461453 100644
--- a/1-js/02-first-steps/11-logical-operators/2-alert-or/task.md
+++ b/1-js/02-first-steps/11-logical-operators/2-alert-or/task.md
@@ -4,8 +4,8 @@ importance: 3
 
 # ¿Cuál es el resultado de las alertas aplicadas al operador OR?
 
-¿Qué va a imprimir el codigo debajo?
+¿Cuál será la salida del siguiente código?
 
 ```js
-alert(alert(1) || 2 || alert(3));
+alert( alert(1) || 2 || alert(3) );
 ```

From b7f27dc35a83fabbe2b10cca7d5f2148d37d2b59 Mon Sep 17 00:00:00 2001
From: Tomas Scandalitta <38343557+tscandalitta@users.noreply.github.com>
Date: Sun, 19 May 2019 21:24:33 -0300
Subject: [PATCH 09/36] Update solution.md

---
 .../11-logical-operators/3-alert-1-null-2/solution.md          | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/solution.md b/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/solution.md
index 4a0e0823e..0af868958 100644
--- a/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/solution.md
@@ -1,5 +1,6 @@
 La respuesta: `null`, porque es el primer valor falso de la lista.
 
 ```js run
-alert(1 && null && 2);
+alert( 1 && null && 2 );
 ```
+

From 6d0f0a6efef094907d83fe0da3e147fa9c1de538 Mon Sep 17 00:00:00 2001
From: Tomas Scandalitta <38343557+tscandalitta@users.noreply.github.com>
Date: Sun, 19 May 2019 21:25:33 -0300
Subject: [PATCH 10/36] Update task.md

---
 .../11-logical-operators/3-alert-1-null-2/task.md            | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/task.md b/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/task.md
index 86d017b44..910a417e0 100644
--- a/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/task.md
+++ b/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/task.md
@@ -4,8 +4,9 @@ importance: 5
 
 # ¿Cuál es el resultado de AND?
 
-¿Qué va a imprimir el codigo debajo?
+¿Cuál será la salida del siguiente código?
 
 ```js
-alert(1 && null && 2);
+alert( 1 && null && 2 );
 ```
+

From 885c3fed15cb32131bfaa8816323ba2ae071bef9 Mon Sep 17 00:00:00 2001
From: Tomas Scandalitta <38343557+tscandalitta@users.noreply.github.com>
Date: Sun, 19 May 2019 21:30:28 -0300
Subject: [PATCH 11/36] Update solution.md

---
 .../11-logical-operators/4-alert-and/solution.md          | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/1-js/02-first-steps/11-logical-operators/4-alert-and/solution.md b/1-js/02-first-steps/11-logical-operators/4-alert-and/solution.md
index a4b90f400..a0b0e083e 100644
--- a/1-js/02-first-steps/11-logical-operators/4-alert-and/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/4-alert-and/solution.md
@@ -1,9 +1,9 @@
-La respuesta: `1` y entonces `undefined`.
+La respuesta: `1` y después `undefined`.
 
 ```js run
-alert(alert(1) && alert(2));
+alert( alert(1) && alert(2) );
 ```
 
-La llamada a `alert`retorna `undefined` (solo muestra un mensaje, asi que no hay un valor que retornar significante)
+La llamada a `alert` retorna `undefined` (solo muestra un mensaje, asi que no hay un valor que retornar relevante)
 
-Debido a ello, `&&` evaluá el operando a la izquierda (imprime `1`), e inmediatamente se detiene, porque `undefined` es un valor falso. Y `&&` busca un valor falso y lo retorna, asi que ya está hecho.
+Debido a ello, `&&` evalua el operando de la izquierda (imprime `1`) e inmediatamente se detiene porque `undefined` es un valor falso. Como `&&` busca un valor falso y lo retorna, ya está.

From e306baec8baefd41d493502db259c7a4bdc8f337 Mon Sep 17 00:00:00 2001
From: Tomas Scandalitta <38343557+tscandalitta@users.noreply.github.com>
Date: Sun, 19 May 2019 21:31:42 -0300
Subject: [PATCH 12/36] Update task.md

---
 1-js/02-first-steps/11-logical-operators/4-alert-and/task.md | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/1-js/02-first-steps/11-logical-operators/4-alert-and/task.md b/1-js/02-first-steps/11-logical-operators/4-alert-and/task.md
index fd4847bd0..e3c318884 100644
--- a/1-js/02-first-steps/11-logical-operators/4-alert-and/task.md
+++ b/1-js/02-first-steps/11-logical-operators/4-alert-and/task.md
@@ -4,8 +4,9 @@ importance: 3
 
 # ¿Cuál es el resultado de las alertas aplicadas al operador AND?
 
-¿Qué va a imprimir el codigo debajo?
+¿Cuál será la salida del siguiente código?
 
 ```js
-alert(alert(1) && alert(2));
+alert( alert(1) && alert(2) );
 ```
+

From 05c8fa6838387be9247350e9e3494ef3e6469cf5 Mon Sep 17 00:00:00 2001
From: Tomas Scandalitta <38343557+tscandalitta@users.noreply.github.com>
Date: Sun, 19 May 2019 21:32:42 -0300
Subject: [PATCH 13/36] Update solution.md

---
 .../11-logical-operators/5-alert-and-or/solution.md         | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/1-js/02-first-steps/11-logical-operators/5-alert-and-or/solution.md b/1-js/02-first-steps/11-logical-operators/5-alert-and-or/solution.md
index 818d4fd33..92d6fef5f 100644
--- a/1-js/02-first-steps/11-logical-operators/5-alert-and-or/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/5-alert-and-or/solution.md
@@ -1,15 +1,15 @@
 La respuesta: `3`.
 
 ```js run
-alert(null || (2 && 3) || 4);
+alert( null || 2 && 3 || 4 );
 ```
 
 La precedencia de AND `&&` es mayor que la de `||`, asi que se ejecuta primero.
 
-El resultado de `2 && 3 = 3`, asi que la expresión se convierte en:
+El resultado de `2 && 3 = 3`, por lo que la expresión se convierte en:
 
 ```
 null || 3 || 4
 ```
 
-Ahora el resultado sera el primer valor verdadero: `3`.
+Ahora el resultado será el primer valor verdadero: `3`.

From 1a7bb8a14d48b41d3e197885df9b7a241e96e215 Mon Sep 17 00:00:00 2001
From: Tomas Scandalitta <38343557+tscandalitta@users.noreply.github.com>
Date: Sun, 19 May 2019 21:33:12 -0300
Subject: [PATCH 14/36] Update task.md

---
 .../11-logical-operators/5-alert-and-or/task.md              | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/1-js/02-first-steps/11-logical-operators/5-alert-and-or/task.md b/1-js/02-first-steps/11-logical-operators/5-alert-and-or/task.md
index a92f6691e..2e97e602a 100644
--- a/1-js/02-first-steps/11-logical-operators/5-alert-and-or/task.md
+++ b/1-js/02-first-steps/11-logical-operators/5-alert-and-or/task.md
@@ -4,8 +4,9 @@ importance: 5
 
 # El resultado de OR AND OR
 
-¿Cuál sera el resultado?
+¿Cuál será el resultado?
 
 ```js
-alert(null || (2 && 3) || 4);
+alert( null || 2 && 3 || 4 );
 ```
+

From 682cda529035bf433d6c79432cfdc4f6c540cb2d Mon Sep 17 00:00:00 2001
From: Tomas Scandalitta <38343557+tscandalitta@users.noreply.github.com>
Date: Sun, 19 May 2019 21:35:30 -0300
Subject: [PATCH 15/36] Update task.md

---
 .../11-logical-operators/6-check-if-in-range/task.md          | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/1-js/02-first-steps/11-logical-operators/6-check-if-in-range/task.md b/1-js/02-first-steps/11-logical-operators/6-check-if-in-range/task.md
index b3765e6c7..2f7fe0b8e 100644
--- a/1-js/02-first-steps/11-logical-operators/6-check-if-in-range/task.md
+++ b/1-js/02-first-steps/11-logical-operators/6-check-if-in-range/task.md
@@ -4,6 +4,6 @@ importance: 3
 
 # Comprueba el rango entre ellos
 
-Escribe una condición "if" para comprobar que `age`(edad) esta entre `14` y `90` inclusivemente.
+Escribe una condición "if" para comprobar que `age`(edad) está entre `14` y `90` inclusivamente.
 
-"Inclusivemente" significa que `age` puede llegar a ser uno de los extremos, `14` o `90`
+"Inclusivamente" significa que `age` puede llegar a ser uno de los extremos, `14` o `90`.

From a2fac86bff1770a4d10084a4aebfb62c24537b72 Mon Sep 17 00:00:00 2001
From: Tomas Scandalitta <38343557+tscandalitta@users.noreply.github.com>
Date: Sun, 19 May 2019 21:35:47 -0300
Subject: [PATCH 16/36] Update solution.md

---
 .../11-logical-operators/7-check-if-out-range/solution.md        | 1 +
 1 file changed, 1 insertion(+)

diff --git a/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/solution.md b/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/solution.md
index 35a1ba906..dd8c08364 100644
--- a/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/solution.md
@@ -9,3 +9,4 @@ La segunda variante:
 ```js
 if (age < 14 || age > 90)
 ```
+

From 7f940f131ba6a83e71e5e6b0f86194e8e4a00f19 Mon Sep 17 00:00:00 2001
From: Tomas Scandalitta <38343557+tscandalitta@users.noreply.github.com>
Date: Sun, 19 May 2019 21:38:00 -0300
Subject: [PATCH 17/36] Update task.md

---
 .../11-logical-operators/7-check-if-out-range/task.md         | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/task.md b/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/task.md
index b6b328295..c97e08312 100644
--- a/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/task.md
+++ b/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/task.md
@@ -2,8 +2,8 @@ importance: 3
 
 ---
 
-# Comprueba el rango al exterior
+# Comprueba el rango por fuera
 
-Escribe una condición `if` para comprobar que `age` NO esta entre 14 y 90 inclusivemente.
+Escribe una condición `if` para comprobar que `age` NO está entre 14 y 90 inclusivemente.
 
 Crea dos variantes: la primera usando NOT `!`, y la segunda -- sin usarlo.

From 36c1b7d01e8deba03e571d00f58b057b457f4b96 Mon Sep 17 00:00:00 2001
From: Tomas Scandalitta <38343557+tscandalitta@users.noreply.github.com>
Date: Sun, 19 May 2019 21:39:49 -0300
Subject: [PATCH 18/36] Update solution.md

---
 .../11-logical-operators/8-if-question/solution.md        | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/1-js/02-first-steps/11-logical-operators/8-if-question/solution.md b/1-js/02-first-steps/11-logical-operators/8-if-question/solution.md
index 2017fa0dd..542624637 100644
--- a/1-js/02-first-steps/11-logical-operators/8-if-question/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/8-if-question/solution.md
@@ -5,15 +5,15 @@ Detalles:
 ```js run
 // Corre.
 // El resultado de -1 || 0 = -1, valor verdadero
-if (-1 || 0) alert("primero");
+if (-1 || 0) alert( "primero" );
 
 // No corre.
 // -1 && 0 = 0, valor falso
-if (-1 && 0) alert("segundo");
+if (-1 && 0) alert( "segundo" );
 
 // Se ejecuta
 // El operador && tiene mayor precedencia que ||
-// Asi que -1 && 1 se ejecuta primero, dandonos la cadena:
+// Así que -1 && 1 se ejecuta primero, dándonos la cadena:
 // null || -1 && 1  ->  null || 1  ->  1
-if (null || (-1 && 1)) alert("tercero");
+if (null || -1 && 1) alert( "tercero" );
 ```

From 32b47447d6fc42fc81b507ee215832c695dce1b4 Mon Sep 17 00:00:00 2001
From: Tomas Scandalitta <38343557+tscandalitta@users.noreply.github.com>
Date: Sun, 19 May 2019 21:40:58 -0300
Subject: [PATCH 19/36] Update task.md

---
 .../11-logical-operators/8-if-question/task.md        | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/1-js/02-first-steps/11-logical-operators/8-if-question/task.md b/1-js/02-first-steps/11-logical-operators/8-if-question/task.md
index 4aeac7790..c27278f0a 100644
--- a/1-js/02-first-steps/11-logical-operators/8-if-question/task.md
+++ b/1-js/02-first-steps/11-logical-operators/8-if-question/task.md
@@ -4,12 +4,13 @@ importance: 5
 
 # Un pregunta acerca de "if"
 
-¿Cualés de estos `alert`s va a ejecutarse?
+¿Cuáles de estos `alert`s va a ejecutarse?
 
-¿Cualés van a ser los resultados de las expresiones dentro de `if(...)`?
+¿Cuáles serán los resultados de las expresiones dentro de `if(...)`?
 
 ```js
-if (-1 || 0) alert("first");
-if (-1 && 0) alert("second");
-if (null || (-1 && 1)) alert("third");
+if (-1 || 0) alert( "first" );
+if (-1 && 0) alert( "second" );
+if (null || -1 && 1) alert( "third" );
 ```
+

From 4b8c0a6f761b92168c0240d1e8a2f42341052ca0 Mon Sep 17 00:00:00 2001
From: Tomas Scandalitta <38343557+tscandalitta@users.noreply.github.com>
Date: Sun, 19 May 2019 21:44:51 -0300
Subject: [PATCH 20/36] Update solution.md

---
 .../9-check-login/solution.md                   | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

diff --git a/1-js/02-first-steps/11-logical-operators/9-check-login/solution.md b/1-js/02-first-steps/11-logical-operators/9-check-login/solution.md
index 2ac737471..687a4e0e9 100644
--- a/1-js/02-first-steps/11-logical-operators/9-check-login/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/9-check-login/solution.md
@@ -1,21 +1,24 @@
+
+
 ```js run demo
-let userName = prompt("Quién esta alli?", "");
+let userName = prompt("Quién está ahí?", "");
 
 if (userName == "Admin") {
+
 	let pass = prompt("Contraseña?", "");
 
 	if (pass == "TheMaster") {
-		alert("Bienvenido!");
+		alert( "Bienvenido!" );
 	} else if (pass == "" || pass == null) {
-		alert("Cancelado.");
+		alert( "Cancelado." );
 	} else {
-		alert("Contraseña incorrecta");
+		alert( "Contraseña incorrecta" );
 	}
 } else if (userName == "" || userName == null) {
-	alert("Canceledo");
+	alert( "Canceledo" );
 } else {
-	alert("No te conozco");
+	alert( "No te conozco" );
 }
 ```
 
-Nota las sangrías verticales dentro de los bloques `if`. Tecnicamente no son necesarias, pero facilitan la redacción del código.
+Nota las sangrías verticales dentro de los bloques `if`. Técnicamente no son necesarias, pero facilitan la lectura del código.

From 9c17870b01c124767e5658a9a595322626798a55 Mon Sep 17 00:00:00 2001
From: Tomas Scandalitta <38343557+tscandalitta@users.noreply.github.com>
Date: Sun, 19 May 2019 21:48:07 -0300
Subject: [PATCH 21/36] Update task.md

---
 .../11-logical-operators/9-check-login/task.md            | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/1-js/02-first-steps/11-logical-operators/9-check-login/task.md b/1-js/02-first-steps/11-logical-operators/9-check-login/task.md
index ad9681f0a..cf5fe5e30 100644
--- a/1-js/02-first-steps/11-logical-operators/9-check-login/task.md
+++ b/1-js/02-first-steps/11-logical-operators/9-check-login/task.md
@@ -6,11 +6,11 @@ importance: 3
 
 Escribe un código que pregunte por el inicio de sesión con `propmt`.
 
-Si el visitante ingresa `Admin`, entonces `prompt`(pregunta) por una contraseña, si la entrada es una linea vacía o `key:Esc` -- muestra "Cancelado.", si es otra cadena de texto -- entonces muestra "No te conozco".
+Si el visitante ingresa `"Admin"`, entonces `prompt`(pregunta) por una contraseña, si la entrada es una linea vacía o `key:Esc` -- muestra "Cancelado.", si es otra cadena de texto -- entonces muestra "No te conozco".
 
-La contraseña es comprobada así:
+La contraseña se comprueba así:
 
--  Si iguala a "TheMaster", entonces muestra "Bienvenido!",
+-  Si es igual a "TheMaster", entonces muestra "Bienvenido!",
 -  Si es otra cadena de texto -- muetra "Contraseña incorrecta",
 -  Para una cadena de texto vacía o una entrada cancelada, muestra "Cancelado."
 
@@ -20,6 +20,6 @@ El esquema:
 
 Por favor usa bloques anidados de `if`. Piensa en la legibilidad general del código.
 
-Pista: pasando una entrada vacía a un prompt retorna una cadena de texto vacía `''`. Presionando `key:ESC` durante un prompt retorna `null`.
+Pista: si se le pasa una entrada vacía a un prompt, retorna una cadena de texto vacía `''`. Presionando `key:ESC` durante un prompt retorna `null`.
 
 [demo]

From 847d5f5ac95736939cb77a9921261bf6a1027dc4 Mon Sep 17 00:00:00 2001
From: Tomas Scandalitta <38343557+tscandalitta@users.noreply.github.com>
Date: Mon, 20 May 2019 07:34:47 -0300
Subject: [PATCH 22/36] Update solution.md

---
 .../11-logical-operators/1-alert-null-2-undefined/solution.md   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/solution.md b/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/solution.md
index aa444844a..b8da8ec85 100644
--- a/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/solution.md
@@ -1,5 +1,5 @@
 La respuesta es `2`, ese es el primer valor verdadero.
 
 ```js run
-alert(null || 2 || undefined);
+alert( null || 2 || undefined );
 ```

From 96a65ece609650a6b2bb74fa603b568b812fb784 Mon Sep 17 00:00:00 2001
From: Tomas Scandalitta <38343557+tscandalitta@users.noreply.github.com>
Date: Mon, 20 May 2019 07:34:59 -0300
Subject: [PATCH 23/36] Update solution.md

---
 .../11-logical-operators/1-alert-null-2-undefined/solution.md    | 1 +
 1 file changed, 1 insertion(+)

diff --git a/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/solution.md b/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/solution.md
index b8da8ec85..9cd356a62 100644
--- a/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/solution.md
@@ -3,3 +3,4 @@ La respuesta es `2`, ese es el primer valor verdadero.
 ```js run
 alert( null || 2 || undefined );
 ```
+

From 4809cbece5de016563e4705ab21eed6d0b68c132 Mon Sep 17 00:00:00 2001
From: Tomas Scandalitta <38343557+tscandalitta@users.noreply.github.com>
Date: Mon, 20 May 2019 07:35:17 -0300
Subject: [PATCH 24/36] Update task.md

---
 .../11-logical-operators/1-alert-null-2-undefined/task.md      | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/task.md b/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/task.md
index 49b2a56bd..2bf460f1d 100644
--- a/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/task.md
+++ b/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/task.md
@@ -7,5 +7,6 @@ importance: 5
 ¿Cuál será la salida del siguiente código?
 
 ```js
-alert(null || 2 || undefined);
+alert( null || 2 || undefined );
 ```
+

From f2e80f4f83e731225ab45232c59e9ae72928c756 Mon Sep 17 00:00:00 2001
From: Tomas Scandalitta <38343557+tscandalitta@users.noreply.github.com>
Date: Mon, 20 May 2019 07:36:26 -0300
Subject: [PATCH 25/36] Update task.md

---
 1-js/02-first-steps/11-logical-operators/2-alert-or/task.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/1-js/02-first-steps/11-logical-operators/2-alert-or/task.md b/1-js/02-first-steps/11-logical-operators/2-alert-or/task.md
index 804461453..4b5519fbb 100644
--- a/1-js/02-first-steps/11-logical-operators/2-alert-or/task.md
+++ b/1-js/02-first-steps/11-logical-operators/2-alert-or/task.md
@@ -9,3 +9,4 @@ importance: 3
 ```js
 alert( alert(1) || 2 || alert(3) );
 ```
+

From 7fa3dd2c0d51ef0e7acbe601227d033ba3f11450 Mon Sep 17 00:00:00 2001
From: Tomas Scandalitta <38343557+tscandalitta@users.noreply.github.com>
Date: Mon, 20 May 2019 07:37:02 -0300
Subject: [PATCH 26/36] Update solution.md

---
 .../11-logical-operators/5-alert-and-or/solution.md              | 1 +
 1 file changed, 1 insertion(+)

diff --git a/1-js/02-first-steps/11-logical-operators/5-alert-and-or/solution.md b/1-js/02-first-steps/11-logical-operators/5-alert-and-or/solution.md
index 92d6fef5f..627b30e5c 100644
--- a/1-js/02-first-steps/11-logical-operators/5-alert-and-or/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/5-alert-and-or/solution.md
@@ -13,3 +13,4 @@ null || 3 || 4
 ```
 
 Ahora el resultado será el primer valor verdadero: `3`.
+

From 1adc84c24d3ec3e9ccb04cd1b12e91ba4c26366f Mon Sep 17 00:00:00 2001
From: Tomas Scandalitta <38343557+tscandalitta@users.noreply.github.com>
Date: Mon, 20 May 2019 07:37:11 -0300
Subject: [PATCH 27/36] Update solution.md

---
 .../11-logical-operators/8-if-question/solution.md               | 1 +
 1 file changed, 1 insertion(+)

diff --git a/1-js/02-first-steps/11-logical-operators/8-if-question/solution.md b/1-js/02-first-steps/11-logical-operators/8-if-question/solution.md
index 542624637..f9ce47b32 100644
--- a/1-js/02-first-steps/11-logical-operators/8-if-question/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/8-if-question/solution.md
@@ -17,3 +17,4 @@ if (-1 && 0) alert( "segundo" );
 // null || -1 && 1  ->  null || 1  ->  1
 if (null || -1 && 1) alert( "tercero" );
 ```
+

From c7cb13e93b7803acf49784ba193944d5ad818170 Mon Sep 17 00:00:00 2001
From: Tomas Scandalitta <38343557+tscandalitta@users.noreply.github.com>
Date: Mon, 20 May 2019 07:37:28 -0300
Subject: [PATCH 28/36] Update solution.md

---
 .../11-logical-operators/9-check-login/solution.md               | 1 +
 1 file changed, 1 insertion(+)

diff --git a/1-js/02-first-steps/11-logical-operators/9-check-login/solution.md b/1-js/02-first-steps/11-logical-operators/9-check-login/solution.md
index 687a4e0e9..d9a413d3a 100644
--- a/1-js/02-first-steps/11-logical-operators/9-check-login/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/9-check-login/solution.md
@@ -22,3 +22,4 @@ if (userName == "Admin") {
 ```
 
 Nota las sangrías verticales dentro de los bloques `if`. Técnicamente no son necesarias, pero facilitan la lectura del código.
+

From 0a5f045800061bf3b8fb95b6cd24015b0b22ec92 Mon Sep 17 00:00:00 2001
From: Tomas Scandalitta <38343557+tscandalitta@users.noreply.github.com>
Date: Mon, 20 May 2019 07:39:22 -0300
Subject: [PATCH 29/36] Update solution.md

---
 .../11-logical-operators/9-check-login/solution.md              | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/11-logical-operators/9-check-login/solution.md b/1-js/02-first-steps/11-logical-operators/9-check-login/solution.md
index d9a413d3a..36d236030 100644
--- a/1-js/02-first-steps/11-logical-operators/9-check-login/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/9-check-login/solution.md
@@ -14,6 +14,7 @@ if (userName == "Admin") {
 	} else {
 		alert( "Contraseña incorrecta" );
 	}
+	
 } else if (userName == "" || userName == null) {
 	alert( "Canceledo" );
 } else {
@@ -22,4 +23,3 @@ if (userName == "Admin") {
 ```
 
 Nota las sangrías verticales dentro de los bloques `if`. Técnicamente no son necesarias, pero facilitan la lectura del código.
-

From 28c23148a78d1f7c967c97091867ceb066c005f6 Mon Sep 17 00:00:00 2001
From: Tomas Scandalitta <38343557+tscandalitta@users.noreply.github.com>
Date: Mon, 20 May 2019 10:58:41 -0300
Subject: [PATCH 30/36] Update article.md

---
 1-js/02-first-steps/11-logical-operators/article.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/1-js/02-first-steps/11-logical-operators/article.md b/1-js/02-first-steps/11-logical-operators/article.md
index f63ca6d88..ca88dc510 100644
--- a/1-js/02-first-steps/11-logical-operators/article.md
+++ b/1-js/02-first-steps/11-logical-operators/article.md
@@ -27,7 +27,7 @@ alert(true || false); // true
 alert(false || false); // false (falso)
 ```
 
-Como podemos ver, los resultados son siempre `true` excepto cuando ambos operandos son `false`.
+Como podemos ver, el resultado es siempre `true` excepto cuando ambos operandos son `false`.
 
 Si un operando no es un booleano, se lo convierte a booleano para la evaluación.
 
@@ -84,7 +84,7 @@ El operador OR `||` realiza lo siguiente:
 
 Un valor es retornado en su forma original, sin la conversión.
 
-En otras palabras, una cadena de OR `"||"` retorna el primer valor verdadero o el último valor en caso de que dicho valor no sea encontrado.
+En otras palabras, una cadena de OR `"||"` retorna el primer valor verdadero o el último valor en caso de que ningún verdadero sea encontrado.
 
 Por ejemplo:
 
@@ -101,7 +101,7 @@ Esto brinda varios usos interesantes comparados al "OR puro, clásico, de solo b
 
 1. **Consiguiendo el primer valor verdadero de una lista de variables o expresiones.**
 
-   Imagina que tenemos múltiples variables que pueden contener datos o ser `null/undefined`. ¿Cómo podemos encontrar el primer valor que contenga datos?
+   Imagina que tenemos múltiples variables que pueden contener datos o bien ser `null/undefined`. ¿Cómo podemos encontrar el primer valor que contenga datos?
 
    Podemos usar OR `||`:
 
@@ -244,7 +244,7 @@ Por ejemplo:
 ```js run
 let x = 1;
 
-x > 0 && alert("Mayor que cero!");
+(x > 0) && alert("Mayor que cero!");
 ````
 
 La acción en la parte derecha de `&&` sería ejecutada sólo si la evaluación la alcanza. Eso es, solo si `(x > 0)` es verdadero.
@@ -301,5 +301,5 @@ alert(Boolean("cadena de texto no vacía")); // true
 alert(Boolean(null)); // false
 ```
 
-La precedencia de NOT `!` es la mayor de todos los operadores lógicos, asi que siempre se ejecuta primero, antes de `&&` o `||`.
+La precedencia de NOT `!` es la mayor de todos los operadores lógicos, así que siempre se ejecuta primero, antes que `&&` o `||`.
 

From ded4ce0c40847d0367ef0a9ce11a40202f2141ba Mon Sep 17 00:00:00 2001
From: Tomas Scandalitta <38343557+tscandalitta@users.noreply.github.com>
Date: Mon, 20 May 2019 11:06:37 -0300
Subject: [PATCH 31/36] Update task.md

---
 .../11-logical-operators/6-check-if-in-range/task.md            | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/11-logical-operators/6-check-if-in-range/task.md b/1-js/02-first-steps/11-logical-operators/6-check-if-in-range/task.md
index 2f7fe0b8e..5cae495a8 100644
--- a/1-js/02-first-steps/11-logical-operators/6-check-if-in-range/task.md
+++ b/1-js/02-first-steps/11-logical-operators/6-check-if-in-range/task.md
@@ -2,7 +2,7 @@ importance: 3
 
 ---
 
-# Comprueba el rango entre ellos
+# Comprueba el rango por dentro
 
 Escribe una condición "if" para comprobar que `age`(edad) está entre `14` y `90` inclusivamente.
 

From a97d693ed7c7e3a33902873c75f631d1f9a4ae01 Mon Sep 17 00:00:00 2001
From: Tomas Scandalitta <38343557+tscandalitta@users.noreply.github.com>
Date: Mon, 20 May 2019 11:06:40 -0300
Subject: [PATCH 32/36] Update solution.md

---
 .../11-logical-operators/5-alert-and-or/solution.md             | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/11-logical-operators/5-alert-and-or/solution.md b/1-js/02-first-steps/11-logical-operators/5-alert-and-or/solution.md
index 627b30e5c..4903143d7 100644
--- a/1-js/02-first-steps/11-logical-operators/5-alert-and-or/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/5-alert-and-or/solution.md
@@ -4,7 +4,7 @@ La respuesta: `3`.
 alert( null || 2 && 3 || 4 );
 ```
 
-La precedencia de AND `&&` es mayor que la de `||`, asi que se ejecuta primero.
+La precedencia de AND `&&` es mayor que la de `||`, así que se ejecuta primero.
 
 El resultado de `2 && 3 = 3`, por lo que la expresión se convierte en:
 

From e13ff70512de8e785edd38c9e0ca422e7d5a05f7 Mon Sep 17 00:00:00 2001
From: Tomas Scandalitta <38343557+tscandalitta@users.noreply.github.com>
Date: Mon, 20 May 2019 11:07:43 -0300
Subject: [PATCH 33/36] Update solution.md

---
 .../11-logical-operators/4-alert-and/solution.md              | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/1-js/02-first-steps/11-logical-operators/4-alert-and/solution.md b/1-js/02-first-steps/11-logical-operators/4-alert-and/solution.md
index a0b0e083e..72099de38 100644
--- a/1-js/02-first-steps/11-logical-operators/4-alert-and/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/4-alert-and/solution.md
@@ -4,6 +4,6 @@ La respuesta: `1` y después `undefined`.
 alert( alert(1) && alert(2) );
 ```
 
-La llamada a `alert` retorna `undefined` (solo muestra un mensaje, asi que no hay un valor que retornar relevante)
+La llamada a `alert` retorna `undefined` (solo muestra un mensaje, así que no hay un valor que retornar relevante)
 
-Debido a ello, `&&` evalua el operando de la izquierda (imprime `1`) e inmediatamente se detiene porque `undefined` es un valor falso. Como `&&` busca un valor falso y lo retorna, ya está.
+Debido a ello, `&&` evalua el operando de la izquierda (imprime `1`) e inmediatamente se detiene porque `undefined` es un valor falso. Como `&&` busca un valor falso y lo retorna, terminamos.

From bd691f519b1fcf438f3b9260a74bf38d0e5b7efc Mon Sep 17 00:00:00 2001
From: Tomas Scandalitta <38343557+tscandalitta@users.noreply.github.com>
Date: Mon, 20 May 2019 11:09:20 -0300
Subject: [PATCH 34/36] Update task.md

---
 .../11-logical-operators/8-if-question/task.md              | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/1-js/02-first-steps/11-logical-operators/8-if-question/task.md b/1-js/02-first-steps/11-logical-operators/8-if-question/task.md
index c27278f0a..e909805c1 100644
--- a/1-js/02-first-steps/11-logical-operators/8-if-question/task.md
+++ b/1-js/02-first-steps/11-logical-operators/8-if-question/task.md
@@ -9,8 +9,8 @@ importance: 5
 ¿Cuáles serán los resultados de las expresiones dentro de `if(...)`?
 
 ```js
-if (-1 || 0) alert( "first" );
-if (-1 && 0) alert( "second" );
-if (null || -1 && 1) alert( "third" );
+if (-1 || 0) alert( "primero" );
+if (-1 && 0) alert( "segundo" );
+if (null || -1 && 1) alert( "tercero" );
 ```
 

From 1345509d74ab541108aaf380c33b74a0c359f86e Mon Sep 17 00:00:00 2001
From: Tomas Scandalitta <38343557+tscandalitta@users.noreply.github.com>
Date: Mon, 20 May 2019 11:10:38 -0300
Subject: [PATCH 35/36] Update solution.md

---
 .../9-check-login/solution.md                 | 22 +++++++++----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/1-js/02-first-steps/11-logical-operators/9-check-login/solution.md b/1-js/02-first-steps/11-logical-operators/9-check-login/solution.md
index 36d236030..b2168dc84 100644
--- a/1-js/02-first-steps/11-logical-operators/9-check-login/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/9-check-login/solution.md
@@ -4,21 +4,21 @@
 let userName = prompt("Quién está ahí?", "");
 
 if (userName == "Admin") {
+    
+    let pass = prompt("Contraseña?", "");
 
-	let pass = prompt("Contraseña?", "");
-
-	if (pass == "TheMaster") {
-		alert( "Bienvenido!" );
-	} else if (pass == "" || pass == null) {
-		alert( "Cancelado." );
-	} else {
-		alert( "Contraseña incorrecta" );
-	}
+    if (pass == "TheMaster") {
+	alert( "Bienvenido!" );
+    } else if (pass == "" || pass == null) {
+	alert( "Cancelado." );
+    } else {
+	alert( "Contraseña incorrecta" );
+    }
 	
 } else if (userName == "" || userName == null) {
-	alert( "Canceledo" );
+    alert( "Canceledo" );
 } else {
-	alert( "No te conozco" );
+    alert( "No te conozco" );
 }
 ```
 

From 927cb205731c6179fabb32dfd03226bf65383932 Mon Sep 17 00:00:00 2001
From: Tomas Scandalitta <38343557+tscandalitta@users.noreply.github.com>
Date: Mon, 20 May 2019 11:11:46 -0300
Subject: [PATCH 36/36] Update task.md

---
 1-js/02-first-steps/11-logical-operators/9-check-login/task.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/11-logical-operators/9-check-login/task.md b/1-js/02-first-steps/11-logical-operators/9-check-login/task.md
index cf5fe5e30..5c0481711 100644
--- a/1-js/02-first-steps/11-logical-operators/9-check-login/task.md
+++ b/1-js/02-first-steps/11-logical-operators/9-check-login/task.md
@@ -8,7 +8,7 @@ Escribe un código que pregunte por el inicio de sesión con `propmt`.
 
 Si el visitante ingresa `"Admin"`, entonces `prompt`(pregunta) por una contraseña, si la entrada es una linea vacía o `key:Esc` -- muestra "Cancelado.", si es otra cadena de texto -- entonces muestra "No te conozco".
 
-La contraseña se comprueba así:
+La contraseña se comprueba de la siguiente manera:
 
 -  Si es igual a "TheMaster", entonces muestra "Bienvenido!",
 -  Si es otra cadena de texto -- muetra "Contraseña incorrecta",