Plusieurs types de base que j'ai écrits pour Delphi

// 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.