IDE regular expressions/pl: what changed

Revision 1 to 2. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1		-	~~<div style="font-size:1.88em;margin:0.75em 0;">~~
2		-
3	1		IDE wyrażeń regularnych
4		-
5		-	~~</div>~~
6	2
7	3		Pakiet RegExpr zawiera wiele implementacji wyrażeń regularnych
8	4
9	5		## Regexpr wg Sorokina
10	6
11	7		Jest to najbardziej kompletna implementacja dostępna w packages/regexpr/src/regexpr.pas
12	8
13	9		Przeczytaj stronę wikipedii o wyrażeniach regularnych, aby zapoznać się z tym tematem: [Podstawowe wyrażenia regularne POSIX](https://pl.wikipedia.org/wiki/Wyra%C5%BCenie_regularne)
14	10
15	11		Ten pakiet implementuje podzbiór wyrażeń regularnych Perla, a składnia dostarczona przez pakiet jest udokumentowana tutaj: <https://regex.sorokin.engineer/regex>
16	12
17	13		### Zmiana wielkość liter w trakcie zastępowania
18	14
19	15		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):
20	16
21	17		- \l - Pierwszy znak na małą literę
22	18		- \L - Wszystkie znaki na małe litery
23	19		- \u - Pierwszy znak na wielką literę
24	20		- \U - Wszystkie znaki na wielkie litery
25	21
26	22		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).
27	23
28	24		Ponadto \n zostanie zastąpiony znakiem końca wiersza (lub sekwencją znaków).
29	25
30	26		### Prosty przykład użycia
31	27
32	28		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.
33	29
34	30		``` pascal
35	31		var
36	32		RegexObj: TRegExpr;
37	33		begin
38	34		RegexObj := TRegExpr.Create;
39	35		RegexObj.Expression := '.zaloguj.';
40	36		if RegexObj.Exec('Proszę zaloguj się tutaj') then WriteLn('"zaloguj" został znaleziony!');
41	37		RegexObj.Free;
42	38		end;
43	39		```
44	40
45	41		Dopasowanie podwyrażenia:
46	42
47	43		``` pascal
48	44		program Project1;
49	45
50	46		uses
51	47		RegExpr;
52	48
53	49		var
54	50		re: TRegExpr;
55	51		begin
56	52		re := TRegExpr.Create('witaj (.*?)!');
57	53		if re.Exec('witaj świecie! witaj pascal!') then
58	54		begin
59	55		WriteLn(re.Match[1]);
60	56		while re.ExecNext do
61	57		begin
62	58		WriteLn(re.Match[1]);
63	59		end;
64	60		end;
65	61		re.Free;
66	62		end.
67	63		```
68	64
69	65		Wynik:
70	66
71	67		świecie
72	68		pascal
73	69
74	70		## FLRE - Wyrażenia regularne Fast Light wg BeRo1985
75	71
76	72		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.
77	73
78	74		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](https://www.regular-expressions.info/backref2.html) i tak dalej, które nie są obsługiwane w FLRE, ale obsługiwane są tylko prawdziwe [referencje "wstecz"](https://www.regular-expressions.info/backref.html), 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.
79	75
80	76		FLRE jest licencjonowany na licencji LGPL v2.1 z wyjątkiem statycznego linkowania.
81	77
82	78		[repozytorium Github](https://github.com/BeRo1985/flre)
83	79
84	80		### Przykład
85	81
86	82		Implementacja funkcji PHP parse_url (oparta na [parse_url](http://locutus.io/php/url/parse_url/php.js))
87	83
88	84		``` pascal
89	85
90	86		uses Classes, SysUtils, flre;
91	87
92	88		type
93	89
94	90		RUrlParser = record
95	91		private
96	92		Fcomponents : array[1..13] of string;
97	93
98	94		private
99	95		function getComponent( aIndex : integer ) : string;
100	96		procedure setComponent( aIndex : integer; const aValue : string );
101	97
102	98		public
103	99		function parse( const aUrl : UTF8String ) : boolean;
104	100
105	101		public
106	102		property scheme : string index 1 read getComponent write setComponent; // e.g. http
107	103		property authority : string index 2 read getComponent;
108	104		property userInfo : string index 3 read getComponent;
109	105		property user : string index 4 read getComponent;
110	106		property pass : string index 5 read getComponent;
111	107		property host : string index 6 read getComponent;
112	108		property port : string index 7 read getComponent;
113	109		property path : string index 9 read getComponent;
114	110		property directory : string index 10 read getComponent;
115	111		property fileName : string index 11 read getComponent;
116	112		property query : string index 12 read getComponent; // after the question mark ?
117	113		property fragment : string index 13 read getComponent; // after the hashmark #
118	114
119	115		end;
120	116
121	117		implementation
122	118
123	119		function RUrlParser.getComponent( aIndex : integer ) : string;
124	120		begin
125	121		Result := Fcomponents[ aIndex ];
126	122		end;
127	123
128	124		procedure RUrlParser.setComponent( aIndex : integer; const aValue : string );
129	125		begin
130	126		Fcomponents[ aIndex ] := aValue;
131	127		end;
132	128
133	129		function RUrlParser.parse( const aUrl : UTF8String ) : boolean; overload;
134	130		var
135	131		i : integer;
136	132		re : TFLRE;
137	133		parts : TFLREMultiStrings;
138	134		begin
139	135		re := TFLRE.Create( '(?:([^:\\/\?#]+):)?'
140	136		+ '(?:\/\/()(?:(?:()(?:([^:@\/]):?([^:@\/]))?@)?([^:\/?#])(?::(\d))?))?'
141	137		+ '()'
142	138		+ '(?:(()(?:(?:[^?#\/]\/))()(?:[^?#]))(?:\?([^#]))?(?:#(.*))?)'
143	139		, [ rfUTF8 ]
144	140		);
145	141
146	142		parts := nil;
147	143		Result := re.UTF8ExtractAll( aUrl, parts );
148	144		if ( Result ) then
149	145		begin
150	146		for i := 1 to Length( parts[0] ) - 1 do
151	147		begin
152	148		setComponent( i, string( parts[0][i] ) );
153	149		end;
154	150		end;
155	151
156	152		// Free regexp memory
157	153		for i := 0 to Length( parts ) - 1 do
158	154		begin
159	155		SetLength( parts[i], 0 );
160	156		end;
161	157		parts := nil;
162	158
163	159		re.Free();
164	160		end;
165	161		```
166	162
167	163		## Regexpr wg Joosta
168	164
169	165		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.
170	166
171	167		Obecny moduł jest daleki do ukończenia i nadal brakuje mu bardzo prostej obsługi składni [POSIX](http://www.opengroup.org/onlinepubs/007908799/xbd/re.html) lub bardziej złożonej składni, takiej jak w [Perl regex](http://www.pcre.org/), [Java Regex](http://java.sun.com/j2se/1.4.2/docs/api/java/util/regex/Pattern.html), [Ruby Regex](http://www.jpsoft.com/help/index.htm?regularexpressionsyntax.htm) itp ...
172	168
173	169		Obecnie moduł zawiera 4 funkcje:
174	170
175	171		- GenerateRegExprEngine – Ta funkcja kompiluje wzorzec wyrażenia regularnego.
176	172		- RegExprPos – Znajduje wzorzec w danym ciągu.
177	173		- DestroyRegExprEngine – Uwalnia kompilację wzorca
178	174		- 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.
179	175
180	176		Jest też jeden test:
181	177
182	178		- testreg1 program testowy demonstrujący obsługiwane wyrażenia regularne.
183	179
184	180		## Regexpr wg Floriana
185	181
186	182		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.
187	183
188	184		## Zobacz także
189	185
190	186		- [Porównanie silników wyrażeń regularnych (en)](http://en.wikipedia.org/wiki/Comparison_of_regular_expression_engines)
191	187
192	188		Wróć do [[Package List\|Packages List]]
193	189
194	190		---
195	191		From the Free Pascal wiki, page "IDE regular expressions/pl", as it stood on 2022-02-05 after a change by Trev, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).
196	192		Category: Packages

Back to history