---
title: Declaraciones del programa
slug: develop/es/declaraciones-del-programa
docTags: 
createdAt: 2025-03-11T07:07:17.199Z
---

BrightScript admite los siguientes tipos de instrucciones (tenga en cuenta que BrightScript no distingue entre mayúsculas y minúsculas). La sintaxis de cada instrucción se documenta con más detalle más adelante en este capítulo.

- `Biblioteca`
- `Atenuar`
- `=` (asignación)
- `Fin`
- `Detener`
- `Ir a`
- `Rem <or> '"`
- `imprimir`
- `Para / A / Fin Para / Paso / Salir Para <o> Siguiente`
- `For Each / In / End For / Exit For <o> Next`
- `Mientras / Fin Mientras / Salir de Mientras`
- `Función / End Function / As / Return`

**Ejemplo**

```text
Function Main() As Void
 
       dim cavemen[10]
 
       cavemen.push("fred")
       cavemen.push("barney")
       cavemen.push("wilma")
       cavemen.push("betty")
 
       for each caveman in cavemen
             print caveman
       end for
 
End Function
```

## Sintaxis de instrucciones

Cada línea puede contener una sola instrucción. Sin embargo, se puede utilizar dos puntos (:) para separar múltiples instrucciones en una sola línea.

**Ejemplo**

```text
myname = "fred"
if myname="fred" then yourname = "barney":print yourname
```

## LIBRARY 

`NombreDeArchivo LIBRARY.brs`

La instrucción LIBRARY le permite incluir sus propias bibliotecas BrightScript (archivos *.brs*), que luego pueden ser utilizadas por su script. Las instrucciones LIBRARY deben aparecer al principio de un script, antes de cualquier otra instrucción, función, operador, etc.

El sistema localiza una biblioteca buscando en el directorio que contiene el script actual, así como en el directorio `SYS:/script-lib/` . Tenga en cuenta que la función `Run()` actualmente no cambia la ruta de una instrucción LIBRARY a la del script llamado (es decir, el sistema continuará buscando en el directorio del script que llama). Por otro lado, ejecutar un script directamente desde el shell de BrightSign sí modifica la ruta de búsqueda de bibliotecas a la del script llamado.

La primera instrucción incluirá una biblioteca en la misma carpeta que el script, mientras que la segunda incluirá una biblioteca en una subcarpeta.

```text
LIBRARY "myBSL1.brs"
LIBRARY "new_lib/myBSL2.brs"
```

La siguiente instrucción incluirá la biblioteca [bslCore.brs](docId\:A2aQ-FRNAG8hDSsDqnY8k) , que tiene algunas funciones útiles de BrightScript, desde el directorio `SYS:/script-lib/` .

```text
LIBRARY "v30/bslCore.brs"
```

## DIM 

`Nombre de DIM (dim1, dim2, …, dimK)`

La instrucción `DIM` ("dimension") proporciona un atajo para crear objetos *roArray* . Establece la variable Name con el tipo “roArray”. Puede crear matrices de matrices según sea necesario para la multidimensionalidad. La dimensión pasada a `DIM` es el índice de la entrada máxima que se asignará (es decir, el tamaño inicial de la matriz = dimensión+1), aunque la matriz cambiará automáticamente a un tamaño mayor si es necesario.

Las siguientes dos líneas crean matrices idénticas.

```text
Dim array[5]
array = CreateObject("roArray", 6, true)
```

:::hint{type="info"}
La expresión x\[a,b] es equivalente a x\[a]\[b].
:::

El siguiente script demuestra operaciones útiles en una matriz DIM.

```text
Dim c[5, 4, 6]


For x = 1 To 5
   For y = 1 To 4
        For z = 1 To 6
           c[x, y, z] = k
           k = k + 1
       End for
   End for
End for


k=0
For x = 1 To 5
    For y = 1 To 4
       For z = 1 To 6
          If c[x, y, z] <> k Then print"error" : Stop
          k = k + 1
          End for
   End for
End for
```

## Asignación ("=")

`variable = expresión`

La instrucción de asignación (“=”) asigna una variable a un nuevo valor.

En cada una de las siguientes líneas, a la variable del lado izquierdo del operador igual se le asigna el valor de la constante o expresión del lado derecho del operador igual.

```text
a$="a rose is a rose"
b1=1.23
x=2.23
x=x-b1
```

## END

La instrucción `FIN` finaliza la ejecución del script normalmente.

## STOP

La instrucción `DETENER` interrumpe la ejecución del script, devuelve un error “STOP” e invoca el depurador. Use el comando `cont` en el indicador del depurador para continuar la ejecución del script o el comando `paso` para ejecutar un solo paso en el script.

