chore(i18n,curriculum): update translations (#43018)
This commit is contained in:
camperbot
GitHub
@ -11,7 +11,7 @@ dashedName: access-array-data-with-indexes
|
||||
|
||||
Podemos acessar os dados dentro de arrays usando <dfn>indexes</dfn>.
|
||||
|
||||
Os índices de um array são escritos na mesma notação com colchetes que as strings usam, exceto que em vez de especificar um caractere, eles estão especificando um item do array. Assim como com strings, arrays usam indexação <dfn>zero-based</dfn>, de forma que o primeiro elemento de um array possui índice `0`.
|
||||
Os índices de um array são escritos na mesma notação com colchetes que as strings usam. Porém, em vez de especificar um caractere, eles estão especificando um item do array. Assim como ocorre com as strings, os arrays usam indexação <dfn>de base zero</dfn>, de forma que o primeiro elemento de um array possui índice `0`.
|
||||
|
||||
<br>
|
||||
|
||||
@ -25,7 +25,7 @@ var data = array[1];
|
||||
|
||||
`array[0]` agora é `50` e `data` tem o valor `60`.
|
||||
|
||||
**Nota:** Não deve haver nenhum espaço entre o nome do array e os colchetes, como `array [0]`. Embora JavaScript seja capaz de processar isso corretamente, isso pode confundir outros programadores lendo seu código.
|
||||
**Observação:** não deve haver nenhum espaço entre o nome do array e os colchetes, como `array [0]`. Embora JavaScript seja capaz de processar isso corretamente, isso pode confundir outros programadores lendo seu código.
|
||||
|
||||
# --instructions--
|
||||
|
||||
|
||||
@ -9,7 +9,7 @@ dashedName: access-multi-dimensional-arrays-with-indexes
|
||||
|
||||
# --description--
|
||||
|
||||
Uma maneira de pensar em um array <dfn>multi-dimensional</dfn> é como um *array de arrays*. Quando você usa colchetes para acessar seu array, o primeiro conjunto de colchetes se refere às entradas no array mais exterior (o primeiro nível), e cada par adicional de colchetes refere-se ao próximo nível de entradas interno.
|
||||
Uma maneira de pensar em um array <dfn>multidimensional</dfn> é como um *array de arrays*. Quando você usa colchetes para acessar seu array, o primeiro conjunto de colchetes se refere às entradas no array mais exterior (o primeiro nível), e cada par adicional de colchetes refere-se ao próximo nível de entradas interno.
|
||||
|
||||
**Exemplo**
|
||||
|
||||
@ -27,11 +27,11 @@ arr[3][0][1];
|
||||
|
||||
`arr[3]` é `[[10, 11, 12], 13, 14]`, `arr[3][0]` é `[10, 11, 12]`, e `arr[3][0][1]` é `11`.
|
||||
|
||||
**Nota:** Não deve haver nenhum espaço entre o nome do array e os colchetes como `array [0][0]` e até mesmo `array [0] [0]` não é permitido. Embora JavaScript seja capaz de processar isso corretamente, isso pode confundir outros programadores lendo seu código.
|
||||
**Observação:** não deve haver nenhum espaço entre o nome do array e os colchetes como `array [0][0]` e até mesmo `array [0] [0]` não é permitido. Embora JavaScript seja capaz de processar isso corretamente, isso pode confundir outros programadores lendo seu código.
|
||||
|
||||
# --instructions--
|
||||
|
||||
Utilizando notação de colchetes selecione um elemento de `myArray` de forma que `myData` seja igual a `8`.
|
||||
Utilizando notação de colchetes, selecione um elemento de `myArray` de forma que `myData` seja igual a `8`.
|
||||
|
||||
# --hints--
|
||||
|
||||
|
||||
@ -50,7 +50,7 @@ Usando a notação de ponto e de colchetes, defina a variável `secondTree` para
|
||||
assert(secondTree === 'pine');
|
||||
```
|
||||
|
||||
Seu código deve usar notação de ponto e colchetes para acessar `myPlants`.
|
||||
O código deve usar notação de ponto e colchetes para acessar `myPlants`.
|
||||
|
||||
```js
|
||||
assert(/=\s*myPlants\[1\].list\[1\]/.test(code));
|
||||
|
||||
@ -9,7 +9,7 @@ dashedName: accessing-nested-objects
|
||||
|
||||
# --description--
|
||||
|
||||
As sub propriedades de objetos podem ser acessadas ao encadear a notação de ponto e de colchetes.
|
||||
As subpropriedades de objetos podem ser acessadas ao encadear a notação de ponto e de colchetes.
|
||||
|
||||
Aqui está um objeto aninhado:
|
||||
|
||||
@ -44,7 +44,7 @@ Acesse o objeto `myStorage` e atribua o conteúdo da propriedade `glove box` par
|
||||
assert(gloveBoxContents === 'maps');
|
||||
```
|
||||
|
||||
Seu código deve usar notação de ponto e de colchetes para acessar `myStorage`.
|
||||
O código deve usar notação de ponto e de colchetes para acessar `myStorage`.
|
||||
|
||||
```js
|
||||
assert(/=\s*myStorage\.car\.inside\[\s*("|')glove box\1\s*\]/g.test(code));
|
||||
|
||||
@ -9,7 +9,7 @@ dashedName: accessing-object-properties-with-bracket-notation
|
||||
|
||||
# --description--
|
||||
|
||||
A segunda forma para acessar as propriedades de um objeto é a notação de colchetes (`[]`). Se a propriedade do objeto que você está tentando acessar possui um espaço no seu nome, você irá precisar usar a notação de colchetes.
|
||||
A segunda forma para acessar as propriedades de um objeto é a notação de colchetes (`[]`). Se a propriedade do objeto que você está tentando acessar possui um espaço no seu nome, você precisará usar a notação de colchetes.
|
||||
|
||||
No entanto, você ainda pode usar a notação de colchetes nas propriedades dos objetos sem espaços.
|
||||
|
||||
|
||||
@ -24,7 +24,7 @@ var prop1val = myObj.prop1;
|
||||
var prop2val = myObj.prop2;
|
||||
```
|
||||
|
||||
`prop1val` teria o valor `val1`, e `prop2val` teria o valor `val2`.
|
||||
`prop1val` teria o valor `val1` e `prop2val` teria o valor `val2`.
|
||||
# --instructions--
|
||||
|
||||
Leia os valores de propriedade de `testObj` usando a notação de ponto. Defina a variável `hatValue` igual à propriedade `hat` do objeto e defina a variável `shirtValue` igual à propriedade `shirt` do objeto.
|
||||
|
||||
@ -9,7 +9,7 @@ dashedName: add-new-properties-to-a-javascript-object
|
||||
|
||||
# --description--
|
||||
|
||||
Você pode adicionar novas propriedades para um objeto JavaScript existente da mesma forma que você iria modificá-los.
|
||||
Você pode adicionar novas propriedades para um objeto JavaScript existente da mesma forma pela qual você os modificaria.
|
||||
|
||||
Aqui está como adicionaríamos uma propriedade `bark` para `ourDog`:
|
||||
|
||||
|
||||
@ -9,9 +9,9 @@ dashedName: add-two-numbers-with-javascript
|
||||
|
||||
# --description--
|
||||
|
||||
`Number` é um tipo de dado em JavaScript o qual representa um dado numérico.
|
||||
`Number` é um tipo de dado em JavaScript que representa um dado numérico.
|
||||
|
||||
Agora vamos tentar adicionar dois números usando JavaScript.
|
||||
Agora, vamos tentar adicionar dois números usando JavaScript.
|
||||
|
||||
JavaScript utiliza o símbolo `+` como um operador de adição quando colocado entre dois números.
|
||||
|
||||
|
||||
@ -9,7 +9,7 @@ dashedName: adding-a-default-option-in-switch-statements
|
||||
|
||||
# --description--
|
||||
|
||||
Na instrução `switch` você não deve ser capaz de especificar todos os possíveis valores como instruções `case`. Ao invés disso, você pode adicionar a instrução `default` a qual será executada se nenhuma instrução `case` correspondente for encontrada. Pense nisso como a instrução final `else` em uma cadeia de `if/else`.
|
||||
Na instrução `switch`, você não deve ser capaz de especificar todos os possíveis valores como instruções `case`. Ao invés disso, você pode adicionar a instrução `default`, que será executada se nenhuma instrução `case` correspondente for encontrada. Pense nisso como a instrução final `else` em uma cadeia de `if/else`.
|
||||
|
||||
A instrução `default` deve ser o último caso.
|
||||
|
||||
@ -68,7 +68,7 @@ assert(switchOfStuff('d') === 'stuff');
|
||||
assert(switchOfStuff(4) === 'stuff');
|
||||
```
|
||||
|
||||
Você não deve usar nenhuma das instruções `if` ou `else`
|
||||
Você não deve usar nenhuma instrução do tipo `if` ou `else`
|
||||
|
||||
```js
|
||||
assert(!/else/g.test(code) || !/if/g.test(code));
|
||||
|
||||
@ -18,7 +18,7 @@ var myNum;
|
||||
myNum = myVar;
|
||||
```
|
||||
|
||||
O código acima declara uma variável `myVar` sem valor, e então atribui a ela o valor `5`. Em seguida, uma variável chamada `myNum` é declarada sem valor. Em seguida, o conteúdo de `myVar` (o qual é `5`) é atribuído para a variável `myNum`. Agora, `myNum` também possui o valor de `5`.
|
||||
O código acima declara uma variável `myVar` sem valor, e então atribui a ela o valor `5`. Em seguida, uma variável chamada `myNum` é declarada sem valor. Depois, o conteúdo de `myVar` (o qual é `5`) é atribuído para a variável `myNum`. Agora, `myNum` também possui o valor de `5`.
|
||||
|
||||
# --instructions--
|
||||
|
||||
|
||||
@ -9,9 +9,9 @@ dashedName: assignment-with-a-returned-value
|
||||
|
||||
# --description--
|
||||
|
||||
Se você se lembrar de nossa discussão sobre [Armazenar valores com o Operador de Atribuição](/learn/javascript-algorithms-and-data-structures/basic-javascript/storing-values-with-the-assignment-operator), tudo à direita do sinal de igual é resolvido antes do valor ser atribuído. Isso significa que podemos pegar o valor de retorno de uma função e atribuí-la a uma variável.
|
||||
Se você se lembrar de nossa discussão sobre como [armazenar valores com o operador de atribuição](/learn/javascript-algorithms-and-data-structures/basic-javascript/storing-values-with-the-assignment-operator), tudo à direita do sinal de igual é resolvido antes de o valor ser atribuído. Isso significa que podemos pegar o valor de retorno de uma função e atribuí-lo a uma variável.
|
||||
|
||||
Assuma que temos uma função pré-definida chamada `sum` a qual adiciona dois números, depois:
|
||||
Assuma que temos uma função predefinida chamada `sum`, que soma dois números. Então:
|
||||
|
||||
```js
|
||||
ourSum = sum(5, 12);
|
||||
|
||||
@ -36,17 +36,17 @@ var anotherObject = {
|
||||
};
|
||||
```
|
||||
|
||||
No entanto, se seu objeto tem quaisquer propriedades que não seja string, o JavaScript irá automaticamente definir seus tipos como strings.
|
||||
No entanto, se seu objeto tem quaisquer propriedades que não sejam strings, o JavaScript automaticamente definirá seus tipos como strings.
|
||||
|
||||
# --instructions--
|
||||
|
||||
Faça um objeto que representa um cachorro chamado `myDog` que contém as propriedades `name` (uma string), `legs`, `tails` e `friends`.
|
||||
|
||||
Você pode definir essas propriedades do objeto para os valores que deseja, contanto que `name` seja uma string, `legs` e `tails` são números, e `friends` é um array.
|
||||
Você pode definir essas propriedades do objeto para os valores que deseja, contanto que `name` seja uma string, `legs` e `tails` sejam números, e `friends` seja um array.
|
||||
|
||||
# --hints--
|
||||
|
||||
`myDog` deve conter a propriedade `name` e deve ser uma `string`.
|
||||
`myDog` deve conter a propriedade `name`, que deve ser uma `string`.
|
||||
|
||||
```js
|
||||
assert(
|
||||
@ -64,7 +64,7 @@ assert(
|
||||
);
|
||||
```
|
||||
|
||||
`myDog` deve conter a propriedade `name` e deve ser uma `string`.
|
||||
`myDog` deve conter a propriedade `legs`, que deve ser um `number`.
|
||||
|
||||
```js
|
||||
assert(
|
||||
@ -82,7 +82,7 @@ assert(
|
||||
);
|
||||
```
|
||||
|
||||
`myDog` deve conter a propriedade `tails` e deve ser um `número`.
|
||||
`myDog` deve conter a propriedade `tails`, que deve ser um `number`.
|
||||
|
||||
```js
|
||||
assert(
|
||||
@ -100,7 +100,7 @@ assert(
|
||||
);
|
||||
```
|
||||
|
||||
`myDog` deve conter a propriedade `friends` e deve ser um `array`.
|
||||
`myDog` deve conter a propriedade `friends`, que deve ser um `array`.
|
||||
|
||||
```js
|
||||
assert(
|
||||
@ -118,7 +118,7 @@ assert(
|
||||
);
|
||||
```
|
||||
|
||||
`myDog` deve conter apenas todas as propriedades fornecidas.
|
||||
`myDog` deve conter apenas as propriedades fornecidas.
|
||||
|
||||
```js
|
||||
assert(
|
||||
|
||||
@ -9,7 +9,7 @@ dashedName: chaining-if-else-statements
|
||||
|
||||
# --description--
|
||||
|
||||
`if/else` instruções podem ser encadeadas por uma lógica complexa. Aqui está o <dfn>pseudocódigo</dfn> de várias instruções encadeadas `if` / `else`:
|
||||
Instruções `if/else` podem ser encadeadas por uma lógica complexa. Aqui está o <dfn>pseudocódigo</dfn> de várias instruções encadeadas `if`/`else if`:
|
||||
|
||||
```js
|
||||
if (condition1) {
|
||||
@ -26,7 +26,7 @@ if (condition1) {
|
||||
|
||||
# --instructions--
|
||||
|
||||
Escreva instruções encadeadas `if`/`else` para atender as seguintes condições:
|
||||
Escreva instruções encadeadas `if`/`else if` para atender às seguintes condições:
|
||||
|
||||
`num < 5` - retorna `Tiny`
|
||||
`num < 10` - retorna `Small`
|
||||
|
||||
@ -10,24 +10,24 @@ dashedName: comment-your-javascript-code
|
||||
|
||||
# --description--
|
||||
|
||||
Comentários são linhas de código que JavaScript irá intencionalmente ignorar. Os comentários são uma ótima maneira de deixar anotações para você mesmo e para outras pessoas que mais tarde precisarão descobrir o que esse código faz.
|
||||
Comentários são linhas de código que JavaScript vai ignorar intencionalmente. Os comentários são uma ótima maneira de deixar anotações para você mesmo 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:
|
||||
|
||||
Usando `//` dirá ao JavaScript para ignorar o resto do texto na linha atual. Isso é um comentário de uma linha:
|
||||
Usar `//` dirá ao JavaScript para ignorar o resto do texto na linha atual. Isso é um comentário de uma linha:
|
||||
|
||||
```js
|
||||
// This is an in-line comment.
|
||||
```
|
||||
|
||||
Você pode fazer um comentário de mais de uma linha, começando com `/*` e terminando com `*/`. Este é um comentário em várias linha:
|
||||
Você pode fazer um comentário de mais de uma linha, começando com `/*` e terminando com `*/`. Este é um comentário em várias linhas:
|
||||
|
||||
```js
|
||||
/* This is a
|
||||
multi-line comment */
|
||||
```
|
||||
|
||||
**NOTA:** À medida que você escreve código, você deve adicionar comentários regularmente, para esclarecer a função de partes do seu código. Um bom comentário pode ajudar a comunicar a intenção do seu código — tanto para os outros *quanto* para você mesmo no futuro.
|
||||
**OBSERVAÇÃO:** à medida que você escreve código, deve adicionar comentários regularmente, para esclarecer a função de partes do seu código. Um bom comentário pode ajudar a comunicar a intenção do seu código — para os outros *e* para você mesmo no futuro.
|
||||
|
||||
# --instructions--
|
||||
|
||||
|
||||
@ -11,7 +11,7 @@ dashedName: comparison-with-the-equality-operator
|
||||
|
||||
Há muitos <dfn>operadores de comparação</dfn> em JavaScript. Todos esses operadores retornam um valor booleano `true` ou `false`.
|
||||
|
||||
O operador mais básico é o operador de igualdade `==`. O operador de igualdade compara dois valores e retorna `true` se eles são equivalentes ou `false` se não são. Observe que a igualdade é diferente de atribuição (`=`), que atribui o valor à direita do operador para uma variável à esquerda.
|
||||
O operador mais básico é o operador de igualdade `==`. O operador de igualdade compara dois valores e retorna `true` se eles são equivalentes ou `false` se não são. Observe que o operador de igualdade é diferente do operador de atribuição (`=`), que atribui o valor à direita do operador para uma variável à esquerda.
|
||||
|
||||
```js
|
||||
function equalityTest(myVal) {
|
||||
@ -22,7 +22,7 @@ function equalityTest(myVal) {
|
||||
}
|
||||
```
|
||||
|
||||
Se `myVal` é igual a `10`, o operador de igualdade retorna `true`, assim o código nas chaves será executado e a função retornará `Equal`. Caso contrário, a função retornará `Not Equal`. Para que JavaScript possa comparar dois <dfn>tipos de dados</dfn> diferentes (por exemplo, `números` e `strings`), deve converter um tipo para outro. Isto é conhecido como Coerção do Tipo (casting ou type coercion). No entanto, uma vez que o faça, pode comparar os termos da seguinte forma:
|
||||
Se `myVal` é igual a `10`, o operador de igualdade retorna `true`, assim o código nas chaves será executado e a função retornará `Equal`. Caso contrário, a função retornará `Not Equal`. Para que o JavaScript possa comparar dois <dfn>tipos de dados</dfn> diferentes (por exemplo, `numbers` e `strings`), deve converter um tipo para outro. Isto é conhecido como coerção de tipo (casting ou type coercion). No entanto, uma vez que a faça, você pode comparar os termos da seguinte forma:
|
||||
|
||||
```js
|
||||
1 == 1
|
||||
@ -31,7 +31,7 @@ Se `myVal` é igual a `10`, o operador de igualdade retorna `true`, assim o cód
|
||||
"3" == 3
|
||||
```
|
||||
|
||||
Em ordem, essas expressões seriam avaliadas à `true`, `false`, `true` e `true`.
|
||||
Em ordem, essas expressões seriam avaliadas como `true`, `false`, `true` e `true`.
|
||||
|
||||
# --instructions--
|
||||
|
||||
|
||||
@ -9,7 +9,7 @@ dashedName: comparison-with-the-greater-than-operator
|
||||
|
||||
# --description--
|
||||
|
||||
O operador maior que (`>`) compara os valores de dois números. Se o número para a esquerda for maior que o número à direita, ele retorna `true`. Caso contrário, ele retorna `false`.
|
||||
O operador maior que (`>`) compara os valores de dois números. Se o número à esquerda for maior que o número à direita, ele retorna `true`. Caso contrário, ele retorna `false`.
|
||||
|
||||
Tal como o operador de igualdade, o operador maior que converterá os tipos de dados de valores enquanto compara.
|
||||
|
||||
@ -22,7 +22,7 @@ Tal como o operador de igualdade, o operador maior que converterá os tipos de d
|
||||
'1' > 9
|
||||
```
|
||||
|
||||
Em ordem, essas expressões seriam iguais à `true`, `true`, `false`, e `false`.
|
||||
Em ordem, essas expressões seriam iguais à `true`, `true`, `false` e `false`.
|
||||
|
||||
# --instructions--
|
||||
|
||||
|
||||
@ -26,7 +26,7 @@ Em ordem, essas expressões seriam iguais à `true`, `true`, `false` e `false`.
|
||||
|
||||
# --instructions--
|
||||
|
||||
Adicione o operador maior ou igual que para indicar as linhas indicadas para que as instruções de retorno façam sentido.
|
||||
Adicione o operador maior ou igual que às linhas indicadas para que as instruções de retorno façam sentido.
|
||||
|
||||
# --hints--
|
||||
|
||||
|
||||
@ -9,7 +9,7 @@ dashedName: comparison-with-the-less-than-operator
|
||||
|
||||
# --description--
|
||||
|
||||
O operador menor que (`<`) compara os valores de dois números. Se o número a esquerda for menos que o número à direita, retornará `true`. Caso contrário, retorna `false`. Assim como o operador de igualdade, o operador menor que converte os tipos de dados enquando compara.
|
||||
O operador menor que (`<`) compara os valores de dois números. Se o número à esquerda for menos que o número à direita, retornará `true`. Caso contrário, retorna `false`. Assim como o operador de igualdade, o operador menor que converte os tipos de dados enquanto compara.
|
||||
|
||||
**Exemplos**
|
||||
|
||||
@ -21,7 +21,7 @@ O operador menor que (`<`) compara os valores de dois números. Se o número a e
|
||||
'8' < 4
|
||||
```
|
||||
|
||||
Em ordem, essas expressões seriam igual à `true`, `true`, `false`, `false` e `false`.
|
||||
Em ordem, essas expressões seriam iguais à `true`, `true`, `false`, `false` e `false`.
|
||||
|
||||
# --instructions--
|
||||
|
||||
|
||||
@ -9,7 +9,7 @@ dashedName: comparison-with-the-less-than-or-equal-to-operator
|
||||
|
||||
# --description--
|
||||
|
||||
O operador menor ou igual (`<=`) compara os valores de dois números. Se o número à esquerda for menor ou igual ao número à direita, retornará `true`. Se o número a esquerda for maior que o número a direita, retornará `false`. Assim como o operador de igualdade, o operador de menor ou igual que converte os tipos de dados.
|
||||
O operador menor ou igual (`<=`) compara os valores de dois números. Se o número à esquerda for menor ou igual ao número à direita, retornará `true`. Se o número à esquerda for maior que o número a direita, retornará `false`. Assim como o operador de igualdade, o operador de menor ou igual que converte os tipos de dados.
|
||||
|
||||
**Exemplos**
|
||||
|
||||
|
||||
@ -20,13 +20,13 @@ Se os valores que são comparados tiverem valores diferentes, são considerados
|
||||
3 === '3'
|
||||
```
|
||||
|
||||
Essas condições retornariam `true` e `false` respectivamente.
|
||||
Essas condições retornariam `true` e `false`, respectivamente.
|
||||
|
||||
No segundo exemplo, `3` é um tipo de `Number` e `'3'` é um tipo `String`.
|
||||
|
||||
# --instructions--
|
||||
|
||||
Use o operador de igualdade estrito na instrução `if`, para que a função retorne a string `Equal` quando `val` for estritamente igual a `7`
|
||||
Use o operador de igualdade estrita na instrução `if`, para que a função retorne a string `Equal` quando `val` for estritamente igual a `7`
|
||||
|
||||
# --hints--
|
||||
|
||||
|
||||
@ -23,7 +23,7 @@ Em ordem, essas expressões seriam iguais à `false`, `true` e `true`.
|
||||
|
||||
# --instructions--
|
||||
|
||||
Adicione o operador de desigualdade estrito ao comando `if` para que a função retorne a string `Not Equal` quando `val` não é estritamente igual a `17`
|
||||
Adicione o operador de desigualdade estrita ao comando `if` para que a função retorne a string `Not Equal` quando `val` não é estritamente igual a `17`
|
||||
|
||||
# --hints--
|
||||
|
||||
|
||||
@ -9,7 +9,7 @@ dashedName: comparisons-with-the-logical-and-operator
|
||||
|
||||
# --description--
|
||||
|
||||
Às vezes você precisará testar mais de uma coisa de cada vez. O <dfn>operador lógico e</dfn>(`&&`) retornará `true` apenas se os <dfn>operadores</dfn> a esquerda e à direita são verdadeiros.
|
||||
Às vezes, você precisará testar mais de uma coisa de cada vez. O <dfn>operador lógico AND</dfn> (`&&`) retornará `true` apenas se os <dfn>operadores</dfn> à esquerda e à direita forem verdadeiros.
|
||||
|
||||
O mesmo efeito pode ser alcançado aninhando uma instrução if dentro de outro if:
|
||||
|
||||
@ -22,7 +22,7 @@ if (num > 5) {
|
||||
return "No";
|
||||
```
|
||||
|
||||
só retornará `Yes` se `num` é maior que `5` e menor que `10`. A mesma lógica pode ser escrita como:
|
||||
só retornará `Yes` se `num` for maior que `5` e menor que `10`. A mesma lógica pode ser escrita assim:
|
||||
|
||||
```js
|
||||
if (num > 5 && num < 10) {
|
||||
@ -33,7 +33,7 @@ return "No";
|
||||
|
||||
# --instructions--
|
||||
|
||||
Substitua as duas instruções if por uma declaração, usando o operador `&&`, que irá retornar a string `Yes` se `val` for menor ou igual a `50` e maior ou igual a `25`. Caso contrário, retornará a string `No`.
|
||||
Substitua as duas instruções if por uma declaração, usando o operador `&&`, que vai retornar a string `Yes` se `val` for menor ou igual a `50` e maior ou igual a `25`. Caso contrário, retornará a string `No`.
|
||||
|
||||
# --hints--
|
||||
|
||||
|
||||
@ -9,11 +9,11 @@ dashedName: comparisons-with-the-logical-or-operator
|
||||
|
||||
# --description--
|
||||
|
||||
O <dfn>operador lógico ou</dfn> (`||`) retorna `true` se qualquer um dos <dfn>operandos</dfn> for `true`. Caso contrário, retorna `false`.
|
||||
O <dfn>operador lógico OR</dfn> (`||`) retorna `true` se qualquer um dos <dfn>operandos</dfn> for `true`. Caso contrário, retorna `false`.
|
||||
|
||||
O <dfn>operador lógico ou</dfn> é composto por dois símbolos de pipe: (`||`). Normalmente isso pode ser encontrado entre as teclas Backspace e Enter.
|
||||
O <dfn>operador lógico ou</dfn> é composto por dois símbolos de pipe: (`||`). Normalmente, ele pode ser encontrado entre as teclas Backspace e Enter.
|
||||
|
||||
O padrão abaixo deve parecer familiar aos pontos da passagens anteriores:
|
||||
O padrão abaixo deve parecer familiar aos pontos das passagens anteriores:
|
||||
|
||||
```js
|
||||
if (num > 10) {
|
||||
@ -25,7 +25,7 @@ if (num < 5) {
|
||||
return "Yes";
|
||||
```
|
||||
|
||||
retornará `Yes` apenas se `num` for entre `5` e `10` (5 e 10 incluídos). A mesma lógica pode ser escrita como:
|
||||
retornará `Yes` apenas se `num` for entre `5` e `10` (5 e 10 incluídos). A mesma lógica pode ser escrita assim:
|
||||
|
||||
```js
|
||||
if (num > 10 || num < 5) {
|
||||
|
||||
@ -15,7 +15,7 @@ O operador `/=` divide uma variável por outro número.
|
||||
myVar = myVar / 5;
|
||||
```
|
||||
|
||||
Irá dividir `myVar` por `5`. Isto pode ser reescrito como:
|
||||
dividirá `myVar` por `5`. Essa expressão pode ser reescrita assim:
|
||||
|
||||
```js
|
||||
myVar /= 5;
|
||||
|
||||
@ -15,7 +15,7 @@ O operador `*=` multiplica uma variável por um número.
|
||||
myVar = myVar * 5;
|
||||
```
|
||||
|
||||
irá multiplicar `myVar` por `5`. Isto pode ser reescrito como:
|
||||
multiplicará `myVar` por `5`. Essa expressão pode ser reescrita assim:
|
||||
|
||||
```js
|
||||
myVar *= 5;
|
||||
|
||||
@ -15,7 +15,7 @@ Como o operador `+=`, `-=` subtrai um número de uma variável.
|
||||
myVar = myVar - 5;
|
||||
```
|
||||
|
||||
irá subtrair `5` de `myVar`. Isto pode ser reescrito como:
|
||||
vai subtrair `5` de `myVar`. Essa expressão pode ser reescrita assim:
|
||||
|
||||
```js
|
||||
myVar -= 5;
|
||||
|
||||
@ -9,7 +9,7 @@ dashedName: concatenating-strings-with-plus-operator
|
||||
|
||||
# --description--
|
||||
|
||||
Em JavaScript, quando o operador `+` é usado com um valor de `String`, ele é chamado de operador de <dfn>concatenação</dfn>. Você pode construir uma nova string a partir de outras strings ao <dfn>concatenar</dfn> elas juntos.
|
||||
Em JavaScript, quando o operador `+` é usado com um valor de `String`, ele é chamado de operador de <dfn>concatenação</dfn>. Você pode criar uma nova string a partir de outras strings ao <dfn>concatenar</dfn> elas juntos.
|
||||
|
||||
**Exemplo**
|
||||
|
||||
@ -17,7 +17,7 @@ Em JavaScript, quando o operador `+` é usado com um valor de `String`, ele é c
|
||||
'My name is Alan,' + ' I concatenate.'
|
||||
```
|
||||
|
||||
**Nota:** Cuidado com os espaços. A concatenação não adiciona espaços entre strings concatenadas, então você mesmo precisará adicioná-las.
|
||||
**Observação:** cuidado com os espaços. A concatenação não adiciona espaços entre strings concatenadas, então você mesmo precisará adicioná-las.
|
||||
|
||||
Exemplo:
|
||||
|
||||
@ -28,7 +28,7 @@ var ourStr = "I come first. " + "I come second.";
|
||||
A string `I come first. I come second.` seria exibida no console.
|
||||
# --instructions--
|
||||
|
||||
Construa `myStr` a partir das strings `This is the start.` e `This is the end.` usando o operador `+`.
|
||||
Crie `myStr` a partir das strings `This is the start.` e `This is the end.` usando o operador `+`.
|
||||
|
||||
# --hints--
|
||||
|
||||
@ -38,13 +38,13 @@ Construa `myStr` a partir das strings `This is the start.` e `This is the end.`
|
||||
assert(myStr === 'This is the start. This is the end.');
|
||||
```
|
||||
|
||||
Você deve usar o operador `+` para construir `myStr`.
|
||||
Você deve usar o operador `+` para criar `myStr`.
|
||||
|
||||
```js
|
||||
assert(code.match(/(["']).*\1\s*\+\s*(["']).*\2/g));
|
||||
```
|
||||
|
||||
`myStr` deve ser criado usando a palavra-chave `var`.
|
||||
`myStr` deve ser criada usando a palavra-chave `var`.
|
||||
|
||||
```js
|
||||
assert(/var\s+myStr/.test(code));
|
||||
|
||||
@ -11,7 +11,7 @@ dashedName: concatenating-strings-with-the-plus-equals-operator
|
||||
|
||||
Também podemos usar o operador `+=` para <dfn>concatenar</dfn> uma string no final de uma variável string existente. Isso pode ser muito útil para quebrar uma longa string em várias linhas.
|
||||
|
||||
**Nota:** Cuidado com os espaços. A concatenação não adiciona espaços entre strings concatenadas, então você mesmo precisará adicioná-las.
|
||||
**Observação:** cuidado com os espaços. A concatenação não adiciona espaços entre strings concatenadas, então você mesmo precisará adicioná-los.
|
||||
|
||||
Exemplo:
|
||||
|
||||
@ -24,7 +24,7 @@ ourStr += "I come second.";
|
||||
|
||||
# --instructions--
|
||||
|
||||
Construa `myStr` sobre várias linhas concatenando essas duas strings: `Esta é a primeira frase.` e `Esta é a segunda frase.` usando o operador `+=`. Use o operador `+=` de modo semelhante a como aparece no exemplo. Comece atribuindo o primeiro texto para `myStr`, e então adicione o segundo texto.
|
||||
Crie `myStr` em várias linhas concatenando essas duas strings: `This is the first sentence.` e `This is the second sentence.` usando o operador `+=`. Use o operador `+=` de modo semelhante a como aparece no exemplo. Comece atribuindo o primeiro texto para `myStr`, e então adicione o segundo texto.
|
||||
|
||||
# --hints--
|
||||
|
||||
@ -34,7 +34,7 @@ Construa `myStr` sobre várias linhas concatenando essas duas strings: `Esta é
|
||||
assert(myStr === 'This is the first sentence. This is the second sentence.');
|
||||
```
|
||||
|
||||
Você deve usar o operador `+=` para construir `myStr`.
|
||||
Você deve usar o operador `+=` para criar `myStr`.
|
||||
|
||||
```js
|
||||
assert(code.match(/myStr\s*\+=\s*(["']).*\1/g));
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244b9
|
||||
title: Construir strings com variáveis
|
||||
title: Criar strings com variáveis
|
||||
challengeType: 1
|
||||
videoUrl: 'https://scrimba.com/c/cqk8rf4'
|
||||
forumTopicId: 16805
|
||||
@ -9,7 +9,7 @@ dashedName: constructing-strings-with-variables
|
||||
|
||||
# --description--
|
||||
|
||||
Às vezes você precisará construir uma string, no estilo [Mad Libs](https://en.wikipedia.org/wiki/Mad_Libs). Usando o operador de concatenação (`+`), você pode inserir uma ou mais variáveis em uma string que você está construindo.
|
||||
Às vezes, você precisará criar uma string, no estilo [Mad Libs](https://en.wikipedia.org/wiki/Mad_Libs). Usando o operador de concatenação (`+`), você pode inserir uma ou mais variáveis em uma string que você está criando.
|
||||
|
||||
Exemplo:
|
||||
|
||||
@ -32,7 +32,7 @@ Defina `myName` para uma string igual ao seu nome e construa `myStr` com `myName
|
||||
assert(typeof myName !== 'undefined' && myName.length > 2);
|
||||
```
|
||||
|
||||
Você deve usar dois operadores `+` para construir `myStr` com `myName` dentro dele.
|
||||
Você deve usar dois operadores `+` para criar `myStr` com `myName` dentro dela.
|
||||
|
||||
```js
|
||||
assert(code.match(/["']\s*\+\s*myName\s*\+\s*["']/g).length > 0);
|
||||
|
||||
@ -13,7 +13,7 @@ Um laço for também pode contar pra trás, contanto que possamos definir as con
|
||||
|
||||
Para decrementar em dois cada iteração, nós precisamos alterar nossa inicialização, condição e expressão final.
|
||||
|
||||
Nós começaremos em `i = 10` e iterar enquanto `i > 0`. Nós decrementamos `i` por dois em cada iteração com `i -= 2`.
|
||||
Nós começaremos em `i = 10` e vamos iterar enquanto `i > 0`. Nós decrementamos `i` por dois em cada iteração com `i -= 2`.
|
||||
|
||||
```js
|
||||
var ourArray = [];
|
||||
|
||||
@ -9,18 +9,18 @@ dashedName: counting-cards
|
||||
|
||||
# --description--
|
||||
|
||||
No jogo de casino Blackjack, um jogador pode ganhar vantagem sobre a casa, mantendo o número relativo de cartas altas e baixas restantes no deck. Isso se chama [Contagem de Cartas](https://en.wikipedia.org/wiki/Card_counting).
|
||||
No jogo de casino Blackjack, um jogador pode ganhar vantagem sobre a casa, mantendo o número relativo de cartas altas e baixas restantes no baralho. Isso se chama [contagem de cartas](https://en.wikipedia.org/wiki/Card_counting).
|
||||
|
||||
Ter cartas mais altas restantes no deck favorece o jogador. A cada carta é atribuído um valor de acordo com a tabela abaixo. Quando o contador for positivo, o jogador deve apostar alto. Quando a contagem for zero ou negativa, o jogador deverá apostar baixo.
|
||||
Ter cartas mais altas restantes no baralho favorece o jogador. A cada carta é atribuído um valor de acordo com a tabela abaixo. Quando o contador for positivo, o jogador deve apostar alto. Quando a contagem for zero ou negativa, o jogador deverá apostar baixo.
|
||||
|
||||
<table class='table table-striped'><thead><tr><th>Contagem de mudança</th><th>Cartas</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>
|
||||
<table class='table table-striped'><thead><tr><th>Mudança na contagem</th><th>Cartas</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 cartas. A função receberá um parâmetro `card`, a qual pode ser um número ou uma string e incrementar ou decrementar a variável global `count` de acordo com o valor da carta (veja a tabela). Em seguida, a função retornará a string com o valor atual de contagem (variável count) e a string `Bet` se a contagem for positiva, ou `Hold` se a contagem for zero ou negativa. A contagem atual e a decisão do jogador (`Bet` ou `Hold`) deve ser separado por um único espaço.
|
||||
Você vai escrever uma função de contagem de cartas. A função receberá um parâmetro `card`, que pode ser um número ou uma string, e incrementar ou decrementar a variável global `count` de acordo com o valor da carta (veja a tabela). Em seguida, a função retornará a string com o valor atual de contagem (variável count) e a string `Bet` se a contagem for positiva, ou `Hold` se a contagem for zero ou negativa. A contagem atual e a decisão do jogador (`Bet` ou `Hold`) deve ser separado por um único espaço.
|
||||
|
||||
**Exemplo de Saída:** `-3 Hold` ou `5 Bet`
|
||||
**Exemplo de saída:** `-3 Hold` ou `5 Bet`
|
||||
|
||||
**Dica**
|
||||
Não redefina o valor de `count` para 0 quando o valor for 7, 8, or 9. Não retorne um array.
|
||||
NÃO redefina o valor de `count` para 0 quando o valor for 7, 8, ou 9. Não retorne um array.
|
||||
Não inclua aspas (simples ou duplas) na saída.
|
||||
|
||||
# --hints--
|
||||
|
||||
@ -9,9 +9,9 @@ dashedName: create-decimal-numbers-with-javascript
|
||||
|
||||
# --description--
|
||||
|
||||
Nós também podemos armazenar números decimais em variáveis. Números decimais são referidos as vezes como números de <dfn>ponto flutuante</dfn> ou <dfn>floats</dfn>.
|
||||
Nós também podemos armazenar números decimais em variáveis. Números decimais são às vezes referidos como <dfn>números do ponto flutuante</dfn> ou <dfn>floats</dfn>.
|
||||
|
||||
**Nota:** Nem todos os números reais podem ser representados com precisão no <dfn>ponto flutuante</dfn>. Isso pode levar a erros de arredondamento. [Detalhes aqui](https://en.wikipedia.org/wiki/Floating-point_arithmetic#Accuracy_problems).
|
||||
**Observação:** nem todos os números reais podem ser representados com precisão no <dfn>ponto flutuante</dfn>. Isso pode levar a erros de arredondamento. [Detalhes aqui](https://en.wikipedia.org/wiki/Floating-point_arithmetic#Accuracy_problems).
|
||||
|
||||
# --instructions--
|
||||
|
||||
|
||||
@ -9,13 +9,13 @@ dashedName: declare-javascript-variables
|
||||
|
||||
# --description--
|
||||
|
||||
Na ciência da computação, <dfn>dado</dfn> é qualquer coisa que tenha significado ao computador. JavaScript fornece oito <dfn>tipos de dados</dfn> diferentes que são `undefined`, `null`, `boolean`, `string`, `symbol`, `bigint`, `number` e `object`.
|
||||
Na ciência da computação, <dfn>dado</dfn> é qualquer coisa que tenha significado para o computador. JavaScript fornece oito <dfn>tipos de dados</dfn> diferentes que são `undefined`, `null`, `boolean`, `string`, `symbol`, `bigint`, `number` e `object`.
|
||||
|
||||
Por exemplo, os computadores distinguem números, como o número`12`, e `strings`, como o `"12"`, `"dog"`, ou`"123 cats"`, as quais são coleções de caracteres. Computadores podem realizar operações matemáticas em um número, mas não em string.
|
||||
Por exemplo, os computadores distinguem números, como o número`12`, e `strings`, como o `"12"`, `"dog"`, ou`"123 cats"`, as quais são coleções de caracteres. Computadores podem realizar operações matemáticas em um número, mas não em uma string.
|
||||
|
||||
<dfn>Variáveis</dfn> permitem aos computadores armazenar e manipular dados de forma dinâmica. Eles fazem isso usando um "rótulo" para apontar ao dado ao invés de usar o próprio dado. Qualquer uma dos 8 tipos de dados podem ser armazenados em variável.
|
||||
<dfn>Variáveis</dfn> permitem aos computadores armazenar e manipular dados de forma dinâmica. Elas fazem isso usando uma "etiqueta" para apontar para o dado ao invés de usar o próprio dado. Qualquer um dos 8 tipos de dados pode ser armazenado em uma variável.
|
||||
|
||||
Variáveis são similares às variáveis x e y utilizados na matemática, o que significa que elas são simples nomes para representar os dados que eles querem se referir. Variáveis de computador diferem das variáveis matemáticas porque elas podem armazenar diferentes valores em momentos diferentes.
|
||||
Variáveis são similares às variáveis x e y utilizadas na matemática, o que significa que elas são simples nomes para representar os dados aos quais se referem. Variáveis de computador diferem das variáveis matemáticas porque elas podem armazenar diferentes valores em momentos diferentes.
|
||||
|
||||
Dizemos ao JavaScript para criar ou declarar uma variável colocando a palavra-chave `var` na frente dela, dessa forma:
|
||||
|
||||
@ -23,7 +23,7 @@ Dizemos ao JavaScript para criar ou declarar uma variável colocando a palavra-c
|
||||
var ourName;
|
||||
```
|
||||
|
||||
cria uma variável chamada `ourName`. Em JavaScript terminamos uma instrução com ponto e vírgula. Nomes de variáveis podem ser formadas por números, letras e `$` ou `_`, mas não pode conter espaços ou começar com um número.
|
||||
cria uma variável chamada `ourName`. Em JavaScript, terminamos uma instrução com ponto e vírgula. Nomes de variáveis podem ser formados por números, letras e `$` ou `_`, mas não podem conter espaços ou começar com um número.
|
||||
|
||||
# --instructions--
|
||||
|
||||
|
||||
@ -9,17 +9,17 @@ dashedName: declare-string-variables
|
||||
|
||||
# --description--
|
||||
|
||||
Anteriormente nós usamos o código
|
||||
Anteriormente, nós usamos o código
|
||||
|
||||
```js
|
||||
var myName = "your name";
|
||||
```
|
||||
|
||||
`"your name"` é chamado de <dfn>string literal</dfn>. É uma string porque é uma série de 0 ou mais caracteres entre aspas simples ou duplas.
|
||||
`"your name"` é chamado de <dfn>string</dfn> <dfn>literal</dfn>. É uma string porque é uma série de 0 ou mais caracteres entre aspas simples ou duplas.
|
||||
|
||||
# --instructions--
|
||||
|
||||
Crie duas novas variáveis de string: `myFirstName` e `myLastName` e atribua a eles os valores do seu primeiro e último nome, respectivamente.
|
||||
Crie duas novas variáveis de string: `myFirstName` e `myLastName` e atribua a elas os valores do seu primeiro e último nome, respectivamente.
|
||||
|
||||
# --hints--
|
||||
|
||||
|
||||
@ -21,7 +21,7 @@ i--;
|
||||
i = i - 1;
|
||||
```
|
||||
|
||||
**Nota:** A linha inteira torna-se `i--;`, eliminando a necessidade para o sinal de igual (atribuição).
|
||||
**Observação:** a linha inteira torna-se `i--;`, eliminando a necessidade para o sinal de igual (atribuição).
|
||||
|
||||
# --instructions--
|
||||
|
||||
|
||||
@ -9,10 +9,10 @@ dashedName: escape-sequences-in-strings
|
||||
|
||||
# --description--
|
||||
|
||||
Aspas não são os únicos caracteres que podem ser <dfn>escapadas</dfn> dentro de uma string. Há dois motivos para usar caracteres de escapamento:
|
||||
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 escapamento:
|
||||
|
||||
1. Para permitir que você use caracteres, você pode não ser capaz de digitar caso contrário, como um retorno de carro.
|
||||
2. Para permiti-lo representar várias aspas em uma string sem o JavaScript entender erroneamente o que você quis dizer.
|
||||
1. Para permitir que você use caracteres que você pode não ser capaz de digitar do contrário, como o caractere de retorno de carro.
|
||||
2. Para permitir que você represente várias aspas em uma string sem o JavaScript entender erroneamente o que você quis dizer.
|
||||
|
||||
Aprendemos isso no desafio anterior.
|
||||
|
||||
@ -26,9 +26,9 @@ Atribua as três linhas de texto a seguir em uma única variável `myStr` usando
|
||||
|
||||
<blockquote>FirstLine<br> \SecondLine<br>ThirdLine</blockquote>
|
||||
|
||||
Você precisará usar sequências de escapamento para inserir corretamente os caracteres especiais. Você também precisará seguir os espaçamentos assim como se parece acima, sem espaços entre sequências de escapamento ou palavras.
|
||||
Você precisará usar sequências de escapamento para inserir corretamente os caracteres especiais. Você também precisará seguir os espaçamentos assim como acima, sem espaços entre sequências de escapamento ou palavras.
|
||||
|
||||
**Nota:** A identação para `SecondLine` é alcançada com o caracter de espaçamento tab, e não espaços.
|
||||
**Observação:** a identação para `SecondLine` é alcançada com o caractere de espaçamento tab, e não com espaços.
|
||||
|
||||
# --hints--
|
||||
|
||||
@ -52,7 +52,7 @@ assert(
|
||||
assert(/FirstLine\n/.test(myStr));
|
||||
```
|
||||
|
||||
`myStr` deve conter o caracter tab `\t` a qual está logo após o caractere de nova linha `\n`
|
||||
`myStr` deve conter o caractere de tabulação `\t`, que vem após um caractere de nova linha
|
||||
|
||||
```js
|
||||
assert(/\n\t/.test(myStr));
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
id: 56533eb9ac21ba0edf2244b5
|
||||
title: Escapar citações literais em strings
|
||||
title: Escapar aspas literais em strings
|
||||
challengeType: 1
|
||||
videoUrl: 'https://scrimba.com/c/c2QvgSr'
|
||||
forumTopicId: 17568
|
||||
@ -9,15 +9,15 @@ dashedName: escaping-literal-quotes-in-strings
|
||||
|
||||
# --description--
|
||||
|
||||
Quando você estiver definindo uma sequência de caracteres você deve iniciar e terminar com uma aspa simples ou dupla. O que acontece quando você precisa de uma cotação literal: `"` ou `'` dentro de sua string?
|
||||
Quando você estiver definindo uma sequência de caracteres você deve iniciar e terminar com uma aspa simples ou dupla. O que acontece quando você precisa de uma aspa literal: `"` ou `'` dentro de sua string?
|
||||
|
||||
Em JavaScript, você pode <dfn>escapar</dfn> uma aspas para não ser considerada como o fim de uma string ao colocar a <dfn>barra invertida</dfn> (`\`) na frente da aspa.
|
||||
Em JavaScript, você pode <dfn>escapar</dfn> uma aspa para que não seja considerada como o fim de uma string ao colocar a <dfn>barra invertida</dfn> (`\`) na frente da aspa.
|
||||
|
||||
```js
|
||||
var sampleStr = "Alan said, \"Peter is learning JavaScript\".";
|
||||
```
|
||||
|
||||
Isso sinaliza ao JavaScript que a seguinte aspa não é o fim de uma string, mas ao invés disso, deve aparecer dentro da string. Então, se você fosse imprimir isso no console, você obteria:
|
||||
Isso sinaliza ao JavaScript que a aspa seguinte não é o fim de uma string, mas que deve aparecer dentro da string. Então, se você fosse imprimir isso no console, você obteria:
|
||||
|
||||
```js
|
||||
Alan said, "Peter is learning JavaScript".
|
||||
@ -25,7 +25,7 @@ Alan said, "Peter is learning JavaScript".
|
||||
|
||||
# --instructions--
|
||||
|
||||
Use <dfn>barras invertidas</dfn> para atribuir a string à variável `myStr` para que se você fosse imprimi-la no console, você veria:
|
||||
Use <dfn>barras invertidas</dfn> para atribuir a string à variável `myStr` para que, se você fosse imprimi-la no console, veria:
|
||||
|
||||
```js
|
||||
I am a "double quoted" string inside "double quotes".
|
||||
|
||||
@ -17,7 +17,7 @@ console.log("Alan Peter".length);
|
||||
|
||||
O valor `10` seria exibido no console.
|
||||
|
||||
Por exemplo, se nós criarmos uma variável `var firstName = "Ada"`, poderíamos descobrir qual o tamanho da string `Ada` ao usar a propriedade `firstName.length`.
|
||||
Por exemplo, se nós criássemos uma variável `var firstName = "Ada"`, poderíamos descobrir qual o tamanho da string `Ada` usando a propriedade `firstName.length`.
|
||||
|
||||
# --instructions--
|
||||
|
||||
@ -25,7 +25,7 @@ Use a propriedade `.length` para contar o número de caracteres na variável `la
|
||||
|
||||
# --hints--
|
||||
|
||||
Você não deve alterar as declarações de variáveis a seção `// Setup`.
|
||||
Você não deve alterar as declarações de variáveis na seção `// Setup`.
|
||||
|
||||
```js
|
||||
assert(
|
||||
|
||||
@ -16,11 +16,11 @@ O operador de <dfn>resto</dfn> `%` retorna o resto da divisão de dois números.
|
||||
<blockquote>5 % 2 = 1 porque<br>Math.floor(5 / 2) = 2 (Quociente)<br> 2 * 2 = 4<br>5 - 4 = 1 (Resto)</blockquote>
|
||||
|
||||
**Uso**
|
||||
Na matemática, um número pode ser verificado para ser par ou ímpar ao verificar o resto da divisão de um número por `2`.
|
||||
Na matemática, um número pode ser verificado como par ou ímpar por meio do resto da divisão do número por `2`.
|
||||
|
||||
<blockquote>17 % 2 = 1 (17 é Ímpar)<br>48 % 2 = 0 (48 é Par)</blockquote>
|
||||
|
||||
**Nota:** O operador de <dfn>resto</dfn> às vezes é referido incorretamente como o operador de módulo. É muito semelhante ao módulo, mas não funciona adequadamente com números negativos.
|
||||
**Observação:** o operador de <dfn>resto</dfn> às vezes é referido incorretamente como o operador de módulo. É muito semelhante ao módulo, mas não funciona adequadamente com números negativos.
|
||||
|
||||
# --instructions--
|
||||
|
||||
|
||||
@ -13,7 +13,7 @@ Números aleatórios são úteis para criar comportamento aleatório.
|
||||
|
||||
JavaScript tem a função `Math.random()` que gera um número decimal aleatório entre `0` (incluso) e `1` (excluso). Assim, `Math.random()` pode retornar um `0` mas nunca retornará `1`.
|
||||
|
||||
**Nota:** Como [Armazenar Valores com Operador de Atribuição](/learn/javascript-algorithms-and-data-structures/basic-javascript/storing-values-with-the-assignment-operator), todas as chamadas de funções serão resolvidas antes de executar o `return`, para que possamos `returnar` o valor da função de `Math.random()`.
|
||||
**Observação:** como ao [armazenar valores com operador de atribuição](/learn/javascript-algorithms-and-data-structures/basic-javascript/storing-values-with-the-assignment-operator), todas as chamadas de funções serão resolvidas antes de executar o `return`, para que possamos dar ao `return` o valor da função `Math.random()`.
|
||||
|
||||
# --instructions--
|
||||
|
||||
|
||||
@ -9,11 +9,11 @@ dashedName: generate-random-whole-numbers-with-javascript
|
||||
|
||||
# --description--
|
||||
|
||||
É ótimo podermos gerar números decimais aleatórios, mas é ainda mais útil se usarmos para gerar números inteiros aleatórios.
|
||||
É ótimo podermos gerar números decimais aleatórios, mas é ainda mais útil se usarmos isso para gerar números inteiros aleatórios.
|
||||
|
||||
<ol><li>Use <code>Math.random()</code> para gerar um decimal aleatório.</li><li>Multiplique o decimal aleatório por <code>20</code>.</li><li>Use outra função, <code>Math.floor()</code> para arredondar o número para baixo para o número inteiro mais próximo.</li></ol>
|
||||
|
||||
Lembre-se que `Math.random()` pode nunca retornar um `1` e, porque nós estamos arredondando, é impossível receber examente `20`. Essa técnica nos dará um número inteiro entre `0` e `19`.
|
||||
Lembre-se de que `Math.random()` pode nunca retornar um `1` e, por estarmos arredondando, é impossível também receber `20`. Essa técnica nos dará um número inteiro entre `0` e `19`.
|
||||
|
||||
Juntando tudo, é assim que nosso código se parece:
|
||||
|
||||
@ -21,7 +21,7 @@ Juntando tudo, é assim que nosso código se parece:
|
||||
Math.floor(Math.random() * 20);
|
||||
```
|
||||
|
||||
Nós estamos chamando `Math.random()`, multiplicando o resultado por 20, e em seguida passando o valor para a função `Math.floor()` para arredondar o valor para o número inteiro para baixo mais próximo.
|
||||
Nós estamos chamando `Math.random()`, multiplicando o resultado por 20, e em seguida passando o valor para a função `Math.floor()` para arredondar o valor para o número inteiro mais próximo abaixo.
|
||||
|
||||
# --instructions--
|
||||
|
||||
|
||||
@ -9,7 +9,7 @@ dashedName: generate-random-whole-numbers-within-a-range
|
||||
|
||||
# --description--
|
||||
|
||||
Ao invés de gerar um número inteiro aleatório entre 0 e um número especificado como fizemos anteriormente, nós podemos gerar um número inteiro aleatório que cai entre um intervalo de dois números especificados.
|
||||
Ao invés de gerar um número inteiro aleatório entre 0 e um número especificado, como fizemos anteriormente, nós podemos gerar um número inteiro aleatório que fica em um intervalo entre dois números especificados.
|
||||
|
||||
Para isso, definiremos um número mínimo `min` e um número máximo`max`.
|
||||
|
||||
@ -21,7 +21,7 @@ Math.floor(Math.random() * (max - min + 1)) + min
|
||||
|
||||
# --instructions--
|
||||
|
||||
Crie uma função chamada `randomRange` que recebe um intervalo de `myMin` e `myMax` e retorne um número inteiro aleatório que é maior ou igual a `myMin`, e é menor ou igual a `myMax`, inclusivo.
|
||||
Crie uma função chamada `randomRange` que recebe um intervalo de `myMin` e `myMax` e retorne um número inteiro aleatório que é maior ou igual a `myMin`, e é menor ou igual a `myMax`.
|
||||
|
||||
# --hints--
|
||||
|
||||
|
||||
@ -9,19 +9,19 @@ dashedName: global-scope-and-functions
|
||||
|
||||
# --description--
|
||||
|
||||
Em JavaScript, <dfn>escopo</dfn> refere-se à visibilidade de variáveis. Variáveis que são definidas fora de um bloco de função tem o escopo <dfn>Global</dfn>. Isso significa, que elas podem ser vistas em qualquer lugar no seu código JavaScript.
|
||||
Em JavaScript, <dfn>escopo</dfn> refere-se à visibilidade de variáveis. Variáveis que são definidas fora de um bloco de função tem o escopo <dfn>Global</dfn>. Isso significa que elas podem ser vistas em qualquer lugar no seu código JavaScript.
|
||||
|
||||
Variáveis que são declaradas sem a palavra-chave `var` são automaticamente criadas no escopo `global`. Isso pode criar consequências indesejadas em outro lugar no seu código ou quando executando uma função novamente. Você sempre deve declarar suas variáveis com `var`.
|
||||
Variáveis que são declaradas sem a palavra-chave `var` são automaticamente criadas no escopo `global`. Isso pode criar consequências indesejadas em outro lugar no seu código ou quando executar uma função novamente. Você sempre deve declarar suas variáveis com `var`.
|
||||
|
||||
# --instructions--
|
||||
|
||||
Usando `var`, declare uma variável global chamada `myGlobal` fora de qualquer função. Inicialize ela com o valor de `10`.
|
||||
Usando `var`, declare uma variável global chamada `myGlobal` fora de qualquer função. Inicialize-a com o valor de `10`.
|
||||
|
||||
Dentro da função `fun1`, atribua `5` para `oopsGlobal` ***sem*** usar a palavra-chave `var`.
|
||||
|
||||
# --hints--
|
||||
|
||||
`myGlobal` deve ser definido
|
||||
`myGlobal` deve estar definida
|
||||
|
||||
```js
|
||||
assert(typeof myGlobal != 'undefined');
|
||||
|
||||
@ -9,7 +9,7 @@ dashedName: global-vs--local-scope-in-functions
|
||||
|
||||
# --description--
|
||||
|
||||
É possível ter ambas variáveis <dfn>local</dfn> e <dfn>global</dfn> com o mesmo nome. Quando você faz isso, a variável local tem precedência sobre a variável global.
|
||||
É possível ter as variáveis <dfn>local</dfn> e <dfn>global</dfn> com o mesmo nome. Quando você faz isso, a variável local tem precedência sobre a variável global.
|
||||
|
||||
Neste exemplo:
|
||||
|
||||
|
||||
@ -9,9 +9,9 @@ dashedName: golf-code
|
||||
|
||||
# --description--
|
||||
|
||||
No jogo de [golfe](https://en.wikipedia.org/wiki/Golf), cada buraco tem um `par`, significando o número médio de `strokes` que se espera que golfista faça a fim de derrubar a bola no buraco para completar a jogada. Dependendo do quão distante acima ou abaixo de `par` suas `strokes` estiverem, há diferentes apelidos.
|
||||
No jogo de [golfe](https://en.wikipedia.org/wiki/Golf), cada buraco tem um `par`, significando o número médio de `strokes` que se espera que golfista faça a fim de derrubar a bola no buraco para completar a jogada. Dependendo da distância acima ou abaixo de `par` que seu número de `strokes` estiver, há diferentes apelidos.
|
||||
|
||||
Sua função receberá os argumentos `par` e `strokes`. Retorna a string correta de acordo com esta tabela que lista os strokes em ordem de prioridade; superior (mais alta) para o final (mais baixo):
|
||||
Sua função receberá os argumentos `par` e `strokes`. Retorne a string correta de acordo com esta tabela que lista os strokes em ordem de prioridade; superior (mais alta) para o final (mais baixo):
|
||||
|
||||
<table class='table table-striped'><thead><tr><th>Strokes</th><th>Retorno</th></tr></thead><tbody><tr><td>1</td><td>"Hole-in-one!"</td></tr><tr><td><= par - 2</td><td>"Eagle"</td></tr><tr><td>par - 1</td><td>"Birdie"</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>"Double Bogey"</td></tr><tr><td>>= par + 3</td><td>"Go Home!"</td></tr></tbody></table>
|
||||
|
||||
|
||||
@ -21,11 +21,11 @@ i++;
|
||||
i = i + 1;
|
||||
```
|
||||
|
||||
**Nota:** A linha inteira se torna `i++;`, eliminando a necessidade do sinal de igual.
|
||||
**Observação:** a linha inteira torna-se `i++;`, eliminando a necessidade para o sinal de igual (atribuição).
|
||||
|
||||
# --instructions--
|
||||
|
||||
Modifique o código usando o operador `++` em `myVar`.
|
||||
Altere o código para usar o operador `++` na variável `myVar`.
|
||||
|
||||
# --hints--
|
||||
|
||||
|
||||
@ -9,17 +9,17 @@ dashedName: initializing-variables-with-the-assignment-operator
|
||||
|
||||
# --description--
|
||||
|
||||
É comum <dfn>inicializar</dfn> a variável com um valor inicial na mesma linha que declarada.
|
||||
É comum <dfn>inicializar</dfn> a variável com um valor inicial na mesma linha em que é declarada.
|
||||
|
||||
```js
|
||||
var myVar = 0;
|
||||
```
|
||||
|
||||
Cria uma nova variável chamada `myVar` e atribui o seu valor inicial como `0`.
|
||||
Crie uma nova variável chamada `myVar` e atribua o seu valor inicial como `0`.
|
||||
|
||||
# --instructions--
|
||||
|
||||
Define uma variável `a` com `var` e a inicializa com o valor de `9`.
|
||||
Defina uma variável `a` com `var` e a inicialize com o valor de `9`.
|
||||
|
||||
# --hints--
|
||||
|
||||
|
||||
@ -9,7 +9,7 @@ dashedName: introducing-else-statements
|
||||
|
||||
# --description--
|
||||
|
||||
Quando uma condição para uma instrução `if` for verdadeiro, o bloco de código seguinte será executado. E quando a condição for falsa? Normalmente nada aconteceria. Com uma instrução `else`, um bloco de código alternativo pode ser executado.
|
||||
Quando uma condição para uma instrução `if` for verdadeira, o bloco de código seguinte será executado. E quando a condição for falsa? Normalmente, nada aconteceria. Com uma instrução `else`, um bloco de código alternativo pode ser executado.
|
||||
|
||||
```js
|
||||
if (num > 10) {
|
||||
|
||||
@ -9,7 +9,7 @@ dashedName: iterate-through-an-array-with-a-for-loop
|
||||
|
||||
# --description--
|
||||
|
||||
Uma tarefa comum em JavaScript é para iterar através do conteúdo de um array. Uma forma de fazer isso é com um laço `for`. Esse código irá exibir cada elemento do array `arr` no console:
|
||||
Uma tarefa comum em JavaScript é para iterar através do conteúdo de um array. Uma forma de fazer isso é com um laço `for`. Esse código vai exibir cada elemento do array `arr` no console:
|
||||
|
||||
```js
|
||||
var arr = [10, 9, 8, 7, 6];
|
||||
@ -18,7 +18,7 @@ for (var i = 0; i < arr.length; i++) {
|
||||
}
|
||||
```
|
||||
|
||||
Lembre-se de que arrays têm indexação baseada em zero, o que significa que o último índice do array é de `length - 1`. Nossa condição para esse laço é `i < arr.length`, a qual interrompe o laço quando `i` é igual a `length`. Nesse caso a última iteração é ` i === 4` i.e. quando `i` se tornar igual a `arr.length - 1` e exibe `6` no console. Em seguida, `i` aumenta para `5`, e o laço é interrompido porque `i < arr.length` é `false`.
|
||||
Lembre-se de que arrays têm indexação baseada em zero, o que significa que o último índice do array é de `length - 1`. Nossa condição para esse laço é `i < arr.length`, que interrompe o laço quando `i` é igual a `length`. Nesse caso a última iteração é `i === 4`, ou seja, quando `i` se tornar igual a `arr.length - 1` e exibir `6` no console. Em seguida, `i` aumenta para `5`, e o laço é interrompido porque `i < arr.length` é `false`.
|
||||
|
||||
# --instructions--
|
||||
|
||||
|
||||
@ -9,7 +9,7 @@ dashedName: iterate-with-javascript-do---while-loops
|
||||
|
||||
# --description--
|
||||
|
||||
O próximo tipo de laço que você aprenderá é chamado de laço `do...while`. É chamado um laço `do...while` porque primeiro irá toda vez `fazer (do)`, ou executar, uma vez o bloco de código após a instrução do, não importa o que acontecer, e então continuará a executar o laço `enquanto (while)` a condição for `true`.
|
||||
O próximo tipo de laço que você aprenderá é chamado de laço `do...while`. O laço `do...while` é chamado assim porque primeiro fará algo (`do`) ou executará algo uma vez dentro do bloco de código, não importando o que acontecer. Em seguida, continuará a executar o laço enquanto (`while`) a condição for `true`.
|
||||
|
||||
```js
|
||||
var ourArray = [];
|
||||
@ -31,7 +31,7 @@ while (i < 5) {
|
||||
}
|
||||
```
|
||||
|
||||
Nesse exemplo, inicializamos o valor de `ourArray` como um array vazio e o valor de `i` sendo 5. Quando executamos o laço `while`, a condição é igual a `false` porque `i` não é menor que 5, portanto nós não executamos o código dentro do laço. O resultado é que `ourArray` terminará sem valores adicionados a ele, e ainda se parecerá com `[]` quando todas as linhas do código no exemplo acima for completamente executadas. Agora, dê uma olhada no laço `do...while`:
|
||||
Nesse exemplo, inicializamos o valor de `ourArray` como um array vazio e o valor de `i` sendo 5. Quando executamos o laço `while`, a condição é igual a `false` porque `i` não é menor que 5, portanto nós não executamos o código dentro do laço. O resultado é que `ourArray` terminará sem valores adicionados a ele, e ainda se parecerá com `[]` quando todas as linhas do código no exemplo acima forem completamente executadas. Agora, dê uma olhada no laço `do...while`:
|
||||
|
||||
```js
|
||||
var ourArray = [];
|
||||
@ -42,7 +42,7 @@ do {
|
||||
} while (i < 5);
|
||||
```
|
||||
|
||||
Nesse caso, nós inicializamos o valor de `i` para 5, assim como fizemos com o laço `while`. Quando chegamos na próxima linha, não há condição a ser analisada, então nós vamos ao código dentro das chaves e o executamos. Nós adicionaremos um único elemento ao array e então incrementamos `i` antes de chegarmos a verificação da condição. Quando nós finalmente temos o resultado da condição `i < 5` na última linha, nós notamos que `i` agora é 6, o que não cumpre a verificação da condição, então nós saímos do laço e terminamos. Ao final do exemplo acima, o valor de `ourArray` é `[5]`. Essencialmente, um laço `do...while` garante que o código dentro do laço será executado pelo menos uma vez. Vamos tentar fazer um laço `do...while` funcionar empurrando valores para um array.
|
||||
Nesse caso, nós inicializamos o valor de `i` para 5, assim como fizemos com o laço `while`. Quando chegamos na próxima linha, não há condição a ser analisada, então nós vamos ao código dentro das chaves e o executamos. Nós adicionaremos um único elemento ao array e então incrementamos `i` antes de chegarmos à verificação da condição. Quando nós finalmente temos o resultado da condição `i < 5` na última linha, nós notamos que `i` agora é 6, o que não cumpre a verificação da condição, então nós saímos do laço e terminamos. Ao final do exemplo acima, o valor de `ourArray` é `[5]`. Essencialmente, um laço `do...while` garante que o código dentro do laço será executado pelo menos uma vez. Vamos tentar fazer um laço `do...while` funcionar inserindo valores em um array.
|
||||
|
||||
# --instructions--
|
||||
|
||||
|
||||
@ -11,15 +11,15 @@ dashedName: iterate-with-javascript-for-loops
|
||||
|
||||
Você pode rodar o mesmo código várias vezes usando um laço.
|
||||
|
||||
O tipo mais comum de laço JavaScript é chamado de laço `for` porque ele é executado por um número especificado de vezes.
|
||||
O tipo mais comum de laço JavaScript é chamado de laço `for`, porque ele é executado por um número especificado de vezes.
|
||||
|
||||
Laços For são declarados com três expressões opcionais separadas por ponto e vírgula:
|
||||
Laços for são declarados com três expressões opcionais separadas por ponto e vírgula:
|
||||
|
||||
`for (a; b; c)`, onde `a` é a declaração de inicialização, `b` é a declaração de condição, e `c` é a expressão final.
|
||||
|
||||
A declaração de inicialização é executada apenas uma vez antes do laço iniciar. Normalmente é usado para definir e configurar sua variável de laço.
|
||||
A declaração de inicialização é executada apenas uma vez antes de o laço iniciar. Normalmente, é usada para definir e configurar sua variável de laço.
|
||||
|
||||
A declaração de condição é verificada no início de cada iteração do laço e irá continuar enquanto seu valor for `true`. Quando a condição for `false` no início da iteração, o laço irá parar de executar. Isso significa que se a condição de início for falsa, seu laço nunca será executado.
|
||||
A declaração de condição é verificada no início de cada iteração do laço e vai continuar enquanto seu valor for `true`. Quando a condição for `false` no início da iteração, o laço vai parar de executar. Isso significa que se a condição de início for falsa, seu laço nunca será executado.
|
||||
|
||||
A expressão final é executada no final de cada iteração do laço, antes da verificação da próxima condição e normalmente é usada para incrementar ou decrementar o contador do laço.
|
||||
|
||||
|
||||
@ -9,7 +9,7 @@ dashedName: iterate-with-javascript-while-loops
|
||||
|
||||
# --description--
|
||||
|
||||
Você pode rodar o mesmo código várias vezes ao usar um laço.
|
||||
Você pode rodar o mesmo código várias vezes usando um laço.
|
||||
|
||||
O primeiro tipo de laço que aprenderemos é chamado de laço `while` porque ele irá rodar enquanto uma condição específica for verdadeira e irá parar uma vez que a condição não for mais verdadeira.
|
||||
|
||||
@ -22,13 +22,13 @@ while(i < 5) {
|
||||
}
|
||||
```
|
||||
|
||||
No código de exemplo acima, o laço `while` executará por 5 vezes e adicionará os números de 0 até 4 ao `ourArray`.
|
||||
No código de exemplo acima, o laço `while` executará por 5 vezes e adicionará os números de 0 até 4 a `ourArray`.
|
||||
|
||||
Vamos tentar fazer um laço while funcionar empurrando valores para um array.
|
||||
|
||||
# --instructions--
|
||||
|
||||
Adicione os números de 5 até 1 (inclusivo) em ordem descendente para `myArray` usando um laço `while`.
|
||||
Adicione os números de 5 até 1 (inclusive) em ordem descendente para `myArray` usando um laço `while`.
|
||||
|
||||
# --hints--
|
||||
|
||||
|
||||
@ -9,7 +9,7 @@ dashedName: nesting-for-loops
|
||||
|
||||
# --description--
|
||||
|
||||
Se você possui um array multidimensional, você pode usar a mesma lógica no ponto de passagem anterior para iterar através ambos os arrays e qualquer sub-arrays. Aqui está um exemplo:
|
||||
Se você possui um array multidimensional, você pode usar a mesma lógica no ponto de passagem anterior para iterar através ambos os arrays e qualquer sub-arrays. Exemplo:
|
||||
|
||||
```js
|
||||
var arr = [
|
||||
|
||||
@ -13,7 +13,7 @@ Quando as variáveis de JavaScript são declaradas, elas têm um valor inicial d
|
||||
|
||||
# --instructions--
|
||||
|
||||
Inicialize as três variáveis `a`, `b` e `c` com `5`, `10`, e `"Sou a"` respectivamente para que eles não sejam `undefined`.
|
||||
Inicialize as três variáveis `a`, `b` e `c` com `5`, `10`, e `"I am a"` respectivamente para que eles não sejam `undefined`.
|
||||
|
||||
# --hints--
|
||||
|
||||
@ -29,7 +29,7 @@ assert(typeof a === 'number' && a === 6);
|
||||
assert(typeof b === 'number' && b === 15);
|
||||
```
|
||||
|
||||
`c` não deve conter `undefined` e deve ter o valor da string `eu sou uma String!`
|
||||
`c` não deve conter `undefined` e o valor da string deve ser `I am a String!`
|
||||
|
||||
```js
|
||||
assert(!/undefined/.test(c) && c === 'I am a String!');
|
||||
|
||||
@ -17,7 +17,7 @@ A chamada da função se parece com:
|
||||
parseInt(string, radix);
|
||||
```
|
||||
|
||||
E aqui um exemplo:
|
||||
Exemplo:
|
||||
|
||||
```js
|
||||
var a = parseInt("11", 2);
|
||||
|
||||
@ -9,7 +9,7 @@ dashedName: use-the-parseint-function
|
||||
|
||||
# --description--
|
||||
|
||||
A função `parseInt()` analisa uma string e retorna um inteiro. Aqui está um exemplo:
|
||||
A função `parseInt()` analisa uma string e retorna um inteiro. Exemplo:
|
||||
|
||||
```js
|
||||
var a = parseInt("007");
|
||||
|
||||
Reference in New Issue
Block a user