domingo, 4 de febrero de 2018

Javascript Parte LXXXVI

El objeto RegExp se le puede aplicar tres modificadores que actúan sobre el patrón completo.
i: especifica que la búsqueda se realiza sin 
   diferenciar entre mayúsculas y minúsculas.
g: indica que los caracteres a buscar pueden 
   ser encontrados varias veces en la cadena 
   de caracteres.
m: el modificador m realiza coincidencia de
   patrones en el modo multilínea. En este modo, 
   si la cadena a buscar contiene varias líneas, 
   el metacaracter ^ y $ deben coincidir con el
   inicio y final de una línea, además de que 
   coincida con el comienzo y el final de una cadena.
Estos modificadores pueden aplicarse en forma independiente o conjunta a una expresión regular.
Veamos un ejemplo del modificador i sobre una expresión regular:
<html>
<head>
</head>
<body>

<script type="text/javascript">
  var palabra='Administracion';
  var patron=/adm/i;
  if (patron.test(palabra))
    document.write('La palabra '+palabra+' contiene la cadena adm sin tener en cuenta mayúsculas/minúsculas');
</script>

</body>
</html>
Los modificadores se ubican luego de la segundo barra donde declaramos la expresión regular:
  var patron=/adm/i;
Ahora veamos un problema donde activamos dos modificadores:
<html>
<head>
</head>
<body>

<script type="text/javascript">
  var oracion='El auto tiene el mejor motor que elegimos';
  var patron=/el/gi;
  var vec=patron.exec(oracion);
  document.write(vec.index);  //0
  document.write('<br>');
  vec=patron.exec(oracion);
  document.write(vec.index);  //14
  document.write('<br>');
  vec=patron.exec(oracion);
  document.write(vec.index);  //33
  document.write('<br>');
  vec=patron.exec(oracion);  
  document.write(vec);  //null
</script>

</body>
</html>
Hemos definido el patron los modificadores g (global) e i (insensitive):
  var patron=/el/gi;
Estamos buscando el patrón 'el' dentro de la oración 'El auto tiene el mejor motor que elegimos'. Como vemos la cadena 'el' se repite tres veces en la oración sin tener en cuenta mayúsculas y minúsculas:
El auto tiene el mejor motor que elegimos
Utilizamos el método exec ya que el método test solo tiene en cuenta la primera ocurrencia.
Para que tenga sentido la llamada de sucesivas veces del método exec debemos activar el modificador g (global)
Si no activamos el modificador global cada vez que llamamos al método exec la búsqueda comienza desde el principio.

Javascript Parte LXXXV

Hasta ahora siempre hemos empleado el método test que retorna un valor true si el string cumple el patrón propuesto o false en caso contrario.
La clase RegExp cuenta con otro método llamado exec que retorna un vector con más datos en caso que el string cumpla el patrón propuesto o null si no cumple el patrón.
Veamos con un problema que datos extras retorna este vector.



<html>
<head>
</head>
<body>

<script type="text/javascript">
  var oracion='saliendo de la casa que esta en la montaña';
  var patron1=/la/;
  var vector1=patron1.exec(oracion);
  document.write(vector1.index);
  document.write('<br>');
  document.write(vector1.input);
  document.write('<br>');
  var patron2=/lax/;
  var vector2=patron2.exec(oracion);
  document.write(vector2);
</script>

</body>
</html>
Hemos definido en la variable oracion el valor : 'saliendo de la casa que esta en la montaña'. El primer patrón de búsqueda es verificar si contiene los caracteres 'la' la oración:
  var oracion='saliendo de la casa que esta en la montaña';
  var patron1=/la/;
  var vector1=patron1.exec(oracion);
El método exec retornará un valor distinto a null (tener en cuenta que retorna un vector) ya que la palabra la está contenida en la oración.
El vector devuelto por el método exec tiene dos propiedades llamadas index e input:
La propiedad index almacena la posición dentro del string donde se cumple el patrón, en nuestro ejemplo retorna un 12 que es la posición donde se encuentra la l:
saliendo de la casa que esta en la montaña
La propiedad input almacena la cadena que se está analizando.
La segundo parte del problema define un segundo patrón:
  var patron2=/lax/;
  var vector2=patron2.exec(oracion);
Como no se encuentra en el string la cadena 'lax' el método exec retorna un valor null, es decir no retorna un vector.

