Med operatorprioritet och associativitet avgörs i vilken ordning som operatorerna behandlas. Även om det kan verka naturligt för dem som är bekanta med aritmetik att kompilatorn behandlar multiplikationsoperatorn (
*
) före additionsoperatorn (
+
), så behöver kompilatorn uttryckliga instruktioner om vilka operatorer den ska behandla först. Sådana instruktioner kallas för
operatorprioritet
. I ActionScript definieras en standardoperatorprioritet som du kan ändra genom att använda parentesoperatorn (
()
). I följande kod ändras standardprioriteten från föregående exempel så att kompilatorn tvingas bearbeta additionsoperatorn före multiplikationsoperatorn:
var sumNumber:uint = (2 + 3) * 4; // uint == 20
Du kan komma att stöta på situationer i vilka två eller flera operatorer med samma prioritet förekommer i samma uttryck. I dessa fall använder kompilatorn reglerna för
associativitet
för att avgöra vilken operator som ska behandlas först. Samtliga binära operatorer, förutom tilldelningsoperatorerna, är
vänster-associerande
, vilket innebär att operatorer till vänster behandlas före operatorer till höger. Tilldelningsoperatorer och villkorliga operatorer (
?:
) är
höger-associativa
, vilket innebär att operatorer till höger behandlas före operatorer till vänster.
Låt oss ta operatorerna för mindre än (
<
) och större än (
>
) som har samma prioritet. Om båda operatorerna används i samma uttryck behandlas operatorn till vänster först eftersom båda operatorerna har vänster-associativitet. Detta innebär att de två följande programsatserna ger samma utdata:
trace(3 > 2 < 1); // false
trace((3 > 2) < 1); // false
Operatorn för större än behandlas först, vilket ger värdet
true
eftersom operanden 3 är större än operanden 2. Värdet
true
skickas sedan till operatorn för mindre än tillsammans med operanden 1. Följande kod anger det här mellanläget:
trace((true) < 1);
Operatorn mindre än konverterar värdet
true
till det numeriska värdet 1 och jämför det numeriska värdet med den andra operanden 1 för att returnera värdet
false
(värdet 1 är inte mindre än 1).
trace(1 < 1); // false
Du kan ändra standardvärdet för vänster-associativitet med parentesoperatorn. Du kan instruera kompilatorn att behandla operatorn mindre än först genom att sätta denna operator och dess operander inom parentes. I följande exempel används parentesoperatorn för att skapa andra utdata med samma tal som i föregående exempel.
trace(3 > (2 < 1)); // true
Operatorn för mindre än behandlas först, vilket ger värdet
false
eftersom operanden 2 inte är mindre än operanden 1. Värdet
false
skickas sedan till operatorn för större än tillsammans med operanden 3. Följande kod anger det här mellanläget:
trace(3 > (false));
Operatorn större än konverterar värdet
false
till det numeriska värdet 0 och jämför det numeriska värdet med den andra operanden 3 för att returnera värdet
true
(värdet 3 är större än 0).
trace(3 > 0); // true
I följande tabell visas operatorerna för ActionScript 3.0 i minskande prioritetsordning. Varje rad i tabellen innehåller operatorer med samma prioritet. En rad med operatorer i tabellen har högre prioritet än raden under.
|
Grupp
|
Operatorer
|
|
Primär
|
[] {x:y} () f(x) new x.y x[y] <></> @ :: ..
|
|
Postfix
|
x++ x--
|
|
Unär
|
++x --x + - ~ ! delete typeof void
|
|
Multiplicerande
|
* / %
|
|
Adderande
|
+ -
|
|
Bitvisa skift
|
<< >> >>>
|
|
Relation
|
< > <= >= as in instanceof is
|
|
Likhet
|
== != === !==
|
|
Bitvis AND
|
&
|
|
Bitvis XOR
|
^
|
|
Bitvis OR
|
|
|
|
Logiskt AND
|
&&
|
|
Logiskt OR
|
||
|
|
Villkorligt
|
?:
|
|
Tilldelning
|
= *= /= %= += -= <<= >>= >>>= &= ^= |=
|
|
Komma
|
,
|
