fix(guide): simplify directory structure

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-data-structures/-iterate-through-the-keys-of-an-object-with-a-for...in-statement/index.md

@@ -0,0 +1,69 @@
+---
+title:  Iterate Through the Keys of an Object with a for...in Statement
+localeTitle:  Iterar através das chaves de um objeto com um para ... em declaração
+---
+## Iterar através das chaves de um objeto com um para ... em declaração
+
+Método:
+
+*   Nota: `dot-notation` causará erros neste desafio.
+*   `[square-bracket]` notação `[square-bracket]` deve ser usada para chamar um nome de propriedade variável.
+*   O código a seguir não funcionará.
+
+### Exemplo 1:
+
+```javascript
+for (let user in obj) { 
+    if(obj.user.online === true) { 
+      //code 
+    } 
+  } 
+```
+
+*   O exemplo 2 demonstra como usar a notação `[square-bracket]` o código será executado.
+
+### Exemplo 2:
+
+```javascript
+for (let user in obj) { 
+    if(obj[user]online === true) { 
+      //code 
+    } 
+  } 
+```
+
+### Solução:
+
+```javascript
+let users = { 
+  Alan: { 
+    age: 27, 
+    online: false 
+  }, 
+  Jeff: { 
+    age: 32, 
+    online: true 
+  }, 
+  Sarah: { 
+    age: 48, 
+    online: false 
+  }, 
+  Ryan: { 
+    age: 19, 
+    online: true 
+  } 
+ }; 
+ function countOnline(obj) { 
+  // change code below this line 
+  let result = 0; 
+  for (let user in obj) { 
+    if(obj[user].online === true) { 
+      result++; 
+    } 
+  } 
+  return result; 
+  // change code above this line 
+ } 
+ console.log(countOnline(users)); 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-data-structures/access-an-arrays-contents-using-bracket-notation/index.md

@@ -0,0 +1,14 @@
+---
+title: Access an Array's Contents Using Bracket Notation
+localeTitle: Acessar o conteúdo de uma matriz usando a notação de suporte
+---
+## Acessar o conteúdo de uma matriz usando a notação de suporte
+
+*   Lembre-se de que o índice de arrays começa em 0, então a posição de b estará localizada em `myArray[1]` .
+
+## Solução
+
+```javascript
+myArray[1] = "anything we want"; 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-data-structures/access-property-names-with-bracket-notation/index.md

@@ -0,0 +1,45 @@
+---
+title: Access Property Names with Bracket Notation
+localeTitle: Acessar nomes de propriedades com notação de suporte
+---
+## Acessar nomes de propriedades com notação de suporte
+
+Método:
+
+*   Usando a notação de colchetes, simplesmente escreva a declaração de retorno na função `checkInventory()` .
+*   O bloco de código a seguir demonstra a sintaxe necessária.
+
+## Exemplo:
+
+```javascript
+let juice = { 
+  apple: 1.15, 
+  orange: 1.45 
+ }; 
+ function checkInventory(scannedItem) { 
+  return juice[scannedItem]; 
+ } 
+```
+
+## Solução:
+
+```javascript
+let foods = { 
+  apples: 25, 
+  oranges: 32, 
+  plums: 28, 
+  bananas: 13, 
+  grapes: 35, 
+  strawberries: 27 
+ }; 
+ // do not change code above this line 
+ 
+ function checkInventory(scannedItem) { 
+  // change code below this line 
+  return foods[scannedItem]; 
+ } 
+ 
+ // change code below this line to test different cases: 
+ console.log(checkInventory("apples")); 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-data-structures/add-items-to-an-array-with-push-and-unshift/index.md

@@ -0,0 +1,23 @@
+---
+title: Add Items to an Array with push() and unshift()
+localeTitle: Adicionar itens a uma matriz com push () e unshift ()
+---
+## Adicionar itens a uma matriz com push () e unshift ()
+
+*   Assim como o exemplo dado, use o método `.unshift()` na matriz para adicionar elementos ao início da matriz e use o método `.push()` para adicionar elementos ao final da matriz.
+
+## Solução:
+
+```javascript
+function mixedNumbers(arr) { 
+  // change code below this line 
+ arr.unshift('I',2,'three'); 
+ arr.push(7,'VIII', 9); 
+  // change code above this line 
+  return arr; 
+ } 
+ 
+ // do not change code below this line 
+ console.log(mixedNumbers(['IV', 5, 'six'])); 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-data-structures/add-items-using-splice/index.md