Javascript Parte LXXXIV

Los paréntesis abiertos y cerrados pueden tener varios significados en las expresiones regulares. El fundamental es el agrupar una parte de la expresión regular y aplicarle operaciones como |, *, +, ? etc.
Problema
Elaborar una expresión regular que permita validar si se ingresó correctamente un valor entero o real y que eventualmente lleve el caracter + o - al principio. Validar que si se ingresa la coma debe ingresarse la parte real
<html>
<head>
</head>
<body>

<script type="text/javascript">
  var nro=prompt('ingrese un número entero o real:','');
  var patron=/^[+-]?\d+(\,\d+)?$/;
  if (patron.test(nro))
    alert('Correcto');
  else
    alert('Incorrecto');
</script>

</body>
</html>
Podemos analizar esta expresión regular:
  var patron=/^[+-]?\d+(\,\d+)?$/;
Como la coma y la parte decimal son opcionales los encerramos entre paréntesis y lo finalizamos con el cuantificador '?'
Esto hace que cuando se ingresa la coma deba ingresarse uno o más dígitos obligatoriamente ya que los agrupamos mediante los paréntesis.
Problema
Ingresar una hora con el formato hh:mm:ss, plantear una expresión regular que valide si es correcta.
<html>
<head>
</head>
<body>

<script type="text/javascript">
  var hora=prompt('ingrese una hora con el formato hh:mm:ss','');
  var patron=/^(0[1-9]|1\d|2[0-3]):([0-5]\d):([0-5]\d)$/;
  if (patron.test(hora))
    alert('Correcto');
  else
    alert('Incorrecto');
</script>

</body>
</html>
Analicemos un poco como hemos agrupado cada uno de las secciones de la hora:
  var patron=/^(0[1-9]|1\d|2[0-3]):([0-5]\d):([0-5]\d)$/;
La parte inicial puede tomar un valor entre 0 y 23:
(0[1-9]|1\d|2[0-3])
Utilizamos el metacarácter | para permitir ingresar el cero seguido de un valor entre 1 y 9, o el valor 1 y cualquier dígito, o el dos seguido del dígito 0,1,2, o 3.
Luego debe ingresarse el caracter dos puntos.
La parte de los segundos queda definida por el patrón ([0-5]\d) es decir un valor entre 0 y 5 seguido de cualquier dígito.
Finalmente los segundos es similar a los minutos: ([0-5]\d)

Javascript Parte LXXXIII

El metacarácter punto hace coincidir con cualquier carácter menos el salto de línea.
Por ejemplo si queremos validar el ingreso de cualquier cadena de 5 caracteres que comience con a y finalice con a podemos plantear la siguiente expresión regular:
  var patron=/^a...a$/;
Estamos indicando que la cadena debe comenzar con una letra a luego hemos dispuesto tres metacaracteres punto donde se verifican verdadero cualquiera sea el carácter del string y finalmente indicamos que finaliza con la letra a.
El programa para probarlo es:
<html>
<head>
</head>
<body>

<script type="text/javascript">
  var cadena=prompt('Ingrese una cadena de cinco caracteres que comience y finalice con a','');
  var patron=/^a...a$/;
  if (patron.test(cadena))
    document.write('cadena correcta');
  else
    document.write('cadena incorrecta');
</script>

</body>
</html>
Podemos utilizar un cuantificador para no repetir tres veces el metacarácter punto:
  var patron=/^a.{3}a$/;
Es importante recordar que siempre que necesitemos utilizar alguno de los metacaracteres como dato a buscar es necesario escaparlo con la barra invertida, por ejemplo si queremos verificar si un número tiene el formato 999.99:
<html>
<head>
</head>
<body>

<script type="text/javascript">
  var nro=prompt('Ingrese un número con el formato 999.99','');
  var patron=/^\d{3}\.\d{2}$/;
  if (patron.test(nro))
    document.write('nro correcto');
  else
    document.write('nro incorrecto');
</script>

</body>
</html>
Es fundamental escapar el carácter punto \.
Esta expresión la podemos leer: debe comenzar con 3 dígitos obligatoriamente, luego un punto y finalmente dos dígitos.

jueves, 4 de enero de 2018

Javascript Parte LXXXII

Permite analizar entre varias opciones posibles. El carácter de alternancia es el |.
Ejemplos de sintaxis para alternancia entre opciones:
  [uno|dos|tres]
  [a|e]
  [hombre|mujer]