## GOTO

`Etiqueta GOTO`

La instrucción `GOTO` transfiere el control del programa al número de línea especificado por `etiqueta`. La instrucción `Etiqueta GOTO` produce una operación de bifurcación. Un `etiqueta` es un identificador terminado con dos puntos en una línea que no contiene otras instrucciones ni expresiones.&#x20;

**Ejemplo**

```text
mylabel:
print "Hello World"
goto mylabel
```

## RETURN

`expresión RETURN`

La instrucción `DEVOLUCIÓN` regresa desde una función a quien la llamó. Si la función no es de tipo Void, `DEVOLUCIÓN` también puede devolver un valor a quien la llamó.

## PRINT

`IMPRIMIR [#output_object], [@location], lista de artículos`

La instrucción PRINT imprime un elemento o una lista de elementos en la consola. Los elementos pueden ser cadenas, enteros, números de punto flotante, variables o expresiones. Un objeto con una interfaz *ifInt*, *ifFloat*, o *ifString* también puede imprimirse. Si se especifica `objeto_de_salida` , esta instrucción imprimirá en un objeto con una interfaz *ifStreamSend* .

Si la instrucción imprime una lista de elementos, los elementos deben separarse con punto y coma o comas. Si se usan puntos y coma, no se insertan espacios entre los elementos impresos; si se usan comas, el cursor avanzará automáticamente a la siguiente zona de impresión antes de imprimir el siguiente elemento.

Los números positivos y el cero se imprimen con un espacio inicial (sin signo más). No se insertan espacios antes ni después de las cadenas.

**Ejemplo**

```text
x = 5 : print 25; " is equal to"; x ^2  
' prints "25 is equal to 25"
```

**Ejemplo**

```text
a$ = "string"
print a$;a$,a$;" ";a$
'prints "stringstring	string string"
```

Cada zona de impresión en el siguiente ejemplo tiene 16 caracteres de ancho. El cursor se mueve a la siguiente zona de impresión cada vez que encuentra una coma.

```text
> print "zone 1","zone 2","zone 3","zone 4"
'prints "zone 1          zone 2           zone 3           zone 4"
```

**Ejemplo**

```text
print "print statement #1 ";
print "print statement #2"
'prints "print statement #1 print statement #2"
```

En algunos casos, pueden omitirse los puntos y coma. Por ejemplo, la siguiente instrucción es válida:

```text
Print "this is a five "5"!!"
```

Un punto y coma final anula el retorno del cursor para que la siguiente instrucción `IMPRIMIR` comience donde terminó la anterior. Si no se usa puntuación final con una instrucción `IMPRIMIR` , el cursor baja al comienzo de la siguiente línea.

**\[@location]**

Si la consola en la que está imprimiendo tiene la interfaz *ifTextField* , puede usar el carácter `@` para especificar dónde comenzará la impresión.

**Ejemplo**

```text
print #m.text_field,@width*(height/2-1)+(width-len(msg$))/2,msg$;
```

Siempre que use `IMPRIMIR @` en la línea inferior de la pantalla, un salto de línea automático hace que todas las líneas mostradas suban una línea. Para evitar que esto suceda, use un punto y coma al final de la instrucción.

**TAB (expresión)**

Esta instrucción mueve el cursor a la posición especificada en la línea actual (módulo del ancho de la consola si la posición TAB es mayor que el ancho de la consola).

**Ejemplo**

```text
print tab(5)"tabbed 5";tab(25)"tabbed 25"
```

Tenga en cuenta lo siguiente sobre la instrucción `TAB` :

- La instrucción `TAB` puede utilizarse varias veces en una lista `IMPRIMIR` .
- No se requiere puntuación después de una instrucción `TAB` .
- Pueden usarse expresiones numéricas para especificar una posición `TAB` .
- La instrucción `TAB` no puede utilizarse para mover el cursor hacia la izquierda.
- Si el cursor está más allá de la posición especificada, la instrucción `TAB` se ignora.

**POS(x)**

Esta instrucción devuelve un entero que indica la posición actual del cursor desde 0 hasta el ancho máximo de la ventana. Esta instrucción requiere un argumento ficticio en forma de cualquier expresión numérica.

```text
print tab(40) pos(0)   'prints 40 at position 40

print "these" tab(pos(0)+5)"words" tab(pos(0)+5)"are";
print tab(pos(0)+5)"evenly" tab(pos(0)+5)"spaced"
```

## FOR / END FOR

`PARA variable_contador = valor_inicial HASTA valor_final PASO incremento / FIN PARA <o> SIGUIENTE`

