fix(guide): simplify directory structure

guide/spanish/javascript/standard-objects/string/index.md

@@ -0,0 +1,13 @@
+---
+title: String
+localeTitle: Cuerda
+---
+## Cuerda
+
+En JavaScript, el objeto global `String` es un constructor para cadenas, que almacena series de caracteres. Las cadenas se pueden crear en forma de literales, como `var greeting = "Hi, campers!";` o usando el constructor de `String` : `var greeting = new String("Hi, campers!");` .
+
+A diferencia de otros idiomas, JavaScript no le importa si se utiliza sola `' '` o dobles `" "` cotizaciones de cuerdas. Incluso puedes usarlos _dentro de_ las cuerdas, solo tienen que ser diferentes de las comillas que abrazan la cadena `"Isn't that awesome?"` .
+
+#### Más información:
+
+[Documentos web de MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String) [w3schools.com](https://www.w3schools.com/jsref/jsref_obj_string.asp)

guide/spanish/javascript/standard-objects/string/string-fromcharcode/index.md

@@ -0,0 +1,35 @@
+---
+title: String fromCharCode
+localeTitle: Cadena fromCharCode
+---
+El `String.fromCharCode()` estático `String.fromCharCode()` devuelve una cadena creada utilizando la secuencia especificada de valores Unicode.
+
+## Sintaxis
+```
+String.fromCharCode(num1[, ...[, numN]]) 
+```
+
+### Parámetros
+
+**num1,…, numN**
+
+Una secuencia de números que son valores de Unicode.
+
+[Enlace MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCharCode) | [Enlace MSDN](https://msdn.microsoft.com/en-us/LIBRary/wb4w0k66%28v=vs.94%29.aspx)
+
+## Descripción
+
+Este método devuelve una cadena y no un objeto de cadena.
+
+Debido a que `fromCharCode()` es un método estático de String, siempre lo utiliza como `String.fromCharCode()` , en lugar de como un método de un objeto String que creó.
+
+## Ejemplos
+```
+String.fromCharCode(65, 66, 67);  // "ABC" 
+ 
+ var test = String.fromCharCode(112, 108, 97, 105, 110); 
+ document.write(test); 
+ 
+ // Output: plain 
+
+```

guide/spanish/javascript/standard-objects/string/string-fromcodepoint/index.md

@@ -0,0 +1,11 @@
+---
+title: String Fromcodepoint
+localeTitle: Cadena de punto de punta
+---
+## Cadena de punto de punta
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/javascript/standard-objects/string/string-fromcodepoint/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/javascript/standard-objects/string/string-length/index.md

@@ -0,0 +1,49 @@
+---
+title: String Length
+localeTitle: Longitud de la cuerda
+---
+La propiedad `length` representa la longitud de una cadena.
+
+## Sintaxis
+```
+str.length 
+```
+
+[Enlace MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/length) | [Enlace MSDN](https://msdn.microsoft.com/en-us/LIBRary/3d616214%28v=vs.94%29.aspx)
+
+## Descripción
+
+Esta propiedad devuelve el número de unidades de código en la cadena. UTF-16, el formato de cadena utilizado por JavaScript, utiliza una sola unidad de código de 16 bits para representar los caracteres más comunes, pero necesita usar dos unidades de código para los caracteres menos usados ​​comúnmente, por lo que es posible que el valor devuelto por longitud no coincide con el número real de caracteres en la cadena.
+
+Para una cadena vacía, la longitud es 0.
+
+La propiedad estática `String.length` devuelve el valor 1.
+
+## Ejemplos
+```
+var x = 'Mozilla'; 
+ var empty = ''; 
+ 
+ console.log('Mozilla is ' + x.length + ' code units long'); 
+ /* "Mozilla is 7 code units long" */ 
+ 
+ console.log('The empty string has a length of ' + empty.length); 
+ /* "The empty string has a length of 0" */ 
+ 
+ var str = "every good boy does fine"; 
+        var start = 0; 
+        var end = str.length - 1; 
+        var tmp = ""; 
+        var arr = new Array(end); 
+ 
+        while (end >= 0) { 
+            arr[start++] = str.charAt(end--); 
+        } 
+ 
+ // Join the elements of the array with a 
+        var str2 = arr.join(''); 
+        document.write(str2); 
+ 
+ // Output: enif seod yob doog yreve 
+
+```

guide/spanish/javascript/standard-objects/string/string-prototype-charat/index.md

@@ -0,0 +1,40 @@
+---
+title: String.prototype.charAt
+localeTitle: String.prototype.charAt
+---
+El método `charAt()` devuelve el carácter especificado de una cadena.
+
+## Sintaxis
+```
+str.charAt(index) 
+```
+
+## Parámetros
+
+**índice**
+
+Un entero entre 0 y 1 menos que la longitud de la cadena.
+
+[Enlace MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/charAt) | [Enlace MSDN](https://msdn.microsoft.com/en-us/LIBRary/65zt5h10%28v=vs.94%29.aspx)
+
+## Descripción
+
+Los caracteres en una cadena se indexan de izquierda a derecha. El índice del primer carácter es 0, y el índice del último carácter en una cadena llamada `stringName` es `stringName.length - 1` . Si el índice que proporciona está fuera de rango, JavaScript devuelve una cadena vacía.
+
+## Ejemplos
+```
+var anyString = 'Brave new world'; 
+ 
+ console.log("The character at index 0   is '" + anyString.charAt(0)   + "'"); // 'B' 
+ console.log("The character at index 1   is '" + anyString.charAt(1)   + "'"); // 'r' 
+ console.log("The character at index 2   is '" + anyString.charAt(2)   + "'"); // 'a' 
+ console.log("The character at index 3   is '" + anyString.charAt(3)   + "'"); // 'v' 
+ console.log("The character at index 4   is '" + anyString.charAt(4)   + "'"); // 'e' 
+ console.log("The character at index 999 is '" + anyString.charAt(999) + "'"); // '' 
+ 
+ var str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; 
+ document.write(str.charAt(str.length - 1)); 
+ 
+ // Output: Z 
+
+```

guide/spanish/javascript/standard-objects/string/string-prototype-charcodeat/index.md

@@ -0,0 +1,35 @@
+---
+title: String.prototype.charCodeAt
+localeTitle: String.prototype.charCodeAt
+---
+El método `charCodeAt()` devuelve el valor numérico Unicode del carácter en el índice dado (excepto para puntos de código Unicode> 0x10000).
+
+## Sintaxis
+```
+str.charCodeAt(index) 
+```
+
+### Parámetros
+
+**índice**
+
+Un entero mayor o igual que 0 y menor que la longitud de la cadena; si no es un número, el valor predeterminado es 0.
+
+[Enlace MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/charCodeAt) | [Enlace MSDN](https://msdn.microsoft.com/en-us/LIBRary/hza4d04f%28v=vs.94%29.aspx)
+
+## Descripción
+
+Tenga en cuenta que `charCodeAt()` siempre devolverá un valor inferior a 65536. Esto se debe a que los puntos de código más altos están representados por un par de pseudo-caracteres "sustitutos" (valor inferior) que se utilizan para comprender el carácter real. Debido a esto, para examinar o reproducir el carácter completo para caracteres individuales de valor 65536 y superior, para tales caracteres, es necesario recuperar no solo `charCodeAt(i)` , sino también `charCodeAt(i+1)` (como si examinara / Reproduciendo una cuerda con dos letras). Vea los ejemplos 2 y 3 a continuación.
+
+`charCodeAt()` devuelve `NaN` si el `index` dado es menor que 0 o es igual o mayor que la longitud de la cadena.
+
+## Ejemplos
+```
+'ABC'.charCodeAt(0); // returns 65 
+ 
+ var str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; 
+ document.write(str.charCodeAt(str.length - 1)); 
+ 
+ // Output: 90 
+
+```

guide/spanish/javascript/standard-objects/string/string-prototype-codepointat/index.md

@@ -0,0 +1,11 @@
+---
+title: String.prototype.codePointAt
+localeTitle: String.prototype.codePointAt
+---
+## String.prototype.codePointAt
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/javascript/standard-objects/string/string-prototype-codepointat/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/javascript/standard-objects/string/string-prototype-concat/index.md

@@ -0,0 +1,37 @@
+---
+title: String.prototype.concat
+localeTitle: String.prototype.concat
+---
+El método concat () combina el texto de dos o más cadenas y devuelve una nueva cadena.
+
+**Sintaxis**
+```
+str.concat(string2[,..., stringN]); 
+```
+
+## Parámetros
+
+**string2… string _N_** Las cadenas que deben ser concatenadas a esta cadena.
+
+[Enlace MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/concat)
+
+## Descripción
+
+El método concat () combina el texto de dos o más cadenas y devuelve la cadena concatenada. No modifica las cuerdas originales.
+
+## Ejemplos
+
+**Cuerdas de concatenacion**
+
+```JavaScript
+    var str1 = "Hello"; 
+    var str2 = "World"; 
+    console.log(str1.concat(str2)); 
+    // Console will output: HelloWorld 
+ 
+    var str2 = "Hello, "; 
+    console.log(str2.concat(" Welcome ", "to FCC.")); 
+    // Console will output: Hello, Welcome to FCC. 
+```
+
+Fuente \[MDN\]

guide/spanish/javascript/standard-objects/string/string-prototype-endswith/index.md

@@ -0,0 +1,24 @@
+---
+title: String.prototype.endsWith
+localeTitle: String.prototype.endsWith
+---
+## String.prototype.endsWith
+
+El método `endsWith()` verifica si la cadena termina con su entrada de cadena y devuelve un valor booleano.
+
+### Por ejemplo
+
+```js
+let str = "Hello world"; 
+ let bool = str.endsWith("ld") // true 
+ bool = str.endsWith("llo") // false 
+```
+
+Este método también puede aceptar otro parámetro, la `length` que determina antes de qué carácter buscar la cadena.
+
+```js
+let str = "Hello world"; 
+ let bool = str.endsWith("ld", 5) // false, it's the same as "Hello".endsWith("ld") 
+ bool = str.endsWith("llo", 5) // true, it's the same as "Hello".endsWith("llo") 
+
+```

guide/spanish/javascript/standard-objects/string/string-prototype-includes/index.md

@@ -0,0 +1,59 @@
+---
+title: String.prototype.includes
+localeTitle: String.prototype.includes
+---
+## String.prototype.includes
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/javascript/standard-objects/string/string-prototype-includes/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) .
+
+La `includes()` método se utiliza para determinar si o no una cadena se puede encontrar en otra cadena. Este método devuelve un valor booleano (ya sea `true` o `false` ).
+
+Es importante tener en cuenta que este método distingue entre mayúsculas y minúsculas.
+
+**Sintaxis**
+
+```js
+string.includes(searchString[, position]) 
+```
+
+**Parámetros**
+
+Este método requiere solo un parámetro (searchString). Sin embargo, mediante la inclusión de un segundo parámetro (posición), puede comenzar la búsqueda de una cadena dentro de una cadena desde una posición específica (o índice) en el searchString que.
+
+**Ejemplos**
+
+```js
+let string = "Roses are red, violets are blue."; 
+ 
+ string.includes('red'); // returns true 
+```
+
+```javascript
+let string = "Roses are red, violets are blue."; 
+ 
+ string.includes('Red'); // returns false 
+```
+
+```javascript
+let string = "Roses are red, violets are blue."; 
+ 
+ string.includes('red',12); // returns false because 'red' starts at position 9, and our search begins at position 12. 
+```
+
+```javascript
+let string = "Roses are red, violets are blue."; 
+ 
+ string.includes('blue',12); // returns true because 'blue' starts after our search begins at position 12. 
+```
+
+```javascript
+let string = "Roses are red, violets are blue."; 
+ 
+ string.includes('violets are blue'); // returns true 
+```
+
+#### Más información:
+
+[MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes)

guide/spanish/javascript/standard-objects/string/string-prototype-indexof/index.md

@@ -0,0 +1,44 @@
+---
+title: String.prototype.indexOf
+localeTitle: String.prototype.indexOf
+---
+## String.prototype.indexOf
+
+El método `indexOf()` devuelve el primer índice en el que se puede encontrar un elemento determinado en la matriz. Si el elemento no está presente, devuelve -1.
+
+**Sintaxis**
+
+```javascript
+str.indexOf(searchValue[, fromIndex]) 
+```
+
+### Parámetros
+
+*   **searchValue** Substring que está buscando. Si esto está vacío ( `''` ) y no hay un parámetro `fromIndex` , devolverá 0.
+    
+*   **fromIndex** Opcional. El índice en el que desea iniciar la búsqueda. Si el valor `fromIndex` es mayor o igual que la longitud de la cadena, no se busca la cadena y el método devuelve -1. Si `searchValue` es una cadena vacía ( `''` ) y el `fromIndex` es menor que la longitud de la cadena, devolverá el `fromIndex` ; de lo contrario, devolverá la longitud de la cadena. (Un número negativo se tratará como si no hubiera ningún argumento).
+    
+
+### Descripción
+
+El método `indexOf()` verifica la cadena de izquierda a derecha. El índice del primer carácter es 0; El índice del último carácter es `string.length - 1` . El método `searchValue` cada subcadena con `searchValue` utilizando una igualdad estricta ( `===` ), lo que significa que este método `searchValue` mayúsculas y minúsculas. Una vez que encuentra una subcadena que devuelve `true` , devuelve el índice de su primer carácter.
+
+### Ejemplos
+
+```javascript
+'Blue Whale'.indexOf('Blue');     // returns  0 
+ 'Blue Whale'.indexOf('Blute');    // returns -1 
+ 'Blue Whale'.indexOf('Whale', 0); // returns  5 
+ 'Blue Whale'.indexOf('Whale', 5); // returns  5 
+ 'Blue Whale'.indexOf('Whale', 7); // returns -1 
+ 'Blue Whale'.indexOf('');         // returns  0 
+ 'Blue Whale'.indexOf('', 9);      // returns  9 
+ 'Blue Whale'.indexOf('', 10);     // returns 10 
+ 'Blue Whale'.indexOf('', 11);     // returns 10 
+ 'Blue Whale'.indexOf('blue');     // returns -1 
+```
+
+### Más información:
+
+*   Documentación [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf) : [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf)
+*   Documentación de [MSDN](https://docs.microsoft.com/en-us/scripting/javascript/reference/indexof-method-string-javascript) : [MSDN](https://docs.microsoft.com/en-us/scripting/javascript/reference/indexof-method-string-javascript)

guide/spanish/javascript/standard-objects/string/string-prototype-lastindexof/index.md

@@ -0,0 +1,11 @@
+---
+title: String.prototype.lastIndexOf
+localeTitle: String.prototype.lastIndexOf
+---
+## String.prototype.lastIndexOf
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/javascript/standard-objects/string/string-prototype-lastindexof/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/javascript/standard-objects/string/string-prototype-localecompare/index.md

@@ -0,0 +1,11 @@
+---
+title: String.prototype.localecompare
+localeTitle: String.prototype.localecompare
+---
+## String.prototype.localecompare
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/javascript/standard-objects/string/string-prototype-localecompare/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/javascript/standard-objects/string/string-prototype-match/index.md

@@ -0,0 +1,11 @@
+---
+title: String.prototype.match
+localeTitle: String.prototype.match
+---
+## String.prototype.match
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/javascript/standard-objects/string/string-prototype-match/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/javascript/standard-objects/string/string-prototype-normalize/index.md

@@ -0,0 +1,11 @@
+---
+title: String.prototype.normalize
+localeTitle: String.prototype.normalize
+---
+## String.prototype.normalize
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/javascript/standard-objects/string/string-prototype-normalize/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/javascript/standard-objects/string/string-prototype-padend/index.md

@@ -0,0 +1,11 @@
+---
+title: String.prototype.padEnd
+localeTitle: String.prototype.padEnd
+---
+## String.prototype.padEnd
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/javascript/standard-objects/string/string-prototype-padend/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/javascript/standard-objects/string/string-prototype-padstart/index.md

@@ -0,0 +1,11 @@
+---
+title: String.prototype.padStart
+localeTitle: String.prototype.padStart
+---
+## String.prototype.padStart
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/javascript/standard-objects/string/string-prototype-padstart/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/javascript/standard-objects/string/string-prototype-repeat/index.md

@@ -0,0 +1,21 @@
+---
+title: String.prototype.repeat
+localeTitle: String.prototype.repeat
+---
+## String.prototype.repeat
+
+El `.repeat(n)` obtiene un `.repeat(n)` entero y devuelve la cadena repetida `n` veces.
+
+### Por ejemplo
+
+```js
+  let str = "test"; 
+  console.log(str.repeat(3)); // "testtesttest", test is repeated 3 times 
+ 
+  // NB 
+  console.log(str.repeat(2.5)); // "testtest", 2.5 is converted to an integer and test is repeated 2 times 
+```
+
+#### Más información
+
+[MDN - String.prototype.repeat ()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/repeat)

guide/spanish/javascript/standard-objects/string/string-prototype-replace/index.md

@@ -0,0 +1,11 @@
+---
+title: String.prototype.replace
+localeTitle: String.prototype.replace
+---
+## String.prototype.replace
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/javascript/standard-objects/string/string-prototype-replace/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/javascript/standard-objects/string/string-prototype-search/index.md

@@ -0,0 +1,11 @@
+---
+title: String.prototype.search
+localeTitle: String.prototype.search
+---
+## String.prototype.search
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/javascript/standard-objects/string/string-prototype-search/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/javascript/standard-objects/string/string-prototype-slice/index.md

@@ -0,0 +1,47 @@
+---
+title: String.prototype.slice
+localeTitle: String.prototype.slice
+---
+El método de cadena de JavaScript `.slice()` extrae una parte de una cadena y devuelve una nueva cadena.
+
+## Sintaxis
+```
+str.slice(beginSliceIndex [, endSliceIndex]); 
+```
+
+## Parámetros
+
+**beginSliceIndex**
+
+El índice de base cero donde debe comenzar la división. Si beginSliceIndex es un número negativo, `.slice()` cuenta hacia atrás desde el final de la cadena para determinar dónde comenzar la división.
+
+**endSliceIndex**
+
+Opcional. El índice de base cero donde debe terminar la división. Si se omite, `.slice()` extrae hasta el final de la cadena.
+
+[Enlace MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/slice)
+
+## Descripción
+
+`.slice()` corta el texto de una cadena y devuelve una nueva cadena.
+
+## Ejemplos
+
+**Usando `.slice()` para crear una nueva cadena**
+```
+var string1 = "Hello World!"; 
+ var string2 = string1.slice(3); 
+ console.log(string2);                           // Will log "lo World!" 
+ 
+ var string3 = string1.slice(3, 7); 
+ console.log(string3);                           // Will log "lo W" 
+```
+
+**Utilizando `.slice()` con índices negativos**
+```
+var string = "Hello World!" 
+ str.slice(-3);                                  // Returns "ld!" 
+ str.slice(-3, -1);                              // Returns "ld" 
+ str.slice(0, -1);                               // Returns "Hello World" 
+
+```

guide/spanish/javascript/standard-objects/string/string-prototype-split/index.md

@@ -0,0 +1,40 @@
+---
+title: String.prototype.split
+localeTitle: String.prototype.split
+---
+## String.prototype.split
+
+La función `split()` separa una cadena original en subcadenas, en función de una _cadena separadora_ que se pasa como entrada.
+
+La salida de la función `split()` es una `Array` de cadenas, que representan las subcadenas separadas de la cadena original.
+
+La cadena original no es alterada por la función `split()` .
+
+Ejemplos:
+
+```js
+// We have a regular string 
+ "Hello. I am a string. You can separate me." 
+ 
+ // Let's use the split function to separate the string by the period character: 
+ "Hello. I am a string. You can separate me.".split("."); 
+ // output is [ "Hello", " I am a string", " You can separate me", "" ] 
+```
+
+Ya que usamos el período ( `.` ) Como la _cadena separadora_ , las cadenas en la matriz de salida no contienen el período en ellas; las cadenas separadas de salida _no incluyen la propia cadena de separador de entrada_ .
+
+El _separador de cadenas_ no tiene que ser un solo carácter, puede ser cualquier otra cadena:
+
+```js
+"Hello... I am another string... keep on learning!".split("..."); 
+ // output is [ "Hello", " I am another string", " keep on learning!" ] 
+ 
+ const names = "Kratos- Atreus- Freya- Hela- Thor- Odin"; 
+ // notice separator is a dash and a space 
+ names.split("- "); 
+ // output is [ "Kratos", "Atreus", "Freya", "Hela", "Thor", "Odin" ] 
+```
+
+#### Más información:
+
+*   [String.prototype.split en MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split)

guide/spanish/javascript/standard-objects/string/string-prototype-startswith/index.md

@@ -0,0 +1,11 @@
+---
+title: String.prototype.startsWith
+localeTitle: String.prototype.startsWith
+---
+## String.prototype.startsWith
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/javascript/standard-objects/string/string-prototype-startswith/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/javascript/standard-objects/string/string-prototype-substr/index.md

@@ -0,0 +1,33 @@
+---
+title: String.prototype.substr
+localeTitle: String.prototype.substr
+---
+## String.prototype.substr
+
+El método substr () extrae partes de una cadena, comenzando en el carácter en la posición especificada, y devuelve el número especificado de caracteres.
+
+#### Sintaxis
+
+```JavaScript
+  string.substr(start, length); 
+```
+
+#### Valores paramétricos
+
+| Parámetro | Descripción | | : ------------- | : ------------- | | inicio | **Necesario.** La posición donde comenzar la extracción. El primer carácter está en el índice 0. Si el _inicio_ es positivo y mayor que, o igual, a la longitud de la cadena, substr () devuelve una cadena vacía. Si _inicio_ es negativo, substr () lo usa como un índice de caracteres desde el final de la cadena. Si el _inicio_ es negativo o mayor que la longitud de la cadena, el inicio se establece en 0 | | longitud | **Opcional** El número de caracteres a extraer. Si se omite, extrae el resto de la cadena |
+
+#### Ejemplos:
+
+```JavaScript
+let str = "Hello world!"; 
+ let res = str.substr(1, 4); 
+```
+
+El resultado de res será:
+```
+ello 
+```
+
+#### Más información:
+
+[JavaScript String substr () Método](https://www.w3schools.com/jsref/jsref_substr.asp) .

guide/spanish/javascript/standard-objects/string/string-prototype-substring/index.md

@@ -0,0 +1,30 @@
+---
+title: String.prototype.substring
+localeTitle: String.prototype.substring
+---
+## String.prototype.substring
+
+La función `substring()` _extrae_ una secuencia de caracteres de otra cadena dada. No altera la cadena original.
+
+Se define la secuencia a extraer con un _índice de caracteres inicial y final_ . Estos índices se pasan a la función `substring()` como parámetros. La subcadena se forma a partir del carácter del índice de inicio hasta el carácter del índice final. Ambos índices se cuentan desde el principio de la cadena, a partir de `0` .
+
+Ejemplos:
+
+```js
+"Hello, campers".substring(7, 14); 
+ // output is "campers" 
+ 
+ "Hello, world".substring(0, 5); 
+ // output is "Hello" 
+```
+
+También puede omitir el último parámetro de índice de caracteres, y la secuencia de subcadenas se extraerá del índice de inicio hasta el final de la cadena. Ejemplo:
+
+```js
+"Hello, campers!".substring(7); 
+ // output is "campers!" 
+```
+
+#### Más información:
+
+*   [String.prototype.substring () en MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substring)

guide/spanish/javascript/standard-objects/string/string-prototype-tolocalelowercase/index.md

@@ -0,0 +1,11 @@
+---
+title: String.prototype.toLocaleLowerCase
+localeTitle: String.prototype.toLocaleLowerCase
+---
+## String.prototype.toLocaleLowerCase
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/javascript/standard-objects/string/string-prototype-tolocalelowercase/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/javascript/standard-objects/string/string-prototype-tolocaleuppercase/index.md

@@ -0,0 +1,11 @@
+---
+title: String.prototype.toLocaleUpperCase
+localeTitle: String.prototype.toLocaleUpperCase
+---
+## String.prototype.toLocaleUpperCase
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/javascript/standard-objects/string/string-prototype-tolocaleuppercase/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/javascript/standard-objects/string/string-prototype-tolowercase/index.md

@@ -0,0 +1,25 @@
+---
+title: String.prototype.toLowerCase
+localeTitle: String.prototype.toLowerCase
+---
+El método de matriz de JavaScript `.toLowerCase()` devolverá el valor de la cadena convertida a minúsculas. La cadena original no se cambia.
+
+**Sintaxis**
+
+```javascript
+  string.toLowerCase() 
+```
+
+## Ejemplos
+
+```javascript
+  var shout = "I AM SHOUTING VERY LOUDLY" 
+  var whisper = shout.toLowerCase() 
+ 
+  console.log(shout) // will return "I AM SHOUTING VERY LOUDLY" 
+  console.log(whisper) // will return "i am shouting very loudly" 
+```
+
+#### Más información:
+
+Fuente: [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase)

guide/spanish/javascript/standard-objects/string/string-prototype-tostring/index.md

@@ -0,0 +1,11 @@
+---
+title: String.prototype.toString
+localeTitle: String.prototype.toString
+---
+## String.prototype.toString
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/javascript/standard-objects/string/string-prototype-tostring/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/javascript/standard-objects/string/string-prototype-touppercase/index.md

@@ -0,0 +1,17 @@
+---
+title: String.prototype.toUpperCase
+localeTitle: String.prototype.toUpperCase
+---
+El método de JavaScript `.toUpperCase()` devuelve la misma cadena a la que se llamó, pero en mayúsculas.
+
+**Sintaxis**
+```
+str.toUpperCase() 
+```
+
+## Ejemplos
+```
+console.log("hello world".toUpperCase()); // Console will output "HELLO WORLD" 
+```
+
+Fuente [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase)

guide/spanish/javascript/standard-objects/string/string-prototype-trim/index.md

@@ -0,0 +1,22 @@
+---
+title: String.prototype.trim
+localeTitle: String.prototype.trim
+---
+## String.prototype.trim
+
+La función `trim()` elimina cualquier carácter de espacio en blanco tanto del principio como del final de una cadena dada. No modifica la cadena original; produce una nueva.
+
+Ejemplos:
+
+```js
+"  Hello, campers. I have spaces on both ends!  ".trim(); 
+ // output is "Hello, campers. I have spaces on both ends!" 
+```
+
+`trim()` no solo elimina los caracteres de espacio; elimina cualquier carácter de espacio en blanco, como pestañas, saltos de línea, espacios sin interrupción, etc.
+
+Esto es útil, por ejemplo, cuando desea procesar una entrada de texto de un usuario y es posible que hayan enviado una cadena con espacios al final que tal vez no desee.
+
+#### Más información:
+
+*   [String.prototype.trim () en MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/Trim)

guide/spanish/javascript/standard-objects/string/string-prototype-trimleft/index.md

@@ -0,0 +1,11 @@
+---
+title: String.prototype.trimLeft
+localeTitle: String.prototype.trimLeft
+---
+## String.prototype.trimLeft
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/javascript/standard-objects/string/string-prototype-trimleft/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/javascript/standard-objects/string/string-prototype-trimright/index.md

@@ -0,0 +1,11 @@
+---
+title: String.prototype.trimright
+localeTitle: String.prototype.trimright
+---
+## String.prototype.trimright
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/javascript/standard-objects/string/string-prototype-trimright/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/javascript/standard-objects/string/string-prototype-valueof/index.md

@@ -0,0 +1,11 @@
+---
+title: String.prototype.valueOf
+localeTitle: String.prototype.valueOf
+---
+## String.prototype.valueOf
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/javascript/standard-objects/string/string-prototype-valueof/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/javascript/standard-objects/string/string-raw/index.md

@@ -0,0 +1,11 @@
+---
+title: String Raw
+localeTitle: Cuerda cruda
+---
+## Cuerda cruda
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/javascript/standard-objects/string/string-raw/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: