IDE regular expressions/pl

From Lazarus wiki
Jump to navigationJump to search

English (en) español (es) suomi (fi) polski (pl)

IDE wyrażeń regularnych

Pakiet RegExpr zawiera wiele implementacji wyrażeń regularnych

Regexpr wg Sorokina

Jest to najbardziej kompletna implementacja dostępna w packages/regexpr/src/regexpr.pas

Przeczytaj stronę wikipedii o wyrażeniach regularnych, aby zapoznać się z tym tematem: Podstawowe wyrażenia regularne POSIX

Ten pakiet implementuje podzbiór wyrażeń regularnych Perla, a składnia dostarczona przez pakiet jest udokumentowana tutaj: https://regex.sorokin.engineer/regex

Zmiana wielkość liter w trakcie zastępowania

Możesz zmienić wielkość liter w znalezionych fragmentach, użyć modyfikatorów w polu zamień na (zmiana wielkości liter działa po pozycji modyfikatora):

  • \l - Pierwszy znak na małą literę
  • \L - Wszystkie znaki na małe litery
  • \u - Pierwszy znak na wielką literę
  • \U - Wszystkie znaki na wielkie litery

Np. jeśli znaleziono słowo, to użyj wyrażenie zastępowania „\L$0”, aby zmienić słowo na małe litery (tutaj 0$ jest grupą 0 znalezionego tekstu).

Ponadto \n zostanie zastąpiony znakiem końca wiersza (lub sekwencją znaków).

Prosty przykład użycia

Użycie RegExpr Sorokina do sprawdzenia, czy wyrażenie jest obecne w ciągu jest bardzo łatwe, po prostu utwórz instancję TRegExpr, a następnie umieść swoje wyrażenie regularne we właściwości TRegExpr.Expression, a następnie użyj metody Exec, aby sprawdzić, czy są jakieś dopasowania dla tego regularnego wyrażenie. Exec zwróci wartość true, jeśli wyrażenie pasuje do przekazanego mu ciągu.

var
  RegexObj: TRegExpr;
begin
  RegexObj := TRegExpr.Create;
  RegexObj.Expression := '.*zaloguj.*';
  if RegexObj.Exec('Proszę zaloguj się tutaj') then WriteLn('"zaloguj" został znaleziony!');
  RegexObj.Free;
end;

Dopasowanie podwyrażenia:

program Project1;

uses
  RegExpr;

var
  re: TRegExpr;
begin
  re := TRegExpr.Create('witaj (.*?)!');
  if re.Exec('witaj świecie! witaj pascal!') then
  begin
    WriteLn(re.Match[1]);
    while re.ExecNext do
    begin
      WriteLn(re.Match[1]);
    end;
  end;
  re.Free;
end.

Wynik:

świecie
pascal

FLRE - Wyrażenia regularne Fast Light wg BeRo1985

FLRE (F ast L ight R egular E xpressions) jest szybką, bezpieczną i wydajną biblioteką wyrażeń regularnych, która jest zaimplementowana w Object Pascal (Delphi i Free Pascal), ale może być nawet używana z innych językach, takich jak C/C++ i tym podobnych. Obsługuje ciągi Unicode i UTF8.

Implementuje wiele najpopularniejszych cech Perla i POSIX, z wyjątkiem funkcji wyrażeń nieregularnych, takich jak referencje do przodu i zagnieżdżone referencje do tyłu i tak dalej, które nie są obsługiwane w FLRE, ale obsługiwane są tylko prawdziwe referencje "wstecz", stąd też słowo „Light” w nazwie FLRE. Znajduje również dopasowanie od lewej do pierwszej, to samo dopasowanie, które zrobiłby Perl i PCRE, i może zwrócić informacje o subdopasowaniu. Ale ma także flagę dla eksperymentalnego, jak do tej pory, najbardziej lewostronnego trybu zachowania w stylu POSIX.

FLRE jest licencjonowany na licencji LGPL v2.1 z wyjątkiem statycznego linkowania.

repozytorium Github

Przykład

Implementacja funkcji PHP parse_url (oparta na parse_url)

uses Classes, SysUtils, flre;

type

    RUrlParser = record
private
    Fcomponents                 : array[1..13] of string;

private
    function    getComponent( aIndex : integer ) : string;
    procedure   setComponent( aIndex : integer; const aValue : string );

public
    function    parse( const aUrl : UTF8String ) : boolean;

public
    property scheme : string index 1 read getComponent write setComponent; // e.g. http
    property authority : string index 2 read getComponent;
    property userInfo : string index 3 read getComponent;
    property user : string index 4 read getComponent;
    property pass : string index 5 read getComponent;
    property host : string index 6 read getComponent;
    property port : string index 7 read getComponent;
    property path : string index 9 read getComponent;
    property directory : string index 10 read getComponent;
    property fileName : string index 11 read getComponent;
    property query : string  index 12 read getComponent; // after the question mark ?
    property fragment : string  index 13 read getComponent; // after the hashmark #

    end;

implementation

function RUrlParser.getComponent( aIndex : integer ) : string;
begin
    Result := Fcomponents[ aIndex ];
end;

procedure RUrlParser.setComponent( aIndex : integer; const aValue : string );
begin
    Fcomponents[ aIndex ] := aValue;
end;

function RUrlParser.parse( const aUrl : UTF8String ) : boolean; overload;
var
    i : integer;
    re : TFLRE;
    parts : TFLREMultiStrings;
begin
    re := TFLRE.Create( '(?:([^:\\/\?#]+):)?'
        + '(?:\/\/()(?:(?:()(?:([^:@\/]*):?([^:@\/]*))?@)?([^:\/?#]*)(?::(\d*))?))?'
        + '()'
        + '(?:(()(?:(?:[^?#\/]*\/)*)()(?:[^?#]*))(?:\?([^#]*))?(?:#(.*))?)'
        , [ rfUTF8 ]
    ); 

    parts := nil;
    Result := re.UTF8ExtractAll( aUrl, parts );
    if ( Result ) then
    begin
        for i := 1 to Length( parts[0] ) - 1 do
        begin
            setComponent( i, string( parts[0][i] ) );
        end;
    end;

    // Free regexp memory
    for i := 0 to Length( parts ) - 1 do
    begin
        SetLength( parts[i], 0 );
    end;
    parts := nil;

    re.Free();
end;

Regexpr wg Joosta

Regexpr stworzony przez Joosta (moduły oldregexpr.pp i regex.pp) jest bardzo podstawowym modułem wyrażeń regularnych, obsługuje większość wyrażeń regularnych takich jak GNU regexpr. Używa regex do wyszukiwania wzorców wewnątrz łańcucha znaków.

Obecny moduł jest daleki do ukończenia i nadal brakuje mu bardzo prostej obsługi składni POSIX lub bardziej złożonej składni, takiej jak w Perl regex, Java Regex, Ruby Regex itp ...

Obecnie moduł zawiera 4 funkcje:

  • GenerateRegExprEngine – Ta funkcja kompiluje wzorzec wyrażenia regularnego.
  • RegExprPos – Znajduje wzorzec w danym ciągu.
  • DestroyRegExprEngine – Uwalnia kompilację wzorca
  • RegExprEscapeStr – Odwołuje się do rezerwowej składni języka wyrażeń regularnych, więc będzie rozumiana jako ciąg znaków zamiast składni regex.

Jest też jeden test:

  • testreg1 program testowy demonstrujący obsługiwane wyrażenia regularne.

Regexpr wg Floriana

To jest najstarsze wdrożenie. Jest obecny w packages/regexpr/src/old i nie jest aktualnie kompilowany przez pliki makefiles, więc nie jest dostępny domyślnie w prekompilowanych wersjach wydań FPC/Lazarus.

Zobacz także

Wróć do Packages List