La precedencia y asociatividad de los operadores determina el orden en que se procesan los operadores. Aunque para aquellos usuarios familiarizados con la programación aritmética puede parecer natural que el compilador procese el operador de multiplicación (*) antes que el operador de suma (+), el compilador necesita instrucciones explícitas sobre qué operadores debe procesar primero. Dichas instrucciones se conocen colectivamente como precedencia de operadores. ActionScript establece una precedencia de operadores predeterminada que se puede modificar utilizando el operador paréntesis (()). Por ejemplo, el código siguiente modifica la precedencia predeterminada del ejemplo anterior para forzar al compilador a procesar el operador suma antes que el operador producto:

var sumNumber:uint = (2 + 3) * 4; // uint == 20

Pueden darse situaciones en las que dos o más operadores con la misma precedencia aparezcan en la misma expresión. En estos casos, el compilador utiliza las reglas de asociatividad para determinar qué operador se procesa primero. Todos los operadores binarios, salvo los operadores de asignación, tienen asociatividad desde la izquierda, lo que significa que los operadores de la izquierda se procesan antes que los operadores de la derecha. Los operadores de asignación y el operador condicional (?:) tienen asociatividad desde la derecha, lo que significa que los operadores de la derecha se procesan antes que los operadores de la izquierda.

Consideremos, por ejemplo, los operadores menor que (<) y mayor que (>), que tienen la misma precedencia. Si ambos operadores se utilizan en la misma expresión, el operador de la izquierda se procesará en primer lugar porque ambos operadores tienen asociatividad desde la izquierda. Esto significa que las dos sentencias siguientes generan el mismo resultado:

trace(3 > 2 < 1); // false 
trace((3 > 2) < 1); // false

El operador mayor que se procesa primero, lo que devuelve un valor true, ya que el operando 3 es mayor que el operando 2. A continuación, se pasa el valor true al operador menor que, junto con el operando 1. El código siguiente representa este estado intermedio:

trace((true) < 1); 

El operador menor que convierte el valor true en el valor numérico 1 y compara dicho valor numérico con el segundo operando 1 para devolver el valor false (el valor 1 no es menor que 1).

trace(1 < 1); // false

Se puede modificar la asociatividad predeterminada desde la izquierda con el operador paréntesis. Se puede ordenar al compilador que procese primero el operador menor que escribiendo dicho operador y sus operandos entre paréntesis. En el ejemplo siguiente se utiliza el operador paréntesis para producir un resultado diferente utilizando los mismos números que en el ejemplo anterior:

trace(3 > (2 < 1)); // true

El operador menor que se procesa primero, lo que devuelve un valor false, ya que el operando 2 no es menor que el operando 1. A continuación, se pasa el valor false al operador mayor que, junto con el operando 3. El código siguiente representa este estado intermedio:

trace(3 > (false)); 

El operador mayor que convierte el valor false en el valor numérico 0 y compara dicho valor numérico con el otro operando 3 para devolver el valor true (el valor 3 es mayor que 0).

trace(3 > 0); // true

En la tabla siguiente se muestran los operadores de ActionScript 3.0 por orden decreciente de precedencia. Cada fila de la tabla contiene operadores de la misma precedencia. Cada fila de operadores tiene precedencia superior a la fila que aparece debajo de ella en la tabla.

[] {x:y} () f(x) new x.y x[y] <></> @ :: ..

x++ x--

++x --x + - ~ ! delete typeof void

* / %

+ -

<< >> >>>

< > <= >= as in instanceof is

== != === !==

&

^

|

&&

||

?:

= *= /= %= += -= <<= >>= >>>= &= ^= |=

,

Los operadores principales incluyen los que se utilizan para crear literales Array y Object, agrupar expresiones, llamar a funciones, crear instancias de clase y acceder a propiedades.

Todos los operadores principales, indicados en la tabla siguiente, tienen la misma precedencia. Los operadores que forman parte de la especificación E4X se indican mediante la notación (E4X).

[]

{x:y}

()

f(x)

new

x.y x[y]

<></>

@

::

..

Los operadores de sufijo se aplican a un operador para aumentar o reducir el valor. Aunque estos operadores son unarios, se clasifican por separado del resto de los operadores unarios debido a su mayor precedencia y a su comportamiento especial. Al utilizar un operador de sufijo como parte de una expresión mayor, el valor de la expresión se devuelve antes de que se procese el operador de sufijo. Por ejemplo, el siguiente código muestra cómo se devuelve el valor de la expresión xNum++ antes de que se incremente el valor:

var xNum:Number = 0; 
trace(xNum++); // 0 
trace(xNum); // 1

Todos los operadores de sufijo, indicados en la tabla siguiente, tienen la misma precedencia:

++

--

Los operadores unarios se aplican a un operando. Los operadores de incremento (++) y decremento (--) de este grupo son operadores de prefijo, lo que significa que aparecen delante del operando en una expresión. Los operadores de prefijo difieren de los correspondientes operadores de sufijo en que la operación de incremento o decremento se realiza antes de que se devuelva el valor de la expresión global. Por ejemplo, el siguiente código muestra cómo se devuelve el valor de la expresión ++xNum después de que se incremente el valor:

var xNum:Number = 0; 
trace(++xNum); // 1 
trace(xNum); // 1

Todos los operadores unarios, indicados en la tabla siguiente, tienen la misma precedencia:

++

--

+

-

!

~

delete

typeof

void

Los operadores multiplicativos toman dos operandos y realizan cálculos de multiplicación, división o módulo.

Todos los operadores multiplicativos, indicados en la tabla siguiente, tienen la misma precedencia:

*

/

%

Los operadores aditivos se aplican a dos operandos y realizan cálculos de suma y resta. Todos los operadores aditivos, indicados en la tabla siguiente, tienen la misma precedencia:

+

-

Los operadores de desplazamiento en modo bit se aplican a dos operandos y desplazan los bits del primer operando según lo especificado por el segundo operando. Todos los operadores de desplazamiento en modo de bit, indicados en la tabla siguiente, tienen la misma precedencia:

<<

>>

>>>

Los operadores relacionales se aplican a dos operandos, comparan sus valores y devuelven un valor booleano. Todos los operadores relacionales, indicados en la tabla siguiente, tienen la misma precedencia:

<

>

<=

>=

as

in

instanceof

is

Los operadores de igualdad se aplican a dos operandos, comparan sus valores y devuelven un valor booleano. Todos los operadores de igualdad, indicados en la tabla siguiente, tienen la misma precedencia:

==

!=

===

!==

Los operadores lógicos en modo bit se aplican a dos operandos y realizan operaciones lógicas a nivel de bits. Estos operadores, que tienen una precedencia diferente, se enumeran en la tabla siguiente por orden decreciente de precedencia:

&

^

|

Los operadores lógicos se aplican a dos operandos y devuelven un resultado booleano. Estos operadores, que tienen distintas precedencias, se enumeran en la tabla siguiente por orden decreciente de precedencia:

&&

||

El operador condicional es un operador ternario, lo que significa que se aplica a tres operandos. El operador condicional es un método abreviado para aplicar la sentencia condicional if..else.

?:

Los operadores de asignación se aplican a dos operandos y asignan un valor a un operando en función del valor del otro operando. Todos los operadores de asignación, indicados en la tabla siguiente, tienen la misma precedencia:

=

*=

/=

%=

+=

-=

<<=

>>=

>>>=

&=

^=

|=