Variables, literales y tipos
Identificadores
Los identificadores son nombres de variables, funciones y etiquetas. También se aplican a los métodos de objetos de BrightScript (es decir, funciones) y a las interfaces (que aparecen después de un operador de punto "."). Los identificadores tienen las siguientes reglas:
- Deben comenzar con un carácter alfabético (a-z).
- Pueden consistir en caracteres alfabéticos, números o el símbolo de guion bajo ("_").
- No distinguen entre mayúsculas y minúsculas.
- Pueden tener cualquier longitud.
- (solo variables) Pueden terminar con una declaración de tipo opcional ("$" para una cadena, "%" para un entero, "!" para un float, "#" para un double).
Ejemplos
a
boy5
super_man$
42%Tipos
BrightScript admite tanto tipado dinámico como tipos declarados. Esto significa que cada valor tiene un tipo determinado en tiempo de ejecución, pero también se puede indicar que las variables siempre contengan un valor de un tipo especificado. Si se asigna un valor a una variable que tiene un tipo especificado, el tipo del valor se convertirá al tipo de la variable si es posible. Si la conversión es imposible, se producirá un error en tiempo de ejecución.
Una variable que no termina con una declaración de tipo puede cambiar su tipo dinámicamente. Por ejemplo, la instrucción a=4 creará un entero, mientras que una instrucción posterior que especifique que a="hola" cambiará el tipo de la variable a a una cadena.
BrightScript admite los siguientes tipos:
- Booleano: True o False
- Entero: Un número entero con signo de 32 bits
- Flotar: El formato de número de punto flotante más pequeño compatible con el hardware o el software
- Doble: El formato de número de punto flotante más grande compatible con el hardware o el software. Aunque Double es un tipo comprendido intrínsecamente, se implementa internamente con el objeto roIntrinsicDouble.
- Cadena: Una secuencia de caracteres ASCII (no UTF-8). BrightScript utiliza dos estados de cadena intrínsecos:
- Cadenas constantes: Una instrucción como s="astring" creará una cadena constante intrínseca.
- Instancias de roString: Una vez que una cadena se utiliza en una expresión, se convierte en una instancia de roString. Por ejemplo, la instrucción s = s + "bstring" hará que la cadena intrínseca s se convierta en una instancia de roString. Si esto va seguido de la instrucción s2 = s, el valor de s2 será una referencia a s, no una copia de esta. El comportamiento de las cadenas con recuento de referencias es nuevo en la versión 3.0 de BrightScript.
- Objeto: Una referencia a un objeto BrightScript (es decir, un componente nativo). Tenga en cuenta que la función type() no devolverá "Object", sino el tipo de objeto en su lugar (por ejemplo, roList, roVideoPlayer). Tenga en cuenta también que no existe un tipo separado para los objetos intrínsecos de BrightScript. Todos los objetos intrínsecos de BrightScript se basan en el tipo de objeto roAssociativeArray.
- Interfaz: Una interfaz en un objeto BrightScript. Si se utiliza un operador de punto "." en un tipo de interfaz, el miembro debe ser estático (ya que no hay contexto de objeto).
- No válido: Un tipo que solo puede tener un valor: No válido. Este tipo se devuelve en varias instancias cuando ningún otro tipo es válido (por ejemplo, al indexar un arreglo que nunca se ha enviado). También se puede asignar a una variable con la instrucción var = invalid.
Los siguientes son ejemplos de diferentes tipos. La instrucción ? es un atajo para imprimir, mientras que la función type() devuelve una cadena que identifica el tipo de la expresión pasada.
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)
InvalidCaracteres de declaración de tipo
Se puede usar una declaración de tipo al final de una variable o literal para fijar su tipo. Las variables con el mismo identificador pero tipos separados son variables distintas: por ejemplo, definir a$ y a% crearía dos variables independientes.
Carácter | Tipo | Ejemplos |
|---|---|---|
$ | String | A$, ZZ$ |
% | Integer | A1%, SUM% |
! | Precisión simple (Float) | B!, N1! |
# | Precisión doble (Double) | A#, 1/3#, 2# |
Literales (Constantes)
Los siguientes son tipos literales válidos:
- Tipo Boolean: Verdadero o Falso
- Tipo Invalid: No válido solamente
- Tipo String: Una cadena entre comillas (p. ej., "Esto es una cadena")
- Tipo Integer: Un entero en formato hexadecimal (p. ej., HFF) o decimal (p. ej., 255)
- Tipo Float: Un número con un decimal (p. ej., 2.01), en notación científica (p. ej., 1.23456E+30), o con un designador de tipo Float (p. ej., 2!)
- Tipo Double: Un número en notación científica que contiene un símbolo de exponente de precisión doble (p. ej., 1.23456789D-12) o con una declaración de tipo Double (p. ej., 2.3#)
- Tipo Function: Similar al formato de variable (p. ej., MyFunction)
- Tipo Integer: LINE_NUM – El número de línea fuente actual
Literales de matriz
El [] operador de matriz se puede usar para declarar una matriz. Puede contener literales (constantes) o expresiones.
x = 5
Myarray = []
Myarray = [ 1, 2, 3]
Myarray = [ x+5, true, 1<>2, ["a","b"]]Literales de arreglos asociativos
El operador de arreglo asociativo { } puede utilizarse para definir un arreglo asociativo. Puede contener literales (constantes) o expresiones.
aa = { }
aa = {key1:"value", key2: 55, key3: 5+3 }Los arreglos y arreglos asociativos también pueden definirse con el siguiente formato:
aa = {
Myfunc1: aFunction
Myval1 : "the value"
}Retorno de objeto no válido
Muchos métodos (es decir, funciones) que devuelven objetos también pueden devolver Invalid (por ejemplo, en los casos en los que no hay ningún objeto para devolver). En estos casos, la variable que acepta el resultado debe tiparse dinámicamente, ya que puede asignársele cualquiera de los dos tipos.
El siguiente código devolverá una incompatibilidad de tipos: a$ es una cadena que tiene una declaración de tipo string y, por lo tanto, no puede contener Invalid.
l = []
a$ = l.pop()Números
Tipado dinámico
Las siguientes reglas determinan cómo se tipan dinámicamente los enteros, doubles y floats:
- Si una constante contiene 10 o más dígitos, o si D se utiliza en el exponente, el número es Double. Agregar una declaración de tipo # también fuerza a que una constante sea Double.
- Si el número no es de doble precisión y contiene un punto decimal, el número es Float. Expresar un número en notación científica usando el exponente E también fuerza a que una constante sea Float.
- Si ninguna de las condiciones anteriores es verdadera para una constante, el número es Integer.
Conversión de tipos
Cuando se realizan operaciones con uno o dos números, el resultado debe tiparse como Integer, Float o Double. Cuando se realiza una operación de suma (+), resta (-) o multiplicación (*), el resultado tendrá el mismo grado de precisión que el operando más preciso: Por ejemplo, multiplicar un Integer por un Double devolverá un número que es Double.
Solo cuando ambos operandos sean Integer el resultado será un número Integer. Si el resultado de dos operandos Integer está fuera del rango de 32 bits, la operación y el retorno se llevarán a cabo con Doubles.
La división (/) opera usando las mismas reglas anteriores, excepto que nunca puede realizarse a nivel Integer: Cuando ambos operadores son Integer, la operación y el retorno se llevarán a cabo con Floats.
Las operaciones de comparación (p. ej., <, >, =) convertirán los números al mismo tipo antes de compararlos. El tipo menos preciso siempre se convertirá al tipo más preciso.
Conversión de tipos y precisión
Cuando un número Float o Double se convierte al tipo Integer, se redondea hacia abajo: Se utiliza el entero más grande que no sea mayor que el número. Esto también sucede cuando se llama a la función INT sobre un número.
Cuando un número Double se convierte al tipo Float, se redondea 4/5: El dígito menos significativo se redondea hacia arriba si la parte fraccionaria es >=5 (de lo contrario, se deja sin cambios).
Cuando un número Float se convierte al tipo Double, solo los siete dígitos más significativos serán precisos.