fix(guide): simplify directory structure

guide/spanish/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 a través de las claves de un objeto con una for ... in Statement
+---
+## Iterar a través de las claves de un objeto con una for ... in Statement
+
+Método:
+
+*   Nota: `dot-notation` causará errores en este desafío.
+*   `[square-bracket]` debe usar la notación `[square-bracket]` para llamar a un nombre de propiedad variable.
+*   El siguiente código no funcionará.
+
+### Ejemplo 1:
+
+```javascript
+for (let user in obj) { 
+    if(obj.user.online === true) { 
+      //code 
+    } 
+  } 
+```
+
+*   El ejemplo 2 demuestra cómo usar la notación `[square-bracket]` se ejecutará el código.
+
+### Ejemplo 2:
+
+```javascript
+for (let user in obj) { 
+    if(obj[user]online === true) { 
+      //code 
+    } 
+  } 
+```
+
+### Solución:
+
+```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/spanish/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: Acceder a los contenidos de una matriz usando notación de corchete
+---
+## Acceder a los contenidos de una matriz usando notación de corchete
+
+*   Recuerde que el índice de matrices comienza en 0, por lo que la posición de b se ubicará en `myArray[1]` .
+
+## Solución
+
+```javascript
+myArray[1] = "anything we want"; 
+
+```

guide/spanish/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: Acceso a nombres de propiedades con notación de corchete
+---
+## Acceso a nombres de propiedades con notación de corchete
+
+Método:
+
+*   Usando la notación de corchetes, simplemente escriba la declaración de retorno en la función `checkInventory()` .
+*   El siguiente bloque de código muestra la sintaxis requerida.
+
+## Ejemplo:
+
+```javascript
+let juice = { 
+  apple: 1.15, 
+  orange: 1.45 
+ }; 
+ function checkInventory(scannedItem) { 
+  return juice[scannedItem]; 
+ } 
+```
+
+## Solución:
+
+```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/spanish/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: Agregar elementos a una matriz con push () y unshift ()
+---
+## Agregar elementos a una matriz con push () y unshift ()
+
+*   Al igual que en el ejemplo dado, use el método `.unshift()` en la matriz para agregar elementos al inicio de la matriz y use el método `.push()` para agregar elementos al final de la matriz.
+
+## Solución:
+
+```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/spanish/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: Agregar artículos usando splice ()
+---
+## Agregar artículos usando splice ()
+
+*   Uso de la función de empalme (), debe quitar los 2 primeros elementos de matriz `arr` y reemplazarlos con `DarkSalmon` y `BlanchedAlmond` .
+*   Recuerde que la función de empalme puede tomar hasta tres parámetros.
+
+## Ejemplo:
+
+```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. 
+ */ 
+```
+
+## Solución:
+
+```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/spanish/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: Agregue pares de valor-clave a los objetos de JavaScript
+---
+## Agregue pares de valor-clave a los objetos de JavaScript
+
+*   El objeto alimentos ya ha sido declarado. Todo lo que queda por hacer es agregar tres nuevos `key-values` .
+
+```javascript
+OBJECT[{KEY}] = {VALUE} 
+```
+
+*   El código anterior creará un nuevo `key-value` dentro del objeto.
+
+## Solución
+
+```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/spanish/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: Comprobar la presencia de un elemento con indexOf ()
+---
+## Comprobar la presencia de un elemento con indexOf ()
+
+*   Se puede usar una `if-statement` simple para verificar si el valor devuelto por la función `indexOf()` es menor que 0.
+*   Una vez que se descubre el valor, puede devolver `true` o `false` .
+*   `Solution-1` demuestra cómo una simple `if-statement` puede devolver el resultado correcto.
+
+## Solución-1:
+
+```javascript
+function quickCheck(arr, elem) { 
+  if(arr.indexOf(elem)>=0) { 
+    return true; 
+  } 
+  return false; 
+ } 
+ console.log(quickCheck(['squash', 'onions', 'shallots'], 'mushrooms')); 
+```
+
+*   `Solution-2` demuestra cómo se puede resolver el problema usando `? : (conditional)` operador `? : (conditional)` .
+
+## Solución-2:
+
+```javascript
+function quickCheck(arr, elem) { 
+ return arr.indexOf(elem) >= 0 ? true : false; 
+ } 
+ console.log(quickCheck(['squash', 'onions', 'shallots'], 'mushrooms')); 
+
+```

guide/spanish/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: Compruebe si un objeto tiene una propiedad
+---
+## Compruebe si un objeto tiene una propiedad
+
+Método:
+
+*   La forma más sencilla de completar este desafío es crear una `ìf-statement` para verificar si el objeto contiene todos los usuarios, y luego devolver una declaración verdadera o falsa. La primera solución hace justamente esto.
+*   La segunda solución funciona exactamente de la misma manera, solo que utiliza 1 línea de código - `Conditional(ternary)-Operator` - dentro de la función.
+
+[developer.mozilla.org](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Conditional_Operator) proporciona un análisis más profundo del operador ternario.
+
+### Solución-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)); 
+```
+
+### Solución-2:
+
+```javascript
+function isEveryoneHere(obj) { 
+  return (users.hasOwnProperty('Alan','Jeff','Sarah','Ryan')) ? true : false; 
+ } 
+
+```

