Guardar

Cadenas (Strings)

Las cadenas de caracteres o simplemente cadenas o strings (por su denominación en inglés), son vectores especializados en el manejo de caracteres, es decir en el manejo de texto.

Al ser vectores son datos estructurados, sin embargo, al ser un tipo de dato de uso frecuente, todos los lenguajes de programación disponen de una sintaxis simplificada para las mismas. Como ya se ha visto en el caso de JavaScript (y en la mayoría de los lenguajes de programación) se crean simplemente escribiéndolas entre comillas o apóstrofos y en el caso de JavaScript, también entre acentos invertidos (plantillas literales).

Al igual que ocurre con los números, el valor de la cadena: el texto en sí, es un valor primitivo (no un objeto), sin embargo, desde el mismo se puede llamar a cualquiera de los métodos dinámicos de la clase String, porque JavaScript los convierte automáticamente en objetos.

Al ser objetos, las cadenas pueden ser creadas también con el operador new (new String("cadena")), sin embargo, en la práctica, las cadenas se crean (casi siempre) empleando la notación simplificada.

Métodos y propiedades de las cadenas

Al igual que los array, las cadenas tienen la propiedad length, que devuelve el número de caracteres de la cadena, sin embargo, a diferencia de los array, esta propiedad no puede ser modificada (es de sólo lectura).

Además de esta propiedad, las cadenas cuentan con los siguientes métodos:

Observe que en esta lista existen algunos métodos estáticos: fromCharCode, fromCodePoint y raw. Como se recordará, los métodos estáticos son llamados desde la clase constructora, no desde una instancia u objeto, por lo tanto, estos métodos deben ser llamados desde la clase String.

Las cadenas de caracteres son, en realidad, vectores especializados en el manejo de caracteres. Por esa razón, en lugar de emplear el método charAt o el método at, para recuperar un carácter de la cadena, se puede emplear también la notación de corchetes, empleando el índice del carácter. No obstante, si la cadena tiene caracteres compuestos, como es el caso de algunos emojis y caracteres asiáticos, los cuales están conformados por 2 caracteres, por lo que ocupan dos posiciones (no una), dichos caracteres no pueden ser recuperados ni con el índice ni con charAt, sino con los métodos fromCodePoint y codePointAt y en esos casos, el índice debe avanzar dos posiciones (no una) para pasar al siguiente carácter.

Si sólo se trabaja con alfabetos occidentales (como el nuestro), es seguro emplear tanto los índices como los métodos charAt y at, así dada la siguiente cadena:

Los caracteres ubicados en las posiciones 4, 21 y 42, se puede obtener con cualquiera de las siguientes instrucciones:

Varios de los métodos, como match, search, replace y split, son de mayor utilidad cuando se trabaja con expresiones regulares.

Además de estos métodos, los objetos de tipo String y todos los objetos JavaScript en general, cuentan con el método toString, el mismo que devuelve la cadena que representa al objeto. En el caso de las cadenas es su valor primitivo (el texto en sí). Este método es llamado automáticamente, por Javascript, para mostrar el texto que representa al objeto, por esa razón, cuando se crea una nueva clase, generalmente es necesario reescribir su método toString, para que devuelva una cadena representativa y/o de utilidad práctica.

Secuencias de escape

El quebrado invertido (\) seguido de otro carácter, se conoce como una secuencia de escape y representa a un carácter que no tiene representación gráfica. Por ejemplo el carácter nulo (que no tiene símbolo gráfico) se representa con la secuencia de escape: \0.

Las secuencias de escape son útiles no sólo para representar caracteres que no tienen símbolos gráficos, sino también, para incluir caracteres que tienen un significado especial, como ya se ha visto previamente con el caso de las comillas:

Las secuencias de escape que se pueden emplear en JavaScript (y en la mayoría de los lenguajes de programación) son:

Ejemplos

Cree la variable s1 con el texto "Todos los navegadores actuales soportan Javascript".

Cree la variable s2 con 11 caracteres de s1 a partir del décimo primer carácter.

Sin embargo, debido a que el método substr ha sido puesto en la lista de métodos obsoletos, es conveniente resolver este tipo de problemas con otros métodos. Así, empleando los métodos substring y slice, el problema puede ser resuelto con cualquiera de las siguientes instrucciones:

Cree la variable s3 con los caracteres del vigésimo tercero al vigésimo noveno de s1. Este problema puede ser resuelto empleando los métodos substring y slice:

Obtenga la posición (el índice) donde aparece por primera vez la cadena s2 en la cadena s1.

Obtenga la posición donde aparece por última vez la letra "a" en la cadena s1.

Obtenga el cuarto carácter de la cadena s3. Este problema puede ser resuelto con los métodos charAt, at y con la notación de corchetes:

Obtenga el código del último carácter de s1. Este problema puede ser resuelto con una combinación de los métodos at, slice y la propiedad length, para obtener el último carácter de la cadena y charCodeAt o codePointAt, para obtener el código:

También se podría emplear el método substr, pero como se dijo, al estar en la lísta de métodos obsoletos, se debe evitar su uso. Observe que s1.at(-1) y s1.slice(-1), obtienen el último carácter de la cadena "s1" (el carácter "t") y que s1.length-1, obtiene el último índice de la cadena (el número de caracteres de la cadena menos 1).

Obtenga el carácter correspondiente al código 74. Este problema puede ser resuelto con los métodos fromCharCode y fromCodePoint:

Cree la variable s1 con el texto "Se pueden añadir y/o modificar métodos mediante la propiedad prototype del constructor.";

