macOS NSRegularExpression: what changed

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

Old	New		Line
1	1		## Regular expressions
2	2
3	3		Regular expressions are patterns used to match specified alpha-numeric character combinations in the string data being searched.
4	4
5	5		Each character in a regular expression (that is, each character in the string describing its pattern) is either a metacharacter or operator, having a special meaning, or a regular character that has a literal meaning.
6	6
7	7		Regular expressions can be incredibly complex. Indeed, whole books have been written about them! For a gentle introduction to regular expressions, see this [O'Reilly article](https://www.oreilly.com/content/an-introduction-to-regular-expressions/).
8	8
9	9		## NSRegularExpression Overview
10	10
11	11		The NSRegularExpression class has convenience methods for returning all the matches as an array, the total number of matches, the first match, and the range of the first match.
12	12
13	13		An individual match is represented by an instance of the NSTextCheckingResult class, which carries information about the overall matched range (via its range property), and the range of each individual capture group (via the rangeAtIndex method).
14	14
15	15		NSRegularExpression conforms to the International Components for Unicode (ICU) specification for regular expressions.
16	16
17	17		### Metacharacters
18	18
19	19		For a comprehensive list of characters used by the NSRegularExpression class that have a special meaning in regular expression patterns, see the [ICU listing](https://unicode-org.github.io/icu/userguide/strings/regexp.html#regular-expression-metacharacters).
20	20
21	21		### Operators
22	22
23	23		For a comprehensive list of operators used by the NSRegularExpression class, see the [ICU listing](https://unicode-org.github.io/icu/userguide/strings/regexp.html#regular-expression-operators).
24	24
25	25		## Example 1 - match a pattern
26	26
27	27		In this fairly trivial and contrived code example, we use the \d metacharacter which matches a decimal digit and the + operator to match the preceding decimal digit one or more times. This pattern \d+ aims to match all the occurrences of numbers in the search string which we then output using NSLog(). It uses the NSRegularExpression convenience methods for returning all of the matches in the search string as an array and the total number of matches.
28	28
29	29		### Code
30	30
31	31		``` pascal
32	32		Program regex_ex1;
33	33
34	34		{$mode objfpc}{$H+}
35	35		{$modeswitch objectivec2}
36	36
37	37		Uses
38	38		MacOSAll, CocoaAll, SysUtils;
39	39
40	40		Var
41	41		srchStr : String;
42	42		patnStr : String;
43	43		myRegex : NSregularExpression;
44	44		matches : NSArray;
45	45		match : NSTextCheckingResult;
46	46		error : NSErrorPtr;
47	47
48	48		Begin
49	49		error := Nil;
50	50		srchStr := 'I have 43 bags of 60 marbles.';
51	51		patnStr := '\d+';
52	52
53	53		// Create a regular expression with given string and options
54	54		myRegex := NSregularExpression.regularExpressionWithPattern_options_error(NSStr(patnStr), NSRegularExpressionOptions(NSRegularExpressionCaseInsensitive), error);
55	55
56	56		// Check creation of regular expression with given string and options
57	57		if(error <> Nil) then
58	58		begin
59	59		NSLog(NSStr('Regex creation error: %@'), error);
60	60		Exit;
61	61		end;
62	62
63	63		// Save any matches in the given string in the matches array
64	64		matches := myRegex.matchesInString_options_range(NSStr(srchStr), 0, NSMakeRange(0, srchStr.Length));
65	65
66	66		// Output
67	67		NSLog(NSStr('Search string: %@'), NSStr(srchStr));
68	68		NSLog(NSStr('Pattern string: %@'), NSStr(patnStr));
69	69		NSLog(NSStr('Number of matches: %lu'), myRegex.numberOfMatchesInString_options_range(NSStr(srchStr), 0, NSMakeRange(0, srchStr.Length)));
70	70
71	71		for match in matches do
72	72		NSLog(NSStr('match: %@'), NSStr(srchStr).substringWithRange(match.rangeAtIndex(0)));
73	73		End.
74	74		```
75	75
76	76		### Output
77	77
78	78		The output from running the above code example is:
79	79
80		-	~~`2021-06-12 21:05:46.335 regex_ex1[26138:232243] Search string: I have 43 bags of 60 marbles.`\~~
81		-	~~`2021-06-12 21:05:46.336 regex_ex1[26138:232243] Pattern string: \d+`\~~
82		-	~~`2021-06-12 21:05:46.336 regex_ex1[26138:232243] Number of matches: 2`\~~
83		-	~~`2021-06-12 21:05:46.336 regex_ex1[26138:232243] match: 43`\~~
84		-	~~`2021-06-12 21:05:46.336 regex_ex1[26138:232243] match: 60`~~
	80	+	```text
	81	+	2021-06-12 21:05:46.335 regex_ex1[26138:232243] Search string: I have 43 bags of 60 marbles.
	82	+	2021-06-12 21:05:46.336 regex_ex1[26138:232243] Pattern string: \d+
	83	+	2021-06-12 21:05:46.336 regex_ex1[26138:232243] Number of matches: 2
	84	+	2021-06-12 21:05:46.336 regex_ex1[26138:232243] match: 43
	85	+	2021-06-12 21:05:46.336 regex_ex1[26138:232243] match: 60
	86	+	```
85	87
86	88		### Code explanation
87	89
88	90		The call to regularExpressionWithPattern_options_error() creates an NSRegularExpression object instance (myRegex) with the specified regular expression pattern and options.
89	91
90	92		Options are specified using NSRegularExpressionOptions(). Note that by default NSRegularExpression performs case-sensitive searches, so we specified the NSRegularExpressionCaseInsensitive option for case-insenstive searches although, because we are dealing with digits above, this has no effect and we might as well have specified Nil in this example for no options.
91	93
92	94		Once we have the NSRegularExpression object, we can then use it for matching text among other operations.
93	95
94	96		After checking that the creation of the regular expression did not fail with an error, we call the matchesInString_options_range() method to search for any matches and store them in our NSArray (matches). This method takes our search string, any options (there are none here) and the range to search. The range is specified by giving NSMakeRange() the starting location to search in the string (0 = the beginning of the string) and the length of the search string.
95	97
96	98		Next, we output the search string and pattern string, and then call the numberOfMatchesInString_options_range() method to determine the number of matches and output it.
97	99
98	100		Finally, we iterate through the matches NSArray and output the matches individually. The call to rangeAtIndex(0) is the full match and is equivalent to simply calling range. The code for this looks a little obscure. Let me try to unpack it for you.
99	101
100	102		If you just output the content of the matches NSArray you get this:
101	103
102		-	~~`"<NSSimpleRegularExpressionCheckingResult: 0x14d617570>{7, 2}{<NSRegularExpression: 0x14d614fd0> \\d+ 0x1}",`\~~
103		-	~~`"<NSSimpleRegularExpressionCheckingResult: 0x14d617610>{18, 2}{<NSRegularExpression: 0x14d614fd0> \\d+ 0x1}"`~~
	104	+	```text
	105	+	"<NSSimpleRegularExpressionCheckingResult: 0x14d617570>{7, 2}{<NSRegularExpression: 0x14d614fd0> \\d+ 0x1}",
	106	+	"<NSSimpleRegularExpressionCheckingResult: 0x14d617610>{18, 2}{<NSRegularExpression: 0x14d614fd0> \\d+ 0x1}"
	107	+	```
104	108
105	109		Notice the {7, 2} and {18, 2} ranges which locate the first number at position 7 (counting from zero) in the search string with a length of 2 and the second number at position 18 with a length of 2. Knowing those ranges, you could use:
106	110
107	111		``` pascal
108	112		NSLog(NSStr('match: ''%@'''), NSStr(srchStr).substringWithRange(NSMakeRange(7, 2)));
109	113		```
110	114
111	115		to output the first number. The substringWithRange() method extracts from our search string the substring that matches the specified range (7, 2). Clearer than mud? I hope so.
112	116
113	117		## Example 2 - match pattern groups
114	118
115	119		This is similar to Example 1 above, except that this time we match groups of characters. Our search string is the same as before, but our pattern string has some added complexity. The pattern matches a decimal digit one or more times as before, but this time as a group which is delineated by using parentheses: (/d+). Next, we use a point . to match any character and ? to match zero or one times following the digit(s). Finally, we match the set of characters from a to z (\[a-z\]+) one or more times as a group.
116	120
117	121		### Code
118	122
119	123		``` pascal
120	124		Program regex_ex2;
121	125
122	126		{$mode objfpc}{$H+}
123	127		{$modeswitch objectivec2}
124	128
125	129		Uses
126	130		MacOSAll, CocoaAll, SysUtils;
127	131
128	132		Var
129	133		srchStr : String;
130	134		patnStr : String;
131	135		myRegex : NSregularExpression;
132	136		matches : NSArray;
133	137		match : NSTextCheckingResult;
134	138		error : NSErrorPtr;
135	139
136	140		Begin
137	141		error := Nil;
138	142		srchStr := 'I have 43 Bags of 60 Marbles.';
139	143		patnStr := '(\d+).?([a-z]+)';
140	144
141	145		// Create a regular expression with given string and options
142	146		myRegex := NSregularExpression.regularExpressionWithPattern_options_error(NSStr(patnStr), NSRegularExpressionOptions(NSRegularExpressionCaseInsensitive), error);
143	147
144	148		// Check creation of regular expression with given string and options
145	149		if(error <> Nil) then
146	150		begin
147	151		NSLog(NSStr('Regex creation error: %@'), error);
148	152		Exit;
149	153		end;
150	154
151	155		// Save any matches in the given string in the matches array
152	156		matches := myRegex.matchesInString_options_range(NSStr(srchStr), 0, NSMakeRange(0, srchStr.Length));
153	157
154	158		// Output
155	159		NSLog(NSStr('Search string: %@'), NSStr(srchStr));
156	160		NSLog(NSStr('Pattern string: %@'), NSStr(patnStr));
157	161		NSLog(NSStr('Number of matches: %lu'), myRegex.numberOfMatchesInString_options_range(NSStr(srchStr), 0, NSMakeRange(0, srchStr.Length)));
158	162
159	163		for match in matches do
160	164		begin
161	165		NSLog(NSStr('match(0): ''%@'''), NSStr(srchStr).substringWithRange(match.rangeAtIndex(0)));
162	166		NSLog(NSStr('match(1): ''%@'''), NSStr(srchStr).substringWithRange(match.rangeAtIndex(1)));
163	167		NSLog(NSStr('match(2): ''%@'''), NSStr(srchStr).substringWithRange(match.rangeAtIndex(2)));
164	168		end;
165	169		End.
166	170		```
167	171
168	172		### Output
169	173
170		-	~~`2021-06-14 17:39:51.255 program2[7376:149163] Search string: I have 43 bags of 60 marbles.`\~~
171		-	~~`2021-06-14 17:39:51.255 program2[7376:149163] Pattern string: (\d+).?([a-z]+)`\~~
172		-	~~`2021-06-14 17:39:51.255 program2[7376:149163] Number of matches: 2`\~~
173		-	~~`2021-06-14 17:39:51.255 program2[7376:149163] match(0): '43 Bags'`\~~
174		-	~~`2021-06-14 17:39:51.255 program2[7376:149163] match(1): '43'`\~~
175		-	~~`2021-06-14 17:39:51.255 program2[7376:149163] match(2): 'Bags'`\~~
176		-	~~`2021-06-14 17:39:51.255 program2[7376:149163] match(0): '60 Marbles'`\~~
177		-	~~`2021-06-14 17:39:51.255 program2[7376:149163] match(1): '60'`\~~
178		-	~~`2021-06-14 17:39:51.255 program2[7376:149163] match(2): 'Marbles'`~~
	174	+	```text
	175	+	2021-06-14 17:39:51.255 program2[7376:149163] Search string: I have 43 bags of 60 marbles.
	176	+	2021-06-14 17:39:51.255 program2[7376:149163] Pattern string: (\d+).?([a-z]+)
	177	+	2021-06-14 17:39:51.255 program2[7376:149163] Number of matches: 2
	178	+	2021-06-14 17:39:51.255 program2[7376:149163] match(0): '43 Bags'
	179	+	2021-06-14 17:39:51.255 program2[7376:149163] match(1): '43'
	180	+	2021-06-14 17:39:51.255 program2[7376:149163] match(2): 'Bags'
	181	+	2021-06-14 17:39:51.255 program2[7376:149163] match(0): '60 Marbles'
	182	+	2021-06-14 17:39:51.255 program2[7376:149163] match(1): '60'
	183	+	2021-06-14 17:39:51.255 program2[7376:149163] match(2): 'Marbles'
	184	+	```
179	185
180	186		### Code explanation
181	187
182	188		The explanation is pretty much the same as for Example 1, except that:
183	189
184	190		1\) The NSRegularExpressionCaseInsensitive option for case-insenstive searches now has a use. We specified the set of lowercase characters a to z, but because of the option we matched the words Bags and Marbles with initial capital letters.
185	191
186	192		2\) The call to rangeAtIndex(0) or the equivalent range matches the full pattern; the call to rangeAtIndex(1) matches the first group of digits that we specified; and the call to rangeAtIndex(2) matches the second group of characters that we specified.
187	193
188	194		## Example 3 - replace matched pattern
189	195
190	196		This is similar to Example 1 above, except that this time we replace the decimal numbers matched by the regular expression with words instead of numbers. This is done two ways: one uses the stringByReplacingMatchesInString_options_range_withTemplate() method which returns a new string with the replacements and the other uses the replaceMatchesInString_options_range_withTemplate() method which replaces the matches in the original search string.
191	197
192	198		### Code
193	199
194	200		``` pascal
195	201		Program regex_ex3;
196	202
197	203		{$mode objfpc}{$H+}
198	204		{$modeswitch objectivec2}
199	205
200	206		Uses
201	207		MacOSAll, CocoaAll, SysUtils;
202	208
203	209		Var
204	210		srchStr : NSString;
205	211		srchStr2: NSMutableString;
206	212		patnStr : NSString;
207	213		templStr: NSString;
208	214		myRegex : NSregularExpression;
209	215		matches : NSArray;
210	216		match : NSTextCheckingResult;
211	217		numMatch: NSInteger;
212	218		error : NSErrorPtr;
213	219		count : ShortInt;
214	220
215	221		Begin
216	222		error := Nil;
217	223		srchStr := NSStr('I have 43 Bags of 60 Marbles.');
218	224		srchStr2:= NSMutableString.stringWithString(srchStr);
219	225		patnStr := NSStr('\d+');
220	226
221	227		// Create a regular expression with given string and options
222	228		myRegex := NSregularExpression.regularExpressionWithPattern_options_error(patnStr, NSRegularExpressionOptions(NSRegularExpressionCaseInsensitive), error);
223	229
224	230		// Check creation of regular expression with given string and options
225	231		if(error <> Nil) then
226	232		begin
227	233		NSLog(NSStr('Regex creation error: %@'), error);
228	234		Exit;
229	235		end;
230	236
231	237		// Save any matches in the given string in the matches array
232	238		matches := myRegex.matchesInString_options_range(srchStr, 0, NSMakeRange(0, srchStr.Length));
233	239
234	240		// Save number of matches
235	241		numMatch := myRegex.numberOfMatchesInString_options_range(srchStr, 0, NSMakeRange(0, srchStr.Length));
236	242
237	243		// Output
238	244		NSLog(NSStr('Search string: %@'), srchStr);
239	245		NSLog(NSStr('Pattern string: %@'), patnStr);
240	246		NSLog(NSStr('Number of matches: %lu'), numMatch);
241	247
242	248		// Alternative 1: Using stringByReplacingMatchesInString_options_range_withTemplate()
243	249		for count := numMatch downto 1 do
244	250		begin
245	251		for match in matches do
246	252		begin
247	253		if(srchStr.substringWithRange(match.range) = NSStr('43')) then
248	254		begin
249	255		templStr := NSStr('forty-three');
250	256		NSLog(NSStr('Match 1: %@ - Template string: %@'), srchStr.substringWithRange(match.range), templStr);
251	257		end;
252	258
253	259		if(srchStr.substringWithRange(match.range) = NSStr('60')) then
254	260		begin
255	261		templStr := NSStr('sixty');
256	262		NSLog(NSStr('Match 2: %@ - Template string: %@'), srchStr.substringWithRange(match.range), templStr);
257	263		end;
258	264
259	265		// Do string replacement
260	266		srchStr := myRegex.stringByReplacingMatchesInString_options_range_withTemplate(srchStr, NSRegularExpressionOptions(Nil), match.range, templStr);
261	267		end;
262	268
263	269		// Save any matches in the new search string in the matches array
264	270		matches := myRegex.matchesInString_options_range(srchStr, 0, NSMakeRange(0, srchStr.Length));
265	271		end;
266	272
267	273		// Output string with replacements
268	274		NSLog(NSStr('Result: %@'), srchStr);
269	275
270	276		// Save any matches in the given string in the matches array
271	277		matches := myRegex.matchesInString_options_range(srchStr2, 0, NSMakeRange(0, srchStr2.Length));
272	278
273	279		// Alternative 2: Using replaceMatchesInString_options_range_withTemplate()
274	280		for count := numMatch downto 1 do
275	281		begin
276	282		for match in matches do
277	283		begin
278	284		if(srchStr2.substringWithRange(match.range) = NSStr('43')) then
279	285		begin
280	286		templStr := NSStr('forty-three');
281	287		NSLog(NSStr('Match 1: %@ - Template string: %@'), srchStr2.substringWithRange(match.range), templStr);
282	288		end;
283	289		if(srchStr2.substringWithRange(match.range) = NSStr('60')) then
284	290		begin
285	291		templStr := NSStr('sixty');
286	292		NSLog(NSStr('Match 2: %@ - Template string: %@'), srchStr2.substringWithRange(match.range), templStr);
287	293		end;
288	294
289	295		// Do string replacement
290	296		myRegex.replaceMatchesInString_options_range_withTemplate(srchStr2, NSRegularExpressionOptions(Nil), match.range, templStr);
291	297		end;
292	298
293	299		// Save any matches in the new search string in the matches array
294	300		matches := myRegex.matchesInString_options_range(srchStr2, 0, NSMakeRange(0, srchStr2.Length));
295	301		end;
296	302
297	303		// Output string with replacements
298	304		NSLog(NSStr('Result: %@'), srchStr2);
299	305		End.
300	306		```
301	307
302	308		### Output
303	309
304		-	~~`2021-06-14 22:42:55.807 program3[9115:227765] Search string: I have 43 Bags of 60 Marbles.`\~~
305		-	~~`2021-06-14 22:42:55.808 program3[9115:227765] Pattern string: \d+`\~~
306		-	~~`2021-06-14 22:42:55.808 program3[9115:227765] Number of matches: 2`\~~
307		-	~~`2021-06-14 22:42:55.808 program3[9115:227765] Match 1: 43 - Template string: forty-three`\~~
308		-	~~`2021-06-14 22:42:55.808 program3[9115:227765] Match 2: 60 - Template string: sixty`\~~
309		-	~~`2021-06-14 22:42:55.808 program3[9115:227765] Result: I have forty-three Bags of sixty Marbles.`\~~
310		-	~~`2021-06-14 22:42:55.808 program3[9115:227765] Match 1: 43 - Template string: forty-three`\~~
311		-	~~`2021-06-14 22:42:55.808 program3[9115:227765] Match 2: 60 - Template string: sixty`\~~
312		-	~~`2021-06-14 22:42:55.808 program3[9115:227765] Result: I have forty-three Bags of sixty Marbles.`~~
	310	+	```text
	311	+	2021-06-14 22:42:55.807 program3[9115:227765] Search string: I have 43 Bags of 60 Marbles.
	312	+	2021-06-14 22:42:55.808 program3[9115:227765] Pattern string: \d+
	313	+	2021-06-14 22:42:55.808 program3[9115:227765] Number of matches: 2
	314	+	2021-06-14 22:42:55.808 program3[9115:227765] Match 1: 43 - Template string: forty-three
	315	+	2021-06-14 22:42:55.808 program3[9115:227765] Match 2: 60 - Template string: sixty
	316	+	2021-06-14 22:42:55.808 program3[9115:227765] Result: I have forty-three Bags of sixty Marbles.
	317	+	2021-06-14 22:42:55.808 program3[9115:227765] Match 1: 43 - Template string: forty-three
	318	+	2021-06-14 22:42:55.808 program3[9115:227765] Match 2: 60 - Template string: sixty
	319	+	2021-06-14 22:42:55.808 program3[9115:227765] Result: I have forty-three Bags of sixty Marbles.
	320	+	```
313	321
314	322		## Example 4 - rearrange matched pattern groups
315	323
316	324		This is similar to Example 2 above, except that this time not only do we match groups of characters, we rearrange them. Our search string is different this time and represents a contact list. We are going to rearrange the format from Firstname, Lastname to the more sensible Lastname, Firstname and then enclose the contact number state area code in parentheses. To do this, our pattern string has some added complexity.
317	325
318	326		The pattern matches the first word group as a group of word characters followed by a comma (\w+), and does exactly the same again for the second word group, and finally matches the two digits of the area code as a group (\d{2}). The curly braces enclosing the number {2} after the digit metacharacter specifies that we want to match exactly two digits which comprise the area code.
319	327
320	328		The template string rearranges the data groups by switching the order of the first two word groups and adding parentheses around the third group which comprises the area code number.
321	329
322	330		### Code
323	331
324	332		``` pascal
325	333		Program regex_ex4;
326	334
327	335		{$mode objfpc}{$H+}
328	336		{$modeswitch objectivec2}
329	337
330	338		Uses
331	339		MacOSAll, CocoaAll, SysUtils;
332	340
333	341		Var
334	342		srchStr : NSString;
335	343		srchStr2: NSMutableString;
336	344		patnStr : NSString;
337	345		tmplStr : NSString;
338	346		myRegex : NSregularExpression;
339	347		matches : NSArray;
340	348		match : NSTextCheckingResult;
341	349		error : NSErrorPtr;
342	350
343	351		Begin
344	352		error := Nil;
345	353		srchStr := NSStr('Firstname, Lastname, 02 9428 4687');
346	354		srchStr2:= NSMutableString.stringWithString(srchStr);
347	355		patnStr := NSStr('(\w+), (\w+), (\d{2})');
348	356		tmplStr := NSStr('$2, $1, ($3)');
349	357
350	358		// Create a regular expression with given string and options
351	359		myRegex := NSregularExpression.regularExpressionWithPattern_options_error(patnStr, NSRegularExpressionOptions(NSRegularExpressionCaseInsensitive), error);
352	360
353	361		// Check creation of regular expression with given string and options
354	362		if(error <> Nil) then
355	363		begin
356	364		NSLog(NSStr('Regex creation error: %@'), error);
357	365		Exit;
358	366		end;
359	367
360	368		// Save any matches in the given string in the matches array
361	369		matches := myRegex.matchesInString_options_range(srchStr, 0, NSMakeRange(0, srchStr.Length));
362	370
363	371		// Output
364	372		NSLog(NSStr('Search string: %@'), srchStr);
365	373		NSLog(NSStr('Pattern string: %@'), patnStr);
366	374		NSLog(NSStr('Template string: %@'), tmplStr);
367	375		NSLog(NSStr('Number of matches: %lu'), myRegex.numberOfMatchesInString_options_range(srchStr, 0, NSMakeRange(0, srchStr.Length)));
368	376
369	377		for match in matches do
370	378		begin
371	379		NSLog(NSStr('match(1): %@'), srchStr.substringWithRange(match.rangeAtIndex(1)));
372	380		NSLog(NSStr('match(2): %@'), srchStr.substringWithRange(match.rangeAtIndex(2)));
373	381		NSLog(NSStr('match(3): %@'), srchStr.substringWithRange(match.rangeAtIndex(3)));
374	382		// Do the replacements
375	383		myRegex.replaceMatchesInString_options_range_withTemplate(srchStr2, NSRegularExpressionOptions(Nil), match.range, tmplStr);
376	384		end;
377	385
378	386		NSLog(NSStr('Result: %@'), srchStr2);
379	387		End.
380	388		```
381	389
382	390		### Output
383	391
384		-	~~`2021-06-15 20:37:54.880 program4[23076:159228] Search string: Firstname, Lastname, 02 9428 4687`\~~
385		-	~~`2021-06-15 20:37:54.880 program4[23076:159228] Pattern string: (\w+), (\w+), (\d{2})`\~~
386		-	~~`2021-06-15 20:37:54.880 program4[23090:159932] Template string: $2, $1, ($3)`\~~
387		-	~~`2021-06-15 20:37:54.881 program4[23076:159228] Number of matches: 1`\~~
388		-	~~`2021-06-15 20:37:54.881 program4[23076:159228] match(1): Firstname`\~~
389		-	~~`2021-06-15 20:37:54.881 program4[23076:159228] match(2): Lastname`\~~
390		-	~~`2021-06-15 20:37:54.881 program4[23076:159228] match(3): 02`\~~
391		-	~~`2021-06-15 20:37:54.881 program4[23076:159228] Result: Lastname, Firstname, (02) 9428 4687`~~
	392	+	```text
	393	+	2021-06-15 20:37:54.880 program4[23076:159228] Search string: Firstname, Lastname, 02 9428 4687
	394	+	2021-06-15 20:37:54.880 program4[23076:159228] Pattern string: (\w+), (\w+), (\d{2})
	395	+	2021-06-15 20:37:54.880 program4[23090:159932] Template string: $2, $1, ($3)
	396	+	2021-06-15 20:37:54.881 program4[23076:159228] Number of matches: 1
	397	+	2021-06-15 20:37:54.881 program4[23076:159228] match(1): Firstname
	398	+	2021-06-15 20:37:54.881 program4[23076:159228] match(2): Lastname
	399	+	2021-06-15 20:37:54.881 program4[23076:159228] match(3): 02
	400	+	2021-06-15 20:37:54.881 program4[23076:159228] Result: Lastname, Firstname, (02) 9428 4687
	401	+	```
392	402
393	403		## See also
394	404
395	405		- [[macOS NSString Regular Expressions]].
396	406		- [[RegEx packages]] - cross platform.
397	407
398	408		## External links
399	409
400	410		- [Apple: NSRegularExpression](https://developer.apple.com/documentation/foundation/nsregularexpression).
401	411
402	412		- [ICU: Documentation](https://unicode-org.github.io/icu/).
403	413
404	414		---
405	415		From the Free Pascal wiki, page "macOS NSRegularExpression", as it stood on 2021-08-07 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).

Back to history