guide/spanish/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: Combina matrices con el operador de propagación
+---
+## Combina matrices con el operador de propagación
+
+*   La solución es exactamente igual al ejemplo dado. Simplemente inserte la matriz del `fragment[]` en la matriz de la `sentence[]` en el índice deseado.
+
+## Solución:
+
+```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/spanish/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 una matriz con el operador de propagación
+---
+## Copiar una matriz con el operador de propagación
+
+*   La sugerencia final del ejemplo le indica que use un método aprendido recientemente.
+*   El operador de propagación copia todos los elementos en un nuevo objeto vacío.
+
+\`\` \`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 función copyMachine (arr, num) { deja newArr = \[\]; while (num> = 1) { // cambiar código debajo de esta línea newArr.push (\[… arr\]); // cambiar código por encima de esta línea num--; } devuelve newArr; }
+
+// cambia el código aquí para probar diferentes casos: console.log (copyMachine (\[true, false, true\], 2)); \`\` \`

guide/spanish/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 elementos de matriz utilizando slice ()
+---
+## Copiar elementos de matriz utilizando slice ()
+
+*   la función `slice()` debe usar para devolver una matriz que consiste solo en `warm` y `sunny` .
+*   Por lo tanto, se deben pasar dos parámetros a la función `slice()` . El primer parámetro debe ser el índice en el que desea que comience la subcadena. El segundo parámetro debe ser el índice en el que finaliza la subcadena.
+*   Nota: el segundo parámetro finalizará la subcadena en ese índice exacto.
+
+## Ejemplo:
+
+```javascript
+ return arr.slice(1,4); 
+ /* This will return a substring consisting of indexs [1,2,3] 
+    Note: arr[4] is NOT included. 
+```
+
+## Solución:
+
+```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/spanish/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: Crear complejos arreglos multidimensionales.
+---
+## Crear complejos arreglos multidimensionales.
+
+*   La primera cuerda - `deep` - debe insertarse a tres niveles de profundidad. Esto significa dentro de exactamente tres conjuntos de `[square-brackets]` .
+
+```javascript
+let threeLevelArray = ["first level", ["Two levels deep", ["Three levels deep"]]]; 
+```
+
+*   Usando esta lógica, inserte cadenas más `deep` , `deeper` y `deepest` en la matriz tres niveles de profundidad, cuatro niveles de profundidad y cinco niveles de profundidad respectivamente.
+
+## Solución:
+
+```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/spanish/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: Generar una matriz de todas las claves de objeto con Object.keys ()
+---
+## Generar una matriz de todas las claves de objeto con Object.keys ()
+
+### Método:
+
+*   Para devolver la matriz de usuarios, el método `Object.keys()` debe tomar un argumento.
+*   Este desafío se puede resolver utilizando una sola línea de declaración de retorno.
+
+### Solución:
+
+```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/spanish/certifications/javascript-algorithms-and-data-structures/basic-data-structures/index.md

@@ -0,0 +1,11 @@
+---
+title: Basic Data Structures
+localeTitle: Estructuras de datos básicos
+---
+## Estructuras de datos básicos
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/mathematics/quadratic-equations/index.md) .
+
+[Esta guía rápida de estilo ayudará a asegurar que su solicitud de extracción sea aceptada](https://github.com/freecodecamp/guides/blob/master/README.md) .
+
+#### Más información:

guide/spanish/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 a través de todos los elementos de una matriz utilizando bucles for
+---
+## Iterar a través de todos los elementos de una matriz utilizando bucles for
+
+## Sugerencia 1
+
+*   Se debe utilizar un bucle anidado `for` buscar a través de cada elemento de la matriz.
+
+```javascript
+ for (let i = 0; i < arr.length; i++) { 
+```
+
+\`
+
+## Sugerencia 2
+
+*   Cada elemento de la matriz debe compararse con el parámetro `elem` pasado a través de la función `filteredArray()` .
+
+```javascript
+if (arr[i].indexOf(elem)==-1){ 
+```
+
+## Sugerencia 3
+
+*   Si NO se encuentra una coincidencia, a `newArr` se le `newArr` todo el subarreglo. La función `push()` es muy útil aquí.
+
+```javascript
+newArr.push(arr[i]); 
+```
+
+*   Una vez que toda la subarray se agrega a `newArr` el bucle continúa con el siguiente elemento.
+
+## Solución:
+
+```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/spanish/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 una matriz almacenada en un objeto
+---
+## Modificar una matriz almacenada en un objeto
+
+### Método:
+
+*   La función se puede escribir en sólo dos líneas de código.
+*   La primera línea debería usar la función `push()` para agregar el parámetro `friend` a la matriz que se encuentra en `user.data.friend` . La segunda línea devolverá la matriz modificada.
+*   Recuerde que se debe hacer referencia al `user` con el primer parámetro dado a la función `addFriend()` .
+
+### Solución:
+
+```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/spanish/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 un objeto anidado dentro de un objeto
+---
+## Modificar un objeto anidado dentro de un objeto
+
+Método:
+
+*   Recuerde que el objeto que desea cambiar tiene dos niveles de profundidad, `dot-notation` es más fácil de usar en esta instancia.
+*   Simplemente defina el objeto y luego use `dot-notation` para acceder al segundo objeto y finalmente el elemento final que desea modificar.
+
+## Ejemplo:
+
+```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'; 
+```
+
+## Solución:
+
+```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/spanish/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: Eliminar elementos de una matriz con pop () y shift ()
+---
+## Eliminar elementos de una matriz con pop () y shift ()
+
+*   El `.pop()` método y `.shift()` método debe ser llamado y inicializado usando los `popped` y `shifted` variables para devolver la respuesta correcta de la función.
+
+## Solución:
+
+```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/spanish/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: Quitar elementos utilizando empalme ()
+---
+## Quitar elementos utilizando empalme ()
+
+*   Se debe llamar a la función `splice()` en la matriz `arr` para eliminar 1 o más elementos del centro de la matriz.
+*   La matriz `arr` actualmente suma el valor de 16. Simplemente elimine todas las variables necesarias para obtener 10.
+
+## Solución:
+
+```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/spanish/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: Utilice una matriz para almacenar una colección de datos
+---
+## Utilice una matriz para almacenar una colección de datos
+
+### Método:
+
+*   En JS, las matrices son una de las estructuras de datos más utilizadas. A diferencia de otros idiomas, las matrices en JS pueden almacenar diferentes tipos de datos y también pueden cambiar su tamaño en tiempo de ejecución y, por lo tanto, también se denominan "matrices dinámicas". También están 0 indexados.
+*   Las matrices se pueden inicializar de diferentes maneras:
+
+1.  Literales array
+2.  Constructores de matrices
+
+*   En este desafío nos centraremos en los literales de Array. Para inicializar una matriz simplemente `let arr = [];`
+*   Podemos agregar valores a esta matriz accediendo a su índice, ejemplo: `javascript let arr = []; arr[0] = "hello"; console.log(arr); // ["hello"]`
+*   También podemos inicializar los valores en el arreglo cuando lo declaremos, ejemplo: `javascript let arr = [1, 2, 3, "John"];`
+*   En este desafío, debe crear una matriz con al menos 5 elementos y al menos una cadena, un número y un booleano.
+
+### Solución:
+
+```js
+ let yourArray = ["a", 2, true, "c", null, {name: "john"}]; 
+```
+
+### Recursos
+
+Más información sobre matrices en [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array) .

guide/spanish/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: Utilice la palabra clave delete para eliminar las propiedades del objeto
+---
+## Utilice la palabra clave delete para eliminar las propiedades del objeto
+
+[Developer.mozilla.org](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/delete) proporciona un tutorial completo sobre el operador de eliminación.
+
+### Solución:
+
+```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); 
+
+```