Operadores

Os operadores são funções especiais que usam um ou mais operandos e retornam um valor. Um operando é um valor, normalmente um literal, uma variável ou uma expressão, que um operador usa como entrada. Por exemplo, no código a seguir, os operadores de adição ( + ) e de multiplicação ( * ) são usados com três operandos literais (2, 3 , e 4 ) para retornar um valor. Esse valor é usado pelo operador de atribuição ( = ) para atribuir o valor retornado, 14, para a variável sumNumber . 

var sumNumber:uint = 2 + 3 * 4; // uint = 14

Os operadores podem ser unários, binários ou ternários. Um operador unário usa um operando. Por exemplo, o operador de incremento ( ++ ) é um operador unário, porque usa apenas um operando. Um operador binário usa dois operandos. Por exemplo, o operador de divisão ( / ) usa dois operandos. Um operador ternário usa três operandos. Por exemplo, o operador condicional ( / ) usa três operandos.

Alguns operadores são sobrecarregados , o que significa que se comportam de forma diferente dependendo do tipo ou da quantidade de operandos que lhes são transmitidos. O operador de adição ( + ) é um exemplo de um operador sobrecarregado que se comporta de maneira diferente dependendo do tipo de dados dos operandos. Se os dois operandos forem números, o operador de adição retornará a soma dos valores. Se os dois operandos forem seqüências de caracteres, o operador de adição retornará a concatenação dos dois operandos. O código de exemplo a seguir mostra como o operador se comporta de forma diferente dependendo dos operandos: 

trace(5 + 5); // 10 
trace("5" + "5"); // 55

Os operadores também podem se comportar de forma diferente com base no número de operandos fornecidos. O operador de subtração ( - ) é um operador unário e binário. Quando fornecido com apenas um operando, o operador de subtração nega o operando e retorna o resultado. Quando fornecido com dois operandos, o operador de subtração retorna a diferença entre os operandos. O exemplo a seguir mostra o operador de subtração usado primeiro como um operador unário e depois como binário. 

trace(-3); // -3 
trace(7 - 2); // 5

Precedência e associatividade de operadores

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.

Grupo

Operadores

Primário

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

Sufixo

x++ x--

Unário

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

Multiplicativo

* / %

Aditivo

+ -

Desvio em nível de bits

<< >> >>>

Relacional

< > <= >= as in instanceof is

Igualdade

== != === !==

AND em nível de bits

&

XOR em nível de bits

^

OR em nível de bits

|

AND lógico

&&

OR lógico

||

Condicional

?:

Atribuição

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

Vírgula

,

Operadores primários

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).

Operador

Operação executada

[]

Inicializa uma matriz

{x:y}

Inicializa um objeto

()

Agrupa expressões

f(x)

Chama uma função

new

Chama um construtor

x.y x[y]

Acessa uma propriedade

<></>

Inicializa um objeto XMLList (E4X)

@

Acessa um atributo (E4X)

::

Qualifica um nome (E4X)

..

Acessa um elemento XML descendente (E4X)

Operadores de sufixo

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:

Operador

Operação executada

++

Incrementos (sufixo)

--

Decrementos (sufixo)

Operadores unários

Os operadores unários usam um operando. Os operadores de incremento ( ++ ) e de decremento ( -- ) deste grupo são operadores de prefixo , 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:

Operador

Operação executada

++

Incrementos (prefixo)

--

Decrementos (prefixo)

+

Unário +

-

Unário - (negativa)

!

NOT lógico

~

NOT em nível de bits

delete

Exclui uma propriedade

typeof

Retorna informações de tipo

void

Retorna um valor indefinido

Operadores multiplicativos

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:

Operador

Operação executada

*

Multiplicação

/

Divisão

%

Módulo

Operadores aditivos

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:

Operador

Operação executada

+

Adição

-

Subtração

Operadores de desvio em nível de bits

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:

Operador

Operação executada

<<

Desvio à esquerda em nível de bits

>>

Desvio à direita em nível de bits

>>>

Desvio à direita não assinado em nível de bits

Operadores relacionais

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:

Operador

Operação executada

<

Menor do que

>

Maior do que

<=

Menor do que ou igual a

>=

Maior do que ou igual a

as

Verifica tipo de dados

in

Verifica propriedades de objeto

instanceof

Verifica cadeia de protótipos

is

Verifica tipo de dados

Operadores de igualdade

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:

Operador

Operação executada

==

Igualdade

!=

Desigualdade

===

Igualdade estrita

!==

Desigualdade estrita

Operadores lógicos em nível de bits

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:

Operador

Operação executada

&

AND em nível de bits

^

XOR em nível de bits

|

OR em nível de bits

Operadores lógicos

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:

Operador

Operação executada

&&

AND lógico

||

OR lógico

Operador condicional

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 .

Operador

Operação executada

?:

Condicional

Operadores de atribuição

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:

Operador

Operação executada

=

Atribuição

*=

Atribuição de multiplicação

/=

Atribuição de divisão

%=

Atribuição de módulo

+=

Atribuição de adição

-=

Atribuição de subtração

<<=

Atribuição de desvio à esquerda em nível de bits

>>=

Atribuição de desvio à direita em nível de bits

>>>=

Atribuição de desvio à direita não assinado em nível de bits

&=

Atribuição AND em nível de bits

^=

Atribuição XOR em nível de bits

|=

Atribuição OR em nível de bits