--- title: Variables, literales y tipos slug: develop/es/variables-literales-y-tipos docTags: createdAt: 2025-03-11T07:07:17.199Z --- ## 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. - No pueden ser una [palabra reservada](docId\:eAdlLLuwB1VxX_NrObBCh). - (**solo variables**) Pueden terminar con una declaración de tipo opcional ("$" para una cadena, "%" para un entero, "!" para un float, "#" para un double). **Ejemplos** ```text 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. ```text 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 ``` ## Caracteres 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. ```text 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. ```text aa = { } aa = {key1:"value", key2: 55, key3: 5+3 } ``` Los arreglos y arreglos asociativos también pueden definirse con el siguiente formato: ```text 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. ```text l = [] a$ = l.pop() ``` ## Números ### Tipado dinámico Las siguientes reglas determinan cómo se tipan dinámicamente los enteros, doubles y floats: 1. 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. 2. 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. 3. 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.