duduromeroa.com

Javascript

Programación para web (4.2/8): Métodos para alfanuméricos o strings





En la sección 4.1 mencioné que en programación orientada a objetos los métodos son las acciones que alteran los datos. Similar a los verbos que alteran los sustantivos y los adjetivos en la mayoría de los idiomas humanos.

Los métodos explicados a continuación alteran los valores tipo alfanuméricos o strings. El anglicismo 'string' denota a un conjunto de cosas similares y alineadas. En ciencias de programación refiere a una secuencia de caracteres o símbolos que no siempre son letras.

MÉTODO CONCAT()

Así como en los datos tipo arreglo, concat() funciona en strings de la misma forma: une dos 'piezas' de strings en una sola, sin alterar los originales:

let fraseA = "Eres perla ";
let fraseB = "que surgiste...";
// Unir frases
var unir = fraseA.concat(fraseB);
console.log(unir);
//-> Eres perla que surgiste...

MÉTODO CHARAT()

Halla un caracter según una posición de índice dada. Este método devolverá cero si no halla el índice o si el número de índice a buscar es mayor a la longitud del string inicial dado.

//Índice----012
let zona = "Malecón 2000";
/* Hallar lo que esté en el índice 6 */
let hallar = zona.charAt(2);
console.log("Se halló " + hallar);
//-> l

Para mostrar el caracter hallado en la última posición del string inicial, se agrega un nuevo llamado al string y se accede a .length-1

let fecha = "Julio 25";
/* Mostrar el último caracter --> 
(string.length-1) */
console.log("Se halló el caracter " + 
fecha.charAt(fecha.length-1));
//-> o

MÉTODO ENDSWITH()

Determina si un substrings está ublicado al final de otro. Retorna respuesta booleana ('true' si el método halla el substring, 'false' si no lo halla).

/* Inicio de 'Décimas', de J. J. de Olmedo (1780-1847) */
let frase = "Para templar el calor";
let hallar = frase.endsWith("lor");
console.log(hallar);
//-> true

MÉTODO lastIndexOf()

Este método ubica la última vez que un subconjunto de caracteres es encontrado –o lo que es lo mismo, de la última ocurrencia–. La respuesta será el índice numérico del primer caracter de todo el string buscado:

let equipo = "Barcelona";
let hallar = equipo.lastIndexOf("a");
// Invocar método lastIndexOf()
console.log(hallar);

/* La última vez que la letra 'a' aparece 
en Barcelona es en índice 8 (contando 
desde el cero en adelante) */

De igual forma, se puede determinar desde qué índice deseamos que se busque el primer caracter pedido:

let equipo = "Malecón 2000";
/* Ubicar el primer cero desde el índice 9 en adelante*/
let hallar = equipo.lastIndexOf("0", 9);
// Invocar método lastIndexOf()
console.log(hallar);
//-> 9

MÉTODO REPLACE()

Reemplaza una porción de string mediante dos argumentos: en el primero se indica el substring que se eliminará; y en el segundo argumento se indica el string que reemplazará al eliminado. El string inicial no es alterado. El método replace() también admite expresiones regulares en el primer argumento, creando coincidencias más precisas.

let menu = "Arroz con chuleta";
// Eliminar 'chuleta' y agregar 'menestra'
let reempl = menu.replace("chuleta", "menestra");
console.log(reempl);
//-> Arroz con menestra

/* Si el primer argumento no es dado, 
el string de reemplazo se ubicará al inicio */
console.log(menu.replace("", "*** "));
// *** Arroz con chuleta

/* Solo la primera ocurrencia -en este caso,
solo la primera letra 'o'– será reemplazada */
console.log(menu.replace("o", "**"));
// Arr**z con chuleta

/* El menu inicial no se altera */
console.log(menu);

MÉTODO REPLACEALL()

Este es un reemplazo drástico. Es decir, cambiará todas las ocurrencias de un substring o conjunto de strings dados.

let menu = "Arroz con chuleta";
/* Todas las 'o' será reemplazadas por los asteriscos  */
console.log(menu.replaceAll("o", "**"));
// Arr**z c**n chuleta

MÉTODO SPLIT()

Convierte un tipo dato string a un tipo arreglo. Es decir, cada elemento de una tira de caracteres es pasado a un conjunto de esos elementos, cada uno separado por una coma y con un valor de posición –o índice– que va desde el cero en adelante.

let fraseA = "9 de octubre de 1820";

// Con dos espacios de separación entre comillas...
// Toda la frase es un elemento
var unir = fraseA.split("  ");
console.log(unir);
//-> [ '9 de octubre de 1820' ]

