From 348eac9f2e85644c1b6a5d8098f3bcbf499f81b1 Mon Sep 17 00:00:00 2001 From: rajcespedes <39871433+rajcespedes@users.noreply.github.com> Date: Wed, 21 Aug 2019 23:34:35 -0400 Subject: [PATCH 1/3] Update article.md --- 1-js/02-first-steps/13-switch/article.md | 113 ++++++++++++----------- 1 file changed, 57 insertions(+), 56 deletions(-) diff --git a/1-js/02-first-steps/13-switch/article.md b/1-js/02-first-steps/13-switch/article.md index 258f24068..38b72c885 100644 --- a/1-js/02-first-steps/13-switch/article.md +++ b/1-js/02-first-steps/13-switch/article.md @@ -1,22 +1,23 @@ -# The "switch" statement +# La sentencia "switch" -A `switch` statement can replace multiple `if` checks. +Una sentencia `switch` puede reemplazar múltiples condiciones `if`. -It gives a more descriptive way to compare a value with multiple variants. +Provee una mejor manera de comparar un valor con sus múltiples variantes. -## The syntax -The `switch` has one or more `case` blocks and an optional default. +## La sintaxis -It looks like this: +`switch` tiene uno o mas bloques `case`y un opcional `default`. + +Se ve de esta forma: ```js no-beautify switch(x) { - case 'value1': // if (x === 'value1') + case 'valor1': // if (x === 'valor1') ... [break] - case 'value2': // if (x === 'value2') + case 'valor2': // if (x === 'valor2') ... [break] @@ -26,71 +27,71 @@ switch(x) { } ``` -- 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). +- El valor de `x` es revisado para una igualdad estricta con el valor del primer `case` (el cual es, `valor1`) luego a el segundo (`valor2`) y así suscesivamente. +- 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). -## An example +## Ejemplo -An example of `switch` (the executed code is highlighted): +Un ejemplo de `switch` (se resalta el código ejecutado): ```js run let a = 2 + 2; switch (a) { case 3: - alert( 'Too small' ); + alert( 'Muy pequeño' ); break; *!* case 4: - alert( 'Exactly!' ); + alert( '¡Exacto!' ); break; */!* case 5: - alert( 'Too large' ); + alert( 'Muy grande' ); break; default: - alert( "I don't know such values" ); + alert( "Desconozco estos valores" ); } ``` -Here the `switch` starts to compare `a` from the first `case` variant that is `3`. The match fails. +Aquí el `switch` inicia comparando `a` con la primera variante `case` que es `3`. La comparación falla. -Then `4`. That's a match, so the execution starts from `case 4` until the nearest `break`. +Luego `4`. La comparación es exitosa, por tanto la ejecución empieza desde `case 4` hasta el `break` más cercano. -**If there is no `break` then the execution continues with the next `case` without any checks.** +**Si no existe `break` entonces la ejecución continúa con el próximo `case` si ninguna revisión.** -An example without `break`: +Un ejemplo sin `break`: ```js run let a = 2 + 2; switch (a) { case 3: - alert( 'Too small' ); + alert( 'Muy pequeño' ); *!* case 4: - alert( 'Exactly!' ); + alert( '¡Exacto!' ); case 5: - alert( 'Too big' ); + alert( 'Muy grande' ); default: - alert( "I don't know such values" ); + alert( "Desconozco estos valores" ); */!* } ``` -In the example above we'll see sequential execution of three `alert`s: +En el ejemplo anterior veremos ejecuciones de tres `alert` secuenciales: ```js -alert( 'Exactly!' ); -alert( 'Too big' ); -alert( "I don't know such values" ); +alert( '¡Exacto!' ); +alert( 'Muy grande' ); +alert( "Desconozco estos valores" ); ``` -````smart header="Any expression can be a `switch/case` argument" -Both `switch` and `case` allow arbitrary expressions. +````encabezado inteligente="Cualquier expresión puede ser un argumento `switch/case`" +Ambos `switch` y `case` permiten expresiones arbitrarias. -For example: +Por ejemplo: ```js run let a = "1"; @@ -99,74 +100,74 @@ let b = 0; switch (+a) { *!* case b + 1: - alert("this runs, because +a is 1, exactly equals b+1"); + alert("esto se ejecuta, porque +a es 1, exactamente igual b+1"); break; */!* default: - alert("this doesn't run"); + alert("esto no se ejecuta"); } ``` -Here `+a` gives `1`, that's compared with `b + 1` in `case`, and the corresponding code is executed. +Aquí `+a` da `1`, esto es comparado con `b + 1` en `case`, y el código correspondiente es ejecutado. ```` -## Grouping of "case" +## Agrupamiento de "case" -Several variants of `case` which share the same code can be grouped. +Varias variantes de `case` los cuales comparten el mismo código pueden ser agrupadas. -For example, if we want the same code to run for `case 3` and `case 5`: +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('Right!'); + alert('¡Correcto!'); break; *!* - case 3: // (*) grouped two cases + case 3: // (*) agrupando dos cases case 5: - alert('Wrong!'); - alert("Why don't you take a math class?"); + alert('¡Incorrecto!'); + alert("¿Por qué no tomas una clase de matemáticas?"); break; */!* default: - alert('The result is strange. Really.'); + alert('El resultado es extraño. Realmente.'); } ``` -Now both `3` and `5` show the same message. +Ahora ambos `3` y `5` muestran el mismo mensaje. -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`. +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`. -## Type matters +## El tipo importa -Let's emphasize that the equality check is always strict. The values must be of the same type to match. +Vamos a enfatizar que la comparación de igualdad es siempre strict. Los valores deben ser del mismo tipo para coincidir. -For example, let's consider the code: +Por ejemplo, consideremos el código: ```js run -let arg = prompt("Enter a value?"); +let arg = prompt("Ingrese un valor"); switch (arg) { case '0': case '1': - alert( 'One or zero' ); + alert( 'Uno o cero' ); break; case '2': - alert( 'Two' ); + alert( 'Dos' ); break; case 3: - alert( 'Never executes!' ); + alert( '¡Nunca ejecuta!' ); break; default: - alert( 'An unknown value' ); + alert( 'Un valor desconocido' ); } ``` -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. +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á. From 54422b63cc4ea2b7d007146b85a405c9b9366eb8 Mon Sep 17 00:00:00 2001 From: rajcespedes <39871433+rajcespedes@users.noreply.github.com> Date: Thu, 22 Aug 2019 00:43:22 -0400 Subject: [PATCH 2/3] Update article.md --- 1-js/02-first-steps/13-switch/article.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/1-js/02-first-steps/13-switch/article.md b/1-js/02-first-steps/13-switch/article.md index 38b72c885..38d5bcf62 100644 --- a/1-js/02-first-steps/13-switch/article.md +++ b/1-js/02-first-steps/13-switch/article.md @@ -59,7 +59,7 @@ Aquí el `switch` inicia comparando `a` con la primera variante `case` que es `3 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` si ninguna revisión.** +**Si no existe `break` entonces la ejecución continúa con el próximo `case` sin ninguna revisión.** Un ejemplo sin `break`: @@ -144,7 +144,7 @@ La habilidad para "agrupar" cases es un efecto secundario de como trabaja `switc ## El tipo importa -Vamos a enfatizar que la comparación de igualdad es siempre strict. Los valores deben ser del mismo tipo para coincidir. +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: From eb147eabf6207faa90a94451741092c54d2e41cf Mon Sep 17 00:00:00 2001 From: rajcespedes <39871433+rajcespedes@users.noreply.github.com> Date: Thu, 22 Aug 2019 00:54:28 -0400 Subject: [PATCH 3/3] Update article.md --- 1-js/02-first-steps/13-switch/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/02-first-steps/13-switch/article.md b/1-js/02-first-steps/13-switch/article.md index 38d5bcf62..0f20e05a8 100644 --- a/1-js/02-first-steps/13-switch/article.md +++ b/1-js/02-first-steps/13-switch/article.md @@ -27,7 +27,7 @@ switch(x) { } ``` -- El valor de `x` es revisado para una igualdad estricta con el valor del primer `case` (el cual es, `valor1`) luego a el segundo (`valor2`) y así suscesivamente. +- 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).