Update article.md

Add corrections to translation.

Author: odsantos

1-js/02-first-steps/13-switch/article.md

@@ -2,13 +2,13 @@
 
 Uma instrução `switch` pode substituir muitas comparações `if` (se).
 
-Ela é uma forma mais descritiva de comparar um valor com múltiplas variantes.
+Ela é uma forma mais descritiva de comparar um valor a múltiplas variantes.
 
 ## A sintaxe
 
 O `switch` tem um ou mais blocos `case` (caso) e um `default` (padrão) opcional.
 
-Tem uma apresentação similar a:
+Tem um aspeto semelhante a:
 
 ```js no-beautify
 switch(x) {
@@ -27,8 +27,8 @@ switch(x) {
 ```
 
 - O valor de `x` é comparado por meio de uma igualdade exata ao valor do primeiro `case` (isto é, ao `valor1`), a seguir ao do segundo (`valor2`) e assim sucessivamente.
-- Se uma igualdade é encontrada, o `switch` começa a executar o código a partir do início do `case` correspondente, até ao próximo `break` (ou até ao fim do `switch`).
-- Se nenhum `case` é equiparado então o código em `default` é executado (se existir).
+- Se uma igualdade for encontrada, o `switch` começa a executar o código a partir do início do `case` correspondente, até ao próximo `break` (ou até ao fim do `switch`).
+- Se nenhum `case` for igual então o código em `default` é executado (se existir).
 
 ## Um exemplo
 
@@ -58,7 +58,7 @@ Aqui o `switch` começa por comparar `a` à variante no primeiro `case`, que é
 
 Então a `4`. Existe uma correspondência, e assim a execução começa a partir do `case 4` até ao próximo `break`.
 
-**Se não existir um `break` então a execução continua pelo próximo `case` sem quaisquer verificações.**
+**Se não existir um `break` então a execução continua pelo próximo `case` sem adicionais verificações.**
 
 Um exemplo sem `break`:
 
@@ -99,22 +99,22 @@ let b = 0;
 switch (+a) {
 *!*
   case b + 1:
-    alert("isto executa, porque +a é 1, e é exatamente igual a b+1");
+    alert("isto é executado, porque +a é 1, e é exatamente igual a b+1");
     break;
 */!*
 
   default:
-    alert("isto não executa");
+    alert("isto não é executado");
 }
 ```
-Aqui `+a` dá `1`, o que é comparado a `b + 1` no `case`, e o código correspondente é executado.
+Aqui `+a` dá `1`, que é comparado a `b + 1` no `case`, e o código correspondente é executado.
 ````
 
 ## Grupos de "case"
 
 Múltiplas variantes de `case` que partihem o mesmo código podem ser agrupadas.
 
-Por exemplo, se quisermos que o mesmo código corra por `case 3` e `case 5`:
+Por exemplo, se quisermos que o mesmo código corra para `case 3` e `case 5`:
 
 ```js run no-beautify
 let a = 2 + 2;
@@ -125,7 +125,7 @@ switch (a) {
     break;
 
 *!*
-  case 3:                    // (*) dois cases agrupados
+  case 3:                    // (*) dois 'cases' agrupados
   case 5:
     alert('Errado!');
     alert("Porque não tem aulas de matemática?");
@@ -139,7 +139,7 @@ switch (a) {
 
 Agora ambos `3` e `5` mostram a mesma mensagem.
 
-A habilidade para "agrupar" cases é um efeito secundário de como `switch/case` funciona sem `break`. Aqui a execução do `case 3` começa pela linha `(*)` e prossegue pelo `case 5`, por não existir `break`.
+A habilidade para "agrupar" cases é um efeito secundário de como o `switch/case` funciona sem `break`. Aqui a execução do `case 3` começa pela linha `(*)` e prossegue pelo `case 5`, por não existir `break`.
 
 ## O tipo importa
 
@@ -167,7 +167,6 @@ switch (arg) {
 }
 ```
 
-1. Para `0`, `1`, o primeiro `alert` executa.
+1. Para `0`, `1`, o primeiro `alert` é executado.
 2. Para `2` o segundo `alert` corre.
-3. Mas para `3`, o resultado do `prompt` á a string `"3"`, que não é estritamente igual `===` ao número `3`. Assim temos código não
-executável em `case 3`! A variante `default` será executada.
+3. Mas para `3`, o resultado do `prompt` á a string `"3"`, que não é estritamente igual `===` ao número `3`. Assim temos código sem efeito em `case 3`! A variante `default` será executada.