Flash / ActionScript: Operatoren

ActionScript stellt ein vollständiges Spektrum von Operatoren zur Verfügung, welche entsprechend folgender Zusammenstellung klassifiziert werden können.

Arithmetische Operatoren

Neben den bekannten Operatoren für die mathematischen Grundrechenarten existieren in ActionScript noch spezielle Operatoren für die Division mit Restrückgabe (modulo), Vorzeichen für numerische Werte sowie In- bzw. Dekrementation:

Operator	Bsp.	Operation	Assoziativität	Beschreibung
`+`	`+x`	Positives Vorzeichen	R nach L	Entspricht x
`-`	`-x`	Negatives Vorzeichen	R nach L	Kehrt Vorzeichen von x um
`+`	`x + y`	Addition	L nach R	Summe von x und y
`-`	`x - y`	Subtraktion	L nach R	Differenz von x und y
`*`	`x * y`	Multiplikation	L nach R	Produkt von x und y
`/`	`x / y`	Division	L nach R	Quotient von x und y
`%`	`x % y`	Modulo Division	L nach R	Rest von Division von x und y
`++`	`++x`	präfix Inkrement	R nach L	Zuerst Erhöhung des Werts von x um 1; liefert dann erhaltenen Wert
`--`	`--x`	präfix Dekrement	R nach L	Zuerst Verringerung des Werts von x um 1; liefert dann erhaltenen Wert
`++`	`x++`	postfix Inkrement	L nach R	Liefert zuerst Wert von x; dann Erhöhung des Werts von x um 1
`--`	`x--`	postfix Dekrement	L nach R	Liefert zuerst Wert von x; dann Verringerung des Werts von x um 1

Zuweisungsoperatoren

Neben dem einfachen Zuweisungsoperator (=) existieren in ActionScript noch einige zusammengesetzte Operatoren, mithilfe derer sich Anweisungen verkürzt notiert werden können.

Operator	Bsp.	Operation	Assoziativität	Beschreibung
`=`	`x = y`	Einfache Zuweisung	R nach L	Zuweisung des Werts von y an x
`+=`	`x += y`	Addition, dann Zuweisung	R nach L	Zuweisung des Werts von x+y an x
`-=`	`x -= y`	Subtraktion, dann Zuweisung	R nach L	Zuweisung des Werts von x-y an x
`*=`	`x *= y`	Multiplikation, dann Zuweisung	R nach L	Zuweisung des Werts von x*y an x
`/=`	`x /= y`	Division, dann Zuweisung	R nach L	Zuweisung des Werts von x/y an x
`%=`	`x %= y`	Modulo-Division, dann Zuweisung	R nach L	Zuweisung des Werts von x%y an x

Vergleichsoperatoren

Mithilfe der Vergleichsoperatoren kann man jeweils die Werte zweier Ausdrücke miteinander vergleichen, wobei die beiden booleschen Werte true und false als mögliche Ergebnisse in Erscheinung treten können. ActionScript kennt die folgenden Vergleichsoperatoren, wobei es von jedem einen speziellen für den Vergleich von Strings gibt:

Operator	Bsp.	Operation	Assoziativität	Beschreibung
`>`	`x > y`	größer als; im Stringkontext auch Operator gt verwendbar	L nach R	Ergibt true, wenn x größer als y ist
`<`	`x < y`	kleiner als; im Stringkontext auch Operator lt verwendbar	L nach R	Ergibt true, wenn x kleiner als y ist
`>=`	`x >= y`	größer gleich; im Stringkontext auch Operator ge verwendbar	L nach R	Ergibt true, wenn x größer oder gleich y ist
`<=`	`x <= y`	kleiner gleich; im Stringkontext auch Operator le verwendbar	L nach R	Ergibt true, wenn x kleiner oder gleich y ist

Gleichheitsoperatoren

Mithilfe der Gleichheitsopertoren lassen sich die Werte zweier Ausdrücken miteinander auf Gleichheit oder Ungleichheit überprüfen, wobei im ersten Falle der boolesche Wert true, andernfalls false zurückgegeben wird. Man unterscheidet in ActionScript dabei mehrere Formen: die Gleichheit und Identität bzw. deren Komplemente:

Operator	Bsp.	Operation	Assoziativität	Beschreibung
`==`	`x == y`	Gleichheit; im Stringkontext auch Operator eq verwendbar	L nach R	Ergibt true, wenn x gleich y ist (zuvor Typumwandlung: Datentypen können unterschiedlich sein)
`!=`	`X != y`	Ungleichheit; im Stringkontext auch Operator ne verwendbar	L nach R	Ergibt true, wenn x ungleich y ist (zuvor Typumwandlung: Datentypen können unterschiedlich sein)
`===`	`x === y`	Strikte Gleichheit (Identität)	L nach R	Ergibt true, wenn x gleich y ist und deren Datentyp identisch sind
`!==`	`x !== y`	Strikte Ungleichheit	L nach R	Ergibt true, wenn x ungleich y ist und deren Datentyp identisch sind

Logische Operatoren

Diese Operatoren erwarten als Operanden jeweils zwei boolesche Ausdrücke und geben gemäß ihrer Charakteristik einen booleschen Ausdruck zurück. Folgende sind in ActionScript verwendbar:

Operator	Bsp.	Operation	Assoziativität	Beschreibung
`&&`	`x && y`	AND (logisches und); alternativ als auch Operator and	L nach R	Ergibt true, wenn sowohl x als auch y true sind
`\|\|`	`x \|\| y`	OR (logisches oder) ); alternativ als auch Operator or	L nach R	Ergibt true, wenn zumindest einer der beiden Operanden true ist
`!`	`!x`	NOT (logisches nicht) ); alternativ als auch Operator not	L nach R	Entspricht dem Komplement von x (Umkehr des Wahrheitswertes)

