Como todos sabemos en cualquier formulario de HTML siempre necesitamos validar ciertos campos o condiciones de los mismos para dar el OK, y que a todo el formulario se le pueda dar un submit, y para esto aqui hay algunas expresiones regulares útiles para validar ciertos criterios que pueden llegar a servir.

Read more…

Capitalizar es un anglicismo que proviene del verbo Capitalize, y que en inglés significa pasar a mayúsculas una palabra o pasar a mayúscula la primera letra de una palabra dejando el resto en minúsculas. Y es a esto último lo que se me refiero.

En PostgreSQL existen varias funciones para manejo de strings de uso común, como lower() y upper(), pero no existe una para Capitalizar (gracias a Cristian por la aclaración), por lo que debido a la necesidad, escribí una haciendo uso de las funciones.

  • regexp_replace
  • string_to_array
  • array_dims
  • upper
  • lower

Yo quería hacerlo utilizando backreferences en expresiones regulares, pero no pude aplicar una transformación a la backreference, por lo que si a alguien tiene una mejor forma de hacerlo, espero sus comentario. 😛

Aquí les dejo el código:


CREATE OR REPLACE FUNCTION capitalize(_texto text)
RETURNS text AS
$BODY$
DECLARE
fin INTEGER;
temporal RECORD;
retval TEXT;
BEGIN
retval = ' ';
FOR temporal IN SELECT string_to_array (_texto,' ') AS arreglo LOOP
SELECT regexp_replace(
regexp_replace(
array_dims(temporal.arreglo),'[^1-9]','','g')
,'.','')::integer into fin;
FOR i IN 1..fin LOOP
retval = retval
|| upper(substring(temporal.arreglo[i],1,1))
|| lower(regexp_replace(temporal.arreglo[i],'(.)(.*)','\\2'))
||' ';
END LOOP;
END LOOP;
RETURN trim(retval);
END;
$BODY$
LANGUAGE 'plpgsql' VOLATILE;

Como siempre, espero que les sirva, y Hasta la próxima!

Al empezar a utilizar expresiones regulares, una de las primeras situaciones con las que me topé, es la de que algunos de los operadores cuantificadores poseen cierto comportamiento como el de ser perezosos o codiciosos al momento de hacer ‘match’ con la cadena especificada. Antes de explicar de que se trata este comportamiento, recordemos los operadores cuantificadores:

  • *‘ indica que la expresión puede venir cero o más veces,
  • +‘ indica que la expresión puede venir una o más veces,
  • ?‘ indica que la expresión puede o no venir.

Empecemos la explicación con un ejemplo escrito en php y haciendo uso de la librería de expresiones regulares de php: PCRE (Compatibles con Perl).

Supongamos que tenemos analizar un código html en el cual nos interesa extraer el texto que está contenido entre etiquetas ‘div’. El código html de ejemplo es :

<div>esto es un ejemplo de texto</div> <div> se mostrara como funcionan en modo perezoso o codicioso</div>

Para extraer el texto contenido en el div usamos la siguiente expresión regular: <div>(.*)</div>
que utilizando php la definimos así:

$patron = '/<div>(.*)<\/div>/';

Utilizaremos la función preg_match_all para obtener las cadenas que concuerden con la expresión regular propuesta. El script se vería de la siguiente manera:

<?php
$texto = "<div>esto es un ejemplo de texto</div> <div> se mostrara como funcionan en modo perezoso o codicioso</div>";
$patron = '/<div>(.*)<\/div>/U';
preg_match_all ($patron, $texto, $matches);
echo "<pre>";
print_r($matches);
echo "</pre>";
?>


Si ejecutamos el script, podemos ver que la cadena que hace match es:

[0] => 'esto es un ejemplo de texto</div><div> se mostrara como funcionan en modo perezoso o codicioso'.

Pero este resultado no es el que esperabamos. ¿Qué pasó aquí? Es ahora que podemos hablar del cuantificador codicioso, el cual trata de hacer match a la cadena más grande que encuentre. Y eso fue lo que pasó con el script, hizo match desde la apertura de la etiqueta ‘<div>’ y debido al operador (.*) incluyó todo el texto intermedio sin detenerse en el primer cierre ‘</div>’, ya que siguió buscando si encontraba otro cierre de la etiqueta, el cual lo encontró al final de la cadena.

Entonces ¿cómo hacemos para que obtener el texto dentro de cada etiquetas ‘div’? Transformado el cuantificador codicioso en un cuantificador perezoso para que haga match con la cadena más corta que encuentre. Y eso se puede hacer agregando ‘?’ despues de la expresion (.*). La expresión regular quedaría entonces de la siguiente manera:

<div>(.*?)</div>

Reescribiendo el script:

<?php
$texto = "<div>esto es un ejemplo de texto</div> <div> se mostrara como funcionan en modo perezoso o codicioso</div>";
$patron = '/<div>(.*?)<\/div>/';
preg_match_all ($patron, $texto, $matches);
echo "<pre>";
print_r($matches[1]);
echo "</pre>";
?>


Lo ejecutamos y vemos que ahora ya nos devuelve unicamente el contenido que esta dentro de cada etiqueta ‘div’:

Array
(
[0] => esto es un ejemplo de texto
[1] => se mostrara como funcionan en modo perezoso o codicioso
)

Este mismo comportamiento se aplica a los demás cuantificadores:

Codicioso Perezoso
(.*) (.*?)
(.+) (.+?)
(?) (??)

Asi que ahora podemos usarlos de manera codiciosa o perezosa según nos convenga.

Como información adicional, las expresiones regulares PCRE de php nos ofrecen el modificador U (PCRE_UNGREEDY) para poder alterar este comportamiento, haciendo que los cuantificadores que son codiciosos de manera predeterminada, se vuelvan perezosos. Usando este modificador el patrón quedaría así:

$patron = '/<div>(.*)<\/div>/U';

Y eso es todo amigos… hasta la próxima.