Encuentre la posición en la que aparece, por primera vez, la cadena "métodos" dentro de la cadena s1. Este problema puede ser resuelto empleando los métodos indexOf y search:

Cree la variable s2 con la primera palabra de la cadena en "s1", en minúsculas. Para obtener la primera palabra, se debe ubicar la posición donde aparece por primera vez un espacio en blanco (" "), lo que se consigue con el método indexOf o search, entonces con substring o slice, se copia la cadena que existe entre 0 y esa posición. Finalmente, la cadena se convierte a minúsculas con el método toLowerCase (también se puede emplear el método toLocaleLowerCase, pero en este caso no tiene mucho sentido, porque, toLowerCase, trabaja por defecto con la configuración local del dispositivo).

Cree la variable s3, con la última palabra de la cadena s1, en mayúsculas. En este caso, en lugar de ubicar el primer espacio en blanco, se ubica el último, lo que se consigue con lastIndexOf, entonces desde esa posición más uno (porque el espacio no es parte de la palabra), se copia la cadena con substring o slice. Para convertir la cadena a mayúsculas se emplea el método toUpperCase (aunque se puede emplear, igualmente, el método toLocaleUpperCase):

Se podría emplear igualmente search, pero en ese caso se tendría que emplear una expresión regular, las cuales serán estudiadas más adelante

Cree la variable s4, con el texto de s1, pero reemplazando la cadena "la propiedad" por la cadena "el atributo". En este caso, el método indicado para resolver el problema es replace:

Cree la variable s5 a partir de las cadenas s2 y s3 separándolas con un espacio en blanco. Este problema puede ser resuelto con el método concat, con una plantilla literal y el operador de concatenación +:

Cree un vector con las subcadenas de la cadena s1, que están entre los espacios en blanco.

Cree la variable s con el texto "Todo debe ser hecho tan simple como sea posible, pero no más simple."

Determine si la cadena "s" comienza con la cadena "Todos " o "Todo " y si termina con la cadena "simple" o "simple.". Para resolver este problema se emplea el método startsWith, para determinar si "s" comienza (true) o no (false) con las cadenas dadas y endsWith, para determinar si termina (true) o no (false) con las cadenas dadas:

Como se puede ver, el método startsWith nos informa que la cadena comienza con "Todo " y el método endsWith, nos informa que la cadena termina con "simple."

Cree una nueva cadena, rellenando el principio de la cadena "s" con caracteres "#", de manera que la longitud total de la cadena sea de 75 caracteres. Para resolver este caso se emplea el método padStart:

Cree una nueva cadena, rellenando el final de la cadena "s" con caracteres "$", de manera que la longitud total de la cadena sea de 80 caracteres. Para resolver este caso se emplea el método padEnd:

Cree las cadenas "s1", "s2" y "s3", rellenando el principio de la cadena "s" con espacios en blanco hasta una longitud total de 77 caracteres (s1), rellenando el final de la cadena "s" con espacios hasta una longitud total de 81 caracteres y rellenando, con espacios en blanco, el principio y el final de la cadena "s" hasta una longitud de 80 y 85 caracteres. En este caso se emplean, igualmente, los métodos padStart y padEnd, excepto que ahora no se manda el carácter de relleno, porque el carácter por defecto es el espacio en blanco:

Obtenga nuevas cadenas, eliminando los espacios en blanco al principio de la cadena "s1", los espacios en blanco al final de la cadena "s2" y los espacios en blanco al principio y al final de la cadena "s3". Para eliminar los espacios en blanco, al principio de la cadena, se emplean los métodos trimStart o trimLeft; para eliminar los espacios al final trimEnd o trimRight y para eliminar los espacios al principio y al final trim:

Cree la cadena "s4" repitiendo 5 veces la cadena "JavaScript". Para crear una cadena, repitiendo "n" veces una cadena dada, se emplea el método repeat:

Cree la cadena "s5" con el texto "Nunca pienso \ten el futuro. \nLlega lo \tsuficientemente pronto.", pero de manera que las secuencias de escape \t (tabulación) y \n (nueva línea) no sean interpretadas como tales, sino como caracteres normales. Para que las secuencias de escape no sean interpretadas como tales, se emplea el método estático String.raw:

Con localeCompare determine si la cadena "opción" debe ir antes de (negativo), después de (positivo) o si es igual a (cero) la cadena "opcion"; igualmente si la cadena "hola" debe ir antes, después o es igual a "Hola" y si la cadena "JavaScript" debe ir antes, después o es igual a "JavaScript":

Observe que en el primer caso, de acuerdo a localeCompare "opción" debe ir después de "opcion" (el resultado es positivo); en el segundo caso "hola" debe ir antes de "Hola" (el resultado es negativo) orden que difiere del orden ASCII estándar (donde "h" está después de "H") y en el tercer caso, como las dos cadenas son iguales, localeCompare devuelve 0.

Expresiones regulares

Las expresiones regulares son patrones que se emplean para encontrar combinaciones de caracteres en las cadenas. Las expresiones regulares son empleadas para validar datos, buscar información, reemplazar cadenas, automatizar procesos, etc.

La mayoría de los editores de código actuales, como Visual Studio Code e inclusive CodeMirror (el editor empleado en la calculadora Javascript), así como algunos editores de texto (como Microsoft Word) y herramientas como Google Forms, soportan el uso de expresiones regulares.

Como se dijo en la sección anterior, la verdadera potencia de métodos como: match, replace, search y split, se aprovecha cuando se emplean conjuntamente las expresiones regulares.

Como casi todo en Javascript, las expresiones regulares son también objetos, en este caso, objetos de la clase RegExp, cuyo constructor acepta dos parámetros: el patrón de búsqueda, que es la expresión regular propiamente (la secuencia de caracteres con significado específico) y los modificadores que son caracteres especiales que amplían o restringen el alcance de la expresión regular.

