Icon Types

Elevate Web Builder supports most basic Object Pascal types, and these types are detailed below.

Exact Numeric Types
Exact numeric types are used when you wish to store a numeric value in its exact representation without accumulating rounding errors.

IntegerA 52-bit, signed integer value in client applications (JavaScript), and a 64-bit signed integer value in server applications

Exact numeric literals use the minus (-) as the negative sign character, the plus (+) as the positive sign character, and scientific notation is not supported. In addition, hexadecimal literals can be specified by prefacing the hexadecimal value with the dollar sign ($).

The following are examples of exact numeric literals:

   MyInteger: Integer;
   MyInteger := 100; // Assign 100 to the Integer variable
   MyInteger := $64; // Assign 100 as hexadecimal to the Integer variable

Approximate Numeric Types
Approximate numeric types are used when you wish to store a numeric value in an approximate representation with a floating decimal point. Using approximate numeric types can cause rounding errors due to the fact that certain numbers such as 0.33 cannot be accurately represented using floating-point precision.

DoubleA 64-bit, floating-point numeric value with a maximum precision of 16 digits.

Approximate numeric literals use the period (.) as the decimal point character, the minus (-) as the negative sign character, the plus (+) as the positive sign character, and scientific notation is supported via E (e or E) as the exponent character followed by a plus (+) or minus (-) character and the actual exponent value.

The following are examples of approximate numeric literals:

   MyDouble: Double;
   MyDouble := -100.25; // Assign -100.25 to the Double variable

String/Character Types
String types are used when you wish to store a character string of any length up to 2GB. String types always use the Unicode character set for the characters that comprise the string. Character types store a single character, and also use the Unicode character set.

StringA string value with a variable number of characters.
CharA single character.

String literals use the single quote (') character to identify themselves as such. Any single quotes enclosed inside of the literal must be escaped by prefacing them with another single quote. In addition, single character constants may be specified using their literal value or by prefacing their ordinal character set position with the pound sign (#) character. To reference a specific character in a string, use the left and right brackets ([]) with the 1-based integer position of the character being referenced.

Information Strings are immutable, meaning that they cannot be modified in-place by assigning new character values at specific positions in the string. They must always be copied and then assigned to a new string in order to be modified.

The following are examples of string/character literals:

   MyString: String;
   MyCharacter: Char;
   MyString := 'This is a test'; // Assign "This is a test"
                                 // to the String variable
   MyString := #13+#10; // Assign a carriage return and
                        // linefeed to the String variable
   MyCharacter := MyString[2]; // Assign the second character
                               // from the String variable to
                               // the Char variable

Date/Time Types
Date/time types are used when you wish to store a date, time, or date/time value. Date/time types are actually just integers, so they can be manipulated just like the Integer type. However, you will need to cast the date/time value as an integer in order to use it like an integer.

DateTimeA date/time value containing the number of milliseconds since midnight on January 1, 1970.

Since date/time types are just integers, there isn't any literal representation of a date/time type.

Boolean Types
Boolean types are used to represent the values of True or False.

BooleanA logical true/false value.

Boolean literals are expressed as the literals True and False (case-insensitive) or 1 and 0 for True and False, respectively.

The following are examples of boolean literals:

   MyBoolean: Boolean;
   MyBoolean := False; // Assign False to the Boolean variable