// Con un espacio de separación entre comillas...
// Cada palabra es un elemento
var unirY = fraseA.split(" ");
console.log(unirY);
//-> [ '9', 'de', 'octubre', 'de', '1820' ]

/* Sin espacio de separación es lo más granulado. 
Cada palabra y cada espacio es un 
elemento del arreglo. */
var unirZ = fraseA.split("");
console.log(unirZ);
/* [ '9', ' ', 'd', 'e', ' ',
  'o', 'c', 't', 'u', 'b',
  'r', 'e', ' ', 'd', 'e',
  ' ', '1', '8', '2', '0' ] */

/* Cuando no se da argumento, todo el 
string es un solo elemento de arreglo */
var unirZ = fraseA.split();
console.log(unirZ);
// [ '9 de octubre de 1820' ]

/* Finalmente, el elemento con el 
índice cero en el conjunto 'unirY' es: */
console.log(unirY[0]);
// -> 9

Cuando los strings iniciales están separados por comas:

let fraseA = "gringa, loca, gringa, loca";

var unir = fraseA.split(",");
console.log(unir);
//-> [ 'gringa', ' loca', ' gringa', ' loca' ]

Cuando se le da como argumento uno de los elementos del string, ese elemento es removido del arreglo entregado:

let fraseA = "gringa, loca, gringa, loca";

var unir = fraseA.split("loca");
console.log(unir);
//-> [ 'gringa, ', ', gringa, ', '' ]

Lo mismo cuando se le da al argumento de split() solo unos cuantos caracteres que sí estén presentes en el string inicial. Esos se eliminan del arreglo entregado:

let fraseA = "gringa, loca, gringa, loca";

// De 'loca' solo se muestra 'ca'
var unir = fraseA.split("lo");
console.log(unir);
//-> [ 'gringa, ', 'ca, gringa, ', 'ca' ]

En otro ejemplo, un segundo argumento en split() da la cantidad de trozos de strings –o de caracteres– que serán mostrados en el arreglo entregado. Atentos con la separación de los caracteres:

let frase = "ahora a pata me tendré que regresar";

// Ojo las comillas:
// Solo extraer los tres primeros caracteres
var unirA = frase.split("", 3);
console.log(unirA);
//-> [ 'a', 'h', 'o' ]

// Ojo las comillas:
// Solo extraer los tres primeros conjuntos
var unirB = frase.split(" ", 3);
console.log(unirB);
//-> [ 'a', 'h', 'o' ]

split() permite también trabajar con expresiones regulares. Se detallará eso en próximas secciones.

MÉTODO JOIN()

Al igual que en arreglos, join() trabaja inverso a split(); es decir, convierte un dato tipo arreglo a uno string –fila de palabras, números o caracteres–:

// Arreglo con tres elementos
let barrios = ["Guasmo", "Alborada", "Centenario"];
// Signo '+' servirá para separar elementos
var unir = barrios.join(' + ');
console.log(unir);
//-> Guasmo + Alborada + Centenario

Cuando ningún caracter –desde el argumento de join()– separe los elementos, el resultado será la unión de los strings:

// Arreglo 
let grito = ["G", "o", "o", "l", "!"];

// No separar
var unir = grito.join('');
console.log(unir + " del ídolo");
//-> Gool! del ídolo

También pueden combinarse tres métodos para expresar en minúsculas y en un arreglo el enojo del señor Jirafales. Allí se guarda la conversión del string en una constante; luego; el nombre indicador del string inicial accede a split(), seguido al join() y finalmente a toLowerCase(). Recordar que cada punto significa 'acceder a'.

const jirafales = 'TAAAAA TA TA TA !';

/* Esta separación entre métodos es 
útil para legibilidad. Pero el sistema 
lee todo eso sin los espacios. */
const enojado = 
  jirafales.split(' ')
  .join(' - ')
  .toLowerCase();

console.log(enojado);
//-> taaaaa - ta - ta - ta - !

MÉTODO LOWERCASE()

Cambia el estilo de los caracteres a tipografía en bajas o minúsculas. No altera el conjunto de caracteres iniciales.

let frase = "GUAYAQUIL de Mis AMOres";
console.log( frase.toLowerCase() );
//-> guayaquil de mis amores

MÉTODO INDEXOF()

Así como en los arreglos, el método indexOf() extrae una porción o substring en forma de índice de la primera ocurrencia de un elemento pedido. Si son palabras, extrae el índice del primer caracter. Si no lo halla, el método devuelve -1.

// Índices- -012345
// - - - - - - - -v
let frase = "Eres perla que surgiste";

