A precedência e a associatividade de operadores determina a ordem na qual os operadores são processados. Embora possa parecer natural aos que estão familiarizados com aritmética que o compilador processe o operador de multiplicação (*) antes do operador de adição (+), o compilador precisa de instruções explícitas sobre os operadores que deve processar primeiro. Essas instruções são denominadas coletivamente de precedência de operador. O ActionScript define a precedência de um operador padrão que você pode alterar usando o operador parênteses (()). Por exemplo, o seguinte código altera a precedência padrão no exemplo anterior para forçar o compilador a processar o operador de adição antes do operador de multiplicação:

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

Você pode encontrar situações em que dois ou mais operadores da mesma precedência aparecem na mesma expressão. Nesses casos, o compilador usa as regras de associatividade para determinar qual operador será processado primeiro. Todos os operadores binários, exceto os de atribuição, são associativos à esquerda, o que significa que os operadores à esquerda são processados antes dos que estão à direita. Todos os operadores de atribuição e o operador condicional (?:) são associativos à direita, o que significa que os operadores à direita são processados antes dos que estão à esquerda.

Por exemplo, considere os operadores "menor do que" (<) e "maior do que" (>), que têm a mesma precedência. Se os dois forem usados na mesma expressão, o operador à esquerda será processado primeiro porque os dois operadores são associativos à esquerda. Isso significa que as duas instruções a seguir produzem a mesma saída:

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

O operador maior do que é processado primeiro, o que resulta em um valor true, porque o operando 3 é maior do que o operando 2. O valor true é transmitido para o operador menor do que junto com o operando 1. O seguinte código representa esse estado intermediário:

trace((true) < 1); 

O operador menor do que converte o valor true no valor numérico 1 e compara esse valor numérico com o segundo operando 1 para retornar o valor false (o valor 1 não é menor que 1).

trace(1 < 1); // false

É possível alterar a associatividade à esquerda padrão com o operador parênteses. Você pode instruir o compilador a processar o operador menor do que primeiro, colocando esse operador e seus operandos entre parênteses. O exemplo a seguir usa o operador parênteses para produzir uma saída diferente usando os mesmos números que o exemplo anterior:

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

O operador menor do que é processado primeiro, o que resulta em um valor false, porque o operando 2 não é menor que o operando 1. O valor false é transmitido para o operador maior do que junto com o operando 3. O seguinte código representa esse estado intermediário:

trace(3 > (false)); 

O operador maior do que converte o valor false no valor numérico 0 e compara esse valor numérico com o outro operando 3 para retornar o valor true (o valor 3 é maior que 0).

trace(3 > 0); // true

A tabela a seguir lista os operadores para o ActionScript 3.0 em ordem decrescente de precedência. Cada linha da tabela contém operadores de mesma precedência. Cada linha de operadores tem precedência sobre a linha que aparece abaixo dela na tabela.

Os operadores primários incluem aqueles usados para criar literais Array e Object, agrupar expressões, chamar funções, instanciar ocorrências de classes e acessar propriedades.

Todos os operadores primários, conforme listados na tabela a seguir, têm a mesma precedência. Os operadores que fazem parte da especificação E4X são indicados pela notação (E4X).

Os operadores de sufixo usam um operador e incrementam ou decrementam o valor. Embora esses operadores sejam unários, eles são classificados separadamente do resto dos operadores unários por causa de sua maior precedência e seu comportamento especial. Quando um operador de sufixo é usado como parte de uma expressão maior, o valor da expressão é retornado antes que o operador de sufixo seja processado. Por exemplo, o seguinte código mostra como o valor da expressão xNum++ é retornado antes de ser incrementado:

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

Todos os operadores de sufixo, conforme listados na tabela a seguir, têm a mesma precedência:

Os operadores unários usam um operando. Os operadores de incremento (++) e de decremento (--) deste grupo são operadores deprefixo, o que significa que aparecem antes do operando em uma expressão. Os operadores de prefixo diferem dos de sufixo na operação de incremento ou decremento que é executada antes que o valor da expressão geral seja retornado. Por exemplo, o seguinte código mostra como o valor da expressão ++xNum é retornado depois de ser incrementado:

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

Todos os operadores unários, conforme listados na tabela a seguir, têm a mesma precedência:

Os operadores multiplicativos usam dois operandos e executam cálculos de multiplicação, divisão ou módulo.

Todos os operadores multiplicativos, conforme listados na tabela a seguir, têm a mesma precedência:

Os operadores aditivos usam dois operandos e executam cálculos de adição ou subtração. Todos os operadores aditivos, conforme listados na tabela a seguir, têm a mesma precedência:

Os operadores de desvio em nível de bits usam dois operandos e desviam os bits do primeiro até o ponto especificado pelo segundo operando. Todos os operadores de desvio em nível de bits, conforme listados na tabela a seguir, têm a mesma precedência:

Os operadores relacionais usam dois operandos, comparam seus valores e retornam um valor booleano. Todos os operadores relacionais, conforme listados na tabela a seguir, têm a mesma precedência:

Os operadores de igualdade usam dois operandos, comparam seus valores e retornam um valor booleano. Todos os operadores de igualdade, conforme listados na tabela a seguir, têm a mesma precedência:

Os operadores lógicos em nível de bits usam dois operandos e executam operações lógicas em nível de bits. Os operadores lógicos em nível de bits diferem na precedência e são listados na tabela a seguir em ordem decrescente de precedência:

Os operadores lógicos usam dois operandos e retornam um valor booleano. Os operadores lógicos diferem em precedência e são listados na tabela a seguir em ordem decrescente de precedência:

O operador condicional é um operador ternário, o que significa que usa três operandos. Ele é um método útil para aplicar a instrução condicional if..else .

Os operadores de atribuição usam dois operandos e atribuem um valor a um deles, com base no valor do outro. Todos os operadores de atribuição, conforme listados na tabela a seguir, têm a mesma precedência: