RegEx packages/pl

│ Deutsch (de) │ English (en) │ español (es) │ Bahasa Indonesia (id) │ polski (pl) │ 中文（中国大陆） (zh_CN) │

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

• Porównanie silników wyrażeń regularnych (en)

Wróć do Packages List