Finished second translation of spanish version (#211)

* Empiezo nueva traducción.

* Traducción de file-system, split y substring. Corrección de errores.

* Traducidas README.md, arrow-functions.md, let-const.md y map.md

* Corrección menor para sintaxis markdown.

* Terminda traducción hoisting, template-literals y destructuring. Agregadas páginas reverse y slice.

* - Traducidas páginas reverse y slice.
- Terminada la segunda traducción

* File jakarta.jpg no necesario

Author: hamfree

es/Credits.md

@@ -0,0 +1,25 @@
+---
+pageNumber: VI
+chapter: 
+---
+
+### Mantenedor
+
+---
+<!-- markdownlint-disable MD033 -->
+<table>
+  <tr>
+    <td align="center">
+      <a href="https://github.com/sumn2u">
+        <img src="https://avatars.githubusercontent.com/u/6531541?v=4" alt="Profile Picture" style="border-radius: 50%; width: 100px; height: 100px;" />
+        <br/>
+        <sub><b>Suman Kunwar</b></sub>
+      </a>
+    </td>
+  </tr>
+</table>
+
+### Colaboradores
+
+---
+![Colaboradores](../.gitbook/assets/contributors.png)

es/SUMMARY.md

@@ -18,6 +18,9 @@
   - [Replace](strings/replace.md)
   - [Length](strings/length.md)
   - [Concatenación](strings/concat.md)
+  - [Split](strings/split.md)
+  - [CharAt](strings/charAt.md)
+  - [Substring](strings/substring.md)
 - [Lógica condicional](conditional/README.md)
   - [If](conditional/if.md)
   - [Else](conditional/else.md)
@@ -29,13 +32,15 @@
   - [Map](arrays/map.md)
   - [Spread](arrays/spread.md)
   - [Shift](arrays/shift.md)
-  - [Pop)](arrays/pop.md)
+  - [Pop](arrays/pop.md)
   - [Join](arrays/join.md)
   - [Length](arrays/length.md)
   - [Push](arrays/push.md)
   - [For Each](arrays/for-each.md)
   - [Sort](arrays/sort.md)
   - [Índices](arrays/indices.md)
+  - [Reverse](arrays/reverse.md)
+  - [Slice](arrays/slice.md)
 - [Bucles](loops/README.md)
   - [For](loops/for.md)
   - [While](loops/while.md)
@@ -47,7 +52,7 @@
   - [Mutable](objects/mutable.md)
   - [Referencia](objects/reference.md)
   - [Prototype](objects/prototype.md)
-  - [Delete](objects/delete.md)
+  - [Operador Delete](objects/delete.md)
   - [Enumeración](objects/enumeration.md)
 - [Fecha y hora](date-and-time.md)
 - [JSON](json.md)
@@ -80,11 +85,11 @@
   - [Lista enlazada](miscellaneous/linked-list.md)
   - [Huella global](miscellaneous/global-footprint.md)
   - [Depuración](miscellaneous/debugging.md)
+  - [Creación e implementación de aplicaciones JS](miscellaneous/building-and-deploying.md)
   - [Retrollamadas](miscellaneous/callback.md)
   - [IPA Web y AJAX](miscellaneous/api-ajax.md)
   - [Naturaleza de un solo hilo](./miscellaneous/single-thread-nature.md)
   - [ECMAScript](miscellaneous/ECMA-script.md)
-  - [Creación e implementación de aplicaciones JS](miscellaneous/building-and-deploying.md)
   - [Pruebas](miscellaneous/testing.md)
 - [Código del lado del servidor](server-side/README.md)
   - [Node.js](server-side/nodejs.md)
@@ -100,12 +105,21 @@
   - [Objetos](exercises/objects.md)
   - [Problema de FizzBuzz](exercises/fizzbuzz-problem.md)
   - [¡Consigue los títulos!](exercises/get-the-titles.md)
-- [Preguntas de entrevista](interview-questions/README.md)
+- [Preguntas de entrevista (Sección de Bonificación)](interview-questions/README.md)
   - [Nivel básico](interview-questions/basic-level.md)
   - [Nivel intermedio](interview-questions/intermediate-level.md)
   - [Nivel avanzado](interview-questions/advance-level.md)
-- [Patrones de diseño](design-patterns/README.md)
+- [Patrones de diseño (Sección de Bonificación)](design-patterns/README.md)
   - [Patrones creacionales](design-patterns/creational-patterns.md)
   - [Patrones estructurales](design-patterns/structural-patterns.md)
   - [Patrones conductuales](design-patterns/behavioral-patterns.md)
