Command line parameters and environment variables/fr: what changed

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

Old	New		Line
1	1		## Présentation
2	2
3	3		Quand un programme est démarré, un utlisateur peut transmettre des paramètres de ligne de commandes et définir des variables d'environnement. P. ex., le compilateur FreePascal obtient la plupart de ces paramètres via les options de ligne de commande:
4	4
5		-	~~` fpc -Fudirectory -gh unit1.pas`~~
	5	+	```text
	6	+	fpc -Fudirectory -gh unit1.pas
	7	+	```
6	8
7	9		## Paramètres de la ligne de commande
8	10
9	11		### Les bases
10	12
11	13		Un programme Pascal peut accéder aux paramètres via les fonctions ParamStr et ParamCount. ParamStr(0) est le nom de programme lui-même (et le chemin d'accès _SI_ le système d'exploitation le permet). ParamStr(1) est le premier paramètre. ParamCount est le nombre de paramètres.
12	14
13	15		``` pascal
14	16		program Project1;
15	17
16	18		{$mode objfpc}{$H+}
17	19
18	20		var
19	21		I: Integer;
20	22		begin
21	23		WriteLn('Programme: ', ParamStr(0));
22	24		for I := 1 to ParamCount do
23	25		WriteLn('Param ', I, ': ', ParamStr(I));
24	26		end.
25	27		```
26	28
27	29		P. ex.:
28	30
29		-	~~` $ /tmp/project1 -a`\~~
30		-	~~` Program: /tmp/project1`\~~
31		-	~~` Param 1: -a`~~
	31	+	``` pascal
	32	+	$ /tmp/project1 -a
	33	+	Program: /tmp/project1
	34	+	Param 1: -a
	35	+	```
32	36
33	37		### Orienté utilisateur
34	38
35	39		Un bon programme devrait donner un message d'aide quand il est invoqué avec de mauvais paramètres et devrait suivre une manière commune dpour transmettre les paramètres. L'unité CustApp, qui vient avec FPC, fournit la classe TCustomApplication, laquelle fournit des fonctions pour contrôler et lire facilement des paramètres. Bien sûr, vous pouvez toujours accéder directement aux paramètres via ParamStr et ParamCount.
36	40
37	41		Toute application LCL utilise ceci automatiquement. L'objet Application est une TCustomApplication.
38	42
39	43		Si vous voulez écrire un programme non LCL, puis créer un nouveau projet dans Lazarus du type 'Application Console'. Ceci créera un project1.lpr avec quelques goodies sympas dont presque tous les programmes ont besoin. Allez à la méthode DoRun pour spécifier ce que fait votre programme.
40	44
41	45		#### Contrôler un paramètre
42	46
43	47		Avec TCustomApplication, vous pouvez accéder aux paramètres par leur nom. P. ex., votre programme pourrait afficher un texte d'aide quand l'utilisateur donne le paramètre d'aide courant -h. -h' est une option courte. La forme longue est le--help. Pour tester si l'utilisateur a appelé le programme avec-hou--help'', vous pouvez utiliser;
44	48
45	49		``` pascal
46	50		if HasOption('h', 'help') then begin
47	51		WriteHelp;
48	52		Halt;
49	53		end;
50	54		```
51	55
52	56		Note: Cela est valable dans la méthode DoRun. Dans une fiche LCL, vous devez qualifier HasOption avec Application.. P. ex.:
53	57
54	58		``` pascal
55	59		if Application.HasOption('h', 'help') then begin
56	60		WriteHelp;
57	61		Halt;
58	62		end;
59	63		```
60	64
61	65		``` pascal
62	66		// Si vous voulez seulement proposer l'option courte, utilisez:
63	67		if HasOption('h', '') then ...
64	68
65	69		// Si vous voulez seulement proposer l'option longue, utilisez:
66	70		if HasOption('help') then ...
67	71		```
68	72
69	73		Contrairement à ce que laisse penser l'exemple de présentation, il n'est pas possible de cumuler plusieurs options courtes derrière un seul '-', ainsi -dh n'est pas reconnue comme une écriture condensée de -d -h.
70	74
71	75		#### Lire la valeur d'un paramètre
72	76
73	77		Chaque paramètre peut donner une valeur. Par exemple:
74	78
75		-	~~` project1 -f filename`~~
	79	+	```text
	80	+	project1 -f filename
	81	+	```