La instrucción `PARA` crea un bucle iterativo que permite ejecutar una secuencia de instrucciones del programa un número especificado de veces.

Los valores `valor_inicial`, `valor_final` y `incremento` pueden ser cualquier expresión. La primera vez que se ejecuta la instrucción `PARA` , estas tres variables se evalúan y sus valores se guardan; cambiar las variables durante el bucle no tendrá efecto sobre el funcionamiento del bucle. Sin embargo, la `counter_variable` no debe cambiarse, o el bucle no funcionará normalmente. La primera vez que se ejecuta la instrucción `PARA` , el contador se establece tanto en el valor como en el tipo de `valor_inicial` .

Al comienzo de cada bucle, el valor de `counter_variable` se compara con `valor_final` . Si el valor de `counter_variable` es mayor que `valor_final` , el bucle finalizará y la ejecución continuará con la instrucción siguiente a la instrucción `FIN PARA` (o `SIGUIENTE`). Si, por otro lado, el contador aún no ha superado `valor_final` , el control pasa a la primera instrucción después de la instrucción `PARA` . Si increment es un número negativo, el bucle finalizará cuando el valor de `counter_variable` sea menor que `valor_final` .

Cuando el flujo del programa alcanza la instrucción `FIN PARA` (o `SIGUIENTE`) , el contador se incrementa por la cantidad de incremento especificada (o se decrementa si increment es un valor negativo). Si el lenguaje `PASO [incremento]` no se incluye en la instrucción `PARA` , el incremento toma el valor predeterminado de 1.

Use `SALIDA PARA` para salir prematuramente de un bloque `PARA` .

El siguiente script decrementa `i` al comienzo de cada bucle hasta que es menor que 1.

```text
for i=10 to 1 step -1
       print i
end for
```

## FOR EACH IN / END FOR

`PARA CADA elemento EN objeto / FIN PARA <o> SIGUIENTE` 

La instrucción `PARA CADA` puede iterar a través de un conjunto de elementos en cualquier objeto que tenga una interfaz *ifEnum* (es decir, un enumerador). El bloque `PARA` finaliza con la instrucción `FIN PARA` (o `SIGUIENTE`). Los objetos que están ordenados intrínsecamente (como *roList*) se enumeran en orden, mientras que los objetos que no tienen un orden intrínseco (como *roAssociativeArray*) se enumeran en un orden aparentemente aleatorio. Es posible eliminar entradas a medida que se enumeran.

Use `SALIDA PARA` para salir prematuramente de un bloque `PARA`.

Se pueden enumerar los siguientes objetos: *roList*, *roArray*, *roAssociativeArray*, *roMessagePort*.

El siguiente script itera sobre un arreglo asociativo en orden aleatorio, imprime cada par clave/valor y luego lo elimina.

```text
aa={joe: 10, fred: 11, sue:9}
For each n in aa
   Print n;aa[n]
   aa.delete[n]
end for
```

### Anidamiento de instrucciones FOR EACH

La instrucción `PARA CADA` solo puede rastrear un puntero por instancia de objeto, por lo que anidar bucles `PARA CADA` que iteran sobre el mismo objeto puede provocar que la serie finalice prematuramente:

```text
values = {a: 1, b: 2, c: 3, d: 4, e: 5, f: 6}

for each key_outer in values
	print "outer: ";key_outer;" : ";values[key_outer]
	for each key_inner in values 'THIS WILL CAUSE PROBLEMATIC BEHAVIOR
		print "inner: ";key_inner;" : ";values[key_inner]
	end for
end for
```

Para solucionar esta limitación con arreglos asociativos, copie las claves en un arreglo e itere sobre el arreglo en el bucle anidado `PARA CADA`:

```text
values = {a: 1, b: 2, c: 3, d: 4, e: 5, f: 6}
valuesArray = []

for each key in values 'Copy the keys to an array
	valuesArray.push(key)
end for

for each key_outer in values
	print "outer: ";key_outer;" : ";values[key_outer]
	for each key_inner in valuesArray 'Iterate over the array of keys
		print "inner: ";key_inner;" : ";values[key_inner]
	end for
end for
```

## WHILE / EXIT WHILE

`expresión WHILE / EXIT WHILE`

Un bucle `MIENTRAS` se ejecuta hasta que la expresión especificada sea falsa. Use la instrucción `SALIR MIENTRAS` para salir prematuramente de un bloque `MIENTRAS`.

```text
k=0
while k<>0
   k=1
   Print "loop once"
end while
 
while true
   Print "loop once"
   Exit while
End while
```