// Extraer el índice del primer caracter de 'perla'
let extraer = frase.indexOf("perla");

// Muestra el índice de 'p'
console.log(extraer);
//-> 5

En combinación con bucles como while(){}, indexOf() permite contabilizar las veces que un string pedido está presente en el string inicial:

// Strings
let frase = "Goooooool gol gol gol";

// Valor que guarda las ocurrencias
let contador = 0;

// Busca el string dado
let posicion = frase.indexOf("gol");

/* Bucle: evaluará siempre que esa condición sea true */
while (posicion !== -1) { 

/* Mientras exista el elemento pedido, incrementar */
contador++;

/* Y, mientras exista el elemento pedido, 
actualizar valor de posicion: Es decir, volver a buscar 
el string pedido, pero al mismo tiempo, 
buscar desde 'posición + un índice -seguir hacia adelante-' */
posicion = frase.indexOf(("gol"), posicion + 1);
}
console.log(contador + " veces");

En otro ejemplo, podemos buscar un caracter o palabras a partir de una posición en adelante. En el primer argumento de indexOf("primer", segundo) se agrega el caracter o porción de strings –entre comillas– buscado; y en el segundo argumento se agrega el número índice desde donde se buscará solo la primera ocurrencia de lo pedido desde la ubicación dada en el segundo argumento. Ojo, aunque se dé como argumento un índice mayor a cero, el índice resultado del hallazgo se contará desde el cero en adelante.

/* Del pasillo 'El aguacate', 
de César Guerrero Tamayo, quiteño. */
let frase = "...tu encanto, tu mayor anhelo y tu ilusión";

/* Buscar el primer 'tu' DESDE el índice 5 */
let evaluarA = frase.indexOf("tu", 5);
console.log("Se halló un 'tu' en el índice " + evaluarA);
//-> 15
/* Eso significa que DESDE el índice 0 AL índice 15 
se halla la primera presencia del primer caracter de 'tu' */

/* Buscar el primer 'tu' DESDE el índice 12 */
let evaluarB = frase.indexOf("tu", 12);
console.log("Se halló un 'tu' en el índice " + evaluarB);
//-> 15
/* Eso TAMBIÉN significa que DESDE el índice 0 AL índice 15 
se halla la primera presencia del primer caracter de 'tu' */

/* Buscar el primer 'tu' DESDE el índice 18 */
let evaluarC = frase.indexOf("tu", 18);
console.log("Se halló un 'tu' en el índice " + evaluarC);
//-> 33
/* Eso  significa que DESDE el índice 0 AL índice 33 se halla 
la primera presencia del primer caracter de 'tu' */

Para mdn web docs un resultado raro es cuando se agregan dos argumentos –un string vacio y un número mayor a la longitud del string–. Eso devuelve el total de los elementos del string contados desde el número cero.

// Strings
let frase = "Goooooool";
/* Segundo argumento es un número 
mayor que la longitud del string inicial */
let evaluar = frase.indexOf("", 20);
console.log(evaluar);
//-> 9

Para hallar la presencia o no de un string dado desde indexOf(), se aplica una condicional y una inversión booleana de un estado true/false. En esta sección expliqué eso con anterioridad.

/* 'Gringa loca', (Napolitano e Idrovo) */
let frase = "...loca gringa loca";

/* Condicional: Si en el string 'frase' no hay 
ausencia del string 'gringa'...*/
if (frase.indexOf("gringa") != -1){
console.log("Sí hay gringa");
} else {
console.log("No hay gringa");
}
//-> Sí hay gringa

MÉTODO PADSTARTS()

Rellena con uno o más caracteres dados los espacios desde el inicio de un string hasta completar una cantidad dada.

const saludo = ' Hola Dudú';
/* Se pide rellenar con 'ooo' desde 
el 'saludo' hasta completar 15 caracteres */ 
console.log( saludo.padStart(15, "ooo") );
//-> ooooo Hola Dudú

/* Solo rellenará hasta que se complete 
la cantidad dada */
console.log( saludo.padStart(15, "12345678") );

MÉTODO PADEND()

Rellena con uno o más caracteres dados los espacios desde el FINAL en adelante de un string, hasta completar una cantidad dada.

const saludo = 'Dudú';
console.log( saludo.padEnd(15, "ú") );
//-> Dudúúúúúúúúúúúú

Este método busca un subconjunto específico de strings.

// Índice ----->01234
let opciones = "Hoy bolón con chicharrón y café pasado";
let hallar = opciones.search("bolón");
// Invocar método search()
console.log(hallar);

//-> 4
// La primera letra de 'bolón' se ubica en el índice 4