+- [Sistema de Ficheros  (Sección de Bonificación)](file-system/README.md)
+- [Conceptos de ES6  (Sección de Bonificación)](es6-concepts/README.md)
+  - [Let Const](es6-concepts/let-const.md)
+  - [Map](es6-concepts/map.md)
+  - [Funciones flecha](es6-concepts/arrow-functions.md)
+  - [Desestructurando](es6-concepts/destructuring.md)
+  - [Literales de plantilla](es6-concepts/template-literals.md)
 - [Referencias](References.md)
+- [Recursos](resources.md)
+- [Créditos](Credits.md)

es/arrays/reverse.md

@@ -0,0 +1,40 @@
+---
+chapter: 6
+pageNumber: 59 
+description:  Para agregar un elemento al comienzo de una matriz podemos usar el método inverso. Modifica la matriz original y devuelve la nueva longitud de la matriz.
+---
+# Reverse
+
+El método `reverse` se puede utilizar en cualquier tipo de matriz, incluidas matrices de cadenas, matrices de números y matrices de objetos. Por ejemplo.
+
+```javascript
+let usuarios = [{
+  nombre: "John Smith",
+  edad: 30
+}, {
+  nombre: "Jane Doe",
+  edad: 25
+}];
+
+usuarios.reverse();
+
+console.log(usuarios);
+
+// RESULTADO: 
+[{
+  nombre: "Jane Doe",
+  edad: 25
+}, {
+  nombre: "John Smith",
+  edad: 30
+}];
+```
+
+El método `reverse` transpone los elementos del objeto de matriz que llama en su lugar, mutando la matriz y devolviendo una referencia a la matriz.
+A continuación se muestra un ejemplo del uso de `reverse` de una matriz:
+
+```javascript
+const numeros = [1, 2, 3];
+const nuevaLongitud = numeros.reverse();
+console.log(numeros); // [3, 2, 1]
+```

es/arrays/slice.md

@@ -0,0 +1,54 @@
+---
+chapter: 6
+pageNumber: 60 
+description:  El método Javascript arr.slice() devuelve una nueva matriz que contiene una parte de la matriz en la que se implementa. El original permanece sin cambios.
+---
+# Slice
+
+El método `slice` acepta dos parametros inicio y fin.
+
+* inicio: Este parámetro define el índice inicial desde donde la porción va a ser extraída.
+Si este argumento se pierde entonces el método tomca como inicio el 0 como valor de inicio por defecto.
+
+* final: Este parámetro es el índice hasta el cual se extraerá la porción (excluyendo el índice final).
+
+  Si este argumento no está definido, entonces se extrae la matriz hasta el final, ya que es el valor final predeterminado. Si el valor final es mayor que la longitud de la matriz, entonces el valor final cambia a la longitud de la matriz.
+
+```javascript
+function func() {
+    //Matriz original
+    let arr = [23, 56, 87, 32, 75, 13];
+    //Matrix extraído
+    let nuevo_arr = arr.slice();
+    console.log(arr);
+    console.log(nuevo_arr);
+}
+func();
+
+
+// RESULTADO: 
+[23,56,87,32,75,13]
+[23,56,87,32,75,13]
+```
+
+El método `slice()` copia las referencias de objetos a la nueva matriz.
+(Por ejemplo, una matriz anidada). Entonces, si se modifica el objeto al que se hace referencia, los cambios son visibles en la nueva matriz devuelta.
+
+```javascript
+let humano = {
+  nombre: "David",
+  edad: 23,
+};
+
+let arr = [humano, "Nepal", "Gestor"];
+let nuevo_arr = arr.slice();
+
+// objeto original
+console.log(arr[0]); // { nombre: 'David', edad: 23 }
+
+// hacemos cambios al objeto en la nueva matriz
+nuevo_arr[0].nombre = "Levy";
+
+// los cambios se ven reflejados
+console.log(arr[0]); // { nombre: 'Levy', edad: 23 }
+```

es/es6-concepts/README.md