@@ -0,0 +1,35 @@
+---
+title: Add Items Using splice()
+localeTitle: Adicionar itens usando splice ()
+---
+## Adicionar itens usando splice ()
+
+*   Usando a função splice (), você deve remover os 2 primeiros elementos de matriz `arr` e substituí-los com `DarkSalmon` e `BlanchedAlmond` .
+*   Lembre-se de que a função de emenda pode levar até três parâmetros.
+
+## Exemplo:
+
+```javascript
+arr.splice(0, 1, "Two"); 
+ /*  The first two paramemters are the same as they were in the previous challenge. 
+    `0` will start the `splice()` function off at index 0. 
+    The second parameter `1` will remove only 1 variable from the array. 
+    The final variable "Two" will replace the variable in arr[0]. 
+    Note: The final parameter can take more than 1 arguement. 
+ */ 
+```
+
+## Solução:
+
+```javascript
+function htmlColorNames(arr) { 
+  // change code below this line 
+  arr.splice(0, 2, "DarkSalmon", "BlanchedAlmond"); 
+  // change code above this line 
+  return arr; 
+ } 
+ 
+ // do not change code below this line 
+ console.log(htmlColorNames(['DarkGoldenRod', 'WhiteSmoke', 'LavenderBlush', 'PaleTurqoise', 'FireBrick'])); 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-data-structures/add-key-value-pairs-to-javascript-objects/index.md

@@ -0,0 +1,30 @@
+---
+title: Add Key-Value Pairs to JavaScript Objects
+localeTitle: Adicionar pares de valor-chave a objetos JavaScript
+---
+## Adicionar pares de valor-chave a objetos JavaScript
+
+*   O objeto de alimentos já foi declarado. Tudo o que resta a fazer é adicionar três novos `key-values` .
+
+```javascript
+OBJECT[{KEY}] = {VALUE} 
+```
+
+*   O código acima criará um `key-value` ney dentro do objeto.
+
+## Solução
+
+```javascript
+let foods = { 
+  apples: 25, 
+  oranges: 32, 
+  plums: 28 
+ }; 
+ // change code below this line 
+ foods['bananas'] = 13; 
+ foods['grapes'] = 35; 
+ foods['strawberries'] = 27; 
+ // change code above this line 
+ console.log(foods); 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-data-structures/check-for-the-presence-of-an-element-with-indexof/index.md

