chore(i18n,curriculum): update translations (#43073)
This commit is contained in:
camperbot
GitHub
@ -9,7 +9,7 @@ dashedName: local-scope-and-functions
|
||||
|
||||
# --description--
|
||||
|
||||
Variáveis que são declaradas dentro de uma função, assim como parâmetros de funções, possuem escopo <dfn>local</dfn>. Isso significa que eles são visíveis apenas dentro da função.
|
||||
Variáveis que são declaradas dentro de uma função, assim como parâmetros das funções, possuem escopo <dfn>local</dfn>. Isso significa que elas são visíveis apenas dentro da função.
|
||||
|
||||
Aqui está uma função `myTest` com uma variável local chamada `loc`.
|
||||
|
||||
@ -26,7 +26,7 @@ A chamada da função `myTest()` vai exibir a string `foo` no console. A linha `
|
||||
|
||||
# --instructions--
|
||||
|
||||
O editor possui dois `console.log` para te ajudar a ver o que está acontecendo. Verifique o console enquanto codifica para ver como muda. Declare uma variável local `myVar` dentro de `myLocalScope` e rode os testes.
|
||||
O editor possui dois `console.log` para ajudar você a ver o que está acontecendo. Verifique o console enquanto codifica para ver como muda. Declare uma variável local `myVar` dentro de `myLocalScope` e rode os testes.
|
||||
|
||||
**Observação:** o console ainda exibirá `ReferenceError: myVar is not defined`, mas isso não causará falha nos testes.
|
||||
|
||||
|
||||
@ -9,11 +9,11 @@ dashedName: logical-order-in-if-else-statements
|
||||
|
||||
# --description--
|
||||
|
||||
Ordem é importante em instruções `if` e `else if`.
|
||||
A ordem é importante em instruções `if` e `else if`.
|
||||
|
||||
A função é executada de cima para baixo, então você deve ser cuidados com qual instrução vem primeiro.
|
||||
A função é executada de cima para baixo, então você deve ser cuidadoso com qual instrução vem primeiro.
|
||||
|
||||
Tomem essas duas funções como exemplo.
|
||||
Tomemos como exemplo estas duas funções.
|
||||
|
||||
Aqui está a primeira:
|
||||
|
||||
@ -29,7 +29,7 @@ function foo(x) {
|
||||
}
|
||||
```
|
||||
|
||||
E a segunda apenas altera a ordem das instruções if e else if:
|
||||
A segunda apenas altera a ordem das instruções if e else if:
|
||||
|
||||
```js
|
||||
function bar(x) {
|
||||
@ -43,14 +43,14 @@ function bar(x) {
|
||||
}
|
||||
```
|
||||
|
||||
Embora as duas funções se pareçam praticamente idênticas, se nós passarmos um número para ambos nós teremos saídas diferentes.
|
||||
Embora as duas funções pareçam praticamente idênticas, se passarmos um número para ambas, teremos saídas diferentes.
|
||||
|
||||
```js
|
||||
foo(0)
|
||||
bar(0)
|
||||
```
|
||||
|
||||
`foo(0)` retornará a string `Less than one`, e `bar(0)` retornará a string `Less than two`.
|
||||
`foo(0)` retornará a string `Less than one` e `bar(0)` retornará a string `Less than two`.
|
||||
|
||||
# --instructions--
|
||||
|
||||
|
||||
@ -11,7 +11,7 @@ dashedName: manipulate-arrays-with-pop
|
||||
|
||||
Outra forma de alterar os dados em um array é com a função `.pop()`.
|
||||
|
||||
`.pop()` é usado para remover um valor do final do array. Nós podemos armazenar esse valor removido ao atribuir a saída da chamada do método a uma variável. Em outras palavras, `.pop()` remove o último elemento de um array e retorna aquele elemento.
|
||||
`.pop()` é usado para remover um valor do final do array. Nós podemos armazenar esse valor removido atribuindo-o a uma variável. Em outras palavras, `.pop()` remove o último elemento de um array e retorna aquele elemento.
|
||||
|
||||
Qualquer tipo de entrada pode ser removida de um array - numbers, strings e até mesmo arrays aninhados.
|
||||
|
||||
@ -22,7 +22,7 @@ console.log(oneDown);
|
||||
console.log(threeArr);
|
||||
```
|
||||
|
||||
O primeiro `console.log` exibirá o valor `6`, e o segundo exibirá o valor `[1, 4]`.
|
||||
O primeiro `console.log` exibirá o valor `6` e o segundo exibirá o valor `[1, 4]`.
|
||||
|
||||
# --instructions--
|
||||
|
||||
|
||||
@ -27,7 +27,7 @@ arr2.push(["happy", "joy"]);
|
||||
|
||||
# --instructions--
|
||||
|
||||
Empurre `["dog", 3]` no final da variável `myArray`.
|
||||
Empurre `["dog", 3]` para o final da variável `myArray`.
|
||||
|
||||
# --hints--
|
||||
|
||||
|
||||
@ -9,9 +9,9 @@ dashedName: manipulate-arrays-with-unshift
|
||||
|
||||
# --description--
|
||||
|
||||
Não só você pode `remover` elementos do início de um array, como você também pode `adicionar (unshift)` elementos ao início de um array i.e. adiciona elementos na frente do array.
|
||||
Você pode não apenas usar `shift` para remover elementos do início de um array, como também pode usar `unshift` para adicionar elementos ao início de um array, ou seja, adicionar elementos na posição inicial do array.
|
||||
|
||||
`.unshift()` funciona exatamente como `.push()`, mas ao invés de adicionar o elemento ao final do array, `unshift` adiciona o elemento no início do array.
|
||||
`.unshift()` funciona exatamente como `.push()`, mas, ao invés de adicionar o elemento ao final do array, `unshift()` adiciona o elemento no início do array.
|
||||
|
||||
Exemplo:
|
||||
|
||||
|
||||
@ -9,7 +9,7 @@ dashedName: manipulating-complex-objects
|
||||
|
||||
# --description--
|
||||
|
||||
Às vezes você pode querer armazenar dados em uma <dfn>Estrutura de Dados</dfn> flexível. Um objeto JavaScript é uma forma de lidar com dados flexíveis. Eles permitem combinações arbitrárias de <dfn>strings</dfn>, <dfn>numbers</dfn>, <dfn>booleans</dfn>, <dfn>arrays</dfn>, <dfn>functions</dfn> e <dfn>objects</dfn>.
|
||||
Às vezes, você pode querer armazenar dados em uma <dfn>Estrutura de Dados</dfn> flexível. Um objeto JavaScript é uma forma de lidar com dados flexíveis. Eles permitem combinações arbitrárias de <dfn>strings</dfn>, <dfn>numbers</dfn>, <dfn>booleans</dfn>, <dfn>arrays</dfn>, <dfn>functions</dfn> e <dfn>objects</dfn>.
|
||||
|
||||
Aqui está um exemplo de estrutura de dados complexas:
|
||||
|
||||
@ -29,7 +29,7 @@ var ourMusic = [
|
||||
];
|
||||
```
|
||||
|
||||
Isto é um array o qual contém um objeto dentro dele. O objeto possui vários pedaços de <dfn>metadados</dfn> sobre um album. Também possui um array aninhado `formats`. Se você quiser adicionar mais discos de album, você pode fazer isso ao adicionar os discos no array de alto nível. Objetos armazenam dados em uma propriedade, a qual possui um formato de chave-valor. No exemplo acima, `"artist": "Daft Punk"` é uma propriedade que tem uma chave `artist` e um valor de `Daft Punk`. [Notação de Objeto JavaScript](http://www.json.org/) ou `JSON` é um formato, de interalteração de dados relacionados, usado para armazenar dados.
|
||||
Este é um array que contém um objeto dentro dele. O objeto possui vários pedaços de <dfn>metadados</dfn> sobre um álbum. Também possui um array aninhado `formats`. Se você quiser adicionar mais álbuns, você pode fazer isso adicionando os discos ao array de alto nível. Objetos armazenam dados em uma propriedade, a qual possui um formato de chave-valor. No exemplo acima, `"artist": "Daft Punk"` é uma propriedade que tem uma chave `artist` e um valor de `Daft Punk`. [JavaScript Object Notation](http://www.json.org/) ou `JSON` é um formato de intercâmbio de dados relacionados usado para armazenar dados.
|
||||
|
||||
```json
|
||||
{
|
||||
@ -45,11 +45,11 @@ Isto é um array o qual contém um objeto dentro dele. O objeto possui vários p
|
||||
}
|
||||
```
|
||||
|
||||
**Observação:** você precisará colocar uma vírgula após cada objeto no array, a não ser que for o último objeto no array.
|
||||
**Observação:** você precisará colocar uma vírgula após cada objeto no array, a não ser que ele seja o último objeto no array.
|
||||
|
||||
# --instructions--
|
||||
|
||||
Adicione um novo álbum para o array `myMusic`. Adicione strings: `artist` e `title`, número: `release_year`, e um array de strings: `formats`.
|
||||
Adicione um novo álbum para o array `myMusic`. Adicione as strings `artist` e `title`, o número `release_year` e um array de strings `formats`.
|
||||
|
||||
# --hints--
|
||||
|
||||
@ -71,13 +71,13 @@ Os elementos no array `myMusic` devem ser objetos
|
||||
myMusic.forEach(object => {assert.typeOf(object, 'object')})
|
||||
```
|
||||
|
||||
Seu objeto em `myMusic` deve ter pelo menos 4 propriedades
|
||||
O objeto em `myMusic` deve ter pelo menos 4 propriedades
|
||||
|
||||
```js
|
||||
myMusic.forEach(object => {assert(Object.keys(object).length > 3); });
|
||||
```
|
||||
|
||||
Seu objeto em `myMusic` deve conter a propriedade `artist` a qual é uma string
|
||||
O objeto em `myMusic` deve conter a propriedade `artist`, do tipo string
|
||||
|
||||
```js
|
||||
myMusic.forEach(object => {
|
||||
@ -86,7 +86,7 @@ myMusic.forEach(object => {
|
||||
})
|
||||
```
|
||||
|
||||
Seu objeto em `myMusic` deve conter a propriedade `title` a qual é uma string
|
||||
O objeto em `myMusic` deve conter a propriedade `title`, do tipo string
|
||||
|
||||
```js
|
||||
myMusic.forEach(object => {
|
||||
@ -95,7 +95,7 @@ myMusic.forEach(object => {
|
||||
})
|
||||
```
|
||||
|
||||
Seu objeto em `myMusic` deve conter a propriedade `release_year` a qual é um número
|
||||
O objeto em `myMusic` deve conter a propriedade `release_year`, do tipo number
|
||||
|
||||
```js
|
||||
myMusic.forEach(object => {
|
||||
@ -104,7 +104,7 @@ myMusic.forEach(object => {
|
||||
})
|
||||
```
|
||||
|
||||
Seu objeto em `myMusic` deve conter a propriedade `formats` a qual é um array
|
||||
O objeto em `myMusic` deve conter a propriedade `formats`, que será um array
|
||||
|
||||
```js
|
||||
myMusic.forEach(object => {
|
||||
|
||||
@ -20,7 +20,7 @@ ourArray[0] = 15;
|
||||
|
||||
`ourArray` agora tem o valor `[15, 40, 30]`.
|
||||
|
||||
**Observação:** não deve ter espaços entre o nome do array e os colchetes, como `array [0]`. Embora JavaScript é capaz de processar isso corretamente, isso pode causar confusão em outros programadores lendo o seu código.
|
||||
**Observação:** não deve haver espaços entre o nome do array e os colchetes, como `array [0]`. Embora JavaScript seja capaz de processar isso corretamente, isso pode confundir outros programadores lendo seu código.
|
||||
|
||||
# --instructions--
|
||||
|
||||
|
||||
@ -9,7 +9,7 @@ dashedName: multiple-identical-options-in-switch-statements
|
||||
|
||||
# --description--
|
||||
|
||||
Se a instrução `break` for omitida de uma instrução `case` de um `switch`, as instruções seguintes `case` são executadas até que seja encontrado um `break`. Se você tem várias entradas com a mesma saída, você pode representá-los em uma instrução `switch` da seguinte forma:
|
||||
Se a instrução `break` for omitida de uma instrução `case` de um `switch`, as instruções `case` seguintes serão executadas até que seja encontrado um `break`. Se você tem várias entradas com a mesma saída, você pode representá-las em uma instrução `switch` da seguinte forma:
|
||||
|
||||
```js
|
||||
var result = "";
|
||||
@ -91,7 +91,7 @@ assert(sequentialSizes(8) === 'High');
|
||||
assert(sequentialSizes(9) === 'High');
|
||||
```
|
||||
|
||||
Você não deve usar nenhuma das instruções `if` ou `else`
|
||||
Você não deve usar nenhuma instrução do tipo `if` ou `else`
|
||||
|
||||
```js
|
||||
assert(!/else/g.test(code) || !/if/g.test(code));
|
||||
|
||||
@ -11,7 +11,7 @@ dashedName: multiply-two-decimals-with-javascript
|
||||
|
||||
Em JavaScript, você também pode realizar cálculos com números decimais, assim como com números inteiros.
|
||||
|
||||
Vamos multiplicar dois decimais juntos para obter o produto deles.
|
||||
Vamos multiplicar dois decimais para obter o produto deles.
|
||||
|
||||
# --instructions--
|
||||
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: cf1111c1c11feddfaeb7bdef
|
||||
title: Aninhar um array com outro array
|
||||
title: Aninhar um array em outro array
|
||||
challengeType: 1
|
||||
videoUrl: 'https://scrimba.com/c/crZQZf8'
|
||||
forumTopicId: 18247
|
||||
|
||||
@ -9,7 +9,7 @@ dashedName: nesting-for-loops
|
||||
|
||||
# --description--
|
||||
|
||||
Se você possui um array multidimensional, você pode usar a mesma lógica no ponto de passagem anterior para iterar através ambos os arrays e qualquer sub-arrays. Exemplo:
|
||||
Se você possui um array multidimensional, você pode usar a mesma lógica no ponto de passagem anterior para iterar através de arrays e de qualquer sub-array. Exemplo:
|
||||
|
||||
```js
|
||||
var arr = [
|
||||
@ -22,11 +22,11 @@ for (var i=0; i < arr.length; i++) {
|
||||
}
|
||||
```
|
||||
|
||||
Isso exibe no console cada sub elemento dentro de `arr`, um de cada vez. Note que para o laço interno, nós estamos verificando a propriedade `.length` de `arr[i]`, desde que `arr[i]` também é um array.
|
||||
Isso exibe no console cada subelemento dentro de `arr`, um de cada vez. Note que para o laço interno, nós estamos verificando a propriedade `.length` de `arr[i]`, desde que `arr[i]` também seja um array.
|
||||
|
||||
# --instructions--
|
||||
|
||||
Modifique a função `multiplyAll` para que retorne o produto de todos os números nos sub arrays de `arr`.
|
||||
Modifique a função `multiplyAll` para que retorne o produto de todos os números nos sub-arrays de `arr`.
|
||||
|
||||
# --hints--
|
||||
|
||||
|
||||
@ -17,7 +17,7 @@ Se os valores sendo comparados não são do mesmo tipo, o operador de igualdade
|
||||
|
||||
`3 == '3'` retorna `true` porque JavaScript faz a conversão de tipo de string para número. `3 === '3'` retorna falso porque os tipos são diferentes e não é feita a conversão de tipo.
|
||||
|
||||
**Observação:** em JavaScript, você pode determinar o tipo de uma variável ou de um valor, com o operador `typeof`, como se segue:
|
||||
**Observação:** em JavaScript, você pode determinar o tipo de uma variável ou de um valor, com o operador `typeof`, como vemos a seguir:
|
||||
|
||||
```js
|
||||
typeof 3
|
||||
|
||||
@ -9,7 +9,7 @@ dashedName: profile-lookup
|
||||
|
||||
# --description--
|
||||
|
||||
Nós temos um array de objetos representando pessoas diferentes nas nossas listas de contatos.
|
||||
Temos um array de objetos representando pessoas diferentes nas nossas listas de contatos.
|
||||
|
||||
Uma função `lookUpProfile`, que recebe `name` e uma propriedade (`prop`) como argumentos, foi pré-escrita para você.
|
||||
|
||||
|
||||
@ -9,20 +9,20 @@ dashedName: quoting-strings-with-single-quotes
|
||||
|
||||
# --description--
|
||||
|
||||
Valores de <dfn>String</dfn> em JavaScript podem ser escritas com aspas simples ou duplas, desde que você comece e termine com o mesmo tipo de aspas. Diferente de outras linguagens de programação, aspas simples e duplas funcionam da mesma forma em JavaScript.
|
||||
Valores de <dfn>string</dfn> em JavaScript podem ser escritas com aspas simples ou duplas, desde que você comece e termine com o mesmo tipo de aspas. Diferente de outras linguagens de programação, aspas simples e duplas funcionam da mesma forma em JavaScript.
|
||||
|
||||
```js
|
||||
doubleQuoteStr = "This is a string";
|
||||
singleQuoteStr = 'This is also a string';
|
||||
```
|
||||
|
||||
O motivo pelo qual você pode querer usar um tipo de aspas no lugar da outra, é se você vir a querer usar ambas em uma string. Isso pode acontecer se você quiser salvar uma conversa em uma string e ter a conversa entre aspas. Outro uso para isso seria salvar uma tag `<a>` com vários atributos em aspas, tudo dentro de uma string.
|
||||
O motivo pelo qual você pode querer usar um tipo de aspas no lugar da outra é se você vir a querer usar ambas em uma string. Isso pode acontecer se você quiser salvar uma conversa em uma string e ter a conversa entre aspas. Outro uso para isso seria salvar uma tag `<a>` com vários atributos em aspas, tudo dentro de uma string.
|
||||
|
||||
```js
|
||||
conversation = 'Finn exclaims to Jake, "Algebraic!"';
|
||||
```
|
||||
|
||||
Porém, isso se torna um problema se você precisar usar as aspas mais extremas dentro dela. Lembre-se, uma string tem o mesmo tipo de aspas no início e no final. Mas se você tem aquela mesma aspa em algum lugar no meio, a string irá terminar mais cedo e lançará um erro.
|
||||
Porém, isso se torna um problema se você precisar usar as aspas mais extremas dentro dela. Lembre-se, uma string tem o mesmo tipo de aspas no início e no final. Mas se você tem aquela mesma aspa em algum lugar no meio, a string vai terminar mais cedo e lançará um erro.
|
||||
|
||||
```js
|
||||
goodStr = 'Jake asks Finn, "Hey, let\'s go on an adventure?"';
|
||||
@ -39,7 +39,7 @@ Na string <dfn>goodStr</dfn> acima, você pode usar ambas as aspas com seguranç
|
||||
|
||||
Altere a string fornecida para uma string com aspas simples no início e no final e sem caracteres de escapamento.
|
||||
|
||||
Nesse momento, a tag `<a>` na string usa aspas duplas em todo canto. Você precisará alterar as aspas mais externas em aspas simples, para que você possa remover os caracteres de escapamento.
|
||||
Nesse momento, a tag `<a>` na string usa aspas duplas em todo canto. Você precisará alterar as aspas mais externas para aspas simples, para que você possa remover os caracteres de escapamento.
|
||||
|
||||
# --hints--
|
||||
|
||||
|
||||
@ -10,10 +10,10 @@ dashedName: record-collection
|
||||
|
||||
Você recebeu um objeto literal representando uma parte da sua coleção de álbuns musicais. Cada álbum possui um número de id único como sua chave e diversas outras propriedades. Nem todos os álbuns possuem informações completas.
|
||||
|
||||
Você começa com uma função `updateRecords` que recebe um objeto literal, `records`, contendo a coleção de álbuns musicais, um `id`, uma </code>prop</code>(like `artist` ou `tracks`) e um `vlaue`. Complete a função usando as regras abaixo para modificar o objeto passado para a função.
|
||||
Você começa com uma função `updateRecords` que recebe um objeto literal, `records`, contendo a coleção de álbuns musicais, um `id`, uma `prop`(like `artist` ou `tracks`) e um `value`. Complete a função usando as regras abaixo para modificar o objeto passado para a função.
|
||||
|
||||
- Sua função precisa sempre retornar o objeto de coleção de discos completo.
|
||||
- Se `prop` não for `tracks` e `value` não for uma string vazia, atualize ou defina aquela `prop` do album como `value`.
|
||||
- A função precisa sempre retornar o objeto de coleção de discos completo.
|
||||
- Se `prop` não for `tracks` e `value` não for uma string vazia, atualize ou defina aquela `prop` do álbum como `value`.
|
||||
- Se `prop` for `tracks` mas o álbum não tiver uma propriedade `tracks`, crie um array vazio e adicione o `value` nesse array.
|
||||
- Se `prop` for `tracks` e `value` não for uma string vazia, adicione `value` ao final do array existente de `tracks` do álbum.
|
||||
- Se `value` for uma string vazia, remova a propriedade `prop` recebida do álbum.
|
||||
@ -22,7 +22,7 @@ Você começa com uma função `updateRecords` que recebe um objeto literal, `re
|
||||
|
||||
# --hints--
|
||||
|
||||
Após `updateRecords(recordCollection, 5439, "artist", "ABBA")`, `artist` deve ser aa string `ABBA`
|
||||
Após `updateRecords(recordCollection, 5439, "artist", "ABBA")`, `artist` deve ser a string `ABBA`
|
||||
|
||||
```js
|
||||
assert(
|
||||
|
||||
@ -10,7 +10,7 @@ dashedName: replace-loops-using-recursion
|
||||
|
||||
# --description--
|
||||
|
||||
Recursividade é o conceito de que uma função pode ser chamada por ela mesmo. Para ajudar a entender isso, comece a pensar sobre a seguinte tarefa: multiplique os primeiros `n` elementos de um array para criar o produto desses elementos. Usando um laço `for`, você poderia fazer isso:
|
||||
Recursão é o conceito de que uma função pode ser chamada por ela mesma. Para ajudar a entender isso, comece a pensar sobre a seguinte tarefa: multiplique os primeiros `n` elementos de um array para criar o produto desses elementos. Usando um laço `for`, você poderia fazer isso:
|
||||
|
||||
```js
|
||||
function multiply(arr, n) {
|
||||
@ -22,7 +22,7 @@ Recursividade é o conceito de que uma função pode ser chamada por ela mesmo.
|
||||
}
|
||||
```
|
||||
|
||||
No entanto, note que `multiply(arr, n) == multiply(arr, n - 1) * arr[n - 1]`. Isso significa que você pode rescreve `multiply` dentro da própria função e nunca precisar de usar um laço.
|
||||
No entanto, note que `multiply(arr, n) == multiply(arr, n - 1) * arr[n - 1]`. Isso significa que você pode reescrever `multiply` dentro da própria função e nunca precisar usar um laço.
|
||||
|
||||
```js
|
||||
function multiply(arr, n) {
|
||||
@ -34,9 +34,9 @@ No entanto, note que `multiply(arr, n) == multiply(arr, n - 1) * arr[n - 1]`. Is
|
||||
}
|
||||
```
|
||||
|
||||
A versão recursiva de `multiply` fica dessa forma. No <dfn>caso de base</dfn>, onde `n <= 0`, ele retorna 1. Para valores maiores de `n`, a função chama a si mesmo, mas com `n - 1`. Essa chamada da função é avaliada da mesma forma, chamando `multiply` novamente até que `n <= 0`. Nesse ponto, todas as funções podem retornar e a função `multiply` original retorna a resposta.
|
||||
A versão recursiva de `multiply` fica dessa forma. No <dfn>caso de base</dfn>, onde `n <= 0`, ele retorna 1. Para valores maiores de `n`, a função chama a si mesma, mas com `n - 1`. Essa chamada da função é avaliada da mesma forma, chamando `multiply` novamente até que `n <= 0`. Nesse ponto, todas as funções podem retornar e a função `multiply` original retorna a resposta.
|
||||
|
||||
**Observação:** funções recursivas precisam ter um caso base quando elas retornam sem chamar a função novamente (nesse exemplo, quando `n <= 0`), caso contrário, elas nunca vão parar de executar.
|
||||
**Observação:** funções recursivas precisam ter um caso de base quando elas retornam sem chamar a função novamente (nesse exemplo, quando `n <= 0`), caso contrário, elas nunca vão parar de executar.
|
||||
|
||||
# --instructions--
|
||||
|
||||
@ -62,7 +62,7 @@ assert.equal(sum([2, 3, 4], 1), 2);
|
||||
assert.equal(sum([2, 3, 4, 5], 3), 9);
|
||||
```
|
||||
|
||||
Seu código não deve depender de nenhum laço (`for` ou `while` ou funções de ordem superior como as funções `forEach`, `map`, `filter` ou `reduce`.).
|
||||
O código não deve depender de nenhum laço (`for` ou `while` ou funções de ordem superior como as funções `forEach`, `map`, `filter` ou `reduce`.).
|
||||
|
||||
```js
|
||||
assert(
|
||||
@ -70,7 +70,7 @@ assert(
|
||||
);
|
||||
```
|
||||
|
||||
Você deve usar recursividade para resolver o problema.
|
||||
Você deve usar recursão para resolver o problema.
|
||||
|
||||
```js
|
||||
assert(
|
||||
|
||||
@ -38,7 +38,7 @@ switch(val) {
|
||||
|
||||
# --instructions--
|
||||
|
||||
Altere a cadeia de instruções `if`/`else if` em um comando `switch`.
|
||||
Altere a cadeia de instruções `if`/`else if` por um comando `switch`.
|
||||
|
||||
# --hints--
|
||||
|
||||
|
||||
@ -22,14 +22,14 @@ function myFun() {
|
||||
myFun();
|
||||
```
|
||||
|
||||
O código acima exibirá no console a string `Hello`, e retorna a string `World`. A string `byebye` nunca irá ser exibida no console, porque a função termina na instrução `return`.
|
||||
O código acima exibirá no console a string `Hello`, e retorna a string `World`. A string `byebye` nunca vai ser exibida no console, porque a função termina na instrução `return`.
|
||||
|
||||
# --instructions--
|
||||
|
||||
Modifique a função `abTest` para que se `a` ou `b` forem menores que `0` a função irá imediatamente terminar retornando o valor de `undefined`.
|
||||
|
||||
**Dica**
|
||||
Lembre-se que [`undefined` é uma palavra-chave](https://www.freecodecamp.org/learn/javascript-algorithms-and-data-structures/basic-javascript/understanding-uninitialized-variables) e não uma string.
|
||||
Lembre-se de que [`undefined` é uma palavra-chave](https://www.freecodecamp.org/learn/javascript-algorithms-and-data-structures/basic-javascript/understanding-uninitialized-variables) e não uma string.
|
||||
|
||||
# --hints--
|
||||
|
||||
|
||||
@ -9,9 +9,9 @@ dashedName: returning-boolean-values-from-functions
|
||||
|
||||
# --description--
|
||||
|
||||
Você pode se lembrar de [Comparação com o Operador de Igualdade](/learn/javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-equality-operator) que todas os operadores de comparação retornam um valor booleano `true` ou `false`.
|
||||
Você pode se lembrar de [Comparação com o operador de igualdade](/learn/javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-equality-operator), em que todos os operadores de comparação retornam um valor booleano `true` ou `false`.
|
||||
|
||||
As vezes as pessoas usam uma instrução `if/else` para fazer uma comparação, dessa forma:
|
||||
Às vezes, as pessoas usam uma instrução `if/else` para fazer uma comparação, dessa forma:
|
||||
|
||||
```js
|
||||
function isEqual(a,b) {
|
||||
@ -49,7 +49,7 @@ assert(isLess(10, 15) === true);
|
||||
assert(isLess(15, 10) === false);
|
||||
```
|
||||
|
||||
Você não deve usar nenhuma das instruções `if` ou `else`
|
||||
Você não deve usar nenhuma instrução do tipo `if` ou `else`
|
||||
|
||||
```js
|
||||
assert(!/if|else/g.test(code));
|
||||
|
||||
@ -9,7 +9,7 @@ dashedName: selecting-from-many-options-with-switch-statements
|
||||
|
||||
# --description--
|
||||
|
||||
Se você possui muitas opções pra escolher, use uma instrução <dfn>switch</dfn>. Uma instrução `switch` testa um valor e pode ter muitas instruções <dfn>case</dfn> as quais definem os diversos valores possíveis. Instruções são executadas desde o primeiro `case` correspondente até que encontre um `break`.
|
||||
Se você possui muitas opções pra escolher, use uma instrução <dfn>switch</dfn>. Uma instrução `switch` testa um valor e pode ter muitas instruções <dfn>case</dfn> as quais definem os diversos valores possíveis. As instruções são executadas desde o primeiro `case` correspondente até que seja encontrado um `break`.
|
||||
|
||||
Aqui está um exemplo de uma instrução `switch`:
|
||||
|
||||
@ -24,7 +24,7 @@ switch(lowercaseLetter) {
|
||||
}
|
||||
```
|
||||
|
||||
Valores `case` são testados com o operador de igualdade estrita (`===`). O `break` diz ao JavaScript parar a execução das instruções. Se o `break` for omitido, a próxima instrução case será executada.
|
||||
Valores `case` são testados com o operador de igualdade estrita (`===`). O `break` diz ao JavaScript parar interromper a execução das instruções. Se o `break` for omitido, a próxima instrução case será executada.
|
||||
|
||||
# --instructions--
|
||||
|
||||
|
||||
@ -9,15 +9,15 @@ dashedName: shopping-list
|
||||
|
||||
# --description--
|
||||
|
||||
Crie uma lista de compras na variável `myList`. A lista deve ser um array multidimensional contendo diversos sub arrays.
|
||||
Crie uma lista de compras na variável `myList`. A lista deve ser um array multidimensional contendo diversos sub-arrays.
|
||||
|
||||
O primeiro elemento em cada sub array deve conter uma string com o nome do item. O segundo elemento deve ser um número representando a quantidade i.e.
|
||||
O primeiro elemento em cada sub-array deve conter uma string com o nome do item. O segundo elemento deve ser um número representando a quantidade, ou seja,
|
||||
|
||||
```js
|
||||
["Chocolate Bar", 15]
|
||||
```
|
||||
|
||||
Deve ter pelo menos 5 sub arrays na lista.
|
||||
Deve haver pelo menos 5 sub-arrays na lista.
|
||||
|
||||
# --hints--
|
||||
|
||||
@ -27,13 +27,13 @@ Deve ter pelo menos 5 sub arrays na lista.
|
||||
assert(isArray);
|
||||
```
|
||||
|
||||
Os primeiros elementos em cada um dos seus sub arrays devem ser todos strings.
|
||||
Os primeiros elementos em cada um dos seus sub-arrays devem ser todos strings.
|
||||
|
||||
```js
|
||||
assert(hasString);
|
||||
```
|
||||
|
||||
Os segundos elementos em cada um de seus sub arrays devem ser todos números.
|
||||
Os segundos elementos em cada um de seus sub-arrays devem ser todos números.
|
||||
|
||||
```js
|
||||
assert(hasNumber);
|
||||
|
||||
@ -9,9 +9,9 @@ dashedName: stand-in-line
|
||||
|
||||
# --description--
|
||||
|
||||
Na Ciência da Computação uma <dfn>fila</dfn> é uma <dfn>estrutura de dados</dfn> abstrata onde itens são mantidos em ordem. Novos itens podem ser adicionados no final da fila e itens mais antigos são removidos do início da fila.
|
||||
Na Ciência da Computação, uma <dfn>fila</dfn> é uma <dfn>estrutura de dados</dfn> abstrata onde itens são mantidos em ordem. Novos itens podem ser adicionados no final da fila e itens mais antigos são removidos do início da fila.
|
||||
|
||||
Escreva a função `nextInLine` a qual recebe um array (`arr`) e um número (`item`) como argumentos.
|
||||
Escreva a função `nextInLine`, que recebe um array (`arr`) e um número (`item`) como argumentos.
|
||||
|
||||
Adicione o número no final do array e então remova o primeiro elemento do array.
|
||||
|
||||
@ -25,7 +25,7 @@ A função `nextInLine` deve, em seguida, retornar o elemento que foi removido.
|
||||
assert.isNumber(nextInLine([], 5));
|
||||
```
|
||||
|
||||
`nextInLine([], 1)` deve retonar `1`
|
||||
`nextInLine([], 1)` deve retornar `1`
|
||||
|
||||
```js
|
||||
assert(nextInLine([], 1) === 1);
|
||||
|
||||
@ -9,9 +9,9 @@ dashedName: store-multiple-values-in-one-variable-using-javascript-arrays
|
||||
|
||||
# --description--
|
||||
|
||||
Com as variáveis de `array` em JavaScript, podemos armazenar diversos pedaços de dados em um único lugar.
|
||||
Com as variáveis de `array` em JavaScript, podemos armazenar diversos dados em um único lugar.
|
||||
|
||||
Você começa uma declaração de um array com a abertura de um colchetes, terminando com o fechamento do colchetes e colocando vírgula entre cada entrada, dessa forma:
|
||||
Você começa uma declaração de um array com a abertura de um colchetes, terminando com o fechamento do colchetes e colocando vírgulas entre cada entrada, dessa forma:
|
||||
|
||||
```js
|
||||
var sandwich = ["peanut butter", "jelly", "bread"]
|
||||
@ -19,7 +19,7 @@ var sandwich = ["peanut butter", "jelly", "bread"]
|
||||
|
||||
# --instructions--
|
||||
|
||||
Modifique o novo array `myArray` para que contenha ambos uma string e um número (nessa ordem).
|
||||
Modifique o novo array `myArray` para que contenha uma string e um número (nessa ordem).
|
||||
|
||||
# --hints--
|
||||
|
||||
|
||||
@ -15,16 +15,16 @@ Em JavaScript, você pode armazenar um valor em uma variável com o operador de
|
||||
myVariable = 5;
|
||||
```
|
||||
|
||||
Isso atribui o valor de `Number` `5` para `myVariable`.
|
||||
Isso atribui um valor do tipo `Number` de `5` para `myVariable`.
|
||||
|
||||
Se há qualquer cálculo a direita do operador `=`, esses cálculos são executados antes do valor ser atribuído à variável na esquerda do operador.
|
||||
Se há qualquer cálculo à direita do operador `=`, esses cálculos são executados antes do valor ser atribuído à variável na esquerda do operador.
|
||||
|
||||
```js
|
||||
var myVar;
|
||||
myVar = 5;
|
||||
```
|
||||
|
||||
Primeiro, esse código cria uma variável chamada `myVar`. Em seguida, o código atribui `5` para `myVar`. Agora, se `myVar` aparece novamente no código, o programa vai tratar como se fosse `5`.
|
||||
Primeiro, esse código cria uma variável chamada `myVar`. Em seguida, o código atribui `5` para `myVar`. Agora, se `myVar` aparece novamente no código, o programa vai tratá-la como se fosse `5`.
|
||||
|
||||
# --instructions--
|
||||
|
||||
|
||||
@ -9,7 +9,7 @@ dashedName: testing-objects-for-properties
|
||||
|
||||
# --description--
|
||||
|
||||
Às vezes é útil verificar se a propriedade de um determinado objeto existe ou não. Podemos usar o método de objetos `.hasOwnProperty(propname)` para determinar se aquele objeto possui o nome de propriedade fornecido. `.hasOwnProperty()` retorna `true` ou `false` se a propriedade for encontrada ou não.
|
||||
Às vezes, é útil verificar se a propriedade de um determinado objeto existe ou não. Podemos usar o método de objetos `.hasOwnProperty(propname)` para determinar se aquele objeto possui o nome de propriedade fornecido. `.hasOwnProperty()` retorna `true` ou `false` se a propriedade for encontrada ou não.
|
||||
|
||||
**Exemplo**
|
||||
|
||||
|
||||
@ -18,7 +18,7 @@ var myStr = "Bob";
|
||||
myStr[0] = "J";
|
||||
```
|
||||
|
||||
não é possível alterar o valor de `myStr` para `Job`, porque o conteúdo de `myStr` não pode ser alterado. Note que isso *não* significa que `myStr` não pode ser alterado, apenas que os caracteres individuais de uma <dfn>string literal</dfn> não pode ser alterado. A única forma de alterar `myStr` seria atribuindo-a com uma nova string, dessa forma:
|
||||
não permite alterar o valor de `myStr` para `Job`, porque o conteúdo de `myStr` não pode ser alterado. Note que isso *não* significa que `myStr` não pode ser alterado, apenas que os caracteres individuais de uma <dfn>string literal</dfn> não podem ser alterados. A única forma de alterar `myStr` seria atribuindo a ela uma nova string, dessa forma:
|
||||
|
||||
```js
|
||||
var myStr = "Bob";
|
||||
|
||||
@ -9,17 +9,17 @@ dashedName: understanding-boolean-values
|
||||
|
||||
# --description--
|
||||
|
||||
Outro tipo de dado é o <dfn>Boolean</dfn>. Booleanos podem ser apenas dois valores: `true` ou `false`. Eles basicamente são interruptores pequenos, onde `true` é ligado e `false` é desligado. Esses dois estados são mutuamente exclusivos.
|
||||
Outro tipo de dado é o <dfn>booleano</dfn>. Booleanos podem ser apenas dois valores: `true` ou `false`. Eles basicamente são interruptores pequenos, onde `true` é ligado e `false` é desligado. Esses dois estados são mutuamente exclusivos.
|
||||
|
||||
**Observação:** valores booleanos nunca são escritos com aspas. As strings `"true"` e `"false"` não são Booleanos e não tem nenhum significado especial em JavaScript.
|
||||
**Observação:** valores booleanos nunca são escritos com aspas. As strings `"true"` e `"false"` não são booleanos e não tem nenhum significado especial em JavaScript.
|
||||
|
||||
# --instructions--
|
||||
|
||||
Modifique a função `welcomeToBooleans` para que retorne `true` ao invés de `false` quando o botão de correr for clicado.
|
||||
Modifique a função `welcomeToBooleans` para que retorne `true` ao invés de `false` quando o botão de executar for clicado.
|
||||
|
||||
# --hints--
|
||||
|
||||
A função `welcomeToBooleans()` deve retornar um valor Booleano (`true` ou `false`).
|
||||
A função `welcomeToBooleans()` deve retornar um valor booleano (`true` ou `false`).
|
||||
|
||||
```js
|
||||
assert(typeof welcomeToBooleans() === 'boolean');
|
||||
|
||||
@ -13,7 +13,7 @@ Em JavaScript todas os nomes de variáveis e funções são sensíveis a caracte
|
||||
|
||||
`MYVAR` não é o mesmo que `MyVar` nem `myvar`. É possível ter diversas variáveis distintas com o mesmo nome mas com capitalização diferente. É extremamente recomendado pelo bem da clareza, que você *não* use esse recurso da linguagem.
|
||||
|
||||
**Melhores Práticas**
|
||||
**Melhores práticas**
|
||||
|
||||
Escreva nomes de variáveis em JavaScript em <dfn>camelCase</dfn>. Em <dfn>camelCase</dfn>, nomes de variáveis com mais de uma palavra possuem a primeira palavra toda em minúscula e a primeira letra de cada palavra subsequente capitalizada.
|
||||
|
||||
|
||||
@ -9,7 +9,7 @@ dashedName: understanding-undefined-value-returned-from-a-function
|
||||
|
||||
# --description--
|
||||
|
||||
Uma função pode incluir a instrução `return` mas ela não precisa fazer isso. No caso de a função não ter uma instrução `return`, quando você chamá-la, a função processa o código interno, mas o valor retornado é `undefined`.
|
||||
Uma função pode incluir a instrução `return` mas ela não precisa fazer isso. No caso de a função não ter uma instrução `return`, quando você a chamar, a função processa o código interno, mas o valor retornado é `undefined`.
|
||||
|
||||
**Exemplo**
|
||||
|
||||
@ -21,7 +21,7 @@ function addSum(num) {
|
||||
addSum(3);
|
||||
```
|
||||
|
||||
`addSum` é uma função sem uma instrução `return`. A função irá alterar a variável global `sum`, mas o valor retornado da função é `undefined`.
|
||||
`addSum` é uma função sem uma instrução `return`. A função vai alterar a variável global `sum`, mas o valor retornado da função é `undefined`.
|
||||
|
||||
# --instructions--
|
||||
|
||||
@ -41,7 +41,7 @@ Uma vez que ambas as funções são executadas, a `sum` deve ser igual a `8`.
|
||||
assert(sum === 8);
|
||||
```
|
||||
|
||||
Valor retornado de `addFive` deve ser `undefined`.
|
||||
O valor retornado de `addFive` deve ser `undefined`.
|
||||
|
||||
```js
|
||||
assert(addFive() === undefined);
|
||||
|
||||
@ -26,7 +26,7 @@ Como ele é um cachorro particularmente feliz, vamos mudar seu nome para o texto
|
||||
|
||||
# --instructions--
|
||||
|
||||
Atualize a propriedade name do objeto `myDog`. Vamos alterar o valor da propriedade name dela de `Coder` para `Happy Coder`. Você pode usar notação de ponto ou de colchetes.
|
||||
Atualize a propriedade name do objeto `myDog`. Vamos alterar o valor da propriedade name dele de `Coder` para `Happy Coder`. Você pode usar notação de ponto ou de colchetes.
|
||||
|
||||
# --hints--
|
||||
|
||||
|
||||
@ -9,11 +9,11 @@ dashedName: use-bracket-notation-to-find-the-first-character-in-a-string
|
||||
|
||||
# --description--
|
||||
|
||||
<dfn>Notação de Colchetes</dfn> é uma forma de pegar um caractere no índice especificado dentro de uma string.
|
||||
<dfn>Notação de colchetes</dfn> é uma forma de pegar um caractere no índice especificado dentro de uma string.
|
||||
|
||||
A maioria das linguagens de programações modernas, como JavaScript, não começa contando do 1 como humanos fazem. Eles começam no 0. Isso é referido como indexação <dfn>baseada em zero</dfn>.
|
||||
A maioria das linguagens de programação modernas, como JavaScript, não começa contando do 1 como humanos fazem. Elas começam no 0. Isso é referido como indexação <dfn>baseada em zero</dfn>.
|
||||
|
||||
Por exemplo, o caractere no índice 0 da palavra `Charles` é `C`. Então se `var firstName = "Charles"`, você pode pegar o valor da primeira letra da string usando `firstName[0]`.
|
||||
Por exemplo, o caractere no índice 0 da palavra `Charles` é `C`. Então, se `var firstName = "Charles"`, você pode pegar o valor da primeira letra da string usando `firstName[0]`.
|
||||
|
||||
Exemplo:
|
||||
|
||||
@ -28,7 +28,7 @@ var firstLetter = firstName[0];
|
||||
|
||||
Use notação de colchetes para encontrar o primeiro caractere na variável `lastName` e atribua a letra para a variável `firstLetterOfLastName`.
|
||||
|
||||
**Dica:** Tente olhar o exemplo acima se você ficar travado.
|
||||
**Dica:** tente olhar o exemplo acima se você ficar travado.
|
||||
|
||||
# --hints--
|
||||
|
||||
|
||||
@ -9,7 +9,7 @@ dashedName: use-bracket-notation-to-find-the-last-character-in-a-string
|
||||
|
||||
# --description--
|
||||
|
||||
Em ordem para pegar a última letra de uma string, você pode subtrair um do tamanho da string.
|
||||
Para pegar a última letra de uma string, você pode subtrair um do tamanho da string.
|
||||
|
||||
Por exemplo, se `var firstName = "Ada"`, você pode pegar o valor da última letra da string ao usar `firstName[firstName.length - 1]`.
|
||||
|
||||
@ -24,9 +24,9 @@ var lastLetter = firstName[firstName.length - 1];
|
||||
|
||||
# --instructions--
|
||||
|
||||
Use <dfn>notação de colchetes</dfn> para descobrir o último caracter na variável `lastName`.
|
||||
Use <dfn>notação de colchetes</dfn> para descobrir o último caractere na variável `lastName`.
|
||||
|
||||
**Dica:** Tente olhar o exemplo acima se você ficar travado.
|
||||
**Dica:** tente olhar o exemplo acima se você ficar travado.
|
||||
|
||||
# --hints--
|
||||
|
||||
|
||||
@ -11,7 +11,7 @@ dashedName: use-bracket-notation-to-find-the-nth-character-in-a-string
|
||||
|
||||
Você também pode usar <dfn>notação de colchetes</dfn> para pegar caracteres em outras posições em uma string.
|
||||
|
||||
Lembre-se que computadores começam contando do `0`, então o primeiro caractere é na verdade o caractere na posição 0.
|
||||
Lembre-se de que computadores começam contando do `0`. Então, o primeiro caractere é na verdade o caractere na posição 0.
|
||||
|
||||
Exemplo:
|
||||
|
||||
@ -26,7 +26,7 @@ var secondLetterOfFirstName = firstName[1];
|
||||
|
||||
Vamos tentar definir `thirdLetterOfLastName` para ser igual a terceira letra da variável `lastName` usando notação de colchetes.
|
||||
|
||||
**Dica:** Tente olhar o exemplo acima se você ficar travado.
|
||||
**Dica:** tente olhar o exemplo acima se você ficar travado.
|
||||
|
||||
# --hints--
|
||||
|
||||
|
||||
@ -9,9 +9,9 @@ dashedName: use-bracket-notation-to-find-the-nth-to-last-character-in-a-string
|
||||
|
||||
# --description--
|
||||
|
||||
Você pode usar o mesmo princípio que nós acabamos de usar para recuperar o último caractere em uma string, para recuperar o Nº antes do último caractere.
|
||||
Você pode usar o mesmo princípio que nós acabamos de usar para recuperar o último caractere em uma string, para recuperar o enésimo caractere antes do último caractere.
|
||||
|
||||
Por exemplo, você pode pegar o valor da antepenúltima letra da string `var fistName = "Augusta` usando `firstName[firstName.length -3]`
|
||||
Por exemplo, você pode pegar o valor da antepenúltima letra da string `var firstName = "Augusta"` usando `firstName[firstName.length - 3]`
|
||||
|
||||
Exemplo:
|
||||
|
||||
@ -26,7 +26,7 @@ var thirdToLastLetter = firstName[firstName.length - 3];
|
||||
|
||||
Use <dfn>notação de colchetes</dfn> para descobrir o penúltimo caractere na string `lastName`.
|
||||
|
||||
**Dica:** Tente olhar o exemplo acima se você ficar travado.
|
||||
**Dica:** tente olhar o exemplo acima se você ficar travado.
|
||||
|
||||
# --hints--
|
||||
|
||||
|
||||
@ -11,7 +11,7 @@ dashedName: use-conditional-logic-with-if-statements
|
||||
|
||||
Instruções `If` são usadas para tomar decisões no código. A palavra-chave `if` diz ao JavaScript para executar o código nas chaves sob certas condições, definidas nos parênteses. Essas condições são conhecidas como condições `Boolean` e elas só podem ser `true` ou `false`.
|
||||
|
||||
Quando a condição for `true`, o programa executara as instruções dentro das chaves. Quando a condição booleana for `false`, as instruções dentro das chaves não serão executadas.
|
||||
Quando a condição for `true`, o programa executará as instruções dentro das chaves. Quando a condição booleana for `false`, as instruções dentro das chaves não serão executadas.
|
||||
|
||||
**Pseudocódigo**
|
||||
|
||||
@ -32,7 +32,7 @@ test(false);
|
||||
|
||||
`test(true)` retorna a string `It was true` e `test(false)` retorna a string `It was false`.
|
||||
|
||||
Quando `test` é chamado com o valor `true`, a instrução `if` avalia `myCondition` para verificar se é `true` ou não. Já que é `true`, a função retorna `It was true`. Quando chamamos `test` com um valor de `false`, `myCondition` *não é* `true` e a instrução nas chaves não é executada e a função retorna `It was false`.
|
||||
Quando `test` é chamado com o valor `true`, a instrução `if` avalia `myCondition` para verificar se é `true` ou não. Já que é `true`, a função retorna `It was true`. Quando chamamos `test` com um valor de `false`, `myCondition` *não é* `true`, a instrução nas chaves não é executada e a função retorna `It was false`.
|
||||
|
||||
# --instructions--
|
||||
|
||||
|
||||
@ -37,7 +37,7 @@ function findGreaterOrEqual(a, b) {
|
||||
}
|
||||
```
|
||||
|
||||
É considerado a melhor prática para formatar operadores de múltiplas condições, tal que cada condição está em uma linha separada, como mostrada acima. Usando operadores de múltiplas condições sem a indentação adequada pode dificultar a leitura do seu código. Por exemplo:
|
||||
É considerada a melhor prática para formatar operadores de múltiplas condições, já que cada condição está em uma linha separada, como mostrado acima. Usar operadores de múltiplas condições sem a indentação adequada pode dificultar a leitura do seu código. Por exemplo:
|
||||
|
||||
```js
|
||||
function findGreaterOrEqual(a, b) {
|
||||
|
||||
@ -8,11 +8,11 @@ dashedName: use-recursion-to-create-a-countdown
|
||||
|
||||
# --description--
|
||||
|
||||
Em um [desafio anterior](/learn/javascript-algorithms-and-data-structures/basic-javascript/replace-loops-using-recursion), você aprendeu como usar recursividade para substituir laços `for`. Agora, vamos analisar uma função mais complexa, a qual retorna um array de inteiros consecutivos começando com `1` até o número passado para a função.
|
||||
Em um [desafio anterior](/learn/javascript-algorithms-and-data-structures/basic-javascript/replace-loops-using-recursion), você aprendeu como usar recursão para substituir laços `for`. Agora, vamos analisar uma função mais complexa, a qual retorna um array de inteiros consecutivos começando com `1` até o número passado para a função.
|
||||
|
||||
Como mencionado no desafio anterior, haverá um <dfn>caso base</dfn>. O caso base diz a função recursiva quando ela não precisa mais chamar a si. É um simples caso onde o valor de retorno já é conhecido. Também haverá uma <dfn>chamada recursiva</dfn> a qual executa a função original com argumentos diferentes. Se a função for escrita corretamente, eventualmente o caso base será alcançado.
|
||||
Como mencionado no desafio anterior, haverá um <dfn>caso de base</dfn>. O caso de base diz a função recursiva quando ela não precisa mais chamar a si. É um simples caso onde o valor de retorno já é conhecido. Também haverá uma <dfn>chamada recursiva</dfn>, a qual executa a função original com argumentos diferentes. Se a função for escrita corretamente, eventualmente o caso de base será alcançado.
|
||||
|
||||
Por exemplo, vamos dizer que você quer escrever uma função recursiva que retorna um array contendo os números de `1` até `n`. Essa função precisará aceitar um argumento, `n`, representando o número final. Então ela precisará chamar a si mesmo como valores progressivamente menores de `n` até que alcance `1`. Você poderia escrever a função da seguinte forma:
|
||||
Por exemplo, vamos dizer que você quer escrever uma função recursiva que retorna um array contendo os números de `1` até `n`. Essa função precisará aceitar um argumento, `n`, representando o número final. Então, ela precisará chamar a si mesma com valores progressivamente menores, começando em `n` até chegar a `1`. Você poderia escrever a função da seguinte forma:
|
||||
|
||||
```javascript
|
||||
function countup(n) {
|
||||
@ -29,11 +29,11 @@ console.log(countup(5));
|
||||
|
||||
O valor `[1, 2, 3, 4, 5]` será exibido no console.
|
||||
|
||||
Inicialmente, isso se parece contra-intuitivo já que o valor de `n` *diminui*, mas os valores no array final estão *em ordem crescente*. Isso acontece porque a adição no array (push) acontece por último, após a chamada recursiva ter retornado. No ponto onde `n` é adicionado ao array, `countup(n - 1)` já foi avaliado e retornou `[1, 2, ..., n -1]`.
|
||||
Inicialmente, isso parece contraintuitivo já que o valor de `n` *diminui*, mas os valores no array final estão *em ordem crescente*. Isso acontece porque a adição no array (push) acontece por último, após a chamada recursiva ter retornado. No ponto onde `n` é adicionado ao array, `countup(n - 1)` já foi avaliado e retornou `[1, 2, ..., n -1]`.
|
||||
|
||||
# --instructions--
|
||||
|
||||
Definimos uma função chamada `countdown` com um parâmetro (`n`). A função deve usar recursividade para retornar um array contendo inteiros `n` até `1` baseado no parâmetro `n`. Se a função é chamada com um número menor que 1, a função deve retornar um array vazio. Por exemplo, chamando essa função com `n = 5` deve retornar o array `[5, 4, 3, 2, 1]`. Sua função precisa usar recursividade ao chamar ela mesma e não deve usar laços de qualquer tipo.
|
||||
Definimos uma função chamada `countdown` com um parâmetro (`n`). A função deve usar recursão para retornar um array contendo inteiros `n` até `1` com base no parâmetro `n`. Se a função é chamada com um número menor que 1, a função deve retornar um array vazio. Por exemplo, chamar essa função com `n = 5` deve retornar o array `[5, 4, 3, 2, 1]`. Sua função precisa usar recursão para chamar a si mesma e não depender de nenhum tipo de laço.
|
||||
|
||||
# --hints--
|
||||
|
||||
@ -55,7 +55,7 @@ assert.deepStrictEqual(countdown(10), [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]);
|
||||
assert.deepStrictEqual(countdown(5), [5, 4, 3, 2, 1]);
|
||||
```
|
||||
|
||||
Seu código não deve depender de nenhum tipo de laço (`for`, `while` ou outras funções superiores como `forEach`, `map`, `filter` e `reduce`).
|
||||
O código não deve depender de nenhum laço (`for` ou `while` ou funções de ordem superior como as funções `forEach`, `map`, `filter` ou `reduce`).
|
||||
|
||||
```js
|
||||
assert(
|
||||
@ -63,7 +63,7 @@ assert(
|
||||
);
|
||||
```
|
||||
|
||||
Você deve usar recursividade para resolver esse problema.
|
||||
Você deve usar recursão para resolver o problema.
|
||||
|
||||
```js
|
||||
assert(
|
||||
|
||||
@ -8,21 +8,21 @@ dashedName: use-recursion-to-create-a-range-of-numbers
|
||||
|
||||
# --description--
|
||||
|
||||
Continuando do desafio anterior, nós o fornecemos outra oportunidade para criar uma função recursiva para resolver um problema.
|
||||
Continuando do desafio anterior, fornecemos a você outra oportunidade para criar uma função recursiva para resolver um problema.
|
||||
|
||||
# --instructions--
|
||||
|
||||
Definimos uma função chamada `rangeOfNumbers` com dois parâmetros. A função deve retornar um array de inteiros a qual começa com um número representado pelo parâmetro `startNum` e terminar com um número representado pelo parâmetro `endNum`. O número inicial sempre será menor ou igual ao número final. Sua função precisa usar recursividade ao chamar ela mesma e não depender de nenhum tipo de laço. Também deve funcionar para casos onde ambos `startNum` e `endNum` forem o mesmo.
|
||||
Definimos uma função chamada `rangeOfNumbers` com dois parâmetros. A função deve retornar um array de inteiros a qual começa com um número representado pelo parâmetro `startNum` e terminar com um número representado pelo parâmetro `endNum`. O número inicial sempre será menor ou igual ao número final. Sua função precisa usar recursão para chamar a si mesma e não deve depender de nenhum tipo de laço. Também deve funcionar para casos onde `startNum` e `endNum` tiverem o mesmo valor.
|
||||
|
||||
# --hints--
|
||||
|
||||
Sua função deve retornar um array.
|
||||
A função deve retornar um array.
|
||||
|
||||
```js
|
||||
assert(Array.isArray(rangeOfNumbers(5, 10)));
|
||||
```
|
||||
|
||||
Seu código não deve depender de nenhum laço (`for` ou `while` ou funções de ordem superior como as funções `forEach`, `map`, `filter` ou `reduce`).
|
||||
O código não deve depender de nenhum laço (`for` ou `while` ou funções de ordem superior como as funções `forEach`, `map`, `filter` ou `reduce`).
|
||||
|
||||
```js
|
||||
assert(
|
||||
|
||||
@ -35,7 +35,7 @@ alpha[value];
|
||||
|
||||
# --instructions--
|
||||
|
||||
Converta a instrução switch em um objeto chamado `lookup`. Use ele para pesquisar por `val` e atribua a string associada para a variável `result`.
|
||||
Converta a instrução switch em um objeto chamado `lookup`. Use-o para pesquisar por `val` e atribua a string associada para a variável `result`.
|
||||
|
||||
# --hints--
|
||||
|
||||
|
||||
@ -9,11 +9,11 @@ dashedName: word-blanks
|
||||
|
||||
# --description--
|
||||
|
||||
Nós vamos agora usar nosso conhecimento de strings para criar um "[Mad Libs](https://en.wikipedia.org/wiki/Mad_Libs)" estilo de jogo de palavras que chamamos de "Palavras em Branco". Você criará uma frase no estilo "Preencha os Espaços em Branco" (opcionalmente humorosa).
|
||||
Vamos agora usar nosso conhecimento de strings para criar um "[Mad Libs](https://en.wikipedia.org/wiki/Mad_Libs)" estilo de jogo de palavras que chamamos de "Palavras em Branco". Você criará uma frase no estilo "Preencha os espaços em branco" (opcional: de modo engraçado).
|
||||
|
||||
Em um jogo "Mad Libs", você recebe frases com algumas palavras faltando, como substantivos, verbos, adjetivos e advérbios. Você então preencherá os pedaços faltantes com palavras de sua escolha em uma forma que a frase completa faça sentido.
|
||||
Em um jogo de "Mad Libs", você recebe frases com algumas palavras faltando, como substantivos, verbos, adjetivos e advérbios. Você então preencherá os pedaços faltantes com palavras de sua escolha de modo que a frase completa faça sentido.
|
||||
|
||||
Considere a frase - Era realmente **\_\_\_\_** e nós **\_\_\_\_** nós mesmos **\_\_\_\_**. Essa sentença possui três pedaços faltando - um adjetivo, um verbo e um advérbio, e nós podemos adicionar palavras de nossa escolha para completar. Em seguida, podemos atribuir a frase completa para uma variável como se segue:
|
||||
Considere a frase - Era realmente **\_\_\_\_** e nós **\_\_\_\_** nós mesmos **\_\_\_\_**. Essa frase possui três pedaços faltando - um adjetivo, um verbo e um advérbio, e nós podemos adicionar palavras de nossa escolha para completar. Em seguida, podemos atribuir a frase completa para uma variável como se segue:
|
||||
|
||||
```js
|
||||
var sentence = "It was really " + "hot" + ", and we " + "laughed" + " ourselves " + "silly" + ".";
|
||||
|
||||
@ -9,7 +9,7 @@ dashedName: write-reusable-javascript-with-functions
|
||||
|
||||
# --description--
|
||||
|
||||
Em JavaScript, nós podemos dividir nosso código em partes reutilizáveis chamadas de <dfn>functions</dfn>.
|
||||
Em JavaScript, nós podemos dividir nosso código em partes reutilizáveis chamadas de <dfn>funções</dfn>.
|
||||
|
||||
Aqui está um exemplo de uma função:
|
||||
|
||||
@ -19,7 +19,7 @@ function functionName() {
|
||||
}
|
||||
```
|
||||
|
||||
Você pode chamar ou <dfn>invocar</dfn> essa função ao usar seu nome seguido de parênteses, da seguinte forma: `functionName();` Cada vez que a função é chamada imprimirá no console a mensagem `Hello World`. Todo o código entre as chaves será executado toda vez que uma função for chamada.
|
||||
Você pode chamar ou <dfn>invocar</dfn> essa função ao usar seu nome seguido de parênteses, da seguinte forma: `functionName();` Cada vez que a função é chamada, imprimirá no console a mensagem `Hello World`. Todo o código entre as chaves será executado toda vez que uma função for chamada.
|
||||
|
||||
# --instructions--
|
||||
|
||||
|
||||
@ -12,17 +12,17 @@ Continuando a discussão sobre chamada de funções, o próximo bug para prestar
|
||||
|
||||
# --instructions--
|
||||
|
||||
A função `raiseToPower` eleva uma base para um expoente. Infelizmente, não é chamada corretamente - corrija o código para que o valor de `power` seja o esperado 8.
|
||||
A função `raiseToPower` eleva uma base para um expoente. Infelizmente, não é chamada corretamente - corrija o código para que o valor de `power` seja o 8 esperado.
|
||||
|
||||
# --hints--
|
||||
|
||||
Seu código deve corrigir a variável `power` para que seja igual a 2 elevado a 3ª potência, e não 3 elevado a 2ª potência.
|
||||
O código deve corrigir a variável `power` para que seja igual a 2 elevado a 3ª potência, e não 3 elevado a 2ª potência.
|
||||
|
||||
```js
|
||||
assert(power == 8);
|
||||
```
|
||||
|
||||
Seu código deve usar a ordem correta dos argumentos para a chamada da função `raiseToPower`.
|
||||
O código deve usar a ordem correta dos argumentos para a chamada da função `raiseToPower`.
|
||||
|
||||
```js
|
||||
assert(code.match(/raiseToPower\(\s*?base\s*?,\s*?exp\s*?\);/g));
|
||||
|
||||
@ -28,13 +28,13 @@ Corrija o código para que a variável `result` seja definida para o valor retor
|
||||
|
||||
# --hints--
|
||||
|
||||
Seu código deve corrigir a variável `result` para que seja definida para o número que a função `getNine` retorna.
|
||||
O código deve corrigir a variável `result` para que seja definida para o número que a função `getNine` retorna.
|
||||
|
||||
```js
|
||||
assert(result == 9);
|
||||
```
|
||||
|
||||
Seu código deve chamar a função `getNine`.
|
||||
O código deve chamar a função `getNine`.
|
||||
|
||||
```js
|
||||
assert(code.match(/getNine\(\)/g).length == 2);
|
||||
|
||||
@ -8,9 +8,9 @@ dashedName: catch-misspelled-variable-and-function-names
|
||||
|
||||
# --description--
|
||||
|
||||
Os métodos `console.log()` e `typeof` são duas formas primárias para verificar valores intermediários e tipos de saída do programa. Agora é hora entrar nas formas comuns que um bug assume. Um problema de nível de sintaxe que digitadores rápidos podem ter passado é o humilde erro de digitação incorreta.
|
||||
Os métodos `console.log()` e `typeof` são duas formas primárias para verificar valores intermediários e tipos de saída do programa. Agora é hora de conhecer as formas comuns que um bug assume. Um problema de nível de sintaxe que digitadores rápidos podem deixar passar é um simples erro de digitação incorreta.
|
||||
|
||||
Caracteres deslocados, faltando ou capitalizado erroneamente em um nome de variável ou função fará com que o navegador procure por um objeto que não existe - e reclamará na forma de um erro de referência. Variáveis e funções JavaScript são sensíveis a caracteres maiúsculos e minúsculos.
|
||||
Caracteres deslocados, faltando ou capitalizados erroneamente em um nome de variável ou função farão com que o navegador procure por um objeto que não existe - e reclame na forma de um erro de referência. Variáveis e funções JavaScript são sensíveis a caracteres maiúsculos e minúsculos.
|
||||
|
||||
# --instructions--
|
||||
|
||||
@ -24,7 +24,7 @@ Verifique a ortografia das duas variáveis usadas no cálculo de netWorkingCapit
|
||||
assert(netWorkingCapital === 2);
|
||||
```
|
||||
|
||||
Não deve haver instâncias de variáveis com ortografia incorretas no código.
|
||||
Não deve haver instâncias de variáveis com ortografia incorreta no código.
|
||||
|
||||
```js
|
||||
assert(!code.match(/recievables/g));
|
||||
@ -36,7 +36,7 @@ A variável `receivables` deve ser declarada e usada corretamente no código.
|
||||
assert(code.match(/receivables/g).length == 2);
|
||||
```
|
||||
|
||||
Não deve haver instâncias de variáveis com ortografia incorretas no código.
|
||||
Não deve haver instâncias de variáveis com ortografia incorreta no código.
|
||||
|
||||
```js
|
||||
assert(!code.match(/payable;/g));
|
||||
|
||||
@ -8,20 +8,21 @@ dashedName: catch-mixed-usage-of-single-and-double-quotes
|
||||
|
||||
# --description--
|
||||
|
||||
JavaScript nos permite o uso de ambas as aspas simples (`'<code>) e duplas (<code>"<code>) para declarar uma string. Decidir qual delas usar geralmente é uma questão de preferência pessoal, com algumas exceções.</p>
|
||||
JavaScript nos permite o uso de aspas simples (`'`) e duplas (`"`) para declarar uma string. Decidir qual delas usar geralmente é uma questão de preferência pessoal, com algumas exceções.
|
||||
|
||||
<p spaces-before="0">Ter duas opções é ótimo quando uma string possui contrações ou outros pedaços de texto que estão entre aspas. Apenas tome cuidado para que você não feche uma string muito cedo, o que causa erro de sintaxe.</p>
|
||||
Ter duas opções é ótimo quando uma string possui contrações ou outros pedaços de texto que estão entre aspas. Apenas tome cuidado para que você não feche uma string muito cedo, o que causa erro de sintaxe.
|
||||
|
||||
<p spaces-before="0">Aqui estão alguns exemplos de mistura de aspas:</p>
|
||||
Aqui estão alguns exemplos de mistura de aspas:
|
||||
|
||||
<pre><code class="js">const grouchoContraction = "I've had a perfectly wonderful evening, but this wasn't it.";
|
||||
```js
|
||||
const grouchoContraction = "I've had a perfectly wonderful evening, but this wasn't it.";
|
||||
const quoteInString = "Groucho Marx once said 'Quote me as saying I was mis-quoted.'";
|
||||
const uhOhGroucho = 'I've had a perfectly wonderful evening, but this wasn't it.';
|
||||
`</pre>
|
||||
```
|
||||
|
||||
As duas primeiras estão corretas, mas a terceira não.
|
||||
|
||||
Claro, não há problema usar apenas um estilo de aspas. Você pode escapar as aspas dentro de uma string ao usar o caractere barra invertida (</code>\</code>):
|
||||
Claro, não há problema em usar apenas um estilo de aspas. Você pode escapar as aspas dentro de uma string ao usar o caractere barra invertida (`\`):
|
||||
|
||||
```js
|
||||
const allSameQuotes = 'I\'ve had a perfectly wonderful evening, but this wasn\'t it.';
|
||||
@ -29,17 +30,17 @@ const allSameQuotes = 'I\'ve had a perfectly wonderful evening, but this wasn\'t
|
||||
|
||||
# --instructions--
|
||||
|
||||
Corrija a string para que ou use aspas diferentes para o valor de `href` ou escape as aspas existentes. Mantenha as aspas duplas ao redor de toda a string.
|
||||
Corrija a string para que use aspas diferentes para o valor de `href` ou escape as aspas existentes. Mantenha as aspas duplas ao redor de toda a string.
|
||||
|
||||
# --hints--
|
||||
|
||||
Seu código deve corrigir as aspas em torno do valor de `href`: `#Home` ao mudar ou escapar elas.
|
||||
O código deve corrigir as aspas em torno do valor de `href`: `#Home` mudando-as ou escapando-as.
|
||||
|
||||
```js
|
||||
assert(code.match(/<a href=\s*?('|\\")#Home\1\s*?>/g));
|
||||
```
|
||||
|
||||
Seu código deve manter as aspas duplas ao redor de toda a string.
|
||||
O código deve manter as aspas duplas ao redor de toda a string.
|
||||
|
||||
```js
|
||||
assert(code.match(/"<p>.*?<\/p>";/g));
|
||||
|
||||
@ -8,9 +8,9 @@ dashedName: catch-off-by-one-errors-when-using-indexing
|
||||
|
||||
# --description--
|
||||
|
||||
<dfn>Off by one errors (erros de fora por um)</dfn> (as vezes chamado OBOE) surge quando você está tentando acessar um índice específico de uma string ou array (para fatiar ou acessar um segmento), ou quando você está iterando sobre seus índices. A indexação de JavaScript começa em zero e não um, o que significa que o último índice sempre será o tamanho do item menos 1 (array.length - 1). Se você estiver tentando acessar um índice igual ao tamanho, o programa pode lançar uma referência do erro "index out of range" ou imprimir `undefined`.
|
||||
<dfn>Off by one errors (erros de fora por um)</dfn> (as vezes chamados de OBOE) surgem quando você está tentando acessar um índice específico de uma string ou array (para fatiar ou acessar um segmento), ou quando você está iterando sobre seus índices. A indexação de JavaScript começa em zero e não um, o que significa que o último índice sempre será o tamanho do item menos 1 (array.length - 1). Se você estiver tentando acessar um índice igual ao tamanho, o programa pode lançar uma referência do erro "index out of range" ou imprimir `undefined`.
|
||||
|
||||
Quando você usa métodos de string ou array que recebem intervalos de índices como argumentos, auxilia na leitura da documentação e compreender se eles são inclusivos (o item no índice especificado é parte do que é retornado) ou não. Aqui estão alguns exemplos de erros de fora por um:
|
||||
Quando você usa métodos de string ou array que recebem intervalos de índices como argumentos, auxilia ler a documentação e compreender se eles são inclusivos (o item no índice especificado é parte do que é retornado) ou não. Aqui estão alguns exemplos de erros de fora por um:
|
||||
|
||||
```js
|
||||
let alphabet = "abcdefghijklmnopqrstuvwxyz";
|
||||
@ -34,25 +34,25 @@ Corrija os dois erros de índices nas funções seguintes para que todos os núm
|
||||
|
||||
# --hints--
|
||||
|
||||
Seu código deve definir a condição inicial do laço para começar do primeiro índice.
|
||||
O código deve definir a condição inicial do laço para começar do primeiro índice.
|
||||
|
||||
```js
|
||||
assert(code.match(/i\s*?=\s*?0\s*?;/g).length == 1);
|
||||
```
|
||||
|
||||
Seu código deve corrigir a condição inicial do laço para que o índice comece em 0.
|
||||
O código deve corrigir a condição inicial do laço para que o índice comece em 0.
|
||||
|
||||
```js
|
||||
assert(!code.match(/i\s?=\s*?1\s*?;/g));
|
||||
```
|
||||
|
||||
Seu código deve definir a condição de parada do laço, a fim de parar no último índice.
|
||||
O código deve definir a condição de parada do laço, a fim de parar no último índice.
|
||||
|
||||
```js
|
||||
assert(code.match(/i\s*?<\s*?len\s*?;/g).length == 1);
|
||||
```
|
||||
|
||||
Seu código deve corrigir a condição de parada do laço, a fim de parar no tamanho menos 1.
|
||||
O código deve corrigir a condição de parada do laço, a fim de parar no tamanho menos 1.
|
||||
|
||||
```js
|
||||
assert(!code.match(/i\s*?<=\s*?len;/g));
|
||||
|
||||
@ -8,9 +8,9 @@ dashedName: catch-unclosed-parentheses-brackets-braces-and-quotes
|
||||
|
||||
# --description--
|
||||
|
||||
Outro erro de sintaxe para estar ciente é que todas as aberturas de parênteses, colchetes, chaves e aspas têm um par de fechamento. Esquecer um pedaço tende a acontecer quando você está editando um código existente e inserindo itens com um dos tipos de pares. Também, tenha cuidado ao aninhar blocos de código em outros, como adicionar uma função de callback como um argumento a um método.
|
||||
Outro erro de sintaxe para estar ciente é que todas as aberturas de parênteses, colchetes, chaves e aspas têm um par de fechamento. Esquecer um pedaço tende a acontecer quando você está editando um código existente e inserindo itens com um dos tipos de pares. Além disso, tenha cuidado ao aninhar blocos de código em outros, como ao adicionar uma função de callback como um argumento a um método.
|
||||
|
||||
Uma maneira de evitar esse erro é assim que o caractere de abertura é digitado, imediatamente inclua o caractere de fechamento, mova o cursor entre eles e continue programando. Felizmente, a maioria dos editores de código modernos geram a segunda parte do par automaticamente.
|
||||
Uma maneira de evitar esse erro é, assim que o caractere de abertura é digitado, incluir imediatamente o caractere de fechamento, mover o cursor entre eles e continuar programando. Felizmente, a maioria dos editores de código modernos geram a segunda parte do par automaticamente.
|
||||
|
||||
# --instructions--
|
||||
|
||||
@ -18,13 +18,13 @@ Corrija os dois erros de pares no código.
|
||||
|
||||
# --hints--
|
||||
|
||||
Seu código deve corrigir o pedaço que falta do array.
|
||||
O código deve corrigir o pedaço que falta do array.
|
||||
|
||||
```js
|
||||
assert(code.match(/myArray\s*?=\s*?\[\s*?1\s*?,\s*?2\s*?,\s*?3\s*?\];/g));
|
||||
```
|
||||
|
||||
Seu código deve corrigir o pedaço que falta do método `.reduce()`. A saída no console deve mostrar que `Sum of array value is: 6`.
|
||||
O código deve corrigir o pedaço que falta do método `.reduce()`. A saída no console deve mostrar que `Sum of array value is: 6`.
|
||||
|
||||
```js
|
||||
assert(arraySum === 6);
|
||||
|
||||
@ -10,11 +10,11 @@ dashedName: catch-use-of-assignment-operator-instead-of-equality-operator
|
||||
|
||||
Programas de ramificação, ou seja, programas que fazem coisas diferentes se certas condições forem atendidas, dependem de instruções `i`, `else if` e `else` em JavaScript. Às vezes a condição verifica se um resultado é igual a um valor.
|
||||
|
||||
Essa lógica é fala da seguinte forma: "se x for igual a y, então ..." o que pode literalmente ser traduzido para código usando o `=`, ou operador de atribuição. Isso leva a um controle de fluxo inesperado no seu programa.
|
||||
Essa lógica é dita da seguinte forma: "se x for igual a y, então ..." o que pode literalmente ser traduzido para código usando o `=`, ou operador de atribuição. Isso leva a um controle de fluxo inesperado no seu programa.
|
||||
|
||||
Como abordado nos desafios anteriores, o operador de atribuição (`=`) em JavaScript, atribui um valor para o nome de uma variável. E os operadores `==` e `===` verificam pela igualdade (o triplo `===` testa por igualdade estrita, significando que ambos os valores e o tipo de dado são os mesmos).
|
||||
|
||||
O código abaixo atribui `x` para ser 2, o que tem como resultado `true`. Quase todo valor por si só em JavaScript são avaliados como `true`, exceto com o que são conhecidos como valores falsos: `false`, `0`, `""` (uma string vazia), `NaN`, `undefined` e `null`.
|
||||
O código abaixo atribui o valor 2 para `x`, o que tem como resultado `true`. Quase todo valor por si só em JavaScript é avaliado como `true`, exceto os que são conhecidos como valores "falsy": `false`, `0`, `""` (uma string vazia), `NaN`, `undefined` e `null`.
|
||||
|
||||
```js
|
||||
let x = 1;
|
||||
@ -26,7 +26,7 @@ if (x = y) {
|
||||
}
|
||||
```
|
||||
|
||||
Nesse exemplo, o bloco de código dentro da instrução `if` vai rodar para qualquer valor de `y`, a não ser que `y` seja falso. O bloco de `else`, que nós esperamos ser executado aqui, não vai realmente rodar.
|
||||
Nesse exemplo, o bloco de código dentro da instrução `if` vai rodar para qualquer valor de `y`, a não ser que `y` seja falso. O bloco de `else`, que nós esperamos que seja executado aqui, não vai rodar de fato.
|
||||
|
||||
# --instructions--
|
||||
|
||||
@ -34,7 +34,7 @@ Corrija a condição para que o programa rode na ramificação correta e o valor
|
||||
|
||||
# --hints--
|
||||
|
||||
Seu código deve corrigir a condição para que verifique pela igualdade, ao invés de usar atribuição.
|
||||
O código deve corrigir a condição para que verifique pela igualdade, ao invés de usar atribuição.
|
||||
|
||||
```js
|
||||
assert(result == 'Not equal!');
|
||||
|
||||
@ -20,21 +20,21 @@ function loopy() {
|
||||
}
|
||||
```
|
||||
|
||||
É trabalho do programador garantir que a condição de parada, a qual avisa ao programa quando sair de um laço, é eventualmente alcançada. Um erro é incrementar ou decrementar uma variável contadora na direção errada da condição de parada. Outro erro é acidentalmente reiniciar uma variável contadora ou de índice dentro do laço, ao invés de incrementar ou decrementar.
|
||||
É trabalho do programador garantir que a condição de parada, a qual avisa ao programa quando sair de um laço, seja eventualmente alcançada. Um erro é incrementar ou decrementar uma variável contadora na direção errada da condição de parada. Outro erro é acidentalmente reiniciar uma variável contadora ou de índice dentro do laço, ao invés de incrementar ou decrementar.
|
||||
|
||||
# --instructions--
|
||||
|
||||
A função `myFunc()` contém um laço infinito porque a condição de parada `i != 4` nunca será `false` (e então quebrar o laço) - `i` vai incrementar em 2 a cada iteração, e passa direto por 4 já que `i` é ímpar no início. Corrija o operador de comparação para que o laço só rode enquanto `i` for menor ou igual a 4.
|
||||
A função `myFunc()` contém um laço infinito porque a condição de parada `i != 4` nunca será `false` (para, então, quebrar o laço) - `i` vai incrementar em 2 a cada iteração, e passa direto por 4 já que `i` é ímpar no início. Corrija o operador de comparação para que o laço só rode enquanto `i` for menor ou igual a 4.
|
||||
|
||||
# --hints--
|
||||
|
||||
Seu código deve alterar o operador de comparação na condição de parada (parte do meio) do laço `for`.
|
||||
O código deve alterar o operador de comparação na condição de parada (parte do meio) do laço `for`.
|
||||
|
||||
```js
|
||||
assert(code.match(/i\s*?<=\s*?4;/g).length == 1);
|
||||
```
|
||||
|
||||
Seu código deve corrigir o operador de comparação na condição de parada do laço.
|
||||
O código deve corrigir o operador de comparação na condição de parada do laço.
|
||||
|
||||
```js
|
||||
assert(!code.match(/i\s*?!=\s*?4;/g));
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 587d7b83367417b2b2512b37
|
||||
title: Entender a diferença entre o console da freeCodeCamp e do navegador
|
||||
title: Entender a diferença entre o console do freeCodeCamp e do navegador
|
||||
challengeType: 1
|
||||
forumTopicId: 301193
|
||||
dashedName: understanding-the-differences-between-the-freecodecamp-and-browser-console
|
||||
@ -8,17 +8,17 @@ dashedName: understanding-the-differences-between-the-freecodecamp-and-browser-c
|
||||
|
||||
# --description--
|
||||
|
||||
Você pode ter percebido que alguns dos desafios de JavaScript da freeCodeCamp incluem seu próprio console. Esse console se comporta um pouco difrente do console do navegador que você utilizou no último desafio.
|
||||
Você pode ter percebido que alguns dos desafios de JavaScript da freeCodeCamp incluem seu próprio console. Esse console se comporta um pouco diferente do console do navegador que você utilizou no último desafio.
|
||||
|
||||
O desafio a seguir tem a finalidade de destacar a principal diferença entre o console da freeCodeCamp e do navegador.
|
||||
O desafio a seguir tem a finalidade de destacar a principal diferença entre o console do freeCodeCamp e do navegador.
|
||||
|
||||
Quando você executa JavaScript comum, o console do navegado exibirá suas instruções `console.log()` a exata quantidade de vezes que é chamada.
|
||||
|
||||
O console da freeCodeCamp irá imprimir suas instruções `console.log()` um curto período depois do editor detectar mudança no script, e também durante o teste.
|
||||
O console do freeCodeCamp irá imprimir suas instruções `console.log()` um curto período depois do editor detectar mudança no script, e também durante o teste.
|
||||
|
||||
O console da freeCodeCamp é apagado antes de cada execução de testes e, para evitar spam, só imprime os logs durante o primeiro teste (veja a nota abaixo para exceções).
|
||||
O console do freeCodeCamp é apagado antes de cada execução de testes e, para evitar spam, só imprime os logs durante o primeiro teste (veja a nota abaixo para exceções).
|
||||
|
||||
Se você gostaria de ver todos os logs em todos os testes, execute os testes e abra o console do navegador. Se preferir usar o console do navegador e quiser que ele imite o console da freeCodeCamp, coloque `console.clear()` antes de qualquer outra chamada ao `console`, para apagar o console do navegador.
|
||||
Se você gostaria de ver todos os logs em todos os testes, execute os testes e abra o console do navegador. Se preferir usar o console do navegador e quiser que ele imite o console do freeCodeCamp, coloque `console.clear()` antes de qualquer outra chamada ao `console`, para apagar o console do navegador.
|
||||
|
||||
**Observação:** `console.log` dentro de funções é impresso no console do freeCodeCamp toda vez que essas funções forem chamadas. Isso pode ajudar a depurar (ou debugar) funções que são chamadas durante os testes.
|
||||
|
||||
|
||||
@ -8,9 +8,9 @@ dashedName: use-caution-when-reinitializing-variables-inside-a-loop
|
||||
|
||||
# --description--
|
||||
|
||||
Às vezes é necessário salvar informações, incrementar contadores ou redefinir variáveis dentro de um laço. Um potencial problema é quando variáveis deveriam ser reinicializadas e, não são, ou vice versa. Isso é particularmente perigoso se você acidentalmente redefinir a variável sendo usada para a a condição de parada, causando um laço infinito.
|
||||
Às vezes é necessário salvar informações, incrementar contadores ou redefinir variáveis dentro de um laço. Um problema em potencial é quando variáveis deveriam ser reinicializadas e, não são, ou vice versa. Isso é particularmente perigoso se você acidentalmente redefinir a variável sendo usada para a a condição de parada, causando um laço infinito.
|
||||
|
||||
Imprimir os valores das variáveis em cada ciclo do seu laço usando `console.log()` pode descobrir comportamentos com bugs relacionados a reiniciar ou falhar ao reiniciar uma variável.
|
||||
Imprimir os valores das variáveis em cada ciclo do seu laço usando `console.log()` pode ajudar a descobrir comportamentos com bugs relacionados a reiniciar ou falhar ao reiniciar uma variável.
|
||||
|
||||
# --instructions--
|
||||
|
||||
@ -18,7 +18,7 @@ A seguinte função deveria criar um array de duas dimensões com `m` linhas e `
|
||||
|
||||
# --hints--
|
||||
|
||||
Seu código deve definir a variável `matrix` para um array contendo 3 linhas de 2 colunas de zeros.
|
||||
O código deve definir a variável `matrix` para um array contendo 3 linhas de 2 colunas de zeros.
|
||||
|
||||
```js
|
||||
assert(JSON.stringify(matrix) == '[[0,0],[0,0],[0,0]]');
|
||||
|
||||
@ -8,11 +8,11 @@ dashedName: use-the-javascript-console-to-check-the-value-of-a-variable
|
||||
|
||||
# --description--
|
||||
|
||||
Ambos o Chrome e o Firefox possui excelentes consoles JavaScript, também conhecidos como DevTools, para depurar seu JavaScript.
|
||||
O Chrome e o Firefox possui excelentes consoles JavaScript, também conhecidos como DevTools, para depurar seu JavaScript.
|
||||
|
||||
Você pode encontrar Developer tools no menu do seu Chrome ou Web Console no menu do Firefox. Se você estiver usando um navegador diferente, ou um telefone móvel, recomendamos fortemente mudar para o Firefox ou Chrome Desktop.
|
||||
Você pode encontrar as Developer tools no menu do seu Chrome ou Web Console no menu do Firefox. Se você estiver usando um navegador diferente, ou um telefone móvel, recomendamos fortemente mudar para o Firefox ou Chrome Desktop.
|
||||
|
||||
O método `console.log()`, o qual "imprime" a saída do que está nos seus parênteses no console, provavelmente será a ferramenta de debug mais útil. Colocá-lo em pontos estratégicos no seu código pode te mostrar os valores intermediários de variáveis. É uma boa prática ter uma ideia do que deveria ser a saída antes de olhar o que é. Ter pontos de verificação para ver o status de seus cálculos ao longo do seu código ajudará a encontrar onde o problema está.
|
||||
O método `console.log()`, o qual "imprime" a saída do que está nos seus parênteses no console, provavelmente será a ferramenta de debug mais útil. Colocá-lo em pontos estratégicos no seu código pode mostrar a você os valores intermediários de variáveis. É uma boa prática ter uma ideia do que deveria ser a saída antes de olhar o que é. Ter pontos de verificação para ver o status de seus cálculos ao longo do seu código ajudará a encontrar onde o problema está.
|
||||
|
||||
Aqui está um exemplo para imprimir a string `Hello world!` no console:
|
||||
|
||||
@ -26,7 +26,7 @@ Use o método `console.log()` para imprimir o valor da variável `a` aonde anoto
|
||||
|
||||
# --hints--
|
||||
|
||||
Seu código deve usar `console.log()` para verificar o valor da variável `a`.
|
||||
O código deve usar `console.log()` para verificar o valor da variável `a`.
|
||||
|
||||
```js
|
||||
assert(code.match(/console\.log\(a\)/g));
|
||||
|
||||
@ -29,19 +29,19 @@ Adicione duas instruções `console.log()` para verificar o `typeof` de cada uma
|
||||
|
||||
# --hints--
|
||||
|
||||
Seu código deve usar `typeof` em duas instruções `console.log()` para verificar o tipo das variáveis.
|
||||
O código deve usar `typeof` em duas instruções `console.log()` para verificar o tipo das variáveis.
|
||||
|
||||
```js
|
||||
assert(code.match(/console\.log\(typeof[\( ].*\)?\)/g).length == 2);
|
||||
```
|
||||
|
||||
Seu código deve usar `typeof` para verificar o tipo da variável `seven`.
|
||||
O código deve usar `typeof` para verificar o tipo da variável `seven`.
|
||||
|
||||
```js
|
||||
assert(code.match(/typeof[\( ]seven\)?/g));
|
||||
```
|
||||
|
||||
Seu código deve usar `typeof` para verificar o tipo da variável `three`.
|
||||
O código deve usar `typeof` para verificar o tipo da variável `three`.
|
||||
|
||||
```js
|
||||
assert(code.match(/typeof[\( ]three\)?/g));
|
||||
|
||||
Reference in New Issue
Block a user