Problema
Validar el ingreso de un típo y nro de factura. Para que sea correcto el primer carácter debe ser a,b o c y el nro debe tener uno o más dígitos.
<html>
<head>
</head>
<body>

<script type="text/javascript">
  var factura=prompt('Ingrese tipo y nro de factura:','');
  var patron=/^[a|b|c]\d+$/;
  if (patron.test(factura))
    document.write('Se ingresó un tipo y nro de factura correcta');
  else
    document.write('Se ingresó un tipo y nro de factura incorrecta');
</script>

</body>
</html>
La expresión regular queda definida como:
  var patron=/^[a|b|c]\d+$/;
Es decir debe comenzar con un carácter a,b o c, seguido de uno dígitos.
Problema
Validar si una palabra comienza con los caracteres va o ba
<html>
<head>
</head>
<body>

<script type="text/javascript">
  var palabra=prompt('Ingrese una palabra que comience con va o ba:','');
  var patron=/^[va|ba]/;
  if (patron.test(palabra))
    document.write('La palabra comienza con va o ba');
  else
    document.write('La palabra no comienza con va o ba');
</script>

</body>
</html>

Javascript Parte LXXXI

Hay patrones de búsqueda que son de uso muy frecuente como buscar dígitos por lo que se creó una sintaxis abreviada:
Código Equivalente
\d      [0-9]
\D      [^0-9]
\w      [a-zA-Z0-9_]
\W      [^a-zA-Z0-9_]
\s espacio en blanco
Tener en cuenta que estos caracteres son las iniciales de decimal, word y space.
Problema
Verificar si un número ingresado por teclado tiene exactamente 5 dígitos.
<html>
<head>
</head>
<body>

<script type="text/javascript">
  var valor=prompt('Ingrese un valor numérico de 5 dígitos','');
  var patron=/^\d{5}$/;
  if (patron.test(valor))
    document.write('Tiene 5 dígitos');
  else
    document.write('No tiene 5 dígitos');
</script>

</body>
</html>
La expresión regular en lugar de utilizar los corchetes de valores opcionales utilizamos el carácter de escape y la d:
  var patron=/^\d{5}$/;
Es más corto y legible que utilizar:
  var patron=/^[0-9]{5}$/;
Problema
Ingresar una oración y mostrar un mensaje si tiene al menos una palabra de 4 caracteres.
<html>
<head>
</head>
<body>

<script type="text/javascript">
  var oracion=prompt('Ingrese una oracion','');
  var patron=/\s?\w{4}\s?/;
  if (patron.test(oracion))
    document.write('Tiene al menos una palabra de 4 caracteres');
  else
    document.write('No tiene una palabra de 4 caracteres');
</script>

</body>
</html>
El patrón queda definido con la siguiente sintaxis:
  var patron=/\s?\w{4}\s?/;
Es decir debe ingresarse posiblemente un espacio en blanco (el cuantificador ? debemos utilizarlo porque la palabra puede estar al principio del string y no tener un espacio en blanco antes de la primer letra), seguidamente 4 caracteres y posiblemente un espacio en blanco (el cuantificador ? debemos utilizarlo porque la palabra puede estar al final del string y no tener un espacio en blanco después de la última letra)

Javascript Parte LXXX

La sintaxis de las expresiones regulares define tres metacaracteres que pueden utilizarse en lugar de la sintaxis vista en el concepto anterior.
Caracteres:
?    busca cero o una ocurrencia en el string
     remplaza a    {0,1}
*    busca cero o más ocurrencias en el string
     remplaza a    {0,}
+    busca una o más ocurrencias en el string
     remplaza a    {1,}

Problema
Ingresar una palabra por teclado y validar que tenga al menos una vocal.
<html>
<head>
</head>
<body>

<script type="text/javascript">
  var palabra=prompt('Ingrese una palabra con al menos una vocal:','');
  var patron=/[aeiou]+/;
  if (patron.test(palabra))
    document.write('La palabra ingresada tiene al menos una vocal');
  else
    document.write('La palabra ingresada no tiene vocales');
</script>

</body>
</html>
La expresión regular planteada utiliza el metacaracter + :
  var patron=/[aeiou]+/;
