diff --git a/1-js/02-first-steps/13-switch/article.md b/1-js/02-first-steps/13-switch/article.md
deleted file mode 100644
index 258f24068..000000000
--- a/1-js/02-first-steps/13-switch/article.md
+++ /dev/null
@@ -1,172 +0,0 @@
-# The "switch" statement
-
-A `switch` statement can replace multiple `if` checks.
-
-It gives a more descriptive way to compare a value with multiple variants.
-
-## The syntax
-
-The `switch` has one or more `case` blocks and an optional default.
-
-It looks like this:
-
-```js no-beautify
-switch(x) {
- case 'value1': // if (x === 'value1')
- ...
- [break]
-
- case 'value2': // if (x === 'value2')
- ...
- [break]
-
- default:
- ...
- [break]
-}
-```
-
-- The value of `x` is checked for a strict equality to the value from the first `case` (that is, `value1`) then to the second (`value2`) and so on.
-- If the equality is found, `switch` starts to execute the code starting from the corresponding `case`, until the nearest `break` (or until the end of `switch`).
-- If no case is matched then the `default` code is executed (if it exists).
-
-## An example
-
-An example of `switch` (the executed code is highlighted):
-
-```js run
-let a = 2 + 2;
-
-switch (a) {
- case 3:
- alert( 'Too small' );
- break;
-*!*
- case 4:
- alert( 'Exactly!' );
- break;
-*/!*
- case 5:
- alert( 'Too large' );
- break;
- default:
- alert( "I don't know such values" );
-}
-```
-
-Here the `switch` starts to compare `a` from the first `case` variant that is `3`. The match fails.
-
-Then `4`. That's a match, so the execution starts from `case 4` until the nearest `break`.
-
-**If there is no `break` then the execution continues with the next `case` without any checks.**
-
-An example without `break`:
-
-```js run
-let a = 2 + 2;
-
-switch (a) {
- case 3:
- alert( 'Too small' );
-*!*
- case 4:
- alert( 'Exactly!' );
- case 5:
- alert( 'Too big' );
- default:
- alert( "I don't know such values" );
-*/!*
-}
-```
-
-In the example above we'll see sequential execution of three `alert`s:
-
-```js
-alert( 'Exactly!' );
-alert( 'Too big' );
-alert( "I don't know such values" );
-```
-
-````smart header="Any expression can be a `switch/case` argument"
-Both `switch` and `case` allow arbitrary expressions.
-
-For example:
-
-```js run
-let a = "1";
-let b = 0;
-
-switch (+a) {
-*!*
- case b + 1:
- alert("this runs, because +a is 1, exactly equals b+1");
- break;
-*/!*
-
- default:
- alert("this doesn't run");
-}
-```
-Here `+a` gives `1`, that's compared with `b + 1` in `case`, and the corresponding code is executed.
-````
-
-## Grouping of "case"
-
-Several variants of `case` which share the same code can be grouped.
-
-For example, if we want the same code to run for `case 3` and `case 5`:
-
-```js run no-beautify
-let a = 2 + 2;
-
-switch (a) {
- case 4:
- alert('Right!');
- break;
-
-*!*
- case 3: // (*) grouped two cases
- case 5:
- alert('Wrong!');
- alert("Why don't you take a math class?");
- break;
-*/!*
-
- default:
- alert('The result is strange. Really.');
-}
-```
-
-Now both `3` and `5` show the same message.
-
-The ability to "group" cases is a side-effect of how `switch/case` works without `break`. Here the execution of `case 3` starts from the line `(*)` and goes through `case 5`, because there's no `break`.
-
-## Type matters
-
-Let's emphasize that the equality check is always strict. The values must be of the same type to match.
-
-For example, let's consider the code:
-
-```js run
-let arg = prompt("Enter a value?");
-switch (arg) {
- case '0':
- case '1':
- alert( 'One or zero' );
- break;
-
- case '2':
- alert( 'Two' );
- break;
-
- case 3:
- alert( 'Never executes!' );
- break;
- default:
- alert( 'An unknown value' );
-}
-```
-
-1. For `0`, `1`, the first `alert` runs.
-2. For `2` the second `alert` runs.
-3. But for `3`, the result of the `prompt` is a string `"3"`, which is not strictly equal `===` to the number `3`. So we've got a dead code in `case 3`! The `default` variant will execute.
diff --git a/1-js/02-first-steps/14-switch/article.md b/1-js/02-first-steps/14-switch/article.md
new file mode 100644
index 000000000..68aaa6b1a
--- /dev/null
+++ b/1-js/02-first-steps/14-switch/article.md
@@ -0,0 +1,174 @@
+# La sentencia "switch"
+
+Una sentencia `switch` puede reemplazar múltiples condiciones `if`.
+
+Provee una mejor manera de comparar un valor con sus múltiples variantes.
+
+
+## La sintaxis
+
+`switch` tiene uno o mas bloques `case`y un opcional `default`.
+
+Se ve de esta forma:
+
+```js no-beautify
+switch(x) {
+ case 'valor1': // if (x === 'valor1')
+ ...
+ [break]
+
+ case 'valor2': // if (x === 'valor2')
+ ...
+ [break]
+
+ default:
+ ...
+ [break]
+}
+```
+
+- El valor de `x` es comparado contra el valor del primer `case` (en este caso, `valor1`), luego contra el segundo (`valor2`) y así sucesivamente, todo esto bajo una igualdad estricta.
+- Si la igualdad es encontrada, `switch` empieza a ejecutar el código iniciando por el primer `case` correspondiente, hasta el `break` más cercano (o hasta el final del `switch`).
+- Si no se cumple ningún caso entonces el código `default` es ejecutado (si existe).
+
+## Ejemplo
+
+Un ejemplo de `switch` (se resalta el código ejecutado):
+
+```js run
+let a = 2 + 2;
+
+switch (a) {
+ case 3:
+ alert( 'Muy pequeño' );
+ break;
+*!*
+ case 4:
+ alert( '¡Exacto!' );
+ break;
+*/!*
+ case 5:
+ alert( 'Muy grande' );
+ break;
+ default:
+ alert( "Desconozco estos valores" );
+}
+```
+
+Aquí el `switch` inicia comparando `a` con la primera variante `case` que es `3`. La comparación falla.
+
+Luego `4`. La comparación es exitosa, por tanto la ejecución empieza desde `case 4` hasta el `break` más cercano.
+
+**Si no existe `break` entonces la ejecución continúa con el próximo `case` sin ninguna revisión.**
+
+Un ejemplo sin `break`:
+
+```js run
+let a = 2 + 2;
+
+switch (a) {
+ case 3:
+ alert( 'Muy pequeño' );
+*!*
+ case 4:
+ alert( '¡Exacto!' );
+ case 5:
+ alert( 'Muy grande' );
+ default:
+ alert( "Desconozco estos valores" );
+*/!*
+}
+```
+
+En el ejemplo anterior veremos ejecuciones de tres `alert` secuenciales:
+
+```js
+alert( '¡Exacto!' );
+alert( 'Muy grande' );
+alert( "Desconozco estos valores" );
+```
+
+````encabezado inteligente="Cualquier expresión puede ser un argumento `switch/case`"
+Ambos `switch` y `case` permiten expresiones arbitrarias.
+
+Por ejemplo:
+
+```js run
+let a = "1";
+let b = 0;
+
+switch (+a) {
+*!*
+ case b + 1:
+ alert("esto se ejecuta, porque +a es 1, exactamente igual b+1");
+ break;
+*/!*
+
+ default:
+ alert("esto no se ejecuta");
+}
+```
+Aquí `+a` da `1`, esto es comparado con `b + 1` en `case`, y el código correspondiente es ejecutado.
+````
+
+## Agrupamiento de "case"
+
+Varias variantes de `case` los cuales comparten el mismo código pueden ser agrupadas.
+
+Por ejemplo, si queremos que se ejecute el mismo código para `case 3` y `case 5`:
+
+```js run no-beautify
+let a = 2 + 2;
+
+switch (a) {
+ case 4:
+ alert('¡Correcto!');
+ break;
+
+*!*
+ case 3: // (*) agrupando dos cases
+ case 5:
+ alert('¡Incorrecto!');
+ alert("¿Por qué no tomas una clase de matemáticas?");
+ break;
+*/!*
+
+ default:
+ alert('El resultado es extraño. Realmente.');
+}
+```
+
+Ahora ambos `3` y `5` muestran el mismo mensaje.
+
+La habilidad para "agrupar" cases es un efecto secundario de como trabaja `switch/case` sin `break`. Aquí la ejecución de `case 3` inicia desde la línea `(*)` y continúa a través de `case 5`, porque no existe `break`.
+
+## El tipo importa
+
+Vamos a enfatizar que la comparación de igualdad es siempre estricta. Los valores deben ser del mismo tipo para coincidir.
+
+Por ejemplo, consideremos el código:
+
+```js run
+let arg = prompt("Ingrese un valor");
+switch (arg) {
+ case '0':
+ case '1':
+ alert( 'Uno o cero' );
+ break;
+
+ case '2':
+ alert( 'Dos' );
+ break;
+
+ case 3:
+ alert( '¡Nunca ejecuta!' );
+ break;
+ default:
+ alert( 'Un valor desconocido' );
+}
+```
+
+1. Para `0`, `1`, se ejecuta el primer `alert`.
+2. Para `2` se ejecuta el segundo `alert`.
+3. Pero para `3`, el resultado del `prompt` es un string `"3"`, el cual no es estrictamente igual `===` al número `3`. Por tanto ¡Tenemos un código muerto en `case 3`! La variante `default` se ejecutará.
+
\ No newline at end of file
pFad - Phonifier reborn
Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.
Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.
Alternative Proxies:
Alternative Proxy
pFad Proxy
pFad v3 Proxy
pFad v4 Proxy