Un String es una cadena de texto, es decir, texto puro y llano. Y al final de todo, el valor de una variable dada. Esto es más viejo que evacuar agachado.
Inicializar una variable tipo string
let nombreVariable = "cadena de texto tal cual";
En el momento en que encierro el valor de una variable entre comillas (dobles o simples), hago que sea una variable tipo string.
Se puede usar comillas simples o comillas dobles. Pero si el string mismo va a incluir comillas dobles o simples entonces de más está decir que debo usar una diferente a la que se está usando en el string.
let nombreVariable = 'esto lo dijo "mi mamá" una vez';
let nombreVariable = "un 'string' con comillas simples en el texto";
Escapar las comillas
Puedo hacer que las comillas dobles sean parte del texto, aún cuando uso comillas dobles para encerrar el string, usando una barra invertida antes de las comillas dobles:
const nombreVariable = "Tubo de 5\"";
Métodos de los strings
Ahora que en el artículo anterior he tocado el tema de los métodos, cosa bastante importante en JavaScript, vamos aquí a ver cuáles son los que el curso destaca para los strings.
El método .length – Longitud de un string
El método length es para contar la cantidad de caracteres de un string.
Por ejemplo el siguiente código va a mostrar por consola la cantidad, en números, de caracteres del string, incluyendo los espacios:
let nombreVariable = "Me gusta mucho Nueva York";
console.log(nombreVariable.length);

Eso mismo es un dato que puedo almacenar en una variable, tal como:
let longitudString = nombreVariable.length;
El método length es de los muy pocos métodos que no usan paréntesis. Entiendo porque es más una propiedad que un método.
El método .indexOf() – Posición de un texto dentro de un string
Este método nos va a indicar en qué posición se encuentra el primer caracter de un texto dentro de una cadena de texto, si está.
let nombreVariable = "Me gusta mucho Nueva York";
console.log(nombreVariable.indexOf("gusta"));
posicionLetraInicial = nombreVariable.indexOf("gusta");
console.log(`La posición es ${posicionLetraInicial}`);
console.log(nombreVariable.indexOf("carro"));
console.log(typeof nombreVariable.indexOf("carro"));
El código anterior va a mostrar por consola el número 3; se empieza a contar desde cero.

Si no encuentra la cadena de caracteres que se le solicita arroja -1 como dato. Y el tipo de dato por si acaso, queda claro que es tipo number.
El método .includes() – Buscar un texto dentro de un string
Este método lo que hace es indicar si hay o no una cadena de caracteres solicitada dentro de un string.
let nombreVariable = "Me gusta mucho Nueva York";
console.log(nombreVariable.includes("Nueva")); //Esto va a arrojar true
console.log(nombreVariable.includes("Miami")); //Esto va a arrojar false

Toma en cuenta las minúsculas y mayúsculas, vamos, se trata de un lenguaje de programación, no anda jugando.
Los métodos .trim(), trimStart() y trimEnd() – Quitar espacios en blanco
Se usan para quitar posibles espacios en blanco antes y/o después de la cadena de caracteres en un string.
- .trim(); Quitará los espacios en blanco antes y después de la cadena de caracteres en el string
- .trimStart(); Quitará los espacios en blanco antes de la cadena de caracteres en el string
- .trimEnd(); Quitará los espacios en blanco después de la cadena de caracteres en el string
const text = " Brigzen Coronado ";
console.log(text);
console.log(text.length);
const textTrim = text.trim();
console.log(text);
console.log(textTrim.length);
const textTrimStart = text.trimStart();
console.log(text);
console.log(textTrimStart.length);
const textTrimEnd = text.trimEnd();
console.log(text);
console.log(textTrimEnd.length);

Tanto el método trimStart() como el método trimEnd() son recientes, en cambio el método trim() tiene muchos años de estar funcionando.
El método .replace() – Reemplazar texto en un string
Para reemplazar un texto por otro en un string.
textString.replace(«old text», «new text»);
const datoString = "Me gusta mucho Nueva York";
datoStringChanged = datoString.replace("Nueva York", "Manhattan");
console.log(datoStringChanged);

El método .slice() – Cortar el texto de un string
Esto va a cortar una cadena de texto de un string desde un punto inicial a un punto final.
variable.slice(a, b);
El primer dato es la posición desde donde va a empezar a cortar el texto (incluyéndolo) y el segundo donde va a terminar (sin incluirlo). Si solo se coloca un dato, entonces ese será desde donde empezará e irá hasta el final del string. El primer dato debe ser menor que el segundo de lo contrario dará un error.
let variable = "Me gusta mucho- Nueva York";
console.log(variable.slice(0, 14));
console.log(variable.slice(15));