En consecuencia, formalmente, una expresión regular (r) se crea con:

Sin embargo, al igual que ocurre con los array, Javascript dispone de un método abreviado para crear expresiones regulares, el cual consiste en encerrar el patrón entre quebrados ("//") y escribir los modificadores después del segundo quebrado, es decir:

Ambas formas producen el mismo resultado (un objeto), pero esta última (la forma abreviada), es la más empleada en la práctica y es la forma que se empleará en la asignatura.

Los modificadores, que pueden ser empleados en las expresiones regulares, son:

Si bien el patrón puede ser un texto normal, en cuyo caso sencillamente se busca ese texto, casi siempre involucra uno o más caracteres o metacaracteres con un significado especial:

En las expresiones regulares se puede emplear y en ocasiones es necesario hacerlo, secuencias de escape, por ejemplo para buscar un punto y que el punto sea interpretado como tal y no como un carácter especial, debe ser escrito como una secuencia de escape, es decir precediendo "\" al carácter, así /ción\./ busca específicamente la cadena "ción.", no cadenas como ción:, ción,, ción;, etc., es decir no la cadena "ción" seguida de cualquier otro carácter (que es lo que ocurriría si se escribe "." en lugar de "\."). Por supuesto se pueden emplear también las secuencias de escape estudiadas previamente (como \n, \0, \t, \uXXXX, etc.).

Ejemplos

Cree la variable "s" con la cadena 'Si la cadena tiene más de una línea, el modificador "m" hace que la expresión regular se aplique a todas ellas'.

Obtenga la primera cadena que tenga una "d" seguida de una "a", "e", o "i"

La expresión regular: "d[aei]", ubica las cadenas que tienen una "d" seguidas de una "a", una "e" o una "i" [aei].

Obtenga todas las cadena que tenga una "d" seguidas de una "a", "e", o "i"

La expresión regular para este inciso es la misma que para el inciso anterior, sólo que ahora se emplea el modificador "g", para que ubique todas las cadenas y no sólo la primera:

Este problema puede ser resuelto también con el método matchAll, obteniéndose las mismas cadenas, sólo que matchAll devuelve un iterador (no un array) y cada cadena es devuelta en un array:

Donde el resultado, que es un iterador, ha sido transformado en un array empleando el operador de expansión ..., para este fin, se puede emplear igualmente el método estático Array.from:

El método matchAll, devuelve cada resultado en un array, porque cuando se trabaja con grupos, devuelve no solo el texto encontrado, sino también él o los grupos encontrados. Por ejemplo, si se crea un grupo para la parte de la vocal (encerrando las vocales entre paréntesis), se obtiene:

Ahora cada array contiene no sólo el texto encontrado, sino también el grupo encontrado (la vocal). Sin embargo, en esta sección del capítulo no tiene sentido emplear matchAll, porque no se emplean grupos en las expresiones regulares y por lo tanto matchAll devuelve la misma información que match.

Ubique la primera cadena que tenga una "c" o una "r" y que estén seguidas de una "a" o "e".

La expresión regular: "[cr][ai]", ubica las palabras que tienen una la letra "c" o "r" ([cr]) y que están seguidas por una letra "a" o "i" ([ai]).

Obtenga todas las cadenas que tengan una "c" o una "r" y que estén seguidas de una "a" o "e".

Al igual que en el ejemplo anterior, la única diferencia es que ahora se emplea el modificador "g", para ubicar todas las cadenas y no sólo la primera.

Obtenga todas las cadenas que tengan una "d" pero que no estén seguidas de una "a" o "i"

La expresión regular: "d[^ai]", ubica todas las cadenas que tienen la letra "d", pero que NO estan seguidas por una "a" o una "i" [^ai].

Ubique todas las cadenas que tengan la letra "l" seguidas de una letra comprendida entre la "a" y "l".

La expresión regular es "l[a-l]", ubica todas las cadenas que tienen una letra "l" seguida por cualquiera de las letras comprendidas entre "a" y "l" ([a-l]).

Todas las cadenas que sean "de", "el" o "la".

La expresión regular: "de|el|la", ubica las cadenas conformadas por "de" o "el" o "la".

Ubique todas las cadenas que tengan una "m", seguidas de cualquier carácter.

La expresión regular: "m.", ubica todas las cadenas que tengan la letra "m" seguida por un carácter cualquier ".".

Cree la variable "s" con la cadena 'Si la cadena tiene más de una línea, el modificador "m" hace que la expresión regular se aplique a todas ellas.'.

Ubique todas las cadenas con uno o más caracteres alfanuméricos.

La expresión regular: "\w+", ubica uno o más ("+") caracteres alfanuméricos ("\w"). Observe que las vocales acentuadas no son reconocidas como caracteres alfanuméricos, por eso en el resultado aparecen caracteres sueltos, como "m" y "s", en lugar de la cadena "más". En general los metacaracteres \w, \W, \b y \B han sido creados para ser empleados con el alfabeto inglés, por lo que no funcionan como se esperaría con otros idiomas.

Ubique todas las cadenas con uno o más caracteres NO alfanuméricos.

La expresión regular: "\W+", ubica uno o más ("+") caracteres no alfanuméricos ("\W"). Como se puede ver, las vocales acentuadas son consideradas NO alfanuméricos.

Ubique todas las cadenas con uno o más caracteres no blancos

