for-in loop/fr: what changed

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

Old	New		Line
1	1		La construction de boucle "for-in" est prise en charge dans Delphi depuis Delphi 2005. Elle a été mise en œuvre dans FPC 2.4.2.
2	2
3		-	~~## Contents~~
4		-
5		-	* 1 Implémentation Delphi et FPC
6		-	* 1.1 Boucle sur une chaîne
7		-	* 1.2 Boucle sur un tableau
8		-	* 1.3 Boucle sur un ensemble
9		-	* 1.4 Traverser un conteneur
10		-	* 1.5 Enumérateurs multiples pour une classe
11		-	* 2 Extensions FPC
12		-	* 2.1 Traversée de types énumération et intervalle
13		-	* 2.2 Déclarer des énumérateurs
14		-	* 2.2.1 Traversée de chaînes UTF-8
15		-	* 2.3 Utiliser des identificateurs au lieu de MoveNext et Current
16		-	* 3 Extensions proposées
17		-	* 3.1 Donner la position de l'énumérateur si disponible
18		-	* 3.1.1 Problématique
19		-	* 3.1.2 Solution de contournement pour l'indice
20		-	* 4 Référence
21		-
22	3		# Implémentation Delphi et FPC
23	4
24	5		Une boucle for in respecte la syntaxe suivante:
25	6
26	7		## Boucle sur une chaîne
27	8		```
28	9		procedure StringLoop(S: String);
29	10		var
30	11		C: Char;
31	12		begin
32	13		for C in S do
33	14		DoSomething(C);
34	15		end;
35	16		```
36	17
37	18		## Boucle sur un tableau
38	19		```
39	20		procedure ArrayLoop(A: Array of Byte);
40	21		var
41	22		B: Byte;
42	23		begin
43	24		for B in A do
44	25		DoSomething(B);
45	26		end;
46	27		```
47	28
48	29		## Boucle sur un ensemble
49	30		```
50	31		type
51	32		TColor = (cRed, cGren, cBlue);
52	33		TColors = set of TColor;
53	34		procedure SetLoop(Colors: TColors);
54	35		var
55	36		Color: TColor;
56	37		begin
57	38		for Color in Colors do
58	39		DoSomething(Color);
59	40		end;
60	41		```
61	42
62	43		## Traverser un conteneur
63	44
64	45		Pour travrser une classe conteneur, vous avez besoin d'ajouter un énumérateur. Un Enumérateur est une classe construite selon le modèle suivant :
65	46		```
66	47		TSomeEnumerator = class
67	48		public
68	49		function MoveNext: Boolean;
69	50		property Current: TSomeType;
70	51		end;
71	52		```
72	53
73	54		Il faut seulement deux choses pour définir une classe Enumerateur: une méthode MoveNext qui demande à l'énumérateur d'avancer d'un pas et une propriété Current qui peut retourner tout type approprié.
74	55
75	56		Par la suite, vous devez ajouter la méthode magique GetEnumerator de la classe conteneur qui retourne un énumérateur de l'instance.
76	57
77	58		Par exemple:
78	59		```
79	60		type
80	61		TEnumerableTree = class;
81	62
82	63		TTreeEnumerator = class
83	64		private
84	65		FTree: TEnumerableTree;
85	66		FCurrent: TNode;
86	67		public
87	68		constructor Create(ATree: TEnumerableTree);
88	69		function MoveNext: Boolean;
89	70		property Current: TNode read FCurrent;
90	71		end;
91	72
92	73		TEnumerableTree = class
93	74		public
94	75		function GetEnumerator: TTreeEnumerator;
95	76		end;
96	77
97	78		constructor TTreeEnumerator.Create(ATree: TEnumerableTree);
98	79		begin
99	80		inherited Create;
100	81		FTree := ATree;
101	82		FCurrent := nil;
102	83		end;
103	84
104	85		function TTreeEnumerator.MoveNext: Boolean;
105	86		begin
106	87		// pour obtenir le nœud suivant dans l'arbre
107	88		if FCurrent = nil then
108	89		FCurrent := FTree.GetFirstNode
109	90		else
110	91		FCurrent := FTree.GetNextNode(FCurrent);
111	92		Result := FCurrent <> nil;
112	93		end;
113	94
114	95		function TEnumerableTree.GetEnumerator: TTreeEnumerator;
115	96		begin
116	97		Result := TTreeEnumerator.Create(Self);
117	98		// Important: l'objet créé est automatiquement libéré par le compilateur après la boucle.
118	99		end;
119	100		```
120	101
121	102		Ensuite, cela vous permet de d'exécuter le code suivant:
122	103		```
123	104		procedure TreeLoop(ATree: TEnumerableTree);
124	105		var
125	106		ANode: TNode;
126	107		begin
127	108		for ANode in ATree do
128	109		DoSomething(ANode);
129	110		end;
130	111		```
131	112
132	113		Vos trouverez que plusieurs classes de bases (telles que TList, TStrings, TCollection, TComponent ...) ont des énumérateurs intégrés.
133	114
134	115		Il est aussi possible de rendre une classe énumérable si vous implémentez l'interface suivante dans votre classe conteneur enumérable:
135	116		```
136	117		IEnumerable = interface(IInterface)
137	118		function GetEnumerator: IEnumerator;
138	119		end;
139	120		```
140	121
141	122		où IEnumerator est déclarée comme :
142	123		```
143	124		IEnumerator = interface(IInterface)
144	125		function GetCurrent: TObject;
145	126		function MoveNext: Boolean;
146	127		procedure Reset;
147	128		property Current: TObject read GetCurrent;
148	129		end;
149	130		```
150	131
151	132		## Enumérateurs multiples pour une classe
152	133
153	134		Vous pouvez ajouter des énumérateurs supplémentaires à des classes, des objets et des enregistrements.
154	135
155	136		Voici un exemple d'ajout d'énumérateur qui traverse un TEnumerableTree en ordre inverse:
156	137		```
157	138		type
158	139		TEnumerableTree = class;
159	140
160	141		TTreeEnumerator = class
161	142		// ...pour la traversée dans l'ordre, voir ci-dessus...
162	143		end;
163	144
164	145		TTreeReverseEnumerator = class
165	146		private
166	147		FTree: TEnumerableTree;
167	148		FCurrent: TNode;
168	149		public
169	150		constructor Create(ATree: TEnumerableTree);
170	151		function MoveNext: Boolean;
171	152		property Current: TNode read FCurrent;
172	153		function GetEnumerator: TTreeReverseEnumerator; // se retourne lui-même
173	154		end;
174	155
175	156		TEnumerableTree = class
176	157		public
177	158		function GetEnumerator: TTreeEnumerator;
178	159		function GetReverseEnumerator: TTreeReverseEnumerator;
179	160		end;
180	161
181	162		//...voir ci-dessus l'implémentation de TTreeEnumerator...
182	163
183	164		constructor TTreeReverseEnumerator.Create(ATree: TEnumerableTree);
184	165		begin
185	166		inherited Create;
186	167		FTree := ATree;
187	168		end;
188	169
189	170		function TTreeReverseEnumerator.MoveNext: Boolean;
190	171		begin
191	172		// some logic to get the next node from a tree in reverse order
192	173		if FCurrent = nil then
193	174		FCurrent := FTree.GetLastNode
194	175		else
195	176		FCurrent := FTree.GetPrevNode(FCurrent);
196	177		Result := FCurrent <> nil;
197	178		end;
198	179
199	180		function TTreeReverseEnumerator.GetEnumerator: TTreeReverseEnumerator;
200	181		begin
201	182		Result := Self;
202	183		end;
203	184
204	185		function TEnumerableTree.GetReverseEnumerator: TTreeReverseEnumerator;
205	186		begin
206	187		Result := TTreeReverseEnumerator.Create(Self);
207	188		// Note: l'objet est automatiquement supprimé par le compilateur après la boucle.
208	189		end;
209	190		```
210	191
211	192		Ensuite vous êtes en mesure d'exécuter le code suivant:
212	193		```
213	194		procedure TreeLoop(ATree: TEnumerableTree);
214	195		var
215	196		ANode: TNode;
216	197		begin
217	198		for ANode in ATree.GetReverseEnumerator do
218	199		DoSomething(ANode);
219	200		end;
220	201		```
221	202
222	203		# Extensions FPC
223	204
224	205		Les exemples de code suivants illustrent les constructions implémentées uniquement dans FPC ; elles ne sont pas supportées par Delphi.
225	206
226	207		## Traversée de types énumération et intervalle
227	208
228	209		Dans Delphi, il n'est [pas possible de traverser non plus les types énumérés](<http://qc.embarcadero.com/wc/qcmain.aspx?d=106212>) ou les intervalles, alors qu'en Free Pascal vous pouvez écrire ce qui suit:
229	210		```
230	211		type
231	212		TColor = (clRed, clBlue, clBlack);
232	213		TRange = 'a'..'z';
233	214		var
234	215		Color: TColor;
235	216		ch: Char;
236	217		begin
237	218		for Color in TColor do
238	219		DoSomething(Color);
239	220		for ch in TRange do
240	221		DoSomethingOther(ch);
241	222		end.
242	223		```
243	224
244	225		## Déclarer des énumérateurs
245	226
246	227		Il n'est pas non plus possible dans Delphi d'ajouter un énumérateur sans modifier la classe, ni d'ajouter un énumérateur d'un type non class object/record/interface. FPC rend cela possible en utilisant la nouvelle syntaxe operator type Enumerator. Comme dans l'exemple suivant:
247	228		```
248	229		type
249	230		TMyRecord = record F1: Integer; F2: array of TMyType; end;
250	231		TMyArrayEnumerator = class
251	232		private
252	233		function GetCurrent: TMyType;
253	234		public
254	235		constructor Create(const A: TMyRecord);
255	236		property Current: TMyType read GetCurrent;
256	237		function MoveNext: Boolean;
257	238		end;
258	239
259	240		// C'est le nouveau opérateur intégré.
260	241		operator Enumerator(const A: TMyRecord): TMyArrayEnumerator;
261	242		begin
262	243		Result := TMyArrayEnumerator.Create(A);
263	244		end;
264	245
265	246		var
266	247		A: MyRecord;
267	248		V: TMyType
268	249		begin
269	250		for V in A do
270	251		DoSomething(V);
271	252		end.
272	253		```
273	254
274	255		### Traversée de chaînes UTF-8
275	256
276	257		Comme exemple particulièrement utile, l'extension ci-dessous autorise une traversée très efficace des chaînes UTF-8:
277	258		```
278	259		uses
279	260		LazUTF8;
280	261		interface
281	262		type
282	263		{ TUTF8StringAsStringEnumerator
283	264		La traversée de 'codepoint' UTF8 est utile quand vous voulez connaître l'encodage exact d'un
284	265		caractère UTF-8 ou si vous aimez utiliser des constante de chaîne dans votre code.
285	266		Pour des raisons de sécurité, vous pourriez utiliser les valeurs des points de code (cardinaux) à la place.
286	267		Si la vitesse importe, n'utilisez pas des énumérateurs. Employez à la place directement le PChar
287	268		comme montré dans la méthode MoveNext et lisez sur l'UTF8. Il a des caractéristiques intéressantes. }
288	269
289	270		TUTF8StringAsStringEnumerator = class
290	271		private
291	272		fCurrent: UTF8String;
292	273		fCurrentPos, fEndPos: PChar;
293	274		function GetCurrent: UTF8String;
294	275		public
295	276		constructor Create(const A: UTF8String);
296	277		property Current: UTF8String read GetCurrent;
297	278		function MoveNext: Boolean;
298	279		end;
299	280
300	281		operator Enumerator(A: UTF8String): TUTF8StringAsStringEnumerator;
301	282
302	283		var
303	284		Form1: TForm1;
304	285
305	286		implementation
306	287
307	288		operator Enumerator(A: UTF8String): TUTF8StringAsStringEnumerator;
308	289		begin
309	290		Result := TUTF8StringAsStringEnumerator.Create(A);
310	291		end;
311	292
312	293		{ TUTF8StringAsStringEnumerator }
313	294
314	295		function TUTF8StringAsStringEnumerator.GetCurrent: UTF8String;
315	296		begin
316	297		Result:=fCurrent;
317	298		end;
318	299
319	300		constructor TUTF8StringAsStringEnumerator.Create(const A: UTF8String);
320	301		begin
321	302		fCurrentPos:=PChar(A); // Note: si A='' alors PChar(A) retourne un pointeur sur une chaîne #0
322	303		fEndPos:=fCurrentPos+length(A);
323	304		end;
324	305
325	306		function TUTF8StringAsStringEnumerator.MoveNext: Boolean;
326	307		var
327	308		l: Integer;
328	309		begin
329	310		if fCurrentPos<fEndPos then
330	311		begin
331	312		l:=UTF8CharacterLength(fCurrentPos);
332	313		SetLength(fCurrent,l);
333	314		Move(fCurrentPos^,fCurrent[1],l);
334	315		inc(fCurrentPos,l);
335	316		Result:=true;
336	317		end else
337	318		Result:=false;
338	319		end;
339	320
340	321		{ TForm1 }
341	322
342	323		procedure TForm1.FormCreate(Sender: TObject);
343	324		var
344	325		s, ch: UTF8String;
345	326		i: SizeInt;
346	327		begin
347	328		s:='mäßig';
348	329
349	330		// Utiliser UTF8Length et UTF8Copy de cette manière est très lent, nécessitant O(n)^2
350	331		for i:=1 to UTF8Length(s) do
351	332		writeln('ch=',UTF8Copy(s,i,1));
352	333
353	334		// L'emploi de l'énumérateur du dessus est plus court et plutôt rapide, nécessitant O(n)
354	335		for ch in s do
355	336		writeln('ch=',ch);
356	337		end;
357	338		```
358	339
359	340		## Utiliser des identificateurs au lieu de MoveNext et Current
360	341
361	342		En Delphi, vous devez utiliser une fonction avec le nom 'MoveNext' et une propriété avec le nom 'Current' dans les énumérateurs. Avec FPC, vous pouvez choisir n'importe quel nom. Cela est permis par l'emploi du modifieur enumerator , avec la syntaxe des modifieurs 'enumerator MoveNext;' et 'enumerator Current;'. Comme dans l'exemple suivant :
362	343		```
363	344		type
364	345		{ TMyListEnumerator }
365	346
366	347		TMyListEnumerator = object
367	348		private
368	349		FCurrent: Integer;
369	350		public
370	351		constructor Create;
371	352		destructor Destroy;
372	353		function StepNext: Boolean; enumerator MoveNext;
373	354		property Value: Integer read FCurrent; enumerator Current;
374	355		end;
375	356
376	357		TMyList = class
377	358		end;
378	359
379	360		{ TMyListEnumerator }
380	361
381	362		constructor TMyListEnumerator.Create;
382	363		begin
383	364		FCurrent := 0;
384	365		end;
385	366
386	367		destructor TMyListEnumerator.Destroy;
387	368		begin
388	369		inherited;
389	370		end;
390	371
391	372		function TMyListEnumerator.StepNext: Boolean;
392	373		begin
393	374		inc(FCurrent);
394	375		Result := FCurrent <= 3;
395	376		end;
396	377
397	378		operator enumerator (AList: TMyList): TMyListEnumerator;
398	379		begin
399	380		Result.Create;
400	381		end;
401	382
402	383		var
403	384		List: TMyList;
404	385		i: integer;
405	386		begin
406	387		List := TMyList.Create;
407	388		for i in List do
408	389		WriteLn(i);
409	390		List.Free;
410	391		end.
411	392		```
412	393
413	394		# Extensions proposées
414	395
415	396		## Donner la position de l'énumérateur si disponible
416	397
417	398		### Problématique
418	399
419	400		Il est impossible d'extraire toute information de l'itérateur sauf l'article courant. Parfois d'autres informations, comme l'index courant, pourraient être utiles :
420	401		```
421	402		type
422	403		TUTF8StringEnumerator = class
423	404		private
424	405		FByteIndex: Integer;
425	406		FCharIndex: Integer;
426	407		public
427	408		constructor Create(const A: UTF8String);
428	409		function Current: UTF8Char;
429	410		function CurrentIndex: Integer;
430	411		function MoveNext: Boolean;
431	412		end;
432	413
433	414		operator GetEnumerator(A: UTF8String): TUTF8StringEnumerator;
434	415		begin
435	416		Result := TUTF8String.Create(A);
436	417		end;
437	418
438	419		var
439	420		s: UTF8String;
440	421		ch: UTF8Char;
441	422		i: Integer;
442	423		begin
443	424
444	425		// inefficace comme discuté plus haut
445	426		for i := 1 to Length(s) do
446	427		Writeln(i, ': ', ch[i]);
447	428
448	429		// Ok, mais moche
449	430		i := 1;
450	431		for ch in s do begin
451	432		Writeln(i, ': ', ch);
452	433		Inc(i);
453	434		end;
454	435
455	436		// Extension proposée
456	437		for ch in s index i do
457	438		Writeln(i, ': ', ch);
458	439
459	440		// Extension proposée pour traverser à l'envers (équivalent au downto)
460	441		for ch in reverse s do
461	442		Writeln(i, ': ', ch);
462	443
463	444		// Avec l'extension d'index proposée
464	445		for ch in reverse s index i do
465	446		Writeln(i, ': ', ch);
466	447		end.
467	448		```
468	449
469	450		Remarquez que l'index doit être conçu pour retourner un type arbitraire (c'est-à-dire pas forcément un entier). Par exemple, dans l'exemple d'une traversée d'arbre, l'index pourrait retourner un tableau de nœuds décrivant le chemin allant de la racine au nœud courant.
470	451
471	452		### Solution de contournement pour l'indice
472	453
473	454		La propriété Current prend la forme d'un couple (Indice,Valeur), on emploie un type générique afin de pérenniser cette conception.
474	455		```
475	456		unit IndicedEnumerators;
476	457
477	458		interface
478	459
479	460		type
480	461
481	462		generic TGIndicedEnumerator<TContainer, TElement> = class
482	463		public type
483	464		TIndicedValue = record
484	465		Value: TElement;
485	466		Ind: Integer;
486	467		end;
487	468		protected
488	469		FCntnr: TContainer;
489	470		FCurrent: TIndicedValue;
490	471		public
491	472		constructor Create(aCntnr: TContainer); virtual;
492	473		function MoveNext: Boolean; virtual; abstract;
493	474		property Current: TIndicedValue read FCurrent;
494	475		function GetEnumerator: TGIndicedEnumerator;
495	476		end;
496	477
497	478		TCsvAnsiStringFieldEnumerator = class(specialize TGIndicedEnumerator<AnsiString, AnsiString>)
498	479		private
499	480		FCurrPos: Integer;
500	481		FSeparator: Char;
501	482		public
502	483		constructor Create(aString: AnsiString; Separator: AnsiChar); overload;
503	484		function MoveNext: Boolean; override;
504	485		end;
505	486
506	487		implementation
507	488
508	489		{ TGIndicedEnumerator }
509	490
510	491		constructor TGIndicedEnumerator.Create(aCntnr: TContainer);
511	492		begin
512	493		FCntnr := aCntnr;
513	494		end;
514	495
515	496		function TGIndicedEnumerator.GetEnumerator: TGIndicedEnumerator;
516	497		begin
517	498		Result := Self;
518	499		end;
519	500
520	501		{ TCsvAnsiStringFieldEnumerator }
521	502
522	503		constructor TCsvAnsiStringFieldEnumerator.Create(aString: AnsiString; Separator: AnsiChar);
523	504		begin
524	505		inherited Create(aString);
525	506		FCurrPos := 0;
526	507		FSeparator := Separator;
527	508		FCurrent.Ind := -1;
528	509		end;
529	510
530	511		function TCsvAnsiStringFieldEnumerator.MoveNext: Boolean;
531	512		begin
532	513		if FCurrPos > Length(FCntnr) then exit(False);
533	514		// Premier élément
534	515		Inc(FCurrent.ind);
535	516		FCurrent.Value := '';
536	517		Inc(FCurrPos);
537	518		while (FCurrPos <= Length(FCntnr)) and (FCntnr[FCurrPos] <> FSeparator) do
538	519		begin
539	520		FCurrent.Value += FCntnr[FCurrPos];
540	521		Inc(FCurrPos);
541	522		end;
542	523		Result := True;
543	524		end;
544	525
545	526		end.
546	527		```
547	528
548	529		Un point intéressant se trouve dans la déclaration de GetEnumerator dont le type de retour est le type énumérateur lui-même, nécessaire pour pouvoir créer un itérateur à partir de la classe elle-même, mais surtout la méthode sera correctement adaptée lors de la spécialisation et retournera alors le type spécialisé (TCsvAnsiStringFieldEnumerator dans notre exemple). Ce qui montre que la substitution lors de spécialisation ne se limite aux seules marques substitutives ("placeholders").
549	530
550	531		Dans l'exemple, la spécialisation et la dérivation sont réalisées simultanément mais ce n'est pas une nécessité, il est d'ailleurs sans doute préférable de scinder ces deux opérations et de créer un type intermédiaire spécialisé TAnsiStringEnumerator qui sans introduire la notion de séparateur permettrait de concevoir d'autres itérateurs sur des AnsiString.
551	532
552	533		L'enregistrement couple (Indice,Valeur) lui-même générique sera automatiquement adapté lors de la spécialisation, cependant, son nom de type devra être qualifié à l'aide du nom de la classe d'énumérateur spécialisé comme nous pouvons le voir dans le petit programme d'exemple, afin de lever toute ambiguïté si deux types spécialisés devaient cohabiter :
553	534		```
554	535		#!/usr/bin/instantfpc
555	536
556	537		// (see the Instantfpc doc)
557	538
558	539		{$mode objfpc}{$H+}
559	540
560	541		uses
561	542		SysUtils,
562	543		IndicedEnumerators;
563	544
564	545		var
565	546		IndStr: TCsvAnsiStringFieldEnumerator.TIndicedValue;
566	547
567	548		begin
568	549		// énumérateur obtenu directement à partir de la classe elle-même, la libération de l'énumérateur
569	550		// est garantie en sortie de la boucle for .. in
570	551		for IndStr in TCsvAnsiStringFieldEnumerator.Create(ParamStr(1), ';') do
571	552		WriteLn(Format('%d : "%s"', [IndStr.Ind, IndStr.Value]));
572	553		end.
573	554		```
574	555
575	556		Appel du script InstantFPC en ligne de commande (nom du fichier source pascal avec des droit d'exécution sous Linux + un paramètre)
576	557		```
577	558		./TestStringFieldEnums.pas "small;string;with;separated;fields"
578	559		```
579	560
580	561		Cette solution a l'avantage de mettre à disposition un indice même si celui-ci n'existe pas nativement dans le type traversé, sans avoir à déclarer une variable Indice dans le code client.
581	562
582	563		Enfin, l'énumérateur générique pourrait être amélioré en ajoutant aux paramètres du constructeur un indice de départ (0 devenant la valeur par défaut).
583	564
584	565		# Référence
585	566
586	567		* <http://17slon.com/blogs/gabr/2007/03/fun-with-enumerators.html>
587	568
588	569		---
589	570		From the Free Pascal wiki, page "for-in loop/fr", as the Internet Archive kept it on 2024-09-08, last changed on 2020-02-16. 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