// Les gens qui sont habitués à Java ou C # peuvent être très en colère contre Delphi et n'ont même pas de types de base dans mon travail quotidien, j'essaie souvent de rassembler certaines fonctions et de faire souvent des fonctions de mes propres types de base. eux ici.
Unit Baseclass;
interface
usages
Sysutils, classes, strutils, idglobal, mathématiques;
taper
TCharset = ensemble de char;
var
TNormalCharset: tCharset = [# 13, # 10, # 32, '.', ',', ';'];
taper
TString = classe
Privé
FText: String;
publique
fonction charat (apposition: entier): char;
// les lettres de la position spécifiée
Fonction TolowerCase: String;
Fonction de classe TolowerCase (Astring: String): String;
// minuscule
Fonction ToupperCase: String;
Fonction de classe ToupperCase (Astring: String): String;
//capital
Valeur de fonction de classe (Avalue: String): Boolean;
Valeur de fonction de classe (Avalue: Boolean): String;
Fonction de classe Stringin (Avalue: String; Avalues: Array of String): Boolean;
Fonction de classe gauche (Avalue: String; alngle: entier): String;
Fonction de classe à droite (Avalue: String; alngle: entier): String;
Fonction de classe DeletePrefix (Avalue: String; FixedString: tCharset = [# 32]): String;
Fonction de classe DeleTesuffix (Avalue: String; FixedString: tCharset = [# 32]): String;
//
Class Fonction Comparrestring (AVALUE1: String; Avalue2: String): Boolean;
Fonction de classe HashCode (Avalue: String): entier;
Fonction de classe LastChar (Avalue: String): char;
Class Function StringReplace (const S, OldPattern, newPattern: String;
Flags: TrePlaceFlags): String;
Fonction de classe Stringofchar (ch: char; count: Integer): String;
Fonction de classe setString (var s: string; tampon: pChar; len: Integer): String;
Fonction de classe Getpy (astr: String): String;
// Obtenez le pinyin correspondant.
Fonction de classe IsallChinese (astr: String): Boolean;
Fonction de classe Isallenglish (astr: String): Boolean;
Fonction de classe getFirstword (Avalue: String; var aword: String; Aseparator: tCharset): Integer;
Fonction de classe getFirstword (Avalue: String; var aword: String; Aseparator: String): Integer;
// La valeur de retour est la longueur du début au document.
Fonction de classe GetAllword (Avalue: String; Aseparator: String): TStringList;
// renvoie tous les mots clés. Après l'avoir utilisé, veuillez libérer le jeu de résultats;
// Remarque: veuillez ne pas utiliser cette fonction dans une utilisation future. Veuillez utiliser sa version rechargée
// getAllword (Avalue: String; Aseparator: String; AstringList: TStringList);
Procédure de classe GetAllword (Avalue: String; Aseparator: String; AstringList: TStrings);
// Chargez tous les ensembles de résultats sur AstringList;
Procédure de classe getAllWordWithall (Avalue: String; Aseparator: String; AstringList: TStrings);
Fonction de classe StringToCharset (Avalue: String): tCharset;
Fonction de classe CharSetToString (Avalue: TCharset): String;
Classe Fonction UpdateSensence (aoldString: String; // La chaîne en cours de fonctionnement
AupdaSource: String; // le mot trouvé.
AupdateString: String;
AssenceSeparator: String;
AwordSeparator: String // Document Séparateur;
): String; // Retour Résultat.
// Par exemple, la valeur de retour de 'Dbarcode ASC, Dname Desc', 'Dbarcode', '', ',', '' est
// 'Dname Desc';
Fonction de classe DeleteRepeat (aoldString: String; // pour gérer les caractères
Adelestring: char; // le caractère à supprimer
ArePeat: char): String;
Fonction de classe ifthen (aexpression: boolean; atrue: string; afalse: string): string;
// Renvoie la chaîne correspondante en fonction de la valeur de l'expression.
Fonction de classe AbsoluteToreLate (AABSolute: String; Acurrent: String): String;
// Compte tenu de deux fichiers, convertissez le chemin absolu en chemin relatif.
Fonction de classe RelateToAbSolute (Arate: String; Acurrent: String): String;
fonction de classe similaire (aone, atwo: string): entier;
Fonction de classe getcharnum (astrring: string; achar: char): entier;
Index de fonction de classe (astrring, asubstring: string): entier;
Fonction de classe Zerotoint (astrring: string): entier;
fonction de classe zerotofloat (astrring: string): double;
Fonction de classe ZerotoStr (astrring: string): String;
Fonction de classe SAMETEXT (Astring, Astring1: String): Boolean;
Fonction de classe Reverse (Astring: String): String;
Fonction de classe Isvalidip (const S: String): Boolean;
Fonction de classe FillString (ACHAR: char; alngle: entier): String;
Fonction de classe StuffString (const Atext: String; Astart, alngle: cardinal;
const asubtext: string): String;
Fonction de classe getNextString (var SourCestring: String; asplitchar: String): String;
fin;
// type entier.
Tinteger = classe
Fonction de classe inttoStr (AInteger: Integer): String;
Fonction de classe IntToStr (AInteger: INT64): String;
Fonction de classe isValidInt (astrring: string): booléen;
Fonction de classe isValidInt64 (astrring: string): booléen;
Fonction de classe Maxint: entier;
Fonction de classe MaxlongInt: entier;
Fonction de classe HashCode (AInteger: Integer): entier;
Fonction de classe IntToBin (Ainteger: Cardinal): String;
Fonction de classe intoHex (AInteger: Integer): String;
Fonction de classe hextoint (astrring: string): entier;
Fonction de classe madeSerialno (Ainteger: entier; adigit: entier): String;
fin;
Tfloat = classe
Fonction de classe IsvalidFloat (astrring: String): Boolean;
Fonction de classe MaxDouble: double;
Fonction de classe Mindouble: double;
Fonction de classe Maxextended: Extended;
Fonction de classe Minextended: Extended;
Fonction de classe SameValue (const a, b: single; epsilon: single = 0): boolean;
Fonction de classe SameValue (const a, b: double; epsilon: double = 0): Boolean;
Fonction de classe SameValue (const A, B: Extended; Epsilon: Extended = 0): Boolean;
Fonction de classe Floattomoney (const Value: Double; Round: boolean = true): String;
fin;
Tboolean = classe
Fonction de classe Booltostr (Aboolan: Booléen): String;
Fonction de classe Strtobool (astrring: String): Boolean;
fin;
Mise en œuvre
{TString}
fonction getpyIndexchar (achar: string): char;
Commencer
Case mot (achar [1]) shl 8 + mot (achar [2]) de
$ B0a1 .. $ b0c4: résultat: = 'a';
$ B0c5 .. $ b2c0: résultat: = 'b';
$ B2c1 .. $ b4ed: résultat: = 'c';
$ B4ee .. $ b6e9: résultat: = 'd';
$ B6ea .. $ b7a1: résultat: = 'e';
$ B7a2 .. $ b8c0: résultat: = 'f';
$ B8c1 .. $ b9fd: résultat: = 'g';
$ B9fe .. $ bbf6: résultat: = 'h';
$ Bbf7 .. $ bfa5: résultat: = 'j';
$ Bfa6 .. $ c0ab: résultat: = 'k';
$ C0AC .. $ C2E7: Résultat: = 'l';
$ C2E8 .. $ C4C2: Résultat: = 'M';
$ C4C3 .. $ C5B5: Résultat: = 'n';
$ C5B6 .. $ C5BD: Résultat: = 'O';
$ C5BE .. $ C6D9: Résultat: = 'P';
$ C6da .. $ c8ba: résultat: = 'q';
$ C8BB .. $ C8F5: Résultat: = 'r';
$ C8f6 .. $ cbf9: résultat: = 's';
$ Cbfa .. $ cdd9: résultat: = 't';
$ Cdda .. $ cef3: résultat: = 'w';
$ Cef4 .. $ d188: résultat: = 'x';
$ D1b9 .. $ d4d0: résultat: = 'y';
$ D4d1 .. $ d7f9: résultat: = 'z';
autre
Résultat: = char (0);
fin;
fin;
Fonction de classe tString.getpy (astr: string): String;
var
I: entier;
Commencer
Résultats: = '';
pour i: = 1 à la longueur (astr) faire
Commencer
Si byteType (astr, i) = mbtrailbyte alors
Résultat: = résultat + getpyIndexchar (asst [i - 1] + astr [i])
autre
Si byteType (astr, i) = mbSingleByte alors
Résultat: = résultat + astr [i];
fin;
fin;
fonction tString.Charat (apposition: entier): char;
Commencer
Résultat: = fText [aposition];
fin;
Fonction de classe TString.CharsetToString (Avalue: TCharset): String;
Commencer
fin;
Fonction de classe tString.Carestring (Avalue1, Avalue2: String): Boolean;
Commencer
Résultat: = uppercase (AVALUE1) = UPPERCASE (AVALUE2);
fin;
Fonction de classe tString.DelePrefix (Avalue: String;
FIXTSTRING: TCHARSET): String;
Commencer
tandis que System.Length (Avalue)> 0 do
Commencer
Si AVALUE [1] dans FixedString alors
Supprimer (Avalue, 1, 1)
autre
Casser;
fin;
Résultat: = Avalue;
fin;
Fonction de classe tString.getFirstword (Avalue: String; var aword: String; Aseparator: tCharset
): Entier;
var
tmptr: String;
TMPPOS: entier;
Commencer
tmptr: = DeleTesuffix (Avalue, Aseparator);
tmptr: = deletePrefix (Avalue, Aseparator);
Résultat: = longueur (Avalue) - Longueur (TMPSTR);
{if LONGUELL (TMPSTR) = 0 puis sortir;
if (tmpstr [1] = '' '') et (tmptr [2] = '' '') puis
Commencer
Pour TMPPOS: = 3 à la longueur (TMPSTR)
Commencer
Si tmptr [tMPPOS] dans ['' ''] alors
Casser;
fin;
fin;
Si TMPPOS> 3 alors TMPPOS: = TMPPOS + 2;
}
Pour TMPPOS: = 1 à la longueur (TMPSTR)
Commencer
Si TMPSTR [TMPPOS] dans Aseparator alors
Casser;
fin;
TMPPOS: = TMPPOS -1;
// {todo: -oghs a corrigé le dernier paramètre analysant incorrectement}
if (tMPPOS = 0) et (Avalue <> '') puis
TMPPOS: = longueur (Avalue);
Aword: = copy (Avalue, Result + 1, tMPPOS);
Résultat: = résultat + TMPPOS;
fin;
Fonction de classe tString.hashCode (Avalue: String): entier;
var
I: entier;
tmpValue: entier;
Commencer
tmpValue: = 0;
pour i: = 1 à System.length (Avalue) faire
Commencer
tmpValue: = 3 * tmpValue + ord (Avalue [i]);
fin;
Résultat: = tmpValue;
fin;
Fonction de classe TString.isallChinese (AST: String): Boolean;
var
I: entier;
Commencer
Résultat: = true;
pour i: = 1 à la longueur (astr) faire
Commencer
Si byteType (astr, i) = mbSingleByte alors
Commencer
Résultat: = false;
Casser;
fin;
fin;
fin;
Fonction de classe tString.isallenglish (astr: string): booléen;
var
I: entier;
Commencer
Résultat: = true;
pour i: = 1 à la longueur (astr) faire
Commencer
Si byteType (astr, i) <> mbsinglebybyte alors
Commencer
Résultat: = false;
Casser;
fin;
fin;
fin;
Fonction de classe TString.lastchar (Avalue: String): char;
Commencer
Résultat: = Avalue [System.Length (Avalue)];
fin;
Fonction de classe TString.left (Avalue: String; alngle: INTEGER): String;
Commencer
Résultat: = Copy (Avalue, 1, alngle);
fin;
Fonction de classe TString.Right (Avalue: String; alngle: Integer): String;
Commencer
Résultat: = strutils.rightstr (Avalue, alngle);
fin;
Fonction de classe TString.SetString (var S: String; Buffer: PCHA;
Len: entier): String;
Commencer
System.SetString (S, Buffer, Len);
Résultats: = s;
fin;
Fonction de classe TString.stringin (Avalue: String;
Avalues: tableau de chaîne): booléen;
var
I: entier;
Commencer
Résultat: = false;
pour i: = bas (avals) à élevé (avalues) faire
Commencer
Si majuscule (Avalue) = majuscule (Avalues [i])
Commencer
Résultat: = true;
Casser;
fin;
fin;
fin;
Fonction de classe TString.Stringofchar (Ch: char; Count: Integer): String;
Commencer
Résultat: = System.Stringofchar (Ch, Count);
fin;
Fonction de classe TString.StringReplace (const S, OldPattern,
NewPattern: String; Flags: TrePlaceFlags): String;
Commencer
Résultat: = synutils.stringreplace (s, oldpattern, newpattern, drapeaux);
fin;
Fonction de classe TString.StringtoCharset (Avalue: String): TCharset;
var
I: entier;
Commencer
Résultats: = [];
pour i: = 1 à la longueur (Avalue) faire
Commencer
Résultat: = résultat + [Avalue [i]];
fin;
fin;
fonction tString.tolowerCase: String;
Commencer
Résultat: = minuscules (ftext);
fin;
fonction tString.touppercase: String;
Commencer
Résultat: = uppercase (fText);
fin;
Fonction de classe TString.Valueof (Avalue: Boolean): String;
Commencer
Si AVALUE alors
Résultat: = 'Oui'
autre
Résultat: = 'non';
fin;
Fonction de classe TString.Valueof (Avalue: String): Boolean;
Commencer
Résultat: = Stringin (Avalue, ['Yes', 'Yes', 'OK']);
fin;
Fonction de classe tString.getFirstword (Avalue: String; var aword: String;
ASEPARATOR: String): entier;
Commencer
Résultat: = getFirstWord (Avalue, Aword, StringToCharset (ASEPARATOR));
fin;
Fonction de classe tString.getAllword (Avalue, Aseparator: String): TStringList;
var
tmplist: tStringList;
TMPword: String;
Commencer
tmplist: = tStringList.Create;
Pendant que la longueur (AVALUE)> 0 fait
Commencer
TMPword: = '';
Delete (Avalue, 1, getFirstword (Avalue, Tmpword, Aseparator));
Si tmpword <> '' alors
tmplist.add (TMPword)
autre
Casser;
fin;
Résultat: = tmplist;
fin;
Fonction de classe tString.updaSESENCE (AoldString, AupdaSource,
AupDateString, assenceSeparator, AwordSparator: String): String;
var
TMPSENSENCE: String;
TMPword: String;
tmpword1: chaîne;
I: entier;
TMPRESULT: String;
Commencer
// Obtenez la première phrase
tmpPentence: = aoldString;
tmpresult: = '';
tandis que la longueur (tmpsentence)> 0 fait
Commencer
i: = getFirstWord (tmpPsence, tmpord, assenceSeparator);
TMPRESULT: = TMPRESULT + Left (tmpPsence, i - length (tmpword));
Supprimer (tmpPsence, 1, i);
Si tmpword <> '' alors
Commencer
i: = getFirstword (tmpword, tmpword1, awordSeparator);
TMPRESULT: = TMPRESULT + Left (tmpword, i - length (tmpword1));
Si Comparrestring (TMPWord1, AupDaSEnource)
Commencer
TMPRESULT: = TMPRESULT + AUPDATESTRING;
fin
autre
Commencer
TMPRESULT: = TMPRESULT + TMPWORD;
fin;
fin;
fin;
tmpresult: = deletePrefix (tmpresult, ['', ',']);
tmpresult: = deleTesuffix (tmpresult, ['', ',']);
tmpresult: = deleterepeat (tmpresult, ',', '');
tmpresult: = deleterepeat (tmpresult, '', '');
Résultat: = tmpResult;
fin;
Fonction de classe tString.DeleTerepeat (aoldString: String; AdeleTestring,
ArePeat: char): String;
var
I: entier;
tmpFind1: booléen;
Commencer
tmpFind1: = false;
pour i: = longueur (aoldstring)
Commencer
Si tmpFind1 alors
Commencer
Si aoldstring [i] = adeletestring alors
Supprimer (aoldstring, i, 1)
autre
Commencer
Si aoldString [i] = arePeat alors
Continuer;
tmpFind1: = aoldString [i] = AdeleTestring;
fin;
fin
autre
Commencer
Si Adeletestring <> ArePeat alors
Si aoldString [i] = arePeat alors
Continuer;
tmpFind1: = aoldstring [i] = Adeletestring
fin;
fin;
Résultat: = aoldString;
fin;
Fonction de classe TString.DeteSuffix (Avalue: String;
FIXTSTRING: TCHARSET): String;
Commencer
tandis que System.Length (Avalue)> 0 do
Commencer
Si Avalue [System.Length (Avalue)] dans FixedString alors
Supprimer (Avalue, System.Length (Avalue), 1)
autre
Casser;
fin;
Résultat: = Avalue;
fin;
Procédure de classe tString.getAllword (Avalue, Aseparator: String;
AstringList: TStrings);
var
TMPword: String;
Commencer
Si astringList = nil alors
AstringList: = tStringList.Create;
Pendant que la longueur (AVALUE)> 0 fait
Commencer
TMPword: = '';
Delete (Avalue, 1, getFirstword (Avalue, Tmpword, Aseparator));
Si tmpword <> '' alors
AstringList.add (TMPword)
autre
Casser;
fin;
fin;
Fonction de classe TString.ifthen (aexpression: booléen; atrue,
Afalse: String): String;
Commencer
Si aexpression alors
Résultat: = atrue
autre
Résultat: = afalse;
fin;
Fonction de classe tString.absoluTeToreLate (Aabsolute,
Acurrent: String): String;
var
TMPSIMELLASTRING: String;
Aoldfile: String;
I: entier;
TMPPOS: entier;
Commencer
// Après la conversion, il se forme ... / .. / a.ini;
// S'il n'est pas sur le même lecteur, il reviendra directement sur le chemin absolu.
Si ExtractFiledRive (Aabsolute) <> ExtractFiledRive (acurrent)
Résultat: = Aabsolute
autre
Commencer
tmpsimilarString: = '';
Aoldfile: = aaBsolute;
AaBsolute: = ExtractFilePath (aaBsolute);
TMPPOS: = Position similaire (Aabsolute, Acurrent);
Supprimer (aoldfile, 1, TMPPOS - 1);
Supprimer (acurrent, 1, TMPPOS - 1);
pour i: = 0 pour getcharnum (acurrent, '/') -1 do
Commencer
TMPSIMELLSTRING: = TMPSIMELLASTRING + '../';
fin;
Résultat: = TMPSIMILARSTRING + AOLDFILE;
fin;
fin;
Fonction de classe tString.relatetoabsolute (Arate, Acurrent: String): String;
var
TMPSIMELLASTRING: String;
tmprootCount: entier;
I: entier;
Commencer
Si la longueur (arelate)> 2 alors
Commencer
Si Arelate [2] = ':' alors
Commencer
Résultat: = arelate;
Sortie;
fin;
fin;
tmpsimilarString: = '';
tmprootCount: = 0;
Tandis que vrai faire
Commencer
Si Lelestr (arelate, 3) = '../' alors
Commencer
Inc (tmprootCount);
Supprimer (arelater, 1, 3);
fin
autre
casser;
fin;
TMPSIMELLSTRING: = REVERSESTRING (ExtractFilePath (Acurrent));
pour i: = 0 à tmprootcount
Commencer
Delete (tmpsimilarString, 1, pos ('/', tmpsimimarString));
fin;
Résultat: = reversestring (tMPSiMilarString) + arelate;
fin;
Fonction de classe TString.similaringPosition (aone, atwo: string): entier;
var
I: entier;
Max: entier;
Commencer
si la longueur (aone) <longueur (atwo) alors
Max: = longueur (aone)
autre
Max: = longueur (atwo);
pour i: = 1 à max do
Commencer
Si un one [i] <> atwo [i] alors
Casser;
fin;
Résultats: = i;
fin;
Fonction de classe tString.getCharnum (astrring: string; achar: char): entier;
var
I: entier;
Commencer
Résultats: = 0;
pour i: = 1 à la longueur (astrage) faire
Commencer
Si astring [i] = achar alors
Inc (résultat);
fin;
fin;
Procédure de classe tString.getAllwordWithall (Avalue, Aseparator: String;
AstringList: TStrings);
var
TMPI: entier;
TMPPOS: entier;
Commencer
Si astringList = nil alors
AstringList: = tStringList.Create;
TMPPOS: = 0;
Pendant que la longueur (AVALUE)> 0 fait
Commencer
Pour TMPI: = 1 à la longueur (AVALUE)
Commencer
TMPPOS: = POS (AVALUE [TMPPOS], ASEPARATOR);
Si TMPPOS> 0 alors
Commencer
AstringList.add (copie (Avalue, 1, TMPPOS - 1));
AstringList.add (copie (Avalue, TMPPOS, 1));
Supprimer (Avalue, 1, TMPPOS);
Casser;
fin
fin;
fin;
fin;
Fonction de classe tString.tolowerCase (astrring: string): String;
Commencer
Résultat: = minuscules (astring);
fin;
Fonction de classe tString.toupperCase (astrring: string): String;
Commencer
Résultat: = maîtrise en majuscule (Astring);
fin;
Fonction de classe tString.Indexof (astrring, asubstring: string): entier;
Commencer
Résultat: = pos (asubstring, astrring);
fin;
Fonction de classe tString.zerotoint (astrring: string): entier;
Commencer
Si Trim (astring) = '' alors
Astring: = '0';
Résultat: = strToint (astring);
fin;
Fonction de classe tString.zerotofloat (astrring: string): double;
Commencer
Si Trim (astring) = '' alors
Astring: = '0,0';
Résultat: = strtofloat (astring);
fin;
Fonction de classe TString.SameText (Astring, Astring1: String): Boolean;
Commencer
Résultat: = synutils.sameText (astring, astring1);
fin;
Fonction de classe tString.reverse (astrring: string): String;
Commencer
Résultat: = reversestring (astring);
fin;
Fonction de classe tString.isvalidip (const S: String): booléen;
var
J, i: entier;
LTMP: String;
Commencer
Résultat: = true;
LTMP: = TRIM (S);
pour i: = 1 à 4 commencent
j: = strtOrtDef (fetch (ltmp, '.'), -1);
Résultat: = résultat et (j> -1) et (j <256);
Si ce n'est pas les résultats, commencez
Casser;
fin;
fin;
fin;
Fonction de classe tString.zerotoStr (astrring: string): String;
Commencer
Si Trim (astring) = '' alors
Résultat: = '0'
autre
Résultat: = astring;
fin;
Fonction de classe TString.fillString (ACHAR: char; alngle: entier): String;
var
I: entier;
Commencer
Résultats: = '';
pour i: = 1 à alngot
Commencer
Résultat: = résultat + achar;
fin;
fin;
Fonction de classe TString.StuffString (const Atext: String; Astart,
Alngot: cardinal; const asubtext: string): String;
Commencer
Résultat: = strutils.stuffstring (atext, astart, alngle, asubtext);
fin;
Fonction de classe TString.GetNextString (var SourCestring: String;
Asplitchar: string): String;
var
TMPPOS: entier;
Commencer
TMPPOS: = POS (Asplitchar, Sourcestring);
Si TMPPOS = 0 alors
Commencer
Résultat: = Sourcestring;
Sourcestring: = ''
fin
autre
Commencer
Résultat: = tString.left (Sourcestring, TMPPOS -1);
Supprimer (sourcestring, 1, TMPPOS);
fin;
fin;
{Tinteger}
Fonction de classe Tinteger.intToStr (AInteger: Integer): String;
Commencer
Résultat: = synutils.intToStr (Ainteger);
fin;
Fonction de classe Tinteger.HashCode (AInteger: Integer): Integer;
Commencer
Résultat: = Ainteger;
fin;
Fonction de classe Tinteger.intToStr (Ainteger: int64): String;
Commencer
Résultat: = synutils.intToStr (Ainteger);
fin;
Fonction de classe Tinteger.isvalidInt (astrring: string): booléen;
Commencer
Résultat: = true;
essayer
StrToint (astring);
sauf
Résultat: = false;
fin;
fin;
Fonction de classe tinteger.isvalidInt64 (astrring: string): booléen;
Commencer
Résultat: = true;
essayer
StrToint (astring);
sauf
Résultat: = false;
fin;
fin;
Fonction de classe Tinteger.Maxint: Integer;
Commencer
Résultat: = System.maxint;
fin;
Fonction de classe Tinteger.MaxLongInt: Integer;
Commencer
Résultat: = System.MaxLongInt;
fin;
Fonction de classe Tinteger.intoBin (Ainteger: Cardinal): String;
var
I: entier;
Commencer
SetLength (résultat, 32);
pour i: = 1 à 32
Commencer
if ((Ainteger shl (i-1)) shR 31) = 0 alors
Résultat [i]: = '0'
autre
Résultat [i]: = '1';
fin;
fin;
Fonction de classe Tinteger.intoHex (AInteger: Integer): String;
Commencer
Résultat: = synutils.inttohex (Ainteger, 0);
fin;
Fonction de classe Tinteger.hextRowing (astrring: String): Integer;
Commencer
Si tString.left (astring, 1) = '$' alors
Résultat: = strToint (astrring)
autre
Résultat: = strToint ('$' + astring);
fin;
Fonction de classe Tinteger.MakesSerialno (Ainteger, adigit: Integer): String;
var
tmptr: String;
I: entier;
Commencer
tmptr: = '';
pour i: = 0 à adigit - 1 do // itérer
Commencer
tmptr: = tmptr + '0';
fin;
Résultat: = FormatFloat (TMPSTR, AInteger);
fin;
{Tfloat}
Fonction de classe tfloat.floattomoney (constamment: double; rond: booléen): chaîne;
Commencer
// Le montant est arrondis par défaut
fin;
fonction de classe tfloat.isvalidfloat (astrring: string): booléen;
Commencer
Résultat: = true;
essayer
Strtofloat (astring);
sauf
Résultat: = false;
fin;
fin;
fonction de classe tfloat.maxDouble: double;
Commencer
Résultat: = 1,7e + 308;
fin;
Fonction de classe tfloat.maxExtended: Extended;
Commencer
Résultat: = 1.1e + 4932;
fin;
fonction de classe tfloat.mindouble: double;
Commencer
Résultat: = 5.0E-324;
fin;
Fonction de classe tfloat.Minextend: Extended;
Commencer
Résultats: = 3.4E-4932;
fin;
Fonction de classe tfloat.sameValue (const a, b: single;
Epsilon: Single): Boolean;
Commencer
Résultat: = math.SameValue (A, B, Epsilon);
fin;
Fonction de classe tfloat.sameValue (const a, b: double;
Epsilon: Double): Boolean;
Commencer
Résultat: = math.SameValue (A, B, Epsilon);
fin;
Fonction de classe tfloat.sameValue (const a, b: étendu;
Epsilon: étendu): Boolean;
Commencer
Résultat: = math.SameValue (A, B, Epsilon);
fin;
{Tboolean}
Fonction de classe tboolean.boolToStr (Aboolean: booléen): chaîne;
Commencer
Si aboolan alors
Résultat: = 'true'
autre
Résultat: = 'false';
fin;
Fonction de classe tboolean.strtobool (astrring: string): booléen;
Commencer
Si majuscules (astring) = 'true' alors
Résultat: = vrai
autre
Résultat: = false;
fin;
fin.