IdentifiantMot de passe
Mot de passe oublié ?Je m'inscris ! (gratuit)
logo

FAQ DelphiConsultez toutes les FAQ

Nombre d'auteurs : 124, nombre de questions : 929, dernière mise à jour : 31 décembre 2023  Ajouter une question

 

Cette FAQ a été réalisée à partir des questions fréquemment posées sur les forums Delphi et Delphi et bases de données de www.developpez.com et de l'expérience personnelle des auteurs.

Nous tenons à souligner que cette FAQ ne garantit en aucun cas que les informations qu'elle propose soient correctes. Les auteurs font le maximum, mais l'erreur est humaine. Cette FAQ ne prétend pas non plus être complète. Si vous souhaitez y apporter des corrections ou la compléter, contactez un responsable (lien au bas de cette page).

Nous espérons que cette FAQ saura répondre à vos attentes. Nous vous en souhaitons une bonne lecture.

L'équipe Delphi de Developpez.com.

Sommaire →Langage →Types de données →Nombres (10)
précédent sommaire suivant
 
HautPage
Comment transformer un réel en entier ?

Pour convertir un réel en entier, il faut utiliser les fonctions suivantes :

Function Trunc (X : Extended) : Integer

Trunc ajuste à l'entier le plus petit.
Exemples :

  • Trunc(1.2) donne 1 ;
  • Trunc(1.9) donne 1 ;
  • Trunc(-1.4) donne -1.

Function Round (X : Extended) : Integer

Round arrondit à l'entier le plus proche ; dans le cas où la valeur est juste entre deux entiers, c'est l'entier pair qui est choisi.
Exemples :
  • Round(1.2) donne 1 ;
  • Round(1.9) donne 2 ;
  • Round(1.5) donne 2 ;
  • Round(2.5) donne 2 ;
  • Round(2.500001) donne 3 ;
  • Round(-1.4) donne -1 ;
  • Round(-1.5) donne -2.

Function Ceil (X : Extended) : Integer (unité Maths)

Ceil arrondit à l'entier supérieur.
Exemples :
  • Ceil(1.2) donne 2 ;
  • Ceil(1.9) donne 2 ;
  • Ceil(-1.5) donne -1.

Function Floor (X : Extended) : Integer (unité Maths)

Floor arrondit à l'entier inférieur.
Exemples :
  • Floor(1.2) donne 1 ;
  • Floor(1.9) donne 1 ;
  • Floor(-1.5) donne -2.

Mis à jour le 18 octobre 2013 Nono40
Comment formater l'affichage d'un réel ?
HautPage
Comment formater l'affichage d'un réel ?

Pour transformer un réel en chaîne sans formatage particulier, il faut utiliser la fonction FloatToStr (Value : Extended) : String.
Mais dans la plupart des cas, il est utile de formater le nombre de décimales. Pour ce faire il y a différentes fonctions dans Delphi : FloatToStrF(), FormatFloat() ou Format().

Par exemple, pour afficher une valeur avec deux chiffres après la virgule :

Code delphi : Sélectionner tout 
1
2
3
4
5
6
Var f:Real; 
begin 
  f:=12345.6789; 
  ShowMessage(FloatToStrf(f,ffFixed,8,2)); 
  ShowMessage(FormatFloat('0.00',f)); 
  ShowMessage(Format('%8.2f',[f]));end;
Voir l'aide en ligne pour l'utilisation de ces fonctions.

Mis à jour le 18 octobre 2013 Nono40
Comment transformer un réel en entier ?
HautPage
Comment changer le caractère décimal par défaut ?

En fonction des ordinateurs et de la configuration des options régionales, le caractère décimal par défaut n'est pas toujours le même. Si votre application est sensible à ce caractère, il est conseillé de le fixer à l'initialisation de l'application. Par exemple dans la section Initialization de la fiche principale :

Code delphi : Sélectionner tout 
1
2
3
4
... 
Initialization 
  DecimalSeparator:='.'; 
end.

Ainsi, le caractère sera toujours le même. Il faut aussi penser à gérer la saisie de ce caractère dans les TEdit devant contenir des nombres réels :
Code delphi : Sélectionner tout 
1
2
3
4
5
procedure TForm1.Edit1KeyPress(Sender: TObject; var Key: Char); 
begin 
  If (Key=',') Or (Key='.') Then 
    Key:=DecimalSeparator; 
end;