@@ -0,0 +1,33 @@
+---
+title: Check For The Presence of an Element With indexOf()
+localeTitle: Verificar a presença de um elemento com indexOf ()
+---
+## Verificar a presença de um elemento com indexOf ()
+
+*   Uma `if-statement` simples pode ser usada para verificar se o valor retornado pela função `indexOf()` é menor que 0.
+*   Quando o valor for descoberto, você poderá retornar `true` ou `false` .
+*   `Solution-1` demonstra como uma `if-statement` simples pode retornar o resultado correto.
+
+## Solução 1:
+
+```javascript
+function quickCheck(arr, elem) { 
+  if(arr.indexOf(elem)>=0) { 
+    return true; 
+  } 
+  return false; 
+ } 
+ console.log(quickCheck(['squash', 'onions', 'shallots'], 'mushrooms')); 
+```
+
+*   `Solution-2` demonstra como o problema pode ser resolvido usando o `? : (conditional)` operador.
+
+## Solução 2:
+
+```javascript
+function quickCheck(arr, elem) { 
+ return arr.indexOf(elem) >= 0 ? true : false; 
+ } 
+ console.log(quickCheck(['squash', 'onions', 'shallots'], 'mushrooms')); 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-data-structures/check-if-an-object-has-a-property/index.md

@@ -0,0 +1,55 @@
+---
+title: Check if an Object has a Property
+localeTitle: Verificar se um objeto tem uma propriedade
+---
+## Verificar se um objeto tem uma propriedade
+
+Método:
+
+*   A maneira mais simples de completar esse desafio é criar uma `ìf-statement` para verificar se o objeto contém todos os usuários e, em seguida, retornar uma declaração verdadeira ou falsa. A primeira solução faz exatamente isso.
+*   A segunda solução funciona exatamente da mesma maneira, apenas usa 1 linha de código - `Conditional(ternary)-Operator` - `Conditional(ternary)-Operator` - dentro da função.
+
+[O developer.mozilla.org](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Conditional_Operator) fornece uma análise mais aprofundada do operador ternário.
+
+### Solução 1:
+
+```javascript
+let users = { 
+  Alan: { 
+    age: 27, 
+    online: true 
+  }, 
+  Jeff: { 
+    age: 32, 
+    online: true 
+  }, 
+  Sarah: { 
+    age: 48, 
+    online: true 
+  }, 
+  Ryan: { 
+    age: 19, 
+    online: true 
+  } 
+ }; 
+ 
+ function isEveryoneHere(obj) { 
+  // change code below this line 
+  if(users.hasOwnProperty('Alan','Jeff','Sarah','Ryan')) { 
+    return true; 
+  } 
+  return false; 
+  // change code above this line 
+ } 
+ 
+ console.log(isEveryoneHere(users)); 
+```
+
+### Solução 2:
+
+```javascript
+function isEveryoneHere(obj) { 
+  return (users.hasOwnProperty('Alan','Jeff','Sarah','Ryan')) ? true : false; 
+ } 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-data-structures/combine-arrays-with-the-spread-operator/index.md

