fix(guide): simplify directory structure

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/access-array-data-with-indexes/index.md

@@ -0,0 +1,17 @@
+---
+title: Access Array Data with Indexes
+localeTitle: Dados de Matriz de Acesso com Índices
+---
+## Dados de Matriz de Acesso com Índices
+
+O primeiro elemento de um array está na posição zero. Então, se você quiser acessar o primeiro elemento de um array, você pode fazer assim:
+
+```javascript
+var arr = ["Programming", 123, "Coding", 789]; 
+ 
+ var firstElem = arr[0] // This is "Programming" 
+ var thirdElem = arr[2] // This is "Coding" 
+ var fourthElem = arr[3] // This is 789 
+```
+
+Observe que o comprimento da matriz é 4 e a posição do último elemento da matriz é 3.

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/access-multi-dimensional-arrays-with-indexes/index.md

@@ -0,0 +1,29 @@
+---
+title: Access Multi-Dimensional Arrays With Indexes
+localeTitle: Acessar matrizes multi-dimensionais com índices
+---
+## Acessar matrizes multi-dimensionais com índices
+
+Considere o seguinte array multidimensional:
+
+```javascript
+var arr = [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]; 
+```
+
+Isto é o que parece em forma de tabela.
+
+| Posição | 0 | 1 | 2 | 3 | | --- | --- | --- | --- | --- | | **0** | 1 | 4 | 7 | 10 | | **1** | 2 | 5 | 8 | 11 | | **2** | 3 | 6 | 9 | 12 |
+
+Agora tudo que você precisa fazer é escolher as coordenadas dos dados que você deseja! Por exemplo, se queremos que `myNum` seja igual a 8, então ...
+
+```javascript
+var myNum = arr[2][1]; // Equal to 8 
+```
+
+Ou, se você quer que seja igual a 1. Você faz…
+
+```javascript
+var myNum = arr[0][0]; // Equal to 1 
+```
+
+Primeiro você começa escolhendo em qual coluna o número está, depois escolhe a linha. É como o plano de coordenadas xy!

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/accessing-nested-arrays/index.md

@@ -0,0 +1,69 @@
+---
+title: Accessing Nested Arrays
+localeTitle: Acessando matrizes aninhadas
+---
+## Acessando matrizes aninhadas
+
+### Acessando elementos em uma matriz usando a notação de colchetes `[]`
+
+```js
+var fruitBasket = ['apple', 'banana' 'orange', 'melon']; 
+ var favoriteFruit = fruitBasket[2]; 
+ 
+ console.log(favoriteFruit) // 'orange' 
+```
+
+Neste exemplo, nossa fruta favorita é 'laranja', que está no índice `2` na matriz `fruitBasket` . Usando a notação do braket, atribuímos o índice `2` da matriz `fruitBasket` ao `favoriteFruit` . Isso faz com que `favoriteFruit` igual a "laranja".
+
+### Acessando objetos dentro de matrizes usando braket `[]` e dot `.` notação
+
+```js
+var garage = [ 
+  { 
+    type: 'car', 
+    color: 'red', 
+    make: 'Ford' 
+  }, 
+  { 
+    type: 'motorbike', 
+    color: 'black', 
+    make: 'Yamaha' 
+  }, 
+  { 
+    type: 'bus', 
+    color: 'yellow', 
+    make: 'Blue Bird' 
+  } 
+ ]; 
+ 
+ var busColor = garage[2].color; // 'yellow' 
+```
+
+## Solução:
+
+```js
+// Setup 
+ var myPlants = [ 
+  { 
+    type: "flowers", 
+    list: [ 
+      "rose", 
+      "tulip", 
+      "dandelion" 
+    ] 
+  }, 
+  { 
+    type: "trees", 
+    list: [ 
+      "fir", 
+      "pine", 
+      "birch" 
+    ] 
+  } 
+ ]; 
+ 
+ // Only change code below this line 
+ 
+ var secondTree = myPlants[1].list[1]; 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/accessing-nested-objects/index.md

@@ -0,0 +1,50 @@
+---
+title: Accessing Nested Objects
+localeTitle: Acessando Objetos Aninhados
+---
+## Acessando Objetos Aninhados
+
+Dica: **_"Use a notação de colchetes para propriedades com um espaço em seus nomes"._**
+
+Se olharmos para o nosso objeto:
+
+```javascript
+var myStorage = { 
+  "car": { 
+    "inside": { 
+      "glove box": "maps", 
+      "passenger seat": "crumbs" 
+     }, 
+    "outside": { 
+      "trunk": "jack" 
+    } 
+  } 
+ }; 
+```
+
+Nosso nome de objeto é `myStorage` .
+
+| - Dentro disso, temos um objeto aninhado chamado `car` .
+
+| --- Por dentro temos mais dois chamados `inside` e `outside` cada um com seus propriedades próprias
+
+Você pode visualizar a estrutura do objeto assim, se isso ajudar:
+```
+myStorage 
+ |-- car 
+ |--- inside 
+ |----- glove box: maps 
+ |----- passenger seat: crumbs 
+ |--- outside 
+ |----- trunk: jack 
+```
+
+Somos solicitados a atribuir o conteúdo do `glove box` , o que podemos ver está aninhado no objeto `inside` , que por sua vez, é aninhado no objeto de `car` .
+
+Podemos usar a notação de pontos para acessar o `glove box` - `glove box` seguinte maneira:
+
+```javascript
+var gloveBoxContents = myStorage.car.inside'complete here' 
+```
+
+Você deve substituir `complete here` com a maneira correta de acessar a propriedade. Veja a pista acima se você ficar preso.

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-bracket-notation/index.md

@@ -0,0 +1,21 @@
+---
+title: Accessing Object Properties with Bracket Notation
+localeTitle: Acessando propriedades de objeto com notação de suporte
+---
+## Acessando propriedades de objeto com notação de suporte
+
+Aqui está uma solução possível:
+
+```js
+var testObj = { 
+  "an entree": "hamburger", 
+  "my side": "veggies", 
+  "the drink": "water" 
+ }; 
+ 
+ // Only change code below this line 
+ 
+ var entreeValue = testObj["an entree"];   // Change this line 
+ var drinkValue = testObj["the drink"];    // Change this line 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-dot-notation/index.md

@@ -0,0 +1,21 @@
+---
+title: Accessing Object Properties with Dot Notation
+localeTitle: Acessando propriedades de objeto com notação de ponto
+---
+## Acessando propriedades de objeto com notação de ponto
+
+Aqui está uma solução possível:
+
+```js
+var testObj = { 
+  "hat": "ballcap", 
+  "shirt": "jersey", 
+  "shoes": "cleats" 
+ }; 
+ 
+ // Only change code below this line 
+ 
+ var hatValue = testObj.hat;      // Change this line 
+ var shirtValue = testObj.shirt;    // Change this line 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-variables/index.md

@@ -0,0 +1,22 @@
+---
+title: Accessing Object Properties with Variables
+localeTitle: Acessando propriedades de objetos com variáveis
+---
+## Acessando propriedades de objetos com variáveis
+
+Aqui está uma solução de trabalho, caso você esteja preso:
+
+```js
+// Setup 
+ var testObj = { 
+  12: "Namath", 
+  16: "Montana", 
+  19: "Unitas" 
+ }; 
+ 
+ // Only change code below this line; 
+ 
+ var playerNumber = 16;       // Change this Line 
+ var player = testObj[playerNumber];   // Change this Line 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/add-new-properties-to-a-javascript-object/index.md

@@ -0,0 +1,33 @@
+---
+title: Add New Properties to a JavaScript Object
+localeTitle: Adicionar novas propriedades a um objeto JavaScript
+---
+## Adicionar novas propriedades a um objeto JavaScript
+
+Aqui está o exemplo:
+
+```js
+var ourDog = { 
+  "name": "Camper", 
+  "legs": 4, 
+  "tails": 1, 
+  "friends": ["everything!"] 
+ }; 
+ 
+ ourDog.bark = "bow-wow"; 
+```
+
+Aqui está uma solução:
+
+```js
+var myDog = { 
+  "name": "Happy Coder", 
+  "legs": 4, 
+  "tails": 1, 
+  "friends": ["freeCodeCamp Campers"] 
+ }; 
+ 
+ // Only change code below this line. 
+ myDog.bark = "woof"; 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/add-two-numbers-with-javascript/index.md

@@ -0,0 +1,11 @@
+---
+title: Add Two Numbers with JavaScript
+localeTitle: Adicione dois números com JavaScript
+---
+# Adicione dois números com JavaScript
+
+JavaScript usa o símbolo `+` para adição.
+```
+var sum = 10 + 10; //sum gets the value 20 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/adding-a-default-option-in-switch-statements/index.md

@@ -0,0 +1,28 @@
+---
+title: Adding a Default Option in Switch Statements
+localeTitle: Adicionando uma opção padrão em instruções de troca
+---
+# Adicionando uma opção padrão em instruções de troca
+
+*   Adicionar uma opção padrão garante que, caso sua variável não corresponda a nenhuma das opções, o padrão será usado.
+
+## Solução:
+
+```javascript
+function switchOfStuff(val) { 
+  var answer = ""; 
+ 
+  switch(val){ 
+    case 'a': answer = 'apple'; 
+    break; 
+    case 'b': answer = 'bird'; 
+    break; 
+    case 'c': answer = 'cat'; 
+    break; 
+    default: answer = 'stuff'; 
+  } 
+ 
+  return answer; 
+ } 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/appending-variables-to-strings/index.md

@@ -0,0 +1,13 @@
+---
+title: Appending Variables to Strings
+localeTitle: Anexando variáveis ​​a seqüências de caracteres
+---
+## Anexando variáveis ​​a seqüências de caracteres
+
+Verifique se a ortografia e o espaçamento estão corretos. Anexar strings (armazenadas dentro de variáveis) pode ser feito da seguinte forma:
+```
+var adj = "happy!"; 
+ var sent = "Today, I woke up being "; 
+ sent += adj; // The result is "Today, I woke up being happy!" 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/assignment-with-a-returned-value/index.md

@@ -0,0 +1,14 @@
+---
+title: Assignment with a Returned Value
+localeTitle: Atribuição com um valor retornado
+---
+## Atribuição com um valor retornado
+
+As funções agem como espaços reservados para os dados que eles geram. Basicamente, você pode atribuir a saída de uma função a uma variável, assim como qualquer dado normal.
+
+Aqui está a solução básica de código:
+
+```javascript
+processed = processArg(7); // Equal to 2 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/build-javascript-objects/index.md

@@ -0,0 +1,19 @@
+---
+title: Build JavaScript Objects
+localeTitle: Construa objetos JavaScript
+---
+# Construa objetos JavaScript
+
+Os objetos são semelhantes aos arrays, exceto que, em vez de usar índices para acessar e modificar seus dados, você acessa os dados em objetos por meio do que são chamados de propriedades.
+
+Aqui está um objeto de amostra:
+```
+var cat = { 
+    "name": "Whiskers", 
+    "legs": 4, 
+    "tails": 1, 
+    "enemies": ["Water", "Dogs"] 
+ }; 
+```
+
+Os objetos são úteis para armazenar dados de maneira estruturada e podem representar objetos do mundo real, como os gatos.

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/chaining-if-else-statements/index.md

@@ -0,0 +1,63 @@
+---
+title: Chaining If Else Statements
+localeTitle: Encadeamento Se Mais Declarações
+---
+## Encadeamento Se Mais Declarações
+
+*   `If` : o primeiro condicional em toda instrução if / else, caso a condicional seja _verdadeira_ , execute o código e ignore o resto.
+*   `Else if` : nunca pode ser usado como o primeiro condicional. É sempre uma condicional depois de um `if` , caso a condicional seja verdadeira, execute o código. Caso contrário, salta para o próximo condicional.
+*   `Else` : caso todas as condicionais anteriores sejam _falsas_ , **outra** é executada.
+
+### Explicação do problema:
+
+_Escreva encadeado `if` / `else if` instruções preencherem as seguintes condições_ :
+
+_`num < 5` - retorna "minúsculo" `num < 10` - retorna "Pequeno" `num < 15` - return "Medium" `num < 20` - retorna "Grande" `num >= 20` - retornar "Enorme"_
+
+#### Sugestão 1
+
+Lembre-se de que você pode combinar (encadear) várias declarações `if...else` uma após a outra até que a última use `else if (condition) {do this}` .
+
+> _tente resolver o problema agora_
+> 
+> #### Sugestão 2
+> 
+> Às vezes, quando você escreve mais código do que você está acostumado e isso não funciona, as pequenas coisas são o que nos traem. A verificação da falta de ponto-e-vírgula, colchetes etc. pode ser muito útil. _tente resolver o problema agora_
+
+## Alerta de spoiler!
+
+**Solução à frente!**
+
+## Solução:
+
+```javascript
+function testSize(num) { 
+  // Only change code below this line 
+  if (num < 5){ 
+    return "Tiny"; 
+  } 
+  else if (num < 10) { 
+    return "Small"; 
+  } 
+  else if (num < 15){ 
+    return "Medium"; 
+  } 
+  else if (num < 20){ 
+    return "Large"; 
+  } 
+  else { 
+    return "Huge"; 
+  } 
+  // Only change code above this line 
+ } 
+```
+
+· Executar código em [repl.it](https://repl.it/@AdrianSkar/Basic-JS-Chaining-ifelse-statements)
+
+### Explicação de código
+
+A função primeiro verifica a condição `if` `(num < 5)` . Se for avaliado como `true` , retorna a instrução entre as chaves ("Tiny"). Se isso não acontecer, ele verifica a próxima condição até a última instrução `else` .
+
+### Recursos
+
+*   ["if… else" - _Referência do MDN JavaScript_](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/if…else)

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/comment-your-javascript-code/index.md

@@ -0,0 +1,22 @@
+---
+title: Comment Your JavaScript Code
+localeTitle: Comente seu código JavaScript
+---
+## Comente seu código JavaScript
+
+Comentar permite que você digite coisas que você não quer que o computador execute como código. Por exemplo, notas para outros programadores, direções e mais. Veja como criar um comentário de linha única.
+```
+// Hey, I'm a comment! 
+```
+
+Agora, se você quiser comentar um parágrafo inteiro, isso pode ser facilmente realizado com…
+```
+/* 
+  Hey, I'm a paragraph comment. 
+  This allows for programmers to 
+  write tons and tons of random 
+  words, without the fear of me 
+  being compiled! 
+ */ 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-equality-operator/index.md