Mis à jour le 18 octobre 2013 Nono40
HautPage
Comment transformer un nombre entier en lettres ?

La procédure donnée dans le code source ci-dessous permet de transformer un nombre en lettres, c'est-à-dire transformer 123 en « cent vingt trois ».
La déclaration de la fonction est la suivante :

Code delphi : Sélectionner tout 
function NombreEnLettres(n : integer ; France : Boolean = True ) : string;
n est le nombre à transformer en lettres, France détermine le langage à utiliser. Si France est à True, 70 sera écrit « soixante dix », sinon 70 sera écrit « septante ». Par défaut, France est True s'il n'est pas précisé.

Cette fonction tient compte des cas particuliers du Français :
  • 31 : trente et un ;
  • 80 : quatre-vingts ;
  • 81 : quatre-vingt un (sans « s » et sans « et ») ;
  • 200 : deux cents ;
  • 202 : deux cent deux (sans « s »).


La première version de cette fonction a été écrite en Basic sur CBM 4032, pour un ami qui voulait afficher un "chèque" en fin d'un jeu de black-jack, avec le défi de n'utiliser que le minimum de mots en "data". Elle a ensuite été reprise comme sujet d'exercice lors de stages de programmation en Basic qu''animait son auteur en 1983 pour la LFEEP.
Elle a finalement été transcrite en Pascal suite à plusieurs demandes.

Mis à jour le 18 octobre 2013 Pascal Peyremorte
integerlettres.zip
HautPage
Comment arrondir un réel ?

Pour arrondir un réel, utiliser la fonction SimpleRoundTo de l'unité Math.

Exemple :

Code delphi : Sélectionner tout 
1
2
showMessage(floatToStr(SimpleRoundTo(1.235,-2))); 
  // Affiche 1.24
Si cette fonction n'est pas disponible dans votre version de Delphi, vous pouvez utiliser la fonction suivante :
Code delphi : Sélectionner tout 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
uses 
  Math; 
  
function Arrondir(nombre : extended ; nbDecim : integer) : extended; 
var 
  p10 : extended; 
begin 
  { 2 étant le cas le plus fréquent, on le traite directement } 
  if (nbDecim = 2) then 
    result := round(nombre * 100) / 100 
  else 
  begin 
    p10 := Power(10,nbDecim); 
    result := round(nombre * p10) / p10; 
  end; 
end;
Exemples :
Code delphi : Sélectionner tout 
1
2
3
4
5
6
7
8
9
memo1.Lines.Add(floatToStr(arrondir(12,2))); 
memo1.Lines.Add(floatToStr(arrondir(13.59,1))); 
memo1.Lines.Add(floatToStr(arrondir(0.1,5))); 
memo1.Lines.Add(floatToStr(arrondir(0.14444444,3))); 
memo1.Lines.Add(floatToStr(arrondir(1.5,0))); 
memo1.Lines.Add(floatToStr(arrondir(1.54345678,1))); 
memo1.Lines.Add(floatToStr(arrondir(1.54345678,2))); 
memo1.Lines.Add(floatToStr(arrondir(1.54345678,3))); 
memo1.Lines.Add(floatToStr(arrondir(1.54345678,4)));
On obtient :
Code : Sélectionner tout 
1
2
3
4
5
6
7
8
9
12 
13,6 
0,1 
0,144 
2 
1,5 
1,54 
1,543 
1,5435

Mis à jour le 19 janvier 2014 Bloon
HautPage
Comment convertir un nombre en hexadécimal ?

La fonction à utiliser est StrToInt en ajoutant un '$' devant la chaîne qui contient le nombre hexa :

Code delphi : Sélectionner tout 
1
2
3
4
5
6
7
function hexaToInt(s : string) : integer; 
begin 
  if (s <> '') and (s[1] <> '$') then 
    result := StrToInt('$' + s) 
  else 
    result := StrToInt(s); 
end;
Exemples :
Code delphi : Sélectionner tout 
1
2
3
showMessage(intToStr(hexaToInt('10'))); // 16 
showMessage(intToStr(hexaToInt('$10'))); // 16 
showMessage(intToStr(hexaToInt('ABCD'))); // 43981
Rappel : la fonction inverse est intToHex, qui renvoie la représentation hexadécimale d'un entier.

Mis à jour le 19 janvier 2014 Bloon
HautPage
Comment élever un réel X à la puissance Y ?

