diff --git a/1-js/02-first-steps/10-ifelse/1-if-zero-string/solution.md b/1-js/02-first-steps/10-ifelse/1-if-zero-string/solution.md
index 51f1d4680..abcc595ed 100644
--- a/1-js/02-first-steps/10-ifelse/1-if-zero-string/solution.md
+++ b/1-js/02-first-steps/10-ifelse/1-if-zero-string/solution.md
@@ -1,12 +1,11 @@
-**Yes, it will.**
+**Sí lo hará.**
 
-Any string except an empty one (and `"0"` is not empty) becomes `true` in the logical context.
+Cualquier string excepto uno vacío (y `"0"` que no es vacío) se convierte en `true` en un contexto lógico.
 
-We can run and check:
+Podemos ejecutar y verificar:
 
 ```js run
 if ("0") {
-  alert( 'Hello' );
+  alert( 'Hola' );
 }
 ```
-
diff --git a/1-js/02-first-steps/10-ifelse/1-if-zero-string/task.md b/1-js/02-first-steps/10-ifelse/1-if-zero-string/task.md
index 5f16cda85..edb7e7fe3 100644
--- a/1-js/02-first-steps/10-ifelse/1-if-zero-string/task.md
+++ b/1-js/02-first-steps/10-ifelse/1-if-zero-string/task.md
@@ -2,13 +2,12 @@ importance: 5
 
 ---
 
-# if (a string with zero)
+# if (un string con cero)
 
-Will `alert` be shown?
+Se mostrará el `alert`?
 
 ```js
 if ("0") {
   alert( 'Hello' );
 }
 ```
-
diff --git a/1-js/02-first-steps/10-ifelse/2-check-standard/ifelse_task2.svg b/1-js/02-first-steps/10-ifelse/2-check-standard/ifelse_task2.svg
index d2ac8d760..732d1d2c5 100644
--- a/1-js/02-first-steps/10-ifelse/2-check-standard/ifelse_task2.svg
+++ b/1-js/02-first-steps/10-ifelse/2-check-standard/ifelse_task2.svg
@@ -7,22 +7,22 @@
         <g id="ifelse_task2.svg">
             <path id="Path-1218-Copy" d="M422.5,187.5 L422.5,136.5 L342,136.5 L340.5,136.5 L340.5,133.5 L425.5,133.5 L425.5,187.5 L433.5,187.5 L424,206.5 L414.5,187.5 L422.5,187.5 Z" fill="#EE6B47" fill-rule="nonzero"></path>
             <g id="Rectangle-1-+-Корень" transform="translate(213.000000, 4.000000)">
-                <rect id="Rectangle-1" stroke="#E8C48E" stroke-width="2" fill="#FFF9EB" x="1" y="1" width="78" height="28" rx="14"></rect>
+                <rect id="Rectangle-1" stroke="#E8C48E" stroke-width="2" fill="#FFF9EB" x="1" y="1" width="115" height="28" rx="14"></rect>
                 <text id="Begin" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal" fill="#8A704D">
-                    <tspan x="21" y="19">Begin</tspan>
+                    <tspan x="21" y="19">Comencemos</tspan>
                 </text>
             </g>
             <g id="Rectangle-1-+-Корень-Copy-2" transform="translate(8.000000, 206.000000)">
                 <rect id="Rectangle-1" stroke="#E8C48E" stroke-width="2" fill="#FFF9EB" x="1" y="1" width="131" height="49" rx="24.5"></rect>
                 <text id="You-don't-know?-“ECM" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal" fill="#8A704D">
-                    <tspan x="13.3540039" y="20">You don't know?</tspan>
-                    <tspan x="21.9672852" y="39">“ECMAScript”!</tspan>
+                    <tspan x="13.3540039" y="20">¿No lo sabes?</tspan>
+                    <tspan x="21.9672852" y="39">¡“ECMAScript”!</tspan>
                 </text>
             </g>
             <g id="Rectangle-1-+-Корень-Copy-3" transform="translate(354.000000, 206.000000)">
                 <rect id="Rectangle-1" stroke="#E8C48E" stroke-width="2" fill="#FFF9EB" x="1" y="1" width="131" height="49" rx="24.5"></rect>
                 <text id="Right!" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal" fill="#8A704D">
