// ============================================
// Reto: Métodos esenciales de strings en JavaScript
// ============================================
// Practica length, slice, split, trim, toLowerCase, includes,
// startsWith, endsWith y replace. Los strings son inmutables.
// Ejecuta los tests con: npx vitest src/05-metodos-strings
// ============================================
// --- Reto 1: Contar caracteres con length ---
// Recibe un string "texto". Retorna la cantidad de caracteres (usa la propiedad length).
function contarCaracteres(texto) {
// Tu código aquí
return texto?.length;
}
// --- Reto 2: Extraer porción con slice ---
// Recibe "texto", "inicio" y "fin" (índices). Retorna la porción desde inicio hasta fin (sin incluir fin).
// Si fin no se pasa o es undefined, extrae hasta el final del string.
// Usa el método slice.
function extraerConSlice(texto, inicio, fin) {
// Tu código aquí
let textoModificado = '';
if(!fin || fin === undefined) {
textoModificado = texto.slice(inicio);
} else {
textoModificado = texto.slice(inicio, fin)
}
return textoModificado;
}
// --- Reto 3: Extraer desde el final con slice (índice negativo) ---
// Recibe "texto" y "n" (número). Retorna los últimos "n" caracteres del string.
// Usa slice con índice negativo: slice(-n).
function extraerDesdeFinal(texto, n) {
// Tu código aquí
let ultimosCaracteres = texto ? texto.slice(-n) : "";
return ultimosCaracteres;
}
// --- Reto 4: Dividir en array con split ---
// Recibe "texto" y "separador" (string). Retorna un array con las partes del texto
// divididas por el separador. Usa el método split.
function dividirEnPartes(texto, separador) {
// Tu código aquí
let textoSeparado = texto ? texto.split(separador) : [];
return textoSeparado;
}
// --- Reto 5: Limpiar espacios con trim ---
// Recibe un string "texto" que puede tener espacios al inicio y/o al final.
// Retorna el mismo texto sin espacios al inicio ni al final. Usa trim.
function limpiarEspacios(texto) {
// Tu código aquí
let textoSinEspacios = texto ? texto.trim() : "";
return textoSinEspacios;
}
// --- Reto 6: Normalizar a minúsculas ---
// Recibe un string "texto". Retorna el texto en minúsculas usando toLowerCase.
// Útil para comparaciones sin importar mayúsculas/minúsculas.
function normalizarMinusculas(texto) {
// Tu código aquí
let textoMinusculas = texto ? texto.toLowerCase() : "";
return textoMinusculas;
}
// --- Reto 7: Saber si incluye una subcadena con includes ---
// Recibe "texto" y "subcadena". Retorna true si el texto incluye la subcadena, false si no.
// Usa el método includes.
function incluyeSubcadena(texto, subcadena) {
// Tu código aquí
let contieneSubcadena;
contieneSubcadena = texto?.includes(subcadena);
return contieneSubcadena;
}
// --- Reto 8: Validar inicio con startsWith ---
// Recibe "texto" y "prefijo". Retorna true si el texto empieza con el prefijo, false si no.
// Útil para validar prefijos (ej: nombre de archivo, protocolo).
function empiezaCon(texto, prefijo) {
// Tu código aquí
let tienePrefijo = texto ? texto.startsWith(prefijo) : false;
return tienePrefijo;
}
// --- Reto 9: Validar fin con endsWith ---
// Recibe "texto" y "sufijo". Retorna true si el texto termina con el sufijo, false si no.
// Útil para validar extensiones de archivo (ej: "documento.md" termina con ".md").
function terminaCon(texto, sufijo) {
// Tu código aquí
let tieneSufijo = texto ? texto.endsWith(sufijo) : false;
return tieneSufijo;
}
// --- Reto 10: Reemplazar sin mutar con replace ---
// Recibe "texto", "buscar" y "reemplazo". Retorna un NUEVO string donde la primera
// ocurrencia de "buscar" se sustituye por "reemplazo". El original no se modifica (inmutabilidad).
// Usa el método replace.
function reemplazarPrimera(texto, buscar, reemplazo) {
// Tu código aquí
let textoReemplazado = texto ? texto.replace(buscar, reemplazo) : "";
return textoReemplazado;
}
module.exports = {
contarCaracteres,
extraerConSlice,
extraerDesdeFinal,
dividirEnPartes,
limpiarEspacios,
normalizarMinusculas,
incluyeSubcadena,
empiezaCon,
terminaCon,
reemplazarPrimera,
};
Recursos
Resumen
Trabajar con métodos de strings en JavaScript te permite manipular texto de forma precisa: contar caracteres, extraer porciones, reemplazar palabras o validar contenido. Si estás aprendiendo a programar, dominar estos métodos es clave para construir formularios, validaciones y proyectos reales.
¿Cómo cuento los caracteres de un string en JavaScript?
El método más básico y a la vez más usado es length, que devuelve la cantidad de caracteres que tiene un texto. Si escribes texto.length sobre la cadena "Hola mundo", obtienes 10 como resultado [0:30].
¿Para qué sirve length en JavaScript? Para saber cuántos caracteres tiene un string y validar si contiene o no contenido. Es muy popular cuando necesitas verificar que un campo no esté vacío.
Esta validación se vuelve indispensable cuando trabajas con formularios o necesitas confirmar que un usuario ingresó información antes de procesarla.
¿Cómo extraigo una parte de un string?
Aquí entran dos métodos hermanos: slice y substring. Ambos extraen porciones de texto, pero tienen diferencias importantes.
Slice con posiciones positivas y negativas
Con slice le pasas la posición de inicio y de fin. Sobre el texto "JavaScript es genial" puedes hacer lo siguiente [1:20]:
texto1.slice(0, 10)devuelveJavaScript.texto1.slice(11)devuelvees genialal omitir el final.texto1.slice(-6)devuelvegenialrecorriendo desde el final.
La gran ventaja de slice es que acepta valores negativos, ideal para tomar los últimos caracteres sin calcular la longitud total.
Substring y su limitación con negativos
Substring funciona muy parecido: recibe inicio y fin. Sobre "Hola, mundo", texto2.substring(0, 4) te devuelve Hola [2:40]. La diferencia clave es que substring no trabaja con números negativos, por eso la recomendación práctica es usar slice casi siempre.
¿Cómo divido un texto en partes con split?
Cuando tienes una cadena como "línea uno línea dos línea tres" y necesitas convertirla en un arreglo, usas split indicando el separador [3:10]. Si pasas un espacio, obtienes cada palabra como elemento. Si cambias el separador a una coma, divide el texto donde encuentre comas.
Es una herramienta poderosa para procesar listas, CSV o cualquier dato que venga concatenado.
¿Cómo limpio espacios en blanco de un string?
El método trim elimina los espacios al inicio y al final de un texto [3:50]. Tiene dos submétodos útiles:
- trimStart elimina solo los espacios del principio.
- trimEnd elimina solo los espacios del final.
- trim elimina ambos al mismo tiempo.
Esto resulta vital cuando recibes datos de usuarios que sin querer escriben espacios extra.
¿Cómo cambio mayúsculas y minúsculas en JavaScript?
Los métodos toLowerCase y toUpperCase son tus aliados cuando trabajas con formularios [4:30]. Las personas escriben con mayúsculas, minúsculas o combinaciones, y si intentas comparar texto sin normalizar, la comparación falla.
¿Cuándo uso toLowerCase y toUpperCase? Cuando necesitas comparar dos textos sin importar cómo estén escritos. Conviertes ambos al mismo formato y luego comparas.
Por ejemplo, si tienes "JavaScript" con la S en mayúscula intermedia, puedes transformarlo todo a minúsculas con texto.toLowerCase() antes de hacer cualquier validación.
¿Cómo verifico si un string contiene una palabra?
El método includes retorna true o false según si el texto buscado existe dentro de la cadena [5:30]. Sobre la constante "Aprende JavaScript desde cero":
contenido.includes("JavaScript")devuelvetrue.contenido.includes("Python")devuelvefalse.
Es un método clave para hacer validaciones rápidas, perfecto para el manejador de notas que se construirá como proyecto del curso.
¿Cómo sé si un texto empieza o termina con cierta palabra?
Los métodos startsWith y endsWith responden exactamente eso. Si tienes la constante archivo = "documento.md" [6:20]:
archivo.startsWith("doc")devuelvetrue.archivo.endsWith("md")devuelvetrue.archivo.endsWith("js")devuelvefalse.
Esto te permite identificar extensiones de archivo o prefijos sin tener que partir manualmente la cadena. Cuando manipulas documentos, sabes al instante qué tipo de información estás recibiendo.
¿Cómo reemplazo texto dentro de un string?
El método replace sustituye una porción de texto por otra. Sobre "Hola, mundo. Hola, JavaScript", replace("Hola", "Hi") cambia solo la primera ocurrencia y te devuelve "Hi, mundo. Hola, JavaScript" [7:30].
Y aquí viene lo interesante: el string original no cambia. Si imprimes la variable original, sigue intacta.
¿Por qué replace no modifica el string original? Porque los strings son primitivos inmutables en JavaScript. Cada método crea una nueva posición en memoria con el resultado, sin tocar el valor original.
Esta regla aplica para todos los métodos que viste: slice, substring, trim, toLowerCase, replace y los demás. Siempre obtienes un nuevo string, nunca una mutación del anterior.
Conceptos y habilidades clave de la clase
- Inmutabilidad de strings: los métodos no modifican el original, crean uno nuevo en memoria [8:20].
- Diferencia entre slice y substring: slice acepta índices negativos, substring no.
- Normalización de texto: usar toLowerCase o toUpperCase antes de comparar evita errores en formularios.
- Validación con includes, startsWith y endsWith: tres métodos esenciales para verificar contenido y formato.
¿Cuál de estos métodos crees que vas a usar más en tu próximo proyecto? Cuéntame en los comentarios qué validaciones se te ocurren combinando estos métodos.