Cette fonctionnalité est proposée par la fonction Power, déclarée dans l'unité Math.

Syntaxe Delphi :

Code delphi : Sélectionner tout 
function Power(const Base, Exponent: Extended): Extended;
Description
Power élève Base à n'importe quelle puissance. Pour les exposants fractionnels ou supérieurs à MaxInt, le paramètre Base doit être supérieur à 0.

Ainsi, pour récupérer 2.5^6, effectuez :
Code delphi : Sélectionner tout 
1
2
3
uses Math; 
... 
Value := Power(2.5, 6);
Astuce : pour calculer la racine cubique d'un réel, utilisez :
Code delphi : Sélectionner tout 
1
2
3
uses Math; 
... 
Value := Power(Value, 1/3);

Mis à jour le 19 janvier 2014 sjrd
HautPage
Comment comparer deux réels ?

Lorsque l'on compare 2 nombres à virgule flottante avec l'opérateur =, on a parfois des surprises : 2 nombres à priori égaux ne le sont pas. Ceci est dû à la représentation en virgule flottante qui est une approximation du nombre et non une représentation exacte (voir ci-dessous pour des explications plus poussées). Par exemple :

Code delphi : Sélectionner tout 
1
2
3
4
5
6
7
8
9
var 
  a : double; 
begin 
  a := 11 + 1.11; 
  if (a = 12.11) then 
    showMessage('égal') 
  else 
    showMessage('pas égal') // <-- affiche ce message 
end;
Heureusement, à partir de Delphi 6, Borland nous fournit 3 fonctions dans l'unité Math qui sont :
Code delphi : Sélectionner tout 
1
2
// Indique si deux valeurs en virgule flottante sont (approximativement) égales. 
function SameValue(const A, B: Single; Epsilon: Single = 0): Boolean; overload;
Les deux fonctions suivantes utilisent SameValue :
Code delphi : Sélectionner tout 
1
2
// Indique si une variable ou une expression en virgule flottante est évaluée à zéro ou à une valeur très proche de zéro. 
function IsZero(const A: Single; Epsilon: Single = 0): Boolean; overload;
Code delphi : Sélectionner tout 
1
2
// Renvoie la relation existant entre deux valeurs numériques. 
function CompareValue(const A, B: Single; Epsilon: Single = 0): TValueRelationship; overload;
Ces trois fonctions sont définies pour des Single, Double et Extended. CompareValue est également définie pour Integer et Int64. Le code ci-dessus qui ne fonctionnait pas devient alors :
Code delphi : Sélectionner tout 
1
2
3
4
5
6
7
8
9
10
uses Math; 
var 
  a : double; 
begin 
  a := 11 + 1.11; 
  if sameValue(a,12.11) then 
    showMessage('égal')      // <-- affiche ce message 
  else 
    showMessage('pas égal'); 
end;
L'aide de Delphi nous apprend qu'Epsilon est la quantité maximale dont A et B peuvent s'éloigner tout en étant considérées comme égales. Par défaut cette valeur est 0 mais en regardant le code, on constate que si epsilon est à 0 (ce qui n'aurait pas de sens), cette valeur est corrigée.

Si vous avez une version antérieure à Delphi 6

Il faut écrire une fonction qui se charge du travail. La valeur de Epsilon dépend de la précision des types réels comparés :
Code delphi : Sélectionner tout 
1
2
3
4
function EgaliteReels(n1,n2 : extended) : boolean; 
begin 
  result := Abs(n1 - n2) < Min(abs(n1),abs(n2)) * 1E-16; 
end;
Code delphi : Sélectionner tout 
1
2
3
4
function EgaliteReels(n1,n2 : double) : boolean; 
begin 
  result := Abs(n1 - n2) < Min(abs(n1),abs(n2)) * 1E-12; 
end;
Code delphi : Sélectionner tout 
1
2
3
4
function EgaliteReels(n1,n2 : single) : boolean; 
begin 
  result := Abs(n1 - n2) < Min(abs(n1),abs(n2)) * 1E-4; 
end;
Quelques précisions sur le calcul flottant

Pour aborder le calcul flottant je vous invite à vous reporter à la Norme IEEE 754 que vous pouvez consulter à cet endroit.