A diferencia del método indexOf(), el método search() permite aplicar expresiones regulares para dar exactitud en la búsqueda del subconjunto de strings. Mientras que indexOf() sólo acepta caracteres.

MÉTODO SLICE()

Este método extrae caracteres desde un inicio y un final dados; creando con eso un nuevo substring, pero sin alterar el inicial.

let menu = "Seco de gallina con madurito";
/* Extrae un substring desde el 
único índice dado en adelante */ 
console.log("* " + menu.slice(1));
// --> eco de gallina con madurito (no se muestra la 'S')

/* Extrae un substring desde un rango de índices */ 
console.log("* " + menu.slice(8, 15));
// --> gallina

/* Extrae un substring desde los últimos 8 índices */ 
console.log("* " + menu.slice(-8));
// --> madurito

/* Extrae desde el FINAL hacia atrás lo que halle 
en la posición 7 hasta la posición 4 */ 
console.log("* " + menu.slice(-7, -4));
// --> adu

MÉTODO STARTSWITH()

Identifica si una línea de caracteres inicia o no con un substring. Si el string pedido es hallado, se retorna 'true'; sino, se retorna 'false'.

/* Inicio de 'Décimas', de J. J. de Olmedo (1780-1847) */
let frase = "Para templar el calor de la estación y la edad...";
let hallar = frase.startsWith("Para");
console.log(hallar);
//-> true

/* Buscar 'Para' desde el índice 4 en adelante*/
let hallarOtro1 = frase.startsWith("Para", 4);
console.log(hallarOtro1);
//-> false

/* OJO. El string dado es en minúsculas. Dará false*/
let hallarOtro2 = frase.startsWith("para");
console.log(hallarOtro2);
//-> false

Abajo de nuevo combinaremos dos métodos. En este caso, para cambiar de mayúsculas a minúsculas y luego, para ubicar el substring pedido:

let frase = "PARA templar el calor...";
let hallar = frase.toLowerCase().startsWith("para");
console.log(hallar);
//-> true

MÉTODO TOUPPERCASE()

Cambia el estilo de minúsculas o tipografía en baja a alta.

let frase = "guayaquil de mis amores";
console.log(frase.toUpperCase());
//-> GUAYAQUIL DE MIS AMORES

Lars Svekis y Maaike van Putten dan un ejemplo de combinar métodos para alterar solo uno de los caracteres:

/* Inicio de 'Doce años después', del poeta 
guayaquileñó Numa P. Llona (1832 - 1907) */
let frase = "TODO se HA transformado EN LOS lugares 
que hoy recorro doliente y solitario...";
// Todo en minúsculas
let enBajas = frase.toLowerCase();
// Solo inicial en mayúscula
let inicial = enBajas.charAt(0).toUpperCase().
/* Cortar la frase desde el índice 1 en adelante 
y unir con la inicial mayúscula */
concat(enBajas.slice(1));

/* Mostrar el caracter en mayúscula 
concatenado con la frase desde el 
índice 1 en adelante */
console.log(inicial); 
/* -> Todo se ha transformado en los lugares 
que hoy recorro doliente y solitario... */

Según el ejemplo anterior, diseccionaré para explicar cómo se han combinado métodos y argumentos al ser invocados:

Infografías para temas técnico-agrícolas.
// COMBINAR MÉTODOS
let contenido = /* datos */;
let dato = contenido.metodoA(argumento).metodoB(argumento);
console.log(dato);

// INVOCAR MÉTODOS DESDE OTRO MÉTODO
/* Primero entender qué argumentos pide el método */
let fraseA = /* datos */;
let fraseB = /* datos */;
let dato = fraseA.concat( fraseB.metodoC(argumento) );

De lo anterior se deduce lo siguiente:

  • Un método con su argumento puede ir uno seguido de otro siempre que el dato a alterar sea primero. En este caso, el dato a modificar esta en 'contenido'.
  • Un dato invocando a un método junto con su argumento también puede funcionar como un valor de argumento dentro de otro método.
  • En este caso, fraseB.metodoC(argumento) funciona como argumento de concat() -última línea del código anterior–.

Subir al inicio Seguir a la parte quinta



BIBLIOGRAFÍA:
    3ra edición. 2018. Marijn Haverbeke. No starch press.
    Mozilla Foundation.
    David Flanagan (2020). Editorial O'Reilly.
    Ved Antani, Stoyan Stefanov (2017). Packt Publishing.
    Editorial Packt.
    Information and Computation. Elsevier.
    ACM SIGCSE BulletinVolume 19Issue 1Feb. 1987 pp 98–102https://doi.org/10.1145/31726.31742.