---
title: Operadores
slug: develop/es/operadores
docTags: 
createdAt: 2025-03-11T07:07:17.199Z
---

Las operaciones en el nivel más interno de los paréntesis se realizan primero. La evaluación luego continúa según la precedencia de la siguiente tabla. Las operaciones con la misma precedencia son asociativas por la izquierda, excepto la exponenciación, que es asociativa por la derecha.

| **Descripción**                   | **Símbolo(s)**          |
| --------------------------------- | ----------------------- |
| Llamadas a funciones o paréntesis | ()                      |
| Operadores de arreglos            | . , \[]                 |
| Exponenciación                    | ^                       |
| Negación                          | –, +                    |
| Multiplicación, división, módulo  | \*, /, MOD              |
| Suma, resta                       | +, -                    |
| Comparación                       | \<, >, = , \<>, \<=, >= |
| Negación lógica                   | NOT                     |
| Conjunción lógica                 | AND                     |
| OR lógico                         | OR                      |

**Operadores de cadenas**: Los siguientes operadores funcionan con cadenas: `<, >, =, <>, <=, >=, +`

**Referencias a funciones**: Los operadores `=` y `<>` funcionan sobre variables que contienen referencias a funciones y literales de función.

## Operadores lógicos y bit a bit

Los operadores `Y`, `OR`, y `NO` se utilizan para comparaciones lógicas (Boolean) si los argumentos de estos operadores son Boolean:

```text
a = 20
b = 20
c = 20
if a = c and not(b > 40) then print "success"
```

Por otro lado, si los argumentos de estos operadores son numéricos, realizarán operaciones bit a bit:

```text
x = 1 and 2   ' x is zero
y = true and false  ' y is false
```

Cuando el operador `Y` u `OR` se usa para una operación lógica, solo se ejecuta la cantidad necesaria de la expresión. Por ejemplo, la primera instrucción a continuación imprimirá "True", mientras que la segunda instrucción provocará un error de ejecución (porque "invalid" no es un operando válido para `OR`):

```text
print true or invalid
print false or invalid
```

## Operador de punto

El operador de punto "." se puede usar en cualquier objeto BrightScript. También tiene un significado especial cuando se usa en un objeto *roAssociativeArray*, así como en objetos *roXMLElement* y *roXMLList*. Cuando se usa en un objeto BrightScript, hace referencia a una interfaz o método asociado con ese objeto. En el siguiente ejemplo, `IfInt` hace referencia a la interfaz y `SetInt()` hace referencia a un método que forma parte de esa interfaz:

```text
i = CreateObject("roInt")
i.ifInt.SetInt(5)
i.SetInt(5)
```

Cada método de objeto forma parte de una interfaz. Sin embargo, especificar la interfaz con el operador de punto "." es opcional. Si se omite la interfaz, como en la tercera línea del ejemplo anterior, se buscará el miembro especificado en cada interfaz que forme parte del objeto. Si existe un conflicto de nombres (es decir, un método con el mismo nombre aparece en dos interfaces), entonces se debe especificar la interfaz.

### Matrices asociativas

Cuando el operador de punto "." se usa en una matriz asociativa, es lo mismo que llamar a los métodos `Lookup()` o `AddReplace()`, que son funciones miembro del objeto [roAssociativeArray](docId:0YwiKKtpZFySWssiOHDeF):

```text
aa = {}
aa.newkey = "the value"
print aa.newkey
```

Tenga en cuenta que los parámetros del operador de punto "." se establecen en tiempo de compilación; a diferencia de los métodos `Lookup()` y `AddReplace()`, no son dinámicos.

El operador de punto "." siempre distingue mayúsculas y minúsculas de forma no sensible: por ejemplo, la instrucción `aa.NewKey=55` creará la entrada "newkey" en la matriz asociativa. Para generar claves que distingan mayúsculas y minúsculas, instancie un objeto *roAssociativeArray* y use el método `SetModeCaseSensitive()`.

## Operadores de matriz y llamada a función

El operador \[ ] se usa para acceder a una matriz (es decir, cualquier objeto BrightScript que tenga una interfaz *ifArray*, como objetos *roArray* y *roList*). También se puede usar para acceder a una matriz asociativa. El operador \[ ] acepta expresiones que se evalúan en tiempo de ejecución, mientras que el operador de punto "." acepta identificadores en tiempo de compilación.

El operador ( ) se puede usar para llamar a una función. Cuando se usa en un literal de función (o variable que contiene una referencia a una función), esa función será llamada.

El siguiente fragmento de código demuestra el uso de los operadores de matriz y de llamada a función.

```text
aa = CreateObject("roAssociativeArray")
aa["newkey"] = "the value"
print aa["newkey"]

array = CreateObject("roArray", 10, true)
array[2] = "two"
print array[2]
 
fivevar = five
print fivevar()
 
array[1] = fivevar
print array[1]()   ' print 5
 
function five() As Integer
   return 5
end function
```

### Dimensiones de matriz

Las matrices en BrightScript son unidimensionales. Las matrices multidimensionales se implementan como matrices de matrices. El operador \[ ] asignará automáticamente la multidimensionalidad. Por ejemplo, las siguientes dos expresiones de obtención son iguales:

```text
dim array[5,5,5]
item = array[1][2][3]
item = array[1,2,3]
```

:::hint{type="info"}
Si una matriz multidimensional crece más allá de su tamaño sugerido, las nuevas entradas no se establecen automáticamente en *roArray*.
:::

## Operador Equals

El operador = se usa tanto para asignación como para comparación:

```text
a = 5
If a = 5 then print "a is 5"
```

A diferencia del lenguaje C, BrightScript no admite el uso del operador de asignación = dentro de una expresión. Esto tiene como objetivo eliminar una clase común de errores causados por la confusión entre asignación y comparación.

Cuando ocurre una asignación, los tipos intrínsecos se copian, mientras que los objetos BrightScript usan recuento de referencias.