Expresiones Regulares (¿o Regular Expressions?)

[[Bicho]]

Hola, pues yo tampoco tengo ni idea de lo que son y por lo que leo en el ClubDelphi, todo el mundo habla maravillas de ello.

Y como no la Wikipedia tiene la solucion:

Expresión regular

Tambien buscando un poco por los foros he encontrado un par de hilos que quiza puedan ser interesantes:

Regexp... ??

Guia de herramientas para programadores!

Así que nos toca empezar a leer.

Espero sirva para empezar

Saludos

[Ñuño Martínez]

Gracias Bisho.

¡Cuándo aprenderé que hay que usar los buscadores antes de hacer preguntas tontas!

[[Bicho]]

Empezado por Ñuño Martínez

¡Cuándo aprenderé que hay que usar los buscadores antes de hacer preguntas tontas!

Cuando aprendas que mi nick es Bicho y no Bisho, que no soy andalús!! leshe!! soy mallorquín!!

Es coña, eh?

En cuanto a lo de las preguntas tontas, no dicen algo así como no hay mayor ignorante que el que no pregunta? Tu ya has preguntado y ya sabes algo más no?

Además la pregunta no ha sido tonta, a mí me ha servido para (además de ponerme a buscar ) para aprender algo nuevo.

Saludos

[[Lepe]]

Ya teneís links "más profesionales", aquí solo expongo una idea general para saber si es lo que necesitaís o no.

-El propio delphi tiene rutinas para crear expresiones regulares.
- Lex es una analizador léxico (que tiene una versión en delphi)
- Yacc es un analizador sintáctico (que tambien existe en version delphi)

¿Y qué demonios son analizadores lexico/sintactico?

analizador lexico:

[a..z]+            : mostrar('el usuario ha escrito al menos una letra desde la a a la z');
[0..9]+             : mostrar('el usuario ha escrito al menos un número');
[a..z]+[0..9]+     : mostrar(' el usuario ha escrito al menos una letra y despues un número');

Es decir, se puede "adivinar" lo que el usuario va escribiendo, vamos el típico caso de escribir en Word: "Estimado Señor:" y salta el asistente de office diciendo: "Veo que está escribiendo una carta, ¿necesita ayuda?

[a..z]+ es lo que se llama una expresión regular, que se validará solo cuando el usuario pulse una o más letras pertenecientes al rango a..z

Analizador sintáctico:
Es el encargado de verificar el orden en el que se han escrito las palabras. Si el usuario escribe : "Señor Estimado:" no debe saltar el asistente de office, porque no se ha escrito en el orden correcto. Este analizador sólo se encarga del Orden, por ejemplo:

Sacar_Asistente_ si:  "Estimado señor:" o bien
                      "Estimados señores:" o bien
                      "Estimado Cliente:"   o bien
                      "Estimado amigo:"

Aunque muchos no os lo creaís, me atrevo decir que es el futuro de la programación: Detectar qué quiere el usuario en cada momento para brindarle ayuda o asistentes paso a paso y no complicarles la vida en inmensos archivos hlp.

Por cierto, ¿como creeís que se obtienen las partes de un SQL?
SELECT nombrecampos FROM nombretablas WHERE condiciones HAVING ... ORDER BY
A través de un Parser se buscan los tokens (palabras reservadas SELECT, FROM, WHERE,ect) y se validan sin son correctas sintácticamente o no.

Saludos

[roman]

Para entender de qué van las expresiones regulares quizá te sirva este mensaje y si no, por lo menos el tutorial que enlazo al final del mismo. Se trata de las expresiones regulares tipo P_E_R_L (o sea, las que se usan en P_E_R_L) que son muy populares. El tutorial en cuestión, es para el uso de las expresiones en PHP aunque es buena introducción general.

En cuanto a:

Empezado por Lepe

El propio delphi tiene rutinas para crear expresiones regulares.

Pues sí que me sorprende; hasta donde yo sé, es una de las grandes carencias de Delphi. Claro que existen componentes y clases de terceros, muchas de las cuales ya se han mencionado aquí y en los foros en general. Lo más cercano a expresiones regulares que he visto en Delphi es el MatchesMask de la unidad Mask, pero es francamente limitado.

Y en cuanto a esto:

Empezado por Lepe

me atrevo decir que es el futuro de la programación: Detectar qué quiere el usuario en cada momento para brindarle ayuda o asistentes paso a paso y no complicarles la vida en inmensos archivos hlp.

Por dios, espero que no, bastante fastidioso es el ayudante de office diciendome a cada momento que quiero escribir una carta.

// Saludos

[[Bicho]]

Muchas gracias Lepe y Roman por sus lecciones magistrales y sus links de gran interés.

La verdad es que ahora queda mucho más claro todo.