-                    <tspan x="47.9301758" y="28">Right!</tspan>
+                    <tspan x="40" y="28">¡Correcto!</tspan>
                 </text>
             </g>
             <path id="Line" d="M252,57.0499687 L252,34 L255,34 L255,57.0499687 L263,57.0499687 L253.5,76.0499687 L244,57.0499687 L252,57.0499687 Z" fill="#EE6B47" fill-rule="nonzero"></path>
@@ -31,13 +31,13 @@
             <g id="Rectangle-354-+-Каково-“официальное”" transform="translate(137.000000, 76.000000)">
                 <path d="M2.1985673,59.5 L116.5,117.877127 L230.801433,59.5 L116.5,1.12287343 L2.1985673,59.5 Z" id="Rectangle-354" stroke="#E8C48E" stroke-width="2" fill="#FFF9EB"></path>
                 <text id="What's-the-“official" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal" fill="#8A704D">
-                    <tspan x="81.0263672" y="43">What's the</tspan>
-                    <tspan x="60.6347656" y="62">“official” name of</tspan>
+                    <tspan x="81.0263672" y="43">¿Cual es el</tspan>
+                    <tspan x="60.6347656" y="62">nombre “oficial” de</tspan>
                     <tspan x="80.7700195" y="81">JavaScript?</tspan>
                 </text>
             </g>
             <text id="Other" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal" fill="#8A704D">
-                <tspan x="57" y="166">Other</tspan>
+                <tspan x="65" y="166">Otro</tspan>
             </text>
             <rect id="Rectangle-356-Copy" fill="#FFFFFF" x="387" y="152" width="60" height="20"></rect>
             <text id="ECMAScript" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal" fill="#8A704D">
diff --git a/1-js/02-first-steps/10-ifelse/2-check-standard/ifelse_task2/index.html b/1-js/02-first-steps/10-ifelse/2-check-standard/ifelse_task2/index.html
index ea9966653..d6e2d3a60 100644
--- a/1-js/02-first-steps/10-ifelse/2-check-standard/ifelse_task2/index.html
+++ b/1-js/02-first-steps/10-ifelse/2-check-standard/ifelse_task2/index.html
@@ -5,12 +5,12 @@
   <script>
     'use strict';
 
-    let value = prompt('What is the "official" name of JavaScript?', '');
+    let value = prompt('¿Cuál es el nombre "oficial" de JavaScript?', '');
 
     if (value == 'ECMAScript') {
-      alert('Right!');
+      alert('¡Correcto!');
     } else {
-      alert("You don't know? ECMAScript!");
+      alert("¿No lo sabes? ¡ECMAScript!");
     }
   </script>
 
diff --git a/1-js/02-first-steps/10-ifelse/2-check-standard/task.md b/1-js/02-first-steps/10-ifelse/2-check-standard/task.md
index 1d1a3f33d..d3d05c469 100644
--- a/1-js/02-first-steps/10-ifelse/2-check-standard/task.md
+++ b/1-js/02-first-steps/10-ifelse/2-check-standard/task.md
@@ -2,13 +2,12 @@ importance: 2
 
 ---
 
-# The name of JavaScript
+# El nombre de JavaScript
 
-Using the `if..else` construct, write the code which asks: 'What is the "official" name of JavaScript?'
+Usando el constructor `if..else`, escribe el código que pregunta: '¿Cuál es el nombre "oficial" de JavaScript?'
 
-If the visitor enters "ECMAScript", then output "Right!", otherwise -- output: "Didn't know? ECMAScript!"
+Si el visitador escribe "ECMAScript", Entonces muestras "¡Correcto!", de lo contrario -- muestra: "¿No lo sabes? ¡ECMAScript!"
 
 ![](ifelse_task2.svg)
 
 [demo src="ifelse_task2"]