@@ -0,0 +1,21 @@
+---
+title: Combine Arrays with the Spread Operator
+localeTitle: Combine Arrays com o Operador de Spread
+---
+## Combine Arrays com o Operador de Spread
+
+*   A solução é exatamente igual ao exemplo dado. Simplesmente insira a matriz `fragment[]` na matriz `sentence[]` no índice desejado.
+
+## Solução:
+
+```javascript
+function spreadOut() { 
+  let fragment = ['to', 'code']; 
+  let sentence = ["learning", ...fragment, "is", "fun"]; // change this line 
+  return sentence; 
+ } 
+ 
+ // do not change code below this line 
+ console.log(spreadOut()); 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-data-structures/copy-an-array-with-the-spread-operator/index.md

@@ -0,0 +1,20 @@
+---
+title: Copy an Array with the Spread Operator
+localeTitle: Copiar uma matriz com o operador de propagação
+---
+## Copiar uma matriz com o operador de propagação
+
+*   A dica final no exemplo diz para você usar um método recentemente aprendido.
+*   O operador de spread copia todos os elementos em um novo objeto vazio.
+
+\`\` \`javascript while (num> = 1) { newArr = \[… arr\] num--; }
+```
+- The code above will copy all of the elements into `newArr` but will also reinitialise `newArr` with every new iteration of the while loop. 
+ - A new variable should first be initialised using the spread operator - `let obj = [...arr];` - then this variable should be added to the `newArr` for every iteration of the while loop. 
+ 
+ ## Solution: 
+```
+
+javascript função copyMachine (arr, num) { deixe newArr = \[\]; while (num> = 1) { // muda o código abaixo desta linha newArr.push (\[… arr\]); // muda o código acima desta linha num--; } return newArr; }
+
+// altere o código aqui para testar casos diferentes: console.log (copyMachine (\[verdadeiro, falso, verdadeiro\], 2)); \`\` \`

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-data-structures/copy-array-items-using-slice/index.md

@@ -0,0 +1,30 @@
+---
+title: Copy Array Items Using slice()
+localeTitle: Copiar itens de matriz usando slice ()
+---
+## Copiar itens de matriz usando slice ()
+
+*   a função `slice()` deve ser usada para retornar um array que consiste em apenas `warm` e `sunny` .
+*   Portanto, dois parâmetros devem ser passados ​​para a função `slice()` . O primeiro parâmetro deve ser o índice para o qual você deseja que a substring comece. O segundo parâmetro deve ser o índice no qual a substring termina.
+*   Nota: O segundo parâmetro terminará a substring nesse índice exato.
+
+## Exemplo:
+
+```javascript
+ return arr.slice(1,4); 
+ /* This will return a substring consisting of indexs [1,2,3] 
+    Note: arr[4] is NOT included. 
+```
+
+## Solução:
+
+```javascript
+function forecast(arr) { 
+  // change code below this line 
+  return arr.slice(2,4); 
+ } 
+ 
+ // do not change code below this line 
+ console.log(forecast(['cold', 'rainy', 'warm', 'sunny', 'cool', 'thunderstorms'])); 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-data-structures/create-complex-multi-dimensional-arrays/index.md

@@ -0,0 +1,28 @@
+---
+title: Create complex multi-dimensional arrays
+localeTitle: Crie matrizes multidimensionais complexas
+---
+## Crie matrizes multidimensionais complexas
+
+*   A primeira corda - `deep` - deve ser inserida em três níveis de profundidade. Isso significa dentro de exatamente três conjuntos de `[square-brackets]` .
+
+```javascript
+let threeLevelArray = ["first level", ["Two levels deep", ["Three levels deep"]]]; 
+```
+
+*   Usando esta lógica inserir strings `deep` , `deeper` e `deepest` na matriz de três níveis de profundidade, quatro níveis de profundidade e cinco níveis de profundidade, respectivamente.
+
+## Solução:
+
+```javascript
+let myNestedArray = [ 
+  // change code below this line 
+  ['unshift', false, 1, 2, 3, 'complex', 'nested'], 
+  ['loop', 'shift', 6, 7, 1000, 'method'], 
+  ['concat', false, true, 'spread', 'array',["deep"]], 
+  ['mutate', 1327.98, 'splice', 'slice', 'push', [["deeper"]]], 
+  ['iterate', 1.3849, 7, '8.4876', 'arbitrary', 'depth', [[["deepest"]]] ] 
+  // change code above this line 
+ ]; 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-data-structures/generate-an-array-of-all-object-keys-with-object.keys/index.md

@@ -0,0 +1,42 @@
+---
+title: Generate an Array of All Object Keys with Object.keys()
+localeTitle: Gerar uma matriz de todas as chaves de objeto com Object.keys ()
+---
+## Gerar uma matriz de todas as chaves de objeto com Object.keys ()
+
+### Método:
+
+*   Para retornar a matriz de usuários, o método `Object.keys()` deve ter um argumento.
+*   Esse desafio pode ser resolvido usando uma instrução de retorno de linha única.
+
+### Solução:
+
+```javascript
+let users = { 
+  Alan: { 
+    age: 27, 
+    online: false 
+  }, 
+  Jeff: { 
+    age: 32, 
+    online: true 
+  }, 
+  Sarah: { 
+    age: 48, 
+    online: false 
+  }, 
+  Ryan: { 
+    age: 19, 
+    online: true 
+  } 
+ }; 
+ 
+ function getArrayOfUsers(obj) { 
+  // change code below this line 
+  return Object.keys(obj); 
+  // change code above this line 
+ } 
+ 
+ console.log(getArrayOfUsers(users)); 
+
+```

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

@@ -0,0 +1,11 @@
+---
+title: Basic Data Structures
+localeTitle: Estruturas de Dados Básicas
+---
+## Estruturas de Dados Básicas
+
+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-data-structures/iterate-through-all-an-arrays-items-using-for-loops/index.md

@@ -0,0 +1,54 @@
+---
+title: Iterate Through All an Array's Items Using For Loops
+localeTitle: Iterar Através de Todos os Itens de uma Matriz Usando For Loops
+---
+## Iterar Através de Todos os Itens de uma Matriz Usando For Loops
+
+## Sugestão 1
+
+*   A nested `for` loop deve ser usado para pesquisar através de cada elemento na matriz.
+
+```javascript
+ for (let i = 0; i < arr.length; i++) { 
+```
+
+\`
+
+## Sugestão 2
+
+*   Todos os elementos da matriz devem ser comparados ao parâmetro `elem` passado pela função `filteredArray()` .
+
+```javascript
+if (arr[i].indexOf(elem)==-1){ 
+```
+
+## Dica 3
+
+*   Se uma correspondência não for encontrada, então `newArr` terá todo o subarray adicionado. A função `push()` é muito útil aqui.
+
+```javascript
+newArr.push(arr[i]); 
+```
+
+*   Uma vez que todo o subarray é adicionado ao `newArr` o loop continua com o próximo elemento.
+
+## Solução:
+
+```javascript
+function filteredArray(arr, elem) { 
+  let newArr = []; 
+  // change code below this line 
+ 
+ for (let i = 0; i < arr.length; i++) { 
+    if (arr[i].indexOf(elem)==-1){ //Checks every parameter for the element and if is NOT there continues the code 
+          newArr.push(arr[i]); //Inserts the element of the array in the new filtered array 
+            }; 
+          }; 
+ 
+  // change code above this line 
+  return newArr; 
+ }; 
+ // change code here to test different cases: 
+ console.log(filteredArray([[3, 2, 3], [1, 6, 3], [3, 13, 26], [19, 3, 9]], 3)); 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-data-structures/modify-an-array-stored-in-an-object/index.md

@@ -0,0 +1,45 @@
+---
+title: Modify an Array Stored in an Object
+localeTitle: Modificar uma matriz armazenada em um objeto
+---
+## Modificar uma matriz armazenada em um objeto
+
+### Método:
+
+*   A função pode ser escrita em apenas duas linhas de código.
+*   A primeira linha deve usar apenas a função `push()` para adicionar o parâmetro `friend` à matriz encontrada em `user.data.friend` . A segunda linha retornará a matriz modificada.
+*   Lembre-se que o `user` deve ser referenciado com o primeiro parâmetro dado à função `addFriend()` .
+
+### Solução:
+
+```javascript
+let user = { 
+  name: 'Kenneth', 
+  age: 28, 
+  data: { 
+    username: 'kennethCodesAllDay', 
+    joinDate: 'March 26, 2016', 
+    organization: 'freeCodeCamp', 
+    friends: [ 
+      'Sam', 
+      'Kira', 
+      'Tomo' 
+    ], 
+    location: { 
+      city: 'San Francisco', 
+      state: 'CA', 
+      country: 'USA' 
+    } 
+  } 
+ }; 
+ 
+ function addFriend(userObj, friend) { 
+  // change code below this line 
+  userObj.data.friends.push(friend); 
+  return userObj.data.friends; 
+  // change code above this line 
+ } 
+ 
+ console.log(addFriend(user, 'Pete')); 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-data-structures/modify-an-object-nested-within-an-object/index.md

@@ -0,0 +1,46 @@
+---
+title: Modify an Object Nested Within an Object
+localeTitle: Modificar um objeto aninhado em um objeto
+---
+## Modificar um objeto aninhado em um objeto
+
+Método:
+
+*   Lembre-se de que o objeto que você deseja alterar tem dois níveis de profundidade; `dot-notation` é mais fácil de usar nesta instância.
+*   Simplesmente defina o objeto e, em seguida, use `dot-notation` para acessar o segundo objeto e, finalmente, o elemento final que você deseja modificar.
+
+## Exemplo:
+
+```javascript
+let myObject = { 
+  level_1: 'outside', 
+  first_level_object: { 
+    level_2: '2 levels deep', 
+    second_level_object: { 
+      level_3: '3 levels deep' 
+      } 
+   } 
+ }; 
+ //The following line of code will modify the data found in level_2. 
+ myObject.first_level_object.level_2 = 'level-2 has been reached'; 
+```
+
+## Solução:
+
+```javascript
+let userActivity = { 
+  id: 23894201352, 
+  date: 'January 1, 2017', 
+  data: { 
+    totalUsers: 51, 
+    online: 42 
+  } 
+ }; 
+ 
+ // change code below this line 
+ userActivity.data.online = 45; 
+ // change code above this line 
+ 
+ console.log(userActivity); 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-data-structures/remove-items-from-an-array-with-pop-and-shift/index.md

@@ -0,0 +1,21 @@
+---
+title: Remove Items from an Array with pop() and shift()
+localeTitle: Remover itens de uma matriz com pop () e shift ()
+---
+## Remover itens de uma matriz com pop () e shift ()
+
+*   O método `.pop()` e o método `.shift()` devem ser chamados e inicializados usando as variáveis `popped` e `shifted` para retornar a resposta correta da função.
+
+## Solução:
+
+```javascript
+function popShift(arr) { 
+  let popped = arr.pop(); 
+  let shifted = arr.shift(); 
+  return [shifted, popped]; 
+ } 
+ 
+ // do not change code below this line 
+ console.log(popShift(['challenge', 'is', 'not', 'complete'])); 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-data-structures/remove-items-using-splice/index.md

@@ -0,0 +1,23 @@
+---
+title: Remove Items Using splice()
+localeTitle: Remover itens usando splice ()
+---
+## Remover itens usando splice ()
+
+*   A função `splice()` deve ser chamada na matriz `arr` para remover 1 ou mais elementos do centro da matriz.
+*   A matriz `arr` atualmente acrescenta-se ao valor de 16. Basta remover tantas variáveis neccessary para retornar 10.
+
+## Solução:
+
+```javascript
+function sumOfTen(arr) { 
+  // change code below this line 
+  arr.splice(1,2); 
+  // change code above this line 
+  return arr.reduce((a, b) => a + b); 
+ } 
+ 
+ // do not change code below this line 
+ console.log(sumOfTen([2, 5, 1, 5, 2, 1])); 
+
+```

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-data-structures/use-an-array-to-store-a-collection-of-data/index.md

@@ -0,0 +1,28 @@
+---
+title: Use an Array to Store a Collection of Data
+localeTitle: Use uma matriz para armazenar uma coleção de dados
+---
+## Use uma matriz para armazenar uma coleção de dados
+
+### Método:
+
+*   No JS, os Arrays são uma das estruturas de dados mais usadas. Diferentemente de outras linguagens As matrizes no JS podem armazenar diferentes tipos de dados e também podem alterar seu tamanho em tempo de execução e, portanto, também são chamadas de "Dynamic Arrays". Eles também são 0 indexados.
+*   Os arrays podem ser inicializados de diferentes maneiras:
+
+1.  Literais de matriz
+2.  Construtores de matriz
+
+*   Neste desafio, vamos nos concentrar em literais de matriz. Para inicializar uma matriz, simplesmente `let arr = [];`
+*   Podemos adicionar valores a este array acessando seu índice, exemplo: `javascript let arr = []; arr[0] = "hello"; console.log(arr); // ["hello"]`
+*   Podemos também inicializar os valores no array quando o declaramos, exemplo: `javascript let arr = [1, 2, 3, "John"];`
+*   Neste desafio você precisa criar um array com pelo menos 5 elementos e pelo menos uma string, um número e um booleano.
+
+### Solução:
+
+```js
+ let yourArray = ["a", 2, true, "c", null, {name: "john"}]; 
+```
+
+### Recursos
+
+Mais leituras sobre matrizes no [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array) .

guide/portuguese/certifications/javascript-algorithms-and-data-structures/basic-data-structures/use-the-delete-keyword-to-remove-object-properties/index.md

@@ -0,0 +1,27 @@
+---
+title: Use the delete Keyword to Remove Object Properties
+localeTitle: Use a palavra-chave delete para remover propriedades do objeto
+---
+## Use a palavra-chave delete para remover propriedades do objeto
+
+[O Developer.mozilla.org](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/delete) fornece um tutorial abrangente sobre o operador delete.
+
+### Solução:
+
+```javascript
+let foods = { 
+  apples: 25, 
+  oranges: 32, 
+  plums: 28, 
+  bananas: 13, 
+  grapes: 35, 
+  strawberries: 27 
+ }; 
+ // change code below this line 
+ delete foods.oranges; 
+ delete foods.plums; 
+ delete foods.strawberries; 
+ // change code above this line 
+ console.log(foods); 
+
+```