Con esto se analiza cada letra del string y si al menos uno tiene una vocal luego el método test de la expresión regular se verifica verdadera.
Utilizando la otra sintaxis la expresión sería:
  var patron=/[aeiou]{1,}/;
Problema
Ingresar un valor numérico entero que podemos opcionalmente antecederle alguno de los caracteres: + o -.
<html>
<head>
</head>
<body>

<script type="text/javascript">
  var valor=prompt('Ingrese un valor numérico entero, puede anteceder el +/-:','');
  var patron=/^[\+\-]?[0-9]+$/;
  if (patron.test(valor))
    document.write('Tiene un formato correcto');
  else
    document.write('Formato incorrecto');
</script>

</body>
</html>
El patrón queda definido con la siguiente sintaxis:
  var patron=/^[\+\-]?[0-9]+$/;
Es decir con la sintaxis ^[\+\-]? estamos indicando que el primer carácter debe ser un + o - y como fuera de los corchetes indicamos el carácter ? que indica que busca cero o una ocurrencia (es decir es opcional disponer el + o -)
Luego indicamos con la sintaxis [0-9]+$ que se debe ingresar uno o más dígitos (con es +) y debe finalizar con un dígito.
Es test se verifica correcto si ingresamos:
1200
+300
-55
e incorrecto si ingresamos:
10z55
+34aa2
+-20
+++34
Problema
Ingresar un valor numérico entero o real, se debe validar que se ingrese al menos un número previo al operador punto que es opcional y finalizar con un número obligatoriamente.
<html>
<head>
</head>
<body>

<script type="text/javascript">
  var valor=prompt('Ingrese un valor numérico entero o real:','');
  var patron=/^[0-9]+\.?[0-9]+$/;
  if (patron.test(valor))
    document.write('Tiene un formato correcto');
  else
    document.write('Formato incorrecto');
</script>

</body>
</html>
La expresión comienza con ^[0-9]+ lo que significa que se debe ingresar en la primer posición un dígito. Luego es opcional el carácter . ya que empleamos el metacaracter de interrogación \.? y finalmente debe terminar con un dígito obligatoriamente [0-9]+$

Javascript Parte LXXIX

Ahora veremos que podemos inicializar luego que indicamos entre corchetes el patrón a buscar la cantidad de veces que puede repetirse este patrón.
Son útiles para controlar la cantidad de repeticiones del patrón definido.
Se especifican luego del corchete donde definimos los caracteres permitidos:
Verificar si contiene entre 3 y 6 dígitos:
var patron=/[0-9]{3,6}/;
Verificar si contiene 3:
var patron=/[0-9]{3}/;
Verificar si contiene 3 o más dígitos:
var patron=/[0-9]{3,}/;
Problema Ingresar una oración y mostrar si se ingresó un número que tiene al menos 2 dígitos.
<html>
<head>
</head>
<body>

<script type="text/javascript">
  var oracion=prompt('Ingrese una palabra','');
  var patron=/[0-9]{2,}/;
  if (patron.test(oracion))
    alert('La oración tiene un número de al menos 2 dígitos');
  else
    alert('La oración no tiene un número de al menos 2 dígitos');
</script>

</body>
</html>
La expresión regular se verifica verdadera si se ingresa:
Yo tengo 20 años.
Yo tengo 101 años.
La expresión regular se verifica falsa si se ingresa:
Yo tengo 5 años.
Problema Ingresar una patente de un auto de argentina y luego mostrar un mensaje si es correcto o no su valor. Toda patente está constituida por 3 números y tres letras en ese orden (ej. 345afg )
<html>
<head>
</head>
<body>

<script type="text/javascript">
  var patente=prompt('Ingrese un nro de patente','');
  var patron=/[0-9]{3}[a-z]{3}/;
  if (patron.test(patente))
    alert('La patente ingresada es correcta');
  else
    alert('La patente ingresada no es correcta');
</script>

</body>
</html>
A primera medida este patrón resolvería nuestro problema:
  var patron=/[0-9]{3}[a-z]{3}/;
Se verifica verdadero si se ingresa:
123abc
934zaq
Se verifica falso si se ingresa:
123ab
12abc
Pero tenemos un problema ya que si ingresamos:
123abcd
SE VERIFICA VERDADERO.
Para resolver esto debemos modificar el patrón indicando que los últimos tres caracteres deben ser letras:
  var patron=/[0-9]{3}[a-z]{3}$/;