76	82
77	83		ou avec la forme longue
78	84
79		-	~~` project1 --file=filename`~~
	85	+	```text
	86	+	project1 --file=filename
	87	+	```
80	88
81	89		``` pascal
82	90		WriteLn('f=', GetOptionValue('f', 'file'));
83	91		```
84	92
85	93		Note: si vous obtenez le message d'erreur Option at position 1 needs an argument : f. alors vous avez oubliez d'ajouter l'option dans l'appel CheckOptions.
86	94
87	95		#### Contrôler la validité de paramètres
88	96
89	97		Les paramètre de ligne de commande sont du texte libre, aussi l'utilisateur peut facilement taper des erreurs. Contrôler la syntaxe des paramètres est en conséquence obligatoire. Vous pouvez utiliser la méthode [[doc:fcl/custapp/tcustomapplication.checkoptions.html\|CheckOptions]] pour cela:
90	98
91	99		Vous pouvez définir quels paramètres sont permis, lesquels ont besoin d'un paramètre et en cas d'erreur de syntaxe, vous pouvez obtenir un message plus les mauvaises options pour afficher des erreurs utiles et détaillées.
92	100
93	101		Exemples:
94	102
95	103		``` pascal
96	104		ErrorMsg := CheckOptions('hf:', 'help file:');
97	105		```
98	106
99	107		Cela permet de transmettre des options courtes -f value et -h. Il permet de transmettre les options longues --help ou --file=filename. Il ne permet pas de passer --help avec une valeur, ni --file sans valeur.
100	108
101	109		## Variables d'environnement
102	110
103	111		Trois fonctions de bases sont fournies pour travailler avec les variables d'environnement.
104	112
105	113		[GetEnvironmentVariable](http://www.freepascal.org/docs-html/rtl/sysutils/getenvironmentvariable.html)
106	114
107	115		[GetEnvironmentString](http://www.freepascal.org/docs-html/rtl/sysutils/getenvironmentstring.html)
108	116
109	117		[GetEnvironmentVariableCount](http://www.freepascal.org/docs-html/rtl/sysutils/getenvironmentvariablecount.html)
110	118
111	119		Exemple:
112	120
113	121		``` pascal
114	122		var
115	123		I: Integer;
116	124		begin
117	125		WriteLn('PATH = ' + GetEnvironmentVariable('PATH'));
118	126
119	127		WriteLn('Toutes les variables d''environnement:');
120	128		for I := 0 to GetEnvironmentVariableCount - 1 do
121	129		WriteLn(GetEnvironmentString(I));
122	130		end.
123	131		```
124	132
125	133		Il est aussi possible de charger toutes les variables d'environnement dans un objet TStringList et d'accéder à une paire nom-valeur de manière simple. En effet, la liste de chaîne manipule automatiquement le séparateur qui est par défaut '='.
126	134
127	135		``` pascal
128	136		var
129	137		I: Integer;
130	138		EnvVars: TStringList;
131	139		begin
132	140		EnvVars := TStringList.Create;
133	141		try
134	142		// Charge toutes les variables dans une liste de chaînes
135	143		for I := 0 to GetEnvironmentVariableCount - 1 do
136	144		EnvVars.Add(GetEnvironmentString(I));
137	145
138	146		WriteLn('PATH = ' + EnvVars.Values['PATH']);
139	147
140	148		WriteLn('Toutes les variables d''environnement:');
141	149		for I := 0 to EnvVars.Count - 1 do
142	150		WriteLn(EnvVars.Names[I] + ' = ' + EnvVars.ValueFromIndex[I]);
143	151		finally
144	152		EnvVars.Free;
145	153		end;
146	154		end.
147	155		```
148	156
149	157		---
150	158		From the Free Pascal wiki, page "Command line parameters and environment variables/fr", as it stood on 2020-02-11 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