Variables, Literals, and Types

identifiers identifiers are names of variables, functions, and labels they also apply to brightscript object methods (i e functions) and interfaces (which appear after a " " dot operator) identifiers have the following rules must start with an alphabetic character (a z) may consist of alphabetic characters, numbers, or the underscore symbol (" ") are not case sensitive may be of any length may not be a reserved words docid\ o4a6ewopafyohis1shtfr ( variables only ) may end with an optional type declaration ("$" for a string, "%" for an integer, "!" for a float, "#" for a double) examples a boy5 super man$ 42% types brightscript supports both dynamic typing and declared types this means that every value has a type determined at runtime, but variables can also be instructed to always contain a value of a specified type if a value is assigned to a variable that has a specified type, the type of the value will be converted to the variable type if possible if conversion is impossible, a runtime error will occur a variable that does not end in a type declaration may change its type dynamically for example, the statement a=4 will create an integer, while a following statement specifying that a="hello" will change the type of the variable a to a string brightscript supports the following types boolean true or false integer a 32 bit signed integer number float the smallest floating point number format supported by either the hardware or software double the largest floating point number format supported by either the hardware or software although double is an intrinsically understood type, it is implemented internally with the rointrinsicdouble object string a sequence of ascii (not utf 8) characters brightscript uses two intrinsic string states constant strings a statement such as s="astring" will create an intrinsic constant string rostring instances once a string is used in an expression, it becomes an rostring instance for example, the statement s = s + "bstring" will cause the intrinsic string s to convert to an rostring instance if this is followed by the statement s2 = s , the s2 value will be a reference to s , not a copy of it the behavior of reference counting strings is new to brightscript version 3 0 object a reference to a brightscript object (i e a native component) note that the type() function will not return "object" but the type of object instead (e g rolist , rovideoplayer ) also note that there is no separate type for intrinsic brightscript objects all intrinsic brightscript objects are built on the roassociativearray object type interface an interface in a brightscript object if a " " dot operator is used on an interface type, the member must be static (since there is no object context) invalid a type that can have only one value invalid this type is returned in various instances when no other type is valid (for example, when indexing an array that has never been sent) it can also be assigned to a variable with the statement var = invalid the following are examples of different types the ? statement is a shortcut for print , while the type() function returns a string that identifies the type of the passed expression brightscript> ?type(1) integer brightscript> ?type(1 0) float brightscript> ?type("hello") string brightscript> ?type(createobject("rolist")) rolist brightscript> ?type(1%) integer brightscript> b!=1 brightscript> ?type(b!) float brightscript> c$="hello" brightscript> ?type(c$) string brightscript> d="hello again" brightscript> ?type(d) string brightscript> d=1 brightscript> ?type(d) integer brightscript> d=1 0 brightscript> ?type(d) float brightscript>e=invalid brightscript>?type(e) invalid type declaration characters a type declaration may be used at the end of a variable or literal to fix its type variables with the same identifier but separate types are separate variables for example, defining a$ and a% would create two independent variables character type examples $ string a$, zz$ % integer a1%, sum% ! single precision (float) b!, n1! # double precision (double) a#, 1/3#, 2# literals (constants) the following are valid literal types type boolean either true or false type invalid invalid only type string a string in quotes (e g "this is a string" ) type integer an integer in hex (e g hff ) or decimal (e g 255 ) format type float a number with a decimal (e g 2 01 ), in scientific notation (e g 1 23456e+30 ), or with a float type designator (e g 2! ) type double a number in scientific notation containing a double precision exponent symbol (e g 1 23456789d 12 ) or with a double type declaration (e g 2 3# ) type function similar to variable formatting (e g myfunction ) type integer line num – the current source line number array literals the \[] array operator can be used to declare an array it can contain literals (constants) or expressions x = 5 myarray = \[] myarray = \[ 1, 2, 3] myarray = \[ x+5, true, 1<>2, \["a","b"]] associative array literals the { } associative array operator can be used to define an associative array it can contain literals (constants) or expressions aa = { } aa = {key1 "value", key2 55, key3 5+3 } arrays and associative arrays can also be defined with the following format aa = { myfunc1 afunction myval1 "the value" } invalid object return many methods (i e functions) that return objects can also return invalid (for example, in cases where there is no object to return) in these cases, the variable accepting the result must be dynamically typed since it may be assigned either type the following code will return a type mismatch a$ is a string that has a string type declaration, and thus it cannot contain invalid l = \[] a$ = l pop() numbers dynamic typing the following rules determine how integers, doubles, and floats are dynamically typed if a constant contains 10 or more digits, or if d is used in the exponent, the number is double adding a # type declaration also forces a constant to be a double if the number is not double precision and it contains a decimal point, the number is a float expressing a number in scientific notation using the e exponent also forces a constant to be a float if neither of the above conditions is true for a constant, the number is an integer type conversion when operations are performed on one or two numbers, the result must be typed as an integer, float, or double when an addition (+), subtraction ( ), or multiplication ( ) operation is performed, the result will have the same degree of precision as the most precise operand for example, multiplying an integer by a double will return a number that is a double only when both operands are integers will the result be an integer number if the result of two integer operands is outside the 32 bit range, the operation and return will be carried out with doubles division (/) operates using the same rules as above, except that it can never be carried out at the integer level when both operators are integers, the operation and return will be carried out with floats comparison operations (e g <, >, =) will convert the numbers to the same type before they are compared the less precise type will always be converted to the more precise type type conversion and accuracy when a float or double number is converted to the integer type, it is rounded down the largest integer that is not greater than the number is used this also happens when the int function is called on a number when a double number is converted to the float type, it is 4/5 rounded the least significant digit is rounded up if the fractional part is >=5 (otherwise, it is left unchanged) when a float number is converted to the double type, only the seven most significant digits will be accurate