Les arrondis corrects de la nome IEEE 754, font qu'il est pratiquement impossible de comparer deux extended par le simple test suivant :
Code delphi : Sélectionner tout 
1
2
x,y: extended; 
if x = y then //pas bien
Pour résoudre ce problème de façon simple plusieurs méthodes sont à notre disposition.
  • La première consiste à calculer la différence entre nos deux extended x et y puis de vérifier que cette différence est inférieure à epsilon (1 > epsilon > 0) que nous aurons fixé.
    Cela donne :
    Code delphi : Sélectionner tout 
    | x - y | < epsilon
    Rappelons que x et y sont des flottants normalisés, on peut alors écrire
    Code delphi : Sélectionner tout 
    x = m1 10exp(a) et y = m2 10exp(b)
    donc,
    Code delphi : Sélectionner tout 
    |m1 10exp(a) - m2 10exp(b)| < epsilon
    Puisque x et y sont des nombres très proche dans le meilleur des cas nous aurons a = b, donc
    Code delphi : Sélectionner tout 
    |(m1-m2) 10exp(a)| < epsilon
  • La seconde méthode pour comparer les nombres x et y peut partir de la constatation que si x et y sont très proches alors le quotient de ces deux nombres est proche de 1. On peut alors écrire :
    Code delphi : Sélectionner tout 
    1
    2
    1-epsilon < |x/y| < 1 + epsilon 
-epsilon < |x/y| - 1 < epsilon
    soit encore
    Code delphi : Sélectionner tout 
    |1-|x/y|| < epsilon (*en ayant multiplié chacun des membres par -1*)
    En remplaçant x et y par leur représentation flottante normalisée, nous obtenons
    Code delphi : Sélectionner tout 
    |1-|(m1 10exp(a))/(m2 10exp(b))|| < epsilon
    Comme plus haut, a = b dans le meilleur des cas, donc
    Code delphi : Sélectionner tout 
    |1-|m1/m2|| < epsilon
    Ce qui est plus simple que dans la première méthode. En effet ici le calcul ne prendra en compte que les mantisses des flottants.

Mis à jour le 19 janvier 2014 Bloon
HautPage
Comment formater un entier ?

Pour formater un nombre entier en utilisant les séparateurs de milliers, on doit utiliser l'astuce de convertir notre entier en nombre flottant et n'afficher que la partie entière. La fonction format permet de réaliser cela très facilement.

Il existe deux formes d'utilisation de la fonction format.

Il est possible d'utiliser une variable locale pour spécifier le séparateur de milliers ou le séparateur décimal.

Voici un exemple :

Code Delphi : Sélectionner tout 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
  
procedure AfficheEntierFormate; 
var 
i:integer; 
setting:Tformatsettings; 
begin 
i:=10000000; 
  
//première forme de l'utilisation de la fonction format 
//L'astuce consiste à diviser l'entier par 1 pour obtenir un nombre flottant 
//et utiliser le caractère de type de conversion n au lieu de d. 
//On fixe le nombre de décimale à zéro avec le spécificateur facultatif de précision .0 
//On affiche donc une nombre flottant sans afficher les décimales 
//La fonction format utilisera les paramètres locaux pour formater le nombre 
showmessage(format('le nombre est %.0n ',[i/1])); 
//Si le séparateur de millier est l'espace notre valeur sera 10 000 000 
//mais rien nous garantie que le séparateur de millier est celui que nous voulons 
  
//Si on désire contrôler les paramètres de formatage, il faut déclarer une variable 
//de type Tformatsetting et utiliser la deuxième forme de la fonction format 
//On initialise notre variable avec les paramètres régionaux fixés par l'usager 
GetLocaleFormatSettings(SysLocale.DefaultLCID, setting); 
//On modifie la valeur ou les valeurs qui nous intéressent 
setting.ThousandSeparator:=','; 
showmessage(format('le nombre est %.0n ',[i/1], setting)); 
//Notre valeur sera affichée à coup sur selon notre désir 10,000,000 
  
end;
De cette façon, on ne modifie pas les variables globales et on ne risque pas d'effet de bord dans les traitements subséquents.

Mis à jour le 10 avril 2014 BeTuLa
Comment formater l'affichage d'un réel ?
HautPage
Comment convertir un nombre réel en lettres avec ou sans symbole monétaire

Cette fonction convertit un nombre réel en lettres. Si le symbole monétaire (Euro, Livre, Dollar, €, ...) est spécifié, le nombre est arrondi au centime, sinon on peut indiquer le nombre de chiffres après la virgule. La fonction prend en compte la langue française ou belge (quatre-vingt ou nonante par exemple).
La valeur maximum à convertir est de 2 147 483 647 (Maximum des entiers).