Bitweise Operatoren

Bei der Verwendung von bitweisen Operatoren werden Fließkommazahlen intern in 32-Bit-Ganzzahlen umgewandelt, so dass deren Bits, also die kleinsten Informationseinheiten eines Computers. getrennt voneinander ausgewertet werden können. Die Operatoren dieser Klasse werden zwar verhältnismäßig selten benötigt, seien zur Vollständigkeit jedoch aufgeführt. Für die folgenden Beispiele sei x = 21 (Binärcode: 10101), y = 24 (Binärcode: 11000) und z = -21 (Binärcode: 01011).

Operator	Bsp.	Operation	Assoziativität	Beschreibung
`&`	`x = x & y;`	AND (bitweises und)	L nach R	Ergibt boolesche Multiplikation der jeweiligen Bits beider Zahlen; Ergebnis aus Beispiel: 16 (Binärcode: 10000)
`\|`	`x = x \| y;`	OR (bitweises oder)	L nach R	Ergibt boolesche Addition der jeweiligen Bits beider Zahlen; Ergebnis aus Beispiel: 29 (Binärcode: 11101)
`^`	`x = x ^ y;`	XOR (bitweises nicht oder)	L nach R	Ergibt Verknüpfung der jeweiligen Bits beider Zahlen durch exklusives Oder; Ergebnis aus Beispiel: 13 (Binärcode: 01101)
`~`	`x = ~x;`	NOT (bitweises nicht)	R nach L	Bit-Komplement (Negation), d.h. Vertauschen von 0 und 1 jedes Bits; Ergebnis aus Beispiel: -22 (Binärcode: 01010)
`>>`	`y = y >> 3;`	Verschieben nach rechts (Rechtsshift)	L nach R	Verschiebt die Bits um die angegebene Anzahl von Stellen nach rechts; Ergebnis aus Beispiel: 3 (Binärcode: 11)
`<<`	`x = x < < 3;`	Verschieben nach links (Linksshift)	L nach R	Verschiebt die Bits um die angegebene Anzahl von Stellen nach links; Ergebnis aus Beispiel: 168 (Binärcode: 10101000)
`>>>`	`z = z >>> 3`	Verschieben nach rechts (Rechtsshift), Auffüllung mit 0	L nach R	Verschiebt die Bits um die angegebene Anzahl von Stellen nach rechts, ohne dabei das Vorzeichen der Zahl zu beachten; Ergebnis aus Beispiel: 536870909
`>>=`	`y >>= 3;`	Verschiebung nach rechts (Rechtsshift), dann Zuweisung	R nach L	Verkürzte Schreibweise für y = y >> 3;
`<<=`	`x <<= 3;`	Verschiebung nach links (Linksshift), dann Zuweisung	R nach L	Verkürzte Schreibweise für x = x << 3;
`>>>=`	`z >>>= 3;`	Verschieben nach rechts (Rechtsshift), Auffüllung mit 0, dann Zuweisung	R nach L	Verkürzte Schreibweise für z = z >>> 3;
`&=`	`x &= y;`	AND (bitweises und), dann Zuweisung	R nach L	Verkürzte Schreibweise für x = x & y;
`\|=`	`x \|= y;`	OR (bitiweses oder), dann Zuweisung	R nach L	Verkürzte Schreibweise für x = x \| y;
`^=`	`x ^= y;`	XOR (bitweises nicht oder), dann Zuweisung	R nach L	Verkürzte Schreibweise für x = x ^ y;

Präzedenz von Operatoren

Die verschiedenen Operatoren haben eine unterschiedliche interne Priorität in ActionScript . Bei der Verknüpfung von mehreren Operanden mittels dieser ist die Kenntnis dieser Rangfolge von elementarer Bedeutung, um das Zustandekommen unerwünschter Ergebnisse zu vermeiden. Folgende Präzedenztabelle zeigt die Prioritäten, wobei geklammerte Ausdrücke die höchste haben:

Priorität	Operator
hoch	`() (Klammerung von Ausdrücken)`
	`+ - (Vorzeichen)`
	`~`
	`! not`
	`++ (postfix Inkrement) - (postfix Dekrement)`
	`[] (Array-Zugriffsoperator)`
	`. (Punktoeprator)`
	`++ (prätfix Inkrement) - (präfix Dekrement)`
	`new (Objekt von Klasse erzeugen)`
	`Delete (Objekt löschen)`
	`typeof (Datentyp einer Variablen ermitteln)`
	`*`
	`/ %`
	`+ (Addition, Verkettung von Strings)`
	`add (Verkettung von Strings)`
	`- (Subtraktion)`
	`<<`
	`>>`
	`>>>`
	`<`
	`<=`
	`>`
	`>=`
	`lt`
	`le`
	`gt`
	`ge`
	`==`
	`!=`
	`eq`
	`ne`
	`&`
	`^`
	`\|`
	`&&`
	`and`
	`\|\|`
	`or xor`
	`?: (verkürzte Syntax für if-else-Bedingung)`
	`=`
gering	`*=, /=, %=, +=, -=, &=, \|=, ^=, <<=, >>=, >>>=`

Du arbeitest in einer Agentur oder als Freelancer?
Dann wirf doch mal einen Blick auf unsere Software FeatValue.

Weiterlesen: ⯈ Funktionen

Über uns

Wir entwickeln Webanwendungen mit viel Leidenschaft. Unser Wissen geben wir dabei gerne weiter. Mehr über a coding project