La expresión regular: "\S+" ubica uno o más ("+") caracteres no blancos ("\S"). Observe que en el resultado se incluyen cadenas como "más", "línea," ""m""" y "ellas.", porque todo carácter que no sea un espacio en blanco, tabulador o salto de línea, es un carácter no blanco.

Todas las cadenas con uno o más caracteres blancos

La expresión regulars: "\s+", ubica uno o más ("+") caracteres blancos ("\s"). En este caso en particular, todos los caracteres blancos son sólamente los espacios (pues no existen ni tabuladores ni saltos de línea).

Ubique todas las cadenas con una o más letras en mayúsculas o minúsculas, incluidas vocales acentuadas y la ñ:

La expresión regular: "[a-záéíóúñ]+", ubica una o más ("+") letras ("a-z"), vocales acentuadas ("áéíóú") o eñes ("ñ"), tanto en mayúsculas como minúsculas (modificador "i"). Observe que ahora el resultado incluye únicamente letras en español, no otros caracteres como la coma, el punto, etc., (que es lo que ocurría con \S). Si el texto fuera en inglés, se conseguiría el mismo resultado simplemente con "\w+" o más precisamente con "[a-z]+".

Ubique todas las letras (alfabeto español) que estén entre dos caracteres alfanuméricos, sin incluir esos caracteres en el resultado.

La expresión regular: "\B[a-záéíóúñ]+\B", ubica una o más ("+") letras ([a-záéíóúñ]), que estén precedidas y seguidas por un carácter alfanumérico pero sin incluir ese carácter en el resultado (\B). Observe que no aparecen en el resultado cadenas como "Si", "la", "de", porque si bien están entre dos caracteres alfanuméricos, son los caracteres límites que no son incluido sen el resultado. Por otra parte no aparece la "á" de "más", porque ni la primera (m), ni la última letra (a) están precedidas o seguidas de un carácter alfanumérico (ní el espacio ni la á son caracteres alfanuméricos). Algo similar ocurre con las otras palabras acentuadas, que sólo aparecen parcialmente, así de "expresión", sólo se ubica "xpres", porque la última letra (n) no está precedida o seguida de un carácter alfanumérico, siendo la última letra que cumple esa condición la letra "i".

Eso ocurre, como se dijo, porque los caracteres especiales para palabras, como \w, \W, \b y \B, están pensadas en el alfabeto inglés, por lo que no funcionan correctamente con otros alfabetos como el español.

Para obtener el resultado correcto en nuestro en español, es necesario emplear aserciones de búsqueda anterior y posterior, como se muestra a continuación:

Ubique todas las cadenas con una o más letras que tengan la vocal "e".

La expresión regular: "[a-záéíóúñ]*e[a-záéíóúñ]*", ubica 0 o más ("*") letras ("[a-záéíóúñ]*") seguidas por la letra "e" y luego por 0 o más letras ([a-záéíóúñ]*). En este caso se emplea el cuantificador "*" porque algunas palabras como "el" no tienen caracteres antes de la "e" y otras como "hace" no tienen caracteres después de la "e":

Ubique todas las cadenas con una o más letras que terminen en una vocal y estén seguidas de un carácter blanco o una coma (no incluidos en el resultado).

La expresión regular: "[a-záéíóúñ]*[aeiou](?=[\s,])", ubica cero o más letras ("[a-záéíóúñ]*") seguidas de una vocal ("[aeiou]") y seguida (pero sin incluir en el resultado) por un carácter blanco o una coma ("(?=[\s,])"). En este caso se emplea igualmente el cuantificador "*" porque algunas palabras (como la "a") no tienen caracteres antes de la vocal.

Ubique todas las cadenas con una o más letras que terminen en un carácter no alfanumérico y que estén seguidas de un carácter blanco (no incluido en el resultado).

La expresión regular: "[a-záéíóúñ]+\W(?=\s)", ubica una o más letras ("[a-záéíóúñ]+"), seguidas de un carácter no alfanumérico ("\W") y un carácer blanco (no incluido en el resultado) ("(?=\s)"):

Ubique todas las cadenas con una o más letras que inicien con una vocal.

La expresión regular: "\b[aeiou][a-záéíóúñ]*", ubica las cadenas que inician ("\b") en una vocal ("[aeiou]") seguida por 0 o más letras ("[a-záéíóúñ]*"):

Ubique todas las cadenas con una o más letras que terminen en una letra "r" o "s".

La expresión regular: "[a-záéíóúñ]*[rs]\b", ubica cero o más letras ("[a-záéíóúñ]*") que terminen ("\b") en una letra "r" o "s" ("[rs]").

Ubique todas las cadenas con una o más letras que no estén seguidas por un carácter blanco o un carácter alfanumérico o vocal acentuada (no incluidos en el resultado).

La expresión regular: "[a-záéíóúñ]+(?![\s\wáéíóú]", ubica una o más letras ("[a-záéíóúñ]+") que no estén seguidas de un carácter (no incluido en el resultado) blanco, alfanumérico o vocal acentuada ("(?![\s\wáéíóú])"):

Cree la variable "s" con la cadena "Primer semestre: FIS100.\nSegundo semestre: FIS102.\nTercer semestre: FIS200.\nCuarto semestre: FIS202.".

Ubique todas las cadenas con uno o más caracteres alfanuméricos que estén al principio de una línea.

La expresión regular: "^\w+", ubica uno o más caracteres alfanuméricos ("\w+") al principio ("^") de una línea, con los modificadores "g", para que se ubiquen todas las coincidencias y "m" para que se ubique el principio de cada línea:

Ubique todas las cadenas con uno o más caracteres no blancos que estén al final de una línea.

La expresión regular: "\S+$", ubica uno o más caracteres no blancos ("\S+") al final ("$") de una línea, con los modificadores "g", para que se ubiquen todas las coincidencias y "m" para que se ubique el final de cada línea:

Ubique todas las cadenas con uno o más dígitos.

La expresión regular: "\d+", ubica uno o más dígitos (con el modificador "g", para que se ubiquen todas las coincidencias):

Ubique todas las cadenas con uno o más caracteres alfanuméricos seguidos de uno o más dígitos

La expresión regular: "\w+\d+", ubica uno o más caracteres alfanuméricos ("\w+") seguidos de uno o más dígitos ("\d+"):

Ubique todas las cadenas con 6 caracteres alfanuméricos en total.

La expresión regular: "b\w{6}\b", ubica cadenas que antes y después tienen un carácter no alfanumérico ("\b") y seis ("{6}") caracteres alfanuméricos ("\w") en total. Esta expresión regular funciona porque, en este caso en particular, la cadena no tiene eñes ni vocales acentuada, si existieran dichos caracteres tendría que emplearse una expresión como la siguiente (lo mismo es válido para los incisos posteriores):

Ubique todas las cadenas con entre 7 y 8 caracteres alfanuméricos en total.

La expresión regular: "\b\w{7,8}\b", ubica una cadena que antes y después tiene un carácter no alfanumérico ("\b") y entre 7 y 8 ("{7,8}") caracteres alfanuméricos ("\w").

Ubique todas las cadenas con 6 o más caracteres alfanuméricos en total

La expresión regular: "\b\w{6,}\b", ubica una cadena que antes y después tiene un carácter no alfanumérico (\b) y 6 o más ("{6,}") caracteres alfanuméricos ("\w").

Ubique todas las cadenas con uno o más caracteres no blancos.

La expresión regular: "\S+", ubica uno o más caracteres no blancos.

Ubique todas las cadenas con una o más letras, que terminen en un carácter no alfanumérico y que estén seguidas de un carácter blanco (no incluido en el resultado).

La expresión regular: "[a-z]+\W(?=\s)", ubica una o más letras ("[a-z]+"), seguidas de un carácter no alfanumérico ("\W") y de un carácter blanco, no incluido en el resultado, ("(?=\s)"):

Ubique todas las cadenas con una o más letras, que al final estén seguidas por un carácter diferente a ":" (sin incluir ese carácter en el resultado).

La expresión regular: "[a-z]+\b(?!:)", ubica una o más letras ("[a-z]+"), que al final ("\b") no estén seguidas por el carácter ":", sin incluir el carácter en el resultado ("(?!:)").

En la resolución de los ejercicios, un carácter que generalmente no está disponible en el teclado, es el símbolo de grados: °. En las computadoras y portátiles con teclado numérico, se obtiene este símbolo pulsando las teclas Alt+248 o Alt+0176, estando encendido el teclado numérico (haga la prueba).

Si no se cuenta con un teclado numérico, se puede imprimir el símbolo empleando la entidad HTML: ° o el código unicode: B0, o también 00B0:

Entonces se puede copiar el símbolo resultante (Ctrl+C) y pegar (Ctrl+V) en las instrucciones de la calculadora (o en el lugar que se requiera).

Alternativamente, en Windows, se puede acceder a todos los símbolos pulsando las teclas Windows+. (Windows+punto) y haciendo clic en el icono de símbolos:

Dado que las expresiones regulares son objetos, tienen propiedades y métodos. Las propiedades dinámicas de la clase RegExp, más propiamente sus métodos getter, son:

Las expresiones regulares tienen también propiedades estáticas, pero son propiedades obsoletas, por lo que no deben ser empleadas en la solución de problemas.

Los métodos dinámicos, son:

Las expresiones regulares cuentan con otros métodos dinámicos: [@@match], [@@matchAll], [@@replace], [@@replaceAll], [@@search] y [@@split]. Estos métodos son equivalentes a los métodos de la clase String y son empleados principalmente para personalizar el comportamiento de estos métodos en las clases heredadas de la clase RegExp.

Uso de los paréntesis

Si se encierran entre paréntesis dos o más caracteres de una expresión regular, dichos caracteres quedan agrupados y pueden ser manipulados como si se tratara de un carácter simple, así es posible aplicar al grupo cuantificadores como ?, +, etc., buscar 2 o más secuencias de caracteres y otras acciones que sólo serían posibles con caracteres simples.

Por ejemplo, dada la siguiente cadena (una expresión matemática):

Se pueden obtener todas las variables sobre las que se lleva a cabo una operación exponencial (exp) o logarítmica (log), con la siguiente expresión regular:

Es decir se ubican todas las cadenas que tienen uno o más caracteres alfanuméricos (\w+) seguidas de un punto (\.), de la cadena "exp" o "log" ((exp|log)) y que terminan con paréntesis "\(\)". Observe que tanto el punto como los paréntesis, al ser caracteres especiales, deben ser escritos como secuencias de escape (es decir con "\" por delante).

Pero los paréntesis en una expresión regular, no sólo permiten agrupar partes de la misma, sino que además permiten recordarlas. Luego se puede acceder a las cadenas encontradas, con las variables: $1, $2, $3, ...., etc., donde $1 es la cadena ubicada con el primer paréntesis, $2 la del segundo, $3 la del tercero y así sucesivamente.

Por ejemplo, en la siguiente cadena se intercambiar los nombres con los apellidos:

Es decir se ubican todas las cadenas que tienen dos palabras separadas por un espacio ((\w+) (\w+)), pero se las recuerdan (en las variables $1 y $2), pues están encerradas entre paréntesis. Luego en la expresión de reemplazo, se intercambia el orden, al escribir primero la segunda palabra ($2) seguida de la primera palabra ($1) y separándolas con un espacio.

Los grupos encontrados no sólo pueden ser recordados y empleados en las operaciones de reemplazo, sino también en la misma expresión regular. En ese caso, en lugar de emplear $ para hacer referencia a los grupos, se emplea \, así \1 hace referencia al primer grupo encontrado, \2 al segundo y así sucesivamente. Por ejemplo, para encontrar dos palabras repetidas, se escribe la siguiente instrucción:

Esta expresión encuentra las expresiones que tengan una palabra (\b\w+\b), que es recordada (por los paréntesis), seguida por un espacio y por la misma palabra (\1). De esa manera la expresión regular se cumple sólo si existen dos palabras iguales separadas por un espacio.

En ocasiones, se agrupan los elementos de una expresión regular, para cumplir con un criterio de búsqueda, pero no se quiere recordar el grupo. En esos casos los paréntesis deben comenzar con ?:, es decir se debe emplear (?:), en lugar de paréntesis simples. Con esta modificación se crea el grupo pero no es recordado. Las expresiones que emplean un grupo no recordado, se evalúan más rápido que aquellas con grupos recordados.

Por ejemplo, para encontrar, en la siguiente cadena, las variables en las que se calcula el logaritmo natural (log), la raíz cuadrada (sqrt) o la potencia (pow), se escribe la siguiente instrucción:

Esta expresión busca una letra ([a-z]) seguida de un punto (\.), de la cadena "log", "sqrt" o "pow" ((?:log|sqrt|pow)) y de paréntesis, que pueden estar vacíos o con un número entero o real (\(\d?\.?\d*\)). Observe que tanto el punto como los paréntesis se escriben con secuencias de escape, pues son caracteres especiales.

Expresiones regulares con split, search y test

Los métodos más simples que pueden hacer uso de las expresiones regulares son split, search y test.

En el caso de split, la expresión regular se emplea simplemente para encontrar los lugares en los cuales se divide la cadena (con las cuales split crea el vector). Por ejemplo, para obtener un array con todas las cadenas que estén separadas por un carácter blanco, se escribe la siguiente instrucción:

Esta expresión regular ubica las partes de la cadena que están formadas por uno o más caracteres blancos (\s+), lo que incluye tabuladores y saltos de línea. Entonces split divide la cadena en esas partes. Note que este tipo de división no sería posible sin recurrir a una expresión regular.

El método search, igualmente, emplea las expresiones regulares para ubicar la posición de la primera cadena que cumple con el criterio de búsqueda. Por ejemplo, para encontrar, en la siguiente cadena, la posición del primer número en notación científica, se escribe la siguiente instrucción:

Esta expresión regular ubica la parte de la cadena que puede estar precedida o no, por un signo más o menos ([+-]?), seguida por 0 o más dígitos (\d*), uno o ningún punto (\.?), uno o más dígitos (\d+), una letra "e" en mayúsculas o minúsculas ([eE]), uno o ningún signo "+" o "-" ([+-]?) y uno o más dígitos (\d+). Es necesaria un expresión regular así de compleja, porque los números en notación científica pueden tener o no, un signo (3.2e5, +3.2e5), tener o no, dígitos antes del punto (-0.2e9, -.2e9), tener o no, un punto (3.e6, 3e6), pueden ser escritos con una letra "e" en mayúsculas o minúsculas (4.5e12, 4.5E12) y pueden tener o no, un signo antes del exponente (2.12e+34, 2.12e34).

El método test se emplea de manera similar, sólo que devuelve true (en lugar de la posición) si el patrón buscado existe y false (en lugar de -1) cuando no. Además, al ser un método del objeto RegExp (no de String) es llamado desde la expresión regular (no desde la cadena). Así, aplicado al anterior ejemplo se tiene:

Que devuelve true (verdad) porque en este caso existe el patrón buscado.

No obstante, cuando la expresión regular lleva a cabo una búsqueda global (modificador "g") y es creada y guardada en una variable independiente, como ocurre en la siguiente instrucción, que ubica todas las fechas que estén en el formato (d)d(/-)(m)m(/-)(aa)aa:

Con la cual se pueden ubicar las partes de una cadena que tengan uno o dos dígitos (el día: \d?\d), un separador ([/-]), uno o dos dígitos (el mes: \d?\d), otro separador (\1) y dos o cuatro dígitos (el año: (\d\d)?\d\d). Expresión que también puede ser creada (de modo formal) con:

Observe que en esta forma (que como se dijo, no será empleada en la asignatura) las secuencias de escape deben ser creadas con dos quebrados invertidos (\\), porque Javascript elimina automáticamente las secuencias de escape no válidas y \d, es una secuencia de escape no válida pues no tiene significado especial, por lo que es reemplazada por la letra "d". Al emplear \\, que es una secuencia válida y que es reemplazada por \, se consigue crear los metacaracteres necesarios en las expresiones regulares.

Ahora, si se tiene la siguiente cadena:

Y se aplica la expresión regular "er" a la misma, se obtiene:

Que es true, porque en la cadena existen fechas con el formato buscado, pero ahora, como la expresión regular ha sido guardada en una variable, es posible averiguar además (con la propiedad lastIndex) la posición del carácter posterior a la cadena encontrada (en este caso la posición de la coma después de la fecha 1/2/93):

La siguiente vez que se prueba la expresión regular la búsqueda comienza desde este carácter, no desde el principio de la cadena, por lo que se obtiene:

Que como se puede deducir del valor del último carácter, corresponde a la segunda fecha. De la misma manera se pueden encontrar las otras dos fechas:

Ahora, no existen más fechas en la cadena, por lo que al volver a llamar al método, se obtiene:

El resultado false informa que no se han encontrado más fechas en la cadena y el índice 0, informa que el método ha buscado en toda la cadena, por lo que el cursor ha vuelto al principio de la misma.

Expresiones regulares con match y exec

Si se hace una búsqueda simple (sin el modificador "g"), match devuelve un vector con la cadena encontrada y, si existen, los grupos encontrados. Por ejemplo al buscar una fecha (en la cadena "s") se obtiene:

Donde el primer elemento es la cadena encontrada (la primera fecha de la cadena), el segundo corresponde al primer grupo de la expresión regular ([/-]) y el tercero, que en este caso no ha sido encontrado (porque no existe), al segundo grupo ((\d\d)?).

Pero, si se hace una búsqueda global, se obtiene:

Donde los cuatro elementos corresponden a las cuatro fechas existentes en la cadena. De esta manera (como ya se vio en ejemplos y ejercicios previos) cuando se realiza una búsqueda global con este método, se obtiene un vector con todas las coincidencias (por lo que es posible averiguar el número de coincidencias).

El método exec, opera de manera similar a test, pero en lugar de devolver un resultado booleano, devuelve un vector con la cadena encontrada y, si existen, los grupos encontrados. Al igual que ocurre con match, si se realiza una búsqueda simple (sin el modificador "g") sólo devuelve la primera cadena encontrada.

Por ejemplo con la siguiente expresión regular:

Y el método exec, se obtiene:

Que es el mismo resultado obtenido con match cuando se lleva a cabo una búsqueda simple. Por lo tanto, el primer elemento es la fecha encontrada, el segundo el primer grupo dentro de esa fecha y el tercero el segundo grupo (que en este caso no tiene coincidencias, razón por la cual es undefined).

Cuando la búsqueda es simple, como en este caso, o cuando no se guarda la expresión regular en una variable (sin importar que tenga o no el modificador "g"), exec devuelve siempre la primera cadena encontrada, así llamando nuevamente al método se vuelve a obtener el mismo resultado:

Si se emplea una expresión regular con el modificador global (y se guarda en una variable):

Devuelve inicialmente el mismo resultado que en la búsqueda simple:

Pero, al llamar nuevamente al método, se obtiene la segunda fecha:

Donde ahora se han encontrado valores para los dos grupos ("/" en el primer grupo y "20" en el segundo). Se procede igual con las dos fechas restantes:

Como se vio previamente, los mismos resulados pueden ser obtenidos, en una sola instrucción, con matchAll:

Además, en todos los casos (al igual que con test) se puede obtener el índice del carácter posterior a la cadena encontrada (con lastIndex):

Como no existen más fechas en la cadena, al llamar nuevamente al método, se obtiene:

Donde null indica que no existen más cadenas con el formato buscado. Igualmente, lastIndex devuelve 0:

Porque al no existir más cadenas con el formato buscado, el cursor vuelve al principio de toda la cadena.

De manera similar, se pueden obtener los índices, pero del primer carácter de las cadenas encontradas, a partir del resultado devuelto por matchAll:

Expresiones regulares con replace

Replace es el método que mejor permite aprovechar la potencia de las expresiones regulares. En el caso más simple se busca la cadena (o cadenas) y se reemplaza por una cadena simple. Por ejemplo, dada la siguiente cadena (que contiene una expresión matemática):

Para reemplazar todas las funciones sin y cos por tan, se puede emplear la siguiente expresión regular:

Donde se ha empleado (?:), en lugar de ( ), porque en este caso no es necesario recordar el grupo, pues no se emplea ni en la expresión regular ni en la cadena de reemplazo.

Por el contrario, para reemplazar todas las funciones sin por sinh y todas las funciones cos por cosh, es necesario recordar el grupo y añadirle la letra "h", es decir:

Resultado que se consigue igualmente con:

Donde $& es la cadena encontrada (toda la cadena, no sólo el grupo). En este caso se puede emplear $&, en lugar de $1 porque el grupo y la cadena buscada son iguales.

Además de $&, en Javascript se pueden emplear también $`, que representa la porción de la cadena que precede a la cadena encontrada y $', que representa la porción de la cadena que sigue a la cadena encontrada.

Por ejemplo, dado que en la cadena "s":

"(sin(x) + 2*cos(x) + cos(2*y)/sin(3*x)) / (sin(2*x) + cos(2*y) - sin(x*y)*cos(x*y))"

La expresión: "2*cos(x)", está precedida por la cadena "sin(x) + ", es posible reemplazar "sin(x) + 2*cos(x)" por "sin(x) + 5)", con la siguiente expresión regular:

Es decir, se ubica la cadena "2*cos(x)" y se reemplaza la misma por la cadena que le precede ("sin(x) + ") seguida del número 5 y un paréntesis de cierre ("5)").

Igualmente, dado que en "s" la cadena "sin(x*y)" está seguida por "*cos(x*y))", es posible reemplazarla por "(7*cos(x*y))", con la siguiente expresión regular:

Como de costumbre es importante no olvidar escapar los símbolos especiales (en este caso el asterisco y los paréntesis), para que sean tratados como caracteres normales y no como caracteres especiales de la expresión regular.

Aprovechando los grupos se puede cambiar el orden de las cadenas, por ejemplo, para invertir todas las expresiones que involucran sin+cos, por cos+sin, se escribe la siguiente instrucción:

En esta expresión se buscan (y agrupan) todas las partes que tengan la cadena "sin(" seguidas de cero o un dígito, cero o un asterisco, una letra "x" o "y" y un paréntesis de cierre (sin\(\d?\*?[xy]\)), seguida por " + " ( \+ ) y seguida por otro grupo formado por cero o un dígito, cero o un asterisco, la cadena "cos(", cero o un dígito, cero o un asterisco, la letra "x" o "y" y un paréntesis de cierre (\d?\*?cos\(\d?\*?[xy]\)). En la expresión de reemplazo simplemente se invierten los grupos ("$2 + $1").

Sin embargo, si se quiere reemplazar todas las funciones "sin" por "cos" y viceversa, no es suficiente una cadena de reemplazo, pues las cadenas "sin" y "cos" no se encuentran ni en un formato ni en un orden predecible. En estos casos Javascript permite emplear una función de reemplazo, en lugar de una cadena de reemplazo.

Dicha función recibe los siguientes parámetros: match, que corresponde a la cadena encontrada (equivalente a $&); p1, p2, ..., que corresponde a los grupos encontrados (equivalentes a $1, $2, ...); offset, que es la posición en la cual se ha encontrado la cadena y string que es la cadena donde se ha realizado la búsqueda (la cadena original). Por supuesto, los parámetros pueden tener cualquier nombre, pero siempre, el primero será la cadena encontrada, el segundo el primer grupo, el tercero el segundo grupo, etc., y el último la cadena donde se ha realizado la búsqueda.

Como Javascript permite enviar un número menor (o mayor) de datos, no es necesario que la función reciba todos los datos, sino sólo aquellos que serán empleados en la función. El resultado que devuelve la función es la cadena que reemplaza a la cadena encontrada.

Así, para resolver el problema (reemplazar las cadenas "sin" por "cos" y viceversa), se escribe la siguiente instrucción y la correspondiente función de reemplazo:

En este caso, en la función de reemplazo, sólo se emplea un parámetro: la cadena encontrada (match). La función consta de una sola instrucción, la cual devuelve "cos" si el grupo encontrado es "sin" y "sin" en caso contrario.

Tomando en cuenta la siguiente cadena:

Para transformar todas las temperaturas que se encuentran en grados Celsius, a grados Fahrenheit (redondeado los resultados al segundo dígito después del punto), se puede emplear la siguiente instrucción:

En este caso, la función de reemplazo recibe dos parámetros: match y p1 (que, se reitera, pueden tener cualquier nombre). Estos parámetros son la cadena encontrada (match) y el primer grupo encontrado (p1), pero sólo se emplea el primer grupo encontrado (p1), por lo que, por claridad, el parámetro no empleado podría tener un nombre más significativo, como "_":

No se emplea el primer parámetro (la cadena encontrada) porque incluye tanto el valor como la unidad de temperatura (°C), pues esa es la cadena que ubica la expresión regular, sin embargo, en la función sólo se requiere el valor de la temperatura (p1). Por esa razón, en la expresión regular se encierra el número entre paréntesis. Note que en ese grupo se emplea un segundo subgrupo (no recordado) que agrupa el punto y los dígitos después del mismo ((?:\.\d*)?), esto para aquellos casos donde las temperaturas sean enteras. Además, la expresión regular permite 0 o más espacios ("\s*") entre el valor de la temperatura y la unidad respectiva.

La función simplemente convierte el número (p1) en su equivalente en grados Fahrenheit, redondea el resultado al segundo dígito después del punto y le añade la cadena correspondiente a la nueva unidad ("°F").

Se hace notar también que, en este caso, no son necesarias conversiones explícitas (parseFloat), porque el operador * (al igual que el operador /) convierte automáticamente una cadena en un número.

El modificador ?

El carácter especial ? tiene 2 usos en las expresiones regulares: a) Como un cuantificador que encuentra cero o una vez el carácter, patrón o grupo al que sigue (que es como se ha empleado hasta el momento) y b) Como un modificador del modo en que llevan a cabo la búsqueda los cuantificadores.

Por defecto, sin ?, los cuantificadores realizan la búsqueda tratando de abarcar la cadena más larga que cumpla con el patrón de búsqueda, por ejemplo, dada la siguiente cadena:

Para encontrar todas las cadenas que tengan una "l", seguida de cero o más caracteres cualesquiera y que terminen con una "s" (sin importar que los caracteres estén en mayúsculas o minúsculas), se podría pensar que con la siguiente instrucción se lograría obtener el resultado buscado:

Pero, como se puede ver, se obtiene la cadena completa. Esto sucede porque, como se dijo, los cuantificadores (por defecto) encuentran la cadena más larga que cumpla con el patrón de búsqueda y en este caso la cadena más larga que cumple con el patrón, es la cadena completa: porque comienza con la letra "L", está seguida por varios caracteres (recuerde que el punto representa a cualquier carácter excepto el salto de línea) y termina con una "s".

Para que los cuantificadores encuentren todas las cadena que cumpla con el criterio de búsqueda (en lugar de las cadenas más largas), se debe escribir un ? después del cuantificador. Procediendo de esta manera, se obtiene:

Que ahora sí, son las cadenas buscadas. Observe, sin embargo, que la última cadena ("l trabajo con cadenas") incluye espacios en blanco. Si lo que en realidad se está buscando son cadenas con 0 o más letras que comiencen con la letra "l" y terminen en la letra "s", se debe escribir la siguiente expresión regular:

O, si sólo se quiere encontrar cadenas con letras del alfabeto inglés:

O, si se quiere encontrar cadenas alfanuméricas del alfabeto inglés:

El modificador ?, como modificador del comportamiento de los cuantificadores, ralentiza la evaluación de las expresiones regulares, por lo que, en lo posible, se debe evitar su uso en ciclos repetitivos y procesos recursivos.