Add languages Russian, Arabic, Chinese, Portuguese (#18305)
This commit is contained in:
Beau Carnes
committed by
mrugesh mohapatra
mrugesh mohapatra
parent
09d3eca712
commit
2ca3a2093f
@ -0,0 +1,58 @@
|
||||
---
|
||||
id: 587d7b85367417b2b2512b3a
|
||||
title: Catch Arguments Passed in the Wrong Order When Calling a Function
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Argumentos de captura passados na ordem errada ao chamar uma função
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Continuando a discussão sobre as funções de chamada, o próximo bug a ser observado é quando os argumentos de uma função são fornecidos na ordem incorreta. Se os argumentos forem tipos diferentes, como uma função esperando uma matriz e um inteiro, isso provavelmente causará um erro de tempo de execução. Se os argumentos forem do mesmo tipo (todos os inteiros, por exemplo), a lógica do código não fará sentido. Certifique-se de fornecer todos os argumentos necessários, na ordem correta, para evitar esses problemas. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> A função <code>raiseToPower</code> gera uma base para um expoente. Infelizmente, ele não é chamado corretamente - corrija o código para que o valor da <code>power</code> seja o esperado 8. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'Seu código deve fixar a <code>power</code> variável de modo que seja igual a 2 elevado à 3ª potência, e não 3 elevado à 2ª potência.'
|
||||
testString: 'assert(power == 8, "Your code should fix the variable <code>power</code> so it equals 2 raised to the 3rd power, not 3 raised to the 2nd power.");'
|
||||
- text: Seu código deve usar a ordem correta dos argumentos para a chamada de função <code>raiseToPower</code> .
|
||||
testString: 'assert(code.match(/raiseToPower\(\s*?base\s*?,\s*?exp\s*?\);/g), "Your code should use the correct order of the arguments for the <code>raiseToPower</code> function call.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function raiseToPower(b, e) {
|
||||
return Math.pow(b, e);
|
||||
}
|
||||
|
||||
let base = 2;
|
||||
let exp = 3;
|
||||
let power = raiseToPower(exp, base);
|
||||
console.log(power);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,58 @@
|
||||
---
|
||||
id: 587d7b85367417b2b2512b39
|
||||
title: Catch Missing Open and Closing Parenthesis After a Function Call
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Pegar falta abrir e fechar parêntese após uma chamada de função
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Quando uma função ou método não aceita nenhum argumento, você pode esquecer de incluir os parênteses de abertura e fechamento (vazios) ao chamá-lo. Muitas vezes o resultado de uma chamada de função é salvo em uma variável para outro uso em seu código. Esse erro pode ser detectado registrando-se valores de variáveis (ou seus tipos) no console e vendo que um está configurado para uma referência de função, em vez do valor esperado que a função retorna. As variáveis no exemplo a seguir são diferentes: <blockquote> function myFunction () { <br> retorno "Você balança!"; <br> } <br> vamos varOne = myFunction; // configurado para igualar uma função <br> deixe varTwo = myFunction (); // configurado para igualar a string "You rock!" </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Corrija o código para que o <code>result</code> da variável seja definido para o valor retornado da chamada da função <code>getNine</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'Seu código deve corrigir o <code>result</code> da variável, de modo que seja configurado para o número que a função <code>getNine</code> retorna.'
|
||||
testString: 'assert(result == 9, "Your code should fix the variable <code>result</code> so it is set to the number that the function <code>getNine</code> returns.");'
|
||||
- text: Seu código deve chamar a função <code>getNine</code> .
|
||||
testString: 'assert(code.match(/getNine\(\)/g).length == 2, "Your code should call the <code>getNine</code> function.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function getNine() {
|
||||
let x = 6;
|
||||
let y = 3;
|
||||
return x + y;
|
||||
}
|
||||
|
||||
let result = getNine;
|
||||
console.log(result);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,60 @@
|
||||
---
|
||||
id: 587d7b84367417b2b2512b35
|
||||
title: Catch Misspelled Variable and Function Names
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Capturar nomes de variáveis e variáveis com erros ortográficos
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Os métodos <code>console.log()</code> e <code>typeof</code> são as duas principais formas de verificar valores intermediários e tipos de saída do programa. Agora é hora de entrar nos formulários comuns que os bugs tomam. Um problema no nível da sintaxe com o qual os tipificadores rápidos podem se compor é o humilde erro de ortografia. Caracteres transpostos, ausentes ou mal capitalizados em uma variável ou nome de função terão o navegador procurando por um objeto que não existe - e reclamam na forma de um erro de referência. Os nomes de variáveis e funções JavaScript diferenciam maiúsculas de minúsculas. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Corrija os dois erros de ortografia no código para que o cálculo <code>netWorkingCapital</code> funcione. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'Verifique a ortografia das duas variáveis usadas no cálculo netWorkingCapital, a saída do console deve mostrar que "O capital de giro líquido é: 2".'
|
||||
testString: 'assert(netWorkingCapital === 2, "Check the spelling of the two variables used in the netWorkingCapital calculation, the console output should show that "Net working capital is: 2".");'
|
||||
- text: Não deve haver instâncias de variáveis mal escritas no código.
|
||||
testString: 'assert(!code.match(/recievables/g), "There should be no instances of mis-spelled variables in the code.");'
|
||||
- text: A variável de <code>receivables</code> deve ser declarada e usada corretamente no código.
|
||||
testString: 'assert(code.match(/receivables/g).length == 2, "The <code>receivables</code> variable should be declared and used properly in the code.");'
|
||||
- text: Não deve haver instâncias de variáveis mal escritas no código.
|
||||
testString: 'assert(!code.match(/payable;/g), "There should be no instances of mis-spelled variables in the code.");'
|
||||
- text: A variável de <code>payables</code> a <code>payables</code> deve ser declarada e usada corretamente no código.
|
||||
testString: 'assert(code.match(/payables/g).length == 2, "The <code>payables</code> variable should be declared and used properly in the code.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let receivables = 10;
|
||||
let payables = 8;
|
||||
let netWorkingCapital = recievables - payable;
|
||||
console.log(`Net working capital is: ${netWorkingCapital}`);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,52 @@
|
||||
---
|
||||
id: 587d7b84367417b2b2512b37
|
||||
title: Catch Mixed Usage of Single and Double Quotes
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Pegar Uso Misto de Citações Únicas e Duplas
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> O JavaScript permite o uso de aspas simples (") e dupla (" ") para declarar uma string. Decidir qual usar geralmente se resume a preferência pessoal, com algumas exceções. Ter duas opções é ótimo quando uma string tem contrações ou outra pedaço de texto que está entre aspas. Só tome cuidado para não fechar a string muito cedo, o que causa um erro de sintaxe. Aqui estão alguns exemplos de citações de mixagem: <blockquote> // Estes estão corretos: <br> const grouchoContraction = "Eu tive uma noite perfeitamente maravilhosa, mas não foi isso."; <br> const quoteInString = "Groucho Marx uma vez disse: 'Cite-me dizendo que fui mal citado.'"; <br> // Isso está incorreto: <br> const uhOhGroucho = 'Eu tive uma noite perfeitamente maravilhosa, mas não foi isso'; </blockquote> Claro, não há problema em usar apenas um estilo de citações. Você pode escapar as aspas dentro da string usando o caractere de escape barra invertida (\): <blockquote> // Corrigir o uso das mesmas citações: <br> const allSameQuotes = 'Eu tive uma noite perfeitamente maravilhosa, mas não foi isso'; </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Corrija a string de forma que ela use aspas diferentes para o valor <code>href</code> ou escape das existentes. Mantenha as aspas duplas ao redor da string inteira. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'Seu código deve corrigir as aspas em torno do valor de <code>href</code> "#Home" alterando ou escapando delas.'
|
||||
testString: 'assert(code.match(/<a href=\s*?("|\\")#Home\1\s*?>/g), "Your code should fix the quotes around the <code>href</code> value "#Home" by either changing or escaping them.");'
|
||||
- text: Seu código deve manter as aspas duplas ao redor da string inteira.
|
||||
testString: 'assert(code.match(/"<p>.*?<\/p>";/g), "Your code should keep the double quotes around the entire string.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let innerHtml = "<p>Click here to <a href="#Home">return home</a></p>";
|
||||
console.log(innerHtml);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,65 @@
|
||||
---
|
||||
id: 587d7b86367417b2b2512b3b
|
||||
title: Catch Off By One Errors When Using Indexing
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Catch Off One erros ao usar a indexação
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> <code>Off by one errors</code> (às vezes chamado de OBOE) surge quando você está tentando direcionar um índice específico de uma cadeia ou matriz (para dividir ou acessar um segmento), ou quando o loop sobre os índices deles. A indexação JavaScript começa em zero, não em um, o que significa que o último índice é sempre um menor que o comprimento do item. Se você tentar acessar um índice igual ao comprimento, o programa poderá lançar um erro de referência "índice fora do intervalo" ou imprimir <code>undefined</code> . Quando você usa métodos string ou array que usam intervalos de índice como argumentos, é útil ler a documentação e entender se eles são inclusivos (o item no índice fornecido é parte do que é retornado) ou não. Aqui estão alguns exemplos de erros: <blockquote> let alphabet = "abcdefghijklmnopqrstuvwxyz"; <br> vamos len = alphabet.length; <br> para (let i = 0; i <= len; i ++) { <br> // faz um loop muitas vezes no final <br> console.log (alfabeto [i]); <br> } <br> para (let j = 1; j <len; j ++) { <br> // faz um loop muito poucas vezes e erra o primeiro caractere no índice 0 <br> console.log (alfabeto [j]); <br> } <br> para (let k = 0; k <len; k ++) { <br> // Goldilocks aprova - isso é apenas certo <br> console.log (alfabeto [k]); <br> } </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Corrija os dois erros de indexação na seguinte função para que todos os números de 1 a 5 sejam impressos no console. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Seu código deve definir a condição inicial do loop para que ele comece no primeiro índice.
|
||||
testString: 'assert(code.match(/i\s*?=\s*?0\s*?;/g).length == 1, "Your code should set the initial condition of the loop so it starts at the first index.");'
|
||||
- text: Seu código deve corrigir a condição inicial do loop para que o índice comece em 0.
|
||||
testString: 'assert(!code.match(/i\s?=\s*?1\s*?;/g), "Your code should fix the initial condition of the loop so that the index starts at 0.");'
|
||||
- text: Seu código deve definir a condição de terminal do loop para que ele pare no último índice.
|
||||
testString: 'assert(code.match(/i\s*?<\s*?len\s*?;/g).length == 1, "Your code should set the terminal condition of the loop so it stops at the last index.");'
|
||||
- text: Seu código deve consertar a condição terminal do loop para que ele pare em 1 antes do comprimento.
|
||||
testString: 'assert(!code.match(/i\s*?<=\s*?len;/g), "Your code should fix the terminal condition of the loop so that it stops at 1 before the length.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function countToFive() {
|
||||
let firstFive = "12345";
|
||||
let len = firstFive.length;
|
||||
// Fix the line below
|
||||
for (let i = 1; i <= len; i++) {
|
||||
// Do not alter code below this line
|
||||
console.log(firstFive[i]);
|
||||
}
|
||||
}
|
||||
|
||||
countToFive();
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,53 @@
|
||||
---
|
||||
id: 587d7b84367417b2b2512b36
|
||||
title: 'Catch Unclosed Parentheses, Brackets, Braces and Quotes'
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: 'Pegar parênteses, suportes, chaves e citações não fechadas'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Outro erro de sintaxe a ter em conta é que todos os parênteses, parênteses, chaves e cotações de abertura têm um par de fecho. Esquecer uma parte tende a acontecer quando você está editando um código existente e inserindo itens com um dos tipos de par. Além disso, tome cuidado ao aninhar blocos de código em outros, como adicionar uma função de retorno de chamada como um argumento para um método. Uma maneira de evitar esse erro é, assim que o caractere de abertura for digitado, incluir imediatamente a correspondência de fechamento, em seguida, mova o cursor de volta entre eles e continue a codificação. Felizmente, a maioria dos editores de código modernos gera a segunda metade do par automaticamente. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Corrigir os dois erros de par no código. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Seu código deve corrigir a parte que falta na matriz.
|
||||
testString: 'assert(code.match(/myArray\s*?=\s*?\[\s*?1\s*?,\s*?2\s*?,\s*?3\s*?\];/g), "Your code should fix the missing piece of the array.");'
|
||||
- text: 'Seu código deve corrigir a parte que falta do método <code>.reduce()</code> . A saída do console deve mostrar que "Soma dos valores da matriz é: 6".'
|
||||
testString: 'assert(arraySum === 6, "Your code should fix the missing piece of the <code>.reduce()</code> method. The console output should show that "Sum of array values is: 6".");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let myArray = [1, 2, 3;
|
||||
let arraySum = myArray.reduce((previous, current => previous + current);
|
||||
console.log(`Sum of array values is: ${arraySum}`);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,61 @@
|
||||
---
|
||||
id: 587d7b85367417b2b2512b38
|
||||
title: Catch Use of Assignment Operator Instead of Equality Operator
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Pegar o uso do operador de atribuição em vez do operador de igualdade
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Programas de ramificação, ou seja, aqueles que fazem coisas diferentes se determinadas condições forem atendidas, dependem de <code>if</code> , <code>else if</code> e <code>else</code> instruções em JavaScript. A condição às vezes assume a forma de testar se um resultado é igual a um valor. Essa lógica é falada (em inglês, pelo menos) como "se x for igual a y, então ...", o que pode literalmente ser traduzido em código usando o operador <code>=</code> ou atribuição. Isso leva a um fluxo de controle inesperado no seu programa. Como abordado em desafios anteriores, o operador de atribuição ( <code>=</code> ) em JavaScript atribui um valor a um nome de variável. E os operadores <code>==</code> e <code>===</code> verificam a igualdade (o triplo <code>===</code> testa a igualdade estrita, significando que o valor e o tipo são iguais). O código abaixo atribui <code>x</code> como 2, que é avaliado como <code>true</code> . Quase todos os valores em JavaScript são avaliados como <code>true</code> , exceto os que são conhecidos como "falsy": <code>false</code> , <code>0</code> , <code>""</code> (uma string vazia), <code>NaN</code> , <code>undefined</code> e <code>null</code> . <blockquote> seja x = 1; <br> seja y = 2; <br> if (x = y) { <br> // este bloco de códigos será executado para qualquer valor de y (a menos que y tenha sido originalmente definido como falsy) <br> } outro { <br> // este bloco de código é o que deve ser executado (mas não será) neste exemplo <br> } </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Corrija a condição para que o programa execute a ramificação direita e o valor apropriado seja atribuído ao <code>result</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'Seu código deve corrigir a condição para verificar a igualdade, em vez de usar a atribuição.'
|
||||
testString: 'assert(result == "Not equal!", "Your code should fix the condition so it checks for equality, instead of using assignment.");'
|
||||
- text: A condição pode usar <code>==</code> ou <code>===</code> para testar a igualdade.
|
||||
testString: 'assert(code.match(/x\s*?===?\s*?y/g), "The condition can use either <code>==</code> or <code>===</code> to test for equality.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let x = 7;
|
||||
let y = 9;
|
||||
let result = "to come";
|
||||
|
||||
if(x = y) {
|
||||
result = "Equal!";
|
||||
} else {
|
||||
result = "Not equal!";
|
||||
}
|
||||
|
||||
console.log(result);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,55 @@
|
||||
---
|
||||
id: 587d7b86367417b2b2512b3d
|
||||
title: Prevent Infinite Loops with a Valid Terminal Condition
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Evite Loops Infinitos com uma Condição Terminal Válida
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> O tópico final é o temido loop infinito. Os loops são ótimas ferramentas quando você precisa que seu programa execute um bloco de códigos um determinado número de vezes ou até que uma condição seja atendida, mas eles precisam de uma condição terminal que termine o loop. Loops infinitos tendem a congelar ou travar o navegador e causar o caos geral da execução do programa, que ninguém quer. Houve um exemplo de um ciclo infinito na introdução desta secção - que não tinha estado terminal para sair do <code>while</code> loop dentro <code>loopy()</code> . NÃO chame esta função! <blockquote> função loopy () { <br> while (true) { <br> console.log ("Olá, mundo!"); <br> } <br> } </blockquote> É tarefa do programador garantir que a condição do terminal, que informa ao programa quando sair do código de loop, seja atingida. Um erro é incrementar ou decrementar uma variável do contador na direção errada da condição do terminal. Outro é acidentalmente redefinir uma variável de contador ou índice dentro do código de loop, em vez de incrementar ou decrementar. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> A função <code>myFunc()</code> contém um loop infinito porque a condição terminal <code>i != 4</code> nunca será avaliada como <code>false</code> (e quebrará o loop) - <code>i</code> aumentarei em 2 cada passo, e saltará sobre 4, já <code>i</code> é estranho iniciar. Corrija o operador de comparação na condição do terminal para que o loop seja executado apenas para <code>i</code> menor ou igual a 4. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Seu código deve mudar o operador de comparação na condição terminal (a parte intermediária) do loop <code>for</code> .
|
||||
testString: 'assert(code.match(/i\s*?<=\s*?4;/g).length == 1, "Your code should change the comparison operator in the terminal condition (the middle part) of the <code>for</code> loop.");'
|
||||
- text: Seu código deve corrigir o operador de comparação na condição terminal do loop.
|
||||
testString: 'assert(!code.match(/i\s*?!=\s*?4;/g), "Your code should fix the comparison operator in the terminal condition of the loop.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function myFunc() {
|
||||
for (let i = 1; i != 4; i += 2) {
|
||||
console.log("Still going!");
|
||||
}
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,62 @@
|
||||
---
|
||||
id: 587d7b83367417b2b2512b37
|
||||
title: Understanding the Differences between the freeCodeCamp and Browser Console
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Entendendo as Diferenças entre o FreeCodeCamp e o Console do Navegador
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Você deve ter notado que alguns desafios do freeCodeCamp JavaScript incluem seu próprio console. Este console se comporta de maneira um pouco diferente do console do navegador usado no último desafio. O desafio a seguir destina-se a destacar algumas das diferenças entre o console freeCodeCamp e o console do navegador. Primeiro, o console do navegador. Quando você carrega e executa um arquivo JavaScript comum em seu navegador, as instruções <code>console.log()</code> imprimem exatamente o que você diz para imprimir no console do navegador o número exato de vezes que você solicitou. Em seu editor de texto no navegador, o processo é um pouco diferente e pode ser confuso no início. Os valores passados para o <code>console.log()</code> no bloco do editor de texto executam cada conjunto de testes, bem como mais uma vez para qualquer chamada de função que você tenha em seu código. Isso se presta a um comportamento interessante e pode atrapalhar você no início, porque um valor registrado que você espera ver apenas uma vez pode ser impresso várias vezes, dependendo do número de testes e dos valores sendo passados para esses testes. Se você quiser ver apenas sua saída única e não precisar se preocupar em executar os ciclos de teste, use <code>console.clear()</code> . </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Use <code>console.log()</code> para imprimir as variáveis no código onde indicado. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'Use <code>console.log()</code> para imprimir a variável <code>outputTwo</code> . No seu Console do Navegador, isso deve imprimir o valor da variável duas vezes.'
|
||||
testString: 'assert(code.match(/console\.log\(outputTwo\)/g), "Use <code>console.log()</code> to print the <code>outputTwo</code> variable. In your Browser Console this should print out the value of the variable two times.");'
|
||||
- text: Use <code>console.log()</code> para imprimir a variável <code>outputOne</code> .
|
||||
testString: 'assert(code.match(/console\.log\(outputOne\)/g), "Use <code>console.log()</code> to print the <code>outputOne</code> variable.");'
|
||||
- text: 'Use <code>console.clear()</code> para modificar sua saída, de forma que a variável <code>outputOne</code> apenas <code>outputOne</code> uma vez.'
|
||||
testString: 'assert(code.match(/^(\s*console.clear\(\);?\s*)$/gm), "Use <code>console.clear()</code> to modify your output so that <code>outputOne</code> variable only outputs once.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
// Open your browser console
|
||||
let outputTwo = "This will print to the browser console 2 times";
|
||||
// Use console.log() to print the outputTwo variable
|
||||
|
||||
|
||||
let outputOne = "Try to get this to log only once to the browser console";
|
||||
// Use console.clear() in the next line to print the outputOne only once
|
||||
|
||||
|
||||
// Use console.log() to print the outputOne variable
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,71 @@
|
||||
---
|
||||
id: 587d7b86367417b2b2512b3c
|
||||
title: Use Caution When Reinitializing Variables Inside a Loop
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Tenha cuidado ao reinicializar variáveis dentro de um loop
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Às vezes é necessário salvar informações, incrementar contadores ou redefinir variáveis dentro de um loop. Uma questão potencial é quando as variáveis devem ser reinicializadas e não são, ou vice-versa. Isso é particularmente perigoso se você acidentalmente redefinir a variável que está sendo usada para a condição do terminal, causando um loop infinito. A impressão de valores de variáveis em cada ciclo do loop usando <code>console.log()</code> pode revelar o comportamento de bugs relacionado à redefinição ou ao não redefinir uma variável. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> A seguinte função deve criar um array bidimensional com <code>m</code> linhas e <code>n</code> colunas de zeros. Infelizmente, ele não está produzindo a saída esperada porque a variável de <code>row</code> não está sendo reinicializada (definida para uma matriz vazia) no loop externo. Corrigir o código para que ele retorne uma matriz de zeros 3x2 correta, que se parece com <code>[[0, 0], [0, 0], [0, 0]]</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Seu código deve definir a variável <code>matrix</code> para um array contendo 3 linhas de 2 colunas de zeros cada.
|
||||
testString: 'assert(JSON.stringify(matrix) == "[[0,0],[0,0],[0,0]]", "Your code should set the <code>matrix</code> variable to an array holding 3 rows of 2 columns of zeroes each.");'
|
||||
- text: A variável da <code>matrix</code> deve ter 3 linhas.
|
||||
testString: 'assert(matrix.length == 3, "The <code>matrix</code> variable should have 3 rows.");'
|
||||
- text: A variável da <code>matrix</code> deve ter 2 colunas em cada linha.
|
||||
testString: 'assert(matrix[0].length == 2 && matrix[1].length === 2 && matrix[2].length === 2, "The <code>matrix</code> variable should have 2 columns in each row.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function zeroArray(m, n) {
|
||||
// Creates a 2-D array with m rows and n columns of zeroes
|
||||
let newArray = [];
|
||||
let row = [];
|
||||
for (let i = 0; i < m; i++) {
|
||||
// Adds the m-th row into newArray
|
||||
|
||||
for (let j = 0; j < n; j++) {
|
||||
// Pushes n zeroes into the current row to create the columns
|
||||
row.push(0);
|
||||
}
|
||||
// Pushes the current row, which now has n zeroes in it, to the array
|
||||
newArray.push(row);
|
||||
}
|
||||
return newArray;
|
||||
}
|
||||
|
||||
let matrix = zeroArray(3, 2);
|
||||
console.log(matrix);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,56 @@
|
||||
---
|
||||
id: 587d7b83367417b2b2512b33
|
||||
title: Use the JavaScript Console to Check the Value of a Variable
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Use o Console JavaScript para verificar o valor de uma variável
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Tanto o Chrome quanto o Firefox possuem excelentes consoles JavaScript, também conhecidos como DevTools, para depurar seu JavaScript. Você pode encontrar ferramentas do desenvolvedor no menu ou no console da Web do Chrome no menu do FireFox. Se você estiver usando um navegador diferente ou um celular, recomendamos mudar para o Firefox ou o Google Chrome para computador. O método <code>console.log()</code> , que "imprime" a saída do que está dentro de seus parênteses para o console, provavelmente será a ferramenta de depuração mais útil. Colocá-lo em pontos estratégicos em seu código pode mostrar os valores intermediários das variáveis. É uma boa prática ter uma ideia de qual deve ser a saída antes de analisar o que é. Ter pontos de verificação para ver o status de seus cálculos em todo o código ajudará a restringir onde está o problema. Aqui está um exemplo para imprimir "Hello world!" para o console: <code>console.log('Hello world!');</code> </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Use o método <code>console.log()</code> para imprimir o valor da variável <code>a</code> onde indicado no código. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Seu código deve usar <code>console.log()</code> para verificar o valor da variável <code>a</code> .
|
||||
testString: 'assert(code.match(/console\.log\(a\)/g), "Your code should use <code>console.log()</code> to check the value of the variable <code>a</code>.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let a = 5;
|
||||
let b = 1;
|
||||
a++;
|
||||
// Add your code below this line
|
||||
|
||||
|
||||
let sumAB = a + b;
|
||||
console.log(sumAB);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,56 @@
|
||||
---
|
||||
id: 587d7b84367417b2b2512b34
|
||||
title: Use typeof to Check the Type of a Variable
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Use typeof para verificar o tipo de uma variável
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Você pode usar <code>typeof</code> para verificar a estrutura de dados ou o tipo de uma variável. Isso é útil na depuração ao trabalhar com vários tipos de dados. Se você acha que está adicionando dois números, mas um é na verdade uma string, os resultados podem ser inesperados. Erros de tipo podem espreitar em cálculos ou chamadas de função. Tenha cuidado, especialmente quando você está acessando e trabalhando com dados externos na forma de um objeto JavaScript Object Notation (JSON). Aqui estão alguns exemplos usando <code>typeof</code> : <blockquote> console.log (tipo de ""); // produz "string" <br> console.log (tipo 0); // produz "número" <br> console.log (typeof []); // produz "objeto" <br> console.log (typeof {}); // produz "objeto" </blockquote> O JavaScript reconhece seis tipos de dados primitivos (imutáveis): <code>Boolean</code> , <code>Null</code> , <code>Undefined</code> , <code>Number</code> , <code>String</code> e <code>Symbol</code> (novo com ES6) e um tipo para itens mutáveis: <code>Object</code> . Observe que, em JavaScript, as matrizes são tecnicamente um tipo de objeto. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Adicione duas instruções <code>console.log()</code> para verificar o <code>typeof</code> cada uma das duas variáveis <code>seven</code> e <code>three</code> no código. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Seu código deve usar <code>typeof</code> em duas instruções <code>console.log()</code> para verificar o tipo das variáveis.
|
||||
testString: 'assert(code.match(/console\.log\(typeof[\( ].*\)?\)/g).length == 2, "Your code should use <code>typeof</code> in two <code>console.log()</code> statements to check the type of the variables.");'
|
||||
- text: Seu código deve usar <code>typeof</code> para verificar o tipo da variável <code>seven</code> .
|
||||
testString: 'assert(code.match(/typeof[\( ]seven\)?/g), "Your code should use <code>typeof</code> to check the type of the variable <code>seven</code>.");'
|
||||
- text: Seu código deve usar <code>typeof</code> para verificar o tipo da variável <code>three</code> .
|
||||
testString: 'assert(code.match(/typeof[\( ]three\)?/g), "Your code should use <code>typeof</code> to check the type of the variable <code>three</code>.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let seven = 7;
|
||||
let three = "3";
|
||||
console.log(seven + three);
|
||||
// Add your code below this line
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
Reference in New Issue
Block a user