Aplica sugestões do revisor

Author: ermogenes

1-js/02-first-steps/01-hello-world/1-hello-alert/solution.md

@@ -1,2 +0,0 @@
-
-[html src="index.html"]

1-js/02-first-steps/12-nullish-coalescing-operator/article.md

@@ -25,20 +25,20 @@ Agora, deveria estar completamente claro o que `??` faz. Vamos ver onde ele é 
 
 O caso de uso comum para `??` é obter um valor padrão para uma variável potencialmente indefinida.
 
-Por exemplo, aqui exibimos `Anônimo` se `usuario` não for definido:
+Por exemplo, aqui exibimos `Anônimo` se `user` não for definido:
 
 ```js run
-let usuario;
+let user;
 
-alert(usuario ?? "Anônimo"); // Anônimo (usuario não definido)
+alert(user ?? "Anônimo"); // Anônimo ("user" não definido)
 ```
 
-Aqui está o exemplo com um nome atribuido a `user`:
+Aqui está o exemplo com um nome atribuído a `user`:
 
 ```js run
-let usuario = "João";
+let user = "João";
 
-alert(usuario ?? "Anônimo"); // João (usuario está definido)
+alert(user ?? "Anônimo"); // João ("user" está definido)
 ```
 
 Podemos também usar uma sequência de `??` para selecionar o primeiro valor em uma lista que não seja `null/undefined`.
@@ -50,13 +50,13 @@ Gostaríamos de exibir o nome do usuário usando uma dessas variáveis, ou exibi
 Para isso usaremos o operador `??`:
 
 ```js run
-let nome = null;
-let sobrenome = null;
-let apelido = "Supercoder";
+let firstName = null;
+let lastName = null;
+let nickName = "Supercoder";
 
 // exibe o primeiro valor definido:
 *!*
-alert(nome ?? sobrenome ?? apelido ?? "Anônimo"); // Supercoder
+alert(firstName ?? lastName ?? nickName ?? "Anônimo"); // Supercoder
 */!*
 ```
 
@@ -67,13 +67,13 @@ O operador OU `||` pode ser utilizado da mesma forma que `??`, como descrito no
 Por exemplo, no código acima podemos substituir `??` por `||` e o resultado se mantém:
 
 ```js run
-let nome = null;
-let sobrenome = null;
-let apelido = "Supercoder";
+let firstName = null;
+let lastName = null;
+let nickName = "Supercoder";
 
 // exibe o primeiro valor avaliado como verdadeiro:
 *!*
-alert(nome || sobrenome || apelido || "Anônimo"); // Supercoder
+alert(firstName || lastName || nickName || "Anônimo"); // Supercoder
 */!*
 ```
 
@@ -88,21 +88,21 @@ A principal diferença entre eles é:
 
 Em outras palavras, `||` não diferencia entre `false`, `0`, uma string vazia `""` e `null/undefined`. Todos são igualmente valores avaliados como falsos. Se algum desses for o primeiro argumento de `||`, então teremos o segundo argumento como resultado.
 
-Na prática, porém, gostaríamos de usar valores padrão somente se a variável é `null/undefined`. Ou seja, quando o valor realmente seja desconhecido/não definido.
+Na prática, porém, gostaríamos de usar valores padrão somente se a variável é `null/undefined`. Ou seja, quando o valor seja realmente desconhecido/não definido.
 
 Por exemplo, considere isso:
 
 ```js run
-let altura = 0;
+let height = 0;
 
-alert(altura || 100); // 100
-alert(altura ?? 100); // 0
+alert(height || 100); // 100
+alert(height ?? 100); // 0
 ```
 
-- `altura || 100` verifica se `altura` é um valor avaliado como falso, e como é `0`, de fato é.
+- `height || 100` verifica se `height` é um valor avaliado como falso, e como é `0`, de fato é.
   - então o resultado de `||` é o segundo argumento, `100`.
-- `altura ?? 100` verifica se `altura` é `null/undefined`, e não é,
-  - então o resultado é o valor atual de `altura`, que é `0`.
+- `height ?? 100` verifica se `height` é `null/undefined`, e não é,
+  - então o resultado é o valor atual de `height`, que é `0`.
 
 Na prática, a altura igual a zero é um valor válido que não deve ser substituído pelo valor padrão, então usar `??` é o correto.
 
@@ -115,11 +115,11 @@ Isto significa que, tal como `||`, o operador de coalescência nula `??` é aval
 Então, se quiser selecionar um valor com `??` em uma expressão com outros operadores, considere o uso de parênteses:
 
 ```js run
-let altura = null;
-let largura = null;
+let height = null;
+let width = null;
 
 // importante: use parênteses
-let area = (altura ?? 100) * (largura ?? 50);
+let area = (height ?? 100) * (width ?? 50);
 
 alert(area); // 5000
 ```
@@ -128,15 +128,15 @@ Caso contrário, se omitirmos os parênteses, como `*` tem maior precedência qu
 
 ```js
 // sem parênteses
-let area = altura ?? 100 * largura ?? 50;
+let area = height ?? 100 * width ?? 50;
 
 // ...funciona desta forma (provavelmente não como gostaríamos):
-let area = altura ?? 100 * largura ?? 50;
+let area = height ?? 100 * width ?? 50;
 ```
 
 ### Usando ?? com && ou ||
 
-Por razões de segurança, o JavaScript proíbe o uso de `??` juntamente com os operadores `&&` e `||`, a menos que a precedência seja explicitamente especificada usando parênteses.
+Por razões de segurança, o JavaScript proíbe o uso de `??` junto dos operadores `&&` e `||`, a menos que a precedência seja explicitamente especificada usando parênteses.
 
 O código abaixo dispara um erro de sintaxe:
 
@@ -163,8 +163,8 @@ alert(x); // 2
   É usado para atribuir valores a variáveis:
 
   ```js
-  // grava altura=100, se altura é null ou undefined
-  altura = altura ?? 100;
+  // grava height=100, se height é null ou undefined
+  height = height ?? 100;
   ```
 
 - O operador `??` possui uma precedência muito baixa, um pouco maior que `?` e `=`, portanto considere adicionar parênteses quando utilizá-lo em uma expressão.