@@ -0,0 +1,46 @@
+---
+title: Comparison with the Equality Operator
+localeTitle: Comparação com o operador de igualdade
+---
+## Comparação com o operador de igualdade
+
+### Explicação do problema:
+
+_Adicione o operador de igualdade à linha indicada para que a função retorne "Equal" quando `val` é equivalente a 12._
+
+#### Sugestão 1
+
+Lembre-se que a _igualdade é diferente da atribuição ( `=` ), que atribui o valor à direita do operador a uma variável à esquerda._ [1](#cite1)
+
+> _tente resolver o problema agora_
+
+## Alerta de spoiler!
+
+**Solução à frente!**
+
+## Solução básica de código:
+
+```javascript
+function testEqual(val) { 
+  if (val == 12) { // Change this line 
+    return "Equal"; 
+  } 
+  return "Not equal"; 
+ } 
+ // Change this value to test 
+ testEqual(10); 
+```
+
+· [Executar código em repl.it](https://repl.it/@AdrianSkar/Basic-JS-Equality-operator)
+
+### Explicação de código
+
+A função primeiro avalia `if` a condição `(val == 12)` avaliada como `true` . Em caso afirmativo, retorna a instrução entre as chaves ("Equal"). Caso contrário, retorna a próxima instrução de `return` fora deles ("Não é igual").
+
+### Fontes
+
+1 ["JavaScript Básico: Comparação com o Operador de Igualdade", lição do fCC em _Algoritmos de Javascript e Certificação de Estruturas de Dados_](https://learn.freecodecamp.org/javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-equality-operator)
+
+### Recursos
+
+*   ["Operador de igualdade" - _referência do MDN JavaScript_](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Equality_())

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-greater-than-operator/index.md

@@ -0,0 +1,22 @@
+---
+title: Comparison with the Greater Than Operator
+localeTitle: Comparação com o operador Maior que
+---
+## Comparação com o operador Maior que
+
+`>` (Maior que) é um operador lógico que retorna caso verdadeiro o valor à esquerda é maior que o da direita.
+
+## Solução Básica
+
+```javascript
+function testGreaterThan(val) { 
+  if (val > 100) 
+    return "Over 100"; 
+ 
+  if (val > 10) 
+    return "Over 10"; 
+ 
+  return "10 or Under"; 
+ } 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-greater-than-or-equal-to-operator/index.md

@@ -0,0 +1,22 @@
+---
+title: Comparison with the Greater Than Or Equal To Operator
+localeTitle: Comparação com o maior que ou igual ao operador
+---
+## Comparação com o maior que ou igual ao operador
+
+*   `>=` (Maior que ou Igual a) é um operador lógico que retorna caso verdadeiro o valor à esquerda é o **mesmo ou maior** que o da direita.
+
+## Solução Básica
+
+```javascript
+function testGreaterOrEqual(val) { 
+  if (val >= 20) 
+    return "20 or Over"; 
+ 
+  if (val >= 10) 
+    return "10 or Over"; 
+ 
+  return "Less than 10"; 
+ } 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-inequality-operator/index.md

@@ -0,0 +1,20 @@
+---
+title: Comparison with the Inequality Operator
+localeTitle: Comparação com o operador Inequality
+---
+## Comparação com o operador Inequality
+
+*   `!=` (Inequality) é um operador lógico que retorna caso verdadeiro, o valor à esquerda é diferente daquele à direita.
+*   O operador de desigualdade considera `7` e `"7"` o mesmo porque não compara o tipo da variável.
+
+## Solução Básica
+
+```javascript
+function testNotEqual(val) { 
+  if (val != 99) 
+    return "Not Equal"; 
+ 
+  return "Equal"; 
+ } 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-less-than-operator/index.md

@@ -0,0 +1,22 @@
+---
+title: Comparison with the Less Than Operator
+localeTitle: Comparação com o menor que o operador
+---
+## Comparação com o menor que o operador
+
+**`<`** (Less Than) é um operador lógico que retorna caso verdadeiro, o valor à esquerda é menor que o da direita.
+
+## Solução Básica
+
+```javascript
+function testLessThan(val) { 
+  if (val < 25) 
+    return "Under 25"; 
+ 
+  if (val < 55) 
+    return "Under 55"; 
+ 
+  return "55 or Over"; 
+ } 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-less-than-or-equal-to-operator/index.md

@@ -0,0 +1,22 @@
+---
+title: Comparison with the Less Than Or Equal To Operator
+localeTitle: Comparação com o menor ou igual ao operador
+---
+## Comparação com o menor ou igual ao operador
+
+**`<=`** (Menor que ou igual a) é um operador lógico que retorna caso verdadeiro o valor à esquerda é o **mesmo ou menor** que o da direita.
+
+## Solução Básica
+
+```javascript
+function testLessOrEqual(val) { 
+  if (val <= 12) 
+    return "Smaller Than or Equal to 12"; 
+ 
+  if (val <= 24) 
+    return "Smaller Than or Equal to 24"; 
+ 
+  return "More Than 24"; 
+ } 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-strict-equality-operator/index.md

@@ -0,0 +1,56 @@
+---
+title: Comparison with the strict equality operator
+localeTitle: Comparação com o operador estrito de igualdade
+---
+## Comparação com o operador estrito de igualdade
+
+### Explicação do problema:
+
+· _Use o operador de igualdade estrito na instrução `if` para que a função retorne "Equal" quando `val` for estritamente igual a `7` ._
+
+#### Sugestão 1
+
+Lembre-se do exercício anterior que a _igualdade é diferente da atribuição ( `=` ), que atribui o valor à direita do operador a uma variável à esquerda._ [1](#cite1)
+
+> _tente resolver o problema agora_
+> 
+> #### Sugestão 2
+> 
+> _Ao contrário do operador de igualdade, que tenta converter os dois valores sendo comparados a um tipo comum, o operador de igualdade estrita não executa uma conversão de tipo._ [2](#cite2) _tente resolver o problema agora_
+
+## Alerta de spoiler!
+
+**Solução à frente!**
+
+## Solução básica de código:
+
+```javascript
+// Setup 
+ function testStrict(val) { 
+  if (val === 7) { // Change this line 
+    return "Equal"; 
+  } 
+  return "Not equal"; 
+ } 
+ 
+ // Change this value to test 
+ testStrict(10); 
+```
+
+### Explicação de código
+
+A função primeiro avalia `if` a condição `(val === 7)` avaliada como `true` . Em caso afirmativo, retorna a instrução entre as chaves ("Equal"). Caso contrário, retorna a próxima instrução de `return` fora deles ("Não é igual").
+
+### Fontes
+
+1 ["JavaScript Básico: Comparação com o Operador de Igualdade", lição do fCC em _Algoritmos de Javascript e Certificação de Estruturas de Dados_](https://learn.freecodecamp.org/javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-equality-operator)
+
+2 ["JavaScript Básico: Comparação com o Operador de Igualdade Estrita", lição do fCC em _Algoritmos de Javascript e Certificação de Estruturas de Dados_](https://learn.freecodecamp.org/javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-strict-equality-operator)
+
+### Recursos
+
+*   ["if… else" - _Referência do MDN JavaScript_](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/if…else)
+    
+*   [Kondov, Alexander. "Entendendo JS: Coerção". _Hackernoon_](https://hackernoon.com/understanding-js-coercion-ff5684475bfc) , acessado em 15 de setembro de 2018
+    
+*   ["Operadores de comparação" - _referência do MDN JavaScript_](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators)

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-strict-inequality-operator/index.md

@@ -0,0 +1,41 @@
+---
+title: Comparison with the Strict Inequality Operator
+localeTitle: Comparação com o Operador Estrito da Desigualdade
+---
+## Comparação com o Operador Estrito da Desigualdade
+
+### Explicação do problema:
+
+· _Adicione o `strict inequality operator` à instrução `if` para que a função retorne "Not Equal" quando `val` não for estritamente igual a `17` ._
+
+#### Sugestão 1
+
+O operador de desigualdade estrita ( `!==` ) retornará `true` se o primeiro valor não for igual ao segundo considerando o tipo de valor.
+
+> _tente resolver o problema agora_
+
+## Alerta de spoiler!
+
+**Solução à frente!**
+
+## Solução básica de código:
+
+```javascript
+function testStrictNotEqual(val) { 
+  if (val !== 17) { 
+    return "Not equal"; 
+  } 
+  return "Equal"; 
+ } 
+ 
+ // Change this value to test 
+ testStrictNotEqual(10); 
+```
+
+### Explicação de código
+
+A função primeiro avalia `if` a condição `(val !== 17)` avaliada como `true` considerando tanto o valor quanto o tipo de valor. Em caso afirmativo, retorna a instrução entre as chaves ("Não é igual"). Caso contrário, retorna a próxima instrução de `return` fora deles ("Equal").
+
+### Recursos
+
+*   ["Não-identidade / desigualdade estrita (! ==)" - _Referência do MDN JavaScript_](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Non-identity_strict_inequality_(!))

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/comparisons-with-the-logical-and-operator/index.md

@@ -0,0 +1,53 @@
+---
+title: Comparisons with the && (logical AND) operator
+localeTitle: Comparações com o operador && (AND lógico)
+---
+## Comparações com o operador && (AND lógico)
+
+### Explicação do problema:
+
+· _Combine as duas declarações if em uma instrução que retornará `"Yes"` se `val` for menor ou igual a `50` e maior ou igual a `25` . Caso contrário, retornará `"No"` ._
+
+#### Sugestão 1
+
+O operador lógico AND ( `&&` ) compara ambas as declarações e retorna `true` somente se ambas forem verdadeiras ou puderem ser convertidas para true (verdade).
+
+> _tente resolver o problema agora_
+
+#### Sugestão 2
+
+Lembre-se de que esse efeito também pode ser obtido aninhando- `if` instruções.
+
+> _tente resolver o problema agora_
+
+## Alerta de spoiler!
+
+**Solução à frente!**
+
+## Solução básica de código:
+
+```javascript
+function testLogicalAnd(val) { 
+  // Only change code below this line 
+ 
+  if (val <= 50 && val >= 25) { 
+      return "Yes"; 
+  } 
+ 
+  // Only change code above this line 
+  return "No"; 
+ } 
+ 
+ // Change this value to test 
+ testLogicalAnd(10); 
+```
+
+· [Executar código em repl.it](https://repl.it/@AdrianSkar/Basic-JS-Comparison-with-the-and-operator)
+
+### Explicação de código
+
+A função primeiro avalia `if` a condição `val <= 50` avaliada como `true` `val` conversão para um número se necessário, então faz o mesmo com `val >=25` por causa do operador lógico AND ( `&&` ); se ambos retornarem true, a instrução `return "Yes"` será executada.
+
+### Recursos
+
+*   ["Operadores lógicos" - _Referência do MDN JavaScript_](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Logical_Operators)

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/comparisons-with-the-logical-or-operator/index.md

@@ -0,0 +1,19 @@
+---
+title: Comparisons with the Logical Or Operator
+localeTitle: Comparações com o lógico ou operador
+---
+## Comparações com o lógico ou operador
+
+### Guia: Siga o código dado no exemplo
+
+**Alerta de Spoiler**
+
+Abaixo está o código de exemplo (a maneira mais simples).
+
+```javascript
+if ( val < 10 || val > 20 ) { 
+    return "Outside"; 
+ } 
+```
+
+O código acima retornará "Outside" somente se `val` estiver entre 10 e 20 (inclusive).

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-addition/index.md

@@ -0,0 +1,12 @@
+---
+title: Compound Assignment With Augmented Addition
+localeTitle: Atribuição composta com adição aumentada
+---
+## Atribuição composta com adição aumentada
+
+Computadores lidos da esquerda para a direita. Então, usando o operador '+ =' significa que a variável é adicionada com o número correto, então a variável é atribuída à soma. Igual a:
+```
+var a = 9; 
+ a += 10; // Now, 'a' is equal to 19 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-division/index.md

@@ -0,0 +1,12 @@
+---
+title: Compound Assignment With Augmented Division
+localeTitle: Atribuição Composta Com Divisão Aumentada
+---
+## Atribuição Composta Com Divisão Aumentada
+
+Computadores lidos da esquerda para a direita. Então, usando o operador '/ =' significa que a variável é dividida com o número à direita, então a variável é atribuída ao quociente. Igual a:
+```
+var d = 10; 
+ d /= 5; // Now, 'd' is equal to 2 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-multiplication/index.md

@@ -0,0 +1,12 @@
+---
+title: Compound Assignment With Augmented Multiplication
+localeTitle: Atribuição Composta Com Multiplicação Aumentada
+---
+## Atribuição Composta Com Multiplicação Aumentada
+
+Computadores lidos da esquerda para a direita. Então, usando o operador de atribuição de multiplicação significa que a variável é multiplicada com o número à direita, então a variável é atribuída ao produto. Igual a:
+```
+var c = 2; 
+ c *= 3; // Now, 'c' is equal to 6 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-subtraction/index.md

@@ -0,0 +1,12 @@
+---
+title: Compound Assignment With Augmented Subtraction
+localeTitle: Atribuição Composta com Subtração Aumentada
+---
+## Atribuição Composta com Subtração Aumentada
+
+Computadores lidos da esquerda para a direita. Então, usando o operador '- =' significa que a variável é subtraída pelo número à direita, então a variável é atribuída à diferença. Igual a:
+```
+var b = 10; 
+ b -= 4; // Now, 'b' is 6 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/concatenating-strings-with-plus-operator/index.md

@@ -0,0 +1,12 @@
+---
+title: Concatenating Strings with Plus Operator
+localeTitle: Concatenando Strings com Operador Plus
+---
+## Concatenando Strings com Operador Plus
+
+Concatenar significa ligar-se. Pense no operador '+' como uma corrente que une as cordas; adicione as cordas como você adiciona números. Certifique-se de que a sua ortografia está correta! Tome nota dos espaços entre as palavras.
+```
+var str = "Good " + "job!" // It says "Good job!" 
+ var abc = "Good" + "job!" // It says "Goodjob!" 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/concatenating-strings-with-the-plus-equals-operator/index.md

@@ -0,0 +1,13 @@
+---
+title: Concatenating Strings with the Plus Equals Operator
+localeTitle: Concatenando Strings com o Operador Plus Equals
+---
+## Concatenando Strings com o Operador Plus Equals
+
+O operador '+ =' pode concatenar (link) cadeias facilmente. Verifique se a ortografia está correta e se você deixou espaços apropriados.
+```
+var str = "Hello "; 
+ str += "coding"; // Now the string reads "Hello coding" 
+ str += "camper!"; // And now the string reads "Hello codingcamper!" 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/constructing-strings-with-variables/index.md

@@ -0,0 +1,14 @@
+---
+title: Constructing Strings with Variables
+localeTitle: Construindo Strings com Variáveis
+---
+## Construindo Strings com Variáveis
+
+Adicione variáveis ​​que armazenam strings para criar strings mais longas. Verifique se a ortografia e o espaçamento estão corretos.
+```
+var myName = "Bobby"; 
+ var myFavLetter = "B"; 
+ var sentence = "Hello, I'm " + myName + ". My favorite letter is " + myFavLetter + "."; 
+  //The result is "Hello, I'm Bobby. My favorite letter is B. 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/count-backwards-with-a-for-loop/index.md

@@ -0,0 +1,48 @@
+---
+title: Count Backwards With a For Loop
+localeTitle: Conte para trás com um loop for
+---
+## Conte para trás com um loop for
+
+Aqui está o exemplo:
+
+```javascript
+// Example 
+ var ourArray = []; 
+ 
+ for (var i = 10; i > 0; i -= 2) { 
+  ourArray.push(i); 
+ } 
+ 
+ // Setup 
+ var myArray = []; 
+ 
+ // Only change code below this line. 
+```
+
+#### DICA: 1
+
+*   criar um novo loop para myArray
+
+#### DICA: 2
+
+*   começar do primeiro número ímpar um pouco antes de 9
+
+# AVISO DE SPOILER: SOLUÇÃO À FRENTE
+
+```javascript
+var ourArray = []; 
+ 
+ for (var i = 10; i > 0; i -= 2) { 
+  ourArray.push(i); 
+ } 
+ 
+ // Setup 
+ var myArray = []; 
+ 
+ // Only change code below this line. 
+ for (var i = 9; i > 0; i-=2){ 
+  myArray.push(i) 
+ } 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/counting-cards/index.md

@@ -0,0 +1,134 @@
+---
+title: Counting Cards
+localeTitle: Contando Cartões
+---
+![:triangular_flag_on_post:](https://forum.freecodecamp.com/images/emoji/emoji_one/triangular_flag_on_post.png?v=3 "triangular_flag_on_post:") Lembre-se de usar **`Read-Search-Ask`** se você ficar preso. Tente emparelhar o programa ![:busts_in_silhouette:](https://forum.freecodecamp.com/images/emoji/emoji_one/busts_in_silhouette.png?v=3 ": busts_in_silhouette:") e escreva seu próprio código ![:pencil:](https://forum.freecodecamp.com/images/emoji/emoji_one/pencil.png?v=3 ":lápis:")
+
+### ![:checkered_flag:](https://forum.freecodecamp.com/images/emoji/emoji_one/checkered_flag.png?v=3 ": checkered_flag:") Explicação do Problema:
+
+No jogo de cassino **Blackjack** , um jogador pode ganhar uma vantagem sobre a casa, mantendo o controle do número relativo de cartas altas e baixas remanescentes no baralho. Isso é chamado de contagem de cartas.
+
+Ter mais cartas altas restantes no baralho favorece o jogador. Cada cartão recebe um valor de acordo com a tabela abaixo. Quando a contagem é positiva, o jogador deve apostar alto. Quando a contagem é zero ou negativa, o jogador deve apostar baixo.
+
+Valor | Postais  
+\----- | : -------------------:  
++1 | 2, 3, 4, 5, 6  
+0 | 7, 8, 9  
+\-1 | 10, 'J', 'Q', 'K', 'A'
+
+Você vai escrever uma função de contagem de cartões. Ele receberá um parâmetro de **cartão** e incrementará ou decrementará a variável de **contagem** global de acordo com o valor do cartão (consulte a tabela). A função retornará uma string com a contagem atual 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` ) devem ser separadas por um único espaço.
+
+*   Altere o código abaixo `// Only change code below this line` e até `// Only change code above this line`
+*   Certifique-se de que você está editando o interior da função `cc` .
+*   Use o que você aprendeu para verificar o valor de cada parâmetro de **cartão** passado para a função.
+*   Mantenha uma contagem desse número.
+*   Se a contagem final for 1 ou maior, retorne **\# Hold** .
+*   Se a contagem final for 0 ou menos, retorne **\# Aposta** .
+
+**Exemplo de Saída:**
+
+*   \-3 espera
+*   5 Aposta
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugestão: 1
+
+Use uma instrução `switch` (ou `else if` ) para contar o valor de cada cartão.
+
+> _tente resolver o problema agora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Dica: 2
+
+Adicionar / subtrair o valor de cada cartão para **contagem de** variáveis. Se a carta valer 0, não faça nada.
+
+> _tente resolver o problema agora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Dica: 3
+
+Depois de contar os cards, use uma instrução `if` para verificar o valor da **contagem** . Além disso, certifique-se de que seu `return` tenha um espaço entre o número e a string.
+
+> _tente resolver o problema agora_
+
+## Alerta de Spoiler!
+
+![sinal de aviso](//discourse-user-assets.s3.amazonaws.com/original/2X/2/2d6c412a50797771301e7ceabd554cef4edcd74d.gif)
+
+**Solução à frente!**
+
+## ![:beginner:](https://forum.freecodecamp.com/images/emoji/emoji_one/beginner.png?v=3 ":principiante:") Solução básica de código:
+
+```javascript
+    function cc(card) { 
+      // Only change code below this line 
+      switch(card){ 
+        case 2: 
+        case 3: 
+        case 4: 
+        case 5: 
+        case 6: 
+          count++; 
+          break; 
+        case 10: 
+        case "J": 
+        case "Q": 
+        case "K": 
+        case "A": 
+          count--; 
+          break; 
+      } 
+      if (count > 0){ 
+        return count + " Bet"; 
+      } else { 
+        return count + " Hold"; 
+      } 
+      // Only change code above this line 
+    } 
+```
+
+### Explicação do código:
+
+*   Verifique o valor de cada cartão por meio de uma instrução `switch` .
+*   A **contagem** variável:
+    *   Aumenta em 1 se o cartão for 2, 3, 4, 5 ou 6.
+    *   Já que 7, 8 e 9 não valem nada, nós os ignoramos em nossa instrução `switch` .
+    *   Diminui em 1 se o cartão for um 10, 'J', 'Q', 'K' ou 'A'.
+*   Verifique o valor da **contagem** e retorne a resposta apropriada.
+
+**Exemplo de Execução**
+
+*   `cc(2);` corre.
+*   A instrução `switch` atinge o `case 2` , desce e adiciona 1 à `count` variáveis.
+*   A instrução `switch` , em seguida, atinge a `break` e `cc(3);` corre.
+*   Este ciclo continua até que a chamada final seja feita, `cc('A');` .
+*   Após o `switch` declaração, o `if` instrução verifica `count` , que é agora a 0.
+*   Isso então cai para a instrução `else` , que retornará **0 Hold** .
+
+**_Nota_** : Como mencionado anteriormente, a instrução `switch` também poderia ter sido uma instrução `else if` .
+
+## Solução de código adicional:
+
+```javascript
+function cc(card) { 
+  // Only change code below this line 
+  var regex = /[JQKA]/; 
+  if (card > 1 && card < 7){count++;} 
+  else if (card === 10 || String(card).match(regex)){count--;} 
+ 
+  if (count > 0) return count + " Bet"; 
+  return count + " Hold"; 
+ 
+  // Only change code above this line 
+ } 
+```
+
+· Executar código no [repl.it.](https://repl.it/@AdrianSkar/Basic-JS-Counting-cards)
+
+### Explicação de código
+
+· A função primeiro avalia `if` a `card` condição é um valor maior que `1` e menor que `7` , em cujo caso a `count` é incrementada em um. · Então, se a carta é `10` ou superior, diminui a `count` por um. · A variável `regex` é uma [expressão regular que](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp) representa valores (letras) para as cartas mais altas. · A instrução `else` verifica esses valores com o `|| (logical OR)` operador `|| (logical OR)` ; primeiro para `10` e depois para qualquer string que corresponda à expressão regular usando [String.match ()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match) .
+
+#### Recursos
+
+*   [Contagem de cartas na Wikipedia](https://en.wikipedia.org/wiki/Card_counting)
+*   [Desafio: Selecionando entre muitas opções com instruções de troca](http://www.freecodecamp.com/challenges/selecting-from-many-options-with-switch-statements)
+*   [Desafio: Encadeamento Se Mais Declarações](http://www.freecodecamp.com/challenges/chaining-if-else-statements)
+*   [Desafio: Incrementar um número com Javascript](http://www.freecodecamp.com/challenges/increment-a-number-with-javascript)

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/create-decimal-numbers-with-javascript/index.md

@@ -0,0 +1,11 @@
+---
+title: Create Decimal Numbers with JavaScript
+localeTitle: Crie números decimais com JavaScript
+---
+# Crie números decimais com JavaScript
+
+Variáveis ​​numéricas JavaScript podem ter decimais.
+```
+var myDecimal = 2.8; 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/declare-javascript-variables/index.md

@@ -0,0 +1,28 @@
+---
+title: Declare JavaScript Variables
+localeTitle: Declarar variáveis ​​JavaScript
+---
+# Declarar variáveis ​​JavaScript
+
+Quando armazenamos dados em uma estrutura de dados, chamamos de variável. Variáveis ​​JavaScript são escritas no caso do camelo. Um exemplo de caso de camelo é: `camelCase` .
+
+Você pode declarar uma variável dessa maneira
+
+```js
+    var myName = "Rafael"; 
+```
+
+O ES6 introduziu duas outras maneiras de declarar variáveis. **vamos** e **const** . _Let_ é bem parecido com var e a maior parte é intercambiável:
+
+```js
+    let myAge = 36; 
+```
+
+Onde _deixar_ diferir, está em seu escopo. Quando declaramos usando _var_ , é global no escopo. Quando declaramos usando _let_ , o escopo é limitado a essa função. Se você quiser usar uma variável _let_ fora de uma função, você deve torná-la global no escopo ou redeclará-la na próxima função.
+
+**const** , por outro lado, só pode ser declarado uma vez. Seu valor nunca pode mudar.
+
+```js
+    const myName = "Christina"; 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/declare-string-variables/index.md

@@ -0,0 +1,16 @@
+---
+title: Declare String Variables
+localeTitle: Declarar Variáveis ​​de Cadeia
+---
+## Declarar Variáveis ​​de Cadeia
+
+Em JavaScript, as variáveis ​​são **dinâmicas** . Isso significa que eles podem conter números, seqüências de caracteres ou qualquer outro tipo de dados em um determinado momento. Para declarar uma string, basta **inicializar** (criar) uma variável:
+```
+var a; 
+```
+
+Em seguida, usando aspas simples ou duplas, declare a string:
+```
+a = "Hello Camper!"; 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/decrement-a-number-with-javascript/index.md

@@ -0,0 +1,13 @@
+---
+title: Decrement a Number with JavaScript
+localeTitle: Decrementar um número com JavaScript
+---
+## Decrementar um número com JavaScript
+
+Decrementar um número usando o operador '-':
+```
+var a = 5; 
+ a--; // Now, 'a' is 4 
+ --a; // Now, 'a' is 3 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/delete-properties-from-a-javascript-object/index.md

@@ -0,0 +1,36 @@
+---
+title: Delete Properties from a JavaScript Object
+localeTitle: Excluir propriedades de um objeto JavaScript
+---
+## Excluir propriedades de um objeto JavaScript
+
+### DICA: 1
+
+*   alterar as propriedades do myDog usando notação de ponto
+
+# AVISO DE SPOILER: SOLUÇÃO À FRENTE
+
+```javascript
+var ourDog = { 
+  "name": "Camper", 
+  "legs": 4, 
+  "tails": 1, 
+  "friends": ["everything!"], 
+  "bark": "bow-wow" 
+ }; 
+ 
+ delete ourDog.bark; 
+ 
+ // Setup 
+ var myDog = { 
+  "name": "Happy Coder", 
+  "legs": 4, 
+  "tails": 1, 
+  "friends": ["freeCodeCamp Campers"], 
+  "bark": "woof" 
+ }; 
+ 
+ // Only change code below this line. 
+ delete myDog.tails; 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/divide-one-decimal-by-another-with-javascript/index.md

@@ -0,0 +1,11 @@
+---
+title: Divide One Decimal by Another with JavaScript
+localeTitle: Divide um decimal por outro com JavaScript
+---
+# Divide um decimal por outro com JavaScript
+
+Javascript usa o símbolo `/` para divisão.
+```
+var quotient = 0.6 / 0.3; //quotient gets the value 2 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/divide-one-number-by-another-with-javascript/index.md

@@ -0,0 +1,11 @@
+---
+title: Divide One Number by Another with JavaScript
+localeTitle: Divide um número por outro com JavaScript
+---
+# Divide um número por outro com JavaScript
+
+Javascript usa o símbolo `/` para divisão.
+```
+var quotient = 6 / 3; //quotient will get value 2 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/escape-sequences-in-strings/index.md

@@ -0,0 +1,9 @@
+---
+title: Escape Sequences in Strings
+localeTitle: Seqüências de escape em seqüências de caracteres
+---
+## Seqüências de escape em seqüências de caracteres
+
+Este é um esboço. [Ajude nossa comunidade a expandi-lo](https://github.com/freecodecamp/guides/tree/master/src/pages/certifications/javascript-algorithms-and-data-structures/basic-javascript/escape-sequences-in-strings/index.md) .
+
+[Este guia de estilo rápido ajudará a garantir que sua solicitação de recebimento seja aceita](https://github.com/freecodecamp/guides/blob/master/README.md) .

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/escaping-literal-quotes-in-strings/index.md

@@ -0,0 +1,19 @@
+---
+title: Escaping Literal Quotes in Strings
+localeTitle: Escapando citações literais em cordas
+---
+## Escapando citações literais em cordas
+
+*   Quando você precisa usar um caractere especial, como `"` dentro de uma string, você precisa escapar usando `\` .
+*   Se você usar aspas duplas `"` para a string, aspas simples `'` na string não precisam ser escapadas.
+*   Se você usar aspas simples `'` para a string, aspas duplas `"` na string não precisam ser escapadas.
+
+## Solução
+
+```javascript
+var myStr = "I am a \"double quoted\" string inside \"double quotes\"."; 
+ var otherStr = 'I am a \'single quoted\' string inside \'single quotes\'.'; 
+ var noEscapeSingle = "There is no need to 'escape' the single quotes."; 
+ var noEscapeDouble = 'There is no need to "escape" the double quotes.'; 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/find-the-length-of-a-string/index.md

@@ -0,0 +1,14 @@
+---
+title: Find the Length of a String
+localeTitle: Encontre o comprimento de uma string
+---
+## Encontre o comprimento de uma string
+
+As cordas têm um **atributo** (recurso) chamado 'comprimento'. Tudo o que você precisa fazer é marcá-lo após a string / variável.
+```
+var str1 = "Hello"; 
+ var length1 = str1.length; // This returns 5 
+ 
+ var length2 = " Camper".length; // This returns 7 because the space is counted as one character. 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/finding-a-remainder-in-javascript/index.md

@@ -0,0 +1,11 @@
+---
+title: Finding a Remainder in JavaScript
+localeTitle: Encontrando um Restante em JavaScript
+---
+# Encontrando um Restante em JavaScript
+
+O operador `%` restante fornece o restante da divisão de dois números.
+```
+var remainder = 11 % 3; //remainder gets the value 2 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/generate-random-fractions-with-javascript/index.md

@@ -0,0 +1,38 @@
+---
+title: Generate Random Fractions with JavaScript
+localeTitle: Gerar frações aleatórias com JavaScript
+---
+# Gerar frações aleatórias com JavaScript
+
+Números aleatórios são úteis para criar um comportamento aleatório.
+
+JavaScript tem uma função `Math.random()` que gera um número decimal aleatório entre 0 (inclusive) e não chega a 1 (exclusivo). Assim `Math.random()` pode retornar um 0, mas nunca retorna um 1.
+
+## Nota
+
+Assim como Armazenando Valores com o Operador Igual, todas as chamadas de função serão resolvidas antes que o retorno seja executado, para que possamos retornar o valor da função `Math.random()` .
+
+## Instruções
+
+Altere randomFraction para retornar um número aleatório em vez de retornar 0.
+
+## **Aviso !!!**
+
+### **Alerta de Spoiler !!**
+
+Uma solução a seguir:
+```
+function randomFraction() { 
+  // Only change code below this line. 
+  var result = 0; 
+  // Math.random() can generate 0. We don't want to     return a 0, 
+  // so keep generating random numbers until we get one     that isn't 0 
+  while (result === 0) { 
+    result = Math.random(); 
+  } 
+ 
+  return result; 
+  // Only change code above this line. 
+ } 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/generate-random-whole-numbers-with-javascript/index.md

@@ -0,0 +1,9 @@
+---
+title: Generate Random Whole Numbers with JavaScript
+localeTitle: Gere números inteiros aleatórios com JavaScript
+---
+## Gere números inteiros aleatórios com JavaScript
+
+Este é um esboço. [Ajude nossa comunidade a expandi-lo](https://github.com/freecodecamp/guides/tree/master/src/pages/certifications/javascript-algorithms-and-data-structures/basic-javascript/generate-random-whole-numbers-with-javascript/index.md) .
+
+[Este guia de estilo rápido ajudará a garantir que sua solicitação de recebimento seja aceita](https://github.com/freecodecamp/guides/blob/master/README.md) .

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/generate-random-whole-numbers-within-a-range/index.md

@@ -0,0 +1,9 @@
+---
+title: Generate Random Whole Numbers within a Range
+localeTitle: Gerar números inteiros aleatórios dentro de um intervalo
+---
+## Gerar números inteiros aleatórios dentro de um intervalo
+
+**Ajuda para passar no teste final:** _`randomRange` deve usar `myMax` e `myMin` e retornar um número aleatório no seu intervalo._
+
+Você não pode passar no teste final se estiver apenas reutilizando a função `ourRandomRange` dentro de sua fórmula `randomRange` . Você precisa escrever sua própria fórmula que usa as variáveis `myMax` e `myMin` . Ele fará o mesmo trabalho que usando `ourRandomRange` , mas garante que você entendeu os princípios das `Math.floor()` e `Math.random()` .

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/global-scope-and-functions/index.md

@@ -0,0 +1,62 @@
+---
+title: Global Scope and Functions
+localeTitle: Âmbito global e funções
+---
+## Âmbito global e funções
+
+O escopo de uma variável é sua visibilidade; onde no código está a função disponível? Aqui está uma lista dos diferentes escopos que uma variável pode ter.
+
+*   **Escopo global** : a variável está disponível em todo o código
+*   **Escopo local** : Disponível apenas em uma determinada área (como somente dentro da função)
+*   **Escopo do bloco** : disponível dentro de uma área _ainda mais específica_ (como uma declaração if)
+
+Sua tarefa é entender como adicionar `var` (e não adicionar) antes de um nome de variável, pode alterar o escopo da variável.
+
+Quando você adiciona `var` antes do nome da variável, seu escopo é determinado por onde é colocado. Igual a:
+
+```javascript
+var num1 = 18; // Global scope 
+ function fun() { 
+  var num2 = 20; // Local (Function) Scope 
+  if (true) { 
+    var num3 = 22; // Block Scope (within an if-statement) 
+  } 
+ } 
+```
+
+Quando você não faz, este é o resultado:
+
+```javascript
+num1 = 18; // Global scope 
+ function fun() { 
+  num2 = 20; // Global Scope 
+  if (true) { 
+    num3 = 22; // Global Scope 
+  } 
+ } 
+```
+
+Tudo bem, aqui está a solução básica de código.
+
+```javascript
+// Declare your variable here 
+ var myGlobal = 10; 
+ 
+ function fun1() { 
+  oopsGlobal = 5; 
+ 
+ } 
+ 
+ // Only change code above this line 
+ function fun2() { 
+  var output = ""; 
+  if (typeof myGlobal != "undefined") { 
+    output += "myGlobal: " + myGlobal; 
+  } 
+  if (typeof oopsGlobal != "undefined") { 
+    output += " oopsGlobal: " + oopsGlobal; 
+  } 
+  console.log(output); 
+ } 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/global-vs.-local-scope-in-functions/index.md

@@ -0,0 +1,22 @@
+---
+title: Global vs. Local Scope in Functions
+localeTitle: Escopo global vs. local em funções
+---
+## Escopo global vs. local em funções
+
+Lembre-se de que o escopo global significa que a variável está disponível em todo o código. Escopo local, significa que a variável está disponível dentro de um determinado intervalo.
+
+Neste exercício, você tem uma variável `outerWear` no escopo global com "T-shirt" como valor. Agora você deve criar outra variável chamada `outerWear` , mas desta vez dentro da função `myOutfit()` . A solução básica de código da seguinte forma:
+
+```javascript
+var outerWear = "T-shirt"; 
+ 
+ function myOutfit() { 
+  var outerWear = "sweater"; 
+  return outerWear; 
+ } 
+ 
+ myOutfit(); 
+```
+
+A função retornará o `outerWear` mais próximo que puder encontrar. Desde que criamos um `outerWear` dentro da função, que é o 'mais próximo', então a função retornará "sweater".

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/golf-code/index.md

@@ -0,0 +1,125 @@
+---
+title: Golf Code
+localeTitle: Código de Golfe
+---
+![:triangular_flag_on_post:](https://forum.freecodecamp.com/images/emoji/emoji_one/triangular_flag_on_post.png?v=3 "triangular_flag_on_post:") Lembre-se de usar **`Read-Search-Ask`** se você ficar preso. Tente emparelhar o programa ![:busts_in_silhouette:](https://forum.freecodecamp.com/images/emoji/emoji_one/busts_in_silhouette.png?v=3 ": busts_in_silhouette:") e escreva seu próprio código ![:pencil:](https://forum.freecodecamp.com/images/emoji/emoji_one/pencil.png?v=3 ":lápis:")
+
+### ![:checkered_flag:](https://forum.freecodecamp.com/images/emoji/emoji_one/checkered_flag.png?v=3 ": checkered_flag:") Explicação do Problema:
+
+No jogo de golfe, cada buraco tem um **par que** significa o número médio de **golpes que** um golfista deve fazer para afundar a bola em um buraco para completar a jogada. Dependendo de quão longe acima ou abaixo do **par** seus **traços** são, há um apelido diferente.
+
+Sua função receberá argumentos **par** e **strokes** . Você deve retornar a string correta de acordo com essa tabela, que lista os traços em ordem de prioridade; topo (maior) para baixo (menor):
+
+Strokes | Retorna  
+: --------- | : -------------  
+1 | "Buraco-em-um!"  
+<= par - 2 | "Águia"  
+par - 1 | "Passarinho"  
+par | "Par"  
+par + 1 | "Bogey"  
+par + 2 | "Bogey Duplo" > par + 3 | "Ir para casa!"
+
+**par** e **traços** serão sempre numéricos e positivos.
+
+*   Altere o código abaixo `// Only change code below this line` e acima `// Only change code above this line` .
+*   Certifique-se de que você está editando o interior da função `golfScore` .
+*   Você terá que fazer com que a função retorne exatamente a mesma string mostrada na tabela, dependendo do valor dos parâmetros **par** e **traços** que são passados ​​para sua função.
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugestão: 1
+
+`+number -number` pode ser usado para aumentar ou diminuir um parâmetro em sua condição.
+
+> _tente resolver o problema agora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Dica: 2
+
+Você usa `if / else if` cadeias para retornar diferentes valores em diferentes cenários.
+
+> _tente resolver o problema agora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Dica: 3
+
+Controle o fluxo de sua função com base na ordem de prioridade das tabelas - superior (maior) para inferior (menor) para retornar os valores de string correspondentes.
+
+> _tente resolver o problema agora_
+
+## Alerta de Spoiler!
+
+![sinal de aviso](//discourse-user-assets.s3.amazonaws.com/original/2X/2/2d6c412a50797771301e7ceabd554cef4edcd74d.gif)
+
+**Solução à frente!**
+
+## ![:beginner:](https://forum.freecodecamp.com/images/emoji/emoji_one/beginner.png?v=3 ":principiante:") Solução básica de código:
+```
+function golfScore(par, strokes) { 
+  // Only change code below this line 
+  if (strokes == 1){ 
+    return "Hole-in-one!"; 
+  } else if (strokes <= par -2){ 
+    return "Eagle"; 
+  } else if (strokes == par -1) { 
+    return "Birdie"; 
+  } else if (strokes == par) { 
+    return "Par"; 
+  } else if (strokes == par +1) { 
+    return "Bogey"; 
+  } else if (strokes == par +2) { 
+    return "Double Bogey"; 
+  } else { 
+    return "Go Home!"; 
+  } 
+  // Only change code above this line 
+ } 
+ // Change these values to test 
+ golfScore(5, 4); 
+```
+
+### Explicação do código:
+
+*   Compare os parâmetros **par** e **strokes** para retornar os valores de string apropriados.
+*   `if / else if` cadeia for usada para controle de fluxo.
+*   String "Vá para casa!" é retornado para todas as condições em que os **traços** são maiores ou iguais a **par + 3** .
+
+## Solução alternativa de código:
+
+```javascript
+var names = ["Hole-in-one!", "Eagle", "Birdie", "Par", "Bogey", "Double Bogey", "Go Home!"]; 
+ function golfScore(par, strokes) { 
+  // Only change code below this line 
+  if (strokes == 1){ 
+    return names[0]; 
+  } 
+  else if (strokes <= par-2){ 
+    return names[1]; 
+  } 
+  else if (strokes == par -1){ 
+    return names[2]; 
+  } 
+  else if (strokes == par){ 
+    return names[3]; 
+  } 
+  else if (strokes == par +1){ 
+    return names[4]; 
+  } 
+  else if (strokes == par +2){ 
+    return names[5]; 
+  } 
+  else {return names[6];} 
+  // Only change code above this line 
+ } 
+ 
+ // Change these values to test 
+ golfScore(5, 4); 
+```
+
+· Corra no [repl.it](https://repl.it/@AdrianSkar/Basic-JS-Golf-code)
+
+\## Explicação do código Como já temos uma matriz definida nos `names` das variáveis, podemos aproveitá-la e usá-la para nossas instruções de retorno usando índices (por exemplo: `names[0] is the first one` ). Dessa forma, se você precisar alterar um resultado específico, não precisaria procurá-lo dentro da função, seria no início, na sua matriz.
+
+### Recursos
+
+*   [Golfe](https://en.wikipedia.org/wiki/Golf)
+*   [Desafio: Encadeamento Se Mais Declarações](http://www.freecodecamp.com/challenges/chaining-if-else-statements)
+*   [Desafio: Comparação com o Maior que Igual ao Operador](http://www.freecodecamp.com/challenges/comparison-with-the-greater-than-equal-to-operator)
+*   [Desafio: Comparação com o Menos de Igual ao Operador](http://www.freecodecamp.com/challenges/comparison-with-the-less-than-equal-to-operator)
+*   ["Array" - _Referência do MDN JavaScript_](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/increment-a-number-with-javascript/index.md

@@ -0,0 +1,13 @@
+---
+title: Increment a Number with JavaScript
+localeTitle: Incrementar um número com JavaScript
+---
+## Incrementar um número com JavaScript
+
+Você pode facilmente incrementar (adicionar um) a uma variável numérica usando o operador de incremento '++'. Por exemplo:
+```
+var a = 6; 
+ a++; // Now, 'a' is equal to 7 -- post-fixing 
+ ++a; // Now, 'a' is equal to 8 -- pre-fixing 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/index.md

@@ -0,0 +1,11 @@
+---
+title: Basic Javascript
+localeTitle: Javascript Básico
+---
+## Javascript Básico
+
+Este é um esboço. [Ajude nossa comunidade a expandi-lo](https://github.com/freecodecamp/guides/tree/master/src/pages/mathematics/quadratic-equations/index.md) .
+
+[Este guia de estilo rápido ajudará a garantir que sua solicitação de recebimento seja aceita](https://github.com/freecodecamp/guides/blob/master/README.md) .
+
+#### Mais Informações:

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/initializing-variables-with-the-assignment-operator/index.md

@@ -0,0 +1,11 @@
+---
+title: Initializing Variables with the Assignment Operator
+localeTitle: Inicializando Variáveis ​​com o Operador de Atribuição
+---
+## Inicializando Variáveis ​​com o Operador de Atribuição
+
+Para **inicializar** uma variável é dar a ela um valor inicial. Você pode declarar e inicializar uma variável da seguinte forma:
+```
+var num = 5; // This is equal to 5 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/introducing-else-if-statements/index.md

@@ -0,0 +1,63 @@
+---
+title: Introducing Else If statements
+localeTitle: Introduzindo instruções Else If
+---
+## Introduzindo instruções Else If
+
+Lembre-se de usar Read-Search-Ask se você ficar preso. Tente emparelhar o programa e escrever seu próprio código.
+
+\### Explicação do problema:
+
+```javascript
+function testElseIf(val) { 
+  if (val > 10) { 
+    return "Greater than 10"; 
+  } 
+ 
+  if (val < 5) { 
+    return "Smaller than 5"; 
+  } 
+ 
+  return "Between 5 and 10"; 
+ } 
+ 
+ // Change this value to test 
+ testElseIf(7); 
+```
+
+Modificaremos o código existente acima para que ele siga o fluxo de lógica que uma instrução **else-if** possui.
+
+Dica ###: 1 `javascript if (val > 10) { return "Greater than 10"; }` Todas as instruções `if` e suas variantes começam com uma declaração `if` .
+
+> _tente resolver o problema agora_
+
+Dica ###: 2 `javascript else if (val < 5) { return "Smaller than 5"; }` Instruções entre a instrução `if` e a instrução `else` em um fluxo **else-if** estão no formato else-if
+
+> _tente resolver o problema agora_
+
+Dica ###: 3 `javascript else { return "Between 5 and 10"; }` A última instrução em um fluxo **else-if** está no formato `else` ### Alerta de spoiler! ![Spoiler](http://discourse-user-assets.s3.amazonaws.com/original/2X/2/2d6c412a50797771301e7ceabd554cef4edcd74d.gif) Solução à frente! ## Solução básica de código:
+
+```javascript
+function testElseIf(val) { 
+  if (val > 10) { 
+    return "Greater than 10"; 
+  } 
+ 
+  else if (val < 5) { 
+    return "Smaller than 5"; 
+  } 
+ 
+  else { 
+  return "Between 5 and 10"; 
+  } 
+ } 
+ 
+ // Change this value to test 
+ testElseIf(7); 
+```
+
+: rocket: [código de execução](https://repl.it/@RyanPisuena/GoldenWorriedRuntime) ## Explicação do código A estrutura de um **else-se o fluxo de lógica** é uma inicial `if` declaração, mais um `if-else` declarações, e uma final, `else` declaração.
+
+### Recursos
+
+*   ["if… else" - _Referência do MDN JavaScript_](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/if…else)

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/introducing-else-statements/index.md

@@ -0,0 +1,58 @@
+---
+title: Introducing Else statements
+localeTitle: Apresentando instruções Else
+---
+## Apresentando instruções Else
+
+### Explicação do problema:
+
+· _Combine as instruções `if` em uma única instrução `if/else` ._
+
+#### Sugestão 1
+
+Quando a primeira instrução `if` retorna `false` a próxima parte do código é executada / avaliada (como `return` , `if` or `else` statements).
+
+> _tente resolver o problema agora_
+
+#### Sugestão 2
+
+Algumas vezes, `if` instruções ( `condition` ) podem ser substituídas por `else {code to execute instead}` instruções `else {code to execute instead}` (na essência, você está dizendo à sua função para fazer _"y"_ se não puder fazer _"x" em_ vez de especificar _"x"_ várias vezes).
+
+> _tente resolver o problema agora_
+
+## Alerta de spoiler!
+
+**Solução à frente!**
+
+## Solução básica de código:
+
+```javascript
+function testElse(val) { 
+  var result = ""; 
+  // Only change code below this line 
+ 
+  if (val > 5) { 
+    result = "Bigger than 5"; 
+  } 
+ 
+  else { 
+    result = "5 or smaller"; 
+  } 
+ 
+  // Only change code above this line 
+  return result; 
+ } 
+ 
+ // Change this value to test 
+ testElse(4); 
+```
+
+· [Executar código em repl.it](https://repl.it/@AdrianSkar/Introducing-else-statements)
+
+### Explicação de código
+
+A função primeiro avalia `if` a condição `val > 5` avaliada como `true` . Se não, ele executa a próxima instrução ( `else { return "5 or smaller";})` .
+
+### Recursos
+
+*   ["if… else" - _Referência do MDN JavaScript_](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/if…else)

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/iterate-odd-numbers-with-a-for-loop/index.md

@@ -0,0 +1,38 @@
+---
+title: Iterate Odd Numbers With a For Loop
+localeTitle: Iterar números ímpares com um loop for
+---
+## Iterar números ímpares com um loop for
+
+Aqui está o exemplo:
+
+```javascript
+var ourArray = []; 
+ 
+ for (var i = 0; i < 10; i += 2) { 
+  ourArray.push(i); 
+ } 
+ 
+ // Setup 
+ var myArray = []; 
+ 
+ // Only change code below this line. 
+```
+
+Aqui está uma solução: Depois da string `// Only change code below this line.` nós adicionamos `for` loop. Você precisa copiar o loop do topo:
+
+`javascript for (var i = 0; i < 10; i += 2) { ourArray.push(i); }` E mude a `initialization` `var i = 0` para `var i = 1` , também você precisa alterar o nome da matriz `ourArray` para `myArray` :
+
+`javascript for (var i = 1; i < 10; i += 2) { myArray.push(i); }`
+
+Aqui está uma solução completa:
+
+\`\` \`javascript var ourArray = \[\];
+
+para (var i = 0; i <10; i + = 2) { ourArray.push (i); }
+
+// Configuração var myArray = \[\];
+
+// Apenas mude o código abaixo desta linha.
+
+para (var i = 1; i <10; i + = 2) { myArray.push (i); } \`\` \`

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/iterate-through-an-array-with-a-for-loop/index.md

@@ -0,0 +1,9 @@
+---
+title: Iterate Through an Array with a For Loop
+localeTitle: Iterar por meio de uma matriz com um loop for
+---
+## Iterar por meio de uma matriz com um loop for
+
+Este é um esboço. [Ajude nossa comunidade a expandi-lo](https://github.com/freecodecamp/guides/tree/master/src/pages/certifications/javascript-algorithms-and-data-structures/basic-javascript/iterate-through-an-array-with-a-for-loop/index.md) .
+
+[Este guia de estilo rápido ajudará a garantir que sua solicitação de recebimento seja aceita](https://github.com/freecodecamp/guides/blob/master/README.md) .

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-do...while-loops/index.md

@@ -0,0 +1,20 @@
+---
+title: Iterate with JavaScript Do...While Loops
+localeTitle: Iterar com JavaScript Do ... While Loops
+---
+## Iterar com JavaScript Do… While Loops
+
+*   `Do...While` loops garante que o código seja executado pelo menos uma vez, e após a execução, se a condição dentro do `while()` for **verdadeira** , continua com o loop, caso contrário, ele será interrompido.
+
+## Solução
+
+```javascript
+var myArray = []; 
+ var i = 10; 
+ 
+ do { 
+  myArray.push(i); 
+  i++; 
+ } while(i <= 10); 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-for-loops/index.md

@@ -0,0 +1,9 @@
+---
+title: Iterate with JavaScript For Loops
+localeTitle: Iterar com JavaScript For Loops
+---
+## Iterar com JavaScript For Loops
+
+Este é um esboço. [Ajude nossa comunidade a expandi-lo](https://github.com/freecodecamp/guides/tree/master/src/pages/certifications/javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-for-loops/index.md) .
+
+[Este guia de estilo rápido ajudará a garantir que sua solicitação de recebimento seja aceita](https://github.com/freecodecamp/guides/blob/master/README.md) .

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-while-loops/index.md

@@ -0,0 +1,40 @@
+---
+title: Iterate with JavaScript While Loops
+localeTitle: Iterar com loops While de JavaScript
+---
+## Iterar com loops While de JavaScript
+
+Enquanto loops serão executados contanto que a condição dentro de () seja verdadeira. Exemplo:
+
+```javascript
+while(condition){ 
+ code... 
+ } 
+```
+
+## Sugestão 1:
+
+Use uma variável iteradora como i em sua condição
+
+```javascript
+var i = 0; 
+ while(i <= 4){ 
+ } 
+```
+
+## Solução de Alerta de Spoiler à Frente!
+
+## Solução:
+
+```javascript
+// Setup 
+ var myArray = []; 
+ 
+ // Only change code below this line. 
+ var i = 0; 
+ while (i <= 4){ 
+    myArray.push(i); 
+    i++; 
+ } 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/local-scope-and-functions/index.md

@@ -0,0 +1,19 @@
+---
+title: Local Scope and Functions
+localeTitle: Escopo Local e Funções
+---
+## Escopo Local e Funções
+
+Escopo local significa que a variável está disponível em uma determinada área. No caso deste exercício, `myVar` só está disponível dentro da função, e não em qualquer lugar fora.
+
+Aqui está a solução básica de código para criar uma variável `myVar` local.
+
+```javascript
+function myLocalScope() { 
+  var myVar; 
+  console.log(myVar); 
+ } 
+ myLocalScope(); 
+```
+
+A variável existe apenas na função. Fora da função, é inexistente.

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/logical-order-in-if-else-statements/index.md

@@ -0,0 +1,9 @@
+---
+title: Logical Order in If Else Statements
+localeTitle: Ordem lógica em outras declarações
+---
+## Ordem lógica em outras declarações
+
+Este é um esboço. [Ajude nossa comunidade a expandi-lo](https://github.com/freecodecamp/guides/tree/master/src/pages/certifications/javascript-algorithms-and-data-structures/basic-javascript/logical-order-in-if-else-statements/index.md) .
+
+[Este guia de estilo rápido ajudará a garantir que sua solicitação de recebimento seja aceita](https://github.com/freecodecamp/guides/blob/master/README.md) .

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-pop/index.md

@@ -0,0 +1,25 @@
+---
+title: Manipulate Arrays With pop()
+localeTitle: Manipular Arrays Com pop ()
+---
+## Manipular Arrays Com pop ()
+
+## Explicação do Problema
+
+Livre-se do último elemento da matriz. Em seguida, atribua esse elemento montado a `removedFromMyArray` .
+
+## Sugestão 1:
+
+Chame `.pop()` na matriz e atribua-a a `removedFromMyArray` .
+
+## Spoiler! Solução de Código:
+
+```javascript
+var removedFromMyArray = myArray.pop(); 
+ ======= 
+ Remove the last element of an array with the pop() method, like so: 
+```
+
+javascript var arr = \[1, 2, 3, 4, 5\]; arr.pop (); // Isso se livrou de 5
+
+\`\` \`

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-push/index.md

@@ -0,0 +1,13 @@
+---
+title: Manipulate Arrays With push()
+localeTitle: Manipular matrizes com push ()
+---
+## Manipular matrizes com push ()
+
+O método `push()` permite acrescentar (adicionar ao final) um elemento a um array. Igual a…
+
+```javascript
+var arr = [1, 2, 3, 4]; 
+ arr.push(5); // Now, the array is [1, 2, 3, 4, 5] 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-shift/index.md

@@ -0,0 +1,13 @@
+---
+title: Manipulate Arrays With shift()
+localeTitle: Manipular Matrizes Com Deslocamento ()
+---
+## Manipular Matrizes Com Deslocamento ()
+
+Enquanto `pop()` foi usado para se livrar do último elemento de um array, `shift()` é usado para se livrar do primeiro elemento. É como se você estivesse mudando os elementos uma posição. Veja isso:
+
+```javascript
+var arr = [1, 2, 3, 4, 5]; 
+ arr.shift(); // Gets rid of the 1 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-unshift/index.md

@@ -0,0 +1,13 @@
+---
+title: Manipulate Arrays With unshift()
+localeTitle: Manipular matrizes com unshift ()
+---
+## Manipular matrizes com unshift ()
+
+Enquanto `push()` adicionava elementos à parte de trás da matriz, `unshift()` adiciona à frente. Tudo o que tem a fazer é:
+
+```javascript
+var arr = [2, 3, 4, 5]; 
+ arr.unshift(1); // Now, the array has 1 in the front 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/manipulating-complex-objects/index.md

@@ -0,0 +1,70 @@
+---
+title: Manipulating Complex Objects
+localeTitle: Manipulando Objetos Complexos
+---
+## Manipulando Objetos Complexos
+
+Aqui está o exemplo:
+
+```javascript
+var myMusic = [ 
+  { 
+    "artist": "Billy Joel", 
+    "title": "Piano Man", 
+    "release_year": 1973, 
+    "formats": [ 
+      "CD", 
+      "8T", 
+      "LP" 
+    ], 
+    "gold": true 
+  } 
+  // Add record here 
+ ]; 
+```
+
+Aqui está uma solução: Depois da string `// Add record here` , adicionamos novo álbum ao `myMusic` . Você precisa começar a partir `,` . E você pode simplesmente copiar o álbum já criado: `javascript { "artist": "Billy Joel", "title": "Piano Man", "release_year": 1973, "formats": [ "CD", "8T", "LP" ], "gold": true }`
+
+e cole depois `,` :
+
+```javascript
+  // Add record here 
+  , 
+  { 
+    "artist": "Billy Joel", 
+    "title": "Piano Man", 
+    "release_year": 1973, 
+    "formats": [ 
+      "CD", 
+      "8T", 
+      "LP" 
+    ], 
+    "gold": true 
+  } 
+ ]; 
+```
+
+Agora você pode alterar os valores de seu álbum:
+
+```javascript
+  // Add record here 
+  , 
+  { 
+    "artist": "Deep Purple", 
+    "title": "Smoke on the water", 
+    "release_year": 1976, 
+    "formats": [ 
+      "CD", 
+      "8T", 
+      "LP" 
+    ], 
+    "gold": true 
+  } 
+ ]; 
+```
+
+Aqui está uma solução completa:
+
+\`\` \`javascript var myMusic = \[ { "artista": "Billy Joel", "title": "Piano Man", " _ano de_ lançamento _": 1973, "formatos": \[ "CD", "8T", "LP" \] "gold": true } // Adicionar registro aqui { "artista": "Deep Purple", "title": "Smoke on the water", "_ ano de _lançamento_ ": 1976, "formatos": \[ "CD", "8T", "LP" \] } \];
+
+\`\` \`

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/modify-array-data-with-indexes/index.md

@@ -0,0 +1,16 @@
+---
+title: Modify Array Data With Indexes
+localeTitle: Modificar dados de matriz com índices
+---
+## Modificar dados de matriz com índices
+
+Acesse a posição da matriz e altere-a assim:
+
+```javascript
+var arr = [1, 2, 3, 4, 5]; 
+ 
+ arr[0] = 6; // Now, the array is [6, 2, 3, 4, 5] 
+ arr[4] = 10 // Now, the array is [6, 2, 3, 4, 10] 
+```
+
+O conceito importante aqui é que as matrizes são **mutáveis** . Isso significa que eles podem ser alterados facilmente.

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/multiple-identical-options-in-switch-statements/index.md

@@ -0,0 +1,96 @@
+---
+title: Multiple Identical Options in Switch Statements
+localeTitle: Múltiplas Opções Idênticas em Instruções de Comutação
+---
+## Múltiplas Opções Idênticas em Instruções de Comutação
+
+### Explicação do Problema
+
+_Se a instrução break for omitida do caso de uma instrução switch, as instruções a seguir serão executadas até que uma quebra seja encontrada. Se você tiver várias entradas com a mesma saída, você pode representá-las em uma instrução switch como esta:_
+
+```javascript
+switch(val) { 
+  case 1: 
+  case 2: 
+  case 3: 
+    result = "1, 2, or 3"; 
+    break; 
+  case 4: 
+    result = "4 alone"; 
+ } 
+```
+
+_Casos para 1, 2 e 3 produzirão o mesmo resultado._
+
+_Escreva uma instrução switch para definir a resposta para os seguintes intervalos:_ `1-3` - "baixo"  
+`4-6` - "Mid"  
+`7-9` - "Alto"
+
+_Nota: Você precisará ter uma declaração de caso para cada número no intervalo._
+
+## Alerta de spoiler!
+
+**Solução à frente!**
+
+## Solução de Código:
+
+```javascript
+function sequentialSizes(val) { 
+  var answer = ""; 
+  // Only change code below this line 
+  switch(val) { 
+    case 1: 
+    case 2: 
+    case 3: 
+      return "Low"; 
+      break; 
+    case 4: 
+    case 5: 
+    case 6: 
+      return "Mid"; 
+      break; 
+    case 7: 
+    case 8: 
+    case 9: 
+      return "High"; 
+      break; 
+  } 
+  // Only change code above this line 
+  return answer; 
+ } 
+ // Change this value to test 
+ sequentialSizes(1); 
+```
+
+## Solução alternativa de código:
+
+```javascript
+function sequentialSizes(val) { 
+  var answer = ""; 
+  // Only change code below this line 
+  switch(val){ 
+    case 1: case 2: case 3: 
+      answer = "Low"; 
+      break; 
+    case 4: case 5: case 6: 
+      answer = "Mid"; 
+      break; 
+    case 7: case 8: case 9: 
+      answer = "High"; 
+  } 
+  // Only change code above this line 
+  return answer; 
+ } 
+ // Change this value to test 
+ sequentialSizes(1); 
+```
+
+· Executar código no [repl.it.](https://repl.it/@AdrianSkar/Basic-JS-Multiple-opts-in-switch)
+
+### Explicação de código
+
+Como você já tem uma variável chamada `answer` defined e a função a retorna, você pode modificar seu valor em cada grupo de instruções case para atender aos requisitos de exercício.
+
+### Recursos
+
+*   ["Switch: métodos para o caso de vários critérios" - _Referência do MDN para JavaScript_](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/switch)

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/multiply-two-decimals-with-javascript/index.md

@@ -0,0 +1,9 @@
+---
+title: Multiply Two Decimals with JavaScript
+localeTitle: Multiplique dois decimais com JavaScript
+---
+## Multiplique dois decimais com JavaScript
+
+Este é um esboço. [Ajude nossa comunidade a expandi-lo](https://github.com/freecodecamp/guides/tree/master/src/pages/certifications/javascript-algorithms-and-data-structures/basic-javascript/multiply-two-decimals-with-javascript/index.md) .
+
+[Este guia de estilo rápido ajudará a garantir que sua solicitação de recebimento seja aceita](https://github.com/freecodecamp/guides/blob/master/README.md) .

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/multiply-two-numbers-with-javascript/index.md

@@ -0,0 +1,11 @@
+---
+title: Multiply Two Numbers with JavaScript
+localeTitle: Multiplique dois números com JavaScript
+---
+# Multiplique dois números com JavaScript
+
+JavaScript usa o símbolo `*` para multiplicação.
+```
+var product = 8 * 10; //product gets the value 80 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/nest-one-array-within-another-array/index.md

@@ -0,0 +1,13 @@
+---
+title: Nest one Array within Another Array
+localeTitle: Aninhar uma matriz dentro de outra matriz
+---
+## Aninhar uma matriz dentro de outra matriz
+
+Matrizes são unidimensionais; Isso significa que eles armazenam apenas uma linha de dados. Mas você pode fazer uma matriz multi-dimensional, colocando matrizes dentro de matrizes! Igual a:
+
+```javascript
+var arr = [["Two-dimensional", 2], ["Two rows", 12]]; 
+```
+
+A matriz acima tem duas dimensões.

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/nesting-for-loops/index.md

@@ -0,0 +1,91 @@
+---
+title: Nesting For Loops
+localeTitle: Aninhando For Loops
+---
+## Aninhando For Loops
+
+**Lembre-se de usar Read-Search-Ask se você ficar preso. Tente parear programa: bustos _em_ silhueta: e escreva seu próprio código: lápis:**
+
+: checkered\_flag: **Explicação do problema:**
+
+Se você tiver um array multidimensional, você pode usar a mesma lógica do waypoint anterior para percorrer tanto o array quanto qualquer sub-array.
+
+Aqui está um exemplo:
+```
+var arr = [ 
+  [1,2], [3,4], [5,6] 
+ ]; 
+ for (var i=0; i < arr.length; i++) { 
+  for (var j=0; j < arr[i].length; j++) { 
+    console.log(arr[i][j]); 
+  } 
+ } 
+```
+
+Isto produz cada sub-elemento em `arr` um de cada vez. Note que para o laço interno, estamos verificando o comprimento de arr \[i\], já que arr \[i\] é ele próprio um array.
+
+*   Modifique a função `multiplyAll` para que ela multiplique a variável do `product` por cada número nos sub-arrays de `arr` .
+*   Certifique-se de que o segundo loop for está aninhado dentro do primeiro.
+
+**Links Relevantes**
+
+*   [Ninho Um Array Dentro De Outro Array](https://guide.freecodecamp.org/certifications/javascript-algorithms-and-data-structures/basic-javascript/nest-one-array-within-another-array)
+*   [Iterar Através De Uma Matriz Com Um For Loop](https://learn.freecodecamp.org/javascript-algorithms-and-data-structures/basic-javascript/iterate-through-an-array-with-a-for-loop)
+*   [Acessando matrizes aninhadas](https://learn.freecodecamp.org/javascript-algorithms-and-data-structures/basic-javascript/accessing-nested-arrays)
+
+: speech\_balloon: Dica: 1
+
+Certifique-se de verificar com `length` e não a matriz geral.
+
+_tente resolver o problema agora_
+
+: speech\_balloon: Dica 2
+
+Use `i` `j` ao multiplicar o produto.
+
+_tente resolver o problema agora_
+
+: speech\_balloon: Dica 3
+
+Lembre-se de usar `arr[i]` quando você multiplica as sub-matrizes pela variável do `product` .
+
+_tente resolver o problema agora_
+
+_Alerta de Spoiler!_ ![](https://discourse-user-assets.s3.amazonaws.com/original/2X/2/2d6c412a50797771301e7ceabd554cef4edcd74d.gif)
+
+**Solução à frente!**
+
+: beginner: **Basic Code Solution:**
+```
+function multiplyAll(arr) { 
+  var product = 1; 
+  // Only change code below this line 
+  for(var i=0; i < arr.length; i++){ 
+    for (var j=0; j < arr[i].length; j++){ 
+      product = product * arr[i][j]; 
+    } 
+  } 
+  // Only change code above this line 
+  return product; 
+ } 
+ 
+ // Modify values below to test your code 
+ multiplyAll([[1,2],[3,4],[5,6,7]]); 
+```
+
+: rocket: **[Run Code](https://learn.freecodecamp.org/javascript-algorithms-and-data-structures/basic-javascript/nesting-for-loops/)**
+
+**Explicação do código:**
+
+*   Verificamos o comprimento de `arr` no loop `i` e o comprimento `arr[i]` no loop `j` .
+*   Nós multiplicamos a variável de `product` por si só porque é igual a 1 e depois multiplicamos pelos sub-arrays.
+*   Os dois sub-arrays para multiplicar são `arr[i]` e `j` .
+
+: clipboard: **NOTAS PARA CONTRIBUIÇÕES:**
+
+*   : aviso: **NÃO** adicione soluções semelhantes às soluções existentes. Se você acha que é semelhante, mas melhor, tente mesclar (ou substituir) a solução semelhante existente.
+*   Adicione uma explicação da sua solução.
+*   Categorize a solução em uma das seguintes categorias - Básica, Intermediária e Avançada. :semáforo:
+*   Por favor, adicione seu nome de usuário somente se você adicionou qualquer conteúdo principal relevante. (: aviso: _**NÃO**_ remova nenhum nome de usuário existente)
+
+Veja: point\_right: [Modelo de Solução de Desafio do Wiki](http://forum.freecodecamp.com/t/algorithm-article-template/14272) para referência.

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/passing-values-to-functions-with-arguments/index.md

@@ -0,0 +1,21 @@
+---
+title: Passing Values to Functions with Arguments
+localeTitle: Passando Valores para Funções com Argumentos
+---
+## Passando Valores para Funções com Argumentos
+
+Nossa tarefa é criar uma função que tenha **parâmetros** . Estas são entradas que determinam a saída da função. Você coloca os parâmetros dentro do `()` , assim:
+
+```javascript
+function functionWithArgs(one, two) { 
+  console.log(one + two); 
+ } 
+```
+
+Agora temos que adicionar código dentro dos colchetes. Nossa tarefa é adicionar `one` e `two` e imprimir a soma no console. Aqui está a solução básica de código:
+
+```javascript
+functionWithArgs(7, 3); 
+ //This will console log 10. 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/practice-comparing-different-values/index.md

@@ -0,0 +1,46 @@
+---
+title: Practice comparing different values
+localeTitle: Pratique a comparação de valores diferentes
+---
+## Pratique a comparação de valores diferentes
+
+### Explicação do problema:
+
+· _Modifique a função para que ela retorne "Equal" somente quando os valores forem **estritamente** iguais._
+
+#### Sugestão 1
+
+Lembre-se de exercícios anteriores que, _ao contrário do operador de igualdade, que tenta converter os dois valores sendo comparados a um tipo comum, o operador de igualdade estrita não executa uma conversão de tipo._ [1](#cite1)
+
+> _tente resolver o problema agora_
+
+## Alerta de spoiler!
+
+**Solução à frente!**
+
+## Solução básica de código:
+
+```javascript
+// Setup 
+ function compareEquality(a, b) { 
+    if (a === b) { // Change this line 
+        return  "Equal"; 
+    } 
+    return  "Not Equal"; 
+ } 
+ 
+ // Change this value to test 
+ compareEquality(10, "10"); 
+```
+
+### Explicação de código
+
+A função primeiro avalia `if` a condição `(a === b)` avaliada como `true` considerando tanto o tipo quanto o valor. Em caso afirmativo, retorna a instrução entre as chaves ("Equal"). Caso contrário, retorna a próxima instrução de `return` fora deles ("Não é igual").
+
+### Fontes
+
+1 ["JavaScript Básico: Comparação com o Operador de Igualdade Estrita", lição do fCC em _Algoritmos de Javascript e Certificação de Estruturas de Dados_](https://learn.freecodecamp.org/javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-strict-equality-operator)
+
+### Recursos
+
+*   ["Usando os operadores de igualdade" - _referência do MDN JavaScript_](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Using_the_Equality_Operators)

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/profile-lookup/index.md

@@ -0,0 +1,96 @@
+---
+title: Profile Lookup
+localeTitle: Pesquisa de perfil
+---
+![:triangular_flag_on_post:](https://forum.freecodecamp.com/images/emoji/emoji_one/triangular_flag_on_post.png?v=3 "triangular_flag_on_post:") Lembre-se de usar **`Read-Search-Ask`** se você ficar preso. Tente emparelhar o programa ![:busts_in_silhouette:](https://forum.freecodecamp.com/images/emoji/emoji_one/busts_in_silhouette.png?v=3 ": busts_in_silhouette:") e escreva seu próprio código ![:pencil:](https://forum.freecodecamp.com/images/emoji/emoji_one/pencil.png?v=3 ":lápis:")
+
+### ![:checkered_flag:](https://forum.freecodecamp.com/images/emoji/emoji_one/checkered_flag.png?v=3 ": checkered_flag:") Explicação do Problema:
+
+Temos uma variedade de objetos representando pessoas diferentes em nossas listas de contatos.
+
+Uma função `lookUpProfile()` que usa **firstName** e uma propriedade ( **prop** ) como argumentos foi pré-escrita para você.
+
+A função deve verificar se **firstName** é **firstName** de um contato real e a propriedade dada **(PROP)** é uma propriedade desse contato.
+
+Se ambos forem verdadeiros, retorne o _valor_ dessa propriedade.
+
+Se **firstName** não corresponder a nenhum contato, retorne `No such contact` .
+
+Se **prop** não corresponder a nenhuma propriedade válida, não retorne `No such property` .
+
+*   Altere o código abaixo `// Only change code below this line` e até `// Only change code above this line` .
+*   Verifique se você está editando o interior da função `lookUpProfile()` .
+    *   Esta função inclui dois parâmetros, **firstName** e **prop** .
+*   A função deve procurar na lista de **contatos** o parâmetro **firstName** fornecido.
+    *   Se houver uma correspondência encontrada, a função deve procurar o parâmetro **prop** dado.
+    *   Se o **firstName** e o **prop** associado forem encontrados, você deve retornar o valor do **prop** .
+    *   Se **firstName** for encontrado e nenhum **prop** associado for encontrado, você deverá retornar `No such property` .
+*   Se **firstName** não for encontrado em qualquer lugar, você deve retornar `No such contact` .
+
+#### Links Relevantes
+
+*   [Desafio: Acessando Propriedades de Objetos com Notação de Bracket](http://www.freecodecamp.com/challenges/accessing-objects-properties-with-bracket-notation)
+*   [Desafio: Iterar com JavaScript para loops](http://www.freecodecamp.com/challenges/iterate-with-javascript-for-loops)
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugestão: 1
+
+Use um loop `for` para percorrer a lista de **contatos** .
+
+> _tente resolver o problema agora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Dica: 2
+
+Use uma instrução `if` aninhada para primeiro verificar se o **firstName** corresponde e, em seguida, verifica `if` o **prop** corresponde.
+
+> _tente resolver o problema agora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Dica: 3
+
+Deixe o seu `return "No such contact"` fora do loop `for` como um final pega-tudo.
+
+> _tente resolver o problema agora_
+
+## Alerta de Spoiler!
+
+![sinal de aviso](//discourse-user-assets.s3.amazonaws.com/original/2X/2/2d6c412a50797771301e7ceabd554cef4edcd74d.gif)
+
+**Solução à frente!**
+
+## ![:beginner:](https://forum.freecodecamp.com/images/emoji/emoji_one/beginner.png?v=3 ":principiante:") Solução básica de código:
+```
+for (var x = 0; x < contacts.length; x++){ 
+    if (contacts[x].firstName === name) { 
+        if (contacts[x].hasOwnProperty(prop)) { 
+            return contacts[x][prop]; 
+        } else { 
+            return "No such property"; 
+        } 
+    } 
+ } 
+ return "No such contact"; 
+```
+
+### Explicação do código:
+
+*   O loop `for` é executado, iniciando no primeiro objeto na lista de **contatos** .
+*   Se o parâmetro **firstName** passado para a função corresponder ao valor da chave `"firstName"` no primeiro objeto, a instrução `if` transmitida.
+*   Em seguida, usamos o método `.hasOwnProperty()` (verifica se há uma determinada propriedade e retorna um booleano) com **prop** como argumento. Se for verdade, o valor de **prop** é retornado.
+    *   Se a segunda instrução `if` falhar, `No such property` será retornada.
+*   Se a primeira instrução `if` falhar, o loop `for` continuará no próximo objeto da lista de **contatos** .
+*   Se o parâmetro **firstName** não corresponder ao objeto de **contatos** final, o loop `for` encerrado e `No such contact` será retornado.
+
+**Exemplo de Execução**
+
+*   `lookUpProfile("Akira","likes");` corre.
+*   `"Akira"` é correspondido à chave `"firstName"` no primeiro objeto, portanto, a instrução `if` retorna true.
+*   `"likes"` é encontrado dentro do primeiro objeto, então o segundo `if` retorna true.
+*   O valor de `"likes"` é retornado - `"Pizza", "Coding", "Brownie Points"` .
+
+## ![:clipboard:](https://forum.freecodecamp.com/images/emoji/emoji_one/clipboard.png?v=3 ":prancheta:") NOTAS PARA CONTRIBUIÇÕES:
+
+*   ![:warning:](https://forum.freecodecamp.com/images/emoji/emoji_one/warning.png?v=3 ":Aviso:") **NÃO** adicione soluções semelhantes às soluções existentes. Se você acha que é **_semelhante, mas melhor_** , tente mesclar (ou substituir) a solução semelhante existente.
+*   Adicione uma explicação da sua solução.
+*   Categorize a solução em uma das seguintes categorias - **Básica** , **Intermediária** e **Avançada** . ![:traffic_light:](https://forum.freecodecamp.com/images/emoji/emoji_one/traffic_light.png?v=3 ":semáforo:")
+*   Por favor, adicione seu nome de usuário somente se você adicionou qualquer **conteúdo principal relevante** . ( ![:warning:](https://forum.freecodecamp.com/images/emoji/emoji_one/warning.png?v=3 ":Aviso:") **_NÃO_** _remova nenhum nome de usuário existente_ )
+
+> Vejo ![:point_right:](https://forum.freecodecamp.com/images/emoji/emoji_one/point_right.png?v=3 ": point_right:") **`Wiki Challenge Solution Template`** para referência.

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/quoting-strings-with-single-quotes/index.md

@@ -0,0 +1,9 @@
+---
+title: Quoting Strings with Single Quotes
+localeTitle: Citando Strings com Citações Únicas
+---
+## Citando Strings com Citações Únicas
+
+Este é um esboço. [Ajude nossa comunidade a expandi-lo](https://github.com/freecodecamp/guides/tree/master/src/pages/certifications/javascript-algorithms-and-data-structures/basic-javascript/quoting-strings-with-single-quotes/index.md) .
+
+[Este guia de estilo rápido ajudará a garantir que sua solicitação de recebimento seja aceita](https://github.com/freecodecamp/guides/blob/master/README.md) .

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/record-collection/index.md

@@ -0,0 +1,97 @@
+---
+title: Record Collection
+localeTitle: Colecção de registos
+---
+![:triangular_flag_on_post:](https://forum.freecodecamp.com/images/emoji/emoji_one/triangular_flag_on_post.png?v=3 "triangular_flag_on_post:") Lembre-se de usar **`Read-Search-Ask`** se você ficar preso. Tente emparelhar o programa ![:busts_in_silhouette:](https://forum.freecodecamp.com/images/emoji/emoji_one/busts_in_silhouette.png?v=3 ": busts_in_silhouette:") e escreva seu próprio código ![:pencil:](https://forum.freecodecamp.com/images/emoji/emoji_one/pencil.png?v=3 ":lápis:")
+
+### ![:checkered_flag:](https://forum.freecodecamp.com/images/emoji/emoji_one/checkered_flag.png?v=3 ": checkered_flag:") Explicação do Problema:
+
+Você recebe um objeto JSON representando (uma pequena parte de) sua coleção de registros. Cada álbum é identificado por um número de identificação exclusivo e possui várias propriedades. Nem todos os álbuns possuem informações completas.
+
+Escreva uma função que tenha um **id** , uma propriedade ( **prop** ) e um **valor** .
+
+Para o **ID** fornecido na **coleção** :
+
+Se o **valor** não estiver em branco ( **valor! == ""** ), atualize ou defina o **valor** para o **prop** .
+
+Se o **prop** é **"faixas"** e o **valor** não é em branco, verifique se o elemento especificado no array tem a propriedade "tracks". Se o elemento tiver a propriedade "tracks", insira o **valor** no final da matriz "tracks". Se o elemento não tiver a **propriedade** , crie o par de propriedade e valor.
+
+Se o **valor** estiver em branco, exclua esse **prop** .
+
+Sempre retorne o objeto de coleção inteiro.
+
+*   Altere o código abaixo `// Only change code below this line` e `// Only change code below this line` `// Alter values below to test your code` .
+*   Tome nota que você está editando o interior da função `updateRecords` .
+*   Para o parâmetro **id** fornecido, que está associado ao objeto de **coleção** :
+    *   Se o parâmetro **value** não for uma string vazia, atualize (ou configure) o parâmetro **value** para o parâmetro **prop** .
+    *   Se o parâmetro **prop** for igual a `"tracks"` e o **valor** não for uma string vazia, pressione o **valor** para o final da matriz de **tracks** .
+    *   Se o **valor** for uma string vazia, exclua essa **prop** do objeto.
+*   Finalmente, retorne o objeto de **coleção** .
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugestão: 1
+
+Use uma instrução `else if` para verificar as etapas necessárias.
+
+> _tente resolver o problema agora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Dica: 2
+
+A segunda etapa listada nas instruções deve ser a primeira na declaração `else if` .
+
+> _tente resolver o problema agora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Dica: 3
+
+Para acessar o valor de uma chave neste objeto, você usará a `collection[id][prop]` .
+
+> _tente resolver o problema agora_
+
+## Alerta de Spoiler!
+
+![sinal de aviso](//discourse-user-assets.s3.amazonaws.com/original/2X/2/2d6c412a50797771301e7ceabd554cef4edcd74d.gif)
+
+**Solução à frente!**
+
+## ![:beginner:](https://forum.freecodecamp.com/images/emoji/emoji_one/beginner.png?v=3 ":principiante:") Solução básica de código:
+```
+function updateRecords(id, prop, value) { 
+  if (prop === "tracks" && value !== "") { 
+   if(collection[id][prop]) { 
+    collection[id][prop].push(value); 
+   } 
+   else { 
+    collection[id][prop]=[value]; 
+   } 
+  } else if (value !== "") { 
+    collection[id][prop] = value; 
+  } else { 
+    delete collection[id][prop]; 
+  } 
+ 
+  return collection; 
+ } 
+```
+
+![:rocket:](https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=3 ":foguete:") [Executar código](https://repl.it/C2AZ/0)
+
+### Explicação do código:
+
+*   Primeiro, verifica se **prop** é igual a **tracks** E se o **valor** não é uma string em branco. Se ambos os testes forem aprovados, o **valor** será inserido na matriz de **faixas** .
+*   Se essa primeira verificação não for aprovada, a próxima verificação será feita somente se o **valor** não for uma string em branco. Se esse teste for aprovado, uma nova chave ( **prop** ) e um valor ( **valor** ) serão adicionados ao objeto, ou uma chave existente será atualizada se o **prop** já existir.
+*   Se ambas as verificações falharem (o **valor de** significado deve ser uma string vazia), a chave ( **prop** ) será removida do objeto.
+
+**Exemplo de Execução**
+
+*   `updateRecords(5439, "artist", "ABBA");` corre.
+*   **prop** é igual a "artista", não "faixas", então a primeira parte da declaração `else if` falha.
+*   **valor** não é uma string em branco, então a segunda parte da declaração if passa.
+*   `artist: "ABBA"` é adicionado ao `id` `5439` .
+
+### Recursos:
+
+*   [Desafio do FCC: Acessando Propriedades de Objetos com Notação de Bracket](https://learn.freecodecamp.org/javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-bracket-notation/)
+*   [O desafio do fCC: adicionar novas propriedades a um objeto JavaScript](http://www.freecodecamp.com/challenges/add-new-properties-to-a-javascript-object)
+*   [O desafio do fCC: excluir propriedades de um objeto JavaScript](http://www.freecodecamp.com/challenges/delete-properties-from-a-javascript-object)
+*   [O desafio do fCC: Acessando Objetos Aninhados](https://learn.freecodecamp.org/javascript-algorithms-and-data-structures/basic-javascript/accessing-nested-objects/)
+*   ["Array.prototype.push ()" - _Referência do MDN JavaScript_](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push)
+*   ["delete operator" - _Referência do MDN JavaScript_](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/delete)

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/replacing-if-else-chains-with-switch/index.md

@@ -0,0 +1,9 @@
+---
+title: Replacing If Else Chains with Switch
+localeTitle: Substituindo se outras cadeias com o interruptor
+---
+## Substituindo se outras cadeias com o interruptor
+
+Este é um esboço. [Ajude nossa comunidade a expandi-lo](https://github.com/freecodecamp/guides/tree/master/src/pages/certifications/javascript-algorithms-and-data-structures/basic-javascript/replacing-if-else-chains-with-switch/index.md) .
+
+[Este guia de estilo rápido ajudará a garantir que sua solicitação de recebimento seja aceita](https://github.com/freecodecamp/guides/blob/master/README.md) .

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/return-a-value-from-a-function-with-return/index.md

@@ -0,0 +1,14 @@
+---
+title: Return a Value from a Function with Return
+localeTitle: Retornar um valor de uma função com retorno
+---
+## Retornar um valor de uma função com retorno
+
+Usando o `return` , você pode fazer funções de saída de dados. Aqui está a solução básica de código:
+
+```javascript
+function timesFive(num) { 
+  return num * 5; 
+ } 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/return-early-pattern-for-functions/index.md

@@ -0,0 +1,9 @@
+---
+title: Return Early Pattern for Functions
+localeTitle: Retorna o padrão inicial para funções
+---
+## Retorna o padrão inicial para funções
+
+Este é um esboço. [Ajude nossa comunidade a expandi-lo](https://github.com/freecodecamp/guides/tree/master/src/pages/certifications/javascript-algorithms-and-data-structures/basic-javascript/return-early-pattern-for-functions/index.md) .
+
+[Este guia de estilo rápido ajudará a garantir que sua solicitação de recebimento seja aceita](https://github.com/freecodecamp/guides/blob/master/README.md) .

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/returning-boolean-values-from-functions/index.md

@@ -0,0 +1,53 @@
+---
+title: Returning Boolean Values from Functions
+localeTitle: Retornando valores booleanos de funções
+---
+## Retornando valores booleanos de funções
+
+Em vez de usar um bloco if / else para comparar a variável, podemos fazê-lo dentro da declaração de retorno com um operador de comparação e um código minúsculo.
+
+### Explicação do problema
+
+_Corrigir a função `isLess` para remover as instruções `if...else` ._
+
+```js
+// Fix this code 
+  if (a < b) { 
+    return true; 
+  } else { 
+    return false; 
+  } 
+```
+
+#### Sugestão 1
+
+Como no [exercício anterior,](https://learn.freecodecamp.org/javascript-algorithms-and-data-structures/basic-javascript/replacing-if-else-chains-with-switch) você está prestes a mudar como a função retorna o valor correto, o que significa que você não precisa reutilizar ou modificar esse código, mas substituí-lo.
+
+> _tente resolver o problema agora_
+
+#### Sugestão 2
+
+Para retornar `true` ou `false` você não precisa de duas declarações, nem de usar, `if` . O [operador de comparação](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators) correto é tudo que você precisa.
+
+> _tente resolver o problema agora_
+
+## Alerta de spoiler!
+
+**Solução à frente!**
+
+## Solução de Código:
+
+```javascript
+function isLess(a, b) { 
+  // Fix this code 
+  return a <= b; 
+ } 
+ // Change these values to test 
+ isLess(10, 15); 
+```
+
+Execute o código em [repl.it.](https://repl.it/@AdrianSkar/Basic-Js-Returning-boolean-from-function)
+
+### Recursos
+
+*   ["Operador menor ou igual a (<=)" - _Referência do MDN para JavaScript_](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Less_than_or_equal_operator_(%3C))

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/selecting-from-many-options-with-switch-statements/index.md

@@ -0,0 +1,127 @@
+---
+title: Selecting from Many Options with Switch Statements
+localeTitle: Selecionando a partir de muitas opções com instruções de troca
+---
+## Selecionando a partir de muitas opções com instruções de troca
+
+_Se você tiver muitas opções para escolher, use uma instrução `switch` . Uma instrução `switch` testa um valor e pode ter várias instruções `case` que definem vários valores possíveis. As declarações são executadas a partir do primeiro valor do `case` correspondente até que uma `break` seja encontrada._
+
+_Aqui está um exemplo de pseudocódigo:_
+
+```js
+  switch(num) { 
+    case value1: 
+      statement1; 
+      break; 
+    case value2: 
+      statement2; 
+      break; 
+    ... 
+    case valueN: 
+      statementN; 
+      break; 
+  } 
+```
+
+### Um pouco mais de explicação
+
+Uma instrução switch primeiro avalia sua expressão. Em seguida, ele procura a cláusula do primeiro `case` cuja expressão é avaliada para o mesmo valor que o resultado da expressão de entrada (usando a [comparação estrita](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators) , ( `===` ) e transfere o controle para essa cláusula, executando as instruções associadas. o valor fornecido, o primeiro caso correspondente é selecionado, mesmo que os casos não sejam iguais entre si.
+
+Se nenhuma cláusula `case` correspondente for encontrada, o programa procurará a cláusula `default` opcional e, se encontrada, transfere o controle para essa cláusula, executando as instruções associadas. Se nenhuma cláusula `default` for encontrada, o programa continuará a execução na instrução após o final do `switch` . Por convenção, a cláusula `default` é a última cláusula, mas não precisa ser assim.
+
+A instrução de `break` opcional associada a cada rótulo de caso assegura que o programa rompe o comutador quando a instrução correspondente é executada e continua a execução na instrução após o comutador. Se `break` for omitido, o programa continua a execução na próxima instrução na instrução `switch` . [1](#cite1)
+
+### Explicação do Problema:
+
+_Escreva uma instrução switch que teste `val` e configure a `answer` para as seguintes condições:_
+
+*   `1` - "alfa",
+*   `2` - "beta",
+*   `3` - "gama",
+*   `4` - "delta".
+
+## Sugestão 1
+
+Lembre-se de que os valores de `case` são testados com igualdade estrita ( `===` ).
+
+> Tente resolver o problema agora!
+
+## Sugestão 2
+
+Não veja as _"condições a seguir"_ como uma lista ordenada como parece na demo freeCodeCamp original, mas como valores e instruções, como mostrado aqui
+
+> Tente resolver o problema agora!
+
+## Alerta de Spoiler!
+
+### Você está completamente certo do que você quer dar uma olhada? …
+
+## Solução básica de código
+
+```js
+function caseInSwitch(val) { 
+  var answer = ""; 
+  // Only change code below this line 
+  switch(val) { 
+    case 1: 
+      return "alpha"; 
+      break; 
+    case 2: 
+      return "beta"; 
+      break; 
+    case 3: 
+      return "gamma"; 
+      break; 
+    case 4: 
+      return "delta"; 
+      break; 
+  } 
+ 
+  // Only change code above this line 
+  return answer; 
+ } 
+ 
+ // Change this value to test 
+ caseInSwitch(1); 
+```
+
+### Explicação do código
+
+É comum ignorar que os valores do `case` são testados com igualdade estrita com qualquer necessidade de outra expressão, da seguinte forma: `case === value`
+
+## Solução alternativa de código:
+
+```javascript
+function caseInSwitch(val) { 
+  var answer = ""; 
+  // Only change code below this line 
+  switch (val){ 
+    case 1: 
+      answer="alpha"; 
+      break; 
+    case 2: 
+      answer="beta"; 
+      break; 
+    case 3: 
+      answer="gamma"; 
+      break; 
+    case 4: 
+      answer="delta"; 
+      break; 
+  } 
+  // Only change code above this line 
+  return answer; 
+ } 
+ // Change this value to test 
+ caseInSwitch(1); 
+```
+
+· Executar código no [repl.it.](https://repl.it/@AdrianSkar/Basic-JS-Switch-statements)
+
+### Explicação de código
+
+Como você já tem uma variável definida no início da função chamada `answer` e ela é definida como a última instrução de retorno, você pode atribuir novos valores a ela para cada caso e retornará a resposta esperada dependendo do valor que você passa para a função.
+
+### Fontes
+
+1 [Descrição do "switch" - _referência do MDN JavaScript_](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/switch#Description) .

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/shopping-list/index.md

@@ -0,0 +1,65 @@
+---
+title: Shopping List
+localeTitle: Lista de compras
+---
+![:triangular_flag_on_post:](https://forum.freecodecamp.com/images/emoji/emoji_one/triangular_flag_on_post.png?v=3 "triangular_flag_on_post:") Lembre-se de usar **`Read-Search-Ask`** se você ficar preso. Tente emparelhar o programa ![:busts_in_silhouette:](https://forum.freecodecamp.com/images/emoji/emoji_one/busts_in_silhouette.png?v=3 ": busts_in_silhouette:") e escreva seu próprio código ![:pencil:](https://forum.freecodecamp.com/images/emoji/emoji_one/pencil.png?v=3 ":lápis:")
+
+### ![:checkered_flag:](https://forum.freecodecamp.com/images/emoji/emoji_one/checkered_flag.png?v=3 ": checkered_flag:") Explicação do Problema:
+
+Crie uma lista de compras na variável **myList** . A lista deve ser um array multidimensional contendo vários sub-arrays.
+
+O primeiro elemento em cada sub-array deve conter uma string com o nome do item. O segundo elemento deve ser um número representando a quantidade, ou seja, `["Chocolate Bar", 15]` .
+
+Deve haver pelo menos 5 sub-arrays na lista.
+
+*   **myList** deve ser um array.
+*   Os primeiros elementos em cada um dos seus sub-arrays devem ser todos strings.
+*   Os segundos elementos em cada um dos seus sub-arrays devem todos ser números.
+*   Você deve ter pelo menos 5 itens em sua lista.
+
+#### Links Relevantes
+
+*   [Desafio: aninhe um array dentro de outro array](https://learn.freecodecamp.org/javascript-algorithms-and-data-structures/basic-javascript/nest-one-array-within-another-array/)
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugestão: 1
+
+Uma matriz multidimensional teria o seguinte esquema `[[]]` .
+
+> _tente resolver o problema agora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Dica: 2
+
+Cada sub-array deve ser separado por `,` como qualquer item de uma matriz.
+
+> _tente resolver o problema agora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Dica: 3
+
+Não esqueça o `;` no final da sua declaração.
+
+> _tente resolver o problema agora_
+
+## Alerta de Spoiler!
+
+![sinal de aviso](//discourse-user-assets.s3.amazonaws.com/original/2X/2/2d6c412a50797771301e7ceabd554cef4edcd74d.gif)
+
+**Solução à frente!**
+
+## ![:beginner:](https://forum.freecodecamp.com/images/emoji/emoji_one/beginner.png?v=3 ":principiante:") Solução básica de código:
+```
+var myList = [["Canned Beans", 3],["Milk Galon", 1],["Cereal", 2],["Toilet Paper", 12],["Sack of Rice", 1]]; 
+```
+
+### Explicação do código:
+
+*   Uma matriz multidimensional é criada.
+*   A matriz consiste de cinco matrizes no interior, cada uma composta de uma string e um inteiro, na mesma ordem.
+
+## ![:clipboard:](https://forum.freecodecamp.com/images/emoji/emoji_one/clipboard.png?v=3 ":prancheta:") NOTAS PARA CONTRIBUIÇÕES:
+
+*   ![:warning:](https://forum.freecodecamp.com/images/emoji/emoji_one/warning.png?v=3 ":Aviso:") **NÃO** adicione soluções semelhantes às soluções existentes. Se você acha que é **_semelhante, mas melhor_** , tente mesclar (ou substituir) a solução semelhante existente.
+*   Adicione uma explicação da sua solução.
+*   Categorize a solução em uma das seguintes categorias - **Básica** , **Intermediária** e **Avançada** . ![:traffic_light:](https://forum.freecodecamp.com/images/emoji/emoji_one/traffic_light.png?v=3 ":semáforo:")
+*   Por favor, adicione seu nome de usuário somente se você adicionou qualquer **conteúdo principal relevante** . ( ![:warning:](https://forum.freecodecamp.com/images/emoji/emoji_one/warning.png?v=3 ":Aviso:") **_NÃO_** _remova nenhum nome de usuário existente_ )
+
+> Vejo ![:point_right:](https://forum.freecodecamp.com/images/emoji/emoji_one/point_right.png?v=3 ": point_right:") [**`Wiki Challenge Solution Template`**](http://forum.freecodecamp.com/t/algorithm-article-template/14272) para referência.

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/stand-in-line/index.md

@@ -0,0 +1,73 @@
+---
+title: Stand in Line
+localeTitle: Ficar na fila
+---
+![:triangular_flag_on_post:](https://forum.freecodecamp.com/images/emoji/emoji_one/triangular_flag_on_post.png?v=3 "triangular_flag_on_post:") Lembre-se de usar **`Read-Search-Ask`** se você ficar preso. Tente emparelhar o programa ![:busts_in_silhouette:](https://forum.freecodecamp.com/images/emoji/emoji_one/busts_in_silhouette.png?v=3 ": busts_in_silhouette:") e escreva seu próprio código ![:pencil:](https://forum.freecodecamp.com/images/emoji/emoji_one/pencil.png?v=3 ":lápis:")
+
+### ![:checkered_flag:](https://forum.freecodecamp.com/images/emoji/emoji_one/checkered_flag.png?v=3 ": checkered_flag:") Explicação do Problema:
+
+Na Ciência da Computação, uma _fila_ é uma **estrutura de dados** abstrata em que os itens são mantidos em ordem. Novos itens podem ser adicionados na parte de trás da **fila** e itens antigos são retirados da frente da **fila** .
+
+Escreva uma função `nextInLine` que recebe um array ( **arr** ) e um número ( **item** ) como argumentos. Adicione o número ao final da matriz e remova o primeiro elemento da matriz. A função `nextInLine` deve então retornar o elemento que foi removido.
+
+*   Altere o código abaixo `//Your Code here` e até `//Change this line` .
+*   Verifique se você está editando o interior da função `nextInLine` .
+*   Use uma função de matriz que você aprendeu a adicionar o **item** ao final da matriz **arr** .
+*   Use uma função de matriz que você aprendeu a remover o primeiro elemento da matriz **arr** .
+*   Retorna o elemento removido.
+
+#### Links Relevantes
+
+*   [Desafio: manipular matrizes com push ()](http://www.freecodecamp.com/challenges/manipulate-arrays-with-push)
+*   [Desafio: Manipular Arrays Com Shift ()](http://www.freecodecamp.com/challenges/manipulate-arrays-with-shift)
+*   [Desafio: passando valores para funções com argumentos](http://www.freecodecamp.com/challenges/passing-values-to-functions-with-arguments)
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugestão: 1
+
+O método `push()` adiciona um item ao final de um array.
+
+> _tente resolver o problema agora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Dica: 2
+
+O método `shift()` remove o primeiro elemento de uma matriz. Também retorna o elemento removido.
+
+> _tente resolver o problema agora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Dica: 3
+
+A função `nextInLine` usa **arr** e **item** . Esses são os testes que serão usados ​​para transmitir os elementos da matriz com os quais eles testarão. Permite que a função seja reutilizável. Não codifique qualquer um dos testes dentro da função.
+
+> _tente resolver o problema agora_
+
+## Alerta de Spoiler!
+
+![sinal de aviso](//discourse-user-assets.s3.amazonaws.com/original/2X/2/2d6c412a50797771301e7ceabd554cef4edcd74d.gif)
+
+**Solução à frente!**
+
+## ![:beginner:](https://forum.freecodecamp.com/images/emoji/emoji_one/beginner.png?v=3 ":principiante:") Solução básica de código:
+```
+function nextInLine(arr, item) { 
+  // Your code here 
+  arr.push(item); 
+  var removed = arr.shift(); 
+  return removed;  // Change this line 
+ } 
+```
+
+### Explicação do código:
+
+*   Empurrar **item** no final do **arr** .
+*   Chame o método `shift()` na **arr** para obter o primeiro item e armazene-o em **removido** .
+*   Retornar **removido** .
+
+**Exemplo de Execução**
+
+*   Teste `nextInLine([2,1]);` corre.
+*   A função `nextInLine` é chamada. **arr** se torna \[2\]. **item** se torna 1.
+*   `arr.push(item);` Empurra de 1 a \[2\]. Então **arr** é agora \[2,1\].
+*   `var removed = arr.shift();` remove o primeiro elemento. Então **arr** é agora \[1\]. 2 foi removido e é armazenado em **removido** .
+*   `return removed;` 2 é retornado.
+
+**_Nota_** : Você não precisa realmente da variável **removida** . O elemento removido pode ser retornado diretamente usando o `return arr.shift();` .

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/store-multiple-values-in-one-variable-using-javascript-arrays/index.md

@@ -0,0 +1,17 @@
+---
+title: Store Multiple Values in one Variable using JavaScript Arrays
+localeTitle: Armazenar vários valores em uma variável usando matrizes JavaScript
+---
+## Armazenar vários valores em uma variável usando matrizes JavaScript
+
+Arrays permitem que você armazene muitos dados diferentes, dentro de uma única variável. Tudo o que você precisa fazer é colocar os dados no array, separados por vírgulas. Igual a…
+
+```javascript
+var arr = ["Code for change", 123]; 
+```
+
+Lembre-se, uma matriz é definida como uma linha de coisas. Você está armazenando dados diferentes em uma única 'linha' (variável).
+
+Verifique este link se precisar de mais ajuda:
+
+[Matrizes JavaScript em escolas W3](https://www.w3schools.com/js/js_arrays.asp)

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/storing-values-with-the-assignment-operator/index.md

@@ -0,0 +1,15 @@
+---
+title: Storing Values with the Assignment Operator
+localeTitle: Armazenando Valores com o Operador de Atribuição
+---
+## Armazenando Valores com o Operador de Atribuição
+
+É como matemática! Você pode definir uma variável para agir como um espaço reservado para dados usando o operador de atribuição '='. Em outras palavras, a variável armazenará os dados.
+```
+var a; 
+ a = 5; // The variable 'a' is equal to 5 
+ 
+ var zxcv; 
+ zxcv = 123; // The variable 'abc' is equal to 123 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/subtract-one-number-from-another-with-javascript/index.md

@@ -0,0 +1,12 @@
+---
+title: Subtract One Number from Another with JavaScript
+localeTitle: Subtrair um número de outro com JavaScript
+---
+## Subtrair um número de outro com JavaScript
+
+Usando o operador de subtração '-', você pode obter a diferença de dois números…
+```
+var diff1 = 30 - 14; // Difference is 16 
+ var diff2 = 90 - 60; // Difference is 30 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/testing-objects-for-properties/index.md

@@ -0,0 +1,64 @@
+---
+title: Testing Objects for Properties
+localeTitle: Testando Objetos para Propriedades
+---
+## Testando Objetos para Propriedades
+
+Aqui está o exemplo:
+
+```javascript
+// Setup 
+ var myObj = { 
+  gift: "pony", 
+  pet: "kitten", 
+  bed: "sleigh" 
+ }; 
+ 
+ function checkObj(checkProp) { 
+  // Your Code Here 
+ 
+  return "Change Me!"; 
+ } 
+ 
+ // Test your code by modifying these values 
+ checkObj("gift"); 
+```
+
+Aqui está uma solução:
+
+Nós não mudamos nada aqui:
+
+```javascript
+// Setup 
+ var myObj = { 
+  gift: "pony", 
+  pet: "kitten", 
+  bed: "sleigh" 
+ }; 
+```
+
+além disso, no corpo da função, usamos o `.hasOwnProperty(propname)` dos objetos para determinar se esse objeto tem o nome da propriedade fornecido. `if/else` declaração com valores booleanos nos ajudará nisso:
+
+```javascript
+function checkObj(checkProp) { 
+  // Your Code Here 
+  if (myObj.hasOwnProperty(checkProp) == true) { 
+    return myObj[checkProp]; 
+  } 
+  else { 
+ ``` 
+ 
+ and change the value of `return` in `else` statement: 
+```
+
+javascript return "Não encontrado" } }
+```
+Now, you can change `checkObj` values: 
+```
+
+javascript // Teste seu código modificando esses valores checkObj ("presente");
+```
+Here's a full solution: 
+```
+
+javascript function checkObj (checkProp) { // seu código aqui if (myObj.hasOwnProperty (checkProp) == true) { return myObj \[checkProp\]; } outro { return "Não encontrado" } } // Teste seu código modificando esses valores checkObj ("presente"); \`\` \`

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/understand-string-immutability/index.md

@@ -0,0 +1,9 @@
+---
+title: Understand String Immutability
+localeTitle: Entenda a imutabilidade da corda
+---
+## Entenda a imutabilidade da corda
+
+Este é um esboço. [Ajude nossa comunidade a expandi-lo](https://github.com/freecodecamp/guides/tree/master/src/pages/certifications/javascript-algorithms-and-data-structures/basic-javascript/understand-string-immutability/index.md) .
+
+[Este guia de estilo rápido ajudará a garantir que sua solicitação de recebimento seja aceita](https://github.com/freecodecamp/guides/blob/master/README.md) .

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/understanding-boolean-values/index.md

@@ -0,0 +1,42 @@
+---
+title: Understanding Boolean values
+localeTitle: Entendendo valores booleanos
+---
+## Entendendo valores booleanos
+
+### Explicação do problema:
+
+Modifique a função `welcomeToBooleans` para que ela retorne `true` vez de `false` quando o botão de execução for clicado.
+
+### Sugestão 1
+
+Você só precisa editar a linha 5 para que a função retorne `true` vez de `false` .
+
+> _tente resolver o problema agora_
+
+## Alerta de Spoiler!
+
+**Solução à frente!**
+
+## ![:beginner:](https://forum.freecodecamp.com/images/emoji/emoji_one/beginner.png?v=3 ":principiante:") Solução básica de código:
+
+```javascript
+function welcomeToBooleans() { 
+ 
+ // Only change code below this line. 
+ 
+ return true; // Change this line 
+ 
+ // Only change code above this line. 
+ } 
+```
+
+### Explicação de código
+
+Apenas modificar o valor `Boolean` você não quer que a função retorne de `false` para `true` atenderá aos requisitos.
+
+### Recursos
+
+[Glossário MDN - Booleano](https://developer.mozilla.org/en-US/docs/Glossary/Boolean)
+
+[Wikipedia - Tipo de dados booleano](https://en.wikipedia.org/wiki/Boolean_data_type)

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/understanding-case-sensitivity-in-variables/index.md

@@ -0,0 +1,14 @@
+---
+title: Understanding Case Sensitivity in Variables
+localeTitle: Entendendo a sensibilidade do caso em variáveis
+---
+## Entendendo a sensibilidade do caso em variáveis
+
+Uma norma de programação popular é usar o **caso do Camel** ao criar nomes de variáveis. Observe que a primeira palavra é minúscula e toda palavra seguinte é maiúscula. aqui estão alguns exemplos:
+```
+var camelCase; 
+ var someNumber; 
+ var theBestVariableEver; 
+ var weWillStoreNumbersInThisVariable; 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/understanding-undefined-value-returned-from-a-function/index.md

@@ -0,0 +1,22 @@
+---
+title: Understanding Undefined Value returned from a Function
+localeTitle: Entendendo o valor indefinido retornado de uma função
+---
+## Entendendo o valor indefinido retornado de uma função
+
+Uma função sem instrução de `return` , possui uma saída `undefined` . Então, se você tentar igualar uma variável à saída de uma função sem instrução de `return` , essa variável será igual a `undefined` .
+
+Vá em frente e defina `addFive()` assim…
+
+```javascript
+function addFive() { 
+  sum += 5; 
+ } 
+```
+
+Como você pode ver, `sum` é adicionada por 5 sem problemas, mas como não há instrução de retorno, há uma saída `undefined` .
+
+```javascript
+var result = addFive(); // This is undefined 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/understanding-uninitialized-variables/index.md

@@ -0,0 +1,7 @@
+---
+title: Understanding Uninitialized Variables
+localeTitle: Noções básicas sobre variáveis ​​não inicializadas
+---
+## Noções básicas sobre variáveis ​​não inicializadas
+
+Certifique-se de que a variável tenha o valor de dados correto. Deixar uma variável não inicializada, significando que você não atribui a ela um valor, pode causar problemas se você quiser fazer operações nela.

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/updating-object-properties/index.md

@@ -0,0 +1,28 @@
+---
+title: Updating Object Properties
+localeTitle: Atualizando Propriedades do Objeto
+---
+## Atualizando Propriedades do Objeto
+
+## Dica:
+
+Use ponto \*\*. \*\* notação para acessar a propriedade do objeto.
+
+## Alerta de Spoiler: Solução à frente!
+
+## Solução:
+
+```javascript
+// Setup 
+ var myDog = { 
+  "name": "Coder", 
+  "legs": 4, 
+  "tails": 1, 
+  "friends": ["freeCodeCamp Campers"] 
+ }; 
+ 
+ // Only change code below this line. 
+ 
+ myDog.name = "Happy Coder"; // Solution 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-first-character-in-a-string/index.md

@@ -0,0 +1,12 @@
+---
+title: Use Bracket Notation to Find the First Character in a String
+localeTitle: Use a notação de suporte para localizar o primeiro caractere em uma seqüência de caracteres
+---
+## Use a notação de suporte para localizar o primeiro caractere em uma seqüência de caracteres
+
+Lembre-se de que o primeiro caractere de uma string está na posição zero-th. Por exemplo:
+```
+var str = "Hello"; 
+ var letter = str[0]; // This equals "H" 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-last-character-in-a-string/index.md

@@ -0,0 +1,19 @@
+---
+title: Use Bracket Notation to Find the Last Character in a String
+localeTitle: Use a notação de suporte para localizar o último caractere em uma string
+---
+## Use a notação de suporte para localizar o último caractere em uma string
+
+Considere a seguinte string:
+```
+var str = "Coding"; 
+```
+
+Esta string tem um comprimento de 6 caracteres, então se você usar .length na string, ela dará a você 6. Mas lembre-se que o primeiro caractere está na posição zero-th. O segundo personagem está na primeira posição. O terceiro personagem está na segunda posição.
+
+Continue em frente e, eventualmente, você verá que o sexto caractere (que, com base na string acima, é 'g') está na quinta posição. É por isso que você obtém o último caractere de uma string, com:
+```
+var lastChar = str[str.length - 1]; // This is 6 - 1, which is 5 
+```
+
+Isso será 'g'.

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-nth-character-in-a-string/index.md

@@ -0,0 +1,7 @@
+---
+title: Use Bracket Notation to Find the Nth Character in a String
+localeTitle: Use a notação de suporte para localizar o caractere Nth em uma seqüência de caracteres
+---
+## Use a notação de suporte para localizar o caractere Nth em uma seqüência de caracteres
+
+Lembre-se de que o primeiro caractere de uma string está na 0ª posição. Então o segundo personagem deve estar na primeira posição. Então o terceiro personagem, deveria estar no ... hmmm?

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-nth-to-last-character-in-a-string/index.md

@@ -0,0 +1,13 @@
+---
+title: Use Bracket Notation to Find the Nth-to-Last Character in a String
+localeTitle: Use a notação de suporte para localizar o caractere N-para-último em uma seqüência de caracteres
+---
+## Use a notação de suporte para localizar o caractere N-para-último em uma seqüência de caracteres
+
+Lembre-se de que a posição de qualquer caractere é o **comprimento da string, menos um, menos o número de caracteres depois dela** . Por exemplo, se você estiver tentando encontrar o terceiro ao último caractere da seguinte cadeia:
+```
+var str = "Programming"; 
+ var secondToLastChar = str[str.length - 2]; // This is 'i' 
+```
+
+Como você pode ver, há um caractere extra depois de 'n' (e isso é 'g').