Operatorer

Operatorer är speciella funktioner som använder en eller flera operander och returnerar ett värde. En operand är ett värde, vanligtvis en litteral, en variabel eller ett uttryck, som används som indata av en operator. I följande kod används additions- ( + ) och multiplikationsoperatorn ( * ) med tre litterala operander (2, 3 och 4 ) för att returnera ett värde. Värdet används därefter av tilldelningsoperatorn ( = ) för att tilldela variabeln sumNumber det returnerade värdet 14.

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

Operatorer kan vara enställiga, binära eller ternära. En unär operator tar en operand. Ökningsoperatorn ( ++ ) är till exempel en unär operator eftersom den bara tar en operand. En binär operator tar två operander. Divisionsoperatorn ( / ) tar till exempel två operander. En ternär operator tar tre operander. Den villkorliga operatorn ( ?: ) tar till exempel tre operander.

Vissa operatorer är överlastade , vilket betyder att de beter sig på olika sätt beroende på vilken typ eller kvantitet av operander som skickas till dem. Additionsoperatorn ( + ) är ett exempel på en överlastad operator som beter sig på olika sätt beroende på operandernas datatyp. Om båda operanderna är tal returneras summan av värdena. Om båda operanderna är strängar returneras sammanfogningen av de två operanderna. I följande exempelkod visas hur operatorn beter sig på olika sätt beroende på operanderna:

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

Operatorer kan också bete sig på olika sätt beroende på hur många operander det finns. Subtraktionsoperatorn ( - ) är både unär och binär operator. När det bara finns en operand negeras operanden av subtraktionsoperatorn och resultatet returneras. När det finns två operander returneras skillnaden mellan operanderna. I följande exempel visas hur subtraktionsoperatorn först används som unär operator och sedan som binär operator.

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

Operatorprioritet och associativitet

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

,

Primära operatorer

Primära operatorer används för att skapa array- och objektlitteraler, gruppera uttryck, anropa funktioner, instansiera klassinstanser och komma åt egenskaper.

Alla primära operatorer som visas i följande tabell har samma prioritet. Operatorer som är en del av E4X-specifikationen anges med (E4X)-notationen.

Operator

Utförd operation

[]

Initierar en array

{x:y}

Initierar ett objekt

()

Grupperar uttryck

f(x)

Anropar en funktion

new

Anropar en konstruktor

x.y x[y]

Kommer åt en egenskap

<></>

Initierar ett XMLList-objekt (E4X)

@

Kommer åt ett attribut (E4X)

::

Kvalificerar ett namn (E4X)

..

Kommer åt en underordnat XML-element (E4X)

Postfix-operatorer

Postfix-operatorer använder en operator och antingen ökar eller minskar värdet. Även om dessa operatorer är unära operatorer klassificeras de avgränsat från resten av de unära operatorerna genom deras högre prioritet och speciella beteende. När du använder en postfix-operator som en del i ett större uttryck, returneras uttryckets värde innan postfix-operatorn behandlas. Följande kod visar hur värdet för uttrycket xNum++ returneras innan värdet ökas:

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

Alla postfix-operatorer i följande tabell har samma prioritet:

Operator

Utförd operation

++

Ökningar (postfix)

--

Minskningar (postfix)

Unära operatorer

Unära operatorer använder en operand. Operatorer för ökning ( ++ ) och minskning ( -- ) i denna grupp är prefix -operatorer , vilket betyder att de förekommer före operanden i ett uttryck. Prefix-operatorer skiljer sig från postfix-motsvarigheten eftersom öknings- och minskningsoperationen utförs innan värdet för det övergripande uttrycket returneras. I följande kod visas hur värdet för uttrycket ++xNum returneras efter att värdet ökats.

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

Alla unära operatorer i följande tabell har samma prioritet:

Operator

Utförd operation

++

Ökningar (prefix)

--

Minskningar (prefix)

+

Unär +

-

Unär – (negation)

!

Logiskt NOT

~

Bitvis NOT

delete

Tar bort en egenskap

typeof

Returnerar typinformation

void

Returnerar odefinierat värde

Multiplicerande operatorer

Multiplicerande operatorer tar två operander och utför multiplikation, division eller modulo-beräkningar.

Alla multiplicerande operatorer i följande tabell har samma prioritet:

Operator

Utförd operation

*

Multiplikation

/

Division

%

Modulo

Adderande operatorer

Adderande operatorer tar två operander och utför addition eller subtraktion. Alla adderande operatorer i följande tabell har samma prioritet:

Operator

Utförd operation

+

Addition

-

Subtraktion

Bitvisa skiftoperatorer

De bitvisa skiftoperatorerna tar två operatorer och skiftar bitarna i den första operanden i den utsträckning som anges av den andra operanden. Alla bitvisa skiftoperatorer i följande tabell har samma prioritet:

Operator

Utförd operation

<<

Bitvis vänsterskift

>>

Bitvis högerskift

>>>

Bitvis osignerad högerskift

Relationsoperatorer

Relationsoperatorer tar två operander, jämför deras värden och returnerar ett booleskt värde. Alla relationsoperatorer i följande tabell har samma prioritet:

Operator

Utförd operation

<

Mindre än

>

Större än

<=

Mindre än eller lika med

>=

Större än eller lika med

as

Kontrollerar datatyp

in

Kontrollerar objektegenskaper

instanceof

Kontrollerar prototypkedja

is

Kontrollerar datatyp

Likhetsoperatorer

Likhetsoperatorer tar två operander, jämför deras värden, och returnerar ett booleskt värde. Alla likhetsoperatorer i följande tabell har samma prioritet:

Operator

Utförd operation

==

Likhet

!=

Olikhet

===

Strikt likhet

!==

Strikt olikhet

Bitvisa logiska operatorer

Bitvisa logiska operatorer tar två operander och utför logiska operationer på bitnivå. De bitvisa logiska operatorerna har inte samma prioritet och anges i tabellen efter minskande prioritet:

Operator

Utförd operation

&

Bitvis AND

^

Bitvis XOR

|

Bitvis OR

Logiska operatorer

Logiska operatorer tar två operander och returnerar ett booleskt värde. De logiska operatorerna har inte samma prioritet och anges i tabellen efter minskande prioritet:

Operator

Utförd operation

&&

Logiskt AND

||

Logiskt OR

Villkorsoperator

Villkorsoperatorn är en ternär operator vilket innebär att den tar tre operander. Villkorsoperatorn är en snabbare metod att använda den villkorliga programsatsen if..else .

Operator

Utförd operation

?:

Villkorligt

Tilldelningsoperatorer

Tilldelningsoperatorer tar två operander och tilldelar en operand ett värde baserat på värdet för den andra operanden. Alla tilldelningsoperatorer i följande tabell har samma prioritet:

Operator

Utförd operation

=

Tilldelning

*=

Multiplikationstilldelning

/=

Divisionstilldelning

%=

Modulotilldelning

+=

Additionstilldelning

-=

Subtraktionstilldelning

<<=

Bitvis vänsterskifttilldelning

>>=

Bitvis högerskifttilldelning

>>>=

Bitvis osignerad högerskifttilldelning

&=

Bitvis AND-tilldelning

^=

Bitvis XOR-tilldelning

|=

Bitvis OR-tilldelning