## IF / THEN / ELSE

`Expresión IF THEN sentencias [ELSE sentencias]`

:::hint{type="info"}
Esta es la forma de una sola línea de la instrucción IF THEN ELSE; consulte la siguiente sección para obtener más detalles sobre la forma de bloque de la instrucción IF THEN ELSE.
:::

La instrucción `IF` indica al intérprete que pruebe la siguiente expresión. Si la expresión es True, el control procederá a las instrucciones que siguen inmediatamente a la expresión. Si la expresión es False, el control saltará ya sea a la instrucción `SI NO` correspondiente (si existe) o a la siguiente línea del programa después del bloque.

**Ejemplo**

```text
if x>127 then print "out of range" : end
```

`ENTONCES` es opcional en las instrucciones anteriores y similares. Sin embargo, `ENTONCES` a veces es necesario para eliminar la ambigüedad, como en el siguiente ejemplo:

```text
if y=m then m=o 'won't work without THEN
```

## Bloque IF / ELSEIF / THEN / ENDIF

La forma de bloque (es decir, de varias líneas) de IF / THEN / ELSE tiene la siguiente sintaxis:

```text
If BooleanExpression [ Then ]
   [ Block ]
   [ ElseIfStatement+ ]
   [ ElseStatement ]
End If
 
ElseIfStatement ::=
   ElseIf BooleanExpression [ Then ]
   [ Block ]
 
ElseStatement ::=
   Else
   [ Block ]
```

**Ejemplo**

```text
vp_msg_loop:
        msg=wait(tiut, p)
        if type(msg)="rovideoevent" then                                            
            if debug then print "video event";msg.getint()
            if lm=0 and msg.getint() = meden then
                if debug then print "videofinished"
                retcode=5
                return
            endif
        else if type(msg)="rogpiobutton" then
            if debug then print "button press";msg
            if esc0 and msg=b0 then retcode=1:return
            if esc1 and msg=b1 then retcode=2:return
            if esc2 and msg=b2 then retcode=3:return
            if esc3 and msg=b3 then retcode=4:return
        else if type(msg)=" Invalid" then
            if debug then print "timeout"
            retcode=6
            return
        endif
 
        goto vp_msg_loop
```

## Function() As Type / End Function

`NombreDeFunción(parámetro As Type, …) As Type`

:::hint{type="info"}
Cada función tiene su propio ámbito.
:::

Una función se declara utilizando la instrucción `Function()` . Los paréntesis pueden contener uno o más parámetros opcionales; los parámetros también pueden tener valores y expresiones predeterminados.

Se puede declarar el tipo de cada parámetro. El tipo de retorno de la función también puede declararse. Si no se declara un tipo de parámetro o tipo de retorno, de manera predeterminada es Dynamic. Los tipos intrínsecos se pasan por valor (y se crea una copia), mientras que los objetos se pasan por referencia. La instrucción `Sub` puede utilizarse en lugar de `Función` como un atajo para crear una función con tipo de retorno Void.

Un parámetro puede ser uno de los siguientes tipos:

- Integer
- Float
- Double
- String
- Object
- Dynamic

El retorno de la función puede ser uno de los siguientes tipos:

- Void
- Integer
- Float
- Double
- String
- Object
- Dynamic

**Identificador "M"** 

Si se llama a una función desde un arreglo asociativo, entonces la variable local `m` se establece en el arreglo asociativo en el que se almacena la función. Si no se llama a la función desde un arreglo asociativo, entonces su variable `m` se establece en un arreglo asociativo que es global para el módulo y persiste entre llamadas.

El identificador `m` solo debe utilizarse para el propósito indicado anteriormente: No recomendamos usar `m` como identificador de propósito general.

**Ejemplo**

```text
sub main()
   obj={
       add: add
       a: 5
       b: 10
       }
 
   obj.add()
   print obj.result
end sub
 
function add() As void
    m.result=m.a+m.b
end function
```

**Funciones anónimas**

Una función sin una declaración de nombre se considera anónima.

La siguiente es una declaración simple de función anónima:

```text
myfunc=function (a, b)
       Return a+b
end function
 
print myfunc(1,2)
```

Las funciones anónimas también pueden utilizarse con literales de arreglos asociativos:

```text
q = {
 
starring : function(o, e)
str = e.GetBody()
print "Starring: " + str 
toks = box(str).tokenize(",")
for each act in toks
actx = box(act).trim()
if actx <> "" then
print "Actor: [" + actx + "]"
                o.Actors.Push(actx)
endif
end for
return 0
end function
}
 
q.starring(myobj, myxml)
```