IDE regular expressions/pl
│
English (en) │
español (es) │
suomi (fi) │
polski (pl) │
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.
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
