Los operadores son funciones especiales que se aplican a uno o más operandos y devuelven un valor. Un
operando
es un valor (generalmente un literal, una variable o una expresión) que se usa como entrada de un operador. Por ejemplo, en el código siguiente, los operadores de suma (
+
) y multiplicación (
*
) se usan con tres operandos literales (2, 3 y 4
)
para devolver un valor. A continuación, el operador de asignación (
=
) usa este valor para asignar el valor devuelto, 14, a la variable
sumNumber
.
var sumNumber:uint = 2 + 3 * 4; // uint = 14
Los operadores pueden ser unarios, binarios o ternarios. Un operador
unario
se aplica a un operando. Por ejemplo, el operador de incremento (
++
) es un operador unario porque se aplica a un solo operando. Un operador
binario
se aplica a dos operandos. Por ejemplo, el operador división (
/
) se aplica a dos operandos. Un operador
ternario
se aplica a tres operandos. Por ejemplo, el operador condicional (
?:
) se aplica a tres operandos.
Algunos operadores están
sobrecargados
, lo que significa que se comportan de distinta manera en función del tipo o la cantidad de operandos que se les pase. El operador suma (
+
) es un ejemplo de un operador sobrecargado que se comporta de distinta manera en función del tipo de datos de los operandos. Si ambos operandos son números, el operador suma devuelve la suma de los valores. Si ambos operandos son cadenas, el operador suma devuelve la concatenación de los dos operandos. En el siguiente ejemplo de código se muestra cómo cambia el comportamiento del operador en función de los operandos:
trace(5 + 5); // 10
trace("5" + "5"); // 55
Los operadores también pueden comportarse de distintas maneras en función del número de operandos suministrados. El operador resta (
-
) es la vez un operador unario y un operador binario. Si se le suministra un solo operando, el operador resta devuelve como resultado la negación del operando. Si se le suministran dos operandos, el operador resta devuelve la diferencia de los operandos. En el siguiente ejemplo se muestra el operador resta usado primero como un operador unario y después como un operador binario.
trace(-3); // -3
trace(7 - 2); // 5
Precedencia y asociatividad de operadores
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.
Grupo
|
Operadores
|
Primario
|
[] {x:y} () f(x) new x.y x[y] <></> @ :: ..
|
Sufijo
|
x++ x--
|
Unario
|
++x --x + - ~ ! delete typeof void
|
Multiplicativo
|
* / %
|
Aditivo
|
+ -
|
Desplazamiento en modo bit
|
<< >> >>>
|
Relacional
|
< > <= >= como en instanceof es
|
Igualdad
|
== != === !==
|
AND en modo bit
|
&
|
XOR en modo bit
|
^
|
OR en modo bit
|
|
|
AND lógico
|
&&
|
OR lógico
|
||
|
Condicional
|
?:
|
Asignación
|
= *= /= %= += -= <<= >>= >>>= &= ^= |=
|
Coma
|
,
|
Operadores principales
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).
Operador
|
Operación realizada
|
[]
|
Inicializa un conjunto
|
{x:y}
|
Inicializa un objeto
|
()
|
Agrupa expresiones
|
f(x)
|
Llama a una función
|
new
|
Llama a un constructor
|
x.y x[y]
|
Accede a una propiedad
|
<></>
|
Inicializa un objeto XMLList (E4X)
|
@
|
Accede a un atributo (E4X)
|
::
|
Califica un nombre (E4X)
|
..
|
Accede a un elemento XML descendiente (E4X)
|
Operadores de sufijo
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:
Operador
|
Operación realizada
|
++
|
Incremento (sufijo)
|
--
|
Decremento (sufijo)
|
Operadores unarios
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:
Operador
|
Operación realizada
|
++
|
Incremento (prefijo)
|
--
|
Decremento (prefijo)
|
+
|
Unario +
|
-
|
Unario - (negación)
|
!
|
NOT lógico
|
~
|
NOT en modo bit
|
delete
|
Elimina una propiedad
|
typeof
|
Devuelve información de tipo
|
void
|
Devuelve un valor no definido
|
Operadores multiplicativos
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:
Operador
|
Operación realizada
|
*
|
Multiplicación
|
/
|
División
|
%
|
Módulo
|
Operadores aditivos
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:
Operador
|
Operación realizada
|
+
|
Suma
|
-
|
Resta
|
Operadores de desplazamiento en modo bit
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:
Operador
|
Operación realizada
|
<<
|
Desplazamiento a la izquierda en modo bit
|
>>
|
Desplazamiento a la derecha en modo bit
|
>>>
|
Desplazamiento a la derecha en modo bit sin signo
|
Operadores relacionales
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:
Operador
|
Operación realizada
|
<
|
Menor que
|
>
|
Mayor que
|
<=
|
Menor o igual que
|
>=
|
Mayor o igual que
|
as
|
Comprueba el tipo de datos
|
in
|
Comprueba las propiedades de objetos
|
instanceof
|
Comprueba una cadena de prototipos
|
is
|
Comprueba el tipo de datos
|
Operadores de igualdad
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:
Operador
|
Operación realizada
|
==
|
Igualdad
|
!=
|
Desigualdad
|
===
|
Igualdad estricta
|
!==
|
Desigualdad estricta
|
Operadores lógicos en modo bit
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:
Operador
|
Operación realizada
|
&
|
AND en modo bit
|
^
|
XOR en modo bit
|
|
|
OR en modo bit
|
Operadores lógicos
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:
Operador
|
Operación realizada
|
&&
|
AND lógico
|
||
|
OR lógico
|
Operador condicional
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
.
Operador
|
Operación realizada
|
?:
|
Condicional
|
Operadores de asignación
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:
Operador
|
Operación realizada
|
=
|
Asignación
|
*=
|
Asignación de multiplicación
|
/=
|
Asignación de división
|
%=
|
Asignación de módulo
|
+=
|
Asignación de suma
|
-=
|
Asignación de resta
|
<<=
|
Asignación de desplazamiento a la izquierda en modo bit
|
>>=
|
Asignación de desplazamiento a la derecha en modo bit
|
>>>=
|
Asignación de desplazamiento a la derecha en modo bit sin signo
|
&=
|
Asignación de AND en modo bit
|
^=
|
Asignación de XOR en modo bit
|
|=
|
Asignación de OR en modo bit
|
|
|
|