Saludos

[[Lepe]]

roman: supongo que conoces la unidad ConvUtils.pas, donde se puede crear conversiones entre unidades de medida, pesos, etc. Pues juraría que he visto la misma filosofía con expresiones regulares en Delphi 6 hace un par de años, lo encontré de pasada y no entendí la filosofía de uso, así que lo descarté.

Usando el Grep Search de GExpert he obtenido algunas cosas:

En BDS 2006 en la unidad Nsapi.pas, solo he podido encontrar esto:

Código Delphi [-]
{*****************************************************************************}
{* From shexp.h                                                               }
{*****************************************************************************}
{
  Defines and prototypes for shell exp. match routines


  This routine will match a string with a shell expression. The expressions
  accepted are based loosely on the expressions accepted by zsh.

  o * matches anything
  o ? matches one character
  o \ will escape a special character
  o $ matches the end of the string
  o [abc] matches one occurence of a, b, or c. The only character that needs
          to be escaped in this is ], all others are not special.
  o [a-z] matches any character between a and z
  o [^az] matches any character except a or z
  o ~ followed by another shell expression will remove any pattern
      matching the shell expression from the match list
  o (foo|bar) will match either the substring foo, or the substring bar.
              These can be shell expressions as well.

  The public interface to these routines is documented below.
}

{* --------------------------- Public routines ---------------------------- *}

{
  shexp_valid takes a shell expression exp as input. It returns:

   NON_SXP      if exp is a standard string
   INVALID_SXP  if exp is a shell expression, but invalid
   VALID_SXP    if exp is a valid shell expression
}

const
   NON_SXP = -1;
   INVALID_SXP = -2;
   VALID_SXP = 1;

{* and generic shexp/regexp versions *}
   NON_WILDPAT     = NON_SXP;
   INVALID_WILDPAT = INVALID_SXP;
   VALID_WILDPAT   = VALID_SXP;

{* and regexp versions *}
   NON_REGEXP      = NON_SXP;
   INVALID_REGEXP  = INVALID_SXP;
   VALID_REGEXP    = VALID_SXP;

function shexp_valid(exp: PChar): Integer; cdecl;

{
  shexp_match

  Takes a prevalidated shell expression exp, and a string str.

  Returns 0 on match and 1 on non-match.
}
function shexp_match(str, exp: PChar): Integer; cdecl;

{
  shexp_cmp

  Same as above, but validates the exp first. 0 on match, 1 on non-match,
  -1 on invalid exp. shexp_casecmp does the same thing but is case
  insensitive.
}
function shexp_cmp(str, exp: PChar): Integer; cdecl;
function shexp_casecmp(str, exp: PChar): Integer; cdecl;
****************************
function shexp_valid; external nshttp name 'shexp_valid';
function shexp_match; external nshttp name 'shexp_match';
function shexp_cmp; external nshttp name 'shexp_cmp';
function shexp_casecmp; external nshttp name 'shexp_casecmp';
****************************

En la unidad ToolsApi.pas he encontrado esto, aunque el prefijo "IOTA" me deja KO.

Código Delphi [-]
  IOTASearchOptions = interface(IUnknown)
    ['{D1766F8B-D915-11D2-A8C1-00C04FA32F53}']
    function GetCaseSensitive: Boolean;
    function GetDirection: TSearchDirection;
    function GetFromCursor: Boolean;
    function GetRegularExpression: Boolean;
    function GetSearchText: string;
    function GetWholeFile: Boolean;
    function GetWordBoundary: Boolean;
    procedure SetCaseSensitive(Value: Boolean);
    procedure SetDirection(Value: TSearchDirection);
    procedure SetFromCursor(Value: Boolean);
    procedure SetRegularExpression(Value: Boolean);
    procedure SetSearchText(const Value: string);
    procedure SetWholeFile(Value: Boolean);
    procedure SetWordBoundary(Value: Boolean);

    property CaseSensitive: Boolean read GetCaseSensitive write SetCaseSensitive;
    property Direction: TSearchDirection read GetDirection write SetDirection;
    property FromCursor: Boolean read GetFromCursor write SetFromCursor;
    property RegularExpression: Boolean read GetRegularExpression write SetRegularExpression;
    property SearchText: string read GetSearchText write SetSearchText;
    property WholeFile: Boolean read GetWholeFile write SetWholeFile;
    property WordBoundary: Boolean read GetWordBoundary write SetWordBoundary;
  end;

En dotNet\rtl\Borland.Vcl.Masks.pas tambien he encontrado cosas, pero en Delphi 6 no estará, que precisamente es donde recuerdo haberlo visto.

¿Podrías realizar algunas búsquedas en Delphi 6 para comprobar si existen lo que he encontrado? Gracias.

Saludos