@@ -0,0 +1,33 @@
+---
+layout: editorial
+chapter: 25
+pageNumber: 244
+description: Las clases son plantillas para crear un objeto. Encapsula datos con código para trabajar con datos. La palabra clave class se utiliza para crear una clase. 
+---
+
+
+# Capítulo 25
+
+## Descripción general de ES6 (ECMAScript 2015)
+
+ES6, también conocido como ECMAScript 2016, es una actualización significativa al lenguaje JavaScript. Introduce un montón de nuevas características, sintaxis perfeccionada, y mejoras, convirtiéndolo en un hito fundamental en la evolución de JavaScript. ES6 generó un lenguaje más maduro y potente, que abordó desafíos de larga data y permitió a los desarrolladores escribir código más limpio, más eficiente y fácil de mantener.
+
+Uno de los objetivos principales de ES6 era proporcionar a los desarrolladores herramientas para simplificar las tareas comunes de programación, reducir la complejidad del código, y mejorar la calidad general del código. Ha conseguido esto introduciendo numerosas características y conceptos que se han convertido en estándar en el desarrollo moderno de JavaScript.
+
+ES6 incluye características notables tales como las funciones flecha, las palabras clave `let` y `const` para la declaración de variables, los literales de plantilla, y la poderosa sintaxis `class` para la programación orientada a objetos. Estas mejoras mejoran significativamente la productividad de los desarrolladores y la legibilidad del código.
+
+Adicionalmente, ES6 introduce conceptos como las Promesas (Promises, en inglés) y async/await, que agilizan la programación asíncrona, haciéndola más elegante y menos propensa a errores. Esta simplificación del código asíncrono ha tenido un impacto profundo en el desarrollo web y ha llevado a una forma más intuitiva de manejar operaciones asíncronas, como las solicitudes HTTP.
+
+Las funciones de flecha en ES6 ofrecen una sintaxis concisa para escribir funciones, y vinculan automáticamente el contexto `this` al código circundante, lo cual alivia los problemas con el enlazado de `this` en JavaScript. La introducción de declaraciones de variables de alcance de bloque con `let`y `const` han mejorado la gestión y alcance de las variables, reduciendo fuentes comunes de errores.
+
+Los literales de plantilla proporcionan una manera conveniente de crear cadenas dinámicas con expresiones incrustadas, mientras que la desestructuración simplifica la extracción de valores de matrices y objetos, lo que genera un código más limpio y legible.
+
+En general, ES6 se ha convertido en la piedra angular del desarrollo moderno de JavaScript. Tiene buen soporte en los navegadores web modernos y ha remodelado la forma en que los desarrolladores escriben código JavaScript. Comprender ES6 es crucial para cualquier desarrollador de JavaScript que busque mantenerse actualizado y escribir código más eficiente, mantenible y legible en el panorama de desarrollo web actual.
+
+En este capítulo, vamos a hablar sobre la siguiente sintaxis de ES6.
+
+* [let const](./let-const.md)
+* [Objeto map](./map.md)
+* [Funciones flecha](./arrow-functions.md)
+* [Desestructuración](./destructuring.md)
+* [Literales de plantilla](./template-literals.md)

es/es6-concepts/arrow-functions.md

@@ -0,0 +1,85 @@
+---
+chapter: 25
+pageNumber: 248
+description:  Las funciones de flecha, introducidas en ES6, proporcionan una sintaxis concisa para definir funciones en JavaScript. Son ideales para funciones cortas de una sola expresión y ofrecen simplicidad y claridad, a menudo se usan para iterar sobre matrices y definir funciones de devolución de llamada compactas. Las funciones de flecha son conocidas por su eficiencia y legibilidad.
+
+---
+# Funciones flecha en ES6
+
+Las funciones de flecha son una forma concisa de escribir funciones anónimas en JavaScript, introducidas en ES6 (ECMAScript 2015). Proporcionan una sintaxis más compacta y legible para definir funciones, especialmente cuando tiene funciones simples de una sola expresión. Las funciones de flecha son una característica fundamental del JavaScript moderno y ofrecen varias ventajas sobre las expresiones de funciones tradicionales.
+
+**Sintaxis:**
+
+La sintaxis de las funciones de flecha es sencilla:
+
+```javascript
+const nombreFuncion = (parametros) => expresion;
+```
+
+1. `const nombreFuncion`: Aquí es donde asignas la función a una variable. Puede omitir el nombre de la función para funciones anónimas.
+
+2. `(parametros)`: Estos son los parámetros de entrada (argumentos) que acepta la función. Si solo hay un parámetro, puede omitir los paréntesis.
+
+3. `=>`: La flecha gruesa `=>` indica que está definiendo una función de flecha.
+
+4. `expresion`: Este es el valor que devuelve la función. Si la función consta de una sola declaración, puede omitir las llaves y la palabra clave `return`.
+
+**Ejemplos:**
+
+A continuación se muestran algunos ejemplos para ilustrar la sintaxis de las funciones de flecha:
+
+1. Una función de flecha simple sin parámetros:
+
+   ```javascript
+   const diHola = () => "¡Hola, mundo!";
+   ```
+
+2. Una función de flecha con un parámetro:
+
+   ```javascript
+   const doblar = (x) => x * 2;
+   ```
+
+3. Una función de flecha con múltiples parámetros:
+
+   ```javascript
+   const sumar = (a, b) => a + b;
+   ```
+
+**Casos de uso:**
+
+Las funciones de flecha se usan comúnmente en los siguientes escenarios:
+
+1. **Funciones anónimas y cortas:** Las funciones de flecha son perfectas para funciones cortas de una línea. Reducen la necesidad de escribir una expresión de función completa.
+
+2. **Iteración de matrices:** Las funciones de flecha funcionan bien con métodos de matriz como `map`, `filter` y `reduce` para simplificar la iteración sobre matrices.
+
+   ```javascript
+   const numeros = [1, 2, 3, 4, 5];
+   const doblados = numbers.map((x) => x * 2);
+   ```
+
+3. **Funciones de retrollamada:** A menudo se utilizan como funciones de devolución de llamada para operaciones asincrónicas como `setTimeout` y `fetch`.
+
+   ```javascript
+   setTimeout(() => {
+     console.log("Temporizador terminado");
+   }, 1000);
+   ```
+
+4. **Vinculación del contexto `this`:** Las funciones de flecha heredan el contexto `this` de su función contenedora, lo que las hace útiles para definir métodos en objetos sin preocuparse por cambiar `this`.
+
+```javascript
+const persona = {
+  nombre: "Juan",
+  saludar: function() {
+    setTimeout(() => {
+      console.log(`Hola, mi nombre es ${this.nombre}`);
+    }, 1000);
+  },
+};
+
+persona.saludar();
+```
+
+Es importante tener en cuenta que las funciones de flecha no son adecuadas para todas las situaciones. Carecen de su propio contexto `this`, no pueden usarse como constructores y pueden no ser apropiadas para funciones con una estructura multilínea más compleja. En tales casos, las expresiones de funciones tradicionales siguen siendo la opción preferida. Las funciones de flecha son más efectivas cuando se usan para funciones simples, concisas y de una sola línea.