Ahora si ingresamos 123abcd se verifica falso.
Pero todavía tenemos otro problema al ingresar:
1234abc
Y finalmente para que funcione correctamente debemos definir el patrón:
  var patron=/^[0-9]{3}[a-z]{3}$/;
El algoritmo correcto es el siguiente:
<html>
<head>
</head>
<body>

<script type="text/javascript">
  var patente=prompt('Ingrese un nro de patente','');
  var patron=/^[0-9]{3}[a-z]{3}$/;
  if (patron.test(patente))
    alert('La patente ingresada es correcta');
  else
    alert('La patente ingresada no es correcta');
</script>

</body>
</html>
Problema
Ingresar una oración y mostrar si se ingresó uno o más números con exactamente 5 dígitos.
Para resolver este problema debemos definir un patrón que identifique un número con exactamente cinco dígitos y que antes y después de este tenga un espacio en blanco. Para identificar el espacio en blanco debemos introducir en la expresión regular el carácter de escape y la letra s, es decir \s
El algoritmo luego es:
<html>
<head>
</head>
<body>

<script type="text/javascript">
  var oracion=prompt('Ingrese una oracion','');
  var patron=/\s[0-9]{5}\s/;
  if (patron.test(oracion))
    alert('La oración tiene un número de 5 dígitos');
  else
    alert('La oración no tiene un número de 5 dígitos');
</script>

</body>
</html>
Ahora vemos la expresión regular definida es:
  var patron=/\s[0-9]{5}\s/;
Es decir que para que se valide verdadero el string debe contener un espacio en blanco, seguido de 5 dígitos y otro espacio en blanco.

Javascript Parte LXXVIII

Ahora veremos el significado de los caracteres [] en una expresión regular. Se emplea estos caracteres para encerrar los caracteres permitidos.
problema Controlar si la palabra ingresada comienza con el primer carácter alfabético ya sea en mayúsculas o en minúsculas:

<html>
<head>
</head>
<body>

<script type="text/javascript">
  var palabra=prompt('Ingrese una palabra','');
  var patron=/^[a-zA-Z]/;
  if (patron.test(palabra))
    alert('La palabra comienza con un carácter alfabético (mayúscula o minúscula)');
  else
    alert('La palabra no comienza con un carácter alfabético (mayúscula o minúscula)');
</script>

</body>
</html>
Debemos especificar cada uno de los caracteres permitidos encerrados entre los corchetes. Cuando los caracteres son seguidos en la tabla de caracteres podemos utilizar el carácter '-' para indicar un rango de caracteres:
  var patron=/^[a-zA-Z]/;
Como solo debemos verificar el primer carácter utilizamos el comando '^' y le sigue los caracteres posibles.
problema
Ingresar una palabra y luego mostrar un mensaje si finaliza con vocal.
<html>
<head>
</head>
<body>

<script type="text/javascript">
  var palabra=prompt('Ingrese una palabra','');
  var patron=/[aeiouAEIOUáéíóú]$/;
  if (patron.test(palabra))
    alert('La palabra finaliza con vocal');
  else
    alert('La palabra no finaliza con vocal');
</script>

</body>
</html>
En la expresión regular debemos especificar entre corchetes todas las vocales y como no están en forma seguida en la tabla de caracteres debemos especificarlas una por una:
  var patron=/[aeiouAEIOUáéíóú]$/;
Como debemos controlar el último carácter de la oración utilizamos el comando $
Hemos utilizado el carácter '^' para encontrar coincidencias desde el principio del string, pero este carácter dentro de los corchetes abiertos y cerrados tiene otro uso. Permite obtener todos los otros caracteres distintos a los especificados.
problema
Ingresar una clave que no finalice en vocal.
<html>
<head>
</head>
<body>

<script type="text/javascript">
  var palabra=prompt('Ingrese una palabra','');
  var patron=/[^aeiouAEIOUáéíóú]$/;
  if (patron.test(palabra))
    alert('La palabra no finaliza con vocal');
  else
    alert('La palabra finaliza con vocal');
</script>

</body>
</html>
problema
Ingresar una palabra y luego mostrar un mensaje si contiene una vocal en alguna parte de la palabra.
<html>
<head>
</head>
<body>

<script type="text/javascript">
  var palabra=prompt('Ingrese una palabra','');
  var patron=/[aeiouAEIOUáéíóú]/;
  if (patron.test(palabra))
    alert('La palabra tiene al menos una vocal');
  else
    alert('La palabra no tiene vocales');