Pour utiliser cette fonction (testée en D7 et D10.4.2) l'unité Math doit être ajoutée à la clause Uses.

Code Delphi : Sélectionner tout 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
{ ======================================================================== } 
Function NombreEnLettres(Valeur : Real; SM : String = '' ; SSM : String = '' ; 
                NbDecimales : Integer =2 ; 
                France : Boolean = True ; Ancien : Boolean = True; 
                Maj : Boolean = True ) : string; 
// Conversion d'un nombre réel en lettre avec symbole monétaire en option 
// 
//  Valeur      : nombre à convertir en lettres 
//  SM          : symbole monétaire (Exemple € , Euros, £ ou Dollar) 
//  SSM         : sous symbole monétaire (Exemple le centime par défaut) 
//  NbDecimales : Nombre de décimales à utiliser uniquement si SM est vide 
//                Sinon 2 décimales 
//  France      : langue française, sinon belge 
//  Ancien      : si vrai nouvelle orthographe avec trait d'union entre nombres 
//                          Uses Math, ... 
Const 
  Unite     : array[1..19] of string = ('un','deux','trois','quatre','cinq','six', 
                                        'sept','huit','neuf','dix','onze','douze', 
                                        'treize','quatorze','quinze','seize', 
                                        'dix-sept','dix-huit','dix-neuf'); 
  DizaineF  : array[2.. 9] of string = ('vingt','trente','quarante','cinquante', 
                                       'soixante','','quatre-vingt',''); 
  DizaineB  : array[2.. 9] of string = ('vingt','trente','quarante','cinquante', 
                                       'soixante','septante','octante','nonante'); 
  Coefs     : array[0.. 3] of string = ('cent','mille','million','milliard'); 
Var 
  Temp      : String; 
  c, d, u   : Integer;      // Centaine, dizaine et unité 
  Coef      : Integer;      //  Puissance de 10 
  i         : Integer; 
  Negatif   : boolean;      //  Vrai si nombre négatif 
  n         : Integer ; 
  Decimales : Double ;      // Nombre après la virgule 
  Nombre    : Integer ;     // Nombre avant la virgule 
  Centimes  : String ;      // Libellé du ou des centimes 
  Penny     : Boolean ;     //  Vrai si SSM = penny ou pence 
  Livre     : Boolean ;     // Vrai pour la livre sterling  (cas de une au lieu de un) 
  Dollar    : Boolean ;     // Vrai pour le Dollar (cas du cent) 
  Separ     : Char    ;     // Séparateur : espace ou trait d'union 
  Et        : Boolean ;     // Présence du 'et' 
  FirstChar : Char    ;     // Pour mise en majuscule de la premiere lettre 
  Prefixe   : String  ;     // Préfixe après la virgule pour ,0  ou ,00 ... 
  Multiplicateur : Extended ;  // Puissance de 10 
  AA        : Extended ; 
