JavaScript, al ser un lenguaje versátil, ofrece una gran cantidad de funciones para trabajar con cadenas. Las cadenas son uno de los tipos de datos más fundamentales en cualquier lenguaje de programación y comprender cómo manipularlas de manera eficiente puede mejorar significativamente sus habilidades de codificación. En este artículo, profundizaremos en las funciones de cadenas de JavaScript y brindaremos explicaciones detalladas, ejemplos y comentarios para ayudarlo a dominarlas.

Introducción a las cadenas en JavaScript

En JavaScript, una cadena es una secuencia de caracteres utilizados para representar texto. Las cadenas son inmutables, es decir, una vez creadas, no se pueden modificar. En cambio, las operaciones de cadenas crean nuevas cadenas.

let greeting = "Hello, World!";
console.log(greeting); // Output: Hello, World!

Creando cadenas

Las cadenas se pueden crear usando comillas simples, comillas dobles o comillas invertidas para los literales de plantilla.

let singleQuoteStr = 'Hello';
let doubleQuoteStr = "Hello";
let templateLiteralStr = `Hello, ${singleQuoteStr}`;
console.log(templateLiteralStr); // Output: Hello, Hello

Propiedades de cadena

• longitud: Devuelve la longitud de la cadena.

let str = "JavaScript";
console.log(str.length); // Output: 10

Métodos de cadena

1. charAt()

Devuelve el carácter en un índice especificado.

let str = "JavaScript";
console.log(str.charAt(0)); // Output: J

2. charCodeAt()

Devuelve el Unicode del carácter en un índice especificado.

let str = "JavaScript";
console.log(str.charCodeAt(0)); // Output: 74

3. concat()

Concatena dos o más cadenas y devuelve una nueva cadena.

let str1 = "Hello, ";
let str2 = "World!";
let result = str1.concat(str2);
console.log(result); // Output: Hello, World!

4. incluye()

Comprueba si una cadena contiene un valor específico y devuelve verdadero o falso.

let str = "JavaScript is awesome!";
console.log(str.includes("awesome")); // Output: true

5. termina con()

Comprueba si una cadena termina con un valor específico y devuelve verdadero o falso.

let str = "Hello, World!";
console.log(str.endsWith("World!")); // Output: true

6. índice de()

Devuelve el índice de la primera aparición de un valor especificado, o -1 si no se encuentra.

let str = "JavaScript is awesome!";
console.log(str.indexOf("is")); // Output: 11

7. último índice de()

Devuelve el índice de la última aparición de un valor especificado, o -1 si no se encuentra.

let str = "JavaScript is awesome! JavaScript is fun!";
console.log(str.lastIndexOf("JavaScript")); // Output: 22

8. partido()

Recupera las coincidencias al comparar una cadena con una expresión regular.

let str = "JavaScript is awesome!";
let regex = /is/g;
console.log(str.match(regex)); // Output: [ 'is', 'is' ]

9. repetir()

Devuelve una nueva cadena con un número específico de copias de la cadena a la que se llamó.

let str = "Hello!";
console.log(str.repeat(3)); // Output: Hello!Hello!Hello!

10. reemplazar()

Reemplaza un valor especificado con otro valor en una cadena.

let str = "JavaScript is awesome!";
let newStr = str.replace("awesome", "fantastic");
console.log(newStr); // Output: JavaScript is fantastic!

11. buscar()

Busca una cadena para un valor específico y devuelve la posición de la coincidencia.

let str = "JavaScript is awesome!";
console.log(str.search("awesome")); // Output: 15

12. rebanada()

Extrae una parte de una cadena y la devuelve como una nueva cadena.

let str = "JavaScript";
console.log(str.slice(0, 4)); // Output: Java

13. dividir()

Divide una cadena en una matriz de subcadenas según un separador especificado.

let str = "Hello, World!";
let arr = str.split(", ");
console.log(arr); // Output: [ 'Hello', 'World!' ]

14. comienza con()

Comprueba si una cadena comienza con un valor específico y devuelve verdadero o falso.

let str = "Hello, World!";
console.log(str.startsWith("Hello")); // Output: true

let str = "¡Hola mundo!"; console.log(str.startsWith("Hola")); // Salida: verdadero

15. subcadena()

Extrae los caracteres de una cadena entre dos índices especificados.

let str = "Hello, World!";
console.log(str.startsWith("Hello")); // Output: true