El valor 14 es la posición del guión y se puede ver en la consola que no fue incluido. La posición 15 es el espacio entre el guión y la N, como se puede ver fue incluido en el corte.
El método .substring() para sustraer texto
Este es parecido al anterior pero va de extraer texto de un string. Aquí el primer dato puede ser mayor que el segundo dato. Es que .slice() es más como: «corto desde aquí hasta acá». Y este método, .substring(), es como: «de a dónde a dónde saco el texto que quieres?»
let text = "Me gusta mucho Nueva York";
console.log(text.length);
const textTest = "Me gusta mucho ";
console.log(textTest.length);
console.log(text.substring(15,25));
console.log(text.substring(25,15));
console.log(text.substring(15,25).length);
console.log(text.substring(25,15).length);

A diferencia de .slice(), valla usted a saber por qué, cierta lógica tendrá, el caracter correspondiente al dato inicial (sea que esté de primero o segundo trata del valor más bajo) no se toma en cuenta para la extracción y el caracter correspondiente al dato final sí se toma en cuenta.
En ambos casos el resultado es el texto de 10 caracteres «Nueva York».
El método .charAt() – Sacar una letra de un string
Con este método saco un caracter de una cadena de texto. Se supone que es como lo que deben usar cuando vemos en el perfil de alguna red social la inicial del nombre.
let variable = "Me gusta mucho Nueva York";
variable.charAt(0); // El resultado será: M
variable.charAt(15); // El resultado será: N
El método .repeat() – Repetir un texto
Repite un texto de un string tantas veces como se le diga:
let variable = "Me gusta mucho Nueva York, ";
variable.repeat(3);
// El resultado será: Me gusta mucho Nueva York,
//Me gusta mucho Nueva York, Me gusta mucho Nueva York,
Así de simple. El instructor dice que redondea si le pones un número decimal, pero nada, le puedes poner 2.9 y va a actuar como 2, solo ignora el decimal, no redondea nada.
El método .split() – Hacer de un texto en string a un arreglo array
Lo que va dentro del paréntesis de este método es lo que el método va a buscar en el string para dividirlo en diferentes partes para generar un array. En el primer ejemplo usa el espacio entre los caracteres y en el segundo usa la coma y el espacio entre las palabras.
let variable = "Me gusta mucho Nueva York";
varaible.split(" ");
//El resultado es un array: [“Me”, “gusta”, “mucho”, “Nueva”, “York”]
let variable = "Leer, correr, matemática, programar, electrónica";
variable.split(", ");
//El resultado: ["Leer", "correr", "matemática", "programar", "electrónica"]
Los métodos .toUpperCase() y .toLowerCase() – Pasar textos a mayúsculas o minúsculas
Estos métodos lo que van a hacer es pasar todos los caracteres de un string a mayúsculas o a minúsculas. No hace falta mayor explicación.
variable.toLowerCase();
Me queda la duda de cómo hacer para colocar solo la primera letra en mayúscula.
El método .toString() – Pasar un dato tipo número a string
No es necesario mayor explicación. Solo recordar que en las consolas de los navegadores los string y los números se representan con colores diferentes.
let test = 35;
console.log(test);
//El resultado en consola será: 35
console.log(typeof test);
//El resultado en consola será: number
console.log(typeof test.toString());
//El resultado en consola será: string
Concatenar varios strings en una sola cadena de texto
Hay varios métodos, veamos.
Concatenar con el método .concat()
const nomVar1 = "A mi me gusta mucho Nueva York";
const nomVar2 = "pero también todo Estados Unidos";
console.log(nomVar1.concat(nomVar2));
console.log(nomVar1.concat(" y la estatua de la libertad."));
Los resultados en consola serían:
A mi me gusta mucho Nueva Yorkpero también todo Estados Unidos
A mi me gusta mucho Nueva York y la estatua de la libertad.
Concatenar con el símbolo +
console.log(nomVar1 + ", " + nomVar2 + ".");
El resultado en consola sería:
A mi me gusta mucho Nueva York, pero también todo Estados Unidos.
Concatenar reemplazando el símbolo + por comas (,)
console.log(nomVar1 , ", " , nomVar2 , ".");
El resultado en consola sería el mismo:
A mi me gusta mucho Nueva York, pero también todo Estados Unidos.
Concatenar a modo template string or literals
Esta es una nueva forma de concatenar strings a partir de ECMA6 o algo así. Se coloca el texto entre comillas invertidas simples. Creo que es mucho mejor:
let ciudad = "Nueva York";
let condado = "Manhattan";
console.log(`A mi me gusta mucho el condado de ${condado} en la ciudad de ${ciudad}.`);
El resultado en consola sería:
A mi me gusta mucho el condado de Manhattan en la ciudad de Nueva York.
Tres formas de inicializar una variable tipo string con valor
const nombreVariable1 = "Me gusta mucho Nueva York";
const nombreVariable2 = String("Me gusta mucho Nueva York");
const nombreVariable3 = new String("Me gusta mucho Nueva York");
Creo que la primera debe ser la más utilizada.
La segunda está declarando el tipo de variable que asumo no hace falta ya que JS no necesita que le especifique el tipo de variable.
La tercera se usa muy poco, crea el string en un objeto cuyos datos son la letras por letras.