fix(guide): simplify directory structure

guide/spanish/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: Acceso a datos de matriz con índices
+---
+## Acceso a datos de matriz con índices
+
+El primer elemento de una matriz está en la posición cero. Entonces, si desea acceder al primer elemento de una matriz, puede hacerlo así:
+
+```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 la longitud de la matriz es 4, y la posición del último elemento de la matriz es 3.

guide/spanish/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: Acceder a matrices multidimensionales con índices
+---
+## Acceder a matrices multidimensionales con índices
+
+Considere la siguiente matriz multidimensional:
+
+```javascript
+var arr = [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]; 
+```
+
+Esto es lo que parece en forma tabular.
+
+| Posición | 0 | 1 | 2 | 3 | | --- | --- | --- | --- | --- | | **0** | 1 | 4 | 7 | 10 | | **1** | 2 | 5 | 8 | 11 | | **2** | 3 | 6 | 9 | 12 |
+
+¡Ahora todo lo que tiene que hacer es elegir las coordenadas de los datos que desea! Por ejemplo, si queremos que `myNum` igual a 8, entonces ...
+
+```javascript
+var myNum = arr[2][1]; // Equal to 8 
+```
+
+O, si quieres que sea igual a 1. Lo haces ...
+
+```javascript
+var myNum = arr[0][0]; // Equal to 1 
+```
+
+Primero comienza seleccionando en qué columna está el número, luego eliges la fila. Es algo así como el plano de coordenadas xy!

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

@@ -0,0 +1,69 @@
+---
+title: Accessing Nested Arrays
+localeTitle: Acceso a matrices anidadas
+---
+## Acceso a matrices anidadas
+
+### Accediendo a elementos dentro de una matriz usando notación de corchete `[]`
+
+```js
+var fruitBasket = ['apple', 'banana' 'orange', 'melon']; 
+ var favoriteFruit = fruitBasket[2]; 
+ 
+ console.log(favoriteFruit) // 'orange' 
+```
+
+En este ejemplo, nuestra fruta favorita es 'naranja', que está en el índice `2` en la matriz `fruitBasket` . Usando la notación de braket, asignamos el índice `2` de la matriz `fruitBasket` a `favoriteFruit` . Esto hace que `favoriteFruit` sea ​​igual a 'naranja'.
+
+### Accediendo a objetos dentro de arreglos usando braket `[]` y dot `.` notación
+
+```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' 
+```
+
+## Solución:
+
+```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/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/accessing-nested-objects/index.md

@@ -0,0 +1,50 @@
+---
+title: Accessing Nested Objects
+localeTitle: Accediendo a objetos anidados
+---
+## Accediendo a objetos anidados
+
+Pista: **_"Use la notación de corchete para las propiedades con un espacio en su nombre"._**
+
+Si miramos nuestro objeto:
+
+```javascript
+var myStorage = { 
+  "car": { 
+    "inside": { 
+      "glove box": "maps", 
+      "passenger seat": "crumbs" 
+     }, 
+    "outside": { 
+      "trunk": "jack" 
+    } 
+  } 
+ }; 
+```
+
+Nuestro nombre de objeto es `myStorage` .
+
+| - Dentro de eso tenemos un objeto anidado llamado `car` .
+
+| --- Dentro de eso tenemos dos más llamados `inside` y `outside` cada uno con su propiedades propias
+
+Puedes visualizar la estructura del objeto de esta manera, si te ayuda:
+```
+myStorage 
+ |-- car 
+ |--- inside 
+ |----- glove box: maps 
+ |----- passenger seat: crumbs 
+ |--- outside 
+ |----- trunk: jack 
+```
+
+Se nos pide que asignemos los contenidos de la `glove box` , Lo que podemos ver está anidado en el objeto `inside` , que a su vez, está anidado en el objeto del `car` .
+
+Podemos usar la notación de puntos para acceder a la `glove box` siguiente manera:
+
+```javascript
+var gloveBoxContents = myStorage.car.inside'complete here' 
+```
+
+Debe reemplazar `complete here` con la forma correcta de acceder a la propiedad. Ver la pista de arriba si te quedas atascado.

guide/spanish/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: Acceso a las propiedades del objeto con notación de corchete
+---
+## Acceso a las propiedades del objeto con notación de corchete
+
+Aquí hay una posible solución:
+
+```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/spanish/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: Acceso a las propiedades del objeto con notación de puntos
+---
+## Acceso a las propiedades del objeto con notación de puntos
+
+Aquí hay una posible solución:
+
+```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/spanish/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: Accediendo a las propiedades del objeto con variables
+---
+## Accediendo a las propiedades del objeto con variables
+
+Aquí hay una solución de trabajo en caso de que esté atascado:
+
+```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/spanish/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: Agregar nuevas propiedades a un objeto de JavaScript
+---
+## Agregar nuevas propiedades a un objeto de JavaScript
+
+Aquí está el ejemplo:
+
+```js
+var ourDog = { 
+  "name": "Camper", 
+  "legs": 4, 
+  "tails": 1, 
+  "friends": ["everything!"] 
+ }; 
+ 
+ ourDog.bark = "bow-wow"; 
+```
+
+Aquí hay una solución:
+
+```js
+var myDog = { 
+  "name": "Happy Coder", 
+  "legs": 4, 
+  "tails": 1, 
+  "friends": ["freeCodeCamp Campers"] 
+ }; 
+ 
+ // Only change code below this line. 
+ myDog.bark = "woof"; 
+
+```

guide/spanish/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: Añadir dos números con JavaScript
+---
+# Añadir dos números con JavaScript
+
+JavaScript usa el símbolo `+` para la suma.
+```
+var sum = 10 + 10; //sum gets the value 20 
+
+```

guide/spanish/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: Adición de una opción predeterminada en los estados de cambio
+---
+# Adición de una opción predeterminada en los estados de cambio
+
+*   Al agregar una opción predeterminada, se asegura de que, en caso de que su variable no coincida con ninguna de las opciones, se use el valor predeterminado.
+
+## Solución:
+
+```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/spanish/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 Variables a las Cadenas
+---
+## Anexando Variables a las Cadenas
+
+Asegúrese de que su ortografía y el espaciado son correctos. Anexar cadenas (almacenadas dentro de variables) se puede hacer así:
+```
+var adj = "happy!"; 
+ var sent = "Today, I woke up being "; 
+ sent += adj; // The result is "Today, I woke up being happy!" 
+
+```

guide/spanish/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: Asignación con un valor devuelto
+---
+## Asignación con un valor devuelto
+
+Las funciones actúan como marcadores de posición para los datos que generan. Básicamente, puede asignar la salida de una función a una variable, al igual que cualquier dato normal.
+
+Aquí está la solución de código básico:
+
+```javascript
+processed = processArg(7); // Equal to 2 
+
+```

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

@@ -0,0 +1,19 @@
+---
+title: Build JavaScript Objects
+localeTitle: Construir objetos de JavaScript
+---
+# Construir objetos de JavaScript
+
+Los objetos son similares a las matrices, excepto que, en lugar de utilizar índices para acceder y modificar sus datos, puede acceder a los datos de los objetos a través de lo que se denomina propiedades.
+
+Aquí hay un objeto de muestra:
+```
+var cat = { 
+    "name": "Whiskers", 
+    "legs": 4, 
+    "tails": 1, 
+    "enemies": ["Water", "Dogs"] 
+ }; 
+```
+
+Los objetos son útiles para almacenar datos de forma estructurada y pueden representar objetos del mundo real, como los gatos.

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

