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,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>
|
||||
Reference in New Issue
Block a user