Varios tipos de base que escribí para Delphi

Autor：Eve Cole Fecha de actualización：2025-03-13 02:16:01

// Las personas que están acostumbradas a Java o C# pueden estar muy enojadas con Delphi y ni siquiera tienen tipos básicos en mi trabajo diario, a menudo trato de reunir algunas funciones y a menudo hago algunas funciones de mis propios tipos básicos. ellos aquí.

Unidad Baseclass;

interfaz

usos

Sysutils, clases, strutils, idglobal, matemáticas;

tipo

Tcharset = conjunto de char;

varilla

Tnormalcharset: tcharset = [ #13, #10, #32, '.', ',', ';'];

tipo

TString = clase

Privado

Ftext: string;

público

función charat (aposición: entero): char;

// Las letras de la posición especificada

función tolowercase: cadena;

Función de clase TolowerCase (Astring: String): String;

//minúscula

función toUpperCase: String;

Función de clase TOUPPERCASE (Astring: String): String;

//capital

Valor de la función de clase (avalue: cadena): boolean;

Valor de la función de clase (avalue: boolean): string;

Función de clase StringIn (Avalue: String; Avalues: Array of String): Boolean;

Función de clase izquierda (avalue: string; alength: integer): string;

Función de clase Right (Avalue: String; Along: Integer): String;

clase de clase DeletePrefix (Avalue: String; FixedString: tcharset = [#32]): string;

Función de clase DeleteSfix (Avalue: String; FixedString: tcharset = [#32]): String;

comparación de funciones de clase (avalue1: string; avalue2: string): boolean;

función de clase hashcode (avalue: string): integer;

función de clase lastchar (avalue: string): char;

Class Función StringReplace (const S, OldPattern, NewPattern: String;

Banderas: treplaceFlags): cadena;

Función de clase StringOfChar (Ch: Char; Count: Integer): String;

función de clase setString (var s: string; buffer: pchar; len: entero): string;

Función de clase Getpy (Astr: String): String;

// Obtener el pinyin correspondiente.

función de clase isallchinese (astr: string): boolean;

función de clase isallenglish (astr: string): boolean;

Función de clase getFirstWord (Avalue: String; Var Aword: String; AseParator: Tcharset): Integer;

Función de clase getFirstWord (Avalue: String; Var Aword: String; AseParator: String): Integer;

// El valor de retorno es la longitud desde el principio hasta el documento.

Función de clase GetAllword (Avalue: String; AseParator: String): tStringList;

// Devuelve todas las palabras clave. Después de usarlo, libera el conjunto de resultados;

// Nota: No use esta función en el uso futuro. Utilice su versión recargada

// getAllword (avalue: string; aseParator: string; astringList: tStringList);

Procedimiento de clase GetAllword (Avalue: String; AseParator: String; AstringList: Tstrings);

// Cargar todos los conjuntos de resultados en AstringList;

Procedimiento de clase GetAllwordwithall (Avalue: String; AseParator: String; AstringList: tstrings);

Función de clase StringToCharSet (avalue: string): tcharset;

Función de clase CharsetToString (Avalue: tcharset): string;

Función de clase UpdateSentence (aoldString: string; // La cadena que se está operando

Aupdateurce: cadena;

AUPDATESTRING: String; // Documento reemplazado.

AsentenceseParator: String;

AwordSparator: String // Document Separator;

): cadena;

// Por ejemplo, el valor de retorno de 'dBarCode ASC, dname desc', 'dBarcode', '', ',', '' es

// 'dname desc';

Función de clase Deleteepeat (aoldString: string; // para manejar caracteres

Adeletestring: char; /

ArePeat: char): cadena;

función de clase ifthen (aExpression: boolean; atrue: string; afalse: string): string;

// Devuelve la cadena correspondiente de acuerdo con el valor de la expresión.

Función de clase AbsolutTorelate (aabsolute: string; acurrent: string): string;

// Dados dos archivos, convierta la ruta absoluta en la ruta relativa.

Función de clase RelatetoabSolute (arate: string; acurrent: string): string;

Función de clase SimilarPosition (aOne, Atwo: String): Integer;

función de clase getCharnum (astring: string; achar: char): integer;

clase de clase índicef (astring, asubstring: string): integer;

Función de clase ZeroToint (Astring: String): Integer;

Función de clase ZeroToFloat (Astring: String): Double;

Función de clase ZeroToStr (Astring: String): String;

Función de clase Sametext (Astring, Astring1: String): Boolean;

Función de clase inversa (astring: string): string;

función de clase isValidip (const s: string): boolean;

Función de clase FillString (achar: char; Along: Integer): String;

Class Function StuffString (const atext: string; astart, alength: cardinal;

const asubText: string): string;

función de clase getNextString (var SourCeString: String; asplitchar: string): string;

fin;

// Tipo entero.

Tinteger = clase

Función de clase intToStr (ainteger: integer): string;

Función de clase intToStr (ainteger: int64): string;

función de clase isValidint (astring: string): boolean;

función de clase isValidInt64 (astring: string): boolean;

función de clase maxint: integer;

Función de clase MaxLongInt: Integer;

clase de clase hashcode (ainteger: integer): integer;

función de clase inttobin (ainteger: cardinal): string;

función de clase inttoHex (ainteger: integer): string;

Función de clase Hextoint (Astring: String): Integer;

Función de clase Makeerialno (ainteger: integer; adigit: integer): string;

fin;

Tfloat = clase

función de clase isValidfloat (astring: string): boolean;

función de clase maxDouble: double;

CLASE FUNT MindOuble: Double;

función de clase maxExtended: extended;

Función de clase MINEXTEND: Extended;

Función de clase SameValue (const A, B: Single; Epsilon: Single = 0): Boolean;

Función de clase SameValue (const A, B: Double; Epsilon: Double = 0): Boolean;

Función de clase SameValue (const A, B: Extended; Epsilon: Extended = 0): Boolean;

función de clase Floattomoney (const valor: doble; ronda: boolean = true): string;

fin;

Tboolean = clase

función de clase booltostr (aboolean: boolean): string;

Class Function StrToBool (Astring: String): Boolean;

fin;

Implementación

{Tstring}

función getPyIndexchar (achar: string): char;

Comenzar

palabra de caso (achar [1]) shl 8 + palabra (achar [2]) de

$ B0a1 .. $ b0c4: resultado: = 'a';

$ B0C5 .. $ B2C0: resultado: = 'B';

$ B2c1 .. $ b4ed: resultado: = 'c';

$ B4ee .. $ b6e9: resultado: = 'd';

$ B6ea .. $ b7a1: resultado: = 'e';

$ B7a2 .. $ b8c0: resultado: = 'f';

$ B8c1 .. $ b9fd: resultado: = 'g';

$ B9fe .. $ bbf6: resultado: = 'h';

$ Bbf7 .. $ bfa5: resultado: = 'j';

$ Bfa6 .. $ c0ab: resultado: = 'k';

$ C0AC .. $ C2E7: resultado: = 'l';

$ C2e8 .. $ c4c2: resultado: = 'm';

$ C4C3 .. $ C5B5: resultado: = 'n';

$ C5B6 .. $ C5BD: resultado: = 'O';

$ C5be .. $ c6d9: resultado: = 'p';

$ C6DA .. $ C8BA: resultado: = 'Q';

$ C8bb .. $ c8f5: resultado: = 'r';

$ C8f6 .. $ cbf9: resultado: = 's';

$ CBFA .. $ cdd9: resultado: = 't';

$ Cdda .. $ cef3: resultado: = 'w';

$ Cef4 .. $ d188: resultado: = 'x';

$ D1b9 .. $ d4d0: resultado: = 'y';

$ D4d1 .. $ d7f9: resultado: = 'z';

demás

Resultado: = char (0);

fin;

Función de clase tString.getpy (astr: string): string;

varilla

I: entero;

Comenzar

Resultados: = '';

para i: = 1 a longitud (astr) hacer

Comenzar

if bytetype (astr, i) = mbtrailbyte entonces

Resultado: = resultado + getpyindexchar (Astr [i - 1] + astr [i])

demás

if bytetype (astr, i) = mbsingleByte entonces

Resultado: = resultado + Astr [i];

fin;

function tString.charat (Apposition: Integer): char;

Comenzar

Resultado: = ftext [aposición];

fin;

Función de clase TString.CharsetToString (Avalue: tcharset): string;

Comenzar

fin;

Función de clase tString.comparestring (Avalue1, Avalue2: String): boolean;

Comenzar

Resultado: = uppercase (avalue1) = uppercase (avalue2);

fin;

Función de clase tString.DeletEprefix (avalue: string;

Fijotring: tcharset): string;

Comenzar

mientras que System.Length (Avalue)> 0 do

Comenzar

Si Avalue [1] en FixedString entonces

Eliminar (Avalue, 1, 1)

demás

Romper;

fin;

Resultado: = avalue;

fin;

Función de clase tString.getFirstWord (avalue: string; var aword: string; aseParator: tcharset

): Entero;

varilla

TMPSTR: String;

tmpPos: entero;

Comenzar

TMPSTR: = DeleteSuffix (Avalue, AseParator);

TMPSTR: = DeletePrefix (Avalue, AseParator);

Resultado: = longitud (avalue) - longitud (tmpStr);

{if longitud (tmpStr) = 0 luego salir;

if (tmpstr [1] = '' '') y (tmpStr [2] = '' '') entonces

Comenzar

para tmpPos: = 3 a longitud (tmpstr) do

Comenzar

Si tmpStr [tmpPos] en ['' ''] entonces

Romper;

fin;

si tmpPos> 3 entonces tmpPos: = tmpPos + 2;

}

para tmpPos: = 1 a longitud (tmpStr) do

Comenzar

Si TMPSTR [TMPPOS] en AseParator entonces

Romper;

fin;

tmpPos: = tmpPos -1;

// {TODO: -OGHS arregló el último parsante de parámetros incorrectamente}

if (tmppos = 0) y (avalue <> '') entonces

tmpPos: = longitud (avalue);

Aword: = Copy (Avalue, Result + 1, tmpPos);

Resultado: = resultado + tmpPos;

fin;

Función de clase tString.hashCode (Avalue: String): Integer;

varilla

I: entero;

tmpValue: entero;

Comenzar

tmpValue: = 0;

para i: = 1 to system.length (avalue) do

Comenzar

tmpValue: = 3 * tmpValue + ord (avalue [i]);

fin;

Resultado: = tmpValue;

fin;

Función de clase tString.IsAllChinese (AST: String): boolean;

varilla

I: entero;

Comenzar

Resultado: = verdadero;

para i: = 1 a longitud (astr) hacer

Comenzar

if bytetype (astr, i) = mbsingleByte entonces

Comenzar

Resultado: = falso;

Romper;

fin;

Función de clase tString.IsAllEnglish (Astr: String): boolean;

varilla

I: entero;

Comenzar

Resultado: = verdadero;

para i: = 1 a longitud (astr) hacer

Comenzar

if bytetype (astr, i) <> mbsingleByte entonces

Comenzar

Resultado: = falso;

Romper;

fin;

Función de clase tString.lastchar (avalue: string): char;

Comenzar

Resultado: = Avalue [System.Length (Avalue)];

fin;

Función de clase tString.Ltft (Avalue: String; Alength: Integer): String;

Comenzar

Resultado: = copia (Avalue, 1, Along);

fin;

Función de clase tString.right (Avalue: String; Alength: Integer): String;

Comenzar

Resultado: = strutils.rightstr (avalue, longitud);

fin;

Función de clase tString.setString (var s: string; buffer: pchar;

len: entero): cadena;

Comenzar

System.SetString (s, buffer, len);

Resultados: = S;

fin;

Función de clase TString.Stringin (Avalue: String;

Avalues: matriz de cadena): boolean;

varilla

I: entero;

Comenzar

Resultado: = falso;

para i: = bajo (avalues) a alto (avalues) lo hacen

Comenzar

Si uppercase (avalue) = uppercase (avalues [i]) entonces entonces

Comenzar

Resultado: = verdadero;

Romper;

fin;

Función de clase tString.StringOfChar (ch: char; Count: Integer): String;

Comenzar

Resultado: = System.StringOfChar (CH, Count);

fin;

Función de clase TString.StringReplace (const S, Oldpattern,

Newpattern: String;

Comenzar

Resultado: = sysutils.StringReplace (S, OldPattern, NewPattern, Flags);

fin;

Función de clase TString.StringToCharset (Avalue: String): tcharset;

varilla

I: entero;

Comenzar

Resultados: = [];

para i: = 1 a longitud (avalue)

Comenzar

Resultado: = resultado + [avalue [i]];

fin;

función tString.tolowercase: string;

Comenzar

Resultado: = minúscula (ftext);

fin;

función tString.ToUpperCase: String;

Comenzar

Resultado: = uppercase (ftext);

fin;

Función de clase tString.ValueOf (Avalue: Boolean): String;

Comenzar

Si avalue entonces

Resultado: = 'sí'

demás

Resultado: = 'no';

fin;

Función de clase tString.ValueOf (Avalue: String): boolean;

Comenzar

Resultado: = stringIn (avalue, ['sí', 'sí', 'ok']);

fin;

Función de clase tString.getFirstWord (avalue: string; var aword: string;

AseParator: String): Integer;

Comenzar

Resultado: = getFirstWord (avalue, aword, stringToCharset (aseParator));

fin;

Función de clase tString.getallword (Avalue, AseParator: String): tStringList;

varilla

tmplist: tStringList;

tmpword: string;

Comenzar

tmplist: = tStringList.create;

mientras que longitud (avalue)> 0 do

Comenzar

tmpword: = '';

Delete (avalue, 1, getFirstWord (avalue, tmpword, aseparator));

Si tmpword <> '' entonces

tmplist.add (tmpword)

demás

Romper;

fin;

Resultado: = tmplist;

fin;

Función de clase tString.UpdatesEntence (AoldString, AupdateSource,

AUpDateString, AsentenceseParator, AwordSparator: String): String;

varilla

tmpsentence: cadena;

tmpword: string;

tmpword1: string;

I: entero;

tmPresult: string;

Comenzar

// Obtener la primera oración

tmpsentence: = aoldString;

tmPresult: = '';

mientras que la longitud (tmpsentence)> 0 do

Comenzar

i: = getFirstWord (tmpsentence, tmpword, asentenceseParator);

TMPRESULT: = TMPRESULT + IZQUIERD (TMPSENTENCE, I - Longitud (tmpword));

Eliminar (tmpsentence, 1, i);

Si tmpword <> '' entonces

Comenzar

i: = getFirstWord (tmpword, tmpword1, awordseparator);

TMPRESULT: = TMPRESULT + LEZT (TMPWORD, I - Longitud (TMPWord1));

Si comparación (TMPWord1, AupdateSource) entonces

Comenzar

tmPreSult: = tmPresult + aupDateString;

fin

demás

Comenzar

TMPRESULT: = TMPRESULT + TMPWORD;

fin;

tmPresult: = deleteprefix (tmPresult, ['', ',']);

tmPreSult: = DeleteSuffix (tmPreSult, ['', ',']);

tmPreSult: = deletreepeat (tmPresult, ',', '');

tmPreSult: = deletreepeat (tmPresult, '', '');

Resultado: = tmPresult;

fin;

Función de clase tString.deletEpeat (aoldString: String; Adeletestring,

Arpeat: char): string;

varilla

I: entero;

tmpfind1: booleano;

Comenzar

tmpfind1: = false;

para i: = longitud (aoldstring) Down to 1 do

Comenzar

Si tmpfind1 entonces

Comenzar

Si aoldstring [i] = adeletestring entonces

Eliminar (aoldstring, i, 1)

demás

Comenzar

Si aoldstring [i] = arpeat entonces

Continuar;

tmpfind1: = aoldString [i] = adeletestring;

fin;

fin

demás

Comenzar

Si adeletestring <> arpeat entonces

Si aoldstring [i] = arpeat entonces

Continuar;

tmpfind1: = aoldstring [i] = adeletestring

fin;

Resultado: = aoldString;

fin;

Función de clase TString.DeletesUffix (Avalue: String;

Fijotring: tcharset): string;

Comenzar

mientras que System.Length (Avalue)> 0 do

Comenzar

Si Avalue [System.Length (Avalue)] en FixedString, entonces

Eliminar (avalue, system.length (avalue), 1)

demás

Romper;

fin;

Resultado: = avalue;

fin;

Procedimiento de clase tString.getallword (avalue, aseParator: string;

AstringList: tstrings);

varilla

tmpword: string;

Comenzar

Si AstringList = nil entonces

AstringList: = tStringList.create;

mientras que longitud (avalue)> 0 do

Comenzar

tmpword: = '';

Delete (avalue, 1, getFirstWord (avalue, tmpword, aseparator));

Si tmpword <> '' entonces

AstringList.Add (tmpword)

demás

Romper;

fin;

Función de clase tString.ifthen (aExpression: boolean; atrue,

Afalse: String): String;

Comenzar

Si aexpression entonces

Resultado: = Atrue

demás

Resultado: = Afalse;

fin;

Función de clase tString.absolutetorelate (AABSOLUTE,

Acurrent: String): String;

varilla

TMPSIMILARTRING: String;

Aoldfile: cadena;

I: entero;

tmpPos: entero;

Comenzar

// Después de la conversión, se forma .../../a.ini;

// Si no está en la misma unidad, volverá directamente a la ruta absoluta.

Si extractofiledrive (aabsolute) <> extractofiledrive (acurrente) entonces entonces

Resultado: = aabsolute

demás

Comenzar

tmpsimilarString: = '';

Aoldfile: = aabsolute;

Aabsolute: = extractofilepath (aabsolute);

tmpPos: = posición similar (aabsolute, acurrente);

Eliminar (aoldfile, 1, tmpPos - 1);

Eliminar (acurrente, 1, tmppos - 1);

para i: = 0 para getcharnum (acurrent, '/') -1 hacer

Comenzar

tmpsimilarString: = tmpsimilarstring + '../';

fin;

Resultado: = tmpsimilarstring + aoldfile;

fin;

Función de clase tString.relatetoabsolute (arate, acurrent: string): string;

varilla

TMPSIMILARTRING: String;

TMPROOTCOUNT: Integer;

I: entero;

Comenzar

Si longitud (arelate)> 2 entonces

Comenzar

Si arelate [2] = ':' entonces

Comenzar

Resultado: = arelate;

Salida;

fin;

tmpsimilarString: = '';

tmProotCount: = 0;

Mientras que verdadero lo hace

Comenzar

Si le queda a la izquierda (arelate, 3) = '../' entonces

Comenzar

Inc (tmProotCount);

Eliminar (arelate, 1, 3);

fin

demás

romper;

fin;

tmpSimilarString: = reverseString (ExtractFilePath (Acurrent));

para i: = 0 a tmprootcount do

Comenzar

Eliminar (tmpSimilarString, 1, pos ('/', tmpsimilarstring));

fin;

Resultado: = ReverseString (TMPSIMILARTRING) + Arelate;

fin;

Función de clase tString.SimilarPosition (aOne, Atwo: String): Integer;

varilla

I: entero;

Max: entero;

Comenzar

Si longitud (aone) <longitud (ATWO) entonces

Max: = longitud (aone)

demás

Max: = longitud (ATWO);

para i: = 1 a max do

Comenzar

Si aone [i] <> atwo [i] entonces

Romper;

fin;

Resultados: = i;

fin;

Función de clase tString.getCharnum (astring: string; achar: char): integer;

varilla

I: entero;

Comenzar

Resultados: = 0;

para i: = 1 a longitud (astring)

Comenzar

Si astring [i] = achar entonces

Inc (resultado);

fin;

Procedimiento de clase tString.getallwordWithall (avalue, aseParator: string;

AstringList: tstrings);

varilla

tmpi: entero;

tmpPos: entero;

Comenzar

Si AstringList = nil entonces

AstringList: = tStringList.create;

tmpPos: = 0;

mientras que longitud (avalue)> 0 do

Comenzar

para tmpi: = 1 a longitud (avalue) hacer

Comenzar

tmpPos: = pos (avalue [tmpPos], aseparator);

Si tmpPos> 0 entonces

Comenzar

AstringList.Add (copia (Avalue, 1, TMPPOS - 1));

AstringList.Add (copia (Avalue, TMPPOS, 1));

Eliminar (avalue, 1, tmppos);

Romper;

fin

fin;

Función de clase tString.TOLOWERCAT (Astring: String): String;

Comenzar

Resultado: = minúsculas (astring);

fin;

Función de clase tString.ToUpperCase (Astring: String): String;

Comenzar

Resultado: = mayúscula (astring);

fin;

Función de clase tString.Indexof (Astring, Asubstring: String): Integer;

Comenzar

Resultado: = pos (asubstring, astring);

fin;

Función de clase tString.zerotoint (astring: string): integer;

Comenzar

Si TRIM (Astring) = '' entonces

Astring: = '0';

Resultado: = strtoint (astring);

fin;

Función de clase tString.zerotofloat (astring: string): double;

Comenzar

Si TRIM (Astring) = '' entonces

Astring: = '0.0';

Resultado: = strtofloat (astring);

fin;

Función de clase tString.sametext (astring, astring1: string): boolean;

Comenzar

Resultado: = sysutils.sametext (astring, astring1);

fin;

Función de clase TString.Reverse (Astring: String): String;

Comenzar

Resultado: = ReverseString (Astring);

fin;

Función de clase TString.ISValidip (const S: String): boolean;

varilla

J, I: entero;

LTMP: String;

Comenzar

Resultado: = verdadero;

LTMP: = TRIM (S);

para i: = 1 a 4 comience

j: = strTointdef (fetch (ltmp, '.'), -1);

Resultado: = resultado y (j> -1) y (j <256);

Si no es resultados, entonces comience

Romper;

fin;

Función de clase tString.zerotostr (astring: string): string;

Comenzar

Si TRIM (Astring) = '' entonces

Resultado: = '0'

demás

Resultado: = astring;

fin;

Función de clase tString.FillString (achar: char; alength: integer): string;

varilla

I: entero;

Comenzar

Resultados: = '';

para i: = 1 a la longitud do // iterar

Comenzar

Resultado: = resultado + achar;

fin;

Función de clase tString.stuffString (const atext: string; astart,

Alzgo: Cardinal;

Comenzar

Resultado: = strutils.stuffstring (atext, astart, alength, asubText);

fin;

Función de clase tString.getNextString (var SourCeString: String;

Asplitchar: string): string;

varilla

tmpPos: entero;

Comenzar

TMPPOS: = POS (Asplitchar, SourCestring);

Si tmpPos = 0 entonces

Comenzar

Resultado: = SourCestring;

Sourcestring: = ''

fin

demás

Comenzar

Resultado: = tString.Lft (SourCeString, TMPPOS -1);

Eliminar (Sourcestring, 1, TMPPOS);

fin;

{Tinteger}

Función de clase tinteger.inttostr (ainteger: integer): string;

Comenzar

Resultado: = sysutils.inttostr (ainteger);

fin;

Función de clase tinteger.hashcode (ainteger: integer): integer;

Comenzar

Resultado: = ainteger;

fin;

Función de clase tinteger.inttostr (ainteger: int64): string;

Comenzar

Resultado: = sysutils.inttostr (ainteger);

fin;

Función de clase tinteger.isValidInt (astring: string): boolean;

Comenzar

Resultado: = verdadero;

intentar

Strtoint (astring);

excepto

Resultado: = falso;

fin;

Función de clase tinteger.isValidInt64 (astring: string): boolean;

Comenzar

Resultado: = verdadero;

intentar

Strtoint (astring);

excepto

Resultado: = falso;

fin;

Función de clase tinteger.maxint: integer;

Comenzar

Resultado: = System.maxint;

fin;

Función de clase tinteger.maxLongInt: integer;

Comenzar

Resultado: = System.MaxLongInt;

fin;

Función de clase tinteger.inttobin (ainteger: cardinal): string;

varilla

I: entero;

Comenzar

SetLength (resultado, 32);

para i: = 1 a 32 hacer

Comenzar

if ((ainteger shl (i-1)) shr 31) = 0 entonces

Resultado [i]: = '0'

demás

Resultado [i]: = '1';

fin;

Función de clase tinteger.inttoHex (ainteger: integer): string;

Comenzar

Resultado: = sysutils.inttohex (ainteger, 0);

fin;

Función de clase tinteger.HextOnt (astring: string): integer;

Comenzar

if tString.left (astring, 1) = '$' entonces entonces

Resultado: = strtoint (astring)

demás

Resultado: = strToint ('$' + astring);

fin;

Función de clase tinteger.makeserialno (ainteger, adigit: integer): string;

varilla

TMPSTR: String;

I: entero;

Comenzar

tmpStr: = '';

para i: = 0 a adigit - 1 do // iterar

Comenzar

TMPSTR: = TMPSTR + '0';

fin;

Resultado: = formatfloat (tmpstr, ainteger);

fin;

{Tfloat}

función de clase tfloat.floattomoney (constante constante: doble; redondo: boolean): string;

Comenzar

// La cantidad se redondea por defecto

fin;

función de clase tfloat.isValidfloat (astring: string): boolean;

Comenzar

Resultado: = verdadero;

intentar

Strtofloat (astring);

excepto

Resultado: = falso;

fin;

función de clase tfloat.maxDouble: double;

Comenzar

Resultado: = 1.7e+308;

fin;

función de clase tfloat.maxextended: extended;

Comenzar

Resultado: = 1.1e+4932;

fin;

función de clase tfloat.mindubo: double;

Comenzar

Resultado: = 5.0e-324;

fin;

función de clase tfloat.minextended: extended;

Comenzar

Resultados: = 3.4E-4932;

fin;

función de clase tfloat.sameValue (const a, b: simple;

Epsilon: Single): Boolean;

Comenzar

Resultado: = Math.sameValue (A, B, Epsilon);

fin;

función de clase tfloat.sameValue (const a, b: doble;

Epsilon: doble): booleano;

Comenzar

Resultado: = Math.sameValue (A, B, Epsilon);

fin;

función de clase tfloat.sameValue (const a, b: extendido;

Epsilon: extendido): booleano;

Comenzar

Resultado: = Math.sameValue (A, B, Epsilon);

fin;

{Tboolean}

función de clase tboolean.booltostr (Aboolean: boolean): string;

Comenzar

Si aboolean entonces

Resultado: = 'verdadero'

demás

Resultado: = 'falso';

fin;

función de clase tboolean.strtobool (astring: string): boolean;

Comenzar

Si uppercase (astring) = 'verdadero' entonces

Resultado: = verdadero

demás

Resultado: = falso;

fin;

fin.