let str = "JavaScript"; console.log(str.substring(0, 4)); // Salida: Java

16. a minúsculas()

Convierte una cadena a letras minúsculas.

let str = "Hello, World!";
console.log(str.startsWith("Hello")); // Output: true

let str = "JavaScript"; console.log(str.toLowerCase()); // Salida: javascript

17. a mayúsculas()

Convierte una cadena a letras mayúsculas.

let str = "Hello, World!";
console.log(str.startsWith("Hello")); // Output: true

let str = "JavaScript"; console.log(str.toUpperCase()); // Salida: JAVASCRIPT

18. recortar()

Elimina espacios en blanco de ambos extremos de una cadena.

let str = "Hello, World!";
console.log(str.startsWith("Hello")); // Output: true

let str = " JavaScript "; console.log(str.trim()); // Salida: JavaScript

19. recortarInicio()

Elimina espacios en blanco desde el inicio de una cadena.

let str = "Hello, World!";
console.log(str.startsWith("Hello")); // Output: true

let str = "JavaScript"; console.log(str.trimStart()); // Salida: JavaScript

20. recortarEnd()

Elimina los espacios en blanco del final de una cadena.

let str = "Hello, World!";
console.log(str.startsWith("Hello")); // Output: true

let str = "JavaScript "; console.log(str.trimEnd()); // Salida: JavaScript

21. valor de()

Devuelve el valor primitivo de un objeto String.

let str = "Hello, World!";
console.log(str.startsWith("Hello")); // Output: true

let str = new String("JavaScript"); console.log(str.valueOf()); // Salida: JavaScript

Literales de plantilla

Los literales de plantilla permiten expresiones incrustadas, lo que facilita la concatenación de cadenas y cadenas multilínea.

let str = "Hello, World!";
console.log(str.startsWith("Hello")); // Output: true

let nombre = "Juan"; let saludo = `¡Hola, ${nombre}! ¿Cómo estás?`; console.log(saludo); // Salida: ¡Hola, John! ¿Cómo estás?

Cadena.raw()

Devuelve una cadena creada a partir de una cadena de plantilla sin formato, lo que permite el acceso a cadenas sin formato a medida que se escriben.

let str = "Hello, World!";
console.log(str.startsWith("Hello")); // Output: true

let str = String.raw`¡Hola\nMundo!`; consola.log(str); // Salida: ¡Hola\nMundo!

Ejemplos prácticos

Ejemplo 1: invertir una cadena

function reverseString(str) {
    return str.split('').reverse().join('');
}
console.log(reverseString("JavaScript")); // Output: tpircSavaJ

función cadena inversa(cadena) { return str.split('').reverse().join(''); } console.log(reverseString("JavaScript")); // Salida: tpircSavaJ

Ejemplo 2: Comprobación de palíndromos

function reverseString(str) {
    return str.split('').reverse().join('');
}
console.log(reverseString("JavaScript")); // Output: tpircSavaJ

la función es Palíndromo(cadena) { let cleanStr = str.replace(/[\W_]/g, '').toLowerCase(); return cleanStr === cleanStr.split('').reverse().join(''); } console.log(isPalindrome("Un hombre, un plan, un canal, Panamá")); // Salida: verdadero

Ejemplo 3: poner en mayúscula la primera letra de cada palabra

function reverseString(str) {
    return str.split('').reverse().join('');
}
console.log(reverseString("JavaScript")); // Output: tpircSavaJ

función capitalizarPalabras(cadena) { return str.split(' ').map(word => word.charAt(0).toUpperCase() word.slice(1)).join(' '); } console.log(capitalizeWords("hola mundo")); // Salida: Hola mundo

Conclusión

Dominar las funciones de cadenas de JavaScript es crucial para una manipulación de texto y un manejo de datos eficientes. Desde operaciones básicas como concatenación y división hasta funciones más avanzadas como coincidencia de expresiones regulares y literales de plantilla, JavaScript proporciona un amplio conjunto de herramientas para trabajar con cadenas. Al comprender y utilizar estas funciones, podrá escribir código más limpio y eficiente y afrontar una amplia gama de desafíos de programación.

Esta guía completa ha cubierto las funciones de cadena más importantes en JavaScript, completa con ejemplos y explicaciones. Practique estas funciones y experimente con diferentes casos de uso para solidificar su comprensión y mejorar su competencia en codificación.