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,74 @@
|
||||
---
|
||||
id: a77dbc43c33f39daa4429b4f
|
||||
title: Boo who
|
||||
isRequired: true
|
||||
challengeType: 5
|
||||
videoUrl: ''
|
||||
localeTitle: Boo que
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Verifique se um valor é classificado como um primitivo booleano. Retornar verdadeiro ou falso. Primitivas booleanas são verdadeiras e falsas. Lembre-se de usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> se você ficar preso. Tente emparelhar o programa. Escreva seu próprio código. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>booWho(true)</code> deve retornar true.
|
||||
testString: 'assert.strictEqual(booWho(true), true, "<code>booWho(true)</code> should return true.");'
|
||||
- text: <code>booWho(false)</code> deve retornar true.
|
||||
testString: 'assert.strictEqual(booWho(false), true, "<code>booWho(false)</code> should return true.");'
|
||||
- text: '<code>booWho([1, 2, 3])</code> deve retornar falso.'
|
||||
testString: 'assert.strictEqual(booWho([1, 2, 3]), false, "<code>booWho([1, 2, 3])</code> should return false.");'
|
||||
- text: '<code>booWho([].slice)</code> deve retornar false.'
|
||||
testString: 'assert.strictEqual(booWho([].slice), false, "<code>booWho([].slice)</code> should return false.");'
|
||||
- text: '<code>booWho({ "a": 1 })</code> deve retornar false.'
|
||||
testString: 'assert.strictEqual(booWho({ "a": 1 }), false, "<code>booWho({ "a": 1 })</code> should return false.");'
|
||||
- text: <code>booWho(1)</code> deve retornar false.
|
||||
testString: 'assert.strictEqual(booWho(1), false, "<code>booWho(1)</code> should return false.");'
|
||||
- text: <code>booWho(NaN)</code> deve retornar falso.
|
||||
testString: 'assert.strictEqual(booWho(NaN), false, "<code>booWho(NaN)</code> should return false.");'
|
||||
- text: <code>booWho("a")</code> deve retornar false.
|
||||
testString: 'assert.strictEqual(booWho("a"), false, "<code>booWho("a")</code> should return false.");'
|
||||
- text: <code>booWho("true")</code> deve retornar false.
|
||||
testString: 'assert.strictEqual(booWho("true"), false, "<code>booWho("true")</code> should return false.");'
|
||||
- text: <code>booWho("false")</code> deve retornar false.
|
||||
testString: 'assert.strictEqual(booWho("false"), false, "<code>booWho("false")</code> should return false.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function booWho(bool) {
|
||||
// What is the new fad diet for ghost developers? The Boolean.
|
||||
return bool;
|
||||
}
|
||||
|
||||
booWho(null);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,68 @@
|
||||
---
|
||||
id: a9bd25c716030ec90084d8a1
|
||||
title: Chunky Monkey
|
||||
isRequired: true
|
||||
challengeType: 5
|
||||
videoUrl: ''
|
||||
localeTitle: Macaco Robusto
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Escreva uma função que divide um array (primeiro argumento) em grupos com o tamanho do <code>size</code> (segundo argumento) e os retorna como um array bidimensional. Lembre-se de usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> se você ficar preso. Escreva seu próprio código. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: '<code>chunkArrayInGroups(["a", "b", "c", "d"], 2)</code> deve retornar <code>[["a", "b"], ["c", "d"]]</code> .'
|
||||
testString: 'assert.deepEqual(chunkArrayInGroups(["a", "b", "c", "d"], 2), [["a", "b"], ["c", "d"]], "<code>chunkArrayInGroups(["a", "b", "c", "d"], 2)</code> should return <code>[["a", "b"], ["c", "d"]]</code>.");'
|
||||
- text: '<code>chunkArrayInGroups([0, 1, 2, 3, 4, 5], 3)</code> deve retornar <code>[[0, 1, 2], [3, 4, 5]]</code> .'
|
||||
testString: 'assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5], 3), [[0, 1, 2], [3, 4, 5]], "<code>chunkArrayInGroups([0, 1, 2, 3, 4, 5], 3)</code> should return <code>[[0, 1, 2], [3, 4, 5]]</code>.");'
|
||||
- text: '<code>chunkArrayInGroups([0, 1, 2, 3, 4, 5], 2)</code> deve retornar <code>[[0, 1], [2, 3], [4, 5]]</code> .'
|
||||
testString: 'assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5], 2), [[0, 1], [2, 3], [4, 5]], "<code>chunkArrayInGroups([0, 1, 2, 3, 4, 5], 2)</code> should return <code>[[0, 1], [2, 3], [4, 5]]</code>.");'
|
||||
- text: '<code>chunkArrayInGroups([0, 1, 2, 3, 4, 5], 4)</code> deve retornar <code>[[0, 1, 2, 3], [4, 5]]</code> .'
|
||||
testString: 'assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5], 4), [[0, 1, 2, 3], [4, 5]], "<code>chunkArrayInGroups([0, 1, 2, 3, 4, 5], 4)</code> should return <code>[[0, 1, 2, 3], [4, 5]]</code>.");'
|
||||
- text: '<code>chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6], 3)</code> deve retornar <code>[[0, 1, 2], [3, 4, 5], [6]]</code> .'
|
||||
testString: 'assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6], 3), [[0, 1, 2], [3, 4, 5], [6]], "<code>chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6], 3)</code> should return <code>[[0, 1, 2], [3, 4, 5], [6]]</code>.");'
|
||||
- text: '<code>chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 4)</code> deve retornar <code>[[0, 1, 2, 3], [4, 5, 6, 7], [8]]</code> .'
|
||||
testString: 'assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 4), [[0, 1, 2, 3], [4, 5, 6, 7], [8]], "<code>chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 4)</code> should return <code>[[0, 1, 2, 3], [4, 5, 6, 7], [8]]</code>.");'
|
||||
- text: '<code>chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 2)</code> deve retornar <code>[[0, 1], [2, 3], [4, 5], [6, 7], [8]]</code> .'
|
||||
testString: 'assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 2), [[0, 1], [2, 3], [4, 5], [6, 7], [8]], "<code>chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 2)</code> should return <code>[[0, 1], [2, 3], [4, 5], [6, 7], [8]]</code>.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function chunkArrayInGroups(arr, size) {
|
||||
// Break it up.
|
||||
return arr;
|
||||
}
|
||||
|
||||
chunkArrayInGroups(["a", "b", "c", "d"], 2);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,77 @@
|
||||
---
|
||||
id: acda2fb1324d9b0fa741e6b5
|
||||
title: Confirm the Ending
|
||||
isRequired: true
|
||||
challengeType: 5
|
||||
videoUrl: ''
|
||||
localeTitle: Confirme o final
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Verifique se uma string (primeiro argumento, <code>str</code> ) termina com a string de destino (segundo argumento, <code>target</code> ). Esse desafio <em>pode</em> ser resolvido com o método <code>.endsWith()</code> , que foi introduzido no ES2015. Mas, para o propósito deste desafio, gostaríamos que você usasse um dos métodos de substring JavaScript. Lembre-se de usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> se você ficar preso. Escreva seu próprio código. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: '<code>confirmEnding("Bastian", "n")</code> deve retornar true.'
|
||||
testString: 'assert(confirmEnding("Bastian", "n") === true, "<code>confirmEnding("Bastian", "n")</code> should return true.");'
|
||||
- text: '<code>confirmEnding("Congratulation", "on")</code> deve retornar true.'
|
||||
testString: 'assert(confirmEnding("Congratulation", "on") === true, "<code>confirmEnding("Congratulation", "on")</code> should return true.");'
|
||||
- text: '<code>confirmEnding("Connor", "n")</code> deve retornar false.'
|
||||
testString: 'assert(confirmEnding("Connor", "n") === false, "<code>confirmEnding("Connor", "n")</code> should return false.");'
|
||||
- text: '<code>confirmEnding("Walking on water and developing software from a specification are easy if both are frozen", "specification")</code> deve retornar falso.'
|
||||
testString: 'assert(confirmEnding("Walking on water and developing software from a specification are easy if both are frozen", "specification") === false, "<code>confirmEnding("Walking on water and developing software from a specification are easy if both are frozen", "specification")</code> should return false.");'
|
||||
- text: '<code>confirmEnding("He has to give me a new name", "name")</code> deve retornar true.'
|
||||
testString: 'assert(confirmEnding("He has to give me a new name", "name") === true, "<code>confirmEnding("He has to give me a new name", "name")</code> should return true.");'
|
||||
- text: '<code>confirmEnding("Open sesame", "same")</code> deve retornar true.'
|
||||
testString: 'assert(confirmEnding("Open sesame", "same") === true, "<code>confirmEnding("Open sesame", "same")</code> should return true.");'
|
||||
- text: '<code>confirmEnding("Open sesame", "pen")</code> deve retornar false.'
|
||||
testString: 'assert(confirmEnding("Open sesame", "pen") === false, "<code>confirmEnding("Open sesame", "pen")</code> should return false.");'
|
||||
- text: '<code>confirmEnding("Open sesame", "game")</code> deve retornar false.'
|
||||
testString: 'assert(confirmEnding("Open sesame", "game") === false, "<code>confirmEnding("Open sesame", "game")</code> should return false.");'
|
||||
- text: '<code>confirmEnding("If you want to save our world, you must hurry. We dont know how much longer we can withstand the nothing", "mountain")</code> deve retornar falso.'
|
||||
testString: 'assert(confirmEnding("If you want to save our world, you must hurry. We dont know how much longer we can withstand the nothing", "mountain") === false, "<code>confirmEnding("If you want to save our world, you must hurry. We dont know how much longer we can withstand the nothing", "mountain")</code> should return false.");'
|
||||
- text: '<code>confirmEnding("Abstraction", "action")</code> deve retornar true.'
|
||||
testString: 'assert(confirmEnding("Abstraction", "action") === true, "<code>confirmEnding("Abstraction", "action")</code> should return true.");'
|
||||
- text: Não use o método <code>.endsWith()</code> para resolver o desafio.
|
||||
testString: 'assert(!(/\.endsWith\(.*?\)\s*?;?/.test(code)) && !(/\["endsWith"\]/.test(code)), "Do not use the built-in method <code>.endsWith()</code> to solve the challenge.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function confirmEnding(str, target) {
|
||||
// "Never give up and good luck will find you."
|
||||
// -- Falcor
|
||||
return str;
|
||||
}
|
||||
|
||||
confirmEnding("Bastian", "n");
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,66 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244b3
|
||||
title: Convert Celsius to Fahrenheit
|
||||
challengeType: 1
|
||||
isRequired: true
|
||||
videoUrl: ''
|
||||
localeTitle: Converter Celsius para Fahrenheit
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> O algoritmo para converter de Celsius para Fahrenheit é a temperatura em Celsius vezes <code>9/5</code> , mais <code>32</code> . Você recebe uma variável <code>celsius</code> representando uma temperatura em Celsius. Use a variável <code>fahrenheit</code> já definida e atribua a temperatura Fahrenheit equivalente à temperatura Celsius especificada. Use o algoritmo mencionado acima para ajudar a converter a temperatura Celsius em Fahrenheit. Não se preocupe muito com as declarações de função e retorno, pois elas serão abordadas em desafios futuros. Por enquanto, use apenas operadores que você já aprendeu. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>convertToF(0)</code> deve retornar um número
|
||||
testString: 'assert(typeof convertToF(0) === "number", "<code>convertToF(0)</code> should return a number");'
|
||||
- text: <code>convertToF(-30)</code> deve retornar um valor de <code>-22</code>
|
||||
testString: 'assert(convertToF(-30) === -22, "<code>convertToF(-30)</code> should return a value of <code>-22</code>");'
|
||||
- text: <code>convertToF(-10)</code> deve retornar um valor de <code>14</code>
|
||||
testString: 'assert(convertToF(-10) === 14, "<code>convertToF(-10)</code> should return a value of <code>14</code>");'
|
||||
- text: <code>convertToF(0)</code> deve retornar um valor de <code>32</code>
|
||||
testString: 'assert(convertToF(0) === 32, "<code>convertToF(0)</code> should return a value of <code>32</code>");'
|
||||
- text: <code>convertToF(20)</code> deve retornar um valor de <code>68</code>
|
||||
testString: 'assert(convertToF(20) === 68, "<code>convertToF(20)</code> should return a value of <code>68</code>");'
|
||||
- text: <code>convertToF(30)</code> deve retornar um valor de <code>86</code>
|
||||
testString: 'assert(convertToF(30) === 86, "<code>convertToF(30)</code> should return a value of <code>86</code>");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function convertToF(celsius) {
|
||||
let fahrenheit;
|
||||
return fahrenheit;
|
||||
}
|
||||
|
||||
convertToF(30);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,63 @@
|
||||
---
|
||||
id: a302f7aae1aa3152a5b413bc
|
||||
title: Factorialize a Number
|
||||
isRequired: true
|
||||
challengeType: 5
|
||||
videoUrl: ''
|
||||
localeTitle: Factorialize um número
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Retorna o fatorial do inteiro fornecido. Se o inteiro é representado com a letra n, um fatorial é o produto de todos os inteiros positivos menores ou iguais a n. Os fatoriais são frequentemente representados com a notação abreviada <code>n!</code> Por exemplo: <code>5! = 1 * 2 * 3 * 4 * 5 = 120</code> Somente números inteiros maiores ou iguais a zero serão fornecidos para a função. Lembre-se de usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> se você ficar preso. Escreva seu próprio código. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>factorialize(5)</code> deve retornar um número.
|
||||
testString: 'assert(typeof factorialize(5) === "number", "<code>factorialize(5)</code> should return a number.");'
|
||||
- text: <code>factorialize(5)</code> deve retornar 120.
|
||||
testString: 'assert(factorialize(5) === 120, "<code>factorialize(5)</code> should return 120.");'
|
||||
- text: <code>factorialize(10)</code> deve retornar 3628800.
|
||||
testString: 'assert(factorialize(10) === 3628800, "<code>factorialize(10)</code> should return 3628800.");'
|
||||
- text: <code>factorialize(20)</code> deve retornar 2432902008176640000.
|
||||
testString: 'assert(factorialize(20) === 2432902008176640000, "<code>factorialize(20)</code> should return 2432902008176640000.");'
|
||||
- text: <code>factorialize(0)</code> deve retornar 1.
|
||||
testString: 'assert(factorialize(0) === 1, "<code>factorialize(0)</code> should return 1.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function factorialize(num) {
|
||||
return num;
|
||||
}
|
||||
|
||||
factorialize(5);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,62 @@
|
||||
---
|
||||
id: adf08ec01beb4f99fc7a68f2
|
||||
title: Falsy Bouncer
|
||||
isRequired: true
|
||||
challengeType: 5
|
||||
videoUrl: ''
|
||||
localeTitle: Bouncer Falsy
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Remova todos os valores falsos de uma matriz. Os valores de paralisia em JavaScript são <code>false</code> , <code>null</code> , <code>0</code> , <code>""</code> , <code>undefined</code> e <code>NaN</code> . Dica: tente converter cada valor em um booleano. Lembre-se de usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> se você ficar preso. Escreva seu próprio código. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: '<code>bouncer([7, "ate", "", false, 9])</code> deve retornar <code>[7, "ate", 9]</code> .'
|
||||
testString: 'assert.deepEqual(bouncer([7, "ate", "", false, 9]), [7, "ate", 9], "<code>bouncer([7, "ate", "", false, 9])</code> should return <code>[7, "ate", 9]</code>.");'
|
||||
- text: '<code>bouncer(["a", "b", "c"])</code> deve retornar <code>["a", "b", "c"]</code> .'
|
||||
testString: 'assert.deepEqual(bouncer(["a", "b", "c"]), ["a", "b", "c"], "<code>bouncer(["a", "b", "c"])</code> should return <code>["a", "b", "c"]</code>.");'
|
||||
- text: '<code>bouncer([false, null, 0, NaN, undefined, ""])</code> deve retornar <code>[]</code> .'
|
||||
testString: 'assert.deepEqual(bouncer([false, null, 0, NaN, undefined, ""]), [], "<code>bouncer([false, null, 0, NaN, undefined, ""])</code> should return <code>[]</code>.");'
|
||||
- text: '<code>bouncer([1, null, NaN, 2, undefined])</code> deve retornar <code>[1, 2]</code> .'
|
||||
testString: 'assert.deepEqual(bouncer([1, null, NaN, 2, undefined]), [1, 2], "<code>bouncer([1, null, NaN, 2, undefined])</code> should return <code>[1, 2]</code>.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function bouncer(arr) {
|
||||
// Don't show a false ID to this bouncer.
|
||||
return arr;
|
||||
}
|
||||
|
||||
bouncer([7, "ate", "", false, 9]);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,65 @@
|
||||
---
|
||||
id: a26cbbe9ad8655a977e1ceb5
|
||||
title: Find the Longest Word in a String
|
||||
isRequired: true
|
||||
challengeType: 5
|
||||
videoUrl: ''
|
||||
localeTitle: Encontre a palavra mais longa em uma string
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Retorna o tamanho da palavra mais longa na frase fornecida. Sua resposta deve ser um número. Lembre-se de usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> se você ficar preso. Escreva seu próprio código. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>findLongestWordLength("The quick brown fox jumped over the lazy dog")</code> deve retornar um número.
|
||||
testString: 'assert(typeof findLongestWordLength("The quick brown fox jumped over the lazy dog") === "number", "<code>findLongestWordLength("The quick brown fox jumped over the lazy dog")</code> should return a number.");'
|
||||
- text: <code>findLongestWordLength("The quick brown fox jumped over the lazy dog")</code> deve retornar 6.
|
||||
testString: 'assert(findLongestWordLength("The quick brown fox jumped over the lazy dog") === 6, "<code>findLongestWordLength("The quick brown fox jumped over the lazy dog")</code> should return 6.");'
|
||||
- text: <code>findLongestWordLength("May the force be with you")</code> deve retornar 5.
|
||||
testString: 'assert(findLongestWordLength("May the force be with you") === 5, "<code>findLongestWordLength("May the force be with you")</code> should return 5.");'
|
||||
- text: <code>findLongestWordLength("Google do a barrel roll")</code> deve retornar 6.
|
||||
testString: 'assert(findLongestWordLength("Google do a barrel roll") === 6, "<code>findLongestWordLength("Google do a barrel roll")</code> should return 6.");'
|
||||
- text: <code>findLongestWordLength("What is the average airspeed velocity of an unladen swallow")</code> deve retornar 8.
|
||||
testString: 'assert(findLongestWordLength("What is the average airspeed velocity of an unladen swallow") === 8, "<code>findLongestWordLength("What is the average airspeed velocity of an unladen swallow")</code> should return 8.");'
|
||||
- text: <code>findLongestWordLength("What if we try a super-long word such as otorhinolaryngology")</code> deve retornar 19.
|
||||
testString: 'assert(findLongestWordLength("What if we try a super-long word such as otorhinolaryngology") === 19, "<code>findLongestWordLength("What if we try a super-long word such as otorhinolaryngology")</code> should return 19.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function findLongestWordLength(str) {
|
||||
return str.length;
|
||||
}
|
||||
|
||||
findLongestWordLength("The quick brown fox jumped over the lazy dog");
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,58 @@
|
||||
---
|
||||
id: a6e40f1041b06c996f7b2406
|
||||
title: Finders Keepers
|
||||
isRequired: true
|
||||
challengeType: 5
|
||||
videoUrl: ''
|
||||
localeTitle: Achado não é roubado
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Crie uma função que examine uma matriz (primeiro argumento) e retorne o primeiro elemento da matriz que passa por um teste de verdade (segundo argumento). Se nenhum elemento passar no teste, retorne indefinido. Lembre-se de usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> se você ficar preso. Tente emparelhar o programa. Escreva seu próprio código. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: '<code>findElement([1, 3, 5, 8, 9, 10], function(num) { return num % 2 === 0; })</code> deve retornar 8.'
|
||||
testString: 'assert.strictEqual(findElement([1, 3, 5, 8, 9, 10], function(num) { return num % 2 === 0; }), 8, "<code>findElement([1, 3, 5, 8, 9, 10], function(num) { return num % 2 === 0; })</code> should return 8.");'
|
||||
- text: '<code>findElement([1, 3, 5, 9], function(num) { return num % 2 === 0; })</code> deve retornar indefinido.'
|
||||
testString: 'assert.strictEqual(findElement([1, 3, 5, 9], function(num) { return num % 2 === 0; }), undefined, "<code>findElement([1, 3, 5, 9], function(num) { return num % 2 === 0; })</code> should return undefined.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function findElement(arr, func) {
|
||||
let num = 0;
|
||||
return num;
|
||||
}
|
||||
|
||||
findElement([1, 2, 3, 4], num => num % 2 === 0);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,71 @@
|
||||
---
|
||||
id: af2170cad53daa0770fabdea
|
||||
title: Mutations
|
||||
isRequired: true
|
||||
challengeType: 5
|
||||
videoUrl: ''
|
||||
localeTitle: Mutações
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Retorna true se a string no primeiro elemento da matriz contiver todas as letras da string no segundo elemento da matriz. Por exemplo, <code>["hello", "Hello"]</code> , deve retornar true porque todas as letras na segunda string estão presentes na primeira, ignorando o caso. Os argumentos <code>["hello", "hey"]</code> devem retornar false porque a string "hello" não contém um "y". Por último, <code>["Alien", "line"]</code> , deve retornar true porque todas as letras em "line" estão presentes em "Alien". Lembre-se de usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> se você ficar preso. Escreva seu próprio código. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: '<code>mutation(["hello", "hey"])</code> deve retornar false.'
|
||||
testString: 'assert(mutation(["hello", "hey"]) === false, "<code>mutation(["hello", "hey"])</code> should return false.");'
|
||||
- text: '<code>mutation(["hello", "Hello"])</code> deve retornar true.'
|
||||
testString: 'assert(mutation(["hello", "Hello"]) === true, "<code>mutation(["hello", "Hello"])</code> should return true.");'
|
||||
- text: '<code>mutation(["zyxwvutsrqponmlkjihgfedcba", "qrstu"])</code> deve retornar true.'
|
||||
testString: 'assert(mutation(["zyxwvutsrqponmlkjihgfedcba", "qrstu"]) === true, "<code>mutation(["zyxwvutsrqponmlkjihgfedcba", "qrstu"])</code> should return true.");'
|
||||
- text: '<code>mutation(["Mary", "Army"])</code> deve retornar true.'
|
||||
testString: 'assert(mutation(["Mary", "Army"]) === true, "<code>mutation(["Mary", "Army"])</code> should return true.");'
|
||||
- text: '<code>mutation(["Mary", "Aarmy"])</code> deve retornar true.'
|
||||
testString: 'assert(mutation(["Mary", "Aarmy"]) === true, "<code>mutation(["Mary", "Aarmy"])</code> should return true.");'
|
||||
- text: '<code>mutation(["Alien", "line"])</code> deve retornar true.'
|
||||
testString: 'assert(mutation(["Alien", "line"]) === true, "<code>mutation(["Alien", "line"])</code> should return true.");'
|
||||
- text: '<code>mutation(["floor", "for"])</code> deve retornar true.'
|
||||
testString: 'assert(mutation(["floor", "for"]) === true, "<code>mutation(["floor", "for"])</code> should return true.");'
|
||||
- text: '<code>mutation(["hello", "neo"])</code> deve retornar false.'
|
||||
testString: 'assert(mutation(["hello", "neo"]) === false, "<code>mutation(["hello", "neo"])</code> should return false.");'
|
||||
- text: '<code>mutation(["voodoo", "no"])</code> deve retornar false.'
|
||||
testString: 'assert(mutation(["voodoo", "no"]) === false, "<code>mutation(["voodoo", "no"])</code> should return false.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function mutation(arr) {
|
||||
return arr;
|
||||
}
|
||||
|
||||
mutation(["hello", "hey"]);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,68 @@
|
||||
---
|
||||
id: afcc8d540bea9ea2669306b6
|
||||
title: Repeat a String Repeat a String
|
||||
isRequired: true
|
||||
challengeType: 5
|
||||
videoUrl: ''
|
||||
localeTitle: Repetir uma String Repetir uma String
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Repetir uma string <code>str</code> (primeiro argumento) para <code>num</code> times (segundo argumento). Retorna uma string vazia se <code>num</code> não for um número positivo. Lembre-se de usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> se você ficar preso. Escreva seu próprio código. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: '<code>repeatStringNumTimes("*", 3)</code> deve retornar <code>"***"</code> .'
|
||||
testString: 'assert(repeatStringNumTimes("*", 3) === "***", "<code>repeatStringNumTimes("*", 3)</code> should return <code>"***"</code>.");'
|
||||
- text: '<code>repeatStringNumTimes("abc", 3)</code> deve retornar <code>"abcabcabc"</code> .'
|
||||
testString: 'assert(repeatStringNumTimes("abc", 3) === "abcabcabc", "<code>repeatStringNumTimes("abc", 3)</code> should return <code>"abcabcabc"</code>.");'
|
||||
- text: '<code>repeatStringNumTimes("abc", 4)</code> deve retornar <code>"abcabcabcabc"</code> .'
|
||||
testString: 'assert(repeatStringNumTimes("abc", 4) === "abcabcabcabc", "<code>repeatStringNumTimes("abc", 4)</code> should return <code>"abcabcabcabc"</code>.");'
|
||||
- text: '<code>repeatStringNumTimes("abc", 1)</code> deve retornar <code>"abc"</code> .'
|
||||
testString: 'assert(repeatStringNumTimes("abc", 1) === "abc", "<code>repeatStringNumTimes("abc", 1)</code> should return <code>"abc"</code>.");'
|
||||
- text: '<code>repeatStringNumTimes("*", 8)</code> deve retornar <code>"********"</code> .'
|
||||
testString: 'assert(repeatStringNumTimes("*", 8) === "********", "<code>repeatStringNumTimes("*", 8)</code> should return <code>"********"</code>.");'
|
||||
- text: '<code>repeatStringNumTimes("abc", -2)</code> deve retornar <code>""</code> .'
|
||||
testString: 'assert(repeatStringNumTimes("abc", -2) === "", "<code>repeatStringNumTimes("abc", -2)</code> should return <code>""</code>.");'
|
||||
- text: O método <code>repeat()</code> incorporado não deve ser usado
|
||||
testString: 'assert(!/\.repeat/g.test(code), "The built-in <code>repeat()</code>-method should not be used");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function repeatStringNumTimes(str, num) {
|
||||
// repeat after me
|
||||
return str;
|
||||
}
|
||||
|
||||
repeatStringNumTimes("abc", 3);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,62 @@
|
||||
---
|
||||
id: a789b3483989747d63b0e427
|
||||
title: Return Largest Numbers in Arrays
|
||||
isRequired: true
|
||||
challengeType: 5
|
||||
videoUrl: ''
|
||||
localeTitle: Retornar os maiores números em matrizes
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Devolve um array que consiste no maior número de cada sub-array fornecido. Para simplificar, a matriz fornecida conterá exatamente quatro sub-matrizes. Lembre-se, você pode percorrer uma matriz com um loop for simples e acessar cada membro com a sintaxe de array <code>arr[i]</code> . Lembre-se de usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> se você ficar preso. Escreva seu próprio código. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: '<code>largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]])</code> deve retornar uma matriz.'
|
||||
testString: 'assert(largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]).constructor === Array, "<code>largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]])</code> should return an array.");'
|
||||
- text: '<code>largestOfFour([[13, 27, 18, 26], [4, 5, 1, 3], [32, 35, 37, 39], [1000, 1001, 857, 1]])</code> deve retornar <code>[27, 5, 39, 1001]</code> .'
|
||||
testString: 'assert.deepEqual(largestOfFour([[13, 27, 18, 26], [4, 5, 1, 3], [32, 35, 37, 39], [1000, 1001, 857, 1]]), [27, 5, 39, 1001], "<code>largestOfFour([[13, 27, 18, 26], [4, 5, 1, 3], [32, 35, 37, 39], [1000, 1001, 857, 1]])</code> should return <code>[27, 5, 39, 1001]</code>.");'
|
||||
- text: '<code>largestOfFour([[4, 9, 1, 3], [13, 35, 18, 26], [32, 35, 97, 39], [1000000, 1001, 857, 1]])</code> deve retornar <code>[9, 35, 97, 1000000]</code> .'
|
||||
testString: 'assert.deepEqual(largestOfFour([[4, 9, 1, 3], [13, 35, 18, 26], [32, 35, 97, 39], [1000000, 1001, 857, 1]]), [9, 35, 97, 1000000], "<code>largestOfFour([[4, 9, 1, 3], [13, 35, 18, 26], [32, 35, 97, 39], [1000000, 1001, 857, 1]])</code> should return <code>[9, 35, 97, 1000000]</code>.");'
|
||||
- text: '<code>largestOfFour([[17, 23, 25, 12], [25, 7, 34, 48], [4, -10, 18, 21], [-72, -3, -17, -10]])</code> retorno <code>[25, 48, 21, -3]</code> .'
|
||||
testString: 'assert.deepEqual(largestOfFour([[17, 23, 25, 12], [25, 7, 34, 48], [4, -10, 18, 21], [-72, -3, -17, -10]]), [25, 48, 21, -3], "<code>largestOfFour([[17, 23, 25, 12], [25, 7, 34, 48], [4, -10, 18, 21], [-72, -3, -17, -10]])</code> should return <code>[25, 48, 21, -3]</code>.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function largestOfFour(arr) {
|
||||
// You can do this!
|
||||
return arr;
|
||||
}
|
||||
|
||||
largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,61 @@
|
||||
---
|
||||
id: a202eed8fc186c8434cb6d61
|
||||
title: Reverse a String
|
||||
isRequired: true
|
||||
challengeType: 5
|
||||
videoUrl: ''
|
||||
localeTitle: Reverter uma string
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Inverta a string fornecida. Você pode precisar transformar a string em uma matriz antes de poder revertê-la. Seu resultado deve ser uma string. Lembre-se de usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> se você ficar preso. Escreva seu próprio código. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>reverseString("hello")</code> deve retornar uma string.
|
||||
testString: 'assert(typeof reverseString("hello") === "string", "<code>reverseString("hello")</code> should return a string.");'
|
||||
- text: <code>reverseString("hello")</code> deve se tornar <code>"olleh"</code> .
|
||||
testString: 'assert(reverseString("hello") === "olleh", "<code>reverseString("hello")</code> should become <code>"olleh"</code>.");'
|
||||
- text: <code>reverseString("Howdy")</code> deve se tornar <code>"ydwoH"</code> .
|
||||
testString: 'assert(reverseString("Howdy") === "ydwoH", "<code>reverseString("Howdy")</code> should become <code>"ydwoH"</code>.");'
|
||||
- text: <code>reverseString("Greetings from Earth")</code> deve retornar <code>"htraE morf sgniteerG"</code> .
|
||||
testString: 'assert(reverseString("Greetings from Earth") === "htraE morf sgniteerG", "<code>reverseString("Greetings from Earth")</code> should return <code>"htraE morf sgniteerG"</code>.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function reverseString(str) {
|
||||
return str;
|
||||
}
|
||||
|
||||
reverseString("hello");
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,75 @@
|
||||
---
|
||||
id: 579e2a2c335b9d72dd32e05c
|
||||
title: Slice and Splice
|
||||
isRequired: true
|
||||
isBeta: true
|
||||
challengeType: 5
|
||||
videoUrl: ''
|
||||
localeTitle: Fatia e Splice
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Você recebe dois arrays e um índice. Use a <code>slice</code> métodos de matriz e <code>splice</code> para copiar cada elemento da primeira matriz na segunda matriz, em ordem. Comece inserindo elementos no índice <code>n</code> do segundo array. Retorna a matriz resultante. As matrizes de entrada devem permanecer as mesmas após a execução da função. Lembre-se de usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> se você ficar preso. Escreva seu próprio código. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: '<code>frankenSplice([1, 2, 3], [4, 5], 1)</code> deve retornar <code>[4, 1, 2, 3, 5]</code> .'
|
||||
testString: 'assert.deepEqual(frankenSplice([1, 2, 3], [4, 5], 1), [4, 1, 2, 3, 5], "<code>frankenSplice([1, 2, 3], [4, 5], 1)</code> should return <code>[4, 1, 2, 3, 5]</code>.");'
|
||||
- text: '<code>frankenSplice([1, 2], ["a", "b"], 1)</code> deve retornar <code>["a", 1, 2, "b"]</code> .'
|
||||
testString: 'assert.deepEqual(frankenSplice(testArr1, testArr2, 1), ["a", 1, 2, "b"], "<code>frankenSplice([1, 2], ["a", "b"], 1)</code> should return <code>["a", 1, 2, "b"]</code>.");'
|
||||
- text: '<code>frankenSplice(["claw", "tentacle"], ["head", "shoulders", "knees", "toes"], 2)</code> deve retornar <code>["head", "shoulders", "claw", "tentacle", "knees", "toes"]</code> .'
|
||||
testString: 'assert.deepEqual(frankenSplice(["claw", "tentacle"], ["head", "shoulders", "knees", "toes"], 2), ["head", "shoulders", "claw", "tentacle", "knees", "toes"], "<code>frankenSplice(["claw", "tentacle"], ["head", "shoulders", "knees", "toes"], 2)</code> should return <code>["head", "shoulders", "claw", "tentacle", "knees", "toes"]</code>.");'
|
||||
- text: Todos os elementos da primeira matriz devem ser adicionados à segunda matriz na ordem original.
|
||||
testString: 'assert.deepEqual(frankenSplice([1, 2, 3, 4], [], 0), [1, 2, 3, 4], "All elements from the first array should be added to the second array in their original order.");'
|
||||
- text: O primeiro array deve permanecer o mesmo após a execução da função.
|
||||
testString: 'assert(testArr1[0] === 1 && testArr1[1] === 2, "The first array should remain the same after the function runs.");'
|
||||
- text: O segundo array deve permanecer o mesmo após a execução da função.
|
||||
testString: 'assert(testArr2[0] === "a" && testArr2[1] === "b", "The second array should remain the same after the function runs.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function frankenSplice(arr1, arr2, n) {
|
||||
// It's alive. It's alive!
|
||||
return arr2;
|
||||
}
|
||||
|
||||
frankenSplice([1, 2, 3], [4, 5, 6], 1);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,61 @@
|
||||
---
|
||||
id: ab6137d4e35944e21037b769
|
||||
title: Title Case a Sentence
|
||||
isRequired: true
|
||||
challengeType: 5
|
||||
videoUrl: ''
|
||||
localeTitle: Title Case a Sentence
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Retorna a string fornecida com a primeira letra de cada palavra em maiúscula. Certifique-se de que o restante da palavra esteja em letras minúsculas. Para o propósito deste exercício, você também deve capitalizar palavras de conexão como "o" e "de". Lembre-se de usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> se você ficar preso. Escreva seu próprio código. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: '<code>titleCase("I'm a little tea pot")</code> deve retornar uma string.'
|
||||
testString: 'assert(typeof titleCase("I"m a little tea pot") === "string", "<code>titleCase("I'm a little tea pot")</code> should return a string.");'
|
||||
- text: '<code>titleCase("I'm a little tea pot")</code> deve retornar <code>I'm A Little Tea Pot</code> .'
|
||||
testString: 'assert(titleCase("I"m a little tea pot") === "I"m A Little Tea Pot", "<code>titleCase("I'm a little tea pot")</code> should return <code>I'm A Little Tea Pot</code>.");'
|
||||
- text: <code>titleCase("sHoRt AnD sToUt")</code> deve retornar <code>Short And Stout</code> .
|
||||
testString: 'assert(titleCase("sHoRt AnD sToUt") === "Short And Stout", "<code>titleCase("sHoRt AnD sToUt")</code> should return <code>Short And Stout</code>.");'
|
||||
- text: <code>titleCase("HERE IS MY HANDLE HERE IS MY SPOUT")</code> deve retornar <code>Here Is My Handle Here Is My Spout</code> .
|
||||
testString: 'assert(titleCase("HERE IS MY HANDLE HERE IS MY SPOUT") === "Here Is My Handle Here Is My Spout", "<code>titleCase("HERE IS MY HANDLE HERE IS MY SPOUT")</code> should return <code>Here Is My Handle Here Is My Spout</code>.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function titleCase(str) {
|
||||
return str;
|
||||
}
|
||||
|
||||
titleCase("I'm a little tea pot");
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,66 @@
|
||||
---
|
||||
id: ac6993d51946422351508a41
|
||||
title: Truncate a String
|
||||
isRequired: true
|
||||
challengeType: 5
|
||||
videoUrl: ''
|
||||
localeTitle: Truncar uma string
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Truncar uma string (primeiro argumento) se for maior que o tamanho máximo da string (segundo argumento). Retorna a string truncada com um <code>...</code> terminando. Lembre-se de usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> se você ficar preso. Escreva seu próprio código. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: '<code>truncateString("A-tisket a-tasket A green and yellow basket", 8)</code> deve retornar "A-tisket ...".'
|
||||
testString: 'assert(truncateString("A-tisket a-tasket A green and yellow basket", 8) === "A-tisket...", "<code>truncateString("A-tisket a-tasket A green and yellow basket", 8)</code> should return "A-tisket...".");'
|
||||
- text: '<code>truncateString("Peter Piper picked a peck of pickled peppers", 11)</code> deve retornar "Peter Piper ...".'
|
||||
testString: 'assert(truncateString("Peter Piper picked a peck of pickled peppers", 11) === "Peter Piper...", "<code>truncateString("Peter Piper picked a peck of pickled peppers", 11)</code> should return "Peter Piper...".");'
|
||||
- text: '<code>truncateString("A-tisket a-tasket A green and yellow basket", "A-tisket a-tasket A green and yellow basket".length)</code> deve retornar "A-tisket a-tasket Uma cesta verde e amarela".'
|
||||
testString: 'assert(truncateString("A-tisket a-tasket A green and yellow basket", "A-tisket a-tasket A green and yellow basket".length) === "A-tisket a-tasket A green and yellow basket", "<code>truncateString("A-tisket a-tasket A green and yellow basket", "A-tisket a-tasket A green and yellow basket".length)</code> should return "A-tisket a-tasket A green and yellow basket".");'
|
||||
- text: '<code>truncateString("A-tisket a-tasket A green and yellow basket", "A-tisket a-tasket A green and yellow basket".length + 2)</code> deve retornar "A-tisket a-tasket Uma cesta verde e amarela".'
|
||||
testString: 'assert(truncateString("A-tisket a-tasket A green and yellow basket", "A-tisket a-tasket A green and yellow basket".length + 2) === "A-tisket a-tasket A green and yellow basket", "<code>truncateString("A-tisket a-tasket A green and yellow basket", "A-tisket a-tasket A green and yellow basket".length + 2)</code> should return "A-tisket a-tasket A green and yellow basket".");'
|
||||
- text: '<code>truncateString("A-", 1)</code> deve retornar "A ...".'
|
||||
testString: 'assert(truncateString("A-", 1) === "A...", "<code>truncateString("A-", 1)</code> should return "A...".");'
|
||||
- text: '<code>truncateString("Absolutely Longer", 2)</code> deve retornar "Ab ...".'
|
||||
testString: 'assert(truncateString("Absolutely Longer", 2) === "Ab...", "<code>truncateString("Absolutely Longer", 2)</code> should return "Ab...".");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function truncateString(str, num) {
|
||||
// Clear out that junk in your trunk
|
||||
return str;
|
||||
}
|
||||
|
||||
truncateString("A-tisket a-tasket A green and yellow basket", 8);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,86 @@
|
||||
---
|
||||
id: a24c1a4622e3c05097f71d67
|
||||
title: Where do I Belong
|
||||
isRequired: true
|
||||
challengeType: 5
|
||||
videoUrl: ''
|
||||
localeTitle: Onde eu pertenço
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Retorna o índice mais baixo no qual um valor (segundo argumento) deve ser inserido em uma matriz (primeiro argumento) depois de ter sido classificado. O valor retornado deve ser um número. Por exemplo, <code>getIndexToIns([1,2,3,4], 1.5)</code> deve retornar <code>1</code> porque é maior que <code>1</code> (índice 0), mas menor que <code>2</code> (índice 1). Da mesma forma, <code>getIndexToIns([20,3,5], 19)</code> deve retornar <code>2</code> porque, uma vez que a matriz foi classificada, ela será semelhante a <code>[3,5,20]</code> e <code>19</code> será menor que <code>20</code> (índice 2) e maior que <code>5</code> ( índice 1). Lembre-se de usar <a href="http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514" target="_blank">Read-Search-Ask</a> se você ficar preso. Escreva seu próprio código. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: '<code>getIndexToIns([10, 20, 30, 40, 50], 35)</code> deve retornar <code>3</code> .'
|
||||
testString: 'assert(getIndexToIns([10, 20, 30, 40, 50], 35) === 3, "<code>getIndexToIns([10, 20, 30, 40, 50], 35)</code> should return <code>3</code>.");'
|
||||
- text: '<code>getIndexToIns([10, 20, 30, 40, 50], 35)</code> deve retornar um número.'
|
||||
testString: 'assert(typeof(getIndexToIns([10, 20, 30, 40, 50], 35)) === "number", "<code>getIndexToIns([10, 20, 30, 40, 50], 35)</code> should return a number.");'
|
||||
- text: '<code>getIndexToIns([10, 20, 30, 40, 50], 30)</code> deve retornar <code>2</code> .'
|
||||
testString: 'assert(getIndexToIns([10, 20, 30, 40, 50], 30) === 2, "<code>getIndexToIns([10, 20, 30, 40, 50], 30)</code> should return <code>2</code>.");'
|
||||
- text: '<code>getIndexToIns([10, 20, 30, 40, 50], 30)</code> deve retornar um número.'
|
||||
testString: 'assert(typeof(getIndexToIns([10, 20, 30, 40, 50], 30)) === "number", "<code>getIndexToIns([10, 20, 30, 40, 50], 30)</code> should return a number.");'
|
||||
- text: '<code>getIndexToIns([40, 60], 50)</code> deve retornar <code>1</code> .'
|
||||
testString: 'assert(getIndexToIns([40, 60], 50) === 1, "<code>getIndexToIns([40, 60], 50)</code> should return <code>1</code>.");'
|
||||
- text: '<code>getIndexToIns([40, 60], 50)</code> deve retornar um número.'
|
||||
testString: 'assert(typeof(getIndexToIns([40, 60], 50)) === "number", "<code>getIndexToIns([40, 60], 50)</code> should return a number.");'
|
||||
- text: '<code>getIndexToIns([3, 10, 5], 3)</code> deve retornar <code>0</code> .'
|
||||
testString: 'assert(getIndexToIns([3, 10, 5], 3) === 0, "<code>getIndexToIns([3, 10, 5], 3)</code> should return <code>0</code>.");'
|
||||
- text: '<code>getIndexToIns([3, 10, 5], 3)</code> deve retornar um número.'
|
||||
testString: 'assert(typeof(getIndexToIns([3, 10, 5], 3)) === "number", "<code>getIndexToIns([3, 10, 5], 3)</code> should return a number.");'
|
||||
- text: '<code>getIndexToIns([5, 3, 20, 3], 5)</code> deve retornar <code>2</code> .'
|
||||
testString: 'assert(getIndexToIns([5, 3, 20, 3], 5) === 2, "<code>getIndexToIns([5, 3, 20, 3], 5)</code> should return <code>2</code>.");'
|
||||
- text: '<code>getIndexToIns([5, 3, 20, 3], 5)</code> deve retornar um número.'
|
||||
testString: 'assert(typeof(getIndexToIns([5, 3, 20, 3], 5)) === "number", "<code>getIndexToIns([5, 3, 20, 3], 5)</code> should return a number.");'
|
||||
- text: '<code>getIndexToIns([2, 20, 10], 19)</code> deve retornar <code>2</code> .'
|
||||
testString: 'assert(getIndexToIns([2, 20, 10], 19) === 2, "<code>getIndexToIns([2, 20, 10], 19)</code> should return <code>2</code>.");'
|
||||
- text: '<code>getIndexToIns([2, 20, 10], 19)</code> deve retornar um número.'
|
||||
testString: 'assert(typeof(getIndexToIns([2, 20, 10], 19)) === "number", "<code>getIndexToIns([2, 20, 10], 19)</code> should return a number.");'
|
||||
- text: '<code>getIndexToIns([2, 5, 10], 15)</code> deve retornar <code>3</code> .'
|
||||
testString: 'assert(getIndexToIns([2, 5, 10], 15) === 3, "<code>getIndexToIns([2, 5, 10], 15)</code> should return <code>3</code>.");'
|
||||
- text: '<code>getIndexToIns([2, 5, 10], 15)</code> deve retornar um número.'
|
||||
testString: 'assert(typeof(getIndexToIns([2, 5, 10], 15)) === "number", "<code>getIndexToIns([2, 5, 10], 15)</code> should return a number.");'
|
||||
- text: '<code>getIndexToIns([], 1)</code> deve retornar <code>0</code> .'
|
||||
testString: 'assert(getIndexToIns([], 1) === 0, "<code>getIndexToIns([], 1)</code> should return <code>0</code>.");'
|
||||
- text: '<code>getIndexToIns([], 1)</code> deve retornar um número.'
|
||||
testString: 'assert(typeof(getIndexToIns([], 1)) === "number", "<code>getIndexToIns([], 1)</code> should return a number.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function getIndexToIns(arr, num) {
|
||||
// Find my place in this sorted array.
|
||||
return num;
|
||||
}
|
||||
|
||||
getIndexToIns([40, 60], 50);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,76 @@
|
||||
---
|
||||
id: 587d7b7d367417b2b2512b1d
|
||||
title: ' Iterate Through the Keys of an Object with a for...in Statement'
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Iterar através das chaves de um objeto com um para ... em declaração
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Às vezes, você pode precisar iterar por todas as chaves de um objeto. Isso requer uma sintaxe específica em JavaScript chamada uma instrução <dfn>for ... in</dfn> . Para o nosso objeto de <code>users</code> , isso poderia parecer com: <blockquote> para (deixar usuário nos usuários) { <br> console.log (usuário); <br> }; <br><br> // logs: <br> Alan <br> Jeff <br> Sarah <br> Ryan </blockquote> Nesta declaração, definimos um <code>user</code> variável e, como você pode ver, essa variável foi redefinida durante cada iteração para cada uma das chaves do objeto à medida que a instrução passava pelo objeto, resultando na impressão do nome de cada usuário no console. <strong>NOTA:</strong> <br> Objetos não mantêm uma ordenação para chaves armazenadas como as matrizes fazem; assim, a posição das teclas em um objeto, ou a ordem relativa em que ele aparece, é irrelevante ao referenciar ou acessar essa chave. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Nós definimos uma função, <code>countOnline</code> ; use uma instrução <dfn>for ... in</dfn> dentro dessa função para percorrer os usuários no objeto <code>users</code> e retornar o número de usuários cuja propriedade <code>online</code> está configurada como <code>true</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: O objeto <code>users</code> contém usuários <code>Jeff</code> e <code>Ryan</code> com <code>online</code> - <code>online</code> configurados como <code>true</code> e usuários <code>Alan</code> e <code>Sarah</code> com <code>online</code> - <code>online</code> configurados como <code>false</code>
|
||||
testString: 'assert(users.Alan.online === false && users.Jeff.online === true && users.Sarah.online === false && users.Ryan.online === true, "The <code>users</code> object contains users <code>Jeff</code> and <code>Ryan</code> with <code>online</code> set to <code>true</code> and users <code>Alan</code> and <code>Sarah</code> with <code>online</code> set to <code>false</code>");'
|
||||
- text: A função <code>countOnline</code> retorna o número de usuários com a propriedade <code>online</code> - <code>online</code> configurada como <code>true</code>
|
||||
testString: 'assert((function() { users.Harry = {online: true}; users.Sam = {online: true}; users.Carl = {online: true}; return countOnline(users) })() === 5, "The function <code>countOnline</code> returns the number of users with the <code>online</code> property set to <code>true</code>");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let users = {
|
||||
Alan: {
|
||||
age: 27,
|
||||
online: false
|
||||
},
|
||||
Jeff: {
|
||||
age: 32,
|
||||
online: true
|
||||
},
|
||||
Sarah: {
|
||||
age: 48,
|
||||
online: false
|
||||
},
|
||||
Ryan: {
|
||||
age: 19,
|
||||
online: true
|
||||
}
|
||||
};
|
||||
|
||||
function countOnline(obj) {
|
||||
// change code below this line
|
||||
|
||||
// change code above this line
|
||||
}
|
||||
|
||||
console.log(countOnline(users));
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,59 @@
|
||||
---
|
||||
id: 5a661e0f1068aca922b3ef17
|
||||
title: Access an Array's Contents Using Bracket Notation
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Acessar o conteúdo de uma matriz usando a notação de suporte
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> O recurso fundamental de qualquer estrutura de dados é, obviamente, a capacidade de não apenas armazenar dados, mas de recuperar esses dados no comando. Então, agora que aprendemos a criar uma matriz, vamos começar a pensar em como podemos acessar as informações dessa matriz. Quando definimos um array simples como mostrado abaixo, existem 3 itens: <blockquote> vamos ourArray = ["a", "b", "c"]; </blockquote> Em uma matriz, cada item da matriz possui um <dfn>índice</dfn> . Esse índice dobra como a posição desse item na matriz e como você faz referência a ele. No entanto, é importante notar, que as matrizes JavaScript são <dfn>zero-indexada,</dfn> o que significa que o primeiro elemento de uma matriz é, na verdade, na posição de <em><strong>ordem zero,</strong></em> não o primeiro. Para recuperar um elemento de uma matriz, podemos colocar um índice entre colchetes e anexá-lo ao final de uma matriz, ou mais comumente, a uma variável que faz referência a um objeto de matriz. Isso é conhecido como <dfn>notação de colchetes</dfn> . Por exemplo, se quisermos recuperar o <code>"a"</code> de <code>ourArray</code> e atribuí-lo a uma variável, podemos fazê-lo com o seguinte código: <blockquote> vamos ourVariable = ourArray [0]; <br> // ourVariable é igual a "a" </blockquote> Além de acessar o valor associado a um índice, você também pode <em>definir</em> um índice para um valor usando a mesma notação: <blockquote> ourArray [1] = "não mais b"; <br> // ourArray agora é igual a ["a", "not b anymore", "c"]; </blockquote> Usando a notação de colchetes, agora redefinimos o item no índice 1 de <code>"b"</code> para <code>"not b anymore"</code> . </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Para completar este desafio, defina a 2ª posição (índice <code>1</code> ) de <code>myArray</code> para o que você quiser, além de <code>"b"</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: '<code>myArray[0]</code> é igual a <code>"a"</code>'
|
||||
testString: 'assert.strictEqual(myArray[0], "a", "<code>myArray[0]</code> is equal to <code>"a"</code>");'
|
||||
- text: '<code>myArray[1]</code> não está mais definido como <code>"b"</code>'
|
||||
testString: 'assert.notStrictEqual(myArray[1], "b", "<code>myArray[1]</code> is no longer set to <code>"b"</code>");'
|
||||
- text: '<code>myArray[2]</code> é igual a <code>"c"</code>'
|
||||
testString: 'assert.strictEqual(myArray[2], "c", "<code>myArray[2]</code> is equal to <code>"c"</code>");'
|
||||
- text: '<code>myArray[3]</code> é igual a <code>"d"</code>'
|
||||
testString: 'assert.strictEqual(myArray[3], "d", "<code>myArray[3]</code> is equal to <code>"d"</code>");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let myArray = ["a", "b", "c", "d"];
|
||||
// change code below this line
|
||||
|
||||
//change code above this line
|
||||
console.log(myArray);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,73 @@
|
||||
---
|
||||
id: 587d7b7c367417b2b2512b1a
|
||||
title: Access Property Names with Bracket Notation
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Acessar nomes de propriedades com notação de suporte
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> No primeiro desafio de objeto, mencionamos o uso da notação de colchetes como uma forma de acessar valores de propriedade usando a avaliação de uma variável. Por exemplo, imagine que nosso objeto de <code>foods</code> esteja sendo usado em um programa para uma caixa registradora de supermercado. Temos alguma função que define o <code>selectedFood</code> e queremos verificar o nosso objeto de <code>foods</code> para a presença desse alimento. Isso pode parecer com: <blockquote> let selectedFood = getCurrentFood (scannedItem); <br> let inventory = foods [selectedFood]; </blockquote> Esse código avaliará o valor armazenado na variável <code>selectedFood</code> e retornará o valor dessa chave no objeto <code>foods</code> , ou <code>undefined</code> se não estiver presente. A notação de colchetes é muito útil porque às vezes as propriedades do objeto não são conhecidas antes do tempo de execução ou precisamos acessá-las de uma maneira mais dinâmica. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Nós definimos uma função, <code>checkInventory</code> , que recebe um item varrido como argumento. Retorna o valor atual da chave <code>scannedItem</code> no objeto <code>foods</code> . Você pode assumir que apenas chaves válidas serão fornecidas como um argumento para verificar <code>checkInventory</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>checkInventory</code> é uma função
|
||||
testString: 'assert.strictEqual(typeof checkInventory, "function", "<code>checkInventory</code> is a function");'
|
||||
- text: 'Os <code>foods</code> objeto devem ter apenas os seguintes pares de valores-chave: <code>apples: 25</code> , <code>oranges: 32</code> , <code>plums: 28</code> , <code>bananas: 13</code> , <code>grapes: 35</code> , <code>strawberries: 27</code>'
|
||||
testString: 'assert.deepEqual(foods, {apples: 25, oranges: 32, plums: 28, bananas: 13, grapes: 35, strawberries: 27}, "The <code>foods</code> object should have only the following key-value pairs: <code>apples: 25</code>, <code>oranges: 32</code>, <code>plums: 28</code>, <code>bananas: 13</code>, <code>grapes: 35</code>, <code>strawberries: 27</code>");'
|
||||
- text: <code>checkInventory("apples")</code> deve retornar <code>25</code>
|
||||
testString: 'assert.strictEqual(checkInventory("apples"), 25, "<code>checkInventory("apples")</code> should return <code>25</code>");'
|
||||
- text: <code>checkInventory("bananas")</code> deve retornar <code>13</code>
|
||||
testString: 'assert.strictEqual(checkInventory("bananas"), 13, "<code>checkInventory("bananas")</code> should return <code>13</code>");'
|
||||
- text: <code>checkInventory("strawberries")</code> deve retornar <code>27</code>
|
||||
testString: 'assert.strictEqual(checkInventory("strawberries"), 27, "<code>checkInventory("strawberries")</code> should return <code>27</code>");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let foods = {
|
||||
apples: 25,
|
||||
oranges: 32,
|
||||
plums: 28,
|
||||
bananas: 13,
|
||||
grapes: 35,
|
||||
strawberries: 27
|
||||
};
|
||||
// do not change code above this line
|
||||
|
||||
function checkInventory(scannedItem) {
|
||||
// change code below this line
|
||||
|
||||
}
|
||||
|
||||
// change code below this line to test different cases:
|
||||
console.log(checkInventory("apples"));
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,61 @@
|
||||
---
|
||||
id: 587d78b2367417b2b2512b0e
|
||||
title: Add Items to an Array with push() and unshift()
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Adicionar itens a uma matriz com push () e unshift ()
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> O comprimento de um array, como os tipos de dados que ele pode conter, não é fixo. Os arrays podem ser definidos com um comprimento de qualquer número de elementos, e os elementos podem ser adicionados ou removidos ao longo do tempo; em outras palavras, matrizes são <dfn>mutáveis</dfn> . Neste desafio, veremos dois métodos com os quais podemos modificar programaticamente um array: <code>Array.push()</code> e <code>Array.unshift()</code> . Ambos os métodos usam um ou mais elementos como parâmetros e adicionam esses elementos à matriz na qual o método está sendo chamado; o método <code>push()</code> adiciona elementos ao final de um array, e <code>unshift()</code> adiciona elementos ao começo. Considere o seguinte: <blockquote> deixe vinte e três = 'XXIII'; <br> let romanNumerals = ['XXI', 'XXII']; <br><br> romanNumerals.unshift ('XIX', 'XX'); <br> // agora é igual a ['XIX', 'XX', 'XXI', 'XXII'] <br><br> romanNumerals.push (vinte e três); <br> // agora é igual a ['XIX', 'XX', 'XXI', 'XXII', 'XXIII'] Note que também podemos passar variáveis, o que nos permite uma flexibilidade ainda maior em modificar dinamicamente os dados da nossa matriz. </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Nós definimos uma função, <code>mixedNumbers</code> , que estamos passando um array como argumento. Modifique a função usando <code>push()</code> e <code>unshift()</code> para adicionar <code>'I', 2, 'three'</code> ao início da matriz e <code>7, 'VIII', 9</code> até o final, para que a matriz retornada contenha representações dos números 1-9 em ordem. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: '<code>mixedNumbers(["IV", 5, "six"])</code> deve retornar agora <code>["I", 2, "three", "IV", 5, "six", 7, "VIII", 9]</code>'
|
||||
testString: 'assert.deepEqual(mixedNumbers(["IV", 5, "six"]), ["I", 2, "three", "IV", 5, "six", 7, "VIII", 9], "<code>mixedNumbers(["IV", 5, "six"])</code> should now return <code>["I", 2, "three", "IV", 5, "six", 7, "VIII", 9]</code>");'
|
||||
- text: A função <code>mixedNumbers</code> deve utilizar o método <code>push()</code>
|
||||
testString: 'assert.notStrictEqual(mixedNumbers.toString().search(/\.push\(/), -1, "The <code>mixedNumbers</code> function should utilize the <code>push()</code> method");'
|
||||
- text: A função <code>mixedNumbers</code> deve utilizar o método <code>unshift()</code>
|
||||
testString: 'assert.notStrictEqual(mixedNumbers.toString().search(/\.unshift\(/), -1, "The <code>mixedNumbers</code> function should utilize the <code>unshift()</code> method");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function mixedNumbers(arr) {
|
||||
// change code below this line
|
||||
|
||||
// change code above this line
|
||||
return arr;
|
||||
}
|
||||
|
||||
// do not change code below this line
|
||||
console.log(mixedNumbers(['IV', 5, 'six']));
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,63 @@
|
||||
---
|
||||
id: 587d78b3367417b2b2512b11
|
||||
title: Add Items Using splice()
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Adicionar itens usando splice ()
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Lembre-se no último desafio que mencionamos que <code>splice()</code> pode levar até três parâmetros? Bem, podemos ir um passo além com <code>splice()</code> - além de remover elementos, podemos usar esse terceiro parâmetro, que representa um ou mais elementos, para <em>adicioná-</em> los também. Isso pode ser incrivelmente útil para trocar rapidamente um elemento ou um conjunto de elementos por outro. Por exemplo, digamos que você esteja armazenando um esquema de cores para um conjunto de elementos DOM em uma matriz e queira alterar dinamicamente uma cor com base em alguma ação: <blockquote> function colorChange (arr, index, newColor) { <br> arr.splice (index, 1, newColor); <br> return arr; <br> } <br><br> deixe colorScheme = ['# 878787', '# a08794', '# bb7e8c', '# c9b6be', '# d1becf']; <br><br> colorScheme = colorChange (colorScheme, 2, '# 332327'); <br> // removemos '# bb7e8c' e adicionamos '# 332327' em seu lugar <br> // colorScheme agora é igual a ['# 878787', '# a08794', '# 332327', '# c9b6be', '# d1becf'] </blockquote> Essa função usa uma matriz de valores hexadecimais, um índice no qual remover um elemento e a nova cor para substituir o elemento removido. O valor de retorno é uma matriz contendo um esquema de cores recém-modificado! Embora este exemplo seja um pouco simplificado, podemos ver o valor que a <code>splice()</code> pode ter no seu potencial máximo. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Nós definimos uma função, <code>htmlColorNames</code> , que usa uma matriz de cores HTML como argumento. Modifique a função usando <code>splice()</code> para remover os dois primeiros elementos da matriz e adicione <code>'DarkSalmon'</code> e <code>'BlanchedAlmond'</code> em seus respectivos locais. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: '<code>htmlColorNames</code> deve retornar <code>["DarkSalmon", "BlanchedAlmond", "LavenderBlush", "PaleTurqoise", "FireBrick"]</code>'
|
||||
testString: 'assert.deepEqual(htmlColorNames(["DarkGoldenRod", "WhiteSmoke", "LavenderBlush", "PaleTurqoise", "FireBrick"]), ["DarkSalmon", "BlanchedAlmond", "LavenderBlush", "PaleTurqoise", "FireBrick"], "<code>htmlColorNames</code> should return <code>["DarkSalmon", "BlanchedAlmond", "LavenderBlush", "PaleTurqoise", "FireBrick"]</code>");'
|
||||
- text: A função <code>htmlColorNames</code> deve utilizar o método <code>splice()</code>
|
||||
testString: 'assert(/.splice/.test(code), "The <code>htmlColorNames</code> function should utilize the <code>splice()</code> method");'
|
||||
- text: Você não deve usar <code>shift()</code> ou <code>unshift()</code> .
|
||||
testString: 'assert(!/shift|unshift/.test(code), "You should not use <code>shift()</code> or <code>unshift()</code>.");'
|
||||
- text: Você não deve usar a notação de colchetes de matriz.
|
||||
testString: 'assert(!/\[\d\]\s*=/.test(code), "You should not use array bracket notation.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function htmlColorNames(arr) {
|
||||
// change code below this line
|
||||
|
||||
// change code above this line
|
||||
return arr;
|
||||
}
|
||||
|
||||
// do not change code below this line
|
||||
console.log(htmlColorNames(['DarkGoldenRod', 'WhiteSmoke', 'LavenderBlush', 'PaleTurqoise', 'FireBrick']));
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,67 @@
|
||||
---
|
||||
id: 587d7b7c367417b2b2512b18
|
||||
title: Add Key-Value Pairs to JavaScript Objects
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Adicionar pares de valor-chave a objetos JavaScript
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Em sua forma mais básica, os objetos são apenas coleções de <dfn>pares de valores-chave</dfn> ou, em outras palavras, partes de dados mapeados para identificadores exclusivos que chamamos de <dfn>propriedades</dfn> ou <dfn>chaves</dfn> . Vamos dar uma olhada em um exemplo muito simples: <blockquote> deixar FCC_User = { <br> nome de usuário: 'awesome_coder', <br> seguidores: 572, <br> pontos: 1741, <br> concluídosProjetos: 15 <br> }; </blockquote> O código acima define um objeto chamado <code>FCC_User</code> que possui quatro <dfn>propriedades</dfn> , cada uma <code>FCC_User</code> para um valor específico. Se quisermos saber o número de <code>followers</code> <code>FCC_User</code> tem, podemos acessar essa propriedade escrevendo: <blockquote> deixe userData = FCC_User.followers; <br> // userData é igual a 572 </blockquote> Isso é chamado de <dfn>notação de ponto</dfn> . Alternativamente, também podemos acessar a propriedade com colchetes, da seguinte forma: <blockquote> deixe userData = FCC_User ['followers'] <br> // userData é igual a 572 </blockquote> Observe que, com a <dfn>notação de colchetes</dfn> , incluímos <code>followers</code> entre aspas. Isso ocorre porque os colchetes realmente nos permitem passar uma variável para ser avaliada como um nome de propriedade (dica: tenha isso em mente para mais tarde!). Se tivéssemos passado <code>followers</code> sem as aspas, o mecanismo JavaScript teria tentado avaliá-lo como uma variável, e um <code>ReferenceError: followers is not defined</code> teria sido lançado. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Usando a mesma sintaxe, também podemos <em><strong>adicionar novos</strong></em> pares de valores-chave a objetos. Criamos um objeto de <code>foods</code> com três entradas. Adicione mais três entradas: <code>bananas</code> com um valor de <code>13</code> , <code>grapes</code> com um valor de <code>35</code> e <code>strawberries</code> com um valor de <code>27</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>foods</code> é um objeto
|
||||
testString: 'assert(typeof foods === "object", "<code>foods</code> is an object");'
|
||||
- text: O objeto <code>foods</code> tem uma chave <code>"bananas"</code> com um valor de <code>13</code>
|
||||
testString: 'assert(foods.bananas === 13, "The <code>foods</code> object has a key <code>"bananas"</code> with a value of <code>13</code>");'
|
||||
- text: O objeto <code>foods</code> tem uma chave <code>"grapes"</code> com um valor de <code>35</code>
|
||||
testString: 'assert(foods.grapes === 35, "The <code>foods</code> object has a key <code>"grapes"</code> with a value of <code>35</code>");'
|
||||
- text: O objeto de <code>foods</code> tem uma chave <code>"strawberries"</code> com um valor de <code>27</code>
|
||||
testString: 'assert(foods.strawberries === 27, "The <code>foods</code> object has a key <code>"strawberries"</code> with a value of <code>27</code>");'
|
||||
- text: Os pares de valor-chave devem ser definidos usando a notação de pontos ou colchetes
|
||||
testString: 'assert(code.search(/bananas:/) === -1 && code.search(/grapes:/) === -1 && code.search(/strawberries:/) === -1, "The key-value pairs should be set using dot or bracket notation");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let foods = {
|
||||
apples: 25,
|
||||
oranges: 32,
|
||||
plums: 28
|
||||
};
|
||||
|
||||
// change code below this line
|
||||
|
||||
// change code above this line
|
||||
|
||||
console.log(foods);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,64 @@
|
||||
---
|
||||
id: 587d7b7b367417b2b2512b14
|
||||
title: Check For The Presence of an Element With indexOf()
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Verificar a presença de um elemento com indexOf ()
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Desde matrizes pode ser alterado, ou <em>mutante,</em> a qualquer momento, não há nenhuma garantia sobre onde uma determinada peça de dados estará em uma determinada matriz, ou se esse elemento, mesmo ainda existe. Felizmente, o JavaScript nos fornece outro método integrado, <code>indexOf()</code> , que nos permite verificar rápida e facilmente a presença de um elemento em uma matriz. <code>indexOf()</code> usa um elemento como parâmetro e, quando chamado, retorna a posição, ou índice, desse elemento, ou <code>-1</code> se o elemento não existir na matriz. Por exemplo: <blockquote> deixe frutas = ['maçãs', 'pêras', 'laranjas', 'pêssegos', 'pêras']; <br><br> fruits.indexOf ('datas') // retorna -1 <br> fruits.indexOf ('laranjas') // retorna 2 <br> fruits.indexOf ('pears') // retorna 1, o primeiro índice no qual o elemento existe </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> <code>indexOf()</code> pode ser incrivelmente útil para verificar rapidamente a presença de um elemento em um array. Nós definimos uma função, <code>quickCheck</code> , que usa um array e um elemento como argumentos. Modifique a função usando <code>indexOf()</code> para que ela retorne <code>true</code> se o elemento passado existir na matriz e <code>false</code> se não existir. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: '<code>quickCheck(["squash", "onions", "shallots"], "mushrooms")</code> devem retornar <code>false</code>'
|
||||
testString: 'assert.strictEqual(quickCheck(["squash", "onions", "shallots"], "mushrooms"), false, "<code>quickCheck(["squash", "onions", "shallots"], "mushrooms")</code> should return <code>false</code>");'
|
||||
- text: '<code>quickCheck(["squash", "onions", "shallots"], "onions")</code> devem retornar <code>true</code>'
|
||||
testString: 'assert.strictEqual(quickCheck(["squash", "onions", "shallots"], "onions"), true, "<code>quickCheck(["squash", "onions", "shallots"], "onions")</code> should return <code>true</code>");'
|
||||
- text: '<code>quickCheck([3, 5, 9, 125, 45, 2], 125)</code> deve retornar <code>true</code>'
|
||||
testString: 'assert.strictEqual(quickCheck([3, 5, 9, 125, 45, 2], 125), true, "<code>quickCheck([3, 5, 9, 125, 45, 2], 125)</code> should return <code>true</code>");'
|
||||
- text: '<code>quickCheck([true, false, false], undefined)</code> deve retornar <code>false</code>'
|
||||
testString: 'assert.strictEqual(quickCheck([true, false, false], undefined), false, "<code>quickCheck([true, false, false], undefined)</code> should return <code>false</code>");'
|
||||
- text: A função <code>quickCheck</code> deve utilizar o método <code>indexOf()</code>
|
||||
testString: 'assert.notStrictEqual(quickCheck.toString().search(/\.indexOf\(/), -1, "The <code>quickCheck</code> function should utilize the <code>indexOf()</code> method");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function quickCheck(arr, elem) {
|
||||
// change code below this line
|
||||
|
||||
// change code above this line
|
||||
}
|
||||
|
||||
// change code here to test different cases:
|
||||
console.log(quickCheck(['squash', 'onions', 'shallots'], 'mushrooms'));
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,78 @@
|
||||
---
|
||||
id: 587d7b7d367417b2b2512b1c
|
||||
title: Check if an Object has a Property
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Verificar se um objeto tem uma propriedade
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Agora podemos adicionar, modificar e remover chaves de objetos. Mas e se apenas quiséssemos saber se um objeto tem uma propriedade específica? O JavaScript nos fornece duas maneiras diferentes de fazer isso. Um usa o método <code>hasOwnProperty()</code> e o outro usa a palavra-chave <code>in</code> . Se tivermos um objeto <code>users</code> com uma propriedade de <code>Alan</code> , poderemos verificar sua presença de uma das seguintes maneiras: <blockquote> users.hasOwnProperty ('Alan'); <br> 'Alan' nos usuários; <br> // ambos retornam true </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Criamos um objeto, <code>users</code> , com alguns usuários e uma função <code>isEveryoneHere</code> , à qual passamos o objeto <code>users</code> como um argumento. Termine de escrever esta função para que ela retorne <code>true</code> somente se o objeto <code>users</code> contiver todos os quatro nomes, <code>Alan</code> , <code>Jeff</code> , <code>Sarah</code> e <code>Ryan</code> , como chaves, e <code>false</code> caso contrário. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'O objeto <code>users</code> contém apenas as chaves <code>Alan</code> , <code>Jeff</code> , <code>Sarah</code> e <code>Ryan</code>'
|
||||
testString: 'assert("Alan" in users && "Jeff" in users && "Sarah" in users && "Ryan" in users && Object.keys(users).length === 4, "The <code>users</code> object only contains the keys <code>Alan</code>, <code>Jeff</code>, <code>Sarah</code>, and <code>Ryan</code>");'
|
||||
- text: 'A função <code>isEveryoneHere</code> retornará <code>true</code> se <code>Alan</code> , <code>Jeff</code> , <code>Sarah</code> e <code>Ryan</code> forem propriedades no objeto <code>users</code>'
|
||||
testString: 'assert(isEveryoneHere(users) === true, "The function <code>isEveryoneHere</code> returns <code>true</code> if <code>Alan</code>, <code>Jeff</code>, <code>Sarah</code>, and <code>Ryan</code> are properties on the <code>users</code> object");'
|
||||
- text: 'A função <code>isEveryoneHere</code> retorna <code>false</code> se <code>Alan</code> , <code>Jeff</code> , <code>Sarah</code> e <code>Ryan</code> não forem propriedades no objeto <code>users</code>'
|
||||
testString: 'assert((function() { delete users.Alan; delete users.Jeff; delete users.Sarah; delete users.Ryan; return isEveryoneHere(users) })() === false, "The function <code>isEveryoneHere</code> returns <code>false</code> if <code>Alan</code>, <code>Jeff</code>, <code>Sarah</code>, and <code>Ryan</code> are not properties on the <code>users</code> object");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let users = {
|
||||
Alan: {
|
||||
age: 27,
|
||||
online: true
|
||||
},
|
||||
Jeff: {
|
||||
age: 32,
|
||||
online: true
|
||||
},
|
||||
Sarah: {
|
||||
age: 48,
|
||||
online: true
|
||||
},
|
||||
Ryan: {
|
||||
age: 19,
|
||||
online: true
|
||||
}
|
||||
};
|
||||
|
||||
function isEveryoneHere(obj) {
|
||||
// change code below this line
|
||||
|
||||
// change code above this line
|
||||
}
|
||||
|
||||
console.log(isEveryoneHere(users));
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,58 @@
|
||||
---
|
||||
id: 587d7b7b367417b2b2512b17
|
||||
title: Combine Arrays with the Spread Operator
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Combine Arrays com o Operador de Spread
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Outra grande vantagem do operador de <dfn>propagação</dfn> é a capacidade de combinar matrizes ou de inserir todos os elementos de um array em outro, em qualquer índice. Com sintaxes mais tradicionais, podemos concatenar matrizes, mas isso só nos permite combinar matrizes no final de um, e no início de outro. A sintaxe de propagação torna a seguinte operação extremamente simples: <blockquote> deixe thisArray = ['sábio', 'alecrim', 'salsa', 'tomilho']; <br><br> deixe thatArray = ['manjericão', 'coentro', ... thisArray, 'coentro']; <br> // thatArray agora é igual a ['manjericão', 'coentro', 'sálvia', 'alecrim', 'salsa', 'tomilho', 'coentro'] </blockquote> Usando a sintaxe de propagação, acabamos de obter uma operação que teria sido mais complexa e mais detalhada se tivéssemos usado métodos tradicionais. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Definimos uma função <code>spreadOut</code> que retorna a <code>sentence</code> variável, modifica a função usando o operador <dfn>spread</dfn> para que ela retorne a matriz <code>['learning', 'to', 'code', 'is', 'fun']</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: '<code>spreadOut</code> deve retornar <code>["learning", "to", "code", "is", "fun"]</code>'
|
||||
testString: 'assert.deepEqual(spreadOut(), ["learning", "to", "code", "is", "fun"], "<code>spreadOut</code> should return <code>["learning", "to", "code", "is", "fun"]</code>");'
|
||||
- text: A função <code>spreadOut</code> deve utilizar a sintaxe de propagação
|
||||
testString: 'assert.notStrictEqual(spreadOut.toString().search(/[...]/), -1, "The <code>spreadOut</code> function should utilize spread syntax");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function spreadOut() {
|
||||
let fragment = ['to', 'code'];
|
||||
let sentence; // change this line
|
||||
return sentence;
|
||||
}
|
||||
|
||||
// do not change code below this line
|
||||
console.log(spreadOut());
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,69 @@
|
||||
---
|
||||
id: 587d7b7b367417b2b2512b13
|
||||
title: Copy an Array with the Spread Operator
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Copiar uma matriz com o operador de propagação
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Enquanto <code>slice()</code> nos permite ser seletivo sobre quais elementos de um array copiar, entre várias outras tarefas úteis, o novo <dfn>operador spread</dfn> do ES6 nos permite copiar facilmente <em>todos</em> os elementos de um array, em ordem, com uma sintaxe simples e altamente legível. A sintaxe de propagação simplesmente se parece com isso: <code>...</code> Na prática, podemos usar o operador de propagação para copiar uma matriz da seguinte forma: <blockquote> let thisArray = [verdadeiro, verdadeiro, indefinido, falso, nulo]; <br> deixe thatArray = [... thisArray]; <br> // thatArray é igual a [verdadeiro, verdadeiro, indefinido, falso, nulo] <br> // thisArray permanece inalterado e é idêntico a thatArray </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Nós definimos uma função, <code>copyMachine</code> que pega <code>arr</code> (um array) e <code>num</code> (um número) como argumentos. A função deve retornar uma nova matriz composta de um <code>num</code> cópias de <code>arr</code> . Nós fizemos a maior parte do trabalho para você, mas ainda não funciona bem. Modifique a função usando a sintaxe de propagação para que ela funcione corretamente (dica: outro método que já abordamos pode ser útil aqui!). </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: '<code>copyMachine([true, false, true], 2)</code> deve retornar <code>[[true, false, true], [true, false, true]]</code>'
|
||||
testString: 'assert.deepEqual(copyMachine([true, false, true], 2), [[true, false, true], [true, false, true]], "<code>copyMachine([true, false, true], 2)</code> should return <code>[[true, false, true], [true, false, true]]</code>");'
|
||||
- text: '<code>copyMachine([1, 2, 3], 5)</code> deve retornar <code>[[1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3]]</code>'
|
||||
testString: 'assert.deepEqual(copyMachine([1, 2, 3], 5), [[1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3]], "<code>copyMachine([1, 2, 3], 5)</code> should return <code>[[1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3]]</code>");'
|
||||
- text: '<code>copyMachine([true, true, null], 1)</code> deve retornar <code>[[true, true, null]]</code>'
|
||||
testString: 'assert.deepEqual(copyMachine([true, true, null], 1), [[true, true, null]], "<code>copyMachine([true, true, null], 1)</code> should return <code>[[true, true, null]]</code>");'
|
||||
- text: '<code>copyMachine(["it works"], 3)</code> deve retornar <code>[["it works"], ["it works"], ["it works"]]</code>'
|
||||
testString: 'assert.deepEqual(copyMachine(["it works"], 3), [["it works"], ["it works"], ["it works"]], "<code>copyMachine(["it works"], 3)</code> should return <code>[["it works"], ["it works"], ["it works"]]</code>");'
|
||||
- text: A função <code>copyMachine</code> deve utilizar o <code>spread operator</code> com array <code>arr</code>
|
||||
testString: 'assert.notStrictEqual(copyMachine.toString().indexOf(".concat(_toConsumableArray(arr))"), -1, "The <code>copyMachine</code> function should utilize the <code>spread operator</code> with array <code>arr</code>");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function copyMachine(arr, num) {
|
||||
let newArr = [];
|
||||
while (num >= 1) {
|
||||
// change code below this line
|
||||
|
||||
// change code above this line
|
||||
num--;
|
||||
}
|
||||
return newArr;
|
||||
}
|
||||
|
||||
// change code here to test different cases:
|
||||
console.log(copyMachine([true, false, true], 2));
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,58 @@
|
||||
---
|
||||
id: 587d7b7a367417b2b2512b12
|
||||
title: Copy Array Items Using slice()
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Copiar itens de matriz usando slice ()
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> O próximo método que abordaremos é <code>slice()</code> . <code>slice()</code> , em vez de modificar uma matriz, copia ou <em>extrai</em> um determinado número de elementos para uma nova matriz, deixando a matriz em que é chamada intocada. <code>slice()</code> usa apenas dois parâmetros - o primeiro é o índice no qual iniciar a extração e o segundo é o índice no qual interromper a extração (a extração ocorrerá até, mas não incluindo o elemento nesse índice). Considere isto: <blockquote> let weatherConditions = ['chuva', 'neve', 'granizo', 'granizo', 'claro']; <br><br> deixe todaysWeather = weatherConditions.slice (1, 3); <br> // todaysWeather é igual a ['snow', 'sleet']; <br> // weatherConditions ainda é igual a ['rain', 'snow', 'sleet', 'hail', 'clear'] <br></blockquote> Na verdade, criamos uma nova matriz extraindo elementos de uma matriz existente. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Definimos uma função, <code>forecast</code> , que usa um array como argumento. Modifique a função usando <code>slice()</code> para extrair informações da matriz de argumentos e retornar uma nova matriz que contenha os elementos <code>'warm'</code> e <code>'sunny'</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: '<code>forecast</code> deve retornar <code>["warm", "sunny"]</code>'
|
||||
testString: 'assert.deepEqual(forecast(["cold", "rainy", "warm", "sunny", "cool", "thunderstorms"]), ["warm", "sunny"], "<code>forecast</code> should return <code>["warm", "sunny"]");'
|
||||
- text: A função de <code>forecast</code> deve utilizar o método <code>slice()</code>
|
||||
testString: 'assert(/\.slice\(/.test(code), "The <code>forecast</code> function should utilize the <code>slice()</code> method");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function forecast(arr) {
|
||||
// change code below this line
|
||||
|
||||
return arr;
|
||||
}
|
||||
|
||||
// do not change code below this line
|
||||
console.log(forecast(['cold', 'rainy', 'warm', 'sunny', 'cool', 'thunderstorms']));
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,65 @@
|
||||
---
|
||||
id: 587d7b7b367417b2b2512b16
|
||||
title: Create complex multi-dimensional arrays
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Crie matrizes multidimensionais complexas
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Impressionante! Você acabou de aprender uma tonelada sobre arrays! Esta foi uma visão geral de alto nível, e há muito mais a aprender sobre como trabalhar com matrizes, muitas das quais você verá em seções posteriores. Mas antes de pensar em <dfn>objetos</dfn> , vamos dar mais uma olhada e ver como as matrizes podem se tornar um pouco mais complexas do que as que vimos nos desafios anteriores. Uma das características mais poderosas quando se pensa em matrizes como estruturas de dados, é que as matrizes podem conter, ou mesmo serem completamente compostas por outras matrizes. Vimos matrizes que contêm matrizes em desafios anteriores, mas que são bem simples. No entanto, os arrays podem conter uma profundidade infinita de arrays que podem conter outros arrays, cada um com seus próprios níveis arbitrários de profundidade, e assim por diante. Dessa forma, um array pode se tornar muito rapidamente uma estrutura de dados muito complexa, conhecida como array <dfn>multidimensional</dfn> ou aninhado. Considere o seguinte exemplo: <blockquote> vamos nestedArray = [// top, ou primeiro nível - o array mais externo <br> ['deep'], // uma matriz dentro de uma matriz, 2 níveis de profundidade <br> [ <br> ['deep'], ['deep'] // 2 arrays aninhados 3 níveis de profundidade <br> ] <br> [ <br> [ <br> ['deepest'], ['deepest'] // 2 arrays aninhados em 4 níveis de profundidade <br> ] <br> [ <br> [ <br> ['deepest-est?'] // uma matriz aninhada a 5 níveis de profundidade <br> ] <br> ] <br> ] <br> ]; </blockquote> Embora esse exemplo possa parecer complicado, esse nível de complexidade não é inédito, ou mesmo incomum, ao lidar com grandes quantidades de dados. No entanto, ainda podemos acessar com facilidade os níveis mais profundos de um array neste complexo com a notação de colchetes: <blockquote> console.log (nestedArray [2] [1] [0] [0] [0]); <br> // logs: deepest? </blockquote> E agora que sabemos onde estão esses dados, podemos redefini-los se precisarmos: <blockquote> nestedArray [2] [1] [0] [0] [0] = 'ainda mais profundo'; <br><br> console.log (nestedArray [2] [1] [0] [0] [0]); <br> // agora registra: mais fundo ainda </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Nós definimos uma variável, <code>myNestedArray</code> , definida como igual a um array. Modifique <code>myNestedArray</code> , usando qualquer combinação de <dfn>strings</dfn> , <dfn>números</dfn> e <dfn>booleanos</dfn> para elementos de dados, de modo que tenha exatamente cinco níveis de profundidade (lembre-se, a matriz mais externa é nível 1). Em algum lugar no terceiro nível, incluir a string <code>'deep'</code> , no quarto nível, incluir a string <code>'deeper'</code> , e no quinto nível, incluir a string <code>'deepest'</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: '<code>myNestedArray</code> deve conter apenas números, booleanos e cadeias de caracteres como elementos de dados'
|
||||
testString: 'assert.strictEqual((function(arr) { let flattened = (function flatten(arr) { const flat = [].concat(...arr); return flat.some (Array.isArray) ? flatten(flat) : flat; })(arr); for (let i = 0; i < flattened.length; i++) { if ( typeof flattened[i] !== "number" && typeof flattened[i] !== "string" && typeof flattened[i] !== "boolean") { return false } } return true })(myNestedArray), true, "<code>myNestedArray</code> should contain only numbers, booleans, and strings as data elements");'
|
||||
- text: <code>myNestedArray</code> deve ter exatamente 5 níveis de profundidade
|
||||
testString: 'assert.strictEqual((function(arr) {let depth = 0;function arrayDepth(array, i, d) { if (Array.isArray(array[i])) { arrayDepth(array[i], 0, d + 1);} else { depth = (d > depth) ? d : depth;}if (i < array.length) { arrayDepth(array, i + 1, d);} }arrayDepth(arr, 0, 0);return depth;})(myNestedArray), 4, "<code>myNestedArray</code> should have exactly 5 levels of depth");'
|
||||
- text: <code>myNestedArray</code> deve conter exatamente uma ocorrência da string <code>"deep"</code> em uma matriz aninhada em 3 níveis de profundidade
|
||||
testString: 'assert((function howDeep(array, target, depth = 0) {return array.reduce((combined, current) => {if (Array.isArray(current)) { return combined.concat(howDeep(current, target, depth + 1));} else if (current === target) { return combined.concat(depth);} else { return combined;}}, []);})(myNestedArray, "deep").length === 1 && (function howDeep(array, target, depth = 0) {return array.reduce((combined, current) => {if (Array.isArray(current)) { return combined.concat(howDeep(current, target, depth + 1));} else if (current === target) { return combined.concat(depth);} else { return combined;}}, []);})(myNestedArray, "deep")[0] === 2, "<code>myNestedArray</code> should contain exactly one occurrence of the string <code>"deep"</code> on an array nested 3 levels deep");'
|
||||
- text: <code>myNestedArray</code> deve conter exatamente uma ocorrência da string <code>"deeper"</code> em uma matriz aninhada em 4 níveis de profundidade
|
||||
testString: 'assert((function howDeep(array, target, depth = 0) {return array.reduce((combined, current) => {if (Array.isArray(current)) { return combined.concat(howDeep(current, target, depth + 1));} else if (current === target) { return combined.concat(depth);} else { return combined;}}, []);})(myNestedArray, "deeper").length === 1 && (function howDeep(array, target, depth = 0) {return array.reduce((combined, current) => {if (Array.isArray(current)) { return combined.concat(howDeep(current, target, depth + 1));} else if (current === target) { return combined.concat(depth);} else { return combined;}}, []);})(myNestedArray, "deeper")[0] === 3, "<code>myNestedArray</code> should contain exactly one occurrence of the string <code>"deeper"</code> on an array nested 4 levels deep");'
|
||||
- text: <code>myNestedArray</code> deve conter exatamente uma ocorrência da string <code>"deepest"</code> em uma matriz aninhada em 5 níveis de profundidade
|
||||
testString: 'assert((function howDeep(array, target, depth = 0) {return array.reduce((combined, current) => {if (Array.isArray(current)) { return combined.concat(howDeep(current, target, depth + 1));} else if (current === target) { return combined.concat(depth);} else { return combined;}}, []);})(myNestedArray, "deepest").length === 1 && (function howDeep(array, target, depth = 0) {return array.reduce((combined, current) => {if (Array.isArray(current)) { return combined.concat(howDeep(current, target, depth + 1));} else if (current === target) { return combined.concat(depth);} else { return combined;}}, []);})(myNestedArray, "deepest")[0] === 4, "<code>myNestedArray</code> should contain exactly one occurrence of the string <code>"deepest"</code> on an array nested 5 levels deep");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let myNestedArray = [
|
||||
// change code below this line
|
||||
['unshift', false, 1, 2, 3, 'complex', 'nested'],
|
||||
['loop', 'shift', 6, 7, 1000, 'method'],
|
||||
['concat', false, true, 'spread', 'array'],
|
||||
['mutate', 1327.98, 'splice', 'slice', 'push'],
|
||||
['iterate', 1.3849, 7, '8.4876', 'arbitrary', 'depth']
|
||||
// change code above this line
|
||||
];
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,76 @@
|
||||
---
|
||||
id: 587d7b7d367417b2b2512b1e
|
||||
title: Generate an Array of All Object Keys with Object.keys()
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Gerar uma matriz de todas as chaves de objeto com Object.keys ()
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Também podemos gerar um array que contém todas as chaves armazenadas em um objeto usando o método <code>Object.keys()</code> e passando um objeto como argumento. Isso retornará uma matriz com strings representando cada propriedade no objeto. Novamente, não haverá uma ordem específica para as entradas na matriz. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Termine de gravar a função <code>getArrayOfUsers</code> para que ela retorne uma matriz contendo todas as propriedades no objeto que ela recebe como argumento. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'O objeto <code>users</code> contém apenas as chaves <code>Alan</code> , <code>Jeff</code> , <code>Sarah</code> e <code>Ryan</code>'
|
||||
testString: 'assert("Alan" in users && "Jeff" in users && "Sarah" in users && "Ryan" in users && Object.keys(users).length === 4, "The <code>users</code> object only contains the keys <code>Alan</code>, <code>Jeff</code>, <code>Sarah</code>, and <code>Ryan</code>");'
|
||||
- text: A função <code>getArrayOfUsers</code> retorna uma matriz que contém todas as chaves no objeto <code>users</code>
|
||||
testString: 'assert((function() { users.Sam = {}; users.Lewis = {}; let R = getArrayOfUsers(users); return (R.indexOf("Alan") !== -1 && R.indexOf("Jeff") !== -1 && R.indexOf("Sarah") !== -1 && R.indexOf("Ryan") !== -1 && R.indexOf("Sam") !== -1 && R.indexOf("Lewis") !== -1); })() === true, "The <code>getArrayOfUsers</code> function returns an array which contains all the keys in the <code>users</code> object");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let users = {
|
||||
Alan: {
|
||||
age: 27,
|
||||
online: false
|
||||
},
|
||||
Jeff: {
|
||||
age: 32,
|
||||
online: true
|
||||
},
|
||||
Sarah: {
|
||||
age: 48,
|
||||
online: false
|
||||
},
|
||||
Ryan: {
|
||||
age: 19,
|
||||
online: true
|
||||
}
|
||||
};
|
||||
|
||||
function getArrayOfUsers(obj) {
|
||||
// change code below this line
|
||||
|
||||
// change code above this line
|
||||
}
|
||||
|
||||
console.log(getArrayOfUsers(users));
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,66 @@
|
||||
---
|
||||
id: 587d7b7b367417b2b2512b15
|
||||
title: Iterate Through All an Array's Items Using For Loops
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Iterar Através de Todos os Itens de uma Matriz Usando For Loops
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Às vezes, ao trabalhar com arrays, é muito útil poder percorrer cada item para encontrar um ou mais elementos que possamos precisar ou manipular um array com base nos itens de dados que atendem a um determinado conjunto de critérios. O JavaScript oferece vários métodos integrados que cada iterar sobre matrizes de maneiras ligeiramente diferentes para alcançar resultados diferentes (como <code>every()</code> , <code>forEach()</code> , <code>map()</code> , etc.), no entanto, a técnica que é mais flexível e nos oferece o maior quantidade de controlo é um método simples <code>for</code> circuito. Considere o seguinte: <blockquote> function greaterThanTen (arr) { <br> deixe newArr = []; <br> para (let i = 0; i <arr.length; i ++) { <br> if (arr [i]> 10) { <br> newArr.push (arr [i]); <br> } <br> } <br> return newArr; <br> } <br><br> maiorThanTen ([2, 12, 8, 14, 80, 0, 1]); <br> // retorna [12, 14, 80] </blockquote> Usando um loop <code>for</code> , essa função percorre e acessa cada elemento da matriz e a submete a um teste simples que criamos. Dessa maneira, determinamos de maneira fácil e programática quais itens de dados são maiores que <code>10</code> e retornamos um novo array contendo esses itens. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Nós definimos uma função, <code>filteredArray</code> , que recebe <code>arr</code> , um array aninhado e <code>elem</code> como argumentos, e retorna um novo array. <code>elem</code> representa um elemento que pode ou não estar presente em um ou mais dos arrays aninhados dentro de <code>arr</code> . Modificar a função, utilizando um <code>for</code> de loop, para retornar uma versão filtrada da matriz passou de tal modo que qualquer disposição aninhada dentro <code>arr</code> contendo <code>elem</code> foi removido. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: '<code>filteredArray([[10, 8, 3], [14, 6, 23], [3, 18, 6]], 18)</code> deve retornar <code>[ [10, 8, 3], [14, 6, 23] ]</code>'
|
||||
testString: 'assert.deepEqual(filteredArray([ [10, 8, 3], [14, 6, 23], [3, 18, 6] ], 18), [[10, 8, 3], [14, 6, 23]], "<code>filteredArray([[10, 8, 3], [14, 6, 23], [3, 18, 6]], 18)</code> should return <code>[ [10, 8, 3], [14, 6, 23] ]</code>");'
|
||||
- text: '<code>filteredArray([ ["trumpets", 2], ["flutes", 4], ["saxophones", 2] ], 2)</code> deve retornar <code>[ ["flutes", 4] ]</code>'
|
||||
testString: 'assert.deepEqual(filteredArray([ ["trumpets", 2], ["flutes", 4], ["saxophones", 2] ], 2), [["flutes", 4]], "<code>filteredArray([ ["trumpets", 2], ["flutes", 4], ["saxophones", 2] ], 2)</code> should return <code>[ ["flutes", 4] ]</code>");'
|
||||
- text: '<code>filteredArray([ ["amy", "beth", "sam"], ["dave", "sean", "peter"] ], "peter")</code> deve retornar <code>[ ["amy", "beth", "sam"] ]</code>'
|
||||
testString: 'assert.deepEqual(filteredArray([["amy", "beth", "sam"], ["dave", "sean", "peter"]], "peter"), [["amy", "beth", "sam"]], "<code>filteredArray([ ["amy", "beth", "sam"], ["dave", "sean", "peter"] ], "peter")</code> should return <code>[ ["amy", "beth", "sam"] ]</code>");'
|
||||
- text: '<code>filteredArray([[3, 2, 3], [1, 6, 3], [3, 13, 26], [19, 3, 9]], 3)</code> deve retornar <code>[ ]</code>'
|
||||
testString: 'assert.deepEqual(filteredArray([[3, 2, 3], [1, 6, 3], [3, 13, 26], [19, 3, 9]], 3), [], "<code>filteredArray([[3, 2, 3], [1, 6, 3], [3, 13, 26], [19, 3, 9]], 3)</code> should return <code>[ ]</code>");'
|
||||
- text: A função <code>filteredArray</code> deve utilizar um loop <code>for</code>
|
||||
testString: 'assert.notStrictEqual(filteredArray.toString().search(/for/), -1, "The <code>filteredArray</code> function should utilize a <code>for</code> loop");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function filteredArray(arr, elem) {
|
||||
let newArr = [];
|
||||
// change code below this line
|
||||
|
||||
// change code above this line
|
||||
return newArr;
|
||||
}
|
||||
|
||||
// change code here to test different cases:
|
||||
console.log(filteredArray([[3, 2, 3], [1, 6, 3], [3, 13, 26], [19, 3, 9]], 3));
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,79 @@
|
||||
---
|
||||
id: 587d7b7d367417b2b2512b1f
|
||||
title: Modify an Array Stored in an Object
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Modificar uma matriz armazenada em um objeto
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Agora você viu todas as operações básicas para objetos JavaScript. Você pode adicionar, modificar e remover pares de valores-chave, verificar se existem chaves e iterar sobre todas as chaves em um objeto. À medida que você continua aprendendo JavaScript, você verá aplicativos ainda mais versáteis de objetos. Além disso, as lições opcionais de estruturas de dados avançadas, mais adiante no currículo, também abrangem os objetos ES6 <dfn>Map</dfn> e <dfn>Set</dfn> , que são semelhantes aos objetos comuns, mas fornecem alguns recursos adicionais. Agora que você aprendeu as noções básicas de arrays e objetos, você está totalmente preparado para começar a lidar com problemas mais complexos usando JavaScript! </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Dê uma olhada no objeto que fornecemos no editor de código. O objeto de <code>user</code> contém três chaves. A chave de <code>data</code> contém cinco chaves, uma das quais contém uma matriz de <code>friends</code> . A partir disso, você pode ver como os objetos são flexíveis como estruturas de dados. Nós começamos a escrever uma função <code>addFriend</code> . Termine de escrevê-lo para que ele use um objeto de <code>user</code> e adicione o nome do argumento de <code>friend</code> à matriz armazenada em <code>user.data.friends</code> e retorne essa matriz. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'O objeto de <code>user</code> tem <code>name</code> , <code>age</code> e chaves de <code>data</code>'
|
||||
testString: 'assert("name" in user && "age" in user && "data" in user, "The <code>user</code> object has <code>name</code>, <code>age</code>, and <code>data</code> keys");'
|
||||
- text: A função <code>addFriend</code> aceita um objeto de <code>user</code> e uma string de <code>friend</code> como argumentos e adiciona o amigo à matriz de <code>friends</code> no objeto de <code>user</code>
|
||||
testString: 'assert((function() { let L1 = user.data.friends.length; addFriend(user, "Sean"); let L2 = user.data.friends.length; return (L2 === L1 + 1); })(), "The <code>addFriend</code> function accepts a <code>user</code> object and a <code>friend</code> string as arguments and adds the friend to the array of <code>friends</code> in the <code>user</code> object");'
|
||||
- text: '<code>addFriend(user, "Pete")</code> deve retornar <code>["Sam", "Kira", "Tomo", "Pete"]</code>'
|
||||
testString: 'assert.deepEqual((function() { delete user.data.friends; user.data.friends = ["Sam", "Kira", "Tomo"]; return addFriend(user, "Pete") })(), ["Sam", "Kira", "Tomo", "Pete"], "<code>addFriend(user, "Pete")</code> should return <code>["Sam", "Kira", "Tomo", "Pete"]</code>");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let user = {
|
||||
name: 'Kenneth',
|
||||
age: 28,
|
||||
data: {
|
||||
username: 'kennethCodesAllDay',
|
||||
joinDate: 'March 26, 2016',
|
||||
organization: 'freeCodeCamp',
|
||||
friends: [
|
||||
'Sam',
|
||||
'Kira',
|
||||
'Tomo'
|
||||
],
|
||||
location: {
|
||||
city: 'San Francisco',
|
||||
state: 'CA',
|
||||
country: 'USA'
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
function addFriend(userObj, friend) {
|
||||
// change code below this line
|
||||
|
||||
// change code above this line
|
||||
}
|
||||
|
||||
console.log(addFriend(user, 'Pete'));
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,68 @@
|
||||
---
|
||||
id: 587d7b7c367417b2b2512b19
|
||||
title: Modify an Object Nested Within an Object
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Modificar um objeto aninhado em um objeto
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Agora vamos dar uma olhada em um objeto um pouco mais complexo. As propriedades do objeto podem ser aninhadas em uma profundidade arbitrária e seus valores podem ser qualquer tipo de dados suportados pelo JavaScript, incluindo matrizes e até mesmo outros objetos. Considere o seguinte: <blockquote> deixe nestedObject = { <br> id: 28802695164, <br> data: '31 de dezembro de 2016', <br> data: { <br> total de usuários: 99, <br> online: 80, <br> Status online: { <br> ativo: 67, <br> de distância: 13 <br> } <br> } <br> }; </blockquote> <code>nestedObject</code> tem três chaves exclusivas: <code>id</code> , cujo valor é um número, <code>date</code> cujo valor é uma string e <code>data</code> , cujo valor é um objeto que possui outro objeto aninhado dentro dele. Embora as estruturas possam se tornar rapidamente complexas, ainda podemos usar as mesmas notações para acessar as informações de que precisamos. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Aqui nós definimos um objeto, <code>userActivity</code> , que inclui outro objeto aninhado dentro dele. Você pode modificar as propriedades nesse objeto aninhado da mesma maneira que modificou as propriedades no último desafio. Defina o valor da chave <code>online</code> para <code>45</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: '<code>userActivity</code> tem <code>id</code> , <code>date</code> e propriedades de <code>data</code>'
|
||||
testString: 'assert("id" in userActivity && "date" in userActivity && "data" in userActivity, "<code>userActivity</code> has <code>id</code>, <code>date</code> and <code>data</code> properties");'
|
||||
- text: <code>userActivity</code> tem um conjunto de chaves de <code>data</code> para um objeto com chaves <code>totalUsers</code> e <code>online</code> - <code>online</code>
|
||||
testString: 'assert("totalUsers" in userActivity.data && "online" in userActivity.data, "<code>userActivity</code> has a <code>data</code> key set to an object with keys <code>totalUsers</code> and <code>online</code>");'
|
||||
- text: A propriedade <code>online</code> aninhada na chave de <code>data</code> de <code>userActivity</code> deve ser definida como <code>45</code>
|
||||
testString: 'assert(userActivity.data.online === 45, "The <code>online</code> property nested in the <code>data</code> key of <code>userActivity</code> should be set to <code>45</code>");'
|
||||
- text: A propriedade <code>online</code> é definida usando a notação de pontos ou colchetes
|
||||
testString: 'assert.strictEqual(code.search(/online: 45/), -1, "The <code>online</code> property is set using dot or bracket notation");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let userActivity = {
|
||||
id: 23894201352,
|
||||
date: 'January 1, 2017',
|
||||
data: {
|
||||
totalUsers: 51,
|
||||
online: 42
|
||||
}
|
||||
};
|
||||
|
||||
// change code below this line
|
||||
|
||||
// change code above this line
|
||||
|
||||
console.log(userActivity);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,60 @@
|
||||
---
|
||||
id: 587d78b2367417b2b2512b0f
|
||||
title: Remove Items from an Array with pop() and shift()
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Remover itens de uma matriz com pop () e shift ()
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Tanto <code>push()</code> quanto <code>unshift()</code> possuem métodos correspondentes que são quase opostos funcionais: <code>pop()</code> e <code>shift()</code> . Como você deve ter adivinhado agora, em vez de adicionar, <code>pop()</code> <em>remove</em> um elemento do final de um array, enquanto <code>shift()</code> remove um elemento do começo. A principal diferença entre <code>pop()</code> e <code>shift()</code> e seus primos <code>push()</code> e <code>unshift()</code> , é que nenhum método recebe parâmetros, e cada um só permite que um array seja modificado por um único elemento por vez. Vamos dar uma olhada: <blockquote> deixe saudações = ['o que está acontecendo?', 'olá', 'até mais!']; <br><br> greetings.pop (); <br> // agora é igual a ['whats up?', 'olá'] <br><br> greetings.shift (); <br> // agora é igual a ['olá'] </blockquote> Nós também podemos retornar o valor do elemento removido com um dos métodos como este: <blockquote> deixe popped = greetings.pop (); <br> // retorna 'olá' <br> // saudações agora é igual a [] </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
undefined
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: '<code>popShift(["challenge", "is", "not", "complete"])</code> deve retornar <code>["challenge", "complete"]</code>'
|
||||
testString: 'assert.deepEqual(popShift(["challenge", "is", "not", "complete"]), ["challenge", "complete"], "<code>popShift(["challenge", "is", "not", "complete"])</code> should return <code>["challenge", "complete"]</code>");'
|
||||
- text: A função <code>popShift</code> deve utilizar o método <code>pop()</code>
|
||||
testString: 'assert.notStrictEqual(popShift.toString().search(/\.pop\(/), -1, "The <code>popShift</code> function should utilize the <code>pop()</code> method");'
|
||||
- text: A função <code>popShift</code> deve utilizar o método <code>shift()</code>
|
||||
testString: 'assert.notStrictEqual(popShift.toString().search(/\.shift\(/), -1, "The <code>popShift</code> function should utilize the <code>shift()</code> method");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function popShift(arr) {
|
||||
let popped; // change this line
|
||||
let shifted; // change this line
|
||||
return [shifted, popped];
|
||||
}
|
||||
|
||||
// do not change code below this line
|
||||
console.log(popShift(['challenge', 'is', 'not', 'complete']));
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,59 @@
|
||||
---
|
||||
id: 587d78b2367417b2b2512b10
|
||||
title: Remove Items Using splice()
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Remover itens usando splice ()
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Ok, aprendemos como remover elementos do início e do fim de arrays usando <code>shift()</code> e <code>pop()</code> , mas e se quisermos remover um elemento de algum lugar no meio? Ou remover mais de um elemento de uma só vez? Bem, é aí que <code>splice()</code> entra. <code>splice()</code> nos permite fazer exatamente isso: <strong>remover qualquer número de elementos consecutivos</strong> de qualquer lugar em um array. <code>splice()</code> pode levar até 3 parâmetros, mas por enquanto, vamos nos concentrar apenas no primeiro 2. Os dois primeiros parâmetros de <code>splice()</code> são inteiros que representam índices, ou posições, do array que <code>splice()</code> está sendo chamado a. E lembre-se, as matrizes são <em>indexadas com zero</em> , portanto, para indicar o primeiro elemento de uma matriz, usaríamos <code>0</code> . O primeiro parâmetro do <code>splice()</code> representa o índice no array do qual começar a remover elementos, enquanto o segundo parâmetro indica o número de elementos a serem deletados. Por exemplo: <blockquote> vamos array = ['hoje', 'foi', 'não', 'so', 'ótimo']; <br><br> array.splice (2, 2); <br> // remove 2 elementos começando com o terceiro elemento <br> // array agora é igual a ['today', 'was', 'great'] </blockquote> <code>splice()</code> não apenas modifica o array que está sendo chamado, mas também retorna um novo array contendo o valor dos elementos removidos: <blockquote> deixe array = ['eu', 'sou', 'sentindo', 'realmente', 'feliz']; <br><br> deixe newArray = array.splice (3, 2); <br> // newArray é igual a ['really', 'happy'] </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Nós definimos uma função, <code>sumOfTen</code> , que usa um array como argumento e retorna a soma dos elementos do array. Modifique a função, usando <code>splice()</code> , para que ela retorne um valor de <code>10</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>sumOfTen</code> deve retornar 10
|
||||
testString: 'assert.strictEqual(sumOfTen([2, 5, 1, 5, 2, 1]), 10, "<code>sumOfTen</code> should return 10");'
|
||||
- text: A função <code>sumOfTen</code> deve utilizar o método <code>splice()</code>
|
||||
testString: 'assert.notStrictEqual(sumOfTen.toString().search(/\.splice\(/), -1, "The <code>sumOfTen</code> function should utilize the <code>splice()</code> method");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function sumOfTen(arr) {
|
||||
// change code below this line
|
||||
|
||||
// change code above this line
|
||||
return arr.reduce((a, b) => a + b);
|
||||
}
|
||||
|
||||
// do not change code below this line
|
||||
console.log(sumOfTen([2, 5, 1, 5, 2, 1]));
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,57 @@
|
||||
---
|
||||
id: 587d7b7e367417b2b2512b20
|
||||
title: Use an Array to Store a Collection of Data
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Use uma matriz para armazenar uma coleção de dados
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> O abaixo é um exemplo da implementação mais simples de uma estrutura de dados de matriz. Isso é conhecido como um <dfn>array unidimensional</dfn> , o que significa que ele tem apenas um nível, ou que não possui outros arrays aninhados nele. Observe que contém <dfn>booleanos</dfn> , <dfn>cadeias de caracteres</dfn> e <dfn>números</dfn> , entre outros tipos de dados JavaScript válidos: <blockquote> let simpleArray = ['um', 2, 'três', verdadeiro, falso, indefinido, nulo]; <br> console.log (simpleArray.length); <br> // logs 7 </blockquote> Todas as matrizes têm uma propriedade length, que, como mostrado acima, pode ser facilmente acessada com a sintaxe <code>Array.length</code> . Uma implementação mais complexa de um array pode ser vista abaixo. Isso é conhecido como uma <dfn>matriz multidimensional</dfn> ou uma matriz que contém outras matrizes. Observe que essa matriz também contém <dfn>objetos</dfn> JavaScript, que examinaremos de perto na próxima seção, mas, por enquanto, tudo o que você precisa saber é que as matrizes também são capazes de armazenar objetos complexos. <blockquote> deixe complexArray = [ <br> [ <br> { <br> Um 1, <br> dois: 2 <br> } <br> { <br> três: 3 <br> quatro: 4 <br> } <br> ] <br> [ <br> { <br> a: "a", <br> b: "b" <br> } <br> { <br> c: "c", <br> d: "d" <br> } <br> ] <br> ]; </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Nós definimos uma variável chamada <code>yourArray</code> . Complete a instrução atribuindo uma matriz de pelo menos 5 elementos de comprimento à variável <code>yourArray</code> . Sua matriz deve conter pelo menos uma <dfn>string</dfn> , um <dfn>número</dfn> e um <dfn>booleano</dfn> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: yourArray é um array
|
||||
testString: 'assert.strictEqual(Array.isArray(yourArray), true, "yourArray is an array");'
|
||||
- text: <code>yourArray</code> tem pelo menos 5 elementos
|
||||
testString: 'assert.isAtLeast(yourArray.length, 5, "<code>yourArray</code> is at least 5 elements long");'
|
||||
- text: <code>yourArray</code> contém pelo menos um <code>boolean</code>
|
||||
testString: 'assert(yourArray.filter( el => typeof el === "boolean").length >= 1, "<code>yourArray</code> contains at least one <code>boolean</code>");'
|
||||
- text: <code>yourArray</code> contém pelo menos um <code>number</code>
|
||||
testString: 'assert(yourArray.filter( el => typeof el === "number").length >= 1, "<code>yourArray</code> contains at least one <code>number</code>");'
|
||||
- text: <code>yourArray</code> contém pelo menos uma <code>string</code>
|
||||
testString: 'assert(yourArray.filter( el => typeof el === "string").length >= 1, "<code>yourArray</code> contains at least one <code>string</code>");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let yourArray; // change this line
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,64 @@
|
||||
---
|
||||
id: 587d7b7c367417b2b2512b1b
|
||||
title: Use the delete Keyword to Remove Object Properties
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Use a palavra-chave delete para remover propriedades do objeto
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Agora você sabe quais são os objetos e seus recursos e vantagens básicos. Em resumo, eles são armazenamentos de valor-chave que fornecem uma maneira flexível e intuitiva de estruturar dados <strong><em>e</em></strong> fornecem um tempo de pesquisa muito rápido. Durante o restante desses desafios, descreveremos várias operações comuns que você pode executar em objetos, para que você possa se sentir confortável ao aplicar essas estruturas de dados úteis em seus programas. Nos desafios anteriores, adicionamos e modificamos os pares de valores-chave de um objeto. Aqui, veremos como podemos <em>remover</em> um par de valores-chave de um objeto. Vamos revisitar nosso exemplo de objeto de <code>foods</code> uma última vez. Se quiséssemos remover a chave <code>apples</code> , poderíamos removê-la usando a palavra-chave <code>delete</code> seguinte forma: <blockquote> delete foods.apples; </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Use a palavra-chave delete para remover as chaves <code>oranges</code> , <code>plums</code> e <code>strawberries</code> do objeto <code>foods</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'Os <code>foods</code> objeto só tem três chaves: <code>apples</code> , <code>grapes</code> e <code>bananas</code>'
|
||||
testString: 'assert(!foods.hasOwnProperty("oranges") && !foods.hasOwnProperty("plums") && !foods.hasOwnProperty("strawberries") && Object.keys(foods).length === 3, "The <code>foods</code> object only has three keys: <code>apples</code>, <code>grapes</code>, and <code>bananas</code>");'
|
||||
- text: 'As chaves <code>oranges</code> , <code>plums</code> e <code>strawberries</code> são removidas usando a <code>delete</code>'
|
||||
testString: 'assert(code.search(/oranges:/) !== -1 && code.search(/plums:/) !== -1 && code.search(/strawberries:/) !== -1, "The <code>oranges</code>, <code>plums</code>, and <code>strawberries</code> keys are removed using <code>delete</code>");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
let foods = {
|
||||
apples: 25,
|
||||
oranges: 32,
|
||||
plums: 28,
|
||||
bananas: 13,
|
||||
grapes: 35,
|
||||
strawberries: 27
|
||||
};
|
||||
|
||||
// change code below this line
|
||||
|
||||
// change code above this line
|
||||
|
||||
console.log(foods);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,67 @@
|
||||
---
|
||||
id: 56bbb991ad1ed5201cd392ca
|
||||
title: Access Array Data with Indexes
|
||||
challengeType: 1
|
||||
guideUrl: 'https://portuguese.freecodecamp.org/guide/certificates/access-array-data-with-indexes'
|
||||
videoUrl: ''
|
||||
localeTitle: Dados de Matriz de Acesso com Índices
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Podemos acessar os dados dentro de matrizes usando <code>indexes</code> . Os índices de matriz são escritos na mesma notação de colchetes usada pelas cadeias, exceto que, em vez de especificar um caractere, eles estão especificando uma entrada na matriz. Como as strings, as matrizes usam indexação <dfn>baseada em zero</dfn> , portanto, o primeiro elemento em uma matriz é o elemento <code>0</code> . <strong>Exemplo</strong> <blockquote> var array = [50,60,70]; <br> array [0]; // é igual a 50 <br> var data = array [1]; // é igual a 60 </blockquote> <strong>Nota</strong> <br> Não deve haver espaços entre o nome da matriz e os colchetes, como <code>array [0]</code> . Embora JavaScript seja capaz de processar isso corretamente, isso pode confundir outros programadores lendo seu código. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Crie uma variável chamada <code>myData</code> e configure-a para igualar o primeiro valor de <code>myArray</code> usando a notação de colchetes. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: A variável <code>myData</code> deve ser igual ao primeiro valor de <code>myArray</code> .
|
||||
testString: 'assert((function(){if(typeof myArray !== "undefined" && typeof myData !== "undefined" && myArray[0] === myData){return true;}else{return false;}})(), "The variable <code>myData</code> should equal the first value of <code>myArray</code>.");'
|
||||
- text: Os dados na variável <code>myArray</code> devem ser acessados usando a notação de colchetes.
|
||||
testString: 'assert((function(){if(code.match(/\s*=\s*myArray\[0\]/g)){return true;}else{return false;}})(), "The data in variable <code>myArray</code> should be accessed using bracket notation.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
// Example
|
||||
var ourArray = [50,60,70];
|
||||
var ourData = ourArray[0]; // equals 50
|
||||
|
||||
// Setup
|
||||
var myArray = [50,60,70];
|
||||
|
||||
// Only change code below this line.
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,64 @@
|
||||
---
|
||||
id: 56592a60ddddeae28f7aa8e1
|
||||
title: Access Multi-Dimensional Arrays With Indexes
|
||||
challengeType: 1
|
||||
guideUrl: 'https://portuguese.freecodecamp.org/guide/certificates/access-array-data-with-indexes'
|
||||
videoUrl: ''
|
||||
localeTitle: Acessar matrizes multi-dimensionais com índices
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Uma maneira de pensar em uma matriz <dfn>multidimensional</dfn> é como uma <em>matriz de matrizes</em> . Quando você usa colchetes para acessar sua matriz, o primeiro conjunto de colchetes refere-se às entradas na matriz mais externa (o primeiro nível) e cada par adicional de colchetes refere-se ao próximo nível de entradas internas. <strong>Exemplo</strong> <blockquote> var arr = [ <br> [1,2,3], <br> [4,5,6], <br> [7,8,9], <br> [[10,11,12], 13, 14] <br> ]; <br> arr [3]; // é igual a [[10,11,12], 13, 14] <br> arr [3] [0]; // é igual a [10,11,12] <br> arr [3] [0] [1]; // é igual a 11 </blockquote> <strong>Nota</strong> <br> Não deve haver espaços entre o nome da matriz e os colchetes, como <code>array [0][0]</code> e até mesmo esta <code>array [0] [0]</code> não é permitida. Embora JavaScript seja capaz de processar isso corretamente, isso pode confundir outros programadores lendo seu código. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Usando a notação de colchetes, selecione um elemento em <code>myArray</code> , de forma que <code>myData</code> seja igual a <code>8</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>myData</code> deve ser igual a <code>8</code> .
|
||||
testString: 'assert(myData === 8, "<code>myData</code> should be equal to <code>8</code>.");'
|
||||
- text: Você deve estar usando a notação de colchetes para ler o valor correto de <code>myArray</code> .
|
||||
testString: 'assert(/myArray\[2\]\[1\]/g.test(code) && !/myData\s*=\s*(?:.*[-+*/%]|\d)/g.test(code), "You should be using bracket notation to read the correct value from <code>myArray</code>.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
// Setup
|
||||
var myArray = [[1,2,3], [4,5,6], [7,8,9], [[10,11,12], 13, 14]];
|
||||
|
||||
// Only change code below this line.
|
||||
var myData = myArray[0][0];
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,82 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244cd
|
||||
title: Accessing Nested Arrays
|
||||
challengeType: 1
|
||||
guideUrl: 'https://portuguese.freecodecamp.org/guide/certificates/access-array-data-with-indexes'
|
||||
videoUrl: ''
|
||||
localeTitle: Acessando matrizes aninhadas
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Como vimos nos exemplos anteriores, os objetos podem conter tanto objetos aninhados quanto matrizes aninhadas. Semelhante ao acesso a objetos aninhados, a notação de colchetes da Array pode ser encadeada para acessar matrizes aninhadas. Aqui está um exemplo de como acessar uma matriz aninhada: <blockquote> var ourPets = [ <br> { <br> animalTipo: "gato", <br> nomes: [ <br> "Meowzer", <br> "Fofo", <br> "Kit-Cat" <br> ] <br> } <br> { <br> animalTipo: "cachorro", <br> nomes: [ <br> "Local", <br> "Bowser", <br> "Frankie" <br> ] <br> } <br> ]; <br> ourPets [0] .nomes [1]; // "Fofo" <br> ourPets [1] .nomes [0]; // "Local" </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Recuperar a segunda árvore da variável <code>myPlants</code> usando ponto de objeto e notação de colchetes de matriz. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>secondTree</code> deve ser igual a "pine"
|
||||
testString: 'assert(secondTree === "pine", "<code>secondTree</code> should equal "pine"");'
|
||||
- text: Use a notação de pontos e colchetes para acessar <code>myPlants</code>
|
||||
testString: 'assert(/=\s*myPlants\[1\].list\[1\]/.test(code), "Use dot and bracket notation to access <code>myPlants</code>");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
// Setup
|
||||
var myPlants = [
|
||||
{
|
||||
type: "flowers",
|
||||
list: [
|
||||
"rose",
|
||||
"tulip",
|
||||
"dandelion"
|
||||
]
|
||||
},
|
||||
{
|
||||
type: "trees",
|
||||
list: [
|
||||
"fir",
|
||||
"pine",
|
||||
"birch"
|
||||
]
|
||||
}
|
||||
];
|
||||
|
||||
// Only change code below this line
|
||||
|
||||
var secondTree = ""; // Change this line
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,73 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244cc
|
||||
title: Accessing Nested Objects
|
||||
challengeType: 1
|
||||
guideUrl: 'https://portuguese.freecodecamp.org/guide/certificates/accessing-nested-objects-in-json'
|
||||
videoUrl: ''
|
||||
localeTitle: Acessando Objetos Aninhados
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> As subpropriedades dos objetos podem ser acessadas encadeando a notação de pontos ou colchetes. Aqui está um objeto aninhado: <blockquote> var ourStorage = { <br> "escrivaninha": { <br> "gaveta": "grampeador" <br> } <br> "gabinete": { <br> "gaveta superior": { <br> "folder1": "um arquivo", <br> "folder2": "segredos" <br> } <br> "gaveta de fundo": "refrigerante" <br> } <br> }; <br> ourStorage.cabinet ["gaveta de cima"]. folder2; // "segredos" <br> ourStorage.desk.drawer; // "agrafador" </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Acesse o objeto <code>myStorage</code> e atribua o conteúdo da propriedade <code>glove box</code> à variável <code>gloveBoxContents</code> . Use a notação de colchetes para propriedades com um espaço em seus nomes. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>gloveBoxContents</code> deve ser igual a "mapas"
|
||||
testString: 'assert(gloveBoxContents === "maps", "<code>gloveBoxContents</code> should equal "maps"");'
|
||||
- text: Use a notação de pontos e colchetes para acessar <code>myStorage</code>
|
||||
testString: 'assert(/=\s*myStorage\.car\.inside\[\s*("|")glove box\1\s*\]/g.test(code), "Use dot and bracket notation to access <code>myStorage</code>");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
// Setup
|
||||
var myStorage = {
|
||||
"car": {
|
||||
"inside": {
|
||||
"glove box": "maps",
|
||||
"passenger seat": "crumbs"
|
||||
},
|
||||
"outside": {
|
||||
"trunk": "jack"
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
var gloveBoxContents = undefined; // Change this line
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,76 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244c8
|
||||
title: Accessing Object Properties with Bracket Notation
|
||||
challengeType: 1
|
||||
guideUrl: 'https://portuguese.freecodecamp.org/guide/certificates/accessing-objects-properties-with-bracket-notation'
|
||||
videoUrl: ''
|
||||
localeTitle: Acessando propriedades de objeto com notação de suporte
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> A segunda maneira de acessar as propriedades de um objeto é a notação de colchetes ( <code>[]</code> ). Se a propriedade do objeto que você está tentando acessar tiver um espaço em seu nome, você precisará usar a notação de colchetes. No entanto, você ainda pode usar a notação de colchetes nas propriedades do objeto sem espaços. Aqui está uma amostra de uso da notação de colchetes para ler a propriedade de um objeto: <blockquote> var myObj = { <br> "Space Name": "Kirk", <br> "Mais espaço": "Spock", <br> "NoSpace": "USS Enterprise" <br> }; <br> myObj ["nome do espaço"]; // Kirk <br> myObj ['More Space']; // Spock <br> myObj ["NoSpace"]; // USS Enterprise </blockquote> Observe que os nomes de propriedade com espaços neles devem estar entre aspas (simples ou dupla). </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Leia os valores das propriedades <code>"an entree"</code> e <code>"the drink"</code> de <code>testObj</code> usando a notação de colchetes e atribua-os a <code>entreeValue</code> e <code>drinkValue</code> respectivamente. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>entreeValue</code> deve ser uma string
|
||||
testString: 'assert(typeof entreeValue === "string" , "<code>entreeValue</code> should be a string");'
|
||||
- text: O valor de <code>entreeValue</code> deve ser <code>"hamburger"</code>
|
||||
testString: 'assert(entreeValue === "hamburger" , "The value of <code>entreeValue</code> should be <code>"hamburger"</code>");'
|
||||
- text: <code>drinkValue</code> deve ser uma string
|
||||
testString: 'assert(typeof drinkValue === "string" , "<code>drinkValue</code> should be a string");'
|
||||
- text: O valor de <code>drinkValue</code> deve ser <code>"water"</code>
|
||||
testString: 'assert(drinkValue === "water" , "The value of <code>drinkValue</code> should be <code>"water"</code>");'
|
||||
- text: Você deve usar a notação de colchete duas vezes
|
||||
testString: 'assert(code.match(/testObj\s*?\[("|")[^""]+\1\]/g).length > 1, "You should use bracket notation twice");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
// Setup
|
||||
var testObj = {
|
||||
"an entree": "hamburger",
|
||||
"my side": "veggies",
|
||||
"the drink": "water"
|
||||
};
|
||||
|
||||
// Only change code below this line
|
||||
|
||||
var entreeValue = testObj; // Change this line
|
||||
var drinkValue = testObj; // Change this line
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,75 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244c7
|
||||
title: Accessing Object Properties with Dot Notation
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Acessando propriedades de objeto com notação de ponto
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Há duas maneiras de acessar as propriedades de um objeto: notação de ponto ( <code>.</code> ) E notação de colchetes ( <code>[]</code> ), semelhante a uma matriz. A notação de pontos é o que você usa quando sabe o nome da propriedade que está tentando acessar antecipadamente. Aqui está uma amostra de uso de notação de ponto ( <code>.</code> ) Para ler a propriedade de um objeto: <blockquote> var myObj = { <br> prop1: "val1", <br> prop2: "val2" <br> }; <br> var prop1val = myObj.prop1; // val1 <br> var prop2val = myObj.prop2; // val2 </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Leia os valores de propriedade de <code>testObj</code> usando a notação de ponto. Defina a variável <code>hatValue</code> igual ao <code>hat</code> propriedade do objeto e defina a variável <code>shirtValue</code> igual à <code>shirt</code> propriedade do objeto. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>hatValue</code> deve ser uma string
|
||||
testString: 'assert(typeof hatValue === "string" , "<code>hatValue</code> should be a string");'
|
||||
- text: O valor de <code>hatValue</code> deve ser <code>"ballcap"</code>
|
||||
testString: 'assert(hatValue === "ballcap" , "The value of <code>hatValue</code> should be <code>"ballcap"</code>");'
|
||||
- text: <code>shirtValue</code> deve ser uma string
|
||||
testString: 'assert(typeof shirtValue === "string" , "<code>shirtValue</code> should be a string");'
|
||||
- text: O valor de <code>shirtValue</code> deve ser <code>"jersey"</code>
|
||||
testString: 'assert(shirtValue === "jersey" , "The value of <code>shirtValue</code> should be <code>"jersey"</code>");'
|
||||
- text: Você deve usar a notação de ponto duas vezes
|
||||
testString: 'assert(code.match(/testObj\.\w+/g).length > 1, "You should use dot notation twice");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
// Setup
|
||||
var testObj = {
|
||||
"hat": "ballcap",
|
||||
"shirt": "jersey",
|
||||
"shoes": "cleats"
|
||||
};
|
||||
|
||||
// Only change code below this line
|
||||
|
||||
var hatValue = testObj; // Change this line
|
||||
var shirtValue = testObj; // Change this line
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,78 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244c9
|
||||
title: Accessing Object Properties with Variables
|
||||
challengeType: 1
|
||||
guideUrl: 'https://portuguese.freecodecamp.org/guide/certificates/accessing-objects-properties-with-variables'
|
||||
videoUrl: ''
|
||||
localeTitle: Acessando propriedades de objetos com variáveis
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Outro uso da notação de colchetes em objetos é acessar uma propriedade que é armazenada como o valor de uma variável. Isso pode ser muito útil para iterar pelas propriedades de um objeto ou ao acessar uma tabela de pesquisa. Aqui está um exemplo de uso de uma variável para acessar uma propriedade: <blockquote> var dogs = { <br> Fido: "Mutt", Hunter: "Doberman", Snoopie: "Beagle" <br> }; <br> var myDog = "Caçador"; <br> var myBreed = cachorros [myDog]; <br> console.log (myBreed); // "Doberman" </blockquote> Outra maneira de usar esse conceito é quando o nome da propriedade é coletado dinamicamente durante a execução do programa, da seguinte maneira: <blockquote> var someObj = { <br> propName: "John" <br> }; <br> function propPrefix (str) { <br> var s = "prop"; <br> return s + str; <br> } <br> var someProp = propPrefix ("Nome"); // someProp agora contém o valor 'propName' <br> console.log (someObj [someProp]); // "John" </blockquote> Observe que <em>não</em> usamos aspas ao redor do nome da variável ao usá-lo para acessar a propriedade porque estamos usando o <em>valor</em> da variável, não o <em>nome</em> . </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Use a variável <code>playerNumber</code> para procurar o player <code>16</code> em <code>testObj</code> usando a notação de colchetes. Em seguida, atribua esse nome à variável do <code>player</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>playerNumber</code> deve ser um número
|
||||
testString: 'assert(typeof playerNumber === "number", "<code>playerNumber</code> should be a number");'
|
||||
- text: O <code>player</code> variável deve ser uma string
|
||||
testString: 'assert(typeof player === "string", "The variable <code>player</code> should be a string");'
|
||||
- text: O valor do <code>player</code> deve ser "Montana"
|
||||
testString: 'assert(player === "Montana", "The value of <code>player</code> should be "Montana"");'
|
||||
- text: Você deve usar a notação de colchetes para acessar o <code>testObj</code>
|
||||
testString: 'assert(/testObj\s*?\[.*?\]/.test(code),"You should use bracket notation to access <code>testObj</code>");'
|
||||
- text: Você não deve atribuir o valor <code>Montana</code> ao <code>player</code> variável diretamente.
|
||||
testString: 'assert(!code.match(/player\s*=\s*"|\"\s*Montana\s*"|\"\s*;/gi),"You should not assign the value <code>Montana</code> to the variable <code>player</code> directly.");'
|
||||
- text: Você deve estar usando a variável <code>playerNumber</code> na sua notação de colchetes
|
||||
testString: 'assert(/testObj\s*?\[\s*playerNumber\s*\]/.test(code),"You should be using the variable <code>playerNumber</code> in your bracket notation");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
// Setup
|
||||
var testObj = {
|
||||
12: "Namath",
|
||||
16: "Montana",
|
||||
19: "Unitas"
|
||||
};
|
||||
|
||||
// Only change code below this line;
|
||||
|
||||
var playerNumber; // Change this Line
|
||||
var player = testObj; // Change this Line
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,77 @@
|
||||
---
|
||||
id: 56bbb991ad1ed5201cd392d2
|
||||
title: Add New Properties to a JavaScript Object
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Adicionar novas propriedades a um objeto JavaScript
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Você pode adicionar novas propriedades a objetos JavaScript existentes da mesma maneira que você os modificaria. Veja como adicionaríamos uma propriedade <code>"bark"</code> ao <code>ourDog</code> : <code>ourDog.bark = "bow-wow";</code> ou <code>ourDog["bark"] = "bow-wow";</code> Agora, quando avaliarmos o nosso <code>ourDog.bark</code> , vamos pegar o latido dele, "bow-wow". </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Adicione uma propriedade <code>"bark"</code> ao <code>myDog</code> e configure-a para um som de cachorro, como "woof". Você pode usar a notação de pontos ou colchetes. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Adicione a propriedade <code>"bark"</code> ao <code>myDog</code> .
|
||||
testString: 'assert(myDog.bark !== undefined, "Add the property <code>"bark"</code> to <code>myDog</code>.");'
|
||||
- text: Não adicione <code>"bark"</code> à seção de configuração
|
||||
testString: 'assert(!/bark[^\n]:/.test(code), "Do not add <code>"bark"</code> to the setup section");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
// Example
|
||||
var ourDog = {
|
||||
"name": "Camper",
|
||||
"legs": 4,
|
||||
"tails": 1,
|
||||
"friends": ["everything!"]
|
||||
};
|
||||
|
||||
ourDog.bark = "bow-wow";
|
||||
|
||||
// Setup
|
||||
var myDog = {
|
||||
"name": "Happy Coder",
|
||||
"legs": 4,
|
||||
"tails": 1,
|
||||
"friends": ["freeCodeCamp Campers"]
|
||||
};
|
||||
|
||||
// Only change code below this line.
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,59 @@
|
||||
---
|
||||
id: cf1111c1c11feddfaeb3bdef
|
||||
title: Add Two Numbers with JavaScript
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Adicione dois números com JavaScript
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> <code>Number</code> é um tipo de dados em JavaScript que representa dados numéricos. Agora vamos tentar adicionar dois números usando JavaScript. O JavaScript usa o símbolo <code>+</code> como operação de adição quando colocado entre dois números. <strong>Exemplo</strong> <blockquote> myVar = 5 + 10; // atribuído 15 </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Altere <code>0</code> para que a soma seja igual a <code>20</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>sum</code> deve ser igual a <code>20</code>
|
||||
testString: 'assert(sum === 20, "<code>sum</code> should equal <code>20</code>");'
|
||||
- text: Use o operador <code>+</code>
|
||||
testString: 'assert(/\+/.test(code), "Use the <code>+</code> operator");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
var sum = 10 + 0;
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,75 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244de
|
||||
title: Adding a Default Option in Switch Statements
|
||||
challengeType: 1
|
||||
guideUrl: 'https://portuguese.freecodecamp.org/guide/certificates/adding-a-default-option-in-switch-statements'
|
||||
videoUrl: ''
|
||||
localeTitle: Adicionando uma opção padrão em instruções de troca
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Em uma instrução <code>switch</code> , você pode não conseguir especificar todos os valores possíveis como instruções <code>case</code> . Em vez disso, você pode adicionar a instrução <code>default</code> que será executada se nenhuma instrução <code>case</code> correspondente for encontrada. Pense nisso como a final <code>else</code> declaração em um <code>if/else</code> cadeia. Uma declaração <code>default</code> deve ser o último caso. <blockquote> switch (num) { <br> valor do caso1: <br> statement1; <br> pausa; <br> valor do caso2: <br> statement2; <br> pausa; <br> ... <br> padrão: <br> defaultStatement; <br> pausa; <br> } </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Escreva uma instrução switch para definir a <code>answer</code> para as seguintes condições: <br> <code>"a"</code> - "maçã" <br> <code>"b"</code> - "pássaro" <br> <code>"c"</code> - "gato" <br> <code>default</code> - "stuff" </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>switchOfStuff("a")</code> deve ter um valor de "apple"
|
||||
testString: 'assert(switchOfStuff("a") === "apple", "<code>switchOfStuff("a")</code> should have a value of "apple"");'
|
||||
- text: <code>switchOfStuff("b")</code> deve ter um valor de "bird"
|
||||
testString: 'assert(switchOfStuff("b") === "bird", "<code>switchOfStuff("b")</code> should have a value of "bird"");'
|
||||
- text: <code>switchOfStuff("c")</code> deve ter um valor de "cat"
|
||||
testString: 'assert(switchOfStuff("c") === "cat", "<code>switchOfStuff("c")</code> should have a value of "cat"");'
|
||||
- text: <code>switchOfStuff("d")</code> deve ter um valor de "stuff"
|
||||
testString: 'assert(switchOfStuff("d") === "stuff", "<code>switchOfStuff("d")</code> should have a value of "stuff"");'
|
||||
- text: <code>switchOfStuff(4)</code> deve ter um valor de "stuff"
|
||||
testString: 'assert(switchOfStuff(4) === "stuff", "<code>switchOfStuff(4)</code> should have a value of "stuff"");'
|
||||
- text: Você não deve usar nenhuma instrução <code>if</code> ou <code>else</code>
|
||||
testString: 'assert(!/else/g.test(code) || !/if/g.test(code), "You should not use any <code>if</code> or <code>else</code> statements");'
|
||||
- text: Você deve usar uma declaração <code>default</code>
|
||||
testString: 'assert(switchOfStuff("string-to-trigger-default-case") === "stuff", "You should use a <code>default</code> statement");'
|
||||
- text: Você deve ter pelo menos 3 declarações de <code>break</code>
|
||||
testString: 'assert(code.match(/break/g).length > 2, "You should have at least 3 <code>break</code> statements");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function switchOfStuff(val) {
|
||||
var answer = "";
|
||||
// Only change code below this line
|
||||
|
||||
|
||||
|
||||
// Only change code above this line
|
||||
return answer;
|
||||
}
|
||||
|
||||
// Change this value to test
|
||||
switchOfStuff(1);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,68 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244ed
|
||||
title: Appending Variables to Strings
|
||||
challengeType: 1
|
||||
guideUrl: 'https://portuguese.freecodecamp.org/guide/certificates/appending-variables-to-strings'
|
||||
videoUrl: ''
|
||||
localeTitle: Anexando variáveis a seqüências de caracteres
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Assim como podemos construir uma string sobre várias linhas a partir de <dfn>literais</dfn> de string, também podemos anexar variáveis a uma string usando o operador mais igual ( <code>+=</code> ). </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Defina <code>someAdjective</code> e anexe-o ao <code>myStr</code> usando o operador <code>+=</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>someAdjective</code> deve ser definido para uma string com pelo menos 3 caracteres
|
||||
testString: 'assert(typeof someAdjective !== "undefined" && someAdjective.length > 2, "<code>someAdjective</code> should be set to a string at least 3 characters long");'
|
||||
- text: Anexar <code>someAdjective</code> ao <code>myStr</code> usando o operador <code>+=</code>
|
||||
testString: 'assert(code.match(/myStr\s*\+=\s*someAdjective\s*/).length > 0, "Append <code>someAdjective</code> to <code>myStr</code> using the <code>+=</code> operator");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
// Example
|
||||
var anAdjective = "awesome!";
|
||||
var ourStr = "freeCodeCamp is ";
|
||||
ourStr += anAdjective;
|
||||
|
||||
// Only change code below this line
|
||||
|
||||
var someAdjective;
|
||||
var myStr = "Learning to code is ";
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,76 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244c3
|
||||
title: Assignment with a Returned Value
|
||||
challengeType: 1
|
||||
guideUrl: 'https://portuguese.freecodecamp.org/guide/certificates/assignment-with-a-returned-value'
|
||||
videoUrl: ''
|
||||
localeTitle: Atribuição com um valor retornado
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Se você se lembrar de nossa discussão sobre <a href="javascript-algorithms-and-data-structures/basic-javascript/storing-values-with-the-assignment-operator" target="_blank">Armazenando Valores com o Operador de Atribuição</a> , tudo à direita do sinal de igual será resolvido antes de o valor ser atribuído. Isso significa que podemos pegar o valor de retorno de uma função e atribuí-la a uma variável. Suponha que tenhamos pré-definido uma <code>sum</code> funções que adiciona dois números juntos, então: <code>ourSum = sum(5, 12);</code> chamará a função <code>sum</code> , que retorna um valor de <code>17</code> e atribui à variável <code>ourSum</code> . </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Chame a função <code>processArg</code> com um argumento de <code>7</code> e atribua seu valor de retorno à variável <code>processed</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>processed</code> deve ter um valor de <code>2</code>
|
||||
testString: 'assert(processed === 2, "<code>processed</code> should have a value of <code>2</code>");'
|
||||
- text: Você deve atribuir <code>processArg</code> a <code>processed</code>
|
||||
testString: 'assert(/processed\s*=\s*processArg\(\s*7\s*\)\s*;/.test(code), "You should assign <code>processArg</code> to <code>processed</code>");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
// Example
|
||||
var changed = 0;
|
||||
|
||||
function change(num) {
|
||||
return (num + 5) / 3;
|
||||
}
|
||||
|
||||
changed = change(10);
|
||||
|
||||
// Setup
|
||||
var processed = 0;
|
||||
|
||||
function processArg(num) {
|
||||
return (num + 3) / 5;
|
||||
}
|
||||
|
||||
// Only change code below this line
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,80 @@
|
||||
---
|
||||
id: 56bbb991ad1ed5201cd392d0
|
||||
title: Build JavaScript Objects
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Construa objetos JavaScript
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Você pode ter ouvido o termo <code>object</code> antes. Os objetos são semelhantes aos <code>arrays</code> , exceto que, em vez de usar índices para acessar e modificar seus dados, você acessa os dados em objetos por meio do que são chamados de <code>properties</code> . Os objetos são úteis para armazenar dados de maneira estruturada e podem representar objetos do mundo real, como um gato. Aqui está um objeto cat de amostra: <blockquote> var cat = { <br> "nome": "Bigodes", <br> "pernas": 4, <br> "coroa": 1, <br> "inimigos": ["Água", "Cães"] <br> }; </blockquote> Neste exemplo, todas as propriedades são armazenadas como strings, como - <code>"name"</code> , <code>"legs"</code> e <code>"tails"</code> . No entanto, você também pode usar números como propriedades. Você pode até mesmo omitir as aspas para propriedades de string de palavra única, da seguinte maneira: <blockquote> var anotherObject = { <br> make: "Ford", <br> 5: "cinco", <br> "modelo": "foco" <br> }; </blockquote> No entanto, se o seu objeto tiver alguma propriedade que não seja de string, o JavaScript será automaticamente convertido em typecast como string. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Crie um objeto que represente um cão chamado <code>myDog</code> que contenha as propriedades <code>"name"</code> (uma string), <code>"legs"</code> , <code>"tails"</code> e <code>"friends"</code> . Você pode definir essas propriedades de objeto para quaisquer valores desejados, desde que <code>"name"</code> seja uma cadeia, <code>"legs"</code> e <code>"tails"</code> sejam números e <code>"friends"</code> seja uma matriz. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>myDog</code> deve conter o <code>name</code> da propriedade e deve ser uma <code>string</code> .
|
||||
testString: 'assert((function(z){if(z.hasOwnProperty("name") && z.name !== undefined && typeof z.name === "string"){return true;}else{return false;}})(myDog), "<code>myDog</code> should contain the property <code>name</code> and it should be a <code>string</code>.");'
|
||||
- text: <code>myDog</code> deve conter as <code>legs</code> da propriedade e deve ser um <code>number</code> .
|
||||
testString: 'assert((function(z){if(z.hasOwnProperty("legs") && z.legs !== undefined && typeof z.legs === "number"){return true;}else{return false;}})(myDog), "<code>myDog</code> should contain the property <code>legs</code> and it should be a <code>number</code>.");'
|
||||
- text: <code>myDog</code> deve conter as <code>tails</code> da propriedade e deve ser um <code>number</code> .
|
||||
testString: 'assert((function(z){if(z.hasOwnProperty("tails") && z.tails !== undefined && typeof z.tails === "number"){return true;}else{return false;}})(myDog), "<code>myDog</code> should contain the property <code>tails</code> and it should be a <code>number</code>.");'
|
||||
- text: <code>myDog</code> deve conter os <code>friends</code> da propriedade e deve ser um <code>array</code> .
|
||||
testString: 'assert((function(z){if(z.hasOwnProperty("friends") && z.friends !== undefined && Array.isArray(z.friends)){return true;}else{return false;}})(myDog), "<code>myDog</code> should contain the property <code>friends</code> and it should be an <code>array</code>.");'
|
||||
- text: <code>myDog</code> deve conter apenas todas as propriedades dadas.
|
||||
testString: 'assert((function(z){return Object.keys(z).length === 4;})(myDog), "<code>myDog</code> should only contain all the given properties.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
// Example
|
||||
var ourDog = {
|
||||
"name": "Camper",
|
||||
"legs": 4,
|
||||
"tails": 1,
|
||||
"friends": ["everything!"]
|
||||
};
|
||||
|
||||
// Only change code below this line.
|
||||
|
||||
var myDog = {
|
||||
|
||||
|
||||
|
||||
|
||||
};
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,82 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244dc
|
||||
title: Chaining If Else Statements
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Encadeamento Se Mais Declarações
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> <code>if/else</code> instruções podem ser encadeadas para lógica complexa. Aqui está o <dfn>pseudocódigo</dfn> de várias instruções encadeadas <code>if</code> / <code>else if</code> : <blockquote> if ( <em>condição1</em> ) { <br> <em>statement1</em> <br> } else if ( <em>condição2</em> ) { <br> <em>statement2</em> <br> } else if ( <em>condição3</em> ) { <br> <em>statement3</em> <br> . . . <br> } outro { <br> <em>statementN</em> <br> } </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Escreva encadeado <code>if</code> / <code>else if</code> instruções preencherem as seguintes condições: <code>num < 5</code> - return "Tiny" <br> <code>num < 10</code> - retorna "Pequeno" <br> <code>num < 15</code> - return "Medium" <br> <code>num < 20</code> - retorna "Grande" <br> <code>num >= 20</code> - retornar "Enorme" </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Você deve ter pelo menos quatro <code>else</code> declarações
|
||||
testString: 'assert(code.match(/else/g).length > 3, "You should have at least four <code>else</code> statements");'
|
||||
- text: Você deve ter pelo menos quatro declarações <code>if</code>
|
||||
testString: 'assert(code.match(/if/g).length > 3, "You should have at least four <code>if</code> statements");'
|
||||
- text: Você deve ter pelo menos uma declaração de <code>return</code>
|
||||
testString: 'assert(code.match(/return/g).length >= 1, "You should have at least one <code>return</code> statement");'
|
||||
- text: <code>testSize(0)</code> deve retornar "minúsculo"
|
||||
testString: 'assert(testSize(0) === "Tiny", "<code>testSize(0)</code> should return "Tiny"");'
|
||||
- text: <code>testSize(4)</code> deve retornar "minúsculo"
|
||||
testString: 'assert(testSize(4) === "Tiny", "<code>testSize(4)</code> should return "Tiny"");'
|
||||
- text: <code>testSize(5)</code> deve retornar "Small"
|
||||
testString: 'assert(testSize(5) === "Small", "<code>testSize(5)</code> should return "Small"");'
|
||||
- text: <code>testSize(8)</code> deve retornar "Small"
|
||||
testString: 'assert(testSize(8) === "Small", "<code>testSize(8)</code> should return "Small"");'
|
||||
- text: <code>testSize(10)</code> deve retornar "Medium"
|
||||
testString: 'assert(testSize(10) === "Medium", "<code>testSize(10)</code> should return "Medium"");'
|
||||
- text: <code>testSize(14)</code> deve retornar "Medium"
|
||||
testString: 'assert(testSize(14) === "Medium", "<code>testSize(14)</code> should return "Medium"");'
|
||||
- text: <code>testSize(15)</code> deve retornar "Large"
|
||||
testString: 'assert(testSize(15) === "Large", "<code>testSize(15)</code> should return "Large"");'
|
||||
- text: <code>testSize(17)</code> deve retornar "Large"
|
||||
testString: 'assert(testSize(17) === "Large", "<code>testSize(17)</code> should return "Large"");'
|
||||
- text: <code>testSize(20)</code> deve retornar "Enorme"
|
||||
testString: 'assert(testSize(20) === "Huge", "<code>testSize(20)</code> should return "Huge"");'
|
||||
- text: <code>testSize(25)</code> deve retornar "Enorme"
|
||||
testString: 'assert(testSize(25) === "Huge", "<code>testSize(25)</code> should return "Huge"");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function testSize(num) {
|
||||
// Only change code below this line
|
||||
|
||||
|
||||
return "Change Me";
|
||||
// Only change code above this line
|
||||
}
|
||||
|
||||
// Change this value to test
|
||||
testSize(7);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,50 @@
|
||||
---
|
||||
id: bd7123c9c441eddfaeb4bdef
|
||||
title: Comment Your JavaScript Code
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Comente seu código JavaScript
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Comentários são linhas de código que o JavaScript irá ignorar intencionalmente. Os comentários são uma ótima maneira de deixar anotações para você e para outras pessoas que mais tarde precisarão descobrir o que esse código faz. Existem duas maneiras de escrever comentários em JavaScript: Usar o <code>//</code> dirá JavaScript para ignorar o restante do texto na linha atual: <blockquote> // Este é um comentário em linha. </blockquote> Você pode fazer um comentário de várias linhas começando com <code>/*</code> e terminando com <code>*/</code> : <blockquote> /* Isto é um <br> comentário de várias linhas * / </blockquote> <strong>Melhor pratica</strong> <br> Conforme você escreve o código, você deve adicionar regularmente comentários para esclarecer a função de partes do seu código. Bons comentários podem ajudar a comunicar a intenção do seu código - tanto para os outros <em>quanto</em> para o seu futuro. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Tente criar um de cada tipo de comentário. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Crie um <code>//</code> comentário de estilo que contenha pelo menos cinco letras.
|
||||
testString: 'assert(code.match(/(\/\/)...../g), "Create a <code>//</code> style comment that contains at least five letters.");'
|
||||
- text: Crie um comentário <code>/* */</code> style que contenha pelo menos cinco letras.
|
||||
testString: 'assert(code.match(/(\/\*)([^\/]{5,})(?=\*\/)/gm), "Create a <code>/* */</code> style comment that contains at least five letters.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,64 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244d0
|
||||
title: Comparison with the Equality Operator
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Comparação com o operador de igualdade
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Existem muitos <dfn>operadores de comparação</dfn> em JavaScript. Todos esses operadores retornam um valor booleano <code>true</code> ou <code>false</code> . O operador mais básico é o operador de igualdade <code>==</code> . O operador de igualdade compara dois valores e retorna <code>true</code> se eles forem equivalentes ou <code>false</code> se não forem. Observe que a igualdade é diferente da atribuição ( <code>=</code> ), que atribui o valor à direita do operador a uma variável à esquerda. <blockquote> function equalityTest (myVal) { <br> if (myVal == 10) { <br> return "Equal"; <br> } <br> return "Não igual"; <br> } </blockquote> Se <code>myVal</code> for igual a <code>10</code> , o operador de igualdade retornará <code>true</code> , portanto o código nas chaves será executado e a função retornará <code>"Equal"</code> . Caso contrário, a função retornará <code>"Not Equal"</code> . Para que o JavaScript compare dois <code>data types</code> diferentes (por exemplo, <code>numbers</code> e <code>strings</code> ), ele deve converter um tipo em outro. Isso é conhecido como "Type Coerção". Uma vez feito, no entanto, ele pode comparar os termos da seguinte forma: <blockquote> 1 == 1 // verdadeiro <br> 1 == 2 // false <br> 1 == '1' // verdadeiro <br> "3" == 3 // verdadeiro </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Adicione o <code>equality operator</code> à linha indicada para que a função retorne "Equal" quando <code>val</code> é equivalente a <code>12</code> </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>testEqual(10)</code> deve retornar "não igual"
|
||||
testString: 'assert(testEqual(10) === "Not Equal", "<code>testEqual(10)</code> should return "Not Equal"");'
|
||||
- text: <code>testEqual(12)</code> deve retornar "Equal"
|
||||
testString: 'assert(testEqual(12) === "Equal", "<code>testEqual(12)</code> should return "Equal"");'
|
||||
- text: <code>testEqual("12")</code> deve retornar "Igual"
|
||||
testString: 'assert(testEqual("12") === "Equal", "<code>testEqual("12")</code> should return "Equal"");'
|
||||
- text: Você deve usar o operador <code>==</code>
|
||||
testString: 'assert(code.match(/==/g) && !code.match(/===/g), "You should use the <code>==</code> operator");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
// Setup
|
||||
function testEqual(val) {
|
||||
if (val) { // Change this line
|
||||
return "Equal";
|
||||
}
|
||||
return "Not Equal";
|
||||
}
|
||||
|
||||
// Change this value to test
|
||||
testEqual(10);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,76 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244d4
|
||||
title: Comparison with the Greater Than Operator
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Comparação com o operador Maior que
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> O operador maior que ( <code>></code> ) compara os valores de dois números. Se o número à esquerda for maior que o número à direita, ele retornará <code>true</code> . Caso contrário, retorna <code>false</code> . Como o operador de igualdade, maior que o operador converterá tipos de dados de valores durante a comparação. <strong>Exemplos</strong> <blockquote> 5> 3 // verdadeiro <br> 7> '3' // verdadeiro <br> 2> 3 // falso <br> '1'> 9 // falso </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Adicione o operador <code>greater than</code> às linhas indicadas para que as instruções de retorno façam sentido. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>testGreaterThan(0)</code> deve retornar "10 ou menos"
|
||||
testString: 'assert(testGreaterThan(0) === "10 or Under", "<code>testGreaterThan(0)</code> should return "10 or Under"");'
|
||||
- text: <code>testGreaterThan(10)</code> deve retornar "10 ou menos"
|
||||
testString: 'assert(testGreaterThan(10) === "10 or Under", "<code>testGreaterThan(10)</code> should return "10 or Under"");'
|
||||
- text: <code>testGreaterThan(11)</code> deve retornar "Mais de 10"
|
||||
testString: 'assert(testGreaterThan(11) === "Over 10", "<code>testGreaterThan(11)</code> should return "Over 10"");'
|
||||
- text: <code>testGreaterThan(99)</code> deve retornar "Mais de 10"
|
||||
testString: 'assert(testGreaterThan(99) === "Over 10", "<code>testGreaterThan(99)</code> should return "Over 10"");'
|
||||
- text: <code>testGreaterThan(100)</code> deve retornar "Mais de 10"
|
||||
testString: 'assert(testGreaterThan(100) === "Over 10", "<code>testGreaterThan(100)</code> should return "Over 10"");'
|
||||
- text: <code>testGreaterThan(101)</code> deve retornar "Mais de 100"
|
||||
testString: 'assert(testGreaterThan(101) === "Over 100", "<code>testGreaterThan(101)</code> should return "Over 100"");'
|
||||
- text: <code>testGreaterThan(150)</code> deve retornar "Mais de 100"
|
||||
testString: 'assert(testGreaterThan(150) === "Over 100", "<code>testGreaterThan(150)</code> should return "Over 100"");'
|
||||
- text: Você deve usar o operador <code>></code> pelo menos duas vezes
|
||||
testString: 'assert(code.match(/val\s*>\s*("|")*\d+("|")*/g).length > 1, "You should use the <code>></code> operator at least twice");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function testGreaterThan(val) {
|
||||
if (val) { // Change this line
|
||||
return "Over 100";
|
||||
}
|
||||
|
||||
if (val) { // Change this line
|
||||
return "Over 10";
|
||||
}
|
||||
|
||||
return "10 or Under";
|
||||
}
|
||||
|
||||
// Change this value to test
|
||||
testGreaterThan(10);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,76 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244d5
|
||||
title: Comparison with the Greater Than Or Equal To Operator
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Comparação com o maior que ou igual ao operador
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> O <code>greater than or equal to</code> operador ( <code>>=</code> ) compara os valores de dois números. Se o número à esquerda for maior ou igual ao número à direita, ele retornará <code>true</code> . Caso contrário, retorna <code>false</code> . Como o operador de igualdade, <code>greater than or equal to</code> operador converterá os tipos de dados durante a comparação. <strong>Exemplos</strong> <blockquote> 6> = 6 // verdadeiro <br> 7> = '3' // verdadeiro <br> 2> = 3 // falso <br> '7'> = 9 // falso </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Adicione o operador <code>greater than or equal to</code> às linhas indicadas para que as instruções de retorno façam sentido. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>testGreaterOrEqual(0)</code> deve retornar "Menor que 10"
|
||||
testString: 'assert(testGreaterOrEqual(0) === "Less than 10", "<code>testGreaterOrEqual(0)</code> should return "Less than 10"");'
|
||||
- text: <code>testGreaterOrEqual(9)</code> deve retornar "Menor que 10"
|
||||
testString: 'assert(testGreaterOrEqual(9) === "Less than 10", "<code>testGreaterOrEqual(9)</code> should return "Less than 10"");'
|
||||
- text: <code>testGreaterOrEqual(10)</code> deve retornar "10 ou mais"
|
||||
testString: 'assert(testGreaterOrEqual(10) === "10 or Over", "<code>testGreaterOrEqual(10)</code> should return "10 or Over"");'
|
||||
- text: <code>testGreaterOrEqual(11)</code> deve retornar "10 ou mais"
|
||||
testString: 'assert(testGreaterOrEqual(11) === "10 or Over", "<code>testGreaterOrEqual(11)</code> should return "10 or Over"");'
|
||||
- text: <code>testGreaterOrEqual(19)</code> deve retornar "10 ou mais"
|
||||
testString: 'assert(testGreaterOrEqual(19) === "10 or Over", "<code>testGreaterOrEqual(19)</code> should return "10 or Over"");'
|
||||
- text: <code>testGreaterOrEqual(100)</code> deve retornar "20 ou mais"
|
||||
testString: 'assert(testGreaterOrEqual(100) === "20 or Over", "<code>testGreaterOrEqual(100)</code> should return "20 or Over"");'
|
||||
- text: <code>testGreaterOrEqual(21)</code> deve retornar "20 ou mais"
|
||||
testString: 'assert(testGreaterOrEqual(21) === "20 or Over", "<code>testGreaterOrEqual(21)</code> should return "20 or Over"");'
|
||||
- text: Você deve usar o operador <code>>=</code> pelo menos duas vezes
|
||||
testString: 'assert(code.match(/val\s*>=\s*("|")*\d+("|")*/g).length > 1, "You should use the <code>>=</code> operator at least twice");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function testGreaterOrEqual(val) {
|
||||
if (val) { // Change this line
|
||||
return "20 or Over";
|
||||
}
|
||||
|
||||
if (val) { // Change this line
|
||||
return "10 or Over";
|
||||
}
|
||||
|
||||
return "Less than 10";
|
||||
}
|
||||
|
||||
// Change this value to test
|
||||
testGreaterOrEqual(10);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,68 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244d2
|
||||
title: Comparison with the Inequality Operator
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Comparação com o operador Inequality
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> O operador de desigualdade ( <code>!=</code> ) É o oposto do operador de igualdade. Significa "Não igual" e retorna <code>false</code> onde a igualdade retornaria <code>true</code> e <em>vice-versa</em> . Como o operador de igualdade, o operador de desigualdade converterá tipos de dados de valores durante a comparação. <strong>Exemplos</strong> <blockquote> 1! = 2 // verdadeiro <br> 1! = "1" // false <br> 1! = '1' // false <br> 1! = Verdadeiro // falso <br> 0! = Falso // falso </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Adicione o operador de desigualdade <code>!=</code> Na instrução <code>if</code> para que a função retorne "Not Equal" quando <code>val</code> não for equivalente a <code>99</code> </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>testNotEqual(99)</code> deve retornar "igual"
|
||||
testString: 'assert(testNotEqual(99) === "Equal", "<code>testNotEqual(99)</code> should return "Equal"");'
|
||||
- text: <code>testNotEqual("99")</code> deve retornar "igual"
|
||||
testString: 'assert(testNotEqual("99") === "Equal", "<code>testNotEqual("99")</code> should return "Equal"");'
|
||||
- text: <code>testNotEqual(12)</code> deve retornar "não igual"
|
||||
testString: 'assert(testNotEqual(12) === "Not Equal", "<code>testNotEqual(12)</code> should return "Not Equal"");'
|
||||
- text: <code>testNotEqual("12")</code> deve retornar "não igual"
|
||||
testString: 'assert(testNotEqual("12") === "Not Equal", "<code>testNotEqual("12")</code> should return "Not Equal"");'
|
||||
- text: <code>testNotEqual("bob")</code> deve retornar "não igual"
|
||||
testString: 'assert(testNotEqual("bob") === "Not Equal", "<code>testNotEqual("bob")</code> should return "Not Equal"");'
|
||||
- text: Você deve usar o operador <code>!=</code>
|
||||
testString: 'assert(code.match(/(?!!==)!=/), "You should use the <code>!=</code> operator");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
// Setup
|
||||
function testNotEqual(val) {
|
||||
if (val) { // Change this line
|
||||
return "Not Equal";
|
||||
}
|
||||
return "Equal";
|
||||
}
|
||||
|
||||
// Change this value to test
|
||||
testNotEqual(10);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,74 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244d6
|
||||
title: Comparison with the Less Than Operator
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Comparação com o menor que o operador
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> O operador <dfn>menor que</dfn> ( <code><</code> ) compara os valores de dois números. Se o número à esquerda for menor que o número à direita, ele retornará <code>true</code> . Caso contrário, retorna <code>false</code> . Como o operador de igualdade, o operador <dfn>menor que</dfn> converte tipos de dados durante a comparação. <strong>Exemplos</strong> <blockquote> 2 <5 // verdadeiro <br> '3' <7 // verdadeiro <br> 5 <5 // falso <br> 3 <2 // falso <br> '8' <4 // falso </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Adicione o operador <code>less than</code> às linhas indicadas para que as instruções de retorno façam sentido. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>testLessThan(0)</code> deve retornar "Abaixo de 25"
|
||||
testString: 'assert(testLessThan(0) === "Under 25", "<code>testLessThan(0)</code> should return "Under 25"");'
|
||||
- text: <code>testLessThan(24)</code> deve retornar "Abaixo de 25"
|
||||
testString: 'assert(testLessThan(24) === "Under 25", "<code>testLessThan(24)</code> should return "Under 25"");'
|
||||
- text: <code>testLessThan(25)</code> deve retornar "Under 55"
|
||||
testString: 'assert(testLessThan(25) === "Under 55", "<code>testLessThan(25)</code> should return "Under 55"");'
|
||||
- text: <code>testLessThan(54)</code> deve retornar "Under 55"
|
||||
testString: 'assert(testLessThan(54) === "Under 55", "<code>testLessThan(54)</code> should return "Under 55"");'
|
||||
- text: <code>testLessThan(55)</code> deve retornar "55 ou mais"
|
||||
testString: 'assert(testLessThan(55) === "55 or Over", "<code>testLessThan(55)</code> should return "55 or Over"");'
|
||||
- text: <code>testLessThan(99)</code> deve retornar "55 ou mais"
|
||||
testString: 'assert(testLessThan(99) === "55 or Over", "<code>testLessThan(99)</code> should return "55 or Over"");'
|
||||
- text: Você deve usar o operador <code><</code> pelo menos duas vezes
|
||||
testString: 'assert(code.match(/val\s*<\s*("|")*\d+("|")*/g).length > 1, "You should use the <code><</code> operator at least twice");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function testLessThan(val) {
|
||||
if (val) { // Change this line
|
||||
return "Under 25";
|
||||
}
|
||||
|
||||
if (val) { // Change this line
|
||||
return "Under 55";
|
||||
}
|
||||
|
||||
return "55 or Over";
|
||||
}
|
||||
|
||||
// Change this value to test
|
||||
testLessThan(10);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,76 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244d7
|
||||
title: Comparison with the Less Than Or Equal To Operator
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Comparação com o menor ou igual ao operador
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> O operador <code>less than or equal to</code> ( <code><=</code> ) compara os valores de dois números. Se o número à esquerda for menor ou igual ao número à direita, ele retornará <code>true</code> . Se o número à esquerda for maior que o número à direita, ele retornará <code>false</code> . Como o operador de igualdade, <code>less than or equal to</code> converte tipos de dados. <strong>Exemplos</strong> <blockquote> 4 <= 5 // verdadeiro <br> '7' <= 7 // verdadeiro <br> 5 <= 5 // verdadeiro <br> 3 <= 2 // falso <br> '8' <= 4 // falso </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Adicione o operador <code>less than or equal to</code> das linhas indicadas para que as instruções de retorno façam sentido. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>testLessOrEqual(0)</code> deve retornar "Menor ou igual a 12"
|
||||
testString: 'assert(testLessOrEqual(0) === "Smaller Than or Equal to 12", "<code>testLessOrEqual(0)</code> should return "Smaller Than or Equal to 12"");'
|
||||
- text: <code>testLessOrEqual(11)</code> deve retornar "Menor ou igual a 12"
|
||||
testString: 'assert(testLessOrEqual(11) === "Smaller Than or Equal to 12", "<code>testLessOrEqual(11)</code> should return "Smaller Than or Equal to 12"");'
|
||||
- text: <code>testLessOrEqual(12)</code> deve retornar "Menor ou igual a 12"
|
||||
testString: 'assert(testLessOrEqual(12) === "Smaller Than or Equal to 12", "<code>testLessOrEqual(12)</code> should return "Smaller Than or Equal to 12"");'
|
||||
- text: <code>testLessOrEqual(23)</code> deve retornar "Menor ou igual a 24"
|
||||
testString: 'assert(testLessOrEqual(23) === "Smaller Than or Equal to 24", "<code>testLessOrEqual(23)</code> should return "Smaller Than or Equal to 24"");'
|
||||
- text: <code>testLessOrEqual(24)</code> deve retornar "Menor ou igual a 24"
|
||||
testString: 'assert(testLessOrEqual(24) === "Smaller Than or Equal to 24", "<code>testLessOrEqual(24)</code> should return "Smaller Than or Equal to 24"");'
|
||||
- text: <code>testLessOrEqual(25)</code> deve retornar "mais de 24"
|
||||
testString: 'assert(testLessOrEqual(25) === "More Than 24", "<code>testLessOrEqual(25)</code> should return "More Than 24"");'
|
||||
- text: <code>testLessOrEqual(55)</code> deve retornar "mais de 24"
|
||||
testString: 'assert(testLessOrEqual(55) === "More Than 24", "<code>testLessOrEqual(55)</code> should return "More Than 24"");'
|
||||
- text: Você deve usar o operador <code><=</code> pelo menos duas vezes
|
||||
testString: 'assert(code.match(/val\s*<=\s*("|")*\d+("|")*/g).length > 1, "You should use the <code><=</code> operator at least twice");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function testLessOrEqual(val) {
|
||||
if (val) { // Change this line
|
||||
return "Smaller Than or Equal to 12";
|
||||
}
|
||||
|
||||
if (val) { // Change this line
|
||||
return "Smaller Than or Equal to 24";
|
||||
}
|
||||
|
||||
return "More Than 24";
|
||||
}
|
||||
|
||||
// Change this value to test
|
||||
testLessOrEqual(10);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,64 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244d1
|
||||
title: Comparison with the Strict Equality Operator
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Comparação com o operador Strict Equality
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> A igualdade estrita ( <code>===</code> ) é a contrapartida do operador de igualdade ( <code>==</code> ). No entanto, ao contrário do operador de igualdade, que tenta converter os dois valores sendo comparados a um tipo comum, o operador de igualdade estrita não executa uma conversão de tipo. Se os valores que estão sendo comparados tiverem tipos diferentes, eles serão considerados desiguais e o operador de igualdade estrita retornará false. <strong>Exemplos</strong> <blockquote> 3 === 3 // verdadeiro <br> 3 === '3' // false </blockquote> No segundo exemplo, <code>3</code> é um tipo <code>Number</code> e <code>'3'</code> é um tipo <code>String</code> . </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Use o operador de igualdade estrito na instrução <code>if</code> para que a função retorne "Equal" quando <code>val</code> for estritamente igual a <code>7</code> </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>testStrict(10)</code> deve retornar "não igual"
|
||||
testString: 'assert(testStrict(10) === "Not Equal", "<code>testStrict(10)</code> should return "Not Equal"");'
|
||||
- text: <code>testStrict(7)</code> deve retornar "igual"
|
||||
testString: 'assert(testStrict(7) === "Equal", "<code>testStrict(7)</code> should return "Equal"");'
|
||||
- text: <code>testStrict("7")</code> deve retornar "não igual"
|
||||
testString: 'assert(testStrict("7") === "Not Equal", "<code>testStrict("7")</code> should return "Not Equal"");'
|
||||
- text: Você deve usar o operador <code>===</code>
|
||||
testString: 'assert(code.match(/(val\s*===\s*\d+)|(\d+\s*===\s*val)/g).length > 0, "You should use the <code>===</code> operator");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
// Setup
|
||||
function testStrict(val) {
|
||||
if (val) { // Change this line
|
||||
return "Equal";
|
||||
}
|
||||
return "Not Equal";
|
||||
}
|
||||
|
||||
// Change this value to test
|
||||
testStrict(10);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,71 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244d3
|
||||
title: Comparison with the Strict Inequality Operator
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Comparação com o Operador Estrito da Desigualdade
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> O operador de desigualdade restrita ( <code>!==</code> ) é o oposto lógico do operador de igualdade estrito. Significa "estritamente não igual" e retorna <code>false</code> onde a igualdade estrita retornaria <code>true</code> e <em>vice-versa</em> . A desigualdade estrita não converte tipos de dados. <strong>Exemplos</strong> <blockquote> 3! == 3 // false <br> 3! == '3' // true <br> 4! == 3 // verdadeiro </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Adicione o <code>strict inequality operator</code> à instrução <code>if</code> para que a função retorne "Not Equal" quando <code>val</code> não for estritamente igual a <code>17</code> </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>testStrictNotEqual(17)</code> deve retornar "Igual"
|
||||
testString: 'assert(testStrictNotEqual(17) === "Equal", "<code>testStrictNotEqual(17)</code> should return "Equal"");'
|
||||
- text: <code>testStrictNotEqual("17")</code> deve retornar "não igual"
|
||||
testString: 'assert(testStrictNotEqual("17") === "Not Equal", "<code>testStrictNotEqual("17")</code> should return "Not Equal"");'
|
||||
- text: <code>testStrictNotEqual(12)</code> deve retornar "não igual"
|
||||
testString: 'assert(testStrictNotEqual(12) === "Not Equal", "<code>testStrictNotEqual(12)</code> should return "Not Equal"");'
|
||||
- text: <code>testStrictNotEqual("bob")</code> deve retornar "não igual"
|
||||
testString: 'assert(testStrictNotEqual("bob") === "Not Equal", "<code>testStrictNotEqual("bob")</code> should return "Not Equal"");'
|
||||
- text: Você deve usar o operador <code>!==</code>
|
||||
testString: 'assert(code.match(/(val\s*!==\s*\d+)|(\d+\s*!==\s*val)/g).length > 0, "You should use the <code>!==</code> operator");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
// Setup
|
||||
function testStrictNotEqual(val) {
|
||||
// Only Change Code Below this Line
|
||||
|
||||
if (val) {
|
||||
|
||||
// Only Change Code Above this Line
|
||||
|
||||
return "Not Equal";
|
||||
}
|
||||
return "Equal";
|
||||
}
|
||||
|
||||
// Change this value to test
|
||||
testStrictNotEqual(10);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,81 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244d8
|
||||
title: Comparisons with the Logical And Operator
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Comparações com o Logical And Operator
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Às vezes você precisará testar mais de uma coisa de cada vez. O <dfn>lógico e o</dfn> operador ( <code>&&</code> ) retornam <code>true</code> se e somente se os <dfn>operandos</dfn> à esquerda e à direita dele forem verdadeiros. O mesmo efeito pode ser obtido aninhando uma instrução if dentro de outra se: <blockquote> if (num> 5) { <br> if (num <10) { <br> return "Sim"; <br> } <br> } <br> return "não"; </blockquote> só retornará "Sim" se <code>num</code> for maior que <code>5</code> e menor que <code>10</code> . A mesma lógica pode ser escrita como: <blockquote> if (num> 5 && num <10) { <br> return "Sim"; <br> } <br> return "não"; </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Combine as duas instruções if em uma instrução que retornará <code>"Yes"</code> se <code>val</code> for menor ou igual a <code>50</code> e maior ou igual a <code>25</code> . Caso contrário, retornará <code>"No"</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Você deve usar o operador <code>&&</code> uma vez
|
||||
testString: 'assert(code.match(/&&/g).length === 1, "You should use the <code>&&</code> operator once");'
|
||||
- text: Você deve ter apenas uma declaração <code>if</code>
|
||||
testString: 'assert(code.match(/if/g).length === 1, "You should only have one <code>if</code> statement");'
|
||||
- text: <code>testLogicalAnd(0)</code> deve retornar "Não"
|
||||
testString: 'assert(testLogicalAnd(0) === "No", "<code>testLogicalAnd(0)</code> should return "No"");'
|
||||
- text: <code>testLogicalAnd(24)</code> deve retornar "Não"
|
||||
testString: 'assert(testLogicalAnd(24) === "No", "<code>testLogicalAnd(24)</code> should return "No"");'
|
||||
- text: <code>testLogicalAnd(25)</code> deve retornar "Sim"
|
||||
testString: 'assert(testLogicalAnd(25) === "Yes", "<code>testLogicalAnd(25)</code> should return "Yes"");'
|
||||
- text: <code>testLogicalAnd(30)</code> deve retornar "Sim"
|
||||
testString: 'assert(testLogicalAnd(30) === "Yes", "<code>testLogicalAnd(30)</code> should return "Yes"");'
|
||||
- text: <code>testLogicalAnd(50)</code> deve retornar "Sim"
|
||||
testString: 'assert(testLogicalAnd(50) === "Yes", "<code>testLogicalAnd(50)</code> should return "Yes"");'
|
||||
- text: <code>testLogicalAnd(51)</code> deve retornar "Não"
|
||||
testString: 'assert(testLogicalAnd(51) === "No", "<code>testLogicalAnd(51)</code> should return "No"");'
|
||||
- text: <code>testLogicalAnd(75)</code> deve retornar "Não"
|
||||
testString: 'assert(testLogicalAnd(75) === "No", "<code>testLogicalAnd(75)</code> should return "No"");'
|
||||
- text: <code>testLogicalAnd(80)</code> deve retornar "Não"
|
||||
testString: 'assert(testLogicalAnd(80) === "No", "<code>testLogicalAnd(80)</code> should return "No"");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function testLogicalAnd(val) {
|
||||
// Only change code below this line
|
||||
|
||||
if (val) {
|
||||
if (val) {
|
||||
return "Yes";
|
||||
}
|
||||
}
|
||||
|
||||
// Only change code above this line
|
||||
return "No";
|
||||
}
|
||||
|
||||
// Change this value to test
|
||||
testLogicalAnd(10);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,83 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244d9
|
||||
title: Comparisons with the Logical Or Operator
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Comparações com o lógico ou operador
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> O <dfn>lógico ou</dfn> operador ( <code>||</code> ) retorna <code>true</code> se qualquer um dos <dfn>operandos</dfn> for <code>true</code> . Caso contrário, retorna <code>false</code> . O <dfn>lógico ou</dfn> operador é composto de dois símbolos de pipe ( <code>|</code> ). Isso geralmente pode ser encontrado entre as teclas Backspace e Enter. O padrão abaixo deve parecer familiar a partir de waypoints anteriores: <blockquote> if (num> 10) { <br> return "não"; <br> } <br> if (num <5) { <br> return "não"; <br> } <br> return "Sim"; </blockquote> retornará "Sim" somente se <code>num</code> for entre <code>5</code> e <code>10</code> (5 e 10 incluídos). A mesma lógica pode ser escrita como: <blockquote> if (num> 10 || num <5) { <br> return "não"; <br> } <br> return "Sim"; </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Combine as duas declarações <code>if</code> em uma declaração que retorne <code>"Outside"</code> se <code>val</code> não estiver entre <code>10</code> e <code>20</code> , inclusive. Caso contrário, retorne <code>"Inside"</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Você deve usar o <code>||</code> operador uma vez
|
||||
testString: 'assert(code.match(/\|\|/g).length === 1, "You should use the <code>||</code> operator once");'
|
||||
- text: Você deve ter apenas uma declaração <code>if</code>
|
||||
testString: 'assert(code.match(/if/g).length === 1, "You should only have one <code>if</code> statement");'
|
||||
- text: <code>testLogicalOr(0)</code> deve retornar "Outside"
|
||||
testString: 'assert(testLogicalOr(0) === "Outside", "<code>testLogicalOr(0)</code> should return "Outside"");'
|
||||
- text: <code>testLogicalOr(9)</code> deve retornar "Outside"
|
||||
testString: 'assert(testLogicalOr(9) === "Outside", "<code>testLogicalOr(9)</code> should return "Outside"");'
|
||||
- text: <code>testLogicalOr(10)</code> deve retornar "Inside"
|
||||
testString: 'assert(testLogicalOr(10) === "Inside", "<code>testLogicalOr(10)</code> should return "Inside"");'
|
||||
- text: <code>testLogicalOr(15)</code> deve retornar "Inside"
|
||||
testString: 'assert(testLogicalOr(15) === "Inside", "<code>testLogicalOr(15)</code> should return "Inside"");'
|
||||
- text: <code>testLogicalOr(19)</code> deve retornar "Inside"
|
||||
testString: 'assert(testLogicalOr(19) === "Inside", "<code>testLogicalOr(19)</code> should return "Inside"");'
|
||||
- text: <code>testLogicalOr(20)</code> deve retornar "Inside"
|
||||
testString: 'assert(testLogicalOr(20) === "Inside", "<code>testLogicalOr(20)</code> should return "Inside"");'
|
||||
- text: <code>testLogicalOr(21)</code> deve retornar "Outside"
|
||||
testString: 'assert(testLogicalOr(21) === "Outside", "<code>testLogicalOr(21)</code> should return "Outside"");'
|
||||
- text: <code>testLogicalOr(25)</code> deve retornar "Outside"
|
||||
testString: 'assert(testLogicalOr(25) === "Outside", "<code>testLogicalOr(25)</code> should return "Outside"");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function testLogicalOr(val) {
|
||||
// Only change code below this line
|
||||
|
||||
if (val) {
|
||||
return "Outside";
|
||||
}
|
||||
|
||||
if (val) {
|
||||
return "Outside";
|
||||
}
|
||||
|
||||
// Only change code above this line
|
||||
return "Inside";
|
||||
}
|
||||
|
||||
// Change this value to test
|
||||
testLogicalOr(15);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,73 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244af
|
||||
title: Compound Assignment With Augmented Addition
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Atribuição composta com adição aumentada
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Na programação, é comum usar atribuições para modificar o conteúdo de uma variável. Lembre-se de que tudo à direita do sinal de igual é avaliado primeiro, então podemos dizer: <code>myVar = myVar + 5;</code> para adicionar <code>5</code> a <code>myVar</code> . Como esse é um padrão tão comum, há operadores que fazem uma operação matemática e uma atribuição em uma etapa. Um desses operadores é o operador <code>+=</code> . <blockquote> var myVar = 1; <br> myVar + = 5; <br> console.log (myVar); // Retorna 6 </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Converta as atribuições de <code>a</code> , <code>b</code> e <code>c</code> para usar o operador <code>+=</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>a</code> deve ser igual a <code>15</code>
|
||||
testString: 'assert(a === 15, "<code>a</code> should equal <code>15</code>");'
|
||||
- text: <code>b</code> deve ser igual a <code>26</code>
|
||||
testString: 'assert(b === 26, "<code>b</code> should equal <code>26</code>");'
|
||||
- text: <code>c</code> deve ser igual a <code>19</code>
|
||||
testString: 'assert(c === 19, "<code>c</code> should equal <code>19</code>");'
|
||||
- text: Você deve usar o operador <code>+=</code> para cada variável
|
||||
testString: 'assert(code.match(/\+=/g).length === 3, "You should use the <code>+=</code> operator for each variable");'
|
||||
- text: Não modifique o código acima da linha
|
||||
testString: 'assert(/var a = 3;/.test(code) && /var b = 17;/.test(code) && /var c = 12;/.test(code), "Do not modify the code above the line");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
var a = 3;
|
||||
var b = 17;
|
||||
var c = 12;
|
||||
|
||||
// Only modify code below this line
|
||||
|
||||
a = a + 12;
|
||||
b = 9 + b;
|
||||
c = c + 7;
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,73 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244b2
|
||||
title: Compound Assignment With Augmented Division
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Atribuição Composta Com Divisão Aumentada
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> O operador <code>/=</code> divide uma variável por outro número. <code>myVar = myVar / 5;</code> Vai dividir <code>myVar</code> por <code>5</code> . Isso pode ser reescrito como: <code>myVar /= 5;</code> </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Converta as atribuições de <code>a</code> , <code>b</code> e <code>c</code> para usar o operador <code>/=</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>a</code> deve ser igual a <code>4</code>
|
||||
testString: 'assert(a === 4, "<code>a</code> should equal <code>4</code>");'
|
||||
- text: <code>b</code> deve ser igual a <code>27</code>
|
||||
testString: 'assert(b === 27, "<code>b</code> should equal <code>27</code>");'
|
||||
- text: <code>c</code> deve ser igual a <code>3</code>
|
||||
testString: 'assert(c === 3, "<code>c</code> should equal <code>3</code>");'
|
||||
- text: Você deve usar o operador <code>/=</code> para cada variável
|
||||
testString: 'assert(code.match(/\/=/g).length === 3, "You should use the <code>/=</code> operator for each variable");'
|
||||
- text: Não modifique o código acima da linha
|
||||
testString: 'assert(/var a = 48;/.test(code) && /var b = 108;/.test(code) && /var c = 33;/.test(code), "Do not modify the code above the line");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
var a = 48;
|
||||
var b = 108;
|
||||
var c = 33;
|
||||
|
||||
// Only modify code below this line
|
||||
|
||||
a = a / 12;
|
||||
b = b / 4;
|
||||
c = c / 11;
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,73 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244b1
|
||||
title: Compound Assignment With Augmented Multiplication
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Atribuição Composta Com Multiplicação Aumentada
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> O operador <code>*=</code> multiplica uma variável por um número. <code>myVar = myVar * 5;</code> irá multiplicar <code>myVar</code> por <code>5</code> . Isso pode ser reescrito como: <code>myVar *= 5;</code> </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Converta as atribuições de <code>a</code> , <code>b</code> e <code>c</code> para usar o operador <code>*=</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>a</code> deve ser igual a <code>25</code>
|
||||
testString: 'assert(a === 25, "<code>a</code> should equal <code>25</code>");'
|
||||
- text: <code>b</code> deve ser igual a <code>36</code>
|
||||
testString: 'assert(b === 36, "<code>b</code> should equal <code>36</code>");'
|
||||
- text: <code>c</code> deve ser igual a <code>46</code>
|
||||
testString: 'assert(c === 46, "<code>c</code> should equal <code>46</code>");'
|
||||
- text: Você deve usar o operador <code>*=</code> para cada variável
|
||||
testString: 'assert(code.match(/\*=/g).length === 3, "You should use the <code>*=</code> operator for each variable");'
|
||||
- text: Não modifique o código acima da linha
|
||||
testString: 'assert(/var a = 5;/.test(code) && /var b = 12;/.test(code) && /var c = 4\.6;/.test(code), "Do not modify the code above the line");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
var a = 5;
|
||||
var b = 12;
|
||||
var c = 4.6;
|
||||
|
||||
// Only modify code below this line
|
||||
|
||||
a = a * 5;
|
||||
b = 3 * b;
|
||||
c = c * 10;
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,73 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244b0
|
||||
title: Compound Assignment With Augmented Subtraction
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Atribuição Composta com Subtração Aumentada
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Como o operador <code>+=</code> , <code>-=</code> subtrai um número de uma variável. <code>myVar = myVar - 5;</code> subtrairá <code>5</code> do <code>myVar</code> . Isso pode ser reescrito como: <code>myVar -= 5;</code> </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Converta as atribuições de <code>a</code> , <code>b</code> e <code>c</code> para usar o operador <code>-=</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>a</code> deve igual a <code>5</code>
|
||||
testString: 'assert(a === 5, "<code>a</code> should equal <code>5</code>");'
|
||||
- text: <code>b</code> deve ser igual a <code>-6</code>
|
||||
testString: 'assert(b === -6, "<code>b</code> should equal <code>-6</code>");'
|
||||
- text: <code>c</code> deve ser igual a <code>2</code>
|
||||
testString: 'assert(c === 2, "<code>c</code> should equal <code>2</code>");'
|
||||
- text: Você deve usar o operador <code>-=</code> para cada variável
|
||||
testString: 'assert(code.match(/-=/g).length === 3, "You should use the <code>-=</code> operator for each variable");'
|
||||
- text: Não modifique o código acima da linha
|
||||
testString: 'assert(/var a = 11;/.test(code) && /var b = 9;/.test(code) && /var c = 3;/.test(code), "Do not modify the code above the line");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
var a = 11;
|
||||
var b = 9;
|
||||
var c = 3;
|
||||
|
||||
// Only modify code below this line
|
||||
|
||||
a = a - 6;
|
||||
b = b - 15;
|
||||
c = c - 1;
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,68 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244b7
|
||||
title: Concatenating Strings with Plus Operator
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Concatenando Strings com Operador Plus
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Em JavaScript, quando o operador <code>+</code> é usado com um valor <code>String</code> , ele é chamado de operador de <dfn>concatenação</dfn> . Você pode construir uma nova string a partir de outras strings, <dfn>concatenando</dfn> -as juntas. <strong>Exemplo</strong> <blockquote> 'Meu nome é Alan,' concordo '. </blockquote> <strong>Nota</strong> <br> Cuidado com os espaços. A concatenação não adiciona espaços entre as sequências concatenadas, portanto, você precisará adicioná-las você mesmo. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Construa <code>myStr</code> partir das strings <code>"This is the start. "</code> E <code>"This is the end."</code> usando o operador <code>+</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>myStr</code> deve ter um valor de <code>This is the start. This is the end.</code>
|
||||
testString: 'assert(myStr === "This is the start. This is the end.", "<code>myStr</code> should have a value of <code>This is the start. This is the end.</code>");'
|
||||
- text: Use o operador <code>+</code> para construir <code>myStr</code>
|
||||
testString: 'assert(code.match(/([""]).*([""])\s*\+\s*([""]).*([""])/g).length > 1, "Use the <code>+</code> operator to build <code>myStr</code>");'
|
||||
- text: <code>myStr</code> deve ser criado usando a palavra-chave <code>var</code> .
|
||||
testString: 'assert(/var\s+myStr/.test(code), "<code>myStr</code> should be created using the <code>var</code> keyword.");'
|
||||
- text: Certifique-se de atribuir o resultado à variável <code>myStr</code> .
|
||||
testString: 'assert(/myStr\s*=/.test(code), "Make sure to assign the result to the <code>myStr</code> variable.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
// Example
|
||||
var ourStr = "I come first. " + "I come second.";
|
||||
|
||||
// Only change code below this line
|
||||
|
||||
var myStr;
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,65 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244b8
|
||||
title: Concatenating Strings with the Plus Equals Operator
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Concatenando Strings com o Operador Plus Equals
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Também podemos usar o operador <code>+=</code> para <dfn>concatenar</dfn> uma string no final de uma variável de string existente. Isso pode ser muito útil para quebrar uma longa cadeia ao longo de várias linhas. <strong>Nota</strong> <br> Cuidado com os espaços. A concatenação não adiciona espaços entre as sequências concatenadas, portanto, você precisará adicioná-las você mesmo. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Crie <code>myStr</code> em várias linhas concatenando essas duas strings: <code>"This is the first sentence. "</code> e <code>"This is the second sentence."</code> usando o operador <code>+=</code> . Use o operador <code>+=</code> semelhante ao mostrado no editor. Comece atribuindo a primeira string ao <code>myStr</code> , em seguida, adicione a segunda string. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>myStr</code> deve ter um valor de <code>This is the first sentence. This is the second sentence.</code>
|
||||
testString: 'assert(myStr === "This is the first sentence. This is the second sentence.", "<code>myStr</code> should have a value of <code>This is the first sentence. This is the second sentence.</code>");'
|
||||
- text: Use o operador <code>+=</code> para construir <code>myStr</code>
|
||||
testString: 'assert(code.match(/\w\s*\+=\s*[""]/g).length > 1 && code.match(/\w\s*\=\s*[""]/g).length > 1, "Use the <code>+=</code> operator to build <code>myStr</code>");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
// Example
|
||||
var ourStr = "I come first. ";
|
||||
ourStr += "I come second.";
|
||||
|
||||
// Only change code below this line
|
||||
|
||||
var myStr;
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,65 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244b9
|
||||
title: Constructing Strings with Variables
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Construindo Strings com Variáveis
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Às vezes você precisará construir uma string, estilo <a href="https://en.wikipedia.org/wiki/Mad_Libs" target="_blank">Mad Libs</a> . Usando o operador de concatenação ( <code>+</code> ), você pode inserir uma ou mais variáveis em uma string que está construindo. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Definir <code>myName</code> para uma string igual ao seu nome e construir <code>myStr</code> com <code>myName</code> entre as seqüências de caracteres <code>"My name is "</code> e <code>" and I am well!"</code> </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>myName</code> deve ser definido para uma string com pelo menos 3 caracteres
|
||||
testString: 'assert(typeof myName !== "undefined" && myName.length > 2, "<code>myName</code> should be set to a string at least 3 characters long");'
|
||||
- text: Use dois <code>+</code> operadores para construir <code>myStr</code> com <code>myName</code> dentro dele
|
||||
testString: 'assert(code.match(/[""]\s*\+\s*myName\s*\+\s*[""]/g).length > 0, "Use two <code>+</code> operators to build <code>myStr</code> with <code>myName</code> inside it");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
// Example
|
||||
var ourName = "freeCodeCamp";
|
||||
var ourStr = "Hello, our name is " + ourName + ", how are you?";
|
||||
|
||||
// Only change code below this line
|
||||
var myName;
|
||||
var myStr;
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,71 @@
|
||||
---
|
||||
id: 56105e7b514f539506016a5e
|
||||
title: Count Backwards With a For Loop
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Conte para trás com um loop for
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Um loop for também pode contar para trás, desde que possamos definir as condições certas. Para contar para trás por dois, precisaremos alterar nossa <code>initialization</code> , <code>condition</code> e <code>final-expression</code> . Vamos começar em <code>i = 10</code> e fazer um loop enquanto <code>i > 0</code> . Diminuiremos <code>i</code> por 2 cada loop com <code>i -= 2</code> . <blockquote> var ourArray = []; <br> para (var i = 10; i> 0; i- = 2) { <br> ourArray.push (i); <br> } </blockquote> <code>ourArray</code> agora conterá <code>[10,8,6,4,2]</code> . Vamos alterar nossa <code>initialization</code> e <code>final-expression</code> para que possamos contar para trás por dois por números ímpares. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Empurre os números ímpares de 9 a 1 para <code>myArray</code> usando um loop <code>for</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Você deve estar usando um <code>for</code> loop para isso.
|
||||
testString: 'assert(code.match(/for\s*\(/g).length > 1, "You should be using a <code>for</code> loop for this.");'
|
||||
- text: Você deve estar usando o método de matriz <code>push</code> .
|
||||
testString: 'assert(code.match(/myArray.push/), "You should be using the array method <code>push</code>.");'
|
||||
- text: '<code>myArray</code> deve ser igual a <code>[9,7,5,3,1]</code> .'
|
||||
testString: 'assert.deepEqual(myArray, [9,7,5,3,1], "<code>myArray</code> should equal <code>[9,7,5,3,1]</code>.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
// Example
|
||||
var ourArray = [];
|
||||
|
||||
for (var i = 10; i > 0; i -= 2) {
|
||||
ourArray.push(i);
|
||||
}
|
||||
|
||||
// Setup
|
||||
var myArray = [];
|
||||
|
||||
// Only change code below this line.
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,74 @@
|
||||
---
|
||||
id: 565bbe00e9cc8ac0725390f4
|
||||
title: Counting Cards
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Contando Cartões
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> No jogo de cassino Blackjack, um jogador pode ganhar uma vantagem sobre a casa, mantendo o controle do número relativo de cartas altas e baixas remanescentes no baralho. Isso é chamado <a href="https://en.wikipedia.org/wiki/Card_counting" target="_blank">de contagem de cartão</a> . Ter mais cartas altas restantes no baralho favorece o jogador. Cada cartão recebe um valor de acordo com a tabela abaixo. Quando a contagem é positiva, o jogador deve apostar alto. Quando a contagem é zero ou negativa, o jogador deve apostar baixo. <table class="table table-striped"><thead><tr><th> Mudança de contagem </th><th> Postais </th></tr></thead><tbody><tr><td> +1 </td><td> 2, 3, 4, 5, 6 </td></tr><tr><td> 0 </td><td> 7, 8, 9 </td></tr><tr><td> -1 </td><td> 10, 'J', 'Q', 'K', 'A' </td></tr></tbody></table> Você vai escrever uma função de contagem de cartões. Ele receberá um parâmetro de <code>card</code> , que pode ser um número ou uma sequência, e incrementará ou decrementará a variável de <code>count</code> global de acordo com o valor da carta (consulte a tabela). A função retornará uma string com a contagem atual e a string <code>Bet</code> se a contagem for positiva ou <code>Hold</code> se a contagem for zero ou negativa. A contagem atual e a decisão do jogador ( <code>Bet</code> ou <code>Hold</code> ) devem ser separadas por um único espaço. <strong>Exemplo de saída</strong> <br> <code>-3 Hold</code> <br> <code>5 Bet</code> <strong>dica de</strong> <code>5 Bet</code> <br> NÃO redefina a <code>count</code> para 0 quando o valor for 7, 8 ou 9. <br> NÃO retorne um array. <br> NÃO inclua aspas (simples ou dupla) na saída. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'Seqüência de Cartões 2, 3, 4, 5, 6 deve retornar <code>5 Bet</code>'
|
||||
testString: 'assert((function(){ count = 0; cc(2);cc(3);cc(4);cc(5);var out = cc(6); if(out === "5 Bet") {return true;} return false; })(), "Cards Sequence 2, 3, 4, 5, 6 should return <code>5 Bet</code>");'
|
||||
- text: 'Seqüência de Cartões 7, 8, 9 deve retornar <code>0 Hold</code>'
|
||||
testString: 'assert((function(){ count = 0; cc(7);cc(8);var out = cc(9); if(out === "0 Hold") {return true;} return false; })(), "Cards Sequence 7, 8, 9 should return <code>0 Hold</code>");'
|
||||
- text: 'Seqüência de cartas 10, J, Q, K, A deve retornar <code>-5 Hold</code>'
|
||||
testString: 'assert((function(){ count = 0; cc(10);cc("J");cc("Q");cc("K");var out = cc("A"); if(out === "-5 Hold") {return true;} return false; })(), "Cards Sequence 10, J, Q, K, A should return <code>-5 Hold</code>");'
|
||||
- text: 'Seqüência de Cartões 3, 7, Q, 8, A deve retornar <code>-1 Hold</code>'
|
||||
testString: 'assert((function(){ count = 0; cc(3);cc(7);cc("Q");cc(8);var out = cc("A"); if(out === "-1 Hold") {return true;} return false; })(), "Cards Sequence 3, 7, Q, 8, A should return <code>-1 Hold</code>");'
|
||||
- text: 'Cartas Sequência 2, J, 9, 2, 7 devem retornar <code>1 Bet</code>'
|
||||
testString: 'assert((function(){ count = 0; cc(2);cc("J");cc(9);cc(2);var out = cc(7); if(out === "1 Bet") {return true;} return false; })(), "Cards Sequence 2, J, 9, 2, 7 should return <code>1 Bet</code>");'
|
||||
- text: 'Seqüência de Cartões 2, 2, 10 deve retornar <code>1 Bet</code>'
|
||||
testString: 'assert((function(){ count = 0; cc(2);cc(2);var out = cc(10); if(out === "1 Bet") {return true;} return false; })(), "Cards Sequence 2, 2, 10 should return <code>1 Bet</code>");'
|
||||
- text: 'Seqüência de cartas 3, 2, A, 10, K deve retornar <code>-1 Hold</code>'
|
||||
testString: 'assert((function(){ count = 0; cc(3);cc(2);cc("A");cc(10);var out = cc("K"); if(out === "-1 Hold") {return true;} return false; })(), "Cards Sequence 3, 2, A, 10, K should return <code>-1 Hold</code>");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
var count = 0;
|
||||
|
||||
function cc(card) {
|
||||
// Only change code below this line
|
||||
|
||||
|
||||
return "Change Me";
|
||||
// Only change code above this line
|
||||
}
|
||||
|
||||
// Add/remove calls to test your function.
|
||||
// Note: Only the last will display
|
||||
cc(2); cc(3); cc(7); cc('K'); cc('A');
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,61 @@
|
||||
---
|
||||
id: cf1391c1c11feddfaeb4bdef
|
||||
title: Create Decimal Numbers with JavaScript
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Crie números decimais com JavaScript
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Podemos também armazenar números decimais em variáveis. Números decimais às vezes são chamados de números de <dfn>ponto flutuante</dfn> ou <dfn>flutuantes</dfn> . <strong>Nota</strong> <br> Nem todos os números reais podem ser representados com precisão em <dfn>ponto flutuante</dfn> . Isso pode levar a erros de arredondamento. <a href="https://en.wikipedia.org/wiki/Floating_point#Accuracy_problems" target="_blank">Detalhes aqui</a> . </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Crie uma variável <code>myDecimal</code> e dê a ela um valor decimal com uma parte fracionária (por exemplo, <code>5.7</code> ). </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>myDecimal</code> deve ser um número.
|
||||
testString: 'assert(typeof myDecimal === "number", "<code>myDecimal</code> should be a number.");'
|
||||
- text: <code>myDecimal</code> deve ter um ponto decimal
|
||||
testString: 'assert(myDecimal % 1 != 0, "<code>myDecimal</code> should have a decimal point"); '
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
var ourDecimal = 5.7;
|
||||
|
||||
// Only change code below this line
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,60 @@
|
||||
---
|
||||
id: bd7123c9c443eddfaeb5bdef
|
||||
title: Declare JavaScript Variables
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Declarar variáveis JavaScript
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Na ciência da computação, os <dfn>dados</dfn> são tudo o que é significativo para o computador. JavaScript fornece sete <dfn>tipos de dados</dfn> diferentes que são <code>undefined</code> , <code>null</code> , <code>boolean</code> , <code>string</code> , <code>symbol</code> , <code>number</code> e <code>object</code> . Por exemplo, os computadores distinguem entre números, como o número <code>12</code> , e <code>strings</code> , como <code>"12"</code> , <code>"dog"</code> ou <code>"123 cats"</code> , que são conjuntos de caracteres. Os computadores podem realizar operações matemáticas em um número, mas não em uma string. <dfn>As variáveis</dfn> permitem que os computadores armazenem e manipulem dados de maneira dinâmica. Eles fazem isso usando um "rótulo" para apontar os dados em vez de usar os dados em si. Qualquer um dos sete tipos de dados pode ser armazenado em uma variável. <code>Variables</code> são semelhantes às variáveis x e y que você usa em matemática, o que significa que elas são um nome simples para representar os dados aos quais queremos nos referir. As <code>variables</code> computador diferem das variáveis matemáticas, pois podem armazenar valores diferentes em momentos diferentes. Dizemos ao JavaScript para criar ou <dfn>declarar</dfn> uma variável colocando a palavra-chave <code>var</code> na frente dela, assim: <blockquote> var ourName; </blockquote> cria uma <code>variable</code> chamada <code>ourName</code> . Em JavaScript, terminamos as instruções com ponto e vírgula. <code>Variable</code> nomes das <code>Variable</code> podem ser constituídos por números, letras e <code>$</code> ou <code>_</code> , mas não podem conter espaços nem iniciar com um número. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Use a palavra-chave <code>var</code> para criar uma variável chamada <code>myName</code> . <strong>Sugestão</strong> <br> Olhe para o exemplo <code>ourName</code> se você ficar preso. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'Você deve declarar <code>myName</code> com a palavra-chave <code>var</code> , terminando com um ponto-e-vírgula'
|
||||
testString: 'assert(/var\s+myName\s*;/.test(code), "You should declare <code>myName</code> with the <code>var</code> keyword, ending with a semicolon");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
// Example
|
||||
var ourName;
|
||||
|
||||
// Declare myName below this line
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,63 @@
|
||||
---
|
||||
id: bd7123c9c444eddfaeb5bdef
|
||||
title: Declare String Variables
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Declarar Variáveis de Cadeia
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Anteriormente, usamos o código <code>var myName = "your name";</code> <code>"your name"</code> é chamado <dfn>literal de</dfn> <dfn>string</dfn> . É uma string porque é uma série de zero ou mais caracteres entre aspas simples ou duplas. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Crie duas novas variáveis de <code>string</code> : <code>myFirstName</code> e <code>myLastName</code> e atribua a elas os valores de seu primeiro e último nome, respectivamente. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>myFirstName</code> deve ser uma string com pelo menos um caractere.
|
||||
testString: 'assert((function(){if(typeof myFirstName !== "undefined" && typeof myFirstName === "string" && myFirstName.length > 0){return true;}else{return false;}})(), "<code>myFirstName</code> should be a string with at least one character in it.");'
|
||||
- text: <code>myLastName</code> deve ser uma string com pelo menos um caractere.
|
||||
testString: 'assert((function(){if(typeof myLastName !== "undefined" && typeof myLastName === "string" && myLastName.length > 0){return true;}else{return false;}})(), "<code>myLastName</code> should be a string with at least one character in it.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
// Example
|
||||
var firstName = "Alan";
|
||||
var lastName = "Turing";
|
||||
|
||||
// Only change code below this line
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,66 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244ad
|
||||
title: Decrement a Number with JavaScript
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Decrementar um número com JavaScript
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Você pode facilmente <dfn>decrementar</dfn> ou diminuir uma variável por um com o operador <code>--</code> . <code>i--;</code> é o equivalente de <code>i = i - 1;</code> <strong>Nota</strong> <br> A linha inteira se torna <code>i--;</code> , eliminando a necessidade do sinal de igual. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Altere o código para usar o operador <code>--</code> em <code>myVar</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>myVar</code> deve ser igual a <code>10</code>
|
||||
testString: 'assert(myVar === 10, "<code>myVar</code> should equal <code>10</code>");'
|
||||
- text: <code>myVar = myVar - 1;</code> deve ser mudado
|
||||
testString: 'assert(/var\s*myVar\s*=\s*11;\s*\/*.*\s*([-]{2}\s*myVar|myVar\s*[-]{2});/.test(code), "<code>myVar = myVar - 1;</code> should be changed");'
|
||||
- text: Use o <code>--</code> operador em <code>myVar</code>
|
||||
testString: 'assert(/[-]{2}\s*myVar|myVar\s*[-]{2}/.test(code), "Use the <code>--</code> operator on <code>myVar</code>");'
|
||||
- text: Não mude o código acima da linha
|
||||
testString: 'assert(/var myVar = 11;/.test(code), "Do not change code above the line");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
var myVar = 11;
|
||||
|
||||
// Only change code below this line
|
||||
myVar = myVar - 1;
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,79 @@
|
||||
---
|
||||
id: 56bbb991ad1ed5201cd392d3
|
||||
title: Delete Properties from a JavaScript Object
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Excluir propriedades de um objeto JavaScript
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Também podemos excluir propriedades de objetos como este: <code>delete ourDog.bark;</code> </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Exclua a propriedade <code>"tails"</code> do <code>myDog</code> . Você pode usar a notação de pontos ou colchetes. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Exclua a propriedade <code>"tails"</code> do <code>myDog</code> .
|
||||
testString: 'assert(typeof myDog === "object" && myDog.tails === undefined, "Delete the property <code>"tails"</code> from <code>myDog</code>.");'
|
||||
- text: Não modifique a configuração do <code>myDog</code>
|
||||
testString: 'assert(code.match(/"tails": 1/g).length > 1, "Do not modify the <code>myDog</code> setup");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
// Example
|
||||
var ourDog = {
|
||||
"name": "Camper",
|
||||
"legs": 4,
|
||||
"tails": 1,
|
||||
"friends": ["everything!"],
|
||||
"bark": "bow-wow"
|
||||
};
|
||||
|
||||
delete ourDog.bark;
|
||||
|
||||
// Setup
|
||||
var myDog = {
|
||||
"name": "Happy Coder",
|
||||
"legs": 4,
|
||||
"tails": 1,
|
||||
"friends": ["freeCodeCamp Campers"],
|
||||
"bark": "woof"
|
||||
};
|
||||
|
||||
// Only change code below this line.
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,61 @@
|
||||
---
|
||||
id: bd7993c9ca9feddfaeb7bdef
|
||||
title: Divide One Decimal by Another with JavaScript
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Divide um decimal por outro com JavaScript
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Agora vamos dividir um decimal por outro. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Altere o valor <code>0.0</code> para que o <code>quotient</code> seja igual a <code>2.2</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: O <code>quotient</code> variável deve ser igual a <code>2.2</code>
|
||||
testString: 'assert(quotient === 2.2, "The variable <code>quotient</code> should equal <code>2.2</code>");'
|
||||
- text: Você deve usar o operador <code>/</code> para dividir 4.4 por 2
|
||||
testString: 'assert(/4\.40*\s*\/\s*2\.*0*/.test(code), "You should use the <code>/</code> operator to divide 4.4 by 2");'
|
||||
- text: A variável quociente deve ser atribuída apenas uma vez
|
||||
testString: 'assert(code.match(/quotient/g).length === 1, "The quotient variable should only be assigned once");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
var quotient = 0.0 / 2.0; // Fix this line
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,59 @@
|
||||
---
|
||||
id: cf1111c1c11feddfaeb6bdef
|
||||
title: Divide One Number by Another with JavaScript
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Divide um número por outro com JavaScript
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Nós também podemos dividir um número por outro. JavaScript usa o símbolo <code>/</code> para divisão. <p> <strong>Exemplo</strong> </p><blockquote> myVar = 16/2; // atribuído 8 </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Altere <code>0</code> para que o <code>quotient</code> seja igual a <code>2</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Faça o <code>quotient</code> variável igual a 2.
|
||||
testString: 'assert(quotient === 2, "Make the variable <code>quotient</code> equal to 2.");'
|
||||
- text: Use o operador <code>/</code>
|
||||
testString: 'assert(/\d+\s*\/\s*\d+/.test(code), "Use the <code>/</code> operator");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
var quotient = 66 / 0;
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,67 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244b6
|
||||
title: Escape Sequences in Strings
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Seqüências de escape em seqüências de caracteres
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Aspas não são os únicos caracteres que podem ser <dfn>escapados</dfn> dentro de uma string. Há dois motivos para usar caracteres de escape: o primeiro é permitir que você use caracteres que talvez não fossem capazes de digitar, como um backspace. Segundo, permitir que você represente várias aspas em uma string sem que o JavaScript interprete erroneamente o que você quer dizer. Nós aprendemos isso no desafio anterior. <table class="table table-striped"><thead><tr><th> Código </th><th> Saída </th></tr></thead><tbody><tr><td> <code>\'</code> </td> <td> citação única </td></tr><tr><td> <code>\"</code> </td> <td> citação dupla </td></tr><tr><td> <code>\\</code> </td> <td> barra invertida </td></tr><tr><td> <code>\n</code> </td> <td> nova linha </td></tr><tr><td> <code>\r</code> </td> <td> retorno de carro </td></tr><tr><td> <code>\t</code> </td> <td> aba </td></tr><tr><td> <code>\b</code> </td> <td> backspace </td></tr><tr><td> <code>\f</code> </td> <td> feed de formulário </td></tr></tbody></table> <em>Observe que a própria barra invertida deve ter o escape para ser exibida como uma barra invertida.</em> </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Atribuir as seguintes três linhas de texto para a única variável <code>myStr</code> usando seqüências de escape. <blockquote> Primeira linha <br> \Segunda linha <br> ThirdLine </blockquote> Você precisará usar seqüências de escape para inserir caracteres especiais corretamente. Você também precisará seguir o espaçamento como aparece acima, sem espaços entre seqüências de escape ou palavras. Aqui está o texto com as seqüências de escape escritas. <q>FirstLine <code>newline</code> <code>tab</code> <code>backslash</code> SecondLine <code>newline</code> ThirdLine</q> </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>myStr</code> não deve conter espaços
|
||||
testString: 'assert(!/ /.test(myStr), "<code>myStr</code> should not contain any spaces");'
|
||||
- text: '<code>myStr</code> deve conter as strings <code>FirstLine</code> , <code>SecondLine</code> e <code>ThirdLine</code> (lembre-se de <code>ThirdLine</code> maiúsculas e minúsculas)'
|
||||
testString: 'assert(/FirstLine/.test(myStr) && /SecondLine/.test(myStr) && /ThirdLine/.test(myStr), "<code>myStr</code> should contain the strings <code>FirstLine</code>, <code>SecondLine</code> and <code>ThirdLine</code> (remember case sensitivity)");'
|
||||
- text: <code>FirstLine</code> deve ser seguido pelo caractere de nova linha <code>\n</code>
|
||||
testString: 'assert(/FirstLine\n/.test(myStr), "<code>FirstLine</code> should be followed by the newline character <code>\n</code>");'
|
||||
- text: <code>myStr</code> deve conter um caractere de tabulação <code>\t</code> que segue um caractere de nova linha
|
||||
testString: 'assert(/\n\t/.test(myStr), "<code>myStr</code> should contain a tab character <code>\t</code> which follows a newline character");'
|
||||
- text: <code>SecondLine</code> deve ser precedido pelo caractere de barra invertida <code>\\</code>
|
||||
testString: 'assert(/\SecondLine/.test(myStr), "<code>SecondLine</code> should be preceded by the backslash character <code>\\</code>");'
|
||||
- text: Deve haver um caractere de nova linha entre o <code>SecondLine</code> e o <code>ThirdLine</code>
|
||||
testString: 'assert(/SecondLine\nThirdLine/.test(myStr), "There should be a newline character between <code>SecondLine</code> and <code>ThirdLine</code>");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
var myStr; // Change this line
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,59 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244b5
|
||||
title: Escaping Literal Quotes in Strings
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Escapando citações literais em cordas
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Quando você está definindo uma string, você deve começar e terminar com uma aspa simples ou dupla. O que acontece quando você precisa de uma citação literal: <code>"</code> ou <code>'</code> ? Interior de sua corda Em JavaScript, você pode <dfn>escapar de</dfn> uma citação de considerá-lo como um fim de citação corda, colocando uma <dfn>barra invertida</dfn> ( <code>\</code> ) em frente à cotação. <code>var sampleStr = "Alan said, \"Peter is learning JavaScript\".";</code> Isso sinaliza para o JavaScript que a seguinte citação não é o fim da string, mas deve aparecer dentro da string. Então, se você fosse imprimir isso no console, você teria: <code>Alan said, "Peter is learning JavaScript".</code> </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Use <dfn>barras invertidas</dfn> para atribuir uma string à variável <code>myStr</code> , de modo que, se você fosse imprimi-la no console, veria: <code>I am a "double quoted" string inside "double quotes".</code> </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Você deve usar duas aspas duplas ( <code>"</code> ) e quatro aspas duplas com escape ( <code>\"</code> ).
|
||||
testString: 'assert(code.match(/\\"/g).length === 4 && code.match(/[^\\]"/g).length === 2, "You should use two double quotes (<code>"</code>) and four escaped double quotes (<code>\"</code>).");'
|
||||
- text: 'Variável myStr deve conter a string: <code>I am a "double quoted" string inside "double quotes".</code>'
|
||||
testString: 'assert(myStr === "I am a \"double quoted\" string inside \"double quotes\".", "Variable myStr should contain the string: <code>I am a "double quoted" string inside "double quotes".</code>");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
var myStr = ""; // Change this line
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,71 @@
|
||||
---
|
||||
id: bd7123c9c448eddfaeb5bdef
|
||||
title: Find the Length of a String
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Encontre o comprimento de uma string
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Você pode encontrar o comprimento de um valor de <code>String</code> escrevendo <code>.length</code> após a variável de string ou string literal. <code>"Alan Peter".length; // 10</code> Por exemplo, se <code>var firstName = "Charles"</code> uma variável <code>var firstName = "Charles"</code> , poderemos descobrir quanto tempo a string <code>"Charles"</code> está usando a propriedade <code>firstName.length</code> . </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Use a propriedade <code>.length</code> para contar o número de caracteres na variável <code>lastName</code> e atribuí-la a <code>lastNameLength</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>lastNameLength</code> deve ser igual a oito.
|
||||
testString: 'assert((function(){if(typeof lastNameLength !== "undefined" && typeof lastNameLength === "number" && lastNameLength === 8){return true;}else{return false;}})(), "<code>lastNameLength</code> should be equal to eight.");'
|
||||
- text: 'Você deve obter o comprimento de <code>lastName</code> usando <code>.length</code> como este: <code>lastName.length</code> .'
|
||||
testString: 'assert((function(){if(code.match(/\.length/gi) && code.match(/\.length/gi).length >= 2 && code.match(/var lastNameLength \= 0;/gi) && code.match(/var lastNameLength \= 0;/gi).length >= 1){return true;}else{return false;}})(), "You should be getting the length of <code>lastName</code> by using <code>.length</code> like this: <code>lastName.length</code>.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
// Example
|
||||
var firstNameLength = 0;
|
||||
var firstName = "Ada";
|
||||
|
||||
firstNameLength = firstName.length;
|
||||
|
||||
// Setup
|
||||
var lastNameLength = 0;
|
||||
var lastName = "Lovelace";
|
||||
|
||||
// Only change code below this line.
|
||||
|
||||
lastNameLength = lastName;
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,63 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244ae
|
||||
title: Finding a Remainder in JavaScript
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Encontrando um Restante em JavaScript
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> O operador <code>%</code> <dfn>restante</dfn> fornece o restante da divisão de dois números. <strong>Exemplo</strong> <blockquote> 5% 2 = 1 porque <br> Math.floor (5/2) = 2 (Quociente) <br> 2 * 2 = 4 <br> 5 - 4 = 1 (restante) </blockquote> <strong>Uso</strong> <br> Na matemática, um número pode ser verificado para ser par ou ímpar, verificando o restante da divisão do número por <code>2</code> . <blockquote> 17% 2 = 1 (17 é Ímpar) <br> 48% 2 = 0 (48 é mesmo) </blockquote> <strong>Nota</strong> <br> O operador <dfn>restante</dfn> é algumas vezes incorretamente chamado de operador "módulo". É muito semelhante ao módulo, mas não funciona corretamente com números negativos. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Defina o <code>remainder</code> igual ao restante de <code>11</code> dividido por <code>3</code> usando o operador <dfn>restante</dfn> ( <code>%</code> ). </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: A variável <code>remainder</code> deve ser inicializada
|
||||
testString: 'assert(/var\s+?remainder/.test(code), "The variable <code>remainder</code> should be initialized");'
|
||||
- text: O valor do <code>remainder</code> deve ser <code>2</code>
|
||||
testString: 'assert(remainder === 2, "The value of <code>remainder</code> should be <code>2</code>");'
|
||||
- text: Você deve usar o operador <code>%</code>
|
||||
testString: 'assert(/\s+?remainder\s*?=\s*?.*%.*;/.test(code), "You should use the <code>%</code> operator");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
// Only change code below this line
|
||||
|
||||
var remainder;
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,68 @@
|
||||
---
|
||||
id: cf1111c1c11feddfaeb9bdef
|
||||
title: Generate Random Fractions with JavaScript
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Gerar frações aleatórias com JavaScript
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Números aleatórios são úteis para criar um comportamento aleatório. JavaScript tem uma função <code>Math.random()</code> que gera um número decimal aleatório entre <code>0</code> (inclusive) e não chega a <code>1</code> (exclusivo). Assim <code>Math.random()</code> pode retornar um <code>0</code> mas nunca retorna um <code>1</code> <strong>Nota</strong> <br> Assim como <a href="storing-values-with-the-assignment-operator" target="_blank">Armazenando Valores com o Operador Igual</a> , todas as chamadas de função serão resolvidas antes que o <code>return</code> executado, para que possamos <code>return</code> o valor da função <code>Math.random()</code> . </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Altere <code>randomFraction</code> para retornar um número aleatório em vez de retornar <code>0</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>randomFraction</code> deve retornar um número aleatório.
|
||||
testString: 'assert(typeof randomFraction() === "number", "<code>randomFraction</code> should return a random number.");'
|
||||
- text: O número retornado por <code>randomFraction</code> deve ser um decimal.
|
||||
testString: 'assert((randomFraction()+""). match(/\./g), "The number returned by <code>randomFraction</code> should be a decimal.");'
|
||||
- text: Você deve estar usando <code>Math.random</code> para gerar o número decimal aleatório.
|
||||
testString: 'assert(code.match(/Math\.random/g).length >= 0, "You should be using <code>Math.random</code> to generate the random decimal number.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function randomFraction() {
|
||||
|
||||
// Only change code below this line.
|
||||
|
||||
return 0;
|
||||
|
||||
// Only change code above this line.
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,70 @@
|
||||
---
|
||||
id: cf1111c1c12feddfaeb1bdef
|
||||
title: Generate Random Whole Numbers with JavaScript
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Gere números inteiros aleatórios com JavaScript
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> É ótimo podermos gerar números decimais aleatórios, mas é ainda mais útil se usá-lo para gerar números inteiros aleatórios. <ol><li> Use <code>Math.random()</code> para gerar um decimal aleatório. </li><li> Multiplique esse decimal aleatório por <code>20</code> . </li><li> Use outra função, <code>Math.floor()</code> para arredondar o número para o número inteiro mais próximo. </li></ol> Lembre-se que <code>Math.random()</code> nunca pode retornar um <code>1</code> e, porque estamos arredondando para baixo, é impossível realmente obter <code>20</code> . Essa técnica nos dará um número inteiro entre <code>0</code> e <code>19</code> . Colocando tudo junto, é assim que nosso código se parece: <code>Math.floor(Math.random() * 20);</code> Estamos chamando <code>Math.random()</code> , multiplicando o resultado por 20, passando o valor para a função <code>Math.floor()</code> para arredondar o valor para o número inteiro mais próximo. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Use essa técnica para gerar e retornar um número inteiro aleatório entre <code>0</code> e <code>9</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: O resultado de <code>randomWholeNum</code> deve ser um número inteiro.
|
||||
testString: 'assert(typeof randomWholeNum() === "number" && (function(){var r = randomWholeNum();return Math.floor(r) === r;})(), "The result of <code>randomWholeNum</code> should be a whole number.");'
|
||||
- text: Você deve estar usando <code>Math.random</code> para gerar um número aleatório.
|
||||
testString: 'assert(code.match(/Math.random/g).length > 1, "You should be using <code>Math.random</code> to generate a random number.");'
|
||||
- text: Você deve ter multiplicado o resultado de <code>Math.random</code> por 10 para torná-lo um número entre zero e nove.
|
||||
testString: 'assert(code.match(/\s*?Math.random\s*?\(\s*?\)\s*?\*\s*?10[\D]\s*?/g) || code.match(/\s*?10\s*?\*\s*?Math.random\s*?\(\s*?\)\s*?/g), "You should have multiplied the result of <code>Math.random</code> by 10 to make it a number that is between zero and nine.");'
|
||||
- text: Você deve usar <code>Math.floor</code> para remover a parte decimal do número.
|
||||
testString: 'assert(code.match(/Math.floor/g).length > 1, "You should use <code>Math.floor</code> to remove the decimal part of the number.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
var randomNumberBetween0and19 = Math.floor(Math.random() * 20);
|
||||
|
||||
function randomWholeNum() {
|
||||
|
||||
// Only change code below this line.
|
||||
|
||||
return Math.random();
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,80 @@
|
||||
---
|
||||
id: cf1111c1c12feddfaeb2bdef
|
||||
title: Generate Random Whole Numbers within a Range
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Gerar números inteiros aleatórios dentro de um intervalo
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Em vez de gerar um número aleatório entre zero e um dado número, como fizemos antes, podemos gerar um número aleatório que esteja dentro de um intervalo de dois números específicos. Para fazer isso, definiremos um número mínimo <code>min</code> e um número máximo <code>max</code> . Aqui está a fórmula que vamos usar. Tome um momento para lê-lo e tente entender o que este código está fazendo: <code>Math.floor(Math.random() * (max - min + 1)) + min</code> </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Crie uma função chamada <code>randomRange</code> que <code>randomRange</code> um intervalo <code>myMin</code> e <code>myMax</code> e retorne um número aleatório que seja maior ou igual a <code>myMin</code> e seja menor ou igual a <code>myMax</code> , inclusive. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'O menor número aleatório que pode ser gerado por <code>randomRange</code> deve ser igual ao seu número mínimo, <code>myMin</code> .'
|
||||
testString: 'assert(calcMin === 5, "The lowest random number that can be generated by <code>randomRange</code> should be equal to your minimum number, <code>myMin</code>.");'
|
||||
- text: 'O maior número aleatório que pode ser gerado por <code>randomRange</code> deve ser igual ao seu número máximo, <code>myMax</code> .'
|
||||
testString: 'assert(calcMax === 15, "The highest random number that can be generated by <code>randomRange</code> should be equal to your maximum number, <code>myMax</code>.");'
|
||||
- text: 'O número aleatório gerado por <code>randomRange</code> deve ser um inteiro, não um decimal.'
|
||||
testString: 'assert(randomRange(0,1) % 1 === 0 , "The random number generated by <code>randomRange</code> should be an integer, not a decimal.");'
|
||||
- text: <code>randomRange</code> deve usar <code>myMax</code> e <code>myMin</code> e retornar um número aleatório no seu intervalo.
|
||||
testString: 'assert((function(){if(code.match(/myMax/g).length > 1 && code.match(/myMin/g).length > 2 && code.match(/Math.floor/g) && code.match(/Math.random/g)){return true;}else{return false;}})(), "<code>randomRange</code> should use both <code>myMax</code> and <code>myMin</code>, and return a random number in your range.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
// Example
|
||||
function ourRandomRange(ourMin, ourMax) {
|
||||
|
||||
return Math.floor(Math.random() * (ourMax - ourMin + 1)) + ourMin;
|
||||
}
|
||||
|
||||
ourRandomRange(1, 9);
|
||||
|
||||
// Only change code below this line.
|
||||
|
||||
function randomRange(myMin, myMax) {
|
||||
|
||||
return 0; // Change this line
|
||||
|
||||
}
|
||||
|
||||
// Change these values to test your function
|
||||
var myRandom = randomRange(5, 15);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,109 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244be
|
||||
title: Global Scope and Functions
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Âmbito global e funções
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Em JavaScript, o <dfn>escopo</dfn> se refere à visibilidade das variáveis. Variáveis definidas fora de um bloco de funções possuem escopo <dfn>Global</dfn> . Isso significa que eles podem ser vistos em qualquer lugar no seu código JavaScript. As variáveis que são usadas sem a palavra-chave <code>var</code> são criadas automaticamente no escopo <code>global</code> . Isso pode criar consequências indesejadas em outro lugar no seu código ou ao executar uma função novamente. Você deve sempre declarar suas variáveis com <code>var</code> . </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Usando <code>var</code> , declare uma variável <code>global</code> <code>myGlobal</code> fora de qualquer função. Inicialize com um valor de <code>10</code> . Dentro da função <code>fun1</code> , atribua <code>5</code> a <code>oopsGlobal</code> <strong><em>sem</em></strong> usar a palavra-chave <code>var</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>myGlobal</code> deve ser definido
|
||||
testString: 'assert(typeof myGlobal != "undefined", "<code>myGlobal</code> should be defined");'
|
||||
- text: <code>myGlobal</code> deve ter um valor de <code>10</code>
|
||||
testString: 'assert(myGlobal === 10, "<code>myGlobal</code> should have a value of <code>10</code>");'
|
||||
- text: <code>myGlobal</code> deve ser declarado usando a palavra-chave <code>var</code>
|
||||
testString: 'assert(/var\s+myGlobal/.test(code), "<code>myGlobal</code> should be declared using the <code>var</code> keyword");'
|
||||
- text: <code>oopsGlobal</code> deve ser uma variável global e ter um valor de <code>5</code>
|
||||
testString: 'assert(typeof oopsGlobal != "undefined" && oopsGlobal === 5, "<code>oopsGlobal</code> should be a global variable and have a value of <code>5</code>");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
// Declare your variable here
|
||||
|
||||
|
||||
function fun1() {
|
||||
// Assign 5 to oopsGlobal Here
|
||||
|
||||
}
|
||||
|
||||
// Only change code above this line
|
||||
function fun2() {
|
||||
var output = "";
|
||||
if (typeof myGlobal != "undefined") {
|
||||
output += "myGlobal: " + myGlobal;
|
||||
}
|
||||
if (typeof oopsGlobal != "undefined") {
|
||||
output += " oopsGlobal: " + oopsGlobal;
|
||||
}
|
||||
console.log(output);
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
### Before Test
|
||||
<div id='js-setup'>
|
||||
|
||||
```js
|
||||
var logOutput = "";
|
||||
var originalConsole = console
|
||||
function capture() {
|
||||
var nativeLog = console.log;
|
||||
console.log = function (message) {
|
||||
logOutput = message;
|
||||
if(nativeLog.apply) {
|
||||
nativeLog.apply(originalConsole, arguments);
|
||||
} else {
|
||||
var nativeMsg = Array.prototype.slice.apply(arguments).join(' ');
|
||||
nativeLog(nativeMsg);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
function uncapture() {
|
||||
console.log = originalConsole.log;
|
||||
}
|
||||
var oopsGlobal;
|
||||
capture();
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,65 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244c0
|
||||
title: Global vs. Local Scope in Functions
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Escopo global vs. local em funções
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> É possível ter variáveis <dfn>locais</dfn> e <dfn>globais</dfn> com o mesmo nome. Quando você faz isso, a variável <code>local</code> tem precedência sobre a variável <code>global</code> . Neste exemplo: <blockquote> var someVar = "Chapéu"; <br> function myFun () { <br> var someVar = "Head"; <br> return someVar; <br> } </blockquote> A função <code>myFun</code> retornará <code>"Head"</code> porque a versão <code>local</code> da variável está presente. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Adicione uma variável local à função <code>myOutfit</code> para substituir o valor de <code>outerWear</code> por <code>"sweater"</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Não altere o valor do <code>outerWear</code> global
|
||||
testString: 'assert(outerWear === "T-Shirt", "Do not change the value of the global <code>outerWear</code>");'
|
||||
- text: <code>myOutfit</code> deve retornar <code>"sweater"</code>
|
||||
testString: 'assert(myOutfit() === "sweater", "<code>myOutfit</code> should return <code>"sweater"</code>");'
|
||||
- text: Não altere a declaração de retorno
|
||||
testString: 'assert(/return outerWear/.test(code), "Do not change the return statement");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
// Setup
|
||||
var outerWear = "T-Shirt";
|
||||
|
||||
function myOutfit() {
|
||||
// Only change code below this line
|
||||
|
||||
|
||||
|
||||
// Only change code above this line
|
||||
return outerWear;
|
||||
}
|
||||
|
||||
myOutfit();
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,80 @@
|
||||
---
|
||||
id: 5664820f61c48e80c9fa476c
|
||||
title: Golf Code
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Código de Golfe
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> No jogo de <a href="https://en.wikipedia.org/wiki/Golf" target="_blank">golfe,</a> cada buraco tem um <code>par</code> significa o número médio de <code>strokes</code> um golfista deve fazer para afundar a bola em um buraco para completar a jogada. Dependendo de quão longe acima ou abaixo <code>par</code> seus <code>strokes</code> são, há um apelido diferente. Sua função receberá argumentos <code>par</code> e <code>strokes</code> . Retorna a string correta de acordo com esta tabela que lista os traços em ordem de prioridade; topo (maior) para baixo (menor): <table class="table table-striped"><thead><tr><th> Traços </th><th> Retorna </th></tr></thead><tbody><tr><td> 1 </td><td> "Buraco-em-um!" </td></tr><tr><td> <= par - 2 </td><td> "Águia" </td></tr><tr><td> par - 1 </td><td> "Passarinho" </td></tr><tr><td> par </td><td> "Par" </td></tr><tr><td> par + 1 </td><td> "Bogey" </td></tr><tr><td> par + 2 </td><td> "Bogey Duplo" </td></tr><tr><td> > par + 3 </td><td> "Ir para casa!" </td></tr></tbody></table> <code>par</code> e <code>strokes</code> serão sempre numéricos e positivos. Nós adicionamos uma matriz de todos os nomes para sua conveniência. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: '<code>golfScore(4, 1)</code> deve retornar "Hole-in-one!"'
|
||||
testString: 'assert(golfScore(4, 1) === "Hole-in-one!", "<code>golfScore(4, 1)</code> should return "Hole-in-one!"");'
|
||||
- text: '<code>golfScore(4, 2)</code> deve retornar "Eagle"'
|
||||
testString: 'assert(golfScore(4, 2) === "Eagle", "<code>golfScore(4, 2)</code> should return "Eagle"");'
|
||||
- text: '<code>golfScore(5, 2)</code> deve retornar "Eagle"'
|
||||
testString: 'assert(golfScore(5, 2) === "Eagle", "<code>golfScore(5, 2)</code> should return "Eagle"");'
|
||||
- text: '<code>golfScore(4, 3)</code> deve retornar "Birdie"'
|
||||
testString: 'assert(golfScore(4, 3) === "Birdie", "<code>golfScore(4, 3)</code> should return "Birdie"");'
|
||||
- text: '<code>golfScore(4, 4)</code> deve retornar "Par"'
|
||||
testString: 'assert(golfScore(4, 4) === "Par", "<code>golfScore(4, 4)</code> should return "Par"");'
|
||||
- text: '<code>golfScore(1, 1)</code> deve retornar "Hole-in-one!"'
|
||||
testString: 'assert(golfScore(1, 1) === "Hole-in-one!", "<code>golfScore(1, 1)</code> should return "Hole-in-one!"");'
|
||||
- text: '<code>golfScore(5, 5)</code> deve retornar "Par"'
|
||||
testString: 'assert(golfScore(5, 5) === "Par", "<code>golfScore(5, 5)</code> should return "Par"");'
|
||||
- text: '<code>golfScore(4, 5)</code> deve retornar "Bogey"'
|
||||
testString: 'assert(golfScore(4, 5) === "Bogey", "<code>golfScore(4, 5)</code> should return "Bogey"");'
|
||||
- text: '<code>golfScore(4, 6)</code> deve retornar "Double Bogey"'
|
||||
testString: 'assert(golfScore(4, 6) === "Double Bogey", "<code>golfScore(4, 6)</code> should return "Double Bogey"");'
|
||||
- text: '<code>golfScore(4, 7)</code> deve retornar "Go Home!"'
|
||||
testString: 'assert(golfScore(4, 7) === "Go Home!", "<code>golfScore(4, 7)</code> should return "Go Home!"");'
|
||||
- text: '<code>golfScore(5, 9)</code> deve retornar "Go Home!"'
|
||||
testString: 'assert(golfScore(5, 9) === "Go Home!", "<code>golfScore(5, 9)</code> should return "Go Home!"");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
var names = ["Hole-in-one!", "Eagle", "Birdie", "Par", "Bogey", "Double Bogey", "Go Home!"];
|
||||
function golfScore(par, strokes) {
|
||||
// Only change code below this line
|
||||
|
||||
|
||||
return "Change Me";
|
||||
// Only change code above this line
|
||||
}
|
||||
|
||||
// Change these values to test
|
||||
golfScore(5, 4);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,66 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244ac
|
||||
title: Increment a Number with JavaScript
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Incrementar um número com JavaScript
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Você pode facilmente <dfn>incrementar</dfn> ou adicionar um a uma variável com o operador <code>++</code> . <code>i++;</code> é o equivalente de <code>i = i + 1;</code> <strong>Nota</strong> <br> A linha inteira se torna <code>i++;</code> , eliminando a necessidade do sinal de igual. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Altere o código para usar o operador <code>++</code> em <code>myVar</code> . <strong>Sugestão</strong> <br> Saiba mais sobre <a href="https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Increment_()" target="_blank">operadores aritméticos - Incremento (++)</a> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>myVar</code> deve ser igual a <code>88</code>
|
||||
testString: 'assert(myVar === 88, "<code>myVar</code> should equal <code>88</code>");'
|
||||
- text: <code>myVar = myVar + 1;</code> deve ser mudado
|
||||
testString: 'assert(/var\s*myVar\s*=\s*87;\s*\/*.*\s*([+]{2}\s*myVar|myVar\s*[+]{2});/.test(code), "<code>myVar = myVar + 1;</code> should be changed");'
|
||||
- text: Use o operador <code>++</code>
|
||||
testString: 'assert(/[+]{2}\s*myVar|myVar\s*[+]{2}/.test(code), "Use the <code>++</code> operator");'
|
||||
- text: Não mude o código acima da linha
|
||||
testString: 'assert(/var myVar = 87;/.test(code), "Do not change code above the line");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
var myVar = 87;
|
||||
|
||||
// Only change code below this line
|
||||
myVar = myVar + 1;
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,60 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244a9
|
||||
title: Initializing Variables with the Assignment Operator
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Inicializando Variáveis com o Operador de Atribuição
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> É comum <dfn>inicializar</dfn> uma variável com um valor inicial na mesma linha que é declarada. <code>var myVar = 0;</code> Cria uma nova variável chamada <code>myVar</code> e atribui a ela um valor inicial de <code>0</code> . </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Defina uma variável <code>a</code> com <code>var</code> e inicialize-a com um valor de <code>9</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Inicialize <code>a</code> para um valor de <code>9</code>
|
||||
testString: 'assert(/var\s+a\s*=\s*9\s*/.test(code), "Initialize <code>a</code> to a value of <code>9</code>");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
// Example
|
||||
var ourVar = 19;
|
||||
|
||||
// Only change code below this line
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,76 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244db
|
||||
title: Introducing Else If Statements
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Apresentando Else If Statements
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Se você tiver várias condições que precisam ser tratadas, você pode encadear instruções <code>if</code> junto com <code>else if</code> statements. <blockquote> if (num> 15) { <br> return "Maior que 15"; <br> } else if (num <5) { <br> return "Menor do que 5"; <br> } outro { <br> return "entre 5 e 15"; <br> } </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Converta a lógica para usar <code>else if</code> statements. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Você deve ter pelo menos dois <code>else</code> declarações
|
||||
testString: 'assert(code.match(/else/g).length > 1, "You should have at least two <code>else</code> statements");'
|
||||
- text: Você deve ter pelo menos duas declarações <code>if</code>
|
||||
testString: 'assert(code.match(/if/g).length > 1, "You should have at least two <code>if</code> statements");'
|
||||
- text: Você deve fechar e abrir chaves para cada condição
|
||||
testString: 'assert(code.match(/if\s*\((.+)\)\s*\{[\s\S]+\}\s*else if\s*\((.+)\)\s*\{[\s\S]+\}\s*else\s*\{[\s\S]+\s*\}/), "You should have closing and opening curly braces for each condition in your if else statement");'
|
||||
- text: <code>testElseIf(0)</code> deve retornar "Menor que 5"
|
||||
testString: 'assert(testElseIf(0) === "Smaller than 5", "<code>testElseIf(0)</code> should return "Smaller than 5"");'
|
||||
- text: <code>testElseIf(5)</code> deve retornar "entre 5 e 10"
|
||||
testString: 'assert(testElseIf(5) === "Between 5 and 10", "<code>testElseIf(5)</code> should return "Between 5 and 10"");'
|
||||
- text: <code>testElseIf(7)</code> deve retornar "entre 5 e 10"
|
||||
testString: 'assert(testElseIf(7) === "Between 5 and 10", "<code>testElseIf(7)</code> should return "Between 5 and 10"");'
|
||||
- text: <code>testElseIf(10)</code> deve retornar "entre 5 e 10"
|
||||
testString: 'assert(testElseIf(10) === "Between 5 and 10", "<code>testElseIf(10)</code> should return "Between 5 and 10"");'
|
||||
- text: <code>testElseIf(12)</code> deve retornar "Maior que 10"
|
||||
testString: 'assert(testElseIf(12) === "Greater than 10", "<code>testElseIf(12)</code> should return "Greater than 10"");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function testElseIf(val) {
|
||||
if (val > 10) {
|
||||
return "Greater than 10";
|
||||
}
|
||||
|
||||
if (val < 5) {
|
||||
return "Smaller than 5";
|
||||
}
|
||||
|
||||
return "Between 5 and 10";
|
||||
}
|
||||
|
||||
// Change this value to test
|
||||
testElseIf(7);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,78 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244da
|
||||
title: Introducing Else Statements
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Apresentando Else Statements
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Quando uma condição para uma declaração <code>if</code> for verdadeira, o bloco de código que a segue é executado. E quando essa condição é falsa? Normalmente nada aconteceria. Com uma instrução <code>else</code> , um bloco de código alternativo pode ser executado. <blockquote> if (num> 10) { <br> return "Maior que 10"; <br> } outro { <br> return "10 ou menos"; <br> } </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Combine as instruções <code>if</code> em uma única instrução <code>if/else</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Você deve ter apenas uma declaração <code>if</code> no editor
|
||||
testString: 'assert(code.match(/if/g).length === 1, "You should only have one <code>if</code> statement in the editor");'
|
||||
- text: Você deveria usar uma instrução <code>else</code>
|
||||
testString: 'assert(/else/g.test(code), "You should use an <code>else</code> statement");'
|
||||
- text: <code>testElse(4)</code> deve retornar "5 ou menor"
|
||||
testString: 'assert(testElse(4) === "5 or Smaller", "<code>testElse(4)</code> should return "5 or Smaller"");'
|
||||
- text: <code>testElse(5)</code> deve retornar "5 ou menor"
|
||||
testString: 'assert(testElse(5) === "5 or Smaller", "<code>testElse(5)</code> should return "5 or Smaller"");'
|
||||
- text: <code>testElse(6)</code> deve retornar "maior que 5"
|
||||
testString: 'assert(testElse(6) === "Bigger than 5", "<code>testElse(6)</code> should return "Bigger than 5"");'
|
||||
- text: <code>testElse(10)</code> deve retornar "maior que 5"
|
||||
testString: 'assert(testElse(10) === "Bigger than 5", "<code>testElse(10)</code> should return "Bigger than 5"");'
|
||||
- text: Não mude o código acima ou abaixo das linhas.
|
||||
testString: 'assert(/var result = "";/.test(code) && /return result;/.test(code), "Do not change the code above or below the lines.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function testElse(val) {
|
||||
var result = "";
|
||||
// Only change code below this line
|
||||
|
||||
if (val > 5) {
|
||||
result = "Bigger than 5";
|
||||
}
|
||||
|
||||
if (val <= 5) {
|
||||
result = "5 or Smaller";
|
||||
}
|
||||
|
||||
// Only change code above this line
|
||||
return result;
|
||||
}
|
||||
|
||||
// Change this value to test
|
||||
testElse(4);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,69 @@
|
||||
---
|
||||
id: 56104e9e514f539506016a5c
|
||||
title: Iterate Odd Numbers With a For Loop
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Iterar números ímpares com um loop for
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Para laços não tem que iterar um de cada vez. Ao alterar nossa <code>final-expression</code> , podemos contar por números pares. Começaremos em <code>i = 0</code> e em loop enquanto <code>i < 10</code> . Vamos incrementar <code>i</code> por 2 cada loop com <code>i += 2</code> . <blockquote> var ourArray = []; <br> para (var i = 0; i <10; i + = 2) { <br> ourArray.push (i); <br> } </blockquote> <code>ourArray</code> irá agora conter <code>[0,2,4,6,8]</code> . Vamos mudar a nossa <code>initialization</code> para que possamos contar por números ímpares. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Empurre os números ímpares de 1 a 9 para <code>myArray</code> usando um loop <code>for</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Você deve estar usando um <code>for</code> loop para isso.
|
||||
testString: 'assert(code.match(/for\s*\(/g).length > 1, "You should be using a <code>for</code> loop for this.");'
|
||||
- text: '<code>myArray</code> deve ser igual a <code>[1,3,5,7,9]</code> .'
|
||||
testString: 'assert.deepEqual(myArray, [1,3,5,7,9], "<code>myArray</code> should equal <code>[1,3,5,7,9]</code>.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
// Example
|
||||
var ourArray = [];
|
||||
|
||||
for (var i = 0; i < 10; i += 2) {
|
||||
ourArray.push(i);
|
||||
}
|
||||
|
||||
// Setup
|
||||
var myArray = [];
|
||||
|
||||
// Only change code below this line.
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,74 @@
|
||||
---
|
||||
id: 5675e877dbd60be8ad28edc6
|
||||
title: Iterate Through an Array with a For Loop
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Iterar por meio de uma matriz com um loop for
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Uma tarefa comum em JavaScript é fazer uma iteração no conteúdo de uma matriz. Uma maneira de fazer isso é com um loop <code>for</code> . Este código irá mostrar cada elemento da array <code>arr</code> para o console: <blockquote> var arr = [10,9,8,7,6]; <br> para (var i = 0; i <arr.length; i ++) { <br> console.log (arr [i]); <br> } </blockquote> Lembre-se que os Arrays possuem numeração baseada em zero, o que significa que o último índice do array é length - 1. Nossa <dfn>condição</dfn> para este loop é <code>i < arr.length</code> , que para quando <code>i</code> tiver comprimento - 1. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Declare e inicialize um <code>total</code> variáveis para <code>0</code> . Use um loop <code>for</code> para adicionar o valor de cada elemento da matriz <code>myArr</code> ao <code>total</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>total</code> deve ser declarado e inicializado para 0
|
||||
testString: 'assert(code.match(/var.*?total\s*=\s*0.*?;/), "<code>total</code> should be declared and initialized to 0");'
|
||||
- text: <code>total</code> deve ser igual a 20
|
||||
testString: 'assert(total === 20, "<code>total</code> should equal 20");'
|
||||
- text: Você deve usar um loop <code>for</code> para iterar pelo <code>myArr</code>
|
||||
testString: 'assert(code.match(/for\s*\(/g).length > 1 && code.match(/myArr\s*\[/), "You should use a <code>for</code> loop to iterate through <code>myArr</code>");'
|
||||
- text: Não defina o <code>total</code> para 20 diretamente
|
||||
testString: 'assert(!code.match(/total[\s\+\-]*=\s*(\d(?!\s*[;,])|[1-9])/g), "Do not set <code>total</code> to 20 directly");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
// Example
|
||||
var ourArr = [ 9, 10, 11, 12];
|
||||
var ourTotal = 0;
|
||||
|
||||
for (var i = 0; i < ourArr.length; i++) {
|
||||
ourTotal += ourArr[i];
|
||||
}
|
||||
|
||||
// Setup
|
||||
var myArr = [ 2, 3, 4, 5, 6];
|
||||
|
||||
// Only change code below this line
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,70 @@
|
||||
---
|
||||
id: 5a2efd662fb457916e1fe604
|
||||
title: Iterate with JavaScript Do...While Loops
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Iterar com JavaScript Do ... While Loops
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Você pode executar o mesmo código várias vezes usando um loop. O próximo tipo de loop que você aprenderá é chamado de loop " <code>do...while</code> " porque primeiro ele " <code>do</code> " uma passagem do código dentro do loop, não importa o que aconteça, e então executa " <code>while</code> " uma condição especificada é verdadeira e pára assim que a condição não for mais verdadeira. Vamos ver um exemplo. <blockquote> var ourArray = []; <br> var i = 0; <br> Faz { <br> ourArray.push (i); <br> i ++; <br> } enquanto (i <5); </blockquote> Isso se comporta exatamente como você esperaria com qualquer outro tipo de loop, e a matriz resultante será semelhante a <code>[0, 1, 2, 3, 4]</code> . No entanto, o que faz o <code>do...while</code> diferente de outros loops é como ele se comporta quando a condição falha na primeira verificação. Vamos ver isso em ação. Aqui está um loop regular que executará o código no loop desde que <code>i < 5</code> . <blockquote> var ourArray = []; <br> var i = 5; <br> enquanto (i <5) { <br> ourArray.push (i); <br> i ++; <br> } </blockquote> Observe que inicializamos o valor de <code>i</code> como sendo 5. Quando executamos a próxima linha, notamos que <code>i</code> não é menor que 5. Portanto, não executamos o código dentro do loop. O resultado é que o <code>ourArray</code> terá nada adicionado a ele, então ele ainda ficará assim <code>[]</code> quando todo o código no exemplo acima terminar de ser executado. Agora, dê uma olhada em um <code>do...while</code> loop. <blockquote> var ourArray = []; <br> var i = 5; <br> Faz { <br> ourArray.push (i); <br> i ++; <br> } enquanto (i <5); </blockquote> Neste caso, inicializamos o valor de <code>i</code> como 5, assim como fizemos com o loop while. Quando chegamos à próxima linha, não há verificação para o valor de <code>i</code> , então vamos para o código dentro das chaves e executá-lo. Vamos adicionar um elemento à matriz e incrementar <code>i</code> antes de chegarmos à verificação de condição. Então, quando chegarmos a verificar se <code>i < 5</code> ver que <code>i</code> agora é 6, o que falha na verificação condicional. Então, saímos do loop e acabamos. No final do exemplo acima, o valor de <code>ourArray</code> é <code>[5]</code> . Essencialmente, um laço <code>do...while</code> while garante que o código dentro do loop será executado pelo menos uma vez. Vamos tentar fazer um <code>do...while</code> loop para trabalhar, empurrando valores para um array. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Alterar o <code>while</code> loop no código a um <code>do...while</code> loop para que o loop vai empurrar o número 10 a <code>myArray</code> , e <code>i</code> será igual a <code>11</code> quando o código termina a execução. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Você deveria estar usando um <code>do...while</code> loop para isso.
|
||||
testString: 'assert(code.match(/do/g), "You should be using a <code>do...while</code> loop for this.");'
|
||||
- text: '<code>myArray</code> deve ser igual a <code>[10]</code> .'
|
||||
testString: 'assert.deepEqual(myArray, [10], "<code>myArray</code> should equal <code>[10]</code>.");'
|
||||
- text: <code>i</code> deveria igual a <code>11</code>
|
||||
testString: 'assert.deepEqual(i, 11, "<code>i</code> should equal <code>11</code>");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
// Setup
|
||||
var myArray = [];
|
||||
var i = 10;
|
||||
|
||||
// Only change code below this line.
|
||||
|
||||
while (i < 5) {
|
||||
myArray.push(i);
|
||||
i++;
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,69 @@
|
||||
---
|
||||
id: cf1111c1c11feddfaeb5bdef
|
||||
title: Iterate with JavaScript For Loops
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Iterar com JavaScript For Loops
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Você pode executar o mesmo código várias vezes usando um loop. O tipo mais comum de loop de JavaScript é chamado de " <code>for loop</code> " porque é executado "por" um número específico de vezes. For loops são declarados com três expressões opcionais separadas por ponto e vírgula: <code>for ([initialization]; [condition]; [final-expression])</code> A instrução de <code>initialization</code> é executada uma vez apenas antes do loop iniciar. É normalmente usado para definir e configurar sua variável de loop. A instrução de <code>condition</code> é avaliada no início de cada iteração de loop e continuará enquanto ela for avaliada como <code>true</code> . Quando a <code>condition</code> é <code>false</code> no início da iteração, o loop deixará de ser executado. Isso significa que se a <code>condition</code> começar como <code>false</code> , seu loop nunca será executado. A <code>final-expression</code> é executada no final de cada iteração de loop, antes da próxima verificação de <code>condition</code> e é geralmente usada para incrementar ou decrementar seu contador de loop. No exemplo a seguir, inicializamos com <code>i = 0</code> e iteramos enquanto nossa condição <code>i < 5</code> é verdadeira. Vamos incrementar <code>i</code> por <code>1</code> em cada iteração de loop com o <code>i++</code> como nossa <code>final-expression</code> . <blockquote> var ourArray = []; <br> para (var i = 0; i <5; i ++) { <br> ourArray.push (i); <br> } </blockquote> <code>ourArray</code> irá agora conter <code>[0,1,2,3,4]</code> . </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Use um loop <code>for</code> para trabalhar para empurrar os valores de 1 a 5 para <code>myArray</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Você deve estar usando um <code>for</code> loop para isso.
|
||||
testString: 'assert(code.match(/for\s*\(/g).length > 1, "You should be using a <code>for</code> loop for this.");'
|
||||
- text: '<code>myArray</code> deve ser igual a <code>[1,2,3,4,5]</code> .'
|
||||
testString: 'assert.deepEqual(myArray, [1,2,3,4,5], "<code>myArray</code> should equal <code>[1,2,3,4,5]</code>.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
// Example
|
||||
var ourArray = [];
|
||||
|
||||
for (var i = 0; i < 5; i++) {
|
||||
ourArray.push(i);
|
||||
}
|
||||
|
||||
// Setup
|
||||
var myArray = [];
|
||||
|
||||
// Only change code below this line.
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,62 @@
|
||||
---
|
||||
id: cf1111c1c11feddfaeb1bdef
|
||||
title: Iterate with JavaScript While Loops
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Iterar com loops While de JavaScript
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Você pode executar o mesmo código várias vezes usando um loop. O primeiro tipo de loop vamos aprender é chamado de " <code>while</code> " laço porque ele é executado "enquanto" uma condição especificada for verdadeira e pára uma vez que a condição já não é verdade. <blockquote> var ourArray = []; <br> var i = 0; <br> enquanto (i <5) { <br> ourArray.push (i); <br> i ++; <br> } </blockquote> Vamos tentar fazer um loop while funcionar empurrando valores para um array. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Empurrar os números de 0 a 4 para <code>myArray</code> usando uma <code>while</code> loop. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Você deve estar usando um <code>while</code> loop para isso.
|
||||
testString: 'assert(code.match(/while/g), "You should be using a <code>while</code> loop for this.");'
|
||||
- text: '<code>myArray</code> deve ser igual a <code>[0,1,2,3,4]</code> .'
|
||||
testString: 'assert.deepEqual(myArray, [0,1,2,3,4], "<code>myArray</code> should equal <code>[0,1,2,3,4]</code>.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
// Setup
|
||||
var myArray = [];
|
||||
|
||||
// Only change code below this line.
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,96 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244bf
|
||||
title: Local Scope and Functions
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Escopo Local e Funções
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Variáveis que são declaradas dentro de uma função, assim como os parâmetros da função, possuem escopo <dfn>local</dfn> . Isso significa que eles só são visíveis dentro dessa função. Aqui está uma função <code>myTest</code> com uma variável local chamada <code>loc</code> . <blockquote> function myTest () { <br> var loc = "foo"; <br> console.log (loc); <br> } <br> meu teste(); // registra "foo" <br> console.log (loc); // loc não está definido </blockquote> <code>loc</code> não está definido fora da função. </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Declare uma variável local <code>myVar</code> dentro de <code>myLocalScope</code> . Execute os testes e siga as instruções comentadas no editor. <strong>Sugestão</strong> <br> Atualizando a página pode ajudar se você ficar preso. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: Nenhuma variável <code>myVar</code> global
|
||||
testString: 'assert(typeof myVar === "undefined", "No global <code>myVar</code> variable");'
|
||||
- text: Adicione uma variável <code>myVar</code> local
|
||||
testString: 'assert(/var\s+myVar/.test(code), "Add a local <code>myVar</code> variable");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function myLocalScope() {
|
||||
'use strict'; // you shouldn't need to edit this line
|
||||
|
||||
console.log(myVar);
|
||||
}
|
||||
myLocalScope();
|
||||
|
||||
// Run and check the console
|
||||
// myVar is not defined outside of myLocalScope
|
||||
console.log(myVar);
|
||||
|
||||
// Now remove the console log line to pass the test
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
### Before Test
|
||||
<div id='js-setup'>
|
||||
|
||||
```js
|
||||
var logOutput = "";
|
||||
var originalConsole = console
|
||||
function capture() {
|
||||
var nativeLog = console.log;
|
||||
console.log = function (message) {
|
||||
logOutput = message;
|
||||
if(nativeLog.apply) {
|
||||
nativeLog.apply(originalConsole, arguments);
|
||||
} else {
|
||||
var nativeMsg = Array.prototype.slice.apply(arguments).join(' ');
|
||||
nativeLog(nativeMsg);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
function uncapture() {
|
||||
console.log = originalConsole.log;
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,64 @@
|
||||
---
|
||||
id: 5690307fddb111c6084545d7
|
||||
title: Logical Order in If Else Statements
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Ordem lógica em outras declarações
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Ordem é importante em <code>if</code> , <code>else if</code> declarações. A função é executada de cima para baixo, então você vai querer ter cuidado com a afirmação que vem primeiro. Tome estas duas funções como um exemplo. Aqui está o primeiro: <blockquote> função foo (x) { <br> if (x <1) { <br> return "menos de um"; <br> } else if (x <2) { <br> return "menos de dois"; <br> } outro { <br> return "Maior que ou igual a dois"; <br> } <br> } </blockquote> E o segundo apenas muda a ordem das declarações: <blockquote> barra de funções (x) { <br> if (x <2) { <br> return "menos de dois"; <br> } else if (x <1) { <br> return "menos de um"; <br> } outro { <br> return "Maior que ou igual a dois"; <br> } <br> } </blockquote> Embora essas duas funções pareçam quase idênticas, se passarmos um número para ambas, obteremos saídas diferentes. <blockquote> foo (0) // "Menos que um" <br> bar (0) // "menos de dois" </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Altere a ordem da lógica na função para que ela retorne as instruções corretas em todos os casos. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: <code>orderMyLogic(4)</code> deve retornar "Menos de 5"
|
||||
testString: 'assert(orderMyLogic(4) === "Less than 5", "<code>orderMyLogic(4)</code> should return "Less than 5"");'
|
||||
- text: <code>orderMyLogic(6)</code> deve retornar "Menor que 10"
|
||||
testString: 'assert(orderMyLogic(6) === "Less than 10", "<code>orderMyLogic(6)</code> should return "Less than 10"");'
|
||||
- text: <code>orderMyLogic(11)</code> deve retornar "maior que ou igual a 10"
|
||||
testString: 'assert(orderMyLogic(11) === "Greater than or equal to 10", "<code>orderMyLogic(11)</code> should return "Greater than or equal to 10"");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
function orderMyLogic(val) {
|
||||
if (val < 10) {
|
||||
return "Less than 10";
|
||||
} else if (val < 5) {
|
||||
return "Less than 5";
|
||||
} else {
|
||||
return "Greater than or equal to 10";
|
||||
}
|
||||
}
|
||||
|
||||
// Change this value to test
|
||||
orderMyLogic(7);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,70 @@
|
||||
---
|
||||
id: 56bbb991ad1ed5201cd392cc
|
||||
title: Manipulate Arrays With pop()
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Manipular Arrays Com pop ()
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Outra maneira de alterar os dados em uma matriz é com a função <code>.pop()</code> . <code>.pop()</code> é usado para "pop" um valor fora do final de uma matriz. Podemos armazenar esse valor "popped off", atribuindo-o a uma variável. Em outras palavras, <code>.pop()</code> remove o último elemento de uma matriz e retorna esse elemento. Qualquer tipo de entrada pode ser "popped" fora de um array - números, strings, até matrizes aninhadas. <blockquote> <code>var threeArr = [1, 4, 6]; <br> var oneDown = threeArr.pop(); <br> console.log(oneDown); // Returns 6 <br> console.log(threeArr); // Returns [1, 4]</code> </blockquote> </section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Use a função <code>.pop()</code> para remover o último item de <code>myArray</code> , atribuindo o valor "popped off" ao <code>removedFromMyArray</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: '<code>myArray</code> deve conter apenas <code>[["John", 23]]</code> .'
|
||||
testString: 'assert((function(d){if(d[0][0] == "John" && d[0][1] === 23 && d[1] == undefined){return true;}else{return false;}})(myArray), "<code>myArray</code> should only contain <code>[["John", 23]]</code>.");'
|
||||
- text: Use <code>pop()</code> no <code>myArray</code>
|
||||
testString: 'assert(/removedFromMyArray\s*=\s*myArray\s*.\s*pop\s*(\s*)/.test(code), "Use <code>pop()</code> on <code>myArray</code>");'
|
||||
- text: '<code>removedFromMyArray</code> deve conter apenas <code>["cat", 2]</code> .'
|
||||
testString: 'assert((function(d){if(d[0] == "cat" && d[1] === 2 && d[2] == undefined){return true;}else{return false;}})(removedFromMyArray), "<code>removedFromMyArray</code> should only contain <code>["cat", 2]</code>.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
// Example
|
||||
var ourArray = [1,2,3];
|
||||
var removedFromOurArray = ourArray.pop();
|
||||
// removedFromOurArray now equals 3, and ourArray now equals [1,2]
|
||||
|
||||
// Setup
|
||||
var myArray = [["John", 23], ["cat", 2]];
|
||||
|
||||
// Only change code below this line.
|
||||
var removedFromMyArray;
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
@ -0,0 +1,65 @@
|
||||
---
|
||||
id: 56bbb991ad1ed5201cd392cb
|
||||
title: Manipulate Arrays With push()
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Manipular matrizes com push ()
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id="description"> Uma maneira fácil de anexar dados ao final de um array é por meio da função <code>push()</code> . <code>.push()</code> recebe um ou mais <dfn>parâmetros</dfn> e os "empurra" para o final do array. <blockquote> var arr = [1,2,3]; <br> arr.push (4); <br> // arr é agora [1,2,3,4] </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id="instructions"> Empurre <code>["dog", 3]</code> para o final da variável <code>myArray</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: '<code>myArray</code> agora deve ser igual a <code>[["John", 23], ["cat", 2], ["dog", 3]]</code> .'
|
||||
testString: 'assert((function(d){if(d[2] != undefined && d[0][0] == "John" && d[0][1] === 23 && d[2][0] == "dog" && d[2][1] === 3 && d[2].length == 2){return true;}else{return false;}})(myArray), "<code>myArray</code> should now equal <code>[["John", 23], ["cat", 2], ["dog", 3]]</code>.");'
|
||||
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
## Challenge Seed
|
||||
<section id='challengeSeed'>
|
||||
|
||||
<div id='js-seed'>
|
||||
|
||||
```js
|
||||
// Example
|
||||
var ourArray = ["Stimpson", "J", "cat"];
|
||||
ourArray.push(["happy", "joy"]);
|
||||
// ourArray now equals ["Stimpson", "J", "cat", ["happy", "joy"]]
|
||||
|
||||
// Setup
|
||||
var myArray = [["John", 23], ["cat", 2]];
|
||||
|
||||
// Only change code below this line.
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
|
||||
### After Test
|
||||
<div id='js-teardown'>
|
||||
|
||||
```js
|
||||
console.info('after the test');
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
</section>
|
||||
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
```js
|
||||
// solution required
|
||||
```
|
||||
</section>
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user