Flash CS3-Dokumentation |
|||
| Programmieren mit ActionScript 3.0 > ActionScript-Sprache und -Syntax > Operatoren | |||
Operatoren sind spezielle Funktionen, die mindestens einen Operanden umfassen und einen Wert zurückgeben. Ein Operand ist ein Wert - in der Regel ein Literal, eine Variable oder ein Ausdruck - den ein Operator als Eingabe verwendet. Im folgenden Beispielcode werden der Additionsoperator (+) und der Multiplikationsoperator (*) mit drei literalen Operanden (2, 3 und 4) verwendet, um einen Wert zurückzugeben. Dieser Wert wird dann vom Zuweisungsoperator (=) verwendet, um den zurückgegebenen Wert (14) der Variablen sumNumber zuzuweisen.
var sumNumber:uint = 2 + 3 * 4; // uint = 14
Operatoren können unär, binär oder ternär sein. Ein unärer Operator umfasst einen Operanden. Ein Beispiel für einen unären Operator ist der Inkrementoperator (++), da er nur einen Operanden hat. Ein binärer Operator umfasst zwei Operanden. Ein Beispiel ist der Divisionsoperator (/, der zwei Operanden umfasst. Ein ternärer Operator umfasst drei Operanden. Ein Beispiel für diesen Operator ist der Bedingungsoperator (?:, der drei Operanden hat.
Einige Operatoren sind überladen, das heißt, dass sie sich je nach Typ oder Anzahl der übergebenen Operanden unterschiedlich verhalten. Ein Beispiel für einen überladenen Operator ist der Additionsoperator (+), da er sich je nach Datentyp der Operanden unterschiedlich verhält. Handelt es sich bei beiden Operanden um Zahlen, liefert der Additionsoperator die Summe der beiden Werte. Sind beide Operanden Strings, gibt der Additionsoperator eine Verkettung der beiden Operanden zurück. Im folgenden Codebeispiel sind die verschiedenen Auswirkungen des Operators je nach verwendeten Operanden dargestellt:
trace(5 + 5); // 10
trace("5" + "5"); // 55
Operatoren können sich auch je nach Anzahl der angegebenen Operanden unterschiedlich verhalten. Der Subtraktionsoperator (-) ist sowohl ein unärer als auch ein binärer Operator. Wenn nur ein Operand angegeben ist, negiert der Subtraktionsoperator den Operanden und gibt das Ergebnis zurück. Sind zwei Operanden angegeben, gibt der Subtraktionsoperator die Differenz zwischen den Operanden zurück. Im folgenden Beispiel wird der Subtraktionsoperator gezeigt, wie er zuerst als unärer Operator und dann als binärer Operator verwendet wird.
trace(-3); // -3 trace(7-2); // 5
Rangfolge und Assoziativität der Operatoren bestimmen die Reihenfolge, in der die Operatoren verarbeitet werden. Obwohl es für Personen mit arithmetischen Programmierkenntnissen „selbstverständlich" erscheinen mag, dass der Compiler den Multiplikationsoperator (*) vor dem Additionsoperator (+) ausführt, braucht der Compiler konkrete Anweisungen dafür, in welcher Reihenfolge Operatoren verarbeitet werden sollen. Diese Anweisungen werden zusammenfassend als Operatorrangfolge bezeichnet. In ActionScript gilt eine Standardrangfolge für Operatoren, die Sie jedoch mithilfe von runden Klammern (()) ändern können. Beispielsweise wird mit dem folgenden Code die Standardrangfolge aus dem vorangegangenen Beispiel geändert, um den Compiler zu zwingen, den Additionsoperator vor dem Multiplikationsoperator auszuführen:
var sumNumber:uint = (2 + 3) * 4; // uint == 20
In manchen Fällen können sich mindestens zwei Operatoren mit derselben Rangfolge im gleichen Ausdruck befinden. In diesen Fällen ermittelt der Compiler anhand der Regeln der Assoziativität, welcher Operator zuerst verarbeitet wird. Für alle binären Operatoren, mit Ausnahme der Zuweisungsoperatoren, gilt die Linksassoziativität. Das heißt, dass die Operatoren auf der linken Seite vor den Operatoren auf der rechten Seite verarbeitet werden. Für die Zuweisungsoperatoren und den Bedingungsoperator (?:) gilt die Rechtsassoziativität. Das heißt, dass die Operatoren auf der rechten Seite vor den Operatoren auf der linken Seite verarbeitet werden.
Der Kleiner als-Operator < und der Größer als-Operator > haben beispielsweise dieselbe Rangfolge. Sind beide Operatoren im gleichen Ausdruck enthalten, wird der linke Operator zuerst verarbeitet, da für beide Operatoren die Linksassoziativität gilt. Das heißt, dass die beiden folgenden Anweisungen dieselbe Ausgabe generieren:
trace(3 > 2 < 1); // false trace((3 > 2) < 1); // false
Der Größer als-Operator wird zuerst verarbeitet. Als Ergebnis entsteht der Wert true, da der Operand 3 größer ist als der Operand 2. Dann wird der Wert true mit dem Operanden 1 an den Kleiner als-Operator übergeben. Dieser Zwischenzustand ist im folgenden Code dargestellt:
trace((true) < 1);
Der Kleiner als-Operator wandelt den Wert true in den numerischen Wert 1 um und vergleicht diesen numerischen Wert mit dem zweiten Operanden 1. Es wird der Wert false zurückgegeben, da der Wert 1 nicht kleiner ist als 1.
trace(1 < 1); // false
Sie können die standardmäßige Linksassoziativität mit dem Klammernoperator ändern. Durch Einschließen des Operators und seiner Operanden in runden Klammern können Sie den Compiler anweisen, zuerst den Kleiner als-Operator zu verarbeiten. Im folgenden Beispielcode wird der Klammernoperator eingesetzt, um bei Verwendung der Zahlen aus dem vorangegangenen Beispiel eine andere Ausgabe zu erzeugen:
trace(3 > (2 < 1)); // true
Der Kleiner als-Operator wird zuerst verarbeitet. Als Ergebnis entsteht der Wert false, da der Operand 2 nicht kleiner ist als der Operand 1. Dann wird der Wert false mit dem Operanden 3 an den Größer als-Operator übergeben. Dieser Zwischenzustand ist im folgenden Code dargestellt:
trace(3 > (false));
Der Größer als-Operator wandelt den Wert false in den numerischen Wert 0 um und vergleicht diesen numerischen Wert mit dem zweiten Operanden 3. Es wird der Wert true zurückgegeben, da der Wert 3 größer ist als 0.
trace(3 > 0); // true
In der folgenden Tabelle sind die Operatoren für ActionScript 3.0 in absteigender Rangfolge aufgeführt. Jede Tabellenzeile enthält Operatoren der gleichen Rangfolge. Jede Operatorenzeile hat einen höheren Rang als die Zeile, die darunter folgt.
|
Gruppe |
Operatoren |
|---|---|
|
Primär |
[] {x:y} () f(x) new x.y x[y] <></> @ :: ..
|
|
Suffix |
x++ x--
|
|
Unär |
++x --x + - ~ ! delete typeof void
|
|
Multiplikativ |
* / %
|
|
Additiv |
+ -
|
|
Bitweise Verschiebung |
<< >> >>>
|
|
Relational |
< > <= >= as in instanceof is
|
|
Gleichheit |
== != === !==
|
|
Bitweises AND |
&
|
|
Bitweises XOR |
^
|
|
Bitweises OR |
|
|
|
Logisches AND |
&&
|
|
Logisches OR |
||
|
|
Bedingung |
?:
|
|
Zuweisung |
= *= /= %= += -= <<= >>= >>>= &= ^= |=
|
|
Komma |
,
|
Die primären Operatoren umfassen die Operatoren zum Erstellen von Array- und Object-Literalen, zum Gruppieren von Ausdrücken, zum Aufrufen von Funktionen, zum Instanziieren von Klasseninstanzen und für den Zugriff auf Eigenschaften.
Alle in der folgenden Tabelle aufgeführten primären Operatoren haben dieselbe Rangfolge. Operatoren, die Teil der E4X-Spezifikation sind, werden durch die Notation (E4X) gekennzeichnet.
|
Operator |
Aktion |
|---|---|
[]
|
Initialisiert ein Array |
{x:y}
|
Initialisiert ein Objekt |
()
|
Gruppiert Ausdrücke |
f(x)
|
Ruft eine Funktion auf |
new
|
Ruft einen Konstruktor auf |
x.y x[y]
|
Greift auf eine Eigenschaft zu |
<></>
|
Initialisiert ein XMLList-Objekt (E4X) |
@
|
Greift auf ein Attribut zu (E4X) |
::
|
Qualifiziert einen Namen (E4X) |
..
|
Greift auf ein XML-Nachfolgeelement zu (E4X) |
Die Suffix-Operatoren umfassen einen Operator und erhöhen oder verringern dessen Wert. Diese Operatoren sind zwar unär, werden jedoch nicht zusammen mit den anderen unären Operatoren klassifiziert, da sie eine höhere Rangfolge und ein besonderes Verhalten aufweisen. Wenn Sie einen Suffix-Operator in einem größeren Ausdruck verwenden, wird der Wert des Ausdrucks noch vor der Verarbeitung des Suffix-Operators zurückgegeben. Im folgenden Beispielcode wird der Wert des Ausdrucks xNum++ zurückgegeben, bevor dieser inkrementiert wird:
var xNum:Number = 0; trace(xNum++); // 0 trace(xNum); // 1
Alle in der folgenden Tabelle aufgeführten Suffix-Operatoren haben dieselbe Rangfolge:
|
Operator |
Aktion |
|---|---|
++
|
Inkrementiert (Suffix) |
--
|
Dekrementiert (Suffix) |
Unäre Operatoren umfassen einen Operanden. Die Operatoren zum Inkrementieren (++) und Dekrementieren (--) in dieser Gruppe sind Präfix-Operatoren, da sie in einem Ausdruck vor dem Operanden stehen. Präfix-Operatoren unterscheiden sich insofern von ihren Gegenstücken, den Suffix-Operatoren, als dass das Inkrementieren oder Dekrementieren abgeschlossen ist, bevor der Wert des Gesamtausdrucks zurückgegeben wird. Im folgenden Beispielcode wird der Wert des Ausdrucks ++xNum zurückgegeben, nachdem dieser inkrementiert wurde:
var xNum:Number = 0; trace(++xNum); // 1 trace(xNum); // 1
Alle in der folgenden Tabelle aufgeführten unären Operatoren haben dieselbe Rangfolge:
|
Operator |
Aktion |
|---|---|
++
|
Inkrementiert (Präfix) |
--
|
Dekrementiert (Präfix) |
+
|
Unär + |
-
|
Unär - (Negation) |
!
|
Logisches NOT |
~
|
Bitweises NOT |
delete
|
Löscht eine Eigenschaft. |
typeof
|
Gibt Typinformationen zurück |
void
|
Gibt einen undefinierten Wert zurück |
Multiplikative Operatoren haben zwei Operanden und führen Multiplikationen, Divisionen und Restwertberechnungen durch.
Alle in der folgenden Tabelle aufgeführten multiplikativen Operatoren haben dieselbe Rangfolge:
|
Operator |
Aktion |
|---|---|
*
|
Multiplikation |
/
|
Division |
%
|
Restwert |
Additionsoperatoren umfassen zwei Operanden und führen Additionen und Subtraktionen durch. Alle in der folgenden Tabelle aufgeführten Additionsoperatoren haben dieselbe Rangfolge:
|
Operator |
Aktion |
|---|---|
+
|
Addition |
-
|
Subtraktion |
Die Operatoren für bitweise Verschiebung haben zwei Operanden. Sie verschieben die Bits des ersten Operanden um den Wert, der mit dem zweiten Operanden angegeben wird. Alle in der folgenden Tabelle aufgeführten Operatoren für bitweise Verschiebung haben dieselbe Rangfolge:
|
Operator |
Aktion |
|---|---|
<<
|
Bitweise Verschiebung nach links |
>>
|
Bitweise Verschiebung nach rechts |
>>>
|
Vorzeichenlose bitweise Verschiebung nach rechts |
Relationale Operatoren umfassen zwei Operanden, vergleichen deren Werte und geben einen booleschen Wert zurück. Alle in der folgenden Tabelle aufgeführten relationalen Operatoren haben dieselbe Rangfolge:
|
Operator |
Aktion |
|---|---|
<
|
Kleiner als |
>
|
Größer als |
<=
|
Kleiner als oder gleich |
>=
|
Größer als oder gleich |
as
|
Überprüft Datentyp |
in
|
Überprüft Objekteigenschaften |
instanceof
|
Überprüft Prototypkette |
is
|
Überprüft Datentyp |
Gleichheitsoperatoren umfassen zwei Operanden, vergleichen deren Werte und geben einen booleschen Wert zurück. Alle in der folgenden Tabelle aufgeführten Gleichheitsoperatoren haben dieselbe Rangfolge:
|
Operator |
Aktion |
|---|---|
==
|
Gleichheit |
!=
|
Ungleichheit |
===
|
Strikte Gleichheit |
!==
|
Strikte Ungleichheit |
Die bitweisen logischen Operatoren umfassen zwei Operanden und führen logische Operationen auf Bit-Ebene aus. Die bitweisen logischen Operatoren unterscheiden sich hinsichtlich der Rangfolge. In der folgenden Tabelle sind sie in absteigender Rangfolge aufgeführt:
|
Operator |
Aktion |
|---|---|
&
|
Bitweises AND |
^
|
Bitweises XOR |
|
|
Bitweises OR |
Die logischen Operatoren umfassen zwei Operanden und geben einen booleschen Ergebniswert zurück. Die logischen Operatoren unterscheiden sich hinsichtlich der Rangfolge. In der folgenden Tabelle sind sie in absteigender Rangfolge aufgeführt:
|
Operator |
Aktion |
|---|---|
&&
|
Logisches AND |
||
|
Logisches OR |
Der Bedingungsoperator ist ternär, das heißt, er umfasst drei Operanden. Mit dem Bedingungsoperator lässt sich die Bedingungsanweisung if..else auf verkürzte Weise anwenden.
|
Operator |
Aktion |
|---|---|
?:
|
Bedingung |
Zuweisungsoperatoren haben zwei Operanden. Sie weisen einem Operanden einen Wert zu, der auf dem Wert des anderen Operanden basiert. Alle in der folgenden Tabelle aufgeführten Zuweisungsoperatoren haben dieselbe Rangfolge:
|
Operator |
Aktion |
|---|---|
=
|
Zuweisung |
*=
|
Multiplikationszuweisung |
/=
|
Divisionszuweisung |
%=
|
Modulo-Zuweisung (Restwert) |
+=
|
Additionszuweisung |
-=
|
Subtraktionszuweisung |
<<=
|
Zuweisung einer bitweisen Verschiebung nach links |
>>=
|
Zuweisung einer bitweisen Verschiebung nach rechts |
>>>=
|
Zuweisung einer vorzeichenlosen bitweisen Verschiebung nach rechts |
&=
|
Zuweisung von bitweisem AND |
^=
|
Zuweisung von bitweisem XOR |
|=
|
Zuweisung von bitweisem OR |
Flash CS3
Eine E-Mail an mich senden, wenn dieser Seite Kommentare hinzugefügt werden | Kommentarbericht
Aktuelle Seite: http://livedocs.adobe.com/flash/9.0_de/main/00000050.html