</script>

</body>
</html>
Ahora nuestra expresión regular queda especificada como:
  var patron=/[aeiouAEIOUáéíóú]/;
El método test retorna true si ingresamos alguna de las siguientes palabras:
casa
madre
salir
En cambio retorna false si ingresamos:
pbt
Cuando tenemos que buscar en el string alguno de los caracteres que tienen un significado especial en las expresiones regulares '^ $. * +? =! : | \ / () [] {} ' debemos escaparlos a algunos dentro de los corchetes.
problema
Ingresar una oración por teclado y luego mostrar un mensaje si el string ingresado contiene al menos uno de los caracteres que son un comando o metacaracter para las expresiones regulares:
<html>
<head>
</head>
<body>

<script type="text/javascript">
  var oracion=prompt('Ingrese una oracion','');
  var patron=/[\^$.*+?=!:|\\/()\[\]{}]/;
  if (patron.test(oracion))
    alert('La oración tiene al menos un carácter ^ $. * +? =! : | \ / () [] {}');
  else
    alert('La oración no tiene ningún carácter ^ $. * +? =! : | \ / () [] {}');
</script>

</body>
</html>
Se verifica verdadero el método test si ingresamos:
La tarde estaba soleada!
Se verifica falso el método test si ingresamos:
La tarde estaba soleada
problema
Ingresar todos los caracteres con significada especial en las expresiones regulares en el siguiente orden: ^$.*+?=!:|\/()[]{} (es necesario escapar todos los metacaracteres):
<html>
<head>
</head>
<body>

<script type="text/javascript">
  var cadena=prompt('Ingrese esos caracteres especiales para expresiones regulares en este mismo orden: ^$.*+?=!:|\/()[]{} ','');
  var patron=/^\^\$\.\*\+\?\=\!\:\|\\\/\(\)\[\]\{\}$/;
  if (patron.test(cadena))
    alert('Orden correcto');
  else
    alert('Incorrecto');
</script>

</body>
</html>

Javascript Parte LXXVII

Los dos primeros caracteres con un significado especial en una expresión regular son: ^ principio de cadena y $ fin de cadena.
Cuando queremos controlar si un string comienza con un determinado carácter o conjunto de caracteres podemos implementar una expresión regular antecediendo al o los caracteres el símbolo ^.
problema
Ingresar una oración y mostrar un mensaje si la misma comienza con el carácter '-'.
Otro mensaje si comienzo con la palabra 'hora'.
<html>
<head>
</head>
<body>

<script type="text/javascript">
  var oracion=prompt('Ingrese una oración','');
  var patron1=/^-/;
  if (patron1.test(oracion))
    alert('Comienza la oración con el carácter -');
  else
    alert('No comienza la oración con el carácter -');
  var patron2=/^hora/;
  if (patron2.test(oracion))
    alert('Comienza la oración con la palabra hora');
  else
    alert('No comienza la oración con la palabra hora');
</script>

</body>
</html>
La primer expresión regular la definimos con la siguiente sintaxis (luego del carácter ^ disponemos el carácter que debe ingresar primero el operador para que la expresión se valide correctamente):
  var patron1=/^-/;
Luego vemos que podemos disponer un conjunto de caracteres:
  var patron2=/^hora/;
Con esta expresión el operador debe ingresar los cuatro primeros caracteres iguales a los dispuestos después del carácter ^.
problema
Ingresar una palabra y mostrar un mensaje si la misma finaliza con el string 'ón'
<html>
<head>
</head>
<body>

<script type="text/javascript">
  var oracion=prompt('Ingrese una palabra','');
  var patron=/ón$/;
  if (patron.test(oracion))
    alert('La palabra finaliza con los caracteres \'ón\'');
  else
    alert('La palabra no finaliza con los caracteres \'ón\'');
</script>

</body>
</html>
Cuando queremos verificar si una cadena finaliza con un determinado carácter o conjunto de caracteres debemos disponer al final el carácter $ y antecederle el o los caracteres a verificar:
En el ejemplo anterior si ingresamos las palabras 'constitución', 'camión', 'edición' luego el método test retorna verdadero. En cambio si ingresamos 'cama', 'mano' el método test retorna falso ya que dichas palabras no finalizan con el string 'ón'.