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..a57d5efd1 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,12 @@
-**Yes, it will.**
+**Si, así será.**
 
-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 correr y revisar esto:
 
 ```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..69ad9ddae 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,9 +2,9 @@ importance: 5
 
 ---
 
-# if (a string with zero)
+# if (un string con cero)
 
-Will `alert` be shown?
+Creará un `alert` que se muestre?
 
 ```js
 if ("0") {
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..bbbc6adde 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('¿Cual 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..d44072c45 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,11 +2,11 @@ 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)
 
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..7772d64b0 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,15 @@ 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..b78f5d36d 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 líneas 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..6a1f67100 100644
--- a/1-js/02-first-steps/10-ifelse/article.md
+++ b/1-js/02-first-steps/10-ifelse/article.md
@@ -1,117 +1,119 @@
-# 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 mas 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 (…)` evalua la exprecion 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 vació `""`, `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 evalua 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 que año la fué 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 que año la fué 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, continua 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ían haber mas bloques `else if`. Y el último
+ `else` es opcional.
 
-## Ternary operator '?'
+## Operador ternario '?'
 
-Sometimes, we need to assign a variable depending on a condition.
+Algunas 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('¿Que edad tienes?', '');
 
 *!*
 if (age > 18) {
@@ -124,116 +126,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 también llamado "ternario" o "signo de interrogación" nos permite ejecutar esto en una forma mas 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 esta representado por un signo de interrogación de cierre `?`.  El termino 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 de 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 mas 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!' :
+  '¡Que 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. La Primera marca de pregunta revisa si `age < 3`.
+2. Si es cierto -- devuelve `'¡Hola, bebé!'`. De lo contrario, continua a la expresión que esta despues de los dos puntos '":"', revisando `age < 18`.
+3. Si es cierto -- devuelve `'¡Hola!'`. De lo contrario, continua con la expresionque esta despues de los dos puntos siguientes '":"', checking `age < 100`.
+4. Si es cierto -- devuelve `'¡Felicidades!'`. De lo contrario, continua a la expresion que esta despues de los dos puntos '":"', returning `'¡Que edad tan inusual!'`.
 
-Here's how this looks using `if..else`:
+Aqui 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 = '¡Que edad tan inusual!';
 }
 ```
 
-## Non-traditional use of '?'
+## Uso no tradicional de '?'
 
-Sometimes the question mark `?` is used as a replacement for `if`:
+ALgunas veces el signo de interrogacion cerrado `?` se utiliza para reemplazar `if`:
 
 ```js run no-beautify
-let company = prompt('Which company created JavaScript?', '');
+let company = prompt('¿Que 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 notación 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:
+Aqui esta el mismo codigo utilizando la sentencia `if` para comparar:
 
 ```js run no-beautify
-let company = prompt('Which company created JavaScript?', '');
+let company = prompt('¿Que 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.
diff --git a/1-js/02-first-steps/14-function-basics/1-if-else-required/solution.md b/1-js/02-first-steps/14-function-basics/1-if-else-required/solution.md
index e41c80418..60a6d5496 100644
--- a/1-js/02-first-steps/14-function-basics/1-if-else-required/solution.md
+++ b/1-js/02-first-steps/14-function-basics/1-if-else-required/solution.md
@@ -1 +1 @@
-No difference.
\ No newline at end of file
+Ninguna diferencia.
\ No newline at end of file
diff --git a/1-js/02-first-steps/14-function-basics/1-if-else-required/task.md b/1-js/02-first-steps/14-function-basics/1-if-else-required/task.md
index 4f69a5c8c..e3e721c39 100644
--- a/1-js/02-first-steps/14-function-basics/1-if-else-required/task.md
+++ b/1-js/02-first-steps/14-function-basics/1-if-else-required/task.md
@@ -2,11 +2,11 @@ importance: 4
 
 ---
 
-# Is "else" required?
+# ¿Es "else" requerido?
 
-The following function returns `true` if the parameter `age` is greater than `18`.
+La siguiente función devuelve `true` si el parámetro `age` es mayour a `18`.
 
-Otherwise it asks for a confirmation and returns its result:
+De lo contrario, solicita una confirmación y devuelve su resultado:
 
 ```js
 function checkAge(age) {
@@ -15,13 +15,13 @@ function checkAge(age) {
 *!*
   } else {
     // ...
-    return confirm('Did parents allow you?');
+    return confirm('¿Tus padres te permitieron?');
   }
 */!*
 }
 ```
 
-Will the function work differently if `else` is removed?
+¿Funcionará la función de manera diferente si se borra `else`?
 
 ```js
 function checkAge(age) {
@@ -30,9 +30,9 @@ function checkAge(age) {
   }
 *!*
   // ...
-  return confirm('Did parents allow you?');
+  return confirm('¿Tus padres te permitieron?');
 */!*
 }
 ```
 
-Is there any difference in the behavior of these two variants?
+¿Hay alguna diferencia en el comportamiento de estas dos variantes?
diff --git a/1-js/02-first-steps/14-function-basics/2-rewrite-function-question-or/solution.md b/1-js/02-first-steps/14-function-basics/2-rewrite-function-question-or/solution.md
index c8ee9618f..1b2d819f8 100644
--- a/1-js/02-first-steps/14-function-basics/2-rewrite-function-question-or/solution.md
+++ b/1-js/02-first-steps/14-function-basics/2-rewrite-function-question-or/solution.md
@@ -2,16 +2,16 @@ Using a question mark operator `'?'`:
 
 ```js
 function checkAge(age) {
-  return (age > 18) ? true : confirm('Did parents allow you?');
+  return (age > 18) ? true : confirm('¿Tús padres te lo permitieron?');
 }
 ```
 
-Using OR `||` (the shortest variant):
+Usando Ó `||` (la variante más corta):
 
 ```js
 function checkAge(age) {
-  return (age > 18) || confirm('Did parents allow you?');
+  return (age > 18) || confirm('¿Tús padres te lo permitieron?');
 }
 ```
 
-Note that the parentheses around `age > 18` are not required here. They exist for better readabilty.
+Tenga en cuenta que los paréntesis alrededor de `age > 18` no son requeridos aca. Existen para una mejor legibilidad.
diff --git a/1-js/02-first-steps/14-function-basics/2-rewrite-function-question-or/task.md b/1-js/02-first-steps/14-function-basics/2-rewrite-function-question-or/task.md
index 523bb127a..f62c638cb 100644
--- a/1-js/02-first-steps/14-function-basics/2-rewrite-function-question-or/task.md
+++ b/1-js/02-first-steps/14-function-basics/2-rewrite-function-question-or/task.md
@@ -2,25 +2,25 @@ importance: 4
 
 ---
 
-# Rewrite the function using '?' or '||'
+# Reescriba la función utilizando '?' o '||'
 
-The following function returns `true` if the parameter `age` is greater than `18`.
+La siguiente función devuelve `true` si el parametro `age` es mayour que `18`.
 
-Otherwise it asks for a confirmation and returns its result.
+De lo contrario, solicita una confirmación y devuelve su resultado.
 
 ```js
 function checkAge(age) {
   if (age > 18) {
     return true;
   } else {
-    return confirm('Do you have your parents permission to access this page?');
+    return confirm('¿Tienes permiso de tus padres para acceder a esta página?');
   }
 }
 ```
 
-Rewrite it, to perform the same, but without `if`, in a single line.
+Reescríbalo, para realizar lo mismo, pero sin `if`, en una sola linea.
 
-Make two variants of `checkAge`:
+Haz dos variantes de `checkAge`:
 
-1. Using a question mark operator `?`
-2. Using OR `||`
+1. Usando un operador de signo de interrogación `?`
+2. Usando Ó `||`
diff --git a/1-js/02-first-steps/14-function-basics/3-min/solution.md b/1-js/02-first-steps/14-function-basics/3-min/solution.md
index 2236d9203..d01464a52 100644
--- a/1-js/02-first-steps/14-function-basics/3-min/solution.md
+++ b/1-js/02-first-steps/14-function-basics/3-min/solution.md
@@ -10,7 +10,7 @@ function min(a, b) {
 }
 ```
 
-A solution with a question mark operator `'?'`:
+Una solución con un operador de signo de interrogación `'?'`:
 
 ```js
 function min(a, b) {
@@ -18,4 +18,4 @@ function min(a, b) {
 }
 ```
 
-P.S. In the case of an equality `a == b` it does not matter what to return.
\ No newline at end of file
+P.D: En el caso de una igualdad `a == b` No importa qué devuelva.
\ No newline at end of file
diff --git a/1-js/02-first-steps/14-function-basics/3-min/task.md b/1-js/02-first-steps/14-function-basics/3-min/task.md
index 50edd0d36..d784a3b5f 100644
--- a/1-js/02-first-steps/14-function-basics/3-min/task.md
+++ b/1-js/02-first-steps/14-function-basics/3-min/task.md
@@ -2,11 +2,11 @@ importance: 1
 
 ---
 
-# Function min(a, b)
+# Función min(a, b)
 
-Write a function `min(a,b)` which returns the least of two numbers `a` and `b`.
+Escriba una función `min(a,b)` la cual devuelva el menor de dos números `a` y `b`.
 
-For instance:
+Por ejemplo:
 
 ```js
 min(2, 5) == 2
diff --git a/1-js/02-first-steps/14-function-basics/4-pow/solution.md b/1-js/02-first-steps/14-function-basics/4-pow/solution.md
index 5ef20c386..772ec5fa7 100644
--- a/1-js/02-first-steps/14-function-basics/4-pow/solution.md
+++ b/1-js/02-first-steps/14-function-basics/4-pow/solution.md
@@ -14,8 +14,8 @@ let x = prompt("x?", '');
 let n = prompt("n?", '');
 
 if (n < 1) {
-  alert(`Power ${n} is not supported,
-    use an integer greater than 0`);
+  alert(`Potencia ${n} no soportada,
+    use un entero mayor a 0`);
 } else {
   alert( pow(x, n) );
 }
diff --git a/1-js/02-first-steps/14-function-basics/4-pow/task.md b/1-js/02-first-steps/14-function-basics/4-pow/task.md
index f569320c7..fda0a956e 100644
--- a/1-js/02-first-steps/14-function-basics/4-pow/task.md
+++ b/1-js/02-first-steps/14-function-basics/4-pow/task.md
@@ -4,7 +4,7 @@ importance: 4
 
 # Function pow(x,n)
 
-Write a function `pow(x,n)` that returns `x` in power `n`. Or, in other words, multiplies `x` by itself `n` times and returns the result.
+Escriba la función `pow(x,n)` que devuelva `x` como potencia de `n`. O, en otras palabras, multiplique `x` por si mismo `n` veces y devuelva el resultado.
 
 ```js
 pow(3, 2) = 3 * 3 = 9
@@ -12,8 +12,8 @@ pow(3, 3) = 3 * 3 * 3 = 27
 pow(1, 100) = 1 * 1 * ...* 1 = 1
 ```
 
-Create a web-page that prompts for `x` and `n`, and then shows the result of `pow(x,n)`.
+Cree una página web que solicite `x` y `n`, y luego muestra el resultado de `pow(x,n)`.
 
 [demo]
 
-P.S. In this task the function should support only natural values of `n`: integers up from `1`.
+PD: En esta tarea, la función solo debe admitir valores naturales de `n`: enteros hacia por encima de `1`.
diff --git a/1-js/02-first-steps/14-function-basics/article.md b/1-js/02-first-steps/14-function-basics/article.md
index 874890ab5..cd091c36b 100644
--- a/1-js/02-first-steps/14-function-basics/article.md
+++ b/1-js/02-first-steps/14-function-basics/article.md
@@ -1,36 +1,36 @@
-# Functions
+# Funciones
 
-Quite often we need to perform a similar action in many places of the script.
+Muy a menudo necesitamos realizar una acción similar en muchos lugares del script.
 
-For example, we need to show a nice-looking message when a visitor logs in, logs out and maybe somewhere else.
+Por ejemplo, debemos mostrar un mensaje atractivo cuando un visitante inicia sesión, cierra sesión y tal vez en otros momentos.
 
-Functions are the main "building blocks" of the program. They allow the code to be called many times without repetition.
+Las funciones son los principales "bloques de construcción" del programa. Permiten que el código se llame muchas veces sin repetición.
 
-We've already seen examples of built-in functions, like `alert(message)`, `prompt(message, default)` and `confirm(question)`. But we can create functions of our own as well.
+Ya hemos visto ejemplos de funciones integradas, como `alert(message)`, `prompt(message, default)` y `confirm(question)`. Pero también podemos crear funciones propias.
 
-## Function Declaration
+## Declaración de funcicones
 
-To create a function we can use a *function declaration*.
+Para crear una función podemos usar una *declaración de function*.
 
-It looks like this:
+Se Parece a esto:
 
 ```js
 function showMessage() {
-  alert( 'Hello everyone!' );
+  alert( '¡Hola a todos!' );
 }
 ```
 
-The `function` keyword goes first, then goes the *name of the function*, then a list of *parameters* between the parentheses (empty in the example above) and finally the code of the function, also named "the function body", between curly braces.
+La palabra clave `function` va primero, luego una lista de *parámetros* entre paréntesis (vacía en el ejemplo anterior) y finalmente el código de la función, también llamado "el cuerpo de la función" , entre llaves.
 
 ![](function_basics.png)
 
-Our new function can be called by its name: `showMessage()`.
+Nuestra nueva función puede ser llamada por su nombre: `showMessage()`.
 
-For instance:
+Por ejemplo:
 
 ```js run
 function showMessage() {
-  alert( 'Hello everyone!' );
+  alert( '¡Hola a todos!' );
 }
 
 *!*
@@ -39,125 +39,125 @@ showMessage();
 */!*
 ```
 
-The call `showMessage()` executes the code of the function. Here we will see the message two times.
+La llamada `showMessage()` ejecuta el código de la función. Aquí veremos el mensaje dos veces.
 
-This example clearly demonstrates one of the main purposes of functions: to avoid code duplication.
+Este ejemplo demuestra claramente uno de los propósitos principales de las funciones: evitar la duplicación de código..
 
-If we ever need to change the message or the way it is shown, it's enough to modify the code in one place: the function which outputs it.
+Si alguna vez necesitamos cambiar el mensaje o la forma en que se muestra, es suficiente modificar el código en un lugar: la función que lo genera.
 
-## Local variables
+## Variables Locales
 
-A variable declared inside a function is only visible inside that function.
+Una variable declarada dentro de una función solo es visible dentro de esa función.
 
-For example:
+Por ejemplo:
 
 ```js run
 function showMessage() {
 *!*
-  let message = "Hello, I'm JavaScript!"; // local variable
+  let message = "Hola, ¡Soy JavaScript!"; // local variable
 */!*
 
   alert( message );
 }
 
-showMessage(); // Hello, I'm JavaScript!
+showMessage(); // Hola, ¡Soy JavaScript!!
 
-alert( message ); // <-- Error! The variable is local to the function
+alert( message ); // <-- Error! La variable es local para esta función
 ```
 
-## Outer variables
+## Variables Externas
 
-A function can access an outer variable as well, for example:
+Una función también puede acceder a una variable externa, por ejemplo:
 
 ```js run no-beautify
-let *!*userName*/!* = 'John';
+let *!*userName*/!* = 'Juan';
 
 function showMessage() {
-  let message = 'Hello, ' + *!*userName*/!*;
+  let message = 'Hola, ' + *!*userName*/!*;
   alert(message);
 }
 
-showMessage(); // Hello, John
+showMessage(); // Hola, Juan
 ```
 
-The function has full access to the outer variable. It can modify it as well.
+La función tiene acceso completo a la variable externa. Puede modificarlo también.
 
-For instance:
+Por ejemplo:
 
 ```js run
-let *!*userName*/!* = 'John';
+let *!*userName*/!* = 'Juan';
 
 function showMessage() {
-  *!*userName*/!* = "Bob"; // (1) changed the outer variable
+  *!*userName*/!* = "Bob"; // (1) Cambió la variable externa
 
-  let message = 'Hello, ' + *!*userName*/!*;
+  let message = 'Hola, ' + *!*userName*/!*;
   alert(message);
 }
 
-alert( userName ); // *!*John*/!* before the function call
+alert( userName ); // *!*Juan*/!* antes de llamar la función
 
 showMessage();
 
-alert( userName ); // *!*Bob*/!*, the value was modified by the function
+alert( userName ); // *!*Bob*/!*, el valor fué modificado por la función
 ```
 
-The outer variable is only used if there's no local one. So an occasional modification may happen if we forget `let`.
+La variable externa solo se usa si no hay una local. Por lo tanto, puede ocurrir una modificación ocasional si olvidamos colocar el `let`.
 
-If a same-named variable is declared inside the function then it *shadows* the outer one. For instance, in the code below the function uses the local `userName`. The outer one is ignored:
+Si una variable con el mismo nombre se declara dentro de la función, entonces *hace shadowing a* la externa. Por ejemplo, en el siguiente código, la función usa el `userName` local. El exterior se ignora:
 
 ```js run
-let userName = 'John';
+let userName = 'Juan';
 
 function showMessage() {
 *!*
-  let userName = "Bob"; // declare a local variable
+  let userName = "Bob"; // declara variable local
 */!*
 
   let message = 'Hello, ' + userName; // *!*Bob*/!*
   alert(message);
 }
 
-// the function will create and use its own userName
+// la función crea y utiliza su propia variable local userName
 showMessage();
 
-alert( userName ); // *!*John*/!*, unchanged, the function did not access the outer variable
+alert( userName ); // *!*John*/!*, se mantiene, la función no accedió a la variable externa
 ```
 
-```smart header="Global variables"
-Variables declared outside of any function, such as the outer `userName` in the code above, are called *global*.
+```smart header="Variables globales"
+Variables declaradas fuera de cualquier función, como el la variable externa `userName` en el código anterior, se llaman *global*.
 
-Global variables are visible from any function (unless shadowed by locals).
+Las variables globales son visibles desde cualquier función (a menos que estén se haga shadowing en el contexto local).
 
-Usually, a function declares all variables specific to its task. Global variables only store project-level data, and it's important that these variables are accessible from anywhere. Modern code has few or no globals. Most variables reside in their functions.
+Por lo general, una función declara todas las variables específicas de su tarea. Las variables globales solo almacenan datos a nivel de proyecto, y es importante que estas variables sean accesibles desde cualquier lugar. El código moderno tiene pocos o ninguna variable global. La mayoría de las variables residen en sus funciones.
 ```
 
-## Parameters
+## Parámetros
 
-We can pass arbitrary data to functions using parameters (also called *function arguments*) .
+Podemos pasar datos arbitrarios a funciones usando parámetros (también llamados *argumentos de función*).
 
-In the example below, the function has two parameters: `from` and `text`.
+En el siguiente ejemplo, la función tiene dos parámetros: `from` y `text`.
 
 ```js run
-function showMessage(*!*from, text*/!*) { // arguments: from, text
+function showMessage(*!*from, text*/!*) { // argumentos: from, text
   alert(from + ': ' + text);
 }
 
 *!*
-showMessage('Ann', 'Hello!'); // Ann: Hello! (*)
-showMessage('Ann', "What's up?"); // Ann: What's up? (**)
+showMessage('Ann', 'Hola!'); // Ann: Hola! (*)
+showMessage('Ann', "¿Como estás?"); // Ann: ¿Como estás? (**)
 */!*
 ```
 
-When the function is called in lines `(*)` and `(**)`, the given values are copied to local variables `from` and `text`. Then the function uses them.
+Cuando la función se llama `(*)` y `(**)`, los valores dados se copian en variables locales `from` y `text`. Y la función las utiliza.
 
-Here's one more example: we have a variable `from` and pass it to the function. Please note: the function changes `from`, but the change is not seen outside, because a function always gets a copy of the value:
+Aquí hay un ejemplo más: tenemos una variable `from` y la pasamos a la función. Tenga en cuenta: la función cambia `from`, pero el cambio no se ve afuera, porque una función siempre obtiene una copia del valor:
 
 
 ```js run
 function showMessage(from, text) {
 
 *!*
-  from = '*' + from + '*'; // make "from" look nicer
+  from = '*' + from + '*'; // hace que "from" se vea mejor
 */!*
 
   alert( from + ': ' + text );
@@ -165,62 +165,62 @@ function showMessage(from, text) {
 
 let from = "Ann";
 
-showMessage(from, "Hello"); // *Ann*: Hello
+showMessage(from, "Hola"); // *Ann*: Hola
 
-// the value of "from" is the same, the function modified a local copy
+// el valor de "from" es el mismo, la función modificó una copia local
 alert( from ); // Ann
 ```
 
-## Default values
+## Valores predeterminado
 
-If a parameter is not provided, then its value becomes `undefined`.
+Si no se proporciona un parámetro, su valor se convierte en `undefined`.
 
-For instance, the aforementioned function `showMessage(from, text)` can be called with a single argument:
+Por ejemplo, la función mencionada anteriormente `showMessage(from, text)` se puede llamar con un solo argumento:
 
 ```js
 showMessage("Ann");
 ```
 
-That's not an error. Such a call would output `"Ann: undefined"`. There's no `text`, so it's assumed that `text === undefined`.
+Eso no es un error. la llamada saldría `"Ann: undefined"`. No existe el parámetro `text`, entonces asumimos que `text === undefined`.
 
-If we want to use a "default" `text` in this case, then we can specify it after `=`:
+Si quisieramos usar un `text` "predeterminado" en este caso, lo podemos identificar despues del `=`:
 
 ```js run
-function showMessage(from, *!*text = "no text given"*/!*) {
+function showMessage(from, *!*text = "sin texto"*/!*) {
   alert( from + ": " + text );
 }
 
-showMessage("Ann"); // Ann: no text given
+showMessage("Ann"); // Ann: sin texto
 ```
 
-Now if the `text` parameter is not passed, it will get the value `"no text given"`
+Ahora si no existe el parámetro `text`, obtendrá el valor `"sin texto"`
 
-Here `"no text given"` is a string, but it can be a more complex expression, which is only evaluated and assigned if the parameter is missing. So, this is also possible:
+Aquí `"sin texto"` es un string, pero puede ser una expresión mas compleja, la cual solo es evaluada y asignada si el parámetro falta. Entonces, esto es posible:
 
 ```js run
 function showMessage(from, text = anotherFunction()) {
-  // anotherFunction() only executed if no text given
-  // its result becomes the value of text
+  // anotherFunction() solo se ejecuta si el parámetro texto no fué asignado
+  // y su resultado se convierte en el valor de texto
 }
 ```
 
-```smart header="Evaluation of default parameters"
+```smart header="Evaluación de parámetros predeterminado"
 
-In JavaScript, a default parameter is evaluated every time the function is called without the respective parameter. In the example above, `anotherFunction()` is called every time `showMessage()` is called without the `text` parameter. This is in contrast to some other languages like Python, where any default parameters are evaluated only once during the initial interpretation.
+En JavaScript, se evalúa un parámetro predeterminado cada vez que se llama a la función sin el parámetro respectivo. En el ejemplo anterior, se llama a `anotherFunction ()` cada vez que se llama a `showMessage ()` sin el parámetro `text`. Esto contrasta con otros lenguajes como Python, donde los parámetros predeterminados se evalúan solo una vez durante la interpretación inicial.
 
 ```
 
 
-````smart header="Default parameters old-style"
-Old editions of JavaScript did not support default parameters. So there are alternative ways to support them, that you can find mostly in the old scripts.
+````smart header="Parámetros predeterminados de estilo antiguo"
+Las ediciones anteriores de JavaScript no admitían parámetros predeterminados. Por lo tanto, hay formas alternativas de apoyarlos, que se pueden encontrar principalmente en los scripts antiguos.
 
-For instance, an explicit check for being `undefined`:
+Por ejemplo, una comprobación explícita de ser `undefined`:
 
 ```js
 function showMessage(from, text) {
 *!*
   if (text === undefined) {
-    text = 'no text given';
+    text = 'sin texto';
   }
 */!*
 
@@ -228,12 +228,12 @@ function showMessage(from, text) {
 }
 ```
 
-...Or the `||` operator:
+...O el operador `||`
 
 ```js
 function showMessage(from, text) {
-  // if text is falsy then text gets the "default" value
-  text = text || 'no text given';
+  // si text es falso entonces text se convierte en el valor "predeterminado"
+  text = text || 'sin texto';
   ...
 }
 ```
@@ -242,11 +242,11 @@ function showMessage(from, text) {
 ````
 
 
-## Returning a value
+## Devolviendo un valor
 
-A function can return a value back into the calling code as the result.
+Una función puede devolver un valor al código de llamada como resultado.
 
-The simplest example would be a function that sums two values:
+El ejemplo más simple sería una función que suma dos valores:
 
 ```js run no-beautify
 function sum(a, b) {
@@ -257,9 +257,9 @@ let result = sum(1, 2);
 alert( result ); // 3
 ```
 
-The directive `return` can be in any place of the function. When the execution reaches it, the function stops, and the value is returned to the calling code (assigned to `result` above).
+La directiva `return` puede estar en cualquier lugar de la función. Cuando la ejecución lo alcanza, la función se detiene y el valor se devuelve al código de llamada (asignado al `result` anterior).
 
-There may be many occurrences of `return` in a single function. For instance:
+Puede haber muchos casos de `return ` en una sola función. Por ejemplo:
 
 ```js run
 function checkAge(age) {
@@ -269,23 +269,24 @@ function checkAge(age) {
 */!*
   } else {
 *!*
-    return confirm('Do you have permission from your parents?');
+    return confirm('¿Tienes permiso de tus padres?');
 */!*
   }
 }
 
-let age = prompt('How old are you?', 18);
+let age = prompt('¿Que edad tienes?', 18);
 
 if ( checkAge(age) ) {
-  alert( 'Access granted' );
+  alert( 'Acceso otorgado' );
 } else {
-  alert( 'Access denied' );
+  alert( 'Acceso denegado' );
 }
 ```
 
-It is possible to use `return` without a value. That causes the function to exit immediately.
+Es posible utilizar `return` sin ningun valor. Eso hace que la función salga o termine inmediatamente.
 
-For example:
+
+Por ejemplo:
 
 ```js
 function showMovie(age) {
@@ -295,15 +296,15 @@ function showMovie(age) {
 */!*
   }
 
-  alert( "Showing you the movie" ); // (*)
+  alert( "Mostrandote la película" ); // (*)
   // ...
 }
 ```
 
-In the code above, if `checkAge(age)` returns `false`, then `showMovie` won't proceed to the `alert`.
+Enel codigo de arriba, si `checkAge(age)` devuelve `false`, entonces `showMovie` no mostrará la `alert`.
 
-````smart header="A function with an empty `return` or without it returns `undefined`"
-If a function does not return a value, it is the same as if it returns `undefined`:
+````smart header="Una función con un `return` vacio o sin el devuelve `undefined`"
+Si una función no devuelve un valor, es lo mismo que si devuelve `undefined`:
 
 ```js run
 function doNothing() { /* empty */ }
@@ -311,7 +312,7 @@ function doNothing() { /* empty */ }
 alert( doNothing() === undefined ); // true
 ```
 
-An empty `return` is also the same as `return undefined`:
+Un `return` vacío también es lo mismo que `return undefined`:
 
 ```js run
 function doNothing() {
@@ -322,80 +323,80 @@ alert( doNothing() === undefined ); // true
 ```
 ````
 
-````warn header="Never add a newline between `return` and the value"
-For a long expression in `return`, it might be tempting to put it on a separate line, like this:
+````warn header="Nunca agregue una nueva línea entre `return` y el valor"
+Para una expresion larga de `return`, puede ser tentador ponerlo en una línea separada, como esta:
 
 ```js
 return
- (some + long + expression + or + whatever * f(a) + f(b))
+ (una + expresion  + o + cualquier + cosa * f(a) + f(b))
 ```
-That doesn't work, because JavaScript assumes a semicolon after `return`. That'll work the same as:
+Eso no funciona, porque JavaScript asume un punto y coma después del `return`. Eso funcionará igual que:
 
 ```js
 return*!*;*/!*
- (some + long + expression + or + whatever * f(a) + f(b))
+ (una + expresion  + o + cualquier + cosa * f(a) + f(b))
 ```
-So, it effectively becomes an empty return. We should put the value on the same line instead.
+Entonces, efectivamente se convierte en un return vacío. Deberíamos poner el valor en la misma línea.
 ````
 
-## Naming a function [#function-naming]
+## Nomenclatura de funciones [#function-naming]
 
-Functions are actions. So their name is usually a verb. It should be brief, as accurate as possible and describe what the function does, so that someone reading the code gets an indication of what the function does.
+Las funciones son acciones. Entonces su nombre suele ser un verbo. Debe ser breve, lo más preciso posible y describir lo que hace la función, para que alguien que lea el código obtenga una indicación de lo que hace la función.
 
-It is a widespread practice to start a function with a verbal prefix which vaguely describes the action. There must be an agreement within the team on the meaning of the prefixes.
+Es una práctica generalizada comenzar una función con un prefijo verbal que describe vagamente la acción. Debe haber un acuerdo dentro del equipo sobre el significado de los prefijos.
 
-For instance, functions that start with `"show"` usually show something.
+Por ejemplo, funciones que comienzan con `"show"` usualmente muestran algo.
 
-Function starting with...
+Funciónes que comienza con...
 
-- `"get…"` -- return a value,
-- `"calc…"` -- calculate something,
-- `"create…"` -- create something,
-- `"check…"` -- check something and return a boolean, etc.
+- `"get…"` -- devuelven un valor,
+- `"calc…"` -- calcúlan algo,
+- `"create…"` -- crean algo,
+- `"check…"` -- revisan algo y devuelven un boolean, etc.
 
-Examples of such names:
+Ejemplos de este tipo de nombres:
 
 ```js no-beautify
-showMessage(..)     // shows a message
-getAge(..)          // returns the age (gets it somehow)
-calcSum(..)         // calculates a sum and returns the result
-createForm(..)      // creates a form (and usually returns it)
-checkPermission(..) // checks a permission, returns true/false
+showMessage(..)     // muestra un mensaje
+getAge(..)          // devuelve la edad (la obtiene de alguna manera)
+calcSum(..)         // calcula una suma y devuelve el resultado
+createForm(..)      // crea un formulario (y usualmente lo devuelve)
+checkPermission(..) // revisa permisos, y devuelve true/false
 ```
 
-With prefixes in place, a glance at a function name gives an understanding what kind of work it does and what kind of value it returns.
+Con los prefijos en su lugar, un vistazo al nombre de una función permite comprender qué tipo de trabajo realiza y qué tipo de valor devuelve.
 
-```smart header="One function -- one action"
-A function should do exactly what is suggested by its name, no more.
+```smart header="Una función -- una acción"
+Una función debe hacer exactamente lo que sugiere su nombre, no más.
 
-Two independent actions usually deserve two functions, even if they are usually called together (in that case we can make a 3rd function that calls those two).
+Dos acciones independientes por lo general merecen dos funciones, incluso si generalmente se convocan juntas (en ese caso, podemos hacer una tercera función que llame a esas dos).
 
-A few examples of breaking this rule:
+Algunos ejemplos de como se rompen estas reglas:
 
-- `getAge` -- would be bad if it shows an `alert` with the age (should only get).
-- `createForm` -- would be bad if it modifies the document, adding a form to it (should only create it and return).
-- `checkPermission` -- would be bad if it displays the `access granted/denied` message (should only perform the check and return the result).
+- `getAge` -- sería malo si muestra una `alert` con la edad (solo debería obtener).
+- `createForm` -- sería malo si modifica el documento y lo agrega (solo debe crearlo y devolverlo).
+- `checkPermission` -- sería malo si muestra el mensaje `acceso otorgsado/denegado`(solo debe realizar la verificación y devolver el resultado).
 
-These examples assume common meanings of prefixes. What they mean for you is determined by you and your team. Maybe it's pretty normal for your code to behave differently. But you should have a firm understanding of what a prefix means, what a prefixed function can and cannot do. All same-prefixed functions should obey the rules. And the team should share the knowledge.
+Estos ejemplos asumen significados comunes de prefijos. Lo que significan para ti está determinado por ti y tu equipo. Tal vez es bastante normal que su código se comporte de manera diferente. Pero debe tener una comprensión firme de lo que significa un prefijo, lo que una función con prefijo puede y no puede hacer. Todas las funciones con el mismo prefijo deben obedecer las reglas. Y el equipo debe compartir el conocimiento.
 ```
 
-```smart header="Ultrashort function names"
-Functions that are used *very often* sometimes have ultrashort names.
+```smart header="Nombres de funciones ultracortos"
+Las funciones que se utilizan *muy a menudo* algunas veces tienen nombres ultracortos.
 
-For example, the [jQuery](http://jquery.com) framework defines a function with `$`. The [LoDash](http://lodash.com/) library has its core function named `_`.
+Por ejemplo, el framework [jQuery](http://jquery.com) define una función con `$`. La librería [LoDash](http://lodash.com/) tiene como nombre de funccion principal `_`.
 
-These are exceptions. Generally functions names should be concise and descriptive.
+Estas son excepciones. En general, los nombres de las funciones deben ser concisos y descriptivos.
 ```
 
-## Functions == Comments
+## Funciones == Comentarios
 
-Functions should be short and do exactly one thing. If that thing is big, maybe it's worth it to split the function into a few smaller functions. Sometimes following this rule may not be that easy, but it's definitely a good thing.
+Las funciones deben ser cortas y hacer exactamente una cosa. Si esa cosa es grande, tal vez valga la pena dividir la función en algunas funciones más pequeñas. A veces, seguir esta regla puede no ser tan fácil, pero definitivamente es algo bueno.
 
-A separate function is not only easier to test and debug -- its very existence is a great comment!
+Una función separada no solo es más fácil de probar y depurar, -- ¡su existencia es un gran comentario!
 
-For instance, compare the two functions `showPrimes(n)` below. Each one outputs [prime numbers](https://en.wikipedia.org/wiki/Prime_number) up to `n`.
+Por ejemplo, comparemos las dos funciones `showPrimes(n)` siguientes. Cada una devuelve [números primos](https://en.wikipedia.org/wiki/Prime_number) hasta `n`.
 
-The first variant uses a label:
+La primera variante usa una etiqueta:
 
 ```js
 function showPrimes(n) {
@@ -405,12 +406,12 @@ function showPrimes(n) {
       if (i % j == 0) continue nextPrime;
     }
 
-    alert( i ); // a prime
+    alert( i ); // un número primo
   }
 }
 ```
 
-The second variant uses an additional function `isPrime(n)` to test for primality:
+La segunda variante usa una función adicional `isPrime(n)` para probar la primalidad:
 
 ```js
 function showPrimes(n) {
@@ -430,32 +431,32 @@ function isPrime(n) {
 }
 ```
 
-The second variant is easier to understand, isn't it? Instead of the code piece we see a name of the action (`isPrime`). Sometimes people refer to such code as *self-describing*.
+La segunda variante es más fácil de entender, ¿no? En lugar del código, vemos un nombre de la acción. (`isPrime`). A veces las personas se refieren a dicho código como *autodescriptivo*.
 
-So, functions can be created even if we don't intend to reuse them. They structure the code and make it readable.
+Por lo tanto, las funciones se pueden crear incluso si no tenemos la intención de reutilizarlas. Estructuran el código y lo hacen legible.
 
-## Summary
+## Resumen
 
-A function declaration looks like this:
+Una declaración de función se ve así:
 
 ```js
-function name(parameters, delimited, by, comma) {
+function name(parametros, delimitados, por, coma) {
   /* code */
 }
 ```
 
-- Values passed to a function as parameters are copied to its local variables.
-- A function may access outer variables. But it works only from inside out. The code outside of the function doesn't see its local variables.
-- A function can return a value. If it doesn't, then its result is `undefined`.
+- Los valores pasados a una función como parámetros se copian a sus variables locales.
+- Una función puede acceder a variables externas. Pero funciona solo de adentro hacia afuera. El código fuera de la función no ve sus variables locales.
+- Una función puede devolver un valor. Si no lo hace, entonces su resultado es `undefined`.
 
-To make the code clean and easy to understand, it's recommended to use mainly local variables and parameters in the function, not outer variables.
+Para que el código sea limpio y fácil de entender, se recomienda utilizar principalmente variables y parámetros locales en la función, no variables externas.
 
-It is always easier to understand a function which gets parameters, works with them and returns a result than a function which gets no parameters, but modifies outer variables as a side-effect.
+Siempre es más fácil entender una función que obtiene parámetros, trabaja con ellos y devuelve un resultado que una función que no obtiene parámetros, pero modifica las variables externas como un efecto secundario.
 
-Function naming:
+Nomenclatura de funciones:
 
-- A name should clearly describe what the function does. When we see a function call in the code, a good name instantly gives us an understanding what it does and returns.
-- A function is an action, so function names are usually verbal.
-- There exist many well-known function prefixes like `create…`, `show…`, `get…`, `check…` and so on. Use them to hint what a function does.
+- Un nombre debe describir claramente lo que hace la función. Cuando vemos una llamada a la función en el código, un buen nombre nos da al instante una comprensión de lo que hace y devuelve.
+- Una función es una acción, por lo que los nombres de las funciones suelen ser verbales.
+- Existen muchos prefijos de funciones bien conocidos como `create…`, `show…`, `get…`, `check…` y así. Úsalos para insinuar lo que hace una función.
 
-Functions are the main building blocks of scripts. Now we've covered the basics, so we actually can start creating and using them. But that's only the beginning of the path. We are going to return to them many times, going more deeply into their advanced features.
+Las funciones son los principales bloques de construcción de los guiones. Ahora hemos cubierto los conceptos básicos, por lo que en realidad podemos comenzar a crearlos y usarlos. Pero ese es solo el comienzo del camino. Volveremos a ellos muchas veces, profundizando en sus funciones avanzadas.
\ No newline at end of file