IDE regular expressions/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 - Fast Light Regular Expressions by BeRo1985
FLRE (F ast L ight R egular E xpressions) is a fast, safe and efficient regular expression library, which is implemented in Object Pascal (Delphi and Free Pascal) but which is even usable from other languages like C/C++ and so on. Can handle Unicode and UTF8 strings.
It implements the many of the most common Perl and POSIX features, except irregular expression features like forward references and nested back references and so on, which aren't supported at FLRE, only real "back" references are supported, hence also the word "Light" at the FLRE name. It also finds the leftmost-first match, the same match that Perl and PCRE would, and can return submatch information. But it also features a flag for a yet experimental POSIX-style leftmost-longest match behaviour mode.
FLRE is licensed under the LGPL v2.1 with static-linking-exception.
Example
Implementing PHP parse_url function (based on php.js parse_url implementation)
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