@@ -0,0 +1,63 @@
+---
+title: Chaining If Else Statements
+localeTitle: Encadenamiento en caso contrario
+---
+## Encadenamiento en caso contrario
+
+*   `If` : el primer condicional en cada sentencia if / else, en caso de que el condicional sea _verdadero_ , ejecute el código e ignore el resto.
+*   `Else if` : nunca se puede utilizar como el primer condicional. Siempre es un condicional después de un `if` , en caso de que el condicional sea verdadero, ejecute el código. De lo contrario salta al siguiente condicional.
+*   `Else` : en caso de que todos los condicionales anteriores sean _falsos_ , de lo **contrario** se ejecuta.
+
+### Explicación del problema:
+
+_Escriba las instrucciones `if` / `else if` encadenadas para cumplir las siguientes condiciones_ :
+
+_`num < 5` - devuelve "Tiny" `num < 10` - devuelve "Small" `num < 15` - devuelve "Medio" `num < 20` - devuelve "Large" `num >= 20` - devuelve "Enorme"_
+
+#### Sugerencia 1
+
+Recuerde que puede combinar (encadenar) varias declaraciones `if...else` , una después de la otra, hasta que la última use `else if (condition) {do this}` .
+
+> _intenta resolver el problema ahora_
+> 
+> #### Sugerencia 2
+> 
+> A veces, cuando escribes más código del que estás acostumbrado y no funciona, las pequeñas cosas son las que nos traicionan. La comprobación de puntos y comas que faltan, corchetes, etc. puede resultar muy útil. _intenta resolver el problema ahora_
+
+## ¡Alerta de spoiler!
+
+**¡Solución por delante!**
+
+## Solución:
+
+```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 
+ } 
+```
+
+· Ejecutar código en [repl.it](https://repl.it/@AdrianSkar/Basic-JS-Chaining-ifelse-statements)
+
+### Explicación del código
+
+La función primero verifica la condición `if` `(num < 5)` . Si se evalúa como `true` , devuelve la instrucción entre las llaves ("Diminuto"). Si no lo hace, verifica la siguiente condición hasta la última declaración de lo `else` .
+
+### Recursos
+
+*   ["if ... else" - _referencia de JavaScript MDN_](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/if…else)

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

@@ -0,0 +1,22 @@
+---
+title: Comment Your JavaScript Code
+localeTitle: Comenta tu código JavaScript
+---
+## Comenta tu código JavaScript
+
+El comentar le permite escribir cosas que no desea que la computadora ejecute como código. Por ejemplo, notas a otros programadores, direcciones y más. Aquí es cómo crear un comentario de una sola línea.
+```
+// Hey, I'm a comment! 
+```
+
+Ahora, si quieres comentar un párrafo completo, eso se puede lograr fácilmente con ...
+```
+/* 
+  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/spanish/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: Comparación con el operador de igualdad
+---
+## Comparación con el operador de igualdad
+
+### Explicación del problema:
+
+_Agregue el operador de igualdad a la línea indicada para que la función devuelva "Igual" cuando `val` sea ​​equivalente a 12._
+
+#### Sugerencia 1
+
+Recuerde que la _igualdad es diferente de la asignación ( `=` ), que asigna el valor a la derecha del operador a una variable en la izquierda._ [1](#cite1)
+
+> _intenta resolver el problema ahora_
+
+## ¡Alerta de spoiler!
+
+**¡Solución por delante!**
+
+## Solución de código básico:
+
+```javascript
+function testEqual(val) { 
+  if (val == 12) { // Change this line 
+    return "Equal"; 
+  } 
+  return "Not equal"; 
+ } 
+ // Change this value to test 
+ testEqual(10); 
+```
+
+· [Ejecutar código en repl.it](https://repl.it/@AdrianSkar/Basic-JS-Equality-operator)
+
+### Explicación del código
+
+La función primero evalúa `if` la condición `(val == 12)` evalúa como `true` . Si lo hace, devuelve la instrucción entre las llaves ("Igual"). Si no lo hace, devuelve la siguiente declaración de `return` fuera de ellos ("No es igual").
+
+### Fuentes
+
+1 . ["JavaScript básico: comparación con el operador de igualdad", lección de la FCC en la _certificación de algoritmos y estructuras de datos de Javascript_](https://learn.freecodecamp.org/javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-equality-operator)
+
+### Recursos
+
+*   ["Operador de igualdad" - _referencia de JavaScript MDN_](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Equality_())

guide/spanish/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: Comparación con el operador mayor que
+---
+## Comparación con el operador mayor que
+
+`>` (Greater Than) es un operador lógico que devuelve el caso verdadero, el valor de la izquierda es más alto que el de la derecha.
+
+## Solucion basica
+
+```javascript
+function testGreaterThan(val) { 
+  if (val > 100) 
+    return "Over 100"; 
+ 
+  if (val > 10) 
+    return "Over 10"; 
+ 
+  return "10 or Under"; 
+ } 
+
+```

guide/spanish/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: Comparación con el operador mayor o igual que el operador
+---
+## Comparación con el operador mayor o igual que el operador
+
+*   `>=` (Mayor que o Igual a) es un operador lógico que devuelve el caso verdadero, el valor de la izquierda es el **mismo o superior** al de la derecha.
+
+## Solucion basica
+
+```javascript
+function testGreaterOrEqual(val) { 
+  if (val >= 20) 
+    return "20 or Over"; 
+ 
+  if (val >= 10) 
+    return "10 or Over"; 
+ 
+  return "Less than 10"; 
+ } 
+
+```

guide/spanish/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: Comparación con el operador de desigualdad
+---
+## Comparación con el operador de desigualdad
+
+*   `!=` (Desigualdad) es un operador lógico que devuelve el caso verdadero, el valor de la izquierda es diferente del de la derecha.
+*   El operador de desigualdad considera que `7` y `"7"` son iguales porque no compara el tipo de variable.
+
+## Solucion basica
+
+```javascript
+function testNotEqual(val) { 
+  if (val != 99) 
+    return "Not Equal"; 
+ 
+  return "Equal"; 
+ } 
+
+```

guide/spanish/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: Comparación con el operador menor que
+---
+## Comparación con el operador menor que
+
+**`<`** (Menos que) es un operador lógico que devuelve el caso verdadero, el valor de la izquierda es más bajo que el de la derecha.
+
+## Solucion basica
+
+```javascript
+function testLessThan(val) { 
+  if (val < 25) 
+    return "Under 25"; 
+ 
+  if (val < 55) 
+    return "Under 55"; 
+ 
+  return "55 or Over"; 
+ } 
+
+```

guide/spanish/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: Comparación con el operador menor o igual que
+---
+## Comparación con el operador menor o igual que
+
+**`<=`** (Menos que o igual a) es un operador lógico que devuelve el caso verdadero, el valor de la izquierda es el **mismo o inferior** al de la derecha.
+
+## Solucion basica
+
+```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/spanish/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: Comparación con el operador de igualdad estricta.
+---
+## Comparación con el operador de igualdad estricta.
+
+### Explicación del problema:
+
+· _Use el operador de igualdad estricta en la instrucción `if` para que la función devuelva "Igual" cuando `val` sea ​​estrictamente igual a `7` ._
+
+#### Sugerencia 1
+
+Recuerde, desde el último ejercicio, que la _igualdad es diferente de la asignación ( `=` ), que asigna el valor a la derecha del operador a una variable en la izquierda._ [1](#cite1)
+
+> _intenta resolver el problema ahora_
+> 
+> #### Sugerencia 2
+> 
+> _A diferencia del operador de igualdad, que intenta convertir ambos valores en comparación con un tipo común, el operador de igualdad estricta no realiza una conversión de tipo._ [2](#cite2) _intenta resolver el problema ahora_
+
+## ¡Alerta de spoiler!
+
+**¡Solución por delante!**
+
+## Solución de código básico:
+
+```javascript
+// Setup 
+ function testStrict(val) { 
+  if (val === 7) { // Change this line 
+    return "Equal"; 
+  } 
+  return "Not equal"; 
+ } 
+ 
+ // Change this value to test 
+ testStrict(10); 
+```
+
+### Explicación del código
+
+La función primero evalúa `if` la condición `(val === 7)` evalúa como `true` . Si lo hace, devuelve la instrucción entre las llaves ("Igual"). Si no lo hace, devuelve la siguiente declaración de `return` fuera de ellos ("No es igual").
+
+### Fuentes
+
+1 . ["JavaScript básico: comparación con el operador de igualdad", lección de la FCC en la _certificación de algoritmos y estructuras de datos de Javascript_](https://learn.freecodecamp.org/javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-equality-operator)
+
+2 . ["JavaScript Básico: Comparación con el Operador de Igualdad Estricta", lección de la FCC en _Algoritmos de Javascript y Certificación de Estructuras de Datos_](https://learn.freecodecamp.org/javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-strict-equality-operator)
+
+### Recursos
+
+*   ["if ... else" - _referencia de JavaScript MDN_](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/if…else)
+    
+*   [Kondov, Alexander. "Entendiendo JS: Coerción". _Hackernoon_](https://hackernoon.com/understanding-js-coercion-ff5684475bfc) , consultado el 15 de septiembre de 2018
+    
+*   ["Operadores de comparación" - _Referencia de JavaScript MDN_](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators)

guide/spanish/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: Comparación con el operador de desigualdad estricta
+---
+## Comparación con el operador de desigualdad estricta
+
+### Explicación del problema:
+
+· _Agregue el `strict inequality operator` a la instrucción `if` para que la función devuelva "No igual" cuando `val` no sea estrictamente igual a `17` ._
+
+#### Sugerencia 1
+
+El operador de desigualdad estricta ( `!==` ) devolverá `true` si el primer valor no es igual al segundo teniendo en cuenta el tipo de valor.
+
+> _intenta resolver el problema ahora_
+
+## ¡Alerta de spoiler!
+
+**¡Solución por delante!**
+
+## Solución de código básico:
+
+```javascript
+function testStrictNotEqual(val) { 
+  if (val !== 17) { 
+    return "Not equal"; 
+  } 
+  return "Equal"; 
+ } 
+ 
+ // Change this value to test 
+ testStrictNotEqual(10); 
+```
+
+### Explicación del código
+
+La función primero evalúa `if` la condición `(val !== 17)` evalúa como `true` considerando tanto el valor como el tipo de valor. Si lo hace, devuelve la instrucción entre las llaves ("No es igual"). Si no lo hace, devuelve la siguiente declaración de `return` fuera de ellos ("Igual").
+
+### Recursos
+
+*   ["No identidad / desigualdad estricta (! ==)" - _Referencia de JavaScript de MDN_](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Non-identity_strict_inequality_(!))

guide/spanish/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: Comparaciones con el operador && (AND lógico)
+---
+## Comparaciones con el operador && (AND lógico)
+
+### Explicación del problema:
+
+· _Combine las dos declaraciones if en una declaración que devolverá `"Yes"` si `val` es menor o igual a `50` y mayor o igual a `25` . De lo contrario, devolverá `"No"` ._
+
+#### Sugerencia 1
+
+El operador lógico AND ( `&&` ) compara ambas afirmaciones y devuelve `true` solo si ambos son verdaderos o se pueden convertir en verdaderos (truey).
+
+> _intenta resolver el problema ahora_
+
+#### Sugerencia 2
+
+Recuerde que este efecto puede también lograrse mediante la anidación `if` las declaraciones.
+
+> _intenta resolver el problema ahora_
+
+## ¡Alerta de spoiler!
+
+**¡Solución por delante!**
+
+## Solución de código básico:
+
+```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); 
+```
+
+· [Ejecutar código en repl.it](https://repl.it/@AdrianSkar/Basic-JS-Comparison-with-the-and-operator)
+
+### Explicación del código
+
+La función primero evalúa `if` la condición `val <= 50` evalúa como `true` conversión de `val` en un número si es necesario, luego hace lo mismo con `val >=25` debido al operador lógico AND ( `&&` ); Si ambos devuelven verdadero, se ejecuta la instrucción de `return "Yes"` .
+
+### Recursos
+
+*   ["Operadores lógicos" - _Referencia de JavaScript MDN_](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Logical_Operators)

guide/spanish/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: Comparaciones con el operador lógico o
+---
+## Comparaciones con el operador lógico o
+
+### Guía: Sigue el código dado en el ejemplo.
+
+**Alerta de spoiler**
+
+A continuación se muestra el código de ejemplo (la forma más sencilla).
+
+```javascript
+if ( val < 10 || val > 20 ) { 
+    return "Outside"; 
+ } 
+```
+
+El código anterior devolverá "Fuera" solo si `val` está entre 10 y 20 (inclusive).

guide/spanish/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: Asignación compuesta con adición aumentada
+---
+## Asignación compuesta con adición aumentada
+
+Las computadoras leen de izquierda a derecha. Entonces, usar el operador '+ =' significa que la variable se agrega con el número correcto, luego la variable se asigna a la suma. Al igual que:
+```
+var a = 9; 
+ a += 10; // Now, 'a' is equal to 19 
+
+```

guide/spanish/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: Asignación compuesta con división aumentada
+---
+## Asignación compuesta con división aumentada
+
+Las computadoras leen de izquierda a derecha. Entonces, usar el operador '/ =' significa que la variable se divide con el número a la derecha, luego la variable se asigna al cociente. Al igual que:
+```
+var d = 10; 
+ d /= 5; // Now, 'd' is equal to 2 
+
+```

guide/spanish/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: Asignación compuesta con multiplicación aumentada
+---
+## Asignación compuesta con multiplicación aumentada
+
+Las computadoras leen de izquierda a derecha. Por lo tanto, usar el operador de asignación de multiplicación significa que la variable se multiplica por el número a la derecha, luego la variable se asigna al producto. Al igual que:
+```
+var c = 2; 
+ c *= 3; // Now, 'c' is equal to 6 
+
+```

guide/spanish/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: Asignación compuesta con resta aumentada
+---
+## Asignación compuesta con resta aumentada
+
+Las computadoras leen de izquierda a derecha. Entonces, usar el operador '- =' significa que la variable se resta por el número a la derecha, luego la variable se asigna a la diferencia. Al igual que:
+```
+var b = 10; 
+ b -= 4; // Now, 'b' is 6 
+
+```

guide/spanish/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 cuerdas con el operador Plus
+---
+## Concatenando cuerdas con el operador Plus
+
+Concatenar significa enlazar juntos. Piense en el operador '+' como una cadena que une cadenas; agrega las cuerdas al igual que agregas números. ¡Asegúrate que tu ortografía esté correcta! Toma nota de los espacios entre las palabras.
+```
+var str = "Good " + "job!" // It says "Good job!" 
+ var abc = "Good" + "job!" // It says "Goodjob!" 
+
+```

guide/spanish/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 cadenas con el operador Plus Equals
+---
+## Concatenando cadenas con el operador Plus Equals
+
+El operador '+ =' puede concatenar (enlazar) cadenas fácilmente. Asegúrese de que su ortografía sea correcta y que haya dejado los espacios apropiados.
+```
+var str = "Hello "; 
+ str += "coding"; // Now the string reads "Hello coding" 
+ str += "camper!"; // And now the string reads "Hello codingcamper!" 
+
+```

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

@@ -0,0 +1,14 @@
+---
+title: Constructing Strings with Variables
+localeTitle: Construyendo cuerdas con variables
+---
+## Construyendo cuerdas con variables
+
+Agregue variables que almacenen cadenas, para crear cadenas más largas. Asegúrese de que su ortografía y el espacio sea correcto.
+```
+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/spanish/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: Contar hacia atrás con un bucle for
+---
+## Contar hacia atrás con un bucle for
+
+Aquí está el ejemplo:
+
+```javascript
+// Example 
+ var ourArray = []; 
+ 
+ for (var i = 10; i > 0; i -= 2) { 
+  ourArray.push(i); 
+ } 
+ 
+ // Setup 
+ var myArray = []; 
+ 
+ // Only change code below this line. 
+```
+
+#### SUGERENCIA: 1
+
+*   crear un nuevo for for loop para myArray
+
+#### SUGERENCIA: 2
+
+*   comienza desde el primer número impar justo antes del 9
+
+# ADVERTENCIA DE SPOILER: SOLUCIÓN A CONTINUACIÓN
+
+```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/spanish/certifications/javascript-algorithms-and-data-structures/basic-javascript/counting-cards/index.md

@@ -0,0 +1,134 @@
+---
+title: Counting Cards
+localeTitle: Tarjetas de conteo
+---
+![:triangular_flag_on_post:](https://forum.freecodecamp.com/images/emoji/emoji_one/triangular_flag_on_post.png?v=3 ": triangular_flag_on_post:") Recuerda usar **`Read-Search-Ask`** si te atascas. Tratar de emparejar el programa ![:busts_in_silhouette:](https://forum.freecodecamp.com/images/emoji/emoji_one/busts_in_silhouette.png?v=3 ": busts_in_silhouette:") y escribe tu propio código ![:pencil:](https://forum.freecodecamp.com/images/emoji/emoji_one/pencil.png?v=3 ":lápiz:")
+
+### ![:checkered_flag:](https://forum.freecodecamp.com/images/emoji/emoji_one/checkered_flag.png?v=3 ":bandera a cuadros:") Explicación del problema:
+
+En el juego de casino **Blackjack** , un jugador puede obtener una ventaja sobre la casa al hacer un seguimiento del número relativo de cartas altas y bajas que quedan en el mazo. Esto se llama conteo de cartas.
+
+Tener más cartas altas en el mazo favorece al jugador. A cada tarjeta se le asigna un valor de acuerdo con la siguiente tabla. Cuando el conteo es positivo, el jugador debe apostar alto. Cuando el conteo es cero o negativo, el jugador debe apostar bajo.
+
+Valor | Tarjetas  
+\----- | : -------------------:  
++1 | 2, 3, 4, 5, 6  
+0 | 7, 8, 9  
+\-1 | 10, 'J', 'Q', 'K', 'A'
+
+Escribirás una función de conteo de cartas. Recibirá un parámetro de **tarjeta** e incrementará o disminuirá la variable de **conteo** global de acuerdo con el valor de la tarjeta (consulte la tabla). La función devolverá una cadena con el recuento actual y la cadena `Bet` si el recuento es positivo, o `Hold` si el recuento es cero o negativo. El conteo actual y la decisión del jugador ( `Bet` o `Hold` ) deben estar separados por un solo espacio.
+
+*   Cambie el código a continuación `// Only change code below this line` y hasta `// Only change code above this line`
+*   Asegúrese de que está editando el interior de la función `cc` .
+*   Use lo que ha aprendido para verificar el valor de cada parámetro de **tarjeta** que se pasó a la función.
+*   Mantenga una cuenta corriente de ese número.
+*   Si el conteo final es 1 o mayor, devuelve **\# Mantener** .
+*   Si el conteo final es 0 o menos, devuelve **\# Bet** .
+
+**Ejemplo de salida:**
+
+*   \-3 espera
+*   5 Apuesta
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 1
+
+Use una instrucción de `switch` (o `else if` ) para contar el valor de cada tarjeta.
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 2
+
+Suma / resta el valor de cada carta a la **cuenta** variable. Si la tarjeta vale 0, no hagas nada.
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 3
+
+Una vez que haya contado las tarjetas, use una instrucción `if` para verificar el valor del **conteo** . Además, asegúrese de que su `return` tenga un espacio entre el número y la cadena.
+
+> _intenta resolver el problema ahora_
+
+## ¡Alerta de spoiler!
+
+![señal de advertencia](//discourse-user-assets.s3.amazonaws.com/original/2X/2/2d6c412a50797771301e7ceabd554cef4edcd74d.gif)
+
+**¡Solución por delante!**
+
+## ![:beginner:](https://forum.freecodecamp.com/images/emoji/emoji_one/beginner.png?v=3 ":principiante:") Solución de código básico:
+
+```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 
+    } 
+```
+
+### Explicación del código:
+
+*   Compruebe el valor de cada tarjeta a través de una declaración de `switch` .
+*   La **cuenta** variable:
+    *   Aumenta en 1 si la tarjeta es un 2, 3, 4, 5 o 6.
+    *   Como 7, 8 y 9 no valen nada, ignoramos esas tarjetas en nuestra declaración de `switch` .
+    *   Disminuye en 1 si la tarjeta es un 10, 'J', 'Q', 'K' o 'A'.
+*   Verifique el valor de **contar** y devuelva la respuesta apropiada.
+
+**Ejecución de ejemplo**
+
+*   `cc(2);` carreras.
+*   La instrucción de `switch` golpea el `case 2` , salta hacia abajo y agrega 1 a la `count` variable.
+*   La instrucción `switch` `break` y `cc(3);` carreras.
+*   Este ciclo continúa hasta que se realiza la llamada final, `cc('A');` .
+*   Después de la instrucción `switch` , la instrucción `if` cuenta `count` , que ahora es 0.
+*   Esto luego cae a la instrucción `else` , que devolverá **0 Hold** .
+
+**_Nota_** : Como se mencionó anteriormente, la instrucción `switch` también podría haber sido una instrucción `else if` .
+
+## Solución 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 
+ } 
+```
+
+· Ejecutar código en [repl.it.](https://repl.it/@AdrianSkar/Basic-JS-Counting-cards)
+
+### Explicación del código
+
+· La función primero evalúa `if` la `card` condición es un valor mayor que `1` y menor que `7` , en cuyo caso la `count` se incrementa en uno. · Luego, si la tarjeta es `10` o más, se reduce la `count` en uno. · La variable `regex` es una [expresión regular que](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp) representa valores (letras) para las tarjetas más altas. · La sentencia `else` comprueba esos valores con el `|| (logical OR)` operador `|| (logical OR)` ; primero para `10` y luego para cualquier cadena que coincida con la expresión regular usando [String.match ()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match) .
+
+#### Recursos
+
+*   [Recuento de cartas en Wikipedia](https://en.wikipedia.org/wiki/Card_counting)
+*   [Desafío: seleccionar entre muchas opciones con instrucciones de cambio](http://www.freecodecamp.com/challenges/selecting-from-many-options-with-switch-statements)
+*   [Desafío: Encadenar Si En Else Declaraciones](http://www.freecodecamp.com/challenges/chaining-if-else-statements)
+*   [Desafío: Incrementar un número con Javascript](http://www.freecodecamp.com/challenges/increment-a-number-with-javascript)

guide/spanish/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: Crea números decimales con JavaScript
+---
+# Crea números decimales con JavaScript
+
+Las variables de número de JavaScript pueden tener decimales.
+```
+var myDecimal = 2.8; 
+
+```

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

@@ -0,0 +1,28 @@
+---
+title: Declare JavaScript Variables
+localeTitle: Declarar las variables de JavaScript
+---
+# Declarar las variables de JavaScript
+
+Cuando almacenamos datos en una estructura de datos, lo llamamos una variable. Las variables de JavaScript están escritas en camel case. Un ejemplo de camel case es: `camelCase` .
+
+Puedes declarar una variable de esta manera
+
+```js
+    var myName = "Rafael"; 
+```
+
+ES6 introdujo otras dos formas de declarar variables. **let** y **const** . _Let_ es bastante similar a var y en su mayor parte es intercambiable:
+
+```js
+    let myAge = 36; 
+```
+
+Donde _dejar que_ se diferencia, es en su alcance. Cuando declaramos que utilizamos _var_ , su alcance es global. Cuando declaramos usando _let_ , el alcance está limitado a esa función. Si desea utilizar una variable _Let_ fuera de una función, hay que hacerlo de alcance mundial o redeclare en la siguiente función.
+
+**Const** , por otro lado, solo puede ser declarado una vez. Su valor nunca puede cambiar.
+
+```js
+    const myName = "Christina"; 
+
+```

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

@@ -0,0 +1,16 @@
+---
+title: Declare String Variables
+localeTitle: Declarar variables de cadena
+---
+## Declarar variables de cadena
+
+En JavaScript, las variables son **dinámicas** . Eso significa que pueden contener números, cadenas o cualquier otro tipo de datos en un momento dado. Para declarar una cadena, simplemente **inicialice** (cree) una variable:
+```
+var a; 
+```
+
+Luego, utilizando comillas simples o dobles, declare la cadena:
+```
+a = "Hello Camper!"; 
+
+```

guide/spanish/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: Disminuir un número con JavaScript
+---
+## Disminuir un número con JavaScript
+
+Disminuye un número usando el operador '-':
+```
+var a = 5; 
+ a--; // Now, 'a' is 4 
+ --a; // Now, 'a' is 3 
+
+```

guide/spanish/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: Eliminar propiedades de un objeto de JavaScript
+---
+## Eliminar propiedades de un objeto de JavaScript
+
+### SUGERENCIA: 1
+
+*   cambia las propiedades de myDog usando notación de puntos
+
+# ADVERTENCIA DE SPOILER: SOLUCIÓN A CONTINUACIÓN
+
+```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/spanish/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 un decimal por otro con JavaScript
+---
+# Divide un decimal por otro con JavaScript
+
+Javascript usa el símbolo `/` para la división.
+```
+var quotient = 0.6 / 0.3; //quotient gets the value 2 
+
+```

guide/spanish/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 un número por otro con JavaScript
+---
+# Divide un número por otro con JavaScript
+
+Javascript usa el símbolo `/` para la división.
+```
+var quotient = 6 / 3; //quotient will get value 2 
+
+```

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

@@ -0,0 +1,9 @@
+---
+title: Escape Sequences in Strings
+localeTitle: Secuencias de escape en cuerdas
+---
+## Secuencias de escape en cuerdas
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/certifications/javascript-algorithms-and-data-structures/basic-javascript/escape-sequences-in-strings/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) .

guide/spanish/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: Escapar de citas literales en cuerdas
+---
+## Escapar de citas literales en cuerdas
+
+*   Cuando necesite usar un carácter especial como `"` dentro de una cadena, debe escapar de ella usando `\` .
+*   Si usa comillas dobles `"` para la cadena, las comillas simples `'` en la cadena no necesitan escaparse.
+*   Si usa comillas simples `'` para la cadena, las comillas dobles `"` en la cadena no necesitan escaparse.
+
+## Solución
+
+```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/spanish/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: Encuentra la longitud de una cuerda
+---
+## Encuentra la longitud de una cuerda
+
+Las cadenas tienen un **atributo** (característica) llamado 'longitud'. Todo lo que tienes que hacer es etiquetarlo después de la cadena / variable.
+```
+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/spanish/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: Encontrar un resto en JavaScript
+---
+# Encontrar un resto en JavaScript
+
+El operador restante `%` da el resto de la división de dos números.
+```
+var remainder = 11 % 3; //remainder gets the value 2 
+
+```

guide/spanish/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: Generar fracciones aleatorias con JavaScript
+---
+# Generar fracciones aleatorias con JavaScript
+
+Los números aleatorios son útiles para crear un comportamiento aleatorio.
+
+JavaScript tiene una función `Math.random()` que genera un número decimal aleatorio entre 0 (incluido) y no hasta 1 (exclusivo). Por `Math.random()` tanto, `Math.random()` puede devolver un 0 pero nunca devolver un 1.
+
+## Nota
+
+Al igual que el almacenamiento de valores con el operador igual, todas las llamadas de función se resolverán antes de que se ejecute la devolución, por lo que podemos devolver el valor de la función `Math.random()` .
+
+## Instrucciones
+
+Cambie randomFraction para devolver un número aleatorio en lugar de devolver 0.
+
+## **Advertencia !!!**
+
+### **Alerta de spoiler !!**
+
+Una solución 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/spanish/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: Generar números enteros al azar con JavaScript
+---
+## Generar números enteros al azar con JavaScript
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](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) .
+
+[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) .

guide/spanish/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: Generar números enteros al azar dentro de un rango
+---
+## Generar números enteros al azar dentro de un rango
+
+**Ayuda para pasar la prueba final:** _`randomRange` debe usar `myMax` y `myMin` , y devolver un número aleatorio en su rango._
+
+No puede pasar la prueba final si solo está reutilizando la función `ourRandomRange` dentro de su fórmula `randomRange` . Necesita escribir su propia fórmula que use las variables `myMax` y `myMin` . Hará el mismo trabajo que con `ourRandomRange` , pero garantiza que haya comprendido los principios de las `Math.floor()` y `Math.random()` .

guide/spanish/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 y funciones
+---
+## Ámbito global y funciones
+
+El alcance de una variable es su visibilidad; ¿En qué parte del código está disponible la función? Aquí hay una lista de los diferentes ámbitos que puede tener una variable.
+
+*   **Ámbito global** : la variable está disponible en todo el código.
+*   **Alcance local** : Disponible solo en un área determinada (como solo dentro de la función)
+*   **Ámbito de bloque** : disponible dentro de un área _aún más_ cierta (como una sentencia if)
+
+Su tarea es entender cómo agregar `var` (y no agregar) antes del nombre de una variable, puede cambiar el alcance de la variable.
+
+Cuando agrega `var` antes del nombre de la variable, su alcance está determinado por el lugar donde se coloca. Al igual que:
+
+```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) 
+  } 
+ } 
+```
+
+Cuando no lo haces, este es el resultado:
+
+```javascript
+num1 = 18; // Global scope 
+ function fun() { 
+  num2 = 20; // Global Scope 
+  if (true) { 
+    num3 = 22; // Global Scope 
+  } 
+ } 
+```
+
+Muy bien, aquí está la solución de código básico.
+
+```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/spanish/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: Ámbito global vs. local en funciones
+---
+## Ámbito global vs. local en funciones
+
+Recuerde que el alcance global significa que la variable está disponible en todo el código. Ámbito local, significa que la variable está disponible dentro de un cierto rango.
+
+En este ejercicio, tiene una variable `outerWear` en el alcance global con "T-shirt" como valor. Ahora debe crear otra variable llamada `outerWear` , pero esta vez dentro de la función `myOutfit()` . La solución de código básico de la siguiente manera:
+
+```javascript
+var outerWear = "T-shirt"; 
+ 
+ function myOutfit() { 
+  var outerWear = "sweater"; 
+  return outerWear; 
+ } 
+ 
+ myOutfit(); 
+```
+
+La función devolverá el `outerWear` más `outerWear` que pueda encontrar. Ya que creamos un `outerWear` dentro de la función, es el 'más cercano', por lo que la función devolverá "sweater".

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

@@ -0,0 +1,125 @@
+---
+title: Golf Code
+localeTitle: Codigo de golf
+---
+![:triangular_flag_on_post:](https://forum.freecodecamp.com/images/emoji/emoji_one/triangular_flag_on_post.png?v=3 ": triangular_flag_on_post:") Recuerda usar **`Read-Search-Ask`** si te atascas. Tratar de emparejar el programa ![:busts_in_silhouette:](https://forum.freecodecamp.com/images/emoji/emoji_one/busts_in_silhouette.png?v=3 ": busts_in_silhouette:") y escribe tu propio código ![:pencil:](https://forum.freecodecamp.com/images/emoji/emoji_one/pencil.png?v=3 ":lápiz:")
+
+### ![:checkered_flag:](https://forum.freecodecamp.com/images/emoji/emoji_one/checkered_flag.png?v=3 ":bandera a cuadros:") Explicación del problema:
+
+En el juego de golf, cada hoyo tiene un **par, lo que** significa el número promedio de **golpes** que se espera que un golfista realice para hundir la bola en un hoyo para completar el juego. Dependiendo de qué tan por encima o **por** debajo de tus **golpes** , hay un apodo diferente.
+
+Su función se pasará **par** y **trazos** argumentos. Debe devolver la cadena correcta de acuerdo con esta tabla que enumera los trazos en orden de prioridad; arriba (más alto) a abajo (más bajo):
+
+Trazos | Regreso  
+: --------- | : -------------  
+1 | "¡Hoyo en uno!"  
+<= par - 2 | "Águila"  
+par - 1 | "Pajarito"  
+par | "Par"  
+par + 1 | "Espectro"  
+par + 2 | "Doble Bogey" > = par + 3 | "¡Vete a casa!"
+
+**Par** y **trazos** siempre serán numéricos y positivos.
+
+*   Cambie el código a continuación `// Only change code below this line` y arriba `// Only change code above this line` .
+*   Asegúrese de que está editando el interior de la función `golfScore` .
+*   Tendrá que hacer que la función devuelva exactamente la misma cadena que se muestra en la tabla, dependiendo del valor de los parámetros **par** y los **trazos** que se pasan a su función.
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 1
+
+`+number -number` puede utilizarse para aumentar o disminuir un parámetro en su condición.
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 2
+
+Usas `if / else if` cadenas para devolver diferentes valores en diferentes escenarios.
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 3
+
+Controle el flujo de su función según el orden de prioridad de las tablas: de arriba (más alto) a más bajo (más bajo) para devolver valores de cadena coincidentes.
+
+> _intenta resolver el problema ahora_
+
+## ¡Alerta de spoiler!
+
+![señal de advertencia](//discourse-user-assets.s3.amazonaws.com/original/2X/2/2d6c412a50797771301e7ceabd554cef4edcd74d.gif)
+
+**¡Solución por delante!**
+
+## ![:beginner:](https://forum.freecodecamp.com/images/emoji/emoji_one/beginner.png?v=3 ":principiante:") Solución de código básico:
+```
+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); 
+```
+
+### Explicación del código:
+
+*   Compare los parámetros **par** y **trazos** para devolver valores de cadena apropiados.
+*   `if / else if` cadena se utiliza para el control de flujo.
+*   Cuerda "ir a casa!" se devuelve para cada condición donde los **trazos** son mayores o iguales al **par + 3** .
+
+## Solución de código alternativo:
+
+```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); 
+```
+
+· Ejecutar en [repl.it](https://repl.it/@AdrianSkar/Basic-JS-Golf-code)
+
+\## explicación del código Como ya tenemos una matriz definida en los `names` las variables, podemos aprovecharla y utilizarla para nuestras declaraciones de devolución usando índices (por ejemplo: `names[0] is the first one` ). De esa manera, si alguna vez necesita cambiar un resultado específico, no tendría que buscarlo dentro de la función, estaría al principio, en su matriz.
+
+### Recursos
+
+*   [Golf](https://en.wikipedia.org/wiki/Golf)
+*   [Desafío: Encadenar Si En Else Declaraciones](http://www.freecodecamp.com/challenges/chaining-if-else-statements)
+*   [Desafío: Comparación con el operador mayor que igual](http://www.freecodecamp.com/challenges/comparison-with-the-greater-than-equal-to-operator)
+*   [Desafío: Comparación con el operador menos que igual](http://www.freecodecamp.com/challenges/comparison-with-the-less-than-equal-to-operator)
+*   ["Array" - _referencia de JavaScript MDN_](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)

guide/spanish/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 un número con JavaScript
+---
+## Incrementar un número con JavaScript
+
+Puede incrementar (agregar uno) fácilmente a una variable numérica usando el operador de incremento '++'. Por ejemplo:
+```
+var a = 6; 
+ a++; // Now, 'a' is equal to 7 -- post-fixing 
+ ++a; // Now, 'a' is equal to 8 -- pre-fixing 
+
+```

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

@@ -0,0 +1,11 @@
+---
+title: Basic Javascript
+localeTitle: Javascript básico
+---
+## Javascript básico
+
+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-javascript/initializing-variables-with-the-assignment-operator/index.md

@@ -0,0 +1,11 @@
+---
+title: Initializing Variables with the Assignment Operator
+localeTitle: Inicializando variables con el operador de asignación
+---
+## Inicializando variables con el operador de asignación
+
+**Inicializar** una variable es darle un valor inicial. Puedes declarar e inicializar una variable así:
+```
+var num = 5; // This is equal to 5 
+
+```

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

@@ -0,0 +1,63 @@
+---
+title: Introducing Else If statements
+localeTitle: Introduciendo las instrucciones Else If
+---
+## Introduciendo las instrucciones Else If
+
+Recuerda usar Read-Search-Ask si te atascas. Intenta emparejar el programa y escribe tu propio código.
+
+\### Explicación del 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); 
+```
+
+Estaremos modificando el código existente arriba para que siga el flujo de lógica que tiene una sentencia **else-if** .
+
+\### Sugerencia: 1 `javascript if (val > 10) { return "Greater than 10"; }` Todas las declaraciones `if` y sus variantes comienzan con una declaración `if` .
+
+> _intenta resolver el problema ahora_
+
+\### Sugerencia: 2 `javascript else if (val < 5) { return "Smaller than 5"; }` Las declaraciones entre la instrucción `if` y la instrucción `else` en un flujo **else-if** están en el formato else-if
+
+> _intenta resolver el problema ahora_
+
+\### Sugerencia: 3 `javascript else { return "Between 5 and 10"; }` La última declaración en un flujo **else-if** está en el formato `else` ### ¡Alerta de spoiler! ![alerón](http://discourse-user-assets.s3.amazonaws.com/original/2X/2/2d6c412a50797771301e7ceabd554cef4edcd74d.gif) ¡Solución por delante! ## Solución de código básico:
+
+```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); 
+```
+
+: cohete: [Ejecutar código](https://repl.it/@RyanPisuena/GoldenWorriedRuntime) ## explicación del código La estructura de un **flujo lógico else-if** es una declaración inicial `if` , una instrucción `if-else` y una instrucción `else` final.
+
+### Recursos
+
+*   ["if ... else" - _referencia de JavaScript MDN_](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/if…else)

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

@@ -0,0 +1,58 @@
+---
+title: Introducing Else statements
+localeTitle: Introduciendo declaraciones Else
+---
+## Introduciendo declaraciones Else
+
+### Explicación del problema:
+
+· _Combina las sentencias `if` en una sola sentencia `if/else` ._
+
+#### Sugerencia 1
+
+Cuando la primera instrucción `if` devuelve `false` el siguiente fragmento de código se ejecuta / evalúa (como `return` , `if` o `else` ).
+
+> _intenta resolver el problema ahora_
+
+#### Sugerencia 2
+
+A veces `if` ( `condition` ) declaraciones pueden ser reemplazados por `else {code to execute instead}` declaraciones (en esencia está diciendo a su función para hacer _"y"_ si no se puede hacer _"x"_ en lugar de especificar _"x"_ varias veces).
+
+> _intenta resolver el problema ahora_
+
+## ¡Alerta de spoiler!
+
+**¡Solución por delante!**
+
+## Solución de código básico:
+
+```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); 
+```
+
+· [Ejecutar código en repl.it](https://repl.it/@AdrianSkar/Introducing-else-statements)
+
+### Explicación del código
+
+La función primero evalúa `if` la condición `val > 5` evalúa como `true` . Si no lo hace, ejecuta la siguiente instrucción ( `else { return "5 or smaller";})` .
+
+### Recursos
+
+*   ["if ... else" - _referencia de JavaScript MDN_](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/if…else)

guide/spanish/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 impares con un bucle for
+---
+## Iterar números impares con un bucle for
+
+Aquí está el ejemplo:
+
+```javascript
+var ourArray = []; 
+ 
+ for (var i = 0; i < 10; i += 2) { 
+  ourArray.push(i); 
+ } 
+ 
+ // Setup 
+ var myArray = []; 
+ 
+ // Only change code below this line. 
+```
+
+Aquí hay una solución: Después de la cadena `// Only change code below this line.` Añadimos `for` bucle. Necesitas copiar loop desde la parte superior:
+
+`javascript for (var i = 0; i < 10; i += 2) { ourArray.push(i); }` Y cambie la `initialization` `var i = 0` a `var i = 1` , también necesita cambiar el nombre de la matriz `ourArray` a `myArray` :
+
+`javascript for (var i = 1; i < 10; i += 2) { myArray.push(i); }`
+
+Aquí hay una solución completa:
+
+\`\` \`javascript var ourArray = \[\];
+
+para (var i = 0; i <10; i + = 2) { nuestroArray.push (i); }
+
+// Preparar var myArray = \[\];
+
+// Solo cambia el código debajo de esta línea.
+
+para (var i = 1; i <10; i + = 2) { myArray.push (i); } \`\` \`

guide/spanish/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 a través de una matriz con un bucle For
+---
+## Iterar a través de una matriz con un bucle For
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](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) .
+
+[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) .

guide/spanish/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 con JavaScript Do ... While Loops
+---
+## Iterar con JavaScript Do ... While Loops
+
+*   `Do...While` Loops se asegura de que el código se ejecute al menos una vez, y después de la ejecución, si la condición dentro de `while()` es **verdadera** , continúa con el bucle, de lo contrario, se detiene.
+
+## Solución
+
+```javascript
+var myArray = []; 
+ var i = 10; 
+ 
+ do { 
+  myArray.push(i); 
+  i++; 
+ } while(i <= 10); 
+
+```

guide/spanish/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 con JavaScript para bucles
+---
+## Iterar con JavaScript para bucles
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/certifications/javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-for-loops/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) .

guide/spanish/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 con JavaScript mientras bucles
+---
+## Iterar con JavaScript mientras bucles
+
+Mientras que los bucles se ejecutarán mientras la condición dentro de () sea verdadera. Ejemplo:
+
+```javascript
+while(condition){ 
+ code... 
+ } 
+```
+
+## Sugerencia 1:
+
+Use una variable de iterador como i en su condición
+
+```javascript
+var i = 0; 
+ while(i <= 4){ 
+ } 
+```
+
+## Spoiler Alert Solution por delante!
+
+## Solución:
+
+```javascript
+// Setup 
+ var myArray = []; 
+ 
+ // Only change code below this line. 
+ var i = 0; 
+ while (i <= 4){ 
+    myArray.push(i); 
+    i++; 
+ } 
+
+```

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

@@ -0,0 +1,19 @@
+---
+title: Local Scope and Functions
+localeTitle: Ámbito local y funciones
+---
+## Ámbito local y funciones
+
+El alcance local significa que la variable está disponible dentro de un área determinada. En el caso de este ejercicio, `myVar` solo está disponible dentro de la función, y no en ningún lugar fuera.
+
+Aquí está la solución de código básica para crear una variable `myVar` local.
+
+```javascript
+function myLocalScope() { 
+  var myVar; 
+  console.log(myVar); 
+ } 
+ myLocalScope(); 
+```
+
+La variable solo existe en la función. Fuera de la función, no existe.

guide/spanish/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: Orden lógico en si otras declaraciones
+---
+## Orden lógico en si otras declaraciones
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](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) .
+
+[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) .

guide/spanish/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 matrices con pop ()
+---
+## Manipular matrices con pop ()
+
+## Explicación del problema
+
+Deshazte del último elemento de la matriz. Luego, asigne ese elemento montado a `removedFromMyArray` .
+
+## Sugerencia 1:
+
+Llame a `.pop()` en la matriz y asígnele a `removedFromMyArray` .
+
+## Spoiler! Solución 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 (); // Esto se deshizo de 5
+
+\`\` \`

guide/spanish/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 matrices con empuje ()
+---
+## Manipular matrices con empuje ()
+
+El método `push()` permite agregar (agregar al final) un elemento a una matriz. Al igual que…
+
+```javascript
+var arr = [1, 2, 3, 4]; 
+ arr.push(5); // Now, the array is [1, 2, 3, 4, 5] 
+
+```

guide/spanish/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 matrices con cambio ()
+---
+## Manipular matrices con cambio ()
+
+Mientras que `pop()` se usó para deshacerse del último elemento de una matriz, `shift()` se usa para deshacerse del primer elemento. Es como si estuvieras desplazando los elementos hacia abajo una posición. Mira esto:
+
+```javascript
+var arr = [1, 2, 3, 4, 5]; 
+ arr.shift(); // Gets rid of the 1 
+
+```

guide/spanish/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 matrices con unshift ()
+---
+## Manipular matrices con unshift ()
+
+Mientras `push()` agrega elementos a la parte posterior de la matriz, `unshift()` agrega al frente. Todo lo que tienes que hacer es:
+
+```javascript
+var arr = [2, 3, 4, 5]; 
+ arr.unshift(1); // Now, the array has 1 in the front 
+
+```

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

@@ -0,0 +1,70 @@
+---
+title: Manipulating Complex Objects
+localeTitle: Manipulando objetos complejos
+---
+## Manipulando objetos complejos
+
+Aquí está el ejemplo:
+
+```javascript
+var myMusic = [ 
+  { 
+    "artist": "Billy Joel", 
+    "title": "Piano Man", 
+    "release_year": 1973, 
+    "formats": [ 
+      "CD", 
+      "8T", 
+      "LP" 
+    ], 
+    "gold": true 
+  } 
+  // Add record here 
+ ]; 
+```
+
+Aquí hay una solución: Después de la cadena `// Add record here` , agregamos un nuevo álbum a `myMusic` . Es necesario empezar desde `,` . Y simplemente puedes copiar el álbum ya creado: `javascript { "artist": "Billy Joel", "title": "Piano Man", "release_year": 1973, "formats": [ "CD", "8T", "LP" ], "gold": true }`
+
+y pegar después `,` :
+
+```javascript
+  // Add record here 
+  , 
+  { 
+    "artist": "Billy Joel", 
+    "title": "Piano Man", 
+    "release_year": 1973, 
+    "formats": [ 
+      "CD", 
+      "8T", 
+      "LP" 
+    ], 
+    "gold": true 
+  } 
+ ]; 
+```
+
+Ahora, puedes cambiar los valores de tu álbum:
+
+```javascript
+  // Add record here 
+  , 
+  { 
+    "artist": "Deep Purple", 
+    "title": "Smoke on the water", 
+    "release_year": 1976, 
+    "formats": [ 
+      "CD", 
+      "8T", 
+      "LP" 
+    ], 
+    "gold": true 
+  } 
+ ]; 
+```
+
+Aquí hay una solución completa:
+
+\`\` \`javascript var myMusic = \[ { "artista": "billy joel", "Título": "Piano Man", " _año de_ estreno _": 1973, "formatos": \[ "DISCOS COMPACTOS", "8T", "LP" \] "oro": cierto } // Añadir registro aquí { "artista": "Deep Purple", "Título": "Humo en el agua", "_ año de _estreno_ ": 1976, "formatos": \[ "DISCOS COMPACTOS", "8T", "LP" \] } \];
+
+\`\` \`

guide/spanish/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 datos de matriz con índices
+---
+## Modificar datos de matriz con índices
+
+Acceda a la posición de la matriz y cámbiela, de esta manera:
+
+```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] 
+```
+
+El concepto importante aquí es que los arreglos son **mutables** . Esto significa que se pueden cambiar fácilmente.

guide/spanish/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últiples opciones idénticas en declaraciones de cambio
+---
+## Múltiples opciones idénticas en declaraciones de cambio
+
+### Explicación del problema
+
+_Si la declaración de interrupción se omite en el caso de una instrucción de cambio, se ejecutan las siguientes instrucciones de caso hasta que se encuentra una interrupción. Si tiene varias entradas con la misma salida, puede representarlas en una declaración de cambio como esta:_
+
+```javascript
+switch(val) { 
+  case 1: 
+  case 2: 
+  case 3: 
+    result = "1, 2, or 3"; 
+    break; 
+  case 4: 
+    result = "4 alone"; 
+ } 
+```
+
+_Los casos para 1, 2 y 3 producirán el mismo resultado._
+
+_Escriba una instrucción de cambio para establecer la respuesta para los siguientes rangos:_ `1-3` - "Bajo"  
+`4-6` - "Mid"  
+`7-9` - "Alto"
+
+_Nota: Deberá tener una declaración de caso para cada número en el rango._
+
+## ¡Alerta de spoiler!
+
+**¡Solución por delante!**
+
+## Solución 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); 
+```
+
+## Solución de código alternativo:
+
+```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); 
+```
+
+· Ejecutar código en [repl.it.](https://repl.it/@AdrianSkar/Basic-JS-Multiple-opts-in-switch)
+
+### Explicación del código
+
+Como ya tiene una variable llamada `answer` definida y la función la devuelve, solo puede modificar su valor en cada grupo de declaraciones de casos para que se ajusten a los requisitos del ejercicio.
+
+### Recursos
+
+*   ["Switch: Métodos para el caso de criterios múltiples" - _MDN Referencia de Javascript_](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/switch)

guide/spanish/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: Multiplica dos decimales con JavaScript
+---
+## Multiplica dos decimales con JavaScript
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/certifications/javascript-algorithms-and-data-structures/basic-javascript/multiply-two-decimals-with-javascript/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) .

guide/spanish/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: Multiplica dos números con JavaScript
+---
+# Multiplica dos números con JavaScript
+
+JavaScript usa el símbolo `*` para la multiplicación.
+```
+var product = 8 * 10; //product gets the value 80 
+
+```

guide/spanish/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: Anidar una matriz dentro de otra matriz
+---
+## Anidar una matriz dentro de otra matriz
+
+Las matrices son unidimensionales; eso significa que almacenan solo una fila de datos. ¡Pero puedes hacer una matriz multidimensional colocando matrices dentro de matrices! Al igual que:
+
+```javascript
+var arr = [["Two-dimensional", 2], ["Two rows", 12]]; 
+```
+
+La matriz anterior tiene dos dimensiones.

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

@@ -0,0 +1,91 @@
+---
+title: Nesting For Loops
+localeTitle: Anidando para bucles
+---
+## Anidando para bucles
+
+**Recuerda usar Read-Search-Ask si te atascas. Intente vincular el programa: bustos _en_ silueta: y escriba su propio código: lápiz:**
+
+: checkered\_flag: **Explicación del problema:**
+
+Si tiene una matriz multidimensional, puede usar la misma lógica que el punto de ruta anterior para recorrer tanto la matriz como cualquier subarreglo.
+
+Aquí hay un ejemplo:
+```
+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]); 
+  } 
+ } 
+```
+
+Esto genera cada subelemento en `arr` uno a la vez. Tenga en cuenta que para el bucle interno, estamos comprobando la longitud de arr \[i\], ya que arr \[i\] es en sí misma una matriz.
+
+*   Modifique la función `multiplyAll` para que multiplique la variable del `product` por cada número en las subarreglas de `arr` .
+*   Asegúrese de que el segundo bucle for esté anidado dentro del primero.
+
+**Enlaces relevantes**
+
+*   [Anidar una matriz dentro de otra matriz](https://guide.freecodecamp.org/certifications/javascript-algorithms-and-data-structures/basic-javascript/nest-one-array-within-another-array)
+*   [Iterar a través de una matriz con un bucle for](https://learn.freecodecamp.org/javascript-algorithms-and-data-structures/basic-javascript/iterate-through-an-array-with-a-for-loop)
+*   [Acceso a matrices anidadas](https://learn.freecodecamp.org/javascript-algorithms-and-data-structures/basic-javascript/accessing-nested-arrays)
+
+: speech\_balloon: Sugerencia: 1
+
+Asegúrese de verificar con la `length` y no la matriz general.
+
+_intenta resolver el problema ahora_
+
+: speech\_balloon: Sugerencia 2
+
+Usa tanto `i` como `j` cuando multipliques el producto.
+
+_intenta resolver el problema ahora_
+
+: speech\_balloon: Sugerencia 3
+
+Recuerde utilizar `arr[i]` cuando multiplique los subarreglos con la variable del `product` .
+
+_intenta resolver el problema ahora_
+
+_¡Alerta de spoiler!_ ![](https://discourse-user-assets.s3.amazonaws.com/original/2X/2/2d6c412a50797771301e7ceabd554cef4edcd74d.gif)
+
+**¡Solución por delante!**
+
+: principiante: **Solución de código básico:**
+```
+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]]); 
+```
+
+: cohete: **[Ejecutar código](https://learn.freecodecamp.org/javascript-algorithms-and-data-structures/basic-javascript/nesting-for-loops/)**
+
+**Explicación del código:**
+
+*   Verificamos la longitud de `arr` en el bucle `i` for y la longitud `arr[i]` en el bucle `j` for.
+*   Multiplicamos la variable del `product` por sí misma porque es igual a 1, y luego la multiplicamos por los subarreglos.
+*   Las dos subarreglas para multiplicar son `arr[i]` y `j` .
+
+: Portapapeles: **NOTAS DE CONTRIBUCIONES:**
+
+*   : advertencia: **NO** agregue soluciones que sean similares a las soluciones existentes. Si cree que es similar pero mejor, intente fusionar (o reemplazar) la solución similar existente.
+*   Agregue una explicación de su solución.
+*   Categorice la solución en una de las siguientes categorías: Básica, Intermedia y Avanzada. :semáforo:
+*   Agregue su nombre de usuario solo si ha agregado algún contenido principal relevante. (: advertencia: _**NO**_ elimine ningún nombre de usuario existente)
+
+Vea: point\_right: [Wiki Challenge Solution Template](http://forum.freecodecamp.com/t/algorithm-article-template/14272) para referencia.

guide/spanish/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: Pasando valores a funciones con argumentos
+---
+## Pasando valores a funciones con argumentos
+
+Nuestra tarea es crear una función que tenga **parámetros** . Estas son entradas que determinan la salida de la función. Se colocan parámetros dentro del `()` , así:
+
+```javascript
+function functionWithArgs(one, two) { 
+  console.log(one + two); 
+ } 
+```
+
+Ahora tenemos que agregar código dentro de los paréntesis. Nuestra tarea es agregar `one` y `two` , e imprimir la suma en la consola. Aquí está la solución de código básico:
+
+```javascript
+functionWithArgs(7, 3); 
+ //This will console log 10. 
+
+```

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

@@ -0,0 +1,46 @@
+---
+title: Practice comparing different values
+localeTitle: Practicar comparando valores diferentes.
+---
+## Practicar comparando valores diferentes.
+
+### Explicación del problema:
+
+· _Modifique la función de modo que devuelva "Igual" solo cuando los valores sean **estrictamente** iguales._
+
+#### Sugerencia 1
+
+Recuerde de los últimos ejercicios que, a _diferencia del operador de igualdad, que intenta convertir ambos valores en comparación con un tipo común, el operador de igualdad estricta no realiza una conversión de tipo._ [1](#cite1)
+
+> _intenta resolver el problema ahora_
+
+## ¡Alerta de spoiler!
+
+**¡Solución por delante!**
+
+## Solución de código básico:
+
+```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"); 
+```
+
+### Explicación del código
+
+La función primero evalúa `if` la condición `(a === b)` evalúa como `true` considerando tanto el tipo como el valor. Si lo hace, devuelve la instrucción entre las llaves ("Igual"). Si no lo hace, devuelve la siguiente declaración de `return` fuera de ellos ("No es igual").
+
+### Fuentes
+
+1 . ["JavaScript Básico: Comparación con el Operador de Igualdad Estricta", lección de la FCC en _Algoritmos de Javascript y Certificación de Estructuras de Datos_](https://learn.freecodecamp.org/javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-strict-equality-operator)
+
+### Recursos
+
+*   ["Usando los operadores de igualdad" - _Referencia de JavaScript MDN_](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Using_the_Equality_Operators)

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

@@ -0,0 +1,96 @@
+---
+title: Profile Lookup
+localeTitle: Búsqueda de perfiles
+---
+![:triangular_flag_on_post:](https://forum.freecodecamp.com/images/emoji/emoji_one/triangular_flag_on_post.png?v=3 ": triangular_flag_on_post:") Recuerda usar **`Read-Search-Ask`** si te atascas. Tratar de emparejar el programa ![:busts_in_silhouette:](https://forum.freecodecamp.com/images/emoji/emoji_one/busts_in_silhouette.png?v=3 ": busts_in_silhouette:") y escribe tu propio código ![:pencil:](https://forum.freecodecamp.com/images/emoji/emoji_one/pencil.png?v=3 ":lápiz:")
+
+### ![:checkered_flag:](https://forum.freecodecamp.com/images/emoji/emoji_one/checkered_flag.png?v=3 ":bandera a cuadros:") Explicación del problema:
+
+Tenemos una variedad de objetos que representan a diferentes personas en nuestras listas de contactos.
+
+Un `lookUpProfile()` función que toma **primerNombre** y una propiedad **(prop)** como argumentos ha sido pre-escrito para ti.
+
+La función debe comprobar si es **primerNombre** **primerNombre** de un contacto real y la propiedad dada **(prop)** es una propiedad de ese contacto.
+
+Si ambos son verdaderos, entonces devuelva el _valor_ de esa propiedad.
+
+Si **primerNombre** no se corresponde con contactos a continuación, volver `No such contact` .
+
+Si la **propiedad** no corresponde a ninguna propiedad válida, devuelva `No such property`
+
+*   Cambie el código a continuación `// Only change code below this line` y hasta `// Only change code above this line` .
+*   Asegúrese de que está editando el interior de la función `lookUpProfile()` .
+    *   Esta función incluye dos parámetros, **firstName** y **prop.**
+*   La función debe mirar a través de la lista de **contactos** para el parámetro **primerNombre** dado.
+    *   Si se encuentra una coincidencia, la función debe buscar el parámetro **prop** dado.
+    *   Si se encuentran tanto el **FirstName** como el **prop** asociado, debe devolver el valor del **prop** .
+    *   Si **primerNombre** se encuentra y no se encuentra un **puntal** asociado, debe devolver `No such property` .
+*   Si **primerNombre** no se encuentra en cualquier lugar, debe devolver `No such contact` .
+
+#### Enlaces relevantes
+
+*   [Desafío: acceder a las propiedades de los objetos con notación de corchete](http://www.freecodecamp.com/challenges/accessing-objects-properties-with-bracket-notation)
+*   [Desafío: Iterar con JavaScript para bucles](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:") Sugerencia: 1
+
+Use un bucle `for` para recorrer la lista de **contactos** .
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 2
+
+Use un anidado `if` la declaración comprobar primero si el **nombre** coincide, y luego comprueba `if` los partidos **prop.**
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 3
+
+Deje su `return "No such contact"` fuera del bucle `for` como un final definitivo.
+
+> _intenta resolver el problema ahora_
+
+## ¡Alerta de spoiler!
+
+![señal de advertencia](//discourse-user-assets.s3.amazonaws.com/original/2X/2/2d6c412a50797771301e7ceabd554cef4edcd74d.gif)
+
+**¡Solución por delante!**
+
+## ![:beginner:](https://forum.freecodecamp.com/images/emoji/emoji_one/beginner.png?v=3 ":principiante:") Solución de código básico:
+```
+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"; 
+```
+
+### Explicación del código:
+
+*   El bucle `for` ejecuta, comenzando por el primer objeto en la lista de **contactos** .
+*   Si el parámetro **firstName** pasado a la función coincide con el valor de la clave `"firstName"` en el primer objeto, la instrucción `if` pasa.
+*   Luego, usamos el método `.hasOwnProperty()` (verifica si hay una propiedad dada y devuelve un valor booleano) con **prop** como argumento. Si es cierto, se devuelve el valor de **prop** .
+    *   Si la segunda instrucción `if` falla, `No such property` se devuelve `No such property` .
+*   Si la primera instrucción `if` falla, el bucle `for` continúa hasta el siguiente objeto en la lista de **contactos** .
+*   Si el parámetro **firstName** no se corresponde con los **contactos** finales objeto, el `for` las salidas de bucle y `No such contact` se devuelve.
+
+**Ejecución de ejemplo**
+
+*   `lookUpProfile("Akira","likes");` carreras.
+*   `"Akira"` coincide con la clave `"firstName"` en el primer objeto, por lo que la instrucción `if` devuelve verdadero.
+*   `"likes"` se encuentra dentro del primer objeto, por lo que la segunda declaración `if` devuelve true.
+*   Se devuelve el valor de `"likes"` : `"Pizza", "Coding", "Brownie Points"` .
+
+## ![:clipboard:](https://forum.freecodecamp.com/images/emoji/emoji_one/clipboard.png?v=3 ":portapapeles:") NOTAS PARA LAS CONTRIBUCIONES:
+
+*   ![:warning:](https://forum.freecodecamp.com/images/emoji/emoji_one/warning.png?v=3 ":advertencia:") **NO** agregue soluciones que sean similares a las soluciones existentes. Si cree que es **_similar pero mejor_** , intente fusionar (o reemplazar) la solución similar existente.
+*   Agregue una explicación de su solución.
+*   Categorice la solución en una de las siguientes categorías: **Básica** , **Intermedia** y **Avanzada** . ![:traffic_light:](https://forum.freecodecamp.com/images/emoji/emoji_one/traffic_light.png?v=3 ":semáforo:")
+*   Agregue su nombre de usuario solo si ha agregado algún **contenido principal relevante** . ( ![:warning:](https://forum.freecodecamp.com/images/emoji/emoji_one/warning.png?v=3 ":advertencia:") **_NO_** _elimine ningún nombre de usuario existente_ )
+
+> Ver ![:point_right:](https://forum.freecodecamp.com/images/emoji/emoji_one/point_right.png?v=3 ": point_right:") **`Wiki Challenge Solution Template`** para referencia.

guide/spanish/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: Cotizando cuerdas con comillas simples
+---
+## Cotizando cuerdas con comillas simples
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/certifications/javascript-algorithms-and-data-structures/basic-javascript/quoting-strings-with-single-quotes/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) .

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

@@ -0,0 +1,97 @@
+---
+title: Record Collection
+localeTitle: Colección de discos
+---
+![:triangular_flag_on_post:](https://forum.freecodecamp.com/images/emoji/emoji_one/triangular_flag_on_post.png?v=3 ": triangular_flag_on_post:") Recuerda usar **`Read-Search-Ask`** si te atascas. Tratar de emparejar el programa ![:busts_in_silhouette:](https://forum.freecodecamp.com/images/emoji/emoji_one/busts_in_silhouette.png?v=3 ": busts_in_silhouette:") y escribe tu propio código ![:pencil:](https://forum.freecodecamp.com/images/emoji/emoji_one/pencil.png?v=3 ":lápiz:")
+
+### ![:checkered_flag:](https://forum.freecodecamp.com/images/emoji/emoji_one/checkered_flag.png?v=3 ":bandera a cuadros:") Explicación del problema:
+
+Se le proporciona un objeto JSON que representa (una pequeña parte de) su colección de registros. Cada álbum se identifica con un número de identificación único y tiene varias propiedades. No todos los álbumes tienen información completa.
+
+Escriba una función que tome un **id** , una propiedad ( **prop** ) y un **valor** .
+
+Para la **identificación** dada en la **colección** :
+
+Si el **valor** no está en blanco ( **valor! == ""** ), entonces actualice o establezca el **valor** para la **prop** .
+
+Si la **prop** es **"tracks"** y el **valor** no está en blanco, verifique si el elemento dado en la matriz tiene la propiedad de "tracks". Si el elemento tiene la propiedad de "pistas", presione el **valor** hacia el final de la matriz de "pistas". Si el elemento no tiene la **propiedad** , cree el par de propiedad y valor.
+
+Si el **valor** está en blanco, elimine esa **prop** .
+
+Siempre devuelve todo el objeto de colección.
+
+*   Cambie el código a continuación `// Only change code below this line` y hasta `// Alter values below to test your code` .
+*   Tenga en cuenta que está editando el interior de la función `updateRecords` .
+*   Para el parámetro **id** dado, que está asociado al objeto de **colección** :
+    *   Si el parámetro de **valor** no es una cadena vacía, actualice (o establezca) el parámetro de **valor** para el parámetro **prop** .
+    *   Si el parámetro **prop** es igual a `"tracks"` y el **valor** no es una cadena vacía, presione el **valor** en el extremo de la matriz de **tracks** .
+    *   Si el **valor** es una cadena vacía, elimine esa **prop** del objeto.
+*   Finalmente, devuelve el objeto de **colección** .
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 1
+
+Use una instrucción `else if` para verificar los pasos necesarios.
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 2
+
+El segundo paso que se enumera en las instrucciones debe ser el primero en su `else if` instrucción `else if` .
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 3
+
+Para acceder al valor de una clave en este objeto, utilizará la `collection[id][prop]` .
+
+> _intenta resolver el problema ahora_
+
+## ¡Alerta de spoiler!
+
+![señal de advertencia](//discourse-user-assets.s3.amazonaws.com/original/2X/2/2d6c412a50797771301e7ceabd554cef4edcd74d.gif)
+
+**¡Solución por delante!**
+
+## ![:beginner:](https://forum.freecodecamp.com/images/emoji/emoji_one/beginner.png?v=3 ":principiante:") Solución de código básico:
+```
+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 ":cohete:") [Ejecutar código](https://repl.it/C2AZ/0)
+
+### Explicación del código:
+
+*   Primero verifica si la **prop** es igual a las **pistas** Y si el **valor** no es una cadena en blanco. Si ambas pruebas pasan, el **valor** se inserta en la matriz de **pistas** .
+*   Si esa primera verificación no se pasa, a continuación solo verifica si el **valor** no es una cadena en blanco. Si esa prueba pasa, se agregan una nueva clave ( **prop** ) y un valor ( **valor** ) al objeto, o una clave existente se actualiza si ya existe la **prop** .
+*   Si ambas comprobaciones fallan (lo que significa que el **valor** debe ser una cadena vacía), la clave ( **prop** ) se elimina del objeto.
+
+**Ejecución de ejemplo**
+
+*   `updateRecords(5439, "artist", "ABBA");` carreras.
+*   **prop** es igual a "artista", no a "pistas", por lo que la primera parte de la sentencia `else if` falla.
+*   **el valor** no es una cadena en blanco, por lo que la segunda parte de la otra parte si la declaración pasa.
+*   `artist: "ABBA"` se agrega a la `id` `5439` .
+
+### Recursos:
+
+*   [El desafío de la FCC: acceder a las propiedades de los objetos con notación de corchete](https://learn.freecodecamp.org/javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-bracket-notation/)
+*   [El desafío de la FCC: agregar nuevas propiedades a un objeto de JavaScript](http://www.freecodecamp.com/challenges/add-new-properties-to-a-javascript-object)
+*   [El desafío de la FCC: eliminar propiedades de un objeto JavaScript](http://www.freecodecamp.com/challenges/delete-properties-from-a-javascript-object)
+*   [El desafío de la FCC: acceder a objetos anidados](https://learn.freecodecamp.org/javascript-algorithms-and-data-structures/basic-javascript/accessing-nested-objects/)
+*   ["Array.prototype.push ()" - _referencia de JavaScript de MDN_](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push)
+*   ["eliminar operador" - _referencia de JavaScript MDN_](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/delete)

guide/spanish/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: Reemplazo de cadenas de otro tipo con interruptor
+---
+## Reemplazo de cadenas de otro tipo con interruptor
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](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) .
+
+[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) .

guide/spanish/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: Devolver un valor de una función con retorno
+---
+## Devolver un valor de una función con retorno
+
+Usando `return` , puedes hacer funciones de salida de datos. Aquí está la solución de código básico:
+
+```javascript
+function timesFive(num) { 
+  return num * 5; 
+ } 
+
+```

guide/spanish/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: Volver el patrón inicial para funciones
+---
+## Volver el patrón inicial para funciones
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/certifications/javascript-algorithms-and-data-structures/basic-javascript/return-early-pattern-for-functions/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) .

guide/spanish/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: Devolviendo valores booleanos desde funciones
+---
+## Devolviendo valores booleanos desde funciones
+
+En lugar de usar un bloque if / else para comparar la variable, podemos hacerlo directamente dentro de la declaración de retorno con un operador de comparación y un código mínimo.
+
+### Explicación del problema
+
+_Arreglar la función `isLess` permite eliminar las sentencias `if...else` ._
+
+```js
+// Fix this code 
+  if (a < b) { 
+    return true; 
+  } else { 
+    return false; 
+  } 
+```
+
+#### Sugerencia 1
+
+Al igual que con el [ejercicio anterior](https://learn.freecodecamp.org/javascript-algorithms-and-data-structures/basic-javascript/replacing-if-else-chains-with-switch) , está a punto de cambiar la forma en que la función devuelve el valor correcto, lo que significa que no tiene que reutilizar o modificar ese código sino sustituirlo.
+
+> _intenta resolver el problema ahora_
+
+#### Sugerencia 2
+
+Con el fin de devolver `true` o `false` que no es necesario usar dos declaraciones ni `if` queridos. El [operador de comparación](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators) correcto es todo lo que necesita.
+
+> _intenta resolver el problema ahora_
+
+## ¡Alerta de spoiler!
+
+**¡Solución por delante!**
+
+## Solución de código:
+
+```javascript
+function isLess(a, b) { 
+  // Fix this code 
+  return a <= b; 
+ } 
+ // Change these values to test 
+ isLess(10, 15); 
+```
+
+Ejecute el código en [repl.it.](https://repl.it/@AdrianSkar/Basic-Js-Returning-boolean-from-function)
+
+### Recursos
+
+*   ["Operador menor o igual (<=)" - _MDN Referencia de Javascript_](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Less_than_or_equal_operator_(%3C))

guide/spanish/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: Selección de muchas opciones con instrucciones de cambio
+---
+## Selección de muchas opciones con instrucciones de cambio
+
+_Si tiene muchas opciones para elegir, use una instrucción de `switch` . Una instrucción de `switch` prueba un valor y puede tener muchas declaraciones de `case` que definen varios valores posibles. Las declaraciones se ejecutan desde el primer valor de `case` coincidente hasta que se encuentra una `break` ._
+
+_Aquí hay un ejemplo de pseudocódigo:_
+
+```js
+  switch(num) { 
+    case value1: 
+      statement1; 
+      break; 
+    case value2: 
+      statement2; 
+      break; 
+    ... 
+    case valueN: 
+      statementN; 
+      break; 
+  } 
+```
+
+### Un poco más de explicación.
+
+Una sentencia de switch primero evalúa su expresión. Luego busca la primera cláusula de `case` cuya expresión se evalúa con el mismo valor que el resultado de la expresión de entrada (usando la [comparación estricta](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators) , ( `===` ) y transfiere el control a esa cláusula, ejecutando las declaraciones asociadas. (Si coinciden varios casos el valor proporcionado, el primer caso que coincide se selecciona, incluso si los casos no son iguales entre sí.)
+
+Si no se encuentra una cláusula de `case` coincidente, el programa busca la cláusula `default` opcional y, si se encuentra, transfiere el control a esa cláusula, ejecutando las declaraciones asociadas. Si no se encuentra una cláusula `default` , el programa continúa la ejecución en la declaración que sigue al final del `switch` . Por convención, la cláusula `default` es la última cláusula, pero no es necesario que lo sea.
+
+La declaración de `break` opcional asociada con cada etiqueta de caso asegura que el programa se salga del conmutador una vez que se ejecute la sentencia coincidente y continúe la ejecución en la sentencia siguiente al conmutador. Si se omite `break` , el programa continúa su ejecución en la siguiente declaración en la instrucción `switch` . [1](#cite1)
+
+### Explicación del problema:
+
+_Escriba una instrucción de conmutación que pruebe `val` y establezca la `answer` para las siguientes condiciones:_
+
+*   `1` - "alfa",
+*   `2` - "beta",
+*   `3` - "gamma",
+*   `4` - "delta".
+
+## Sugerencia 1
+
+Recuerde que los valores de los `case` se prueban con igualdad estricta ( `===` ).
+
+> Intenta resolver el problema ahora!
+
+## Sugerencia 2
+
+No vea las _"condiciones siguientes"_ como una lista ordenada como se ve en la demostración original de freeCodeCamp, sino como valores y declaraciones, como se muestra aquí
+
+> Intenta resolver el problema ahora!
+
+## ¡Alerta de spoiler!
+
+### ¿Estás completamente seguro de lo que quieres ver? ...
+
+## Solución de código básico
+
+```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); 
+```
+
+### Explicación del Código
+
+Es común ignorar que los valores de `case` se prueban con igualdad estricta con cualquier necesidad de otra expresión, como por ejemplo: `case === value`
+
+## Solución de código alternativo:
+
+```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); 
+```
+
+· Ejecutar código en [repl.it.](https://repl.it/@AdrianSkar/Basic-JS-Switch-statements)
+
+### Explicación del código
+
+Dado que ya tiene una variable definida al comienzo de la función llamada `answer` y está definida como la última declaración de retorno, puede asignarle nuevos valores para cada caso y devolverá la respuesta esperada según el valor que pase a la función.
+
+### Fuentes
+
+1 . [Descripción de "switch" - _referencia de JavaScript MDN_](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/switch#Description) .

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

@@ -0,0 +1,65 @@
+---
+title: Shopping List
+localeTitle: Lista de la compra
+---
+![:triangular_flag_on_post:](https://forum.freecodecamp.com/images/emoji/emoji_one/triangular_flag_on_post.png?v=3 ": triangular_flag_on_post:") Recuerda usar **`Read-Search-Ask`** si te atascas. Tratar de emparejar el programa ![:busts_in_silhouette:](https://forum.freecodecamp.com/images/emoji/emoji_one/busts_in_silhouette.png?v=3 ": busts_in_silhouette:") y escribe tu propio código ![:pencil:](https://forum.freecodecamp.com/images/emoji/emoji_one/pencil.png?v=3 ":lápiz:")
+
+### ![:checkered_flag:](https://forum.freecodecamp.com/images/emoji/emoji_one/checkered_flag.png?v=3 ":bandera a cuadros:") Explicación del problema:
+
+Crea una lista de compras en la variable **myList** . La lista debe ser una matriz multidimensional que contenga varias subarreglas.
+
+El primer elemento de cada sub-matriz debe contener una cadena con el nombre del elemento. El segundo elemento debe ser un número que represente la cantidad, es decir, `["Chocolate Bar", 15]` .
+
+Debe haber al menos 5 subarreglos en la lista.
+
+*   **myList** debería ser una matriz.
+*   Los primeros elementos en cada uno de sus subarreglos deben ser cadenas.
+*   Los segundos elementos en cada uno de sus subarreglos deben ser todos números.
+*   Debe tener al menos 5 elementos en su lista.
+
+#### Enlaces relevantes
+
+*   [Desafío: anidar una matriz dentro de otra matriz](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:") Sugerencia: 1
+
+Una matriz multidimensional tendría el siguiente esquema `[[]]` .
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 2
+
+Cada sub-matriz debe estar separada por `,` igual que cualquier elemento en una matriz.
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 3
+
+No olvides el `;` Al final de su declaración.
+
+> _intenta resolver el problema ahora_
+
+## ¡Alerta de spoiler!
+
+![señal de advertencia](//discourse-user-assets.s3.amazonaws.com/original/2X/2/2d6c412a50797771301e7ceabd554cef4edcd74d.gif)
+
+**¡Solución por delante!**
+
+## ![:beginner:](https://forum.freecodecamp.com/images/emoji/emoji_one/beginner.png?v=3 ":principiante:") Solución de código básico:
+```
+var myList = [["Canned Beans", 3],["Milk Galon", 1],["Cereal", 2],["Toilet Paper", 12],["Sack of Rice", 1]]; 
+```
+
+### Explicación del código:
+
+*   Se crea una matriz multidimensional.
+*   La matriz consta de cinco matrices dentro, cada una compuesta de una cadena y un entero, en el mismo orden.
+
+## ![:clipboard:](https://forum.freecodecamp.com/images/emoji/emoji_one/clipboard.png?v=3 ":portapapeles:") NOTAS PARA LAS CONTRIBUCIONES:
+
+*   ![:warning:](https://forum.freecodecamp.com/images/emoji/emoji_one/warning.png?v=3 ":advertencia:") **NO** agregue soluciones que sean similares a las soluciones existentes. Si cree que es **_similar pero mejor_** , intente fusionar (o reemplazar) la solución similar existente.
+*   Agregue una explicación de su solución.
+*   Categorice la solución en una de las siguientes categorías: **Básica** , **Intermedia** y **Avanzada** . ![:traffic_light:](https://forum.freecodecamp.com/images/emoji/emoji_one/traffic_light.png?v=3 ":semáforo:")
+*   Agregue su nombre de usuario solo si ha agregado algún **contenido principal relevante** . ( ![:warning:](https://forum.freecodecamp.com/images/emoji/emoji_one/warning.png?v=3 ":advertencia:") **_NO_** _elimine ningún nombre de usuario existente_ )
+
+> Ver ![: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 referencia.

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

@@ -0,0 +1,73 @@
+---
+title: Stand in Line
+localeTitle: Hacer cola
+---
+![:triangular_flag_on_post:](https://forum.freecodecamp.com/images/emoji/emoji_one/triangular_flag_on_post.png?v=3 ": triangular_flag_on_post:") Recuerda usar **`Read-Search-Ask`** si te atascas. Tratar de emparejar el programa ![:busts_in_silhouette:](https://forum.freecodecamp.com/images/emoji/emoji_one/busts_in_silhouette.png?v=3 ": busts_in_silhouette:") y escribe tu propio código ![:pencil:](https://forum.freecodecamp.com/images/emoji/emoji_one/pencil.png?v=3 ":lápiz:")
+
+### ![:checkered_flag:](https://forum.freecodecamp.com/images/emoji/emoji_one/checkered_flag.png?v=3 ":bandera a cuadros:") Explicación del problema:
+
+En Ciencias de la Computación una _cola_ es una **estructura de datos** abstracta donde los elementos se mantienen en orden. Los nuevos elementos se pueden agregar al final de la **cola** y los elementos antiguos se quitan de la parte delantera de la **cola** .
+
+Escriba una función `nextInLine` que tome una matriz ( **arr** ) y un número ( **elemento** ) como argumentos. Agregue el número al final de la matriz, luego elimine el primer elemento de la matriz. La función `nextInLine` debería devolver el elemento que se eliminó.
+
+*   Cambie el código a continuación `//Your Code here` y hasta `//Change this line` .
+*   Asegúrese de que está editando el interior de la función `nextInLine` .
+*   Use una función de matriz que aprendió para agregar el **elemento** al final de la matriz **arr** .
+*   Use una función de matriz que aprendió para eliminar el primer elemento de la matriz **arr** .
+*   Devuelve el elemento eliminado.
+
+#### Enlaces relevantes
+
+*   [Desafío: manipular matrices con push ()](http://www.freecodecamp.com/challenges/manipulate-arrays-with-push)
+*   [Desafío: Manipular matrices con cambio ()](http://www.freecodecamp.com/challenges/manipulate-arrays-with-shift)
+*   [Desafío: pasar valores a funciones con 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:") Sugerencia: 1
+
+El método `push()` agrega un elemento al final de una matriz.
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 2
+
+El método `shift()` elimina el primer elemento de una matriz. También devuelve el elemento eliminado.
+
+> _intenta resolver el problema ahora_
+
+## ![:speech_balloon:](https://forum.freecodecamp.com/images/emoji/emoji_one/speech_balloon.png?v=3 ": speech_balloon:") Sugerencia: 3
+
+La función `nextInLine` usa **arr** y **item** . Esas son las que utilizarán las pruebas para pasar los elementos de matriz con los que se probarán. Permite que la función sea reutilizable. No codifique ninguna de las pruebas dentro de la función.
+
+> _intenta resolver el problema ahora_
+
+## ¡Alerta de spoiler!
+
+![señal de advertencia](//discourse-user-assets.s3.amazonaws.com/original/2X/2/2d6c412a50797771301e7ceabd554cef4edcd74d.gif)
+
+**¡Solución por delante!**
+
+## ![:beginner:](https://forum.freecodecamp.com/images/emoji/emoji_one/beginner.png?v=3 ":principiante:") Solución de código básico:
+```
+function nextInLine(arr, item) { 
+  // Your code here 
+  arr.push(item); 
+  var removed = arr.shift(); 
+  return removed;  // Change this line 
+ } 
+```
+
+### Explicación del código:
+
+*   Empuje el **artículo** al final de **arr** .
+*   Llame al método `shift()` en **arr** para obtener el primer elemento y guárdelo en el lugar **eliminado** .
+*   Retorno **eliminado** .
+
+**Ejecución de ejemplo**
+
+*   Prueba `nextInLine([2,1]);` carreras.
+*   Se `nextInLine` función `nextInLine` . **arr se** convierte en \[2\]. **el artículo se** convierte en 1.
+*   `arr.push(item);` Empuja 1 a \[2\]. Así que **arr** es ahora \[2,1\].
+*   `var removed = arr.shift();` elimina el primer elemento. Así que **arr** es ahora \[1\]. 2 ha sido eliminado y se almacena en **eliminado** .
+*   `return removed;` Se devuelve 2.
+
+**_Nota_** : en realidad no es necesario **eliminar** la variable. El elemento eliminado se puede devolver directamente usando `return arr.shift();` .

guide/spanish/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: Almacene múltiples valores en una variable utilizando matrices de JavaScript
+---
+## Almacene múltiples valores en una variable utilizando matrices de JavaScript
+
+Las matrices le permiten almacenar muchos datos diferentes, dentro de una sola variable. Todo lo que tiene que hacer es colocar los datos en la matriz, separados por comas. Al igual que…
+
+```javascript
+var arr = ["Code for change", 123]; 
+```
+
+Recuerde, una matriz se define como una fila de cosas. Estás almacenando diferentes datos en una sola 'fila' (variable).
+
+Revisa este enlace si necesitas más ayuda:
+
+[Arrays de JavaScript en las escuelas W3](https://www.w3schools.com/js/js_arrays.asp)

guide/spanish/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: Almacenamiento de valores con el operador de asignación
+---
+## Almacenamiento de valores con el operador de asignación
+
+¡Es como las matemáticas! Puede configurar una variable para que actúe como un marcador de posición para los datos utilizando el operador de asignación '='. En otras palabras, la variable almacenará los datos.
+```
+var a; 
+ a = 5; // The variable 'a' is equal to 5 
+ 
+ var zxcv; 
+ zxcv = 123; // The variable 'abc' is equal to 123 
+
+```

guide/spanish/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: Resta un número de otro con JavaScript
+---
+## Resta un número de otro con JavaScript
+
+Usando el operador de resta '-', puedes obtener la diferencia de dos números ...
+```
+var diff1 = 30 - 14; // Difference is 16 
+ var diff2 = 90 - 60; // Difference is 30 
+
+```

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

@@ -0,0 +1,64 @@
+---
+title: Testing Objects for Properties
+localeTitle: Prueba de objetos para propiedades
+---
+## Prueba de objetos para propiedades
+
+Aquí está el ejemplo:
+
+```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"); 
+```
+
+Aquí hay una solución:
+
+Aquí no cambiamos nada:
+
+```javascript
+// Setup 
+ var myObj = { 
+  gift: "pony", 
+  pet: "kitten", 
+  bed: "sleigh" 
+ }; 
+```
+
+Además, en el cuerpo de la función usamos el método de objetos `.hasOwnProperty(propname)` para determinar si ese objeto tiene el nombre de propiedad dado. `if/else` declaración `if/else` con valores booleanos nos ayudará en esto:
+
+```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 volver "No encontrado" } }
+```
+Now, you can change `checkObj` values: 
+```
+
+javascript // Prueba tu código modificando estos valores checkObj ("regalo");
+```
+Here's a full solution: 
+```
+
+javascript función checkObj (checkProp) { // Tu Código Aquí if (myObj.hasOwnProperty (checkProp) == true) { return myObj \[checkProp\]; } else { volver "No encontrado" } } // Prueba tu código modificando estos valores checkObj ("regalo"); \`\` \`

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

@@ -0,0 +1,9 @@
+---
+title: Understand String Immutability
+localeTitle: Entender la inmutabilidad de la cuerda
+---
+## Entender la inmutabilidad de la cuerda
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/certifications/javascript-algorithms-and-data-structures/basic-javascript/understand-string-immutability/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) .

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

@@ -0,0 +1,42 @@
+---
+title: Understanding Boolean values
+localeTitle: Entendiendo los valores booleanos
+---
+## Entendiendo los valores booleanos
+
+### Explicación del problema:
+
+Modifique la función `welcomeToBooleans` para que devuelva `true` lugar de `false` cuando se haga clic en el botón Ejecutar.
+
+### Sugerencia 1
+
+Solo necesita editar la línea 5 para que la función devuelva `true` lugar de `false` .
+
+> _intenta resolver el problema ahora_
+
+## ¡Alerta de spoiler!
+
+**¡Solución por delante!**
+
+## ![:beginner:](https://forum.freecodecamp.com/images/emoji/emoji_one/beginner.png?v=3 ":principiante:") Solución de código básico:
+
+```javascript
+function welcomeToBooleans() { 
+ 
+ // Only change code below this line. 
+ 
+ return true; // Change this line 
+ 
+ // Only change code above this line. 
+ } 
+```
+
+### Explicación del código
+
+Solo modificando el valor `Boolean` que no desea que la función devuelva de `false` a `true` cumplirá con los requisitos.
+
+### Recursos
+
+[Glosario MDN - Booleano](https://developer.mozilla.org/en-US/docs/Glossary/Boolean)
+
+[Wikipedia - Tipo de datos booleano](https://en.wikipedia.org/wiki/Boolean_data_type)

guide/spanish/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: Entender la sensibilidad de los casos en variables
+---
+## Entender la sensibilidad de los casos en variables
+
+Una norma de programación popular es utilizar el **caso Camel** al crear nombres de variables. Observe que la primera palabra es minúscula y cada palabra siguiente está en mayúscula. Aquí hay unos ejemplos:
+```
+var camelCase; 
+ var someNumber; 
+ var theBestVariableEver; 
+ var weWillStoreNumbersInThisVariable; 
+
+```

guide/spanish/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: Entendiendo el valor indefinido devuelto por una función
+---
+## Entendiendo el valor indefinido devuelto por una función
+
+Una función sin declaración de `return` , tiene una salida `undefined` . Por lo tanto, si intenta igualar una variable a la salida de una función sin declaración de `return` , esa variable será igual a `undefined` .
+
+Adelante, define `addFive()` así ...
+
+```javascript
+function addFive() { 
+  sum += 5; 
+ } 
+```
+
+Como puede ver, la `sum` se agrega por 5 sin problemas, pero como no hay una declaración de retorno, hay un resultado `undefined` .
+
+```javascript
+var result = addFive(); // This is undefined 
+
+```

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

@@ -0,0 +1,7 @@
+---
+title: Understanding Uninitialized Variables
+localeTitle: Entendiendo las variables sin inicializar
+---
+## Entendiendo las variables sin inicializar
+
+Asegúrese de que la variable tenga el valor de datos correcto. Si deja una variable sin inicializar, lo que significa que no le asigna un valor, puede causar problemas si desea realizar operaciones en ella.

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

@@ -0,0 +1,28 @@
+---
+title: Updating Object Properties
+localeTitle: Actualización de las propiedades del objeto
+---
+## Actualización de las propiedades del objeto
+
+## Insinuación:
+
+Usa el punto \*\*. \*\* Notación para acceder a la propiedad objeto.
+
+## Alerta de Spoiler: ¡Solución por delante!
+
+## Solución:
+
+```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/spanish/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: Usa la notación de corchete para encontrar el primer personaje en una cadena
+---
+## Usa la notación de corchete para encontrar el primer personaje en una cadena
+
+Recuerde que el primer carácter de una cadena está en la posición cero. Por ejemplo:
+```
+var str = "Hello"; 
+ var letter = str[0]; // This equals "H" 
+
+```

guide/spanish/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 la notación de corchete para encontrar el último carácter en una cadena
+---
+## Use la notación de corchete para encontrar el último carácter en una cadena
+
+Considera la siguiente cadena:
+```
+var str = "Coding"; 
+```
+
+Esta cadena tiene una longitud de 6 caracteres, por lo que si usa .length en la cadena, le dará 6. Pero recuerde que el primer carácter está en la posición cero. El segundo personaje está en la primera posición. El tercer personaje está en la segunda posición.
+
+Continúa, y eventualmente obtendrás que el sexto carácter (que, basado en la cadena anterior, es 'g') está en la quinta posición. Es por eso que obtienes el último carácter de una cadena, con:
+```
+var lastChar = str[str.length - 1]; // This is 6 - 1, which is 5 
+```
+
+Esto será 'g'.

guide/spanish/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: Usa la notación de corchete para encontrar el enésimo carácter de una cadena
+---
+## Usa la notación de corchete para encontrar el enésimo carácter de una cadena
+
+Recuerde que el primer carácter de una cadena está en la posición 0-th. Así que el segundo personaje debe estar en la 1ª posición. Entonces el tercer personaje, debe estar en el ... hmmm?

guide/spanish/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 la notación de corchete para encontrar el carácter Nth-to-Last en una cadena
+---
+## Use la notación de corchete para encontrar el carácter Nth-to-Last en una cadena
+
+Recuerde que la posición de cualquier carácter, es la **longitud de la cadena, menos uno, menos el número de caracteres después de ella** . Por ejemplo, si está tratando de encontrar el tercer a último carácter de la siguiente cadena:
+```
+var str = "Programming"; 
+ var secondToLastChar = str[str.length - 2]; // This is 'i' 
+```
+
+Como puede ver, hay un carácter adicional después de 'n' (y eso es 'g').