-
diff --git a/1-js/02-first-steps/10-ifelse/3-sign/if_sign/index.html b/1-js/02-first-steps/10-ifelse/3-sign/if_sign/index.html
index f168360dd..5216ec632 100644
--- a/1-js/02-first-steps/10-ifelse/3-sign/if_sign/index.html
+++ b/1-js/02-first-steps/10-ifelse/3-sign/if_sign/index.html
@@ -6,7 +6,7 @@
   <script>
     'use strict';
 
-    let value = prompt('Type a number', 0);
+    let value = prompt('Escribe un número', 0);
 
     if (value > 0) {
       alert(1);
diff --git a/1-js/02-first-steps/10-ifelse/3-sign/solution.md b/1-js/02-first-steps/10-ifelse/3-sign/solution.md
index 262a605c2..c223ee082 100644
--- a/1-js/02-first-steps/10-ifelse/3-sign/solution.md
+++ b/1-js/02-first-steps/10-ifelse/3-sign/solution.md
@@ -1,7 +1,7 @@
 
 
 ```js run
-let value = prompt('Type a number', 0);
+let value = prompt('Escribe un número', 0);
 
 if (value > 0) {
   alert( 1 );
diff --git a/1-js/02-first-steps/10-ifelse/3-sign/task.md b/1-js/02-first-steps/10-ifelse/3-sign/task.md
index 0c5d0e008..b9a0d78b5 100644
--- a/1-js/02-first-steps/10-ifelse/3-sign/task.md
+++ b/1-js/02-first-steps/10-ifelse/3-sign/task.md
@@ -4,12 +4,12 @@ importance: 2
 
 # Show the sign
 
-Using `if..else`, write the code which gets a number via `prompt` and then shows in `alert`:
+Usando el constructor `if..else`, escribe un código que obtenga a través de un `prompt` un número y entonces muestre en un `alert`:
 
-- `1`, if the value is greater than zero,
-- `-1`, if less than zero,
-- `0`, if equals zero.
+- `1`, si el valor es mayor que cero,
+- `-1`, si es menor que cero,
+- `0`, si es igual a cero.
 
-In this task we assume that the input is always a number.
+En la tarea asumimos que siempre el usuario introduce un número.
 
 [demo src="if_sign"]
diff --git a/1-js/02-first-steps/10-ifelse/5-rewrite-if-question/solution.md b/1-js/02-first-steps/10-ifelse/5-rewrite-if-question/solution.md
index 638ce81f1..fb83697c7 100644
--- a/1-js/02-first-steps/10-ifelse/5-rewrite-if-question/solution.md
+++ b/1-js/02-first-steps/10-ifelse/5-rewrite-if-question/solution.md
@@ -1,6 +1,6 @@
 
 
 ```js
-result = (a + b < 4) ? 'Below' : 'Over';
+result = (a + b < 4) ? 'Debajo' : 'Encima';
 ```
 
diff --git a/1-js/02-first-steps/10-ifelse/5-rewrite-if-question/task.md b/1-js/02-first-steps/10-ifelse/5-rewrite-if-question/task.md
index 684e239f2..df7b392fc 100644
--- a/1-js/02-first-steps/10-ifelse/5-rewrite-if-question/task.md
+++ b/1-js/02-first-steps/10-ifelse/5-rewrite-if-question/task.md
@@ -2,15 +2,14 @@ importance: 5
 
 ---
 
-# Rewrite 'if' into '?'
+# Reescribe el 'if' como '?'
 
-Rewrite this `if` using the ternary operator `'?'`:
+Reescriba esta condición `if` usando el operador ternario `'?'`:
 
 ```js
 if (a + b < 4) {
-  result = 'Below';
+  result = 'Debajo';
 } else {
-  result = 'Over';
+  result = 'Encima';
 }
 ```
-
diff --git a/1-js/02-first-steps/10-ifelse/6-rewrite-if-else-question/solution.md b/1-js/02-first-steps/10-ifelse/6-rewrite-if-else-question/solution.md
index 6d68e29d7..2ac5b7703 100644
--- a/1-js/02-first-steps/10-ifelse/6-rewrite-if-else-question/solution.md
+++ b/1-js/02-first-steps/10-ifelse/6-rewrite-if-else-question/solution.md
@@ -1,9 +1,9 @@
 
 
 ```js
-let message = (login == 'Employee') ? 'Hello' :
-  (login == 'Director') ? 'Greetings' :
-  (login == '') ? 'No login' :
+let message = (login == 'Empleado') ? 'Hola' :
+  (login == 'Director') ? 'Felicidades' :
+  (login == '') ? 'Sin sesión' :
   '';
 ```
 
diff --git a/1-js/02-first-steps/10-ifelse/6-rewrite-if-else-question/task.md b/1-js/02-first-steps/10-ifelse/6-rewrite-if-else-question/task.md
index 4f7d994a2..e5a75c83f 100644
--- a/1-js/02-first-steps/10-ifelse/6-rewrite-if-else-question/task.md
+++ b/1-js/02-first-steps/10-ifelse/6-rewrite-if-else-question/task.md
@@ -2,21 +2,21 @@ importance: 5
 
 ---
 
-# Rewrite 'if..else' into '?'
+# Reescriba el 'if..else' con '?'
 
-Rewrite `if..else` using multiple ternary operators `'?'`.
+Reescriba el `if..else` utilizando operadores ternarios múltiples`'?'`.
 
-For readability, it's recommended to split the code into multiple lines.
+Para legibilidad, es recomendad dividirlo en múltiples lineas de código.
 
 ```js
 let message;
 
-if (login == 'Employee') {
-  message = 'Hello';
+if (login == 'Empleado') {
+  message = 'Hola';
 } else if (login == 'Director') {
-  message = 'Greetings';
+  message = 'Felicidades';
 } else if (login == '') {
-  message = 'No login';
+  message = 'Sin sesión';
 } else {
   message = '';
 }
diff --git a/1-js/02-first-steps/10-ifelse/article.md b/1-js/02-first-steps/10-ifelse/article.md
index 1e12fa7b5..a5d6996bb 100644
--- a/1-js/02-first-steps/10-ifelse/article.md
+++ b/1-js/02-first-steps/10-ifelse/article.md
@@ -1,117 +1,118 @@
-# Conditional operators: if, '?'
+# Operadores condicionales: if, '?'
 
-Sometimes, we need to perform different actions based on different conditions.
+Algunas veces, necesitamos ejecutar diferentes acciones basadas en diferentes condiciones.
 
-To do that, we use the `if` statement and the conditional (ternary) operator which we will be referring to as the “question mark” operator `?` for simplicity.
+Para hacer esto, nosotros utilizaremos la sentencia `if` y el operador condicional (ternario) al cual nos referiremos de aqui en adelante como operador de “signo de interrogación” `?` por simplicidad.
 
-## The "if" statement
+## La sentencia "if"
 
-The `if` statement evaluates a condition and, if the condition's result is `true`, executes a block of code.
+La sentencia `if` evalúa una condición y, si esta condición obtiene un booleano de tipo `true`, ejecuta un bloque de código.
 
-For example:
+Por ejemplo:
 
 ```js run
-let year = prompt('In which year was ECMAScript-2015 specification published?', '');
+let year = prompt('¿En que año la fué publicada la especificación ECMAScript-2015?', '');
 
 *!*
-if (year == 2015) alert( 'You are right!' );
+if (year == 2015) alert( '¡Estás en lo cierto!' );
 */!*
 ```
 
-In the example above, the condition is a simple equality check (`year == 2015`), but it can be much more complex.
+En el ejemplo de arriba, la condición es un simple signo de igualdad (`year == 2015`), pero podría ser mucho mas complejo.
 
-If we want to execute more than one statement, we have to wrap our code block inside curly braces:
+Si quisiéramos ejecutar más de una sentencia, debemos encerrar nuestro bloque de código entre llaves:
 
 ```js
 if (year == 2015) {
-  alert( "That's correct!" );
-  alert( "You're so smart!" );
+  alert( "¡Es Correcto!" );
+  alert( "¡Eres muy inteligente!" );
 }
 ```
 
-We recommend wrapping your code block with curly braces `{}` every time you use an `if` statement, even if there is only one statement to execute. Doing so improves readability.
+Recomendamos siempre encerrar nuestro bloque de código entre llaves `{}` siempre que se utilice la sentencia `if`, inclusive si solo se va a ejecutar una sola sentencia en este caso. Hacer eso mejora la legibilidad.
 
-## Boolean conversion
+## Conversión Booleana
 
-The `if (…)` statement evaluates the expression in its parentheses and converts the result to a boolean.
+La sentencia `if (…)` evalúa la expresión dentro de sus paréntesis y convierte el resultado en booleano.
 
-Let's recall the conversion rules from the chapter <info:type-conversions>:
+Recordemos las reglas de conversión del capítulo.
+<info:type-conversions>:
 
-- A number `0`, an empty string `""`, `null`, `undefined`, and `NaN` all become `false`. Because of that they are called "falsy" values.
-- Other values become `true`, so they are called "truthy".
+- El número `0`, un string vacio `""`, `null`, `undefined`, y `NaN` se convierte en `false`. Por esto son llamados valores "falso".
+- El resto de los valores se convierten en  `true`, entonces los llamaremos valores "verdadero".
 
-So, the code under this condition would never execute:
+Entonces, el código que vemos a continuación nunca se ejecutaria:
 
 ```js
-if (0) { // 0 is falsy
+if (0) { // 0 es falso
   ...
 }
 ```
 
-...and inside this condition -- it always will:
+...y dentro de esta condición -- siempre se ejecutará:
 
 ```js
-if (1) { // 1 is truthy
+if (1) { // 1 es verdadero
   ...
 }
 ```
 
-We can also pass a pre-evaluated boolean value to `if`, like this:
+También podemos pasar un valor booleano pre-evaluado al `if`, así:
 
 ```js
-let cond = (year == 2015); // equality evaluates to true or false
+let cond = (year == 2015); // la igualdad evalúa y devuelve un true o false
 
 if (cond) {
   ...
 }
 ```
 
-## The "else" clause
+## La clausula "else"
 
-The `if` statement may contain an optional "else" block. It executes when the condition is false.
+La sentencia `if` quizás contenga un bloque "else" opcional. Este se ejecutará cuando la condición sea falsa.
 
-For example:
+Por ejemplo:
 ```js run
-let year = prompt('In which year was the ECMAScript-2015 specification published?', '');
+let year = prompt('¿En qué año fue publicada la especificación ECMAScript-2015?', '');
 
 if (year == 2015) {
-  alert( 'You guessed it right!' );
+  alert( '¡Lo adivinaste correcto!' );
 } else {
-  alert( 'How can you be so wrong?' ); // any value except 2015
+  alert( '¿Como te puedes estar tan equivocado?' ); // cualquier valor excepto 2015
 }
 ```
 
-## Several conditions: "else if"
+## Muchas condiciones: "else if"
 
-Sometimes, we'd like to test several variants of a condition. The `else if` clause lets us do that.
+Algunas veces, queremos probar variantes de una condición. La clausula `else if` nos permite hacer esto.
 
-For example:
+Por ejemplo:
 
 ```js run
-let year = prompt('In which year was the ECMAScript-2015 specification published?', '');
+let year = prompt('¿En qué año fue publicada la especificación ECMAScript-2015?', '');
 
 if (year < 2015) {
-  alert( 'Too early...' );
+  alert( 'Muy poco...' );
 } else if (year > 2015) {
-  alert( 'Too late' );
+  alert( 'Muy Tarde' );
 } else {
-  alert( 'Exactly!' );
+  alert( '¡Exactamente!' );
 }
 ```
 
-In the code above, JavaScript first checks `year < 2015`. If that is falsy, it goes to the next condition `year > 2015`. If that is also falsy, it shows the last `alert`.
+En el código de arriba, JavaScript primero revisa si `year < 2015`. Si esto es falso, continúa a la siguiente condición `year > 2015`. Si esta también es falsa, mostrará la última `alert`.
 
-There can be more `else if` blocks. The final `else` is optional.
+Podría haber más bloques `else if`.  Y el último  `else` es opcional.
 
-## Ternary operator '?'
+## Operador ternario '?'
 
-Sometimes, we need to assign a variable depending on a condition.
+A veces necesitamos asignar una variable dependiendo de alguna condición.
 
-For instance:
+Por ejemplo:
 
 ```js run no-beautify
 let accessAllowed;
-let age = prompt('How old are you?', '');
+let age = prompt('¿Qué edad tienes?', '');
 
 *!*
 if (age > 18) {
@@ -124,116 +125,115 @@ if (age > 18) {
 alert(accessAllowed);
 ```
 
-The so-called "ternary" or "question mark" operator lets us do that in a shorter and simpler way.
+Entonces el operador "ternario" también llamado  "signo de interrogación" nos permite ejecutar esto en una forma más corta y simple.
 
-The operator is represented by a question mark `?`.  The formal term "ternary" means that the operator has three operands. It is actually the one and only operator in JavaScript which has that many.
+El operador está representado por un signo de interrogación de cierre `?`.  El término formal "ternario" significa que el operador tiene tres operandos. Este es actualmente el primer y único operador de JavaScript que tiene esta cantidad.
 
-The syntax is:
+La Sintaxis es:
 ```js
 let result = condition ? value1 : value2;
 ```
 
-The `condition` is evaluated: if it's truthy then `value1` is returned, otherwise -- `value2`.
+La `condition` es evaluada: si es verdadera entonces devuelve `value1` , de lo contrario -- `value2`.
 
-For example:
+Por ejemplo:
 
 ```js
 let accessAllowed = (age > 18) ? true : false;
 ```
 
-Technically, we can omit the parentheses around `age > 18`. The question mark operator has a low precedence, so it executes after the comparison `>`. 
+Técnicamente, podemos omitir el paréntesis alrededor de  `age > 18`. El operador de signo de interrogación tiene una precedencia baja, por lo que se ejecuta después del signo de comparación `>`. 
 
-This example will do the same thing as the previous one:
+En este ejemplo realizaremos lo mismo que en el anterior:
 
 ```js
-// the comparison operator "age > 18" executes first anyway
-// (no need to wrap it into parentheses)
+// el operador de comparación  "age > 18" se ejecuta primero de cualquier forma
+// (no necesitamos agregar los paréntesis)
 let accessAllowed = age > 18 ? true : false;
 ```
 
-But parentheses make the code more readable, so we recommend using them.
+Pero los paréntesis hacen el código mas legible, asi que recomendamos utilizarlos.
 
 ````smart
-In the example above, you can avoid using the question mark operator because the comparison itself returns `true/false`:
-
+En el ejemplo de arriba, podrias evitar utilizar el operador de signo de interrogación porque esta comparación devuelve directamente `true/false`:
+````
 ```js
-// the same
+// es lo mismo que
 let accessAllowed = age > 18;
 ```
-````
 
-## Multiple '?'
+## Múltiples '?'
 
-A sequence of question mark operators `?` can return a value that depends on more than one condition.
+Una secuencia de operadores de signos de interrogación  `?` puede devolver un valor que depende de más de una condición.
 
-For instance:
+Por ejemplo:
 ```js run
-let age = prompt('age?', 18);
+let age = prompt('¿edad?', 18);
 
-let message = (age < 3) ? 'Hi, baby!' :
-  (age < 18) ? 'Hello!' :
-  (age < 100) ? 'Greetings!' :
-  'What an unusual age!';
+let message = (age < 3) ? '¡Hola, bebé!' :
+  (age < 18) ? '¡Hola!' :
+  (age < 100) ? '¡Felicidades!' :
+  '¡Qué edad tan inusual!';
 
 alert( message );
 ```
 
-It may be difficult at first to grasp what's going on. But after a closer look, we can see that it's just an ordinary sequence of tests:
+Puede ser difícil al principio comprender lo que está sucediendo. Pero después de una mirada más cercana, podemos ver que es solo una secuencia ordinaria de condiciones:
 
-1. The first question mark checks whether `age < 3`.
-2. If true -- it returns `'Hi, baby!'`. Otherwise, it continues to the expression after the colon '":"', checking `age < 18`.
-3. If that's true -- it returns `'Hello!'`. Otherwise, it continues to the expression after the next colon '":"', checking `age < 100`.
-4. If that's true -- it returns `'Greetings!'`. Otherwise, it continues to the expression after the last colon '":"', returning `'What an unusual age!'`.
+1. El primer signo de pregunta revisa si `age < 3`.
+2. Si es cierto -- devuelve `'¡Hola, bebé!'`. De lo contrario, continua a la expresión que está después de los dos puntos '":"', revisando `age < 18`.
+3. Si es cierto -- devuelve `'¡Hola!'`. De lo contrario, continúa con la expresión que está después de los dos puntos siguientes '":"', revisando `age < 100`.
+4. Si es cierto -- devuelve `'¡Felicidades!'`. De lo contrario, continúa a la expresión que está después de los dos puntos '":"', devolviendo `'¡Qué edad tan inusual!'`.
 
-Here's how this looks using `if..else`:
+Aquí lo podemos ver utilizando `if..else`:
 
 ```js
 if (age < 3) {
-  message = 'Hi, baby!';
+  message = '¡Hola, bebé!';
 } else if (age < 18) {
-  message = 'Hello!';
+  message = '¡Hola!';
 } else if (age < 100) {
-  message = 'Greetings!';
+  message = '¡Felicidades!';
 } else {
-  message = 'What an unusual age!';
+  message = '¡Qué edad tan inusual!';
 }
 ```
 
-## Non-traditional use of '?'
+## Uso no tradicional de '?'
 
-Sometimes the question mark `?` is used as a replacement for `if`:
+A veces el signo de interrogación cerrado `?` se utiliza para reemplazar `if`:
 
 ```js run no-beautify
-let company = prompt('Which company created JavaScript?', '');
+let company = prompt('¿Qué compañía creó JavaScript?', '');
 
 *!*
 (company == 'Netscape') ?
-   alert('Right!') : alert('Wrong.');
+   alert('¡Correcto!') : alert('Equivocado.');
 */!*
 ```
 
-Depending on the condition `company == 'Netscape'`, either the first or the second expression after the `?` gets executed and shows an alert.
+Dependiendo de la condición `company == 'Netscape'`, se ejecutará la primera o la segunda expresión del operador `?` y se mostrará una alerta.
 
-We don't assign a result to a variable here. Instead, we execute different code depending on the condition.
+Aquí no asignamos el resultado de una variable. En vez de esto, ejecutamos diferentes códigos dependiendo de la condición.
 
-**We don't recommend using the question mark operator in this way.**
+**Nosotros no recomendamos el uso del operador de signo de interrogación en estos casos.**
 
-The notation is shorter than the equivalent `if` statement, which appeals to some programmers. But it is less readable.
+La notacion es mas corta que la sentencia equivalente con `if`, lo cual seduce a algunos programadores. Pero es menos legible.
 
-Here is the same code using `if` for comparison:
+Aquí está el mismo código utilizando la sentencia `if` para comparar:
 
 ```js run no-beautify
-let company = prompt('Which company created JavaScript?', '');
+let company = prompt('¿Cuál compañía creó JavaScript?', '');
 
 *!*
 if (company == 'Netscape') {
-  alert('Right!');
+  alert('¡Correcto!');
 } else {
-  alert('Wrong.');
+  alert('Equivocado.');
 }
 */!*
 ```
 
-Our eyes scan the code vertically. Code blocks which span several lines are easier to understand than a long, horizontal instruction set.
+Nuestros ojos leen el código verticalmente. Los bloques de código que se expanden múltiples lineas son mas fáciles de entender que los las instrucciones largas horizontales.
 
-The purpose of the question mark operator `?` is to return one value or another depending on its condition. Please use it for exactly that. Use `if` when you need to execute different branches of code.
+El propósito del operador de signo de interrogación `?` es para devolver un valor u otro dependiendo de su condición. Por favor utilízala para exactamente esto. Utiliza la sentencia `if` cuando necesites ejecutar código en ramas distintas.