Begin 
  Result := ''; 
  
  // Traitement de l'unité Monétaire SM 
  If SM <> EmptyStr Then 
  If (LowerCase(SM[Length(SM)]) = 's') Then 
    Begin 
      Delete(SM, Length(SM), 1) ;    // on met au singulier 
    End; 
  
  // Traitement de la sous-unité monétaire 
  SSM := LowerCase(Trim(SSM)) ; 
    // Cas spécial du penny 
  Penny := False ; 
  If ((SSM = 'penny') or (SSM = 'pence')) Then Penny := True ; 
  If (SSM = '') Then SSM := 'centime'   //  Cas général si SSM oublié : le centime 
    Else 
      Begin 
        If (SSM[Length(SSM)] = 's') Then 
          Begin 
            Delete(SSM, Length(SSM), 1) ;    // on met au singulier 
          End; 
      End ; 
  
  
  // Traitement de l'unité monétaire : cas spécial de la Livre sterling 
  Livre := False ; 
  If ((lowerCase(SM) = 'livre') or (SM = '£')) Then 
    Begin 
      Livre := True ; 
      Penny := True ; 
      Centimes := ' penny' ; 
    End ; 
  
  // Traitement de l'unité monétaire : cas spécial du Dollar 
  Dollar := False ; 
  If ((lowerCase(SM) = 'dollar') or (SM = '$')) Then 
    Begin 
      Dollar := True ; 
      Centimes := ' cent' ; 
    End ; 
  
  // Cas particulier de zéro 
  If Valeur = 0 Then 
  Begin 
    If Maj Then Result := 'Zéro ' + SM Else Result := 'zéro ' + SM ; 
    exit; 
  End; 
  
  // Mémorisation du signe 
  Negatif := Valeur < 0; 
  If Negatif Then Valeur := -Valeur; 
  
  // Nouvelle ou ancienne orthographe (avec ou sans traits d'union) 
  If Ancien Then Separ := ' ' Else Separ := '-' ; 
  
  // Traitement des décimales 
  If NbDecimales < 0 Then NbDecimales := 0 ; 
  If (SM <> EmptyStr) Then NbDecimales := 2 ; 
  
  // Arrondi au nombre de décimales spécifié 
  SetPrecisionMode(pmDouble) ; 
  SetRoundMode(rmNearest) ; 
  Valeur := RoundTo(Valeur, -NbDecimales) ; 
  
  //   Début du traitement  -------- 
  n := Trunc(Valeur) ; 
  
  If Valeur > MaxInt Then 
    Begin 
      Showmessage('Valeur supérieure à '+ IntToStr(MaxInt)+Chr(13)+Chr(10)+ 
                  'Conversion en lettres impossible') ; 
      Exit ; 
    End ; 
  
  Nombre    := n ; 
  
  Multiplicateur := Power(10, NbDecimales) ; 
  AA := Valeur * Multiplicateur ; 
  AA := RoundTo(AA, 0) ; 
  AA := AA / Multiplicateur ; 
  Decimales := RoundTo((AA - Trunc(AA)) * Multiplicateur, 0) ;   // Partie décimale du nombre à convertir 
  
  // Traitement du nombre 
  Coef      := 0 ; 
  Repeat 
    Et := False ; 
    // Récupération de l'unité du bloc de trois chiffres en cours 
    u:=n mod 10; n:=n div 10; 
    // Récupération de la dizaine du bloc de trois chiffres en cours 
    d:=n mod 10; n:=n div 10; 
  
    // Traitement des dizaines 
    Temp := ''; 
    // Passage sur la dizaine inférieure pour 10 à 19 
    // et pour 70-79 90-99 dans le cas de la France 
    If (d=1) Or ((d in [7,9])And France) Then 
      Begin 
        Dec(d); 
        Inc(u,10); 
      End; 
    If d > 1 Then 
      Begin 
        If France Then 
          Begin 
            Temp := Separ + DizaineF[d]; 
            Et := False ; 
            // Ajout du cas particulier de 'et' entre la dizaine et 1 
            If (d < 8) and ((u = 1) or (u = 11)) Then 
              Begin 
                Temp := Temp + Separ + 'et'; 
                Et := True ; 
              End ; 
          End 
        Else 
          Begin 
            Temp := Separ + DizaineB[d]; 
            Et := False ; 
            // Ajout du cas particulier de 'et' entre la dizaine et 1 
            If (u = 1) Then 
              Begin 
                Temp := Temp + Separ + 'et'; 
                Et := True ; 
              End ; 
          End; 
      End; 
  
    // Récupération de la centaine du bloc de trois chiffres en cours 
    c := n mod 10; n := n div 10; {Récupère centaine} 
  
    // Ajout du trait d'union avant l'unité si nombre < 100 et deux mots 
    If (((d > 0) or (not Ancien)) And (not Et) And (u <> 0) )  Then 
      Temp := Temp + '-' 
    Else If (u > 0) Then Temp := Temp + ' ' Else Temp := Temp + '' ;      // Cas de 80 ou de 300 par exemple 
  
    // Ajout du texte de l'unité 
    If u > 0 Then 
      If ((u = 1) And Livre) Then Temp := Temp + 'une'           // Une livre et non un livre 
                             Else Temp := Temp + Unite[u];         // avant les unités 
  
    // Ajout du 's' à 'quatre-vingt' si rien ne suit 
    If (Result = '') and (d = 8) and (u = 0) and France Then Result := 's'; 
    Result := Temp + Result; 
  
    // Traitement de la centaine du bloc de trois chiffres en cours 
    If c > 0 Then 
    Begin 
      Temp := ''; 
      If c > 1 Then Temp := Separ + Unite[c] + Temp; 
      Temp := Temp + Separ+  Coefs[0];                        // Avant cent 
      // Traitement du cas particulier du 's' à cent si rien ne suit 
      If (Result = '') and (c > 1) Then Result := 's'; 
      Result := Temp + Result; 
    End; 
  
    // Traitement du prochain groupe de 3 chiffres 
    If n > 0 Then 
    Begin 
      Inc(Coef); 
      I := n mod 1000; 
      If (i > 1) and (Coef > 1) Then Result := 's' + Result; 
      If i > 0 Then Result := Separ+ Coefs[Coef] + Result;          //  Avant mille 
      // Traitement du cas particulier 'mille' ( non pas 'un mille' ) 
      If (i = 1) and (Coef = 1) Then Dec(n); 
    End; 
  Until n = 0; 
  
  // Finalisation de la conversion (unité monétaire, pluriel...) 
  SM := Trim(SM) ; 
  If (SM <> '') Then 
    Begin 
      Result := Trim(Result) ; 
  
      If Result = EmptyStr Then 
        If Maj Then Result := 'Zéro' Else Result := 'zéro' ; 
  
      If Nombre = 0 Then  Result := ''       // Cas des nombres inférieurs à 1, avec unité monétaire 
        Else 
          If ((Nombre > 1) And (Length(SM) > 3)) Then  Result := Result+ ' '+ SM + 's'  // Ajout ou non d'un s à SM 
                                                 Else  Result := Result+ ' '+ SM  ; 
  
      If ((Decimales > 0 ) And (Nombre > 0)) Then  Result := Result + ' et ' ; 
  
      If Penny Then        //  Traitement spécial du penny 
        Begin 
          If (Decimales > 0 ) Then 
             Begin 
               Centimes := ' penny' ; 
               If (Trunc(Decimales) > 1) Then  Centimes := ' pence' ; 
                Result := Result + IntToStr(Trunc(Decimales)) + Centimes ; 
             End ; 
        End 
      Else 
        Begin 
          If Dollar Then     // Cas du Dollar 
            Begin 
              If (Decimales > 0 ) Then 
                 Begin 
                   Centimes := ' cent' ; 
                   If (Trunc(Decimales) > 1) Then  Centimes := ' cents' ; 
                    Result := Result + IntToStr(Trunc(Decimales)) + Centimes ; 
                 End ;    
            End 
          Else 
            Begin 
              If (Decimales > 0 ) Then    //  Autres sous-unités 
                 Begin 
                   Centimes := ' '+ SSM ; 
                   If (Trunc(Decimales) > 1) Then  Centimes := centimes + 's' ; 
                    Result := Result + IntToStr(Trunc(Decimales)) + Centimes ; 
                 End ; 
            End ; 
        End ; 
    End 
  Else 
    Begin 
      // Traitement spécial du zéro virgule ... 
      Result := Trim(Result); 
  
      If Result = EmptyStr Then 
        If Maj Then Result := 'Zéro' Else Result := 'zéro' ; 
  
      If (Decimales > 0 ) Then 
         Begin 
           //  Ajout du nombre de 'zéro' après la virgule 
           Prefixe := ' virgule' ; 
           For i := NbDecimales Downto 2 Do 
             Begin 
               If (Decimales < Power(10, i-1)) Then Prefixe := Prefixe + ' zéro' ; 
             End ; 
           Result := Result + Prefixe + ' ' + NombreEnLettres(Decimales, '', SSM, NbDecimales, France, Ancien, False); 
         End ; 
    End ; 
  
  // Suppression du - en première position (cas de la nouvelle orthographe) 
  If (Result[1] = '-') Then Delete(Result,1 , 1) ; 
  
  if (Maj And (Result <> EmptyStr)) then      //  Première lettre en majuscule 
  begin 
    FirstChar := UpCase(Result[1]); 
    Result := FirstChar + Copy(Result, 2, Length(Result) - 1); 
  End ; 
  
  // Ajout du signe en cas de besoin 
  If Negatif Then Result := 'moins ' + Result; 
End; 
{ ======================================================================== }

Mis à jour le 13 décembre 2021 Charly910

Proposer une nouvelle réponse sur la FAQ

Ce n'est pas l'endroit pour poser des questions, allez plutôt sur le forum de la rubrique pour ça


Réponse à la question

Liens sous la question
précédent sommaire suivant
 

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2024 Developpez Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.