es/es6-concepts/destructuring.md

@@ -0,0 +1,63 @@
+---
+chapter: 25
+pageNumber: 250
+description: La desestructuración, una característica de ES6, agiliza la extracción de datos de matrices y objetos. Simplifica el proceso al permitirle asignar valores o propiedades específicas directamente a las variables, lo que mejora la claridad y la eficiencia del código. La desestructuración es una herramienta esencial para trabajar con estructuras de datos complejas en JavaScript.
+
+---
+# Desestructuración en ES6: descomprimiendo matrices y objetos
+
+La desestructuración es una característica poderosa introducida en ES6 (ECMAScript 2015) que simplifica el proceso de extracción de valores de matrices y propiedades de objetos. Le permite "desempaquetar" valores en variables con una sintaxis concisa y legible.
+
+**Desestructuración de matrices:**
+
+**Sintaxis:**
+
+```javascript
+const [variable1, variable2, ...resto] = matriz;
+```
+
+- `variable1`, `variable2`: Estas son variables donde se asignan elementos de la matriz.
+- `...resto` (operador resto): Esto reúne los elementos restantes en una nueva variable de matriz.
+
+**Ejemplo:**
+
+```javascript
+const colores = ["rojo", "verde", "azul"];
+const [primerColor, segundoColor] = colores;
+console.log(primerColor); // Salida: "rojo"
+console.log(segundoColor); // Salida: "verde"
+```
+
+**Desestructuración de objetos:**
+
+**Sintaxis:**
+
+```javascript
+const { propiedad1, propiedad2, ...resto } = objeto;
+```
+
+- `propiedad1`, `propiedad2`: Estas son variables donde se asignan las propiedades del objeto.
+- `...resto` (operador resto): Esto reúne las propiedades restantes en un nuevo objeto.
+
+**Ejemplo:**
+
+```javascript
+const persona = { nombre: "Alicia", edad: 30, ciudad: "Nueva York" };
+const { nombre, edad } = persona;
+console.log(nombre); // Salida: "Alicia"
+console.log(edad); // Salida: 30
+```
+
+**Casos de uso:**
+
+La desestructuración se usa comúnmente para diversas tareas, que incluyen:
+
+1. **Simplificación de la tarea:** Asignar rápidamente elementos de matriz o propiedades de objetos a variables.
+
+2. **Intercambio de variables:** Intercambiar fácilmente los valores de dos variables sin una variable temporal.
+
+3. **Parámetros de función:** Extraer propiedades específicas de un objeto pasado como un parámetro de función.
+
+4. **Otros parámetros:** Reúna los elementos o propiedades restantes en una matriz u objeto.
+
+Al emplear la desestructuración, puede hacer que su código sea más limpio, más expresivo y menos propenso a errores al trabajar con matrices y objetos en JavaScript.