Operatoren 

Addiert numerische Ausdrücke. Wenn beide Ausdrücke Ganzzahlen sind, ist die Summe eine Ganzzahl; wenn ein oder beide Ausdrücke Gleitkommazahlen sind, ist die Summe eine Gleitkommazahl.

IWenn einer der Ausdrücke eine Zeichenfolge ist, werden alle Ausdrücke in Zeichenfolgen umgewandelt und verkettet anstatt summiert. Wenn ein Ausdruck dagegen keine Zahl ist, wandelt ihn Flash^® Player in eine Zahl um.

trace(2 + 3); // 5

trace(2.5 + 3.25); // 5.75

trace("Number " + 8 + 0); // Number 80

var oldBalance:Number = 1345.23; 
var currentBalance = deposit_txt.text + oldBalance; 
trace(currentBalance); 

var oldBalance:Number = 1345.23; 
var currentBalance:Number = Number(deposit_txt.text) + oldBalance;
trace(currentBalance);

Verwandte API-Elemente

Weist expression1 den Wert von expression1 + expression2 zu. Die folgenden Anweisungen sind beispielsweise gleichwertig:

x += y; 
x = x + y; 

var x:Number = 5; 
var y:Number = 10; 
x += y; 
trace(x); // 15 

Verwandte API-Elemente

myArray = [a0, a1,...aN]
myArray[i] = value 
myObject[propertyName]

Initialisiert ein neues Array oder ein neues multidimensionales Array mit den angegebenen Elementen (a0 usw.) bzw. greift auf Elemente in einem Array zu. Mit dem Array-Zugriffsoperator können Namen von Instanzen, Variablen und Objekten dynamisch gesetzt und abgerufen werden. Sie können den Operator auch zum Zugriff auf Objekteigenschaften verwenden.

Verwendung 1: Ein Array ist ein Objekt, dessen Eigenschaften (elements) durch eine Zahl (den sog. index) angegeben werden. Beim Erstellen eines Arrays umgeben Sie die Elemente mit Array-Zugriffsoperatoren ([], also eckigen Klammern). Ein Array kann verschiedene Arten von Elementen enthalten. Das folgende Array namens employee weist beispielsweise drei Elemente auf: Das erste ist eine Zahl, das zweite und dritte sind Strings in Anführungszeichen ("):

var employee:Array = [15, "Barbara", "Jay"]; 

var ticTacToe:Array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]; 
			
/* Select Debug > List Variables in test mode 
to see a list of the array elements.*/ 

var my_array:Array = new Array(); 
my_array[0] = 15; 
my_array[1] = "Hello"; 
my_array[2] = true; 

my_array[3] = "George"; 

var ticTacToe:Array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]; 
trace(ticTacToe[1][2]); // 6 

var obj:Object = new Object();
obj.prop1 = "foo";
trace(obj["prop" + 1]); // foo
obj.prop2 = "bar";
for (j in obj) {
	trace(obj[j]);
} 
/* Output of for loop: 
foo
bar */

var my_array:Array = []; 
var my_array:Array = new Array(); 

Der folgende Beispielcode erstellt ein Array mit der Bezeichnung employee_array mit drei Elementen und ändert das dritte Element im Array:

var employee_array = ["Barbara", "George", "Mary"]; 
trace(employee_array); // Barbara,George,Mary 
employee_array[2] = "Sam"; 
trace(employee_array); // Barbara,George,Sam 

var obj:Object = new Object();
obj.prop1 = "foo";
obj.prop2 = "bar";

for (var i:int = 1;i < 3;i++) {
	trace(obj["prop"+i]);
}
/* Output of for loop:
foo
bar */ 

Verwandte API-Elemente

Wertet aus, ob ein vom ersten Operanden angegebener Ausdruck ein Mitglied des Datentyps ist, der vom zweiten Operanden angegeben wird. Ist der erste Operand ein Mitglied des Datentyps, ist das Ergebnis der erste Operand. Andernfalls ist das Ergebnis der Wert null.

Der für den zweiten Operanden verwendete Ausdruck muss sich als Datentyp auswerten lassen.

public var myArray:Array = ["one", "two", "three"];
trace(myArray as Array);  // one,two,three
trace(myArray as Number); // null
trace(myArray as int);    // null

Verwandte API-Elemente

Weist der Variablen, dem Array-Element oder der Eigenschaft expression1 den Wert von expression2 (dem rechten Operanden) zu. Die Zuweisung kann entweder durch einen Wert oder durch eine Referenz erfolgen. Bei einer Zuweisung durch einen Wert wird der tatsächliche Wert von expression2 kopiert und in expression1 gespeichert. Die Zuweisung durch einen Wert wird dann verwendet, wenn es sich bei expression2 um einen Grundwert handelt. Dies bedeutet, der Datentyp ist entweder „Boolean“, „int“, „uint“ oder „String“. Bei einer Zuweisung durch eine Referenz wird die Referenz auf expression2 in expression1 gespeichert. Die Referenzzuweisung wird in der Regel zusammen mit dem Operator new verwendet. Der Operator new erstellt im Speicher ein Objekt und weist einer Variablen einen Verweis auf diese Speicherposition zu.

Hinweis: In ActionScript 3.0 sind alle Werte (einschließlich Grundwerte) Objekte, und jede Zuweisung erfolgt über einen Verweis. Grundobjekte haben jedoch spezielle Operatoren, die es ihnen erlauben, sich so zu verhalten, als ob sie durch einen Wert zugewiesen wären.

var z:Number = 5;

var x:String;
x = "hello";

var moonsOfJupiter:Array = new Array();
moonsOfJupiter[0] = "Callisto";

var mercury:Object = new Object();
mercury.diameter = 3030; // in miles
trace(mercury.diameter); // 3030

var merkur:Object = mercury;
merkur.diameter = 4878;  // in kilometers
trace(mercury.diameter); // 4878

Verwandte API-Elemente

 myXML.@attributeName 

Kennzeichnet die Attribute eines XML- oder XMLList-Objekts. Beispiel: myXML.@id kennzeichnet Attribute mit der Bezeichnung id für das XML-Objekt myXML. Sie können auch mit der folgenden Syntax auf Attribute zugreifen: myXML.attribute("id"), myXML["@id"] und myXML.@["id"]. Die Syntax myXML.@id wird empfohlen. Um ein XMLList-Objekt aller Attributnamen zurückzugeben, verwenden Sie @*. Um ein Attribut mit einem Namen zurückzugeben, der einem in ActionScript reservierten Wort entspricht, verwenden Sie die attribute()-Methode anstelle des @-Operators.

var myXML:XML = 
	<item id = "42">
		<catalogName>Presta tube</catalogName>
		<price>3.99</price>
	</item>;

trace(myXML.@id); // 42

var xml:XML =<example id='123' color='blue'/>
 var xml2:XMLList = xml.@*;
 trace(xml2 is XMLList); // true
 trace(xml2.length());  // 2
 for (var i:int = 0; i < xml2.length(); i++)
 { 
	trace(typeof(xml2[i]));    // xml
	trace(xml2[i].nodeKind()); // attribute
	trace(xml2[i].name());     // id and color
 } 

var xml:XML = <example class='123'/>
trace(xml.attribute("class"));

Verwandte API-Elemente

Wandelt expression1 und expression2 in vorzeichenlose 32-Bit-Ganzzahlen um und führt eine boolesche AND-Operation an jedem einzelnen Bit der ganzzahligen Parameter aus. Gleitkommazahlen werden in Ganzzahlen umgewandelt. Dabei werden sämtliche Nachkommastellen abgeschnitten. Das Ergebnis ist eine neue 32-Bit-Ganzzahl.

Eine positive Ganzzahl wird in einen vorzeichenlosen Hexadezimalwert mit einem Maximalwert von 4294967295 bzw. hexadezimal 0xFFFFFFFF umgewandelt. Ist die ursprüngliche Zahl größer, werden die höchstwertigen Stellen bei der Umwandlung abgeschnitten, sodass das Ergebnis weiterhin ein 32-Bit-Wert ist. Eine negative Zahl wird mithilfe der Zweierkomplement-Darstellung in einen vorzeichenlosen Hexadezimalwert von maximal -2147483648 bzw. 0x800000000 konvertiert. Von einer kleineren Zahl wird das Zweierkomplement gebildet (mit höherer Genauigkeit), die höchstwertigen Stellen werden wiederum abgeschnitten.

Das Ergebnis wird als vorzeichenbehafteter 32-Bit-Zweierkomplementwert interpretiert, also handelt es sich bei diesem Wert um eine Ganzzahl zwischen -2147483648 und 2147483647.

var insert:Number = 13; 
var update:Number = 11; 
trace(insert & update); // 9 (or 1001 binary) 

  1101
& 1011
  ----
  1001

Die folgenden Beispiele veranschaulichen das Verhalten bei der Umwandlung der Rückgabewerte:

trace(0xFFFFFFFF); // 4294967295 
trace(0xFFFFFFFF & 0xFFFFFFFF); // -1 
trace(0xFFFFFFFF & -1); // -1 
trace(4294967295 & -1); // -1 
trace(4294967295 & 4294967295); // -1 

Verwandte API-Elemente

Weist expression1 den Wert von expression1 & expression2 zu. Beispielsweise sind die beiden folgenden Ausdrücke austauschbar:

x &= y; 
x = x & y; 

var x:Number = 15; 
var y:Number = 9; 
trace(x &= y); // 9 

Verwandte API-Elemente

Wandelt expression1 und shiftCount in 32-Bit-Ganzzahlen um und verschiebt alle Bits in expression1 um die Anzahl der Stellen nach links, die sich aus der ganzzahligen Umwandlung von shiftCount ergibt. Die Bit-Positionen, die als Ergebnis dieser Operation geleert werden, werden mit 0 aufgefüllt. Gleichzeitig werden nach links verschobene Bits abgeschnitten. Das Verschieben eines Werts um eine Position nach links entspricht einer Multiplikation mit 2.

Eine Gleitkommazahl wird in eine Ganzzahl umgewandelt. Dabei werden alle Nachkommastellen abgeschnitten. Eine positive Ganzzahl wird in einen vorzeichenlosen Hexadezimalwert mit einem Maximalwert von 4294967295 bzw. hexadezimal 0xFFFFFFFF umgewandelt. Ist die ursprüngliche Zahl größer, werden die höchstwertigen Stellen bei der Umwandlung abgeschnitten, sodass das Ergebnis weiterhin ein 32-Bit-Wert ist. Eine negative Zahl wird mithilfe der Zweierkomplement-Darstellung in einen vorzeichenlosen Hexadezimalwert von maximal -2147483648 bzw. 0x800000000 konvertiert. Von einer kleineren Zahl wird das Zweierkomplement gebildet (mit höherer Genauigkeit), die höchstwertigen Stellen werden wiederum abgeschnitten.

Das Ergebnis wird als vorzeichenbehafteter 32-Bit-Zweierkomplementwert interpretiert, also handelt es sich bei diesem Wert um eine Ganzzahl zwischen -2147483648 und 2147483647.

Wenn das Ergebnis eine negative Ganzzahl ist, tritt ein Fehler zur Laufzeit auf, wenn Sie versuchen, das Ergebnis einer Variablen des Typs uint zuzuweisen. Obwohl ActionScript keinen Operator für eine „vorzeichenlose bitweise Verschiebung nach links“ umfasst, können Sie den gleichen Effekt erreichen und den Laufzeitfehler vermeiden, indem Sie uint(expression1 << shiftCount) verwenden:

var num1:uint = 0xFF;
var num2:uint = uint(num1 << 24); // uint() prevents runtime error

x = 1 << 10

   00000000001 binary 
<<          10 decimal
--------------
   10000000000 binary equals 1024 decimal 

Im folgenden Beispiel wird die Ganzzahl 7 um 8 Bit nach links verschoben:

x = 7 << 8

   00000000111 binary 
<<           8 decimal
--------------
   11100000000 binary equals 1792 decimal 

In der folgenden trace-Anweisung wird gezeigt, dass die Bits um drei Stellen nach links verschoben wurden:

// 1 binary == 0001 
// 8 binary == 1000 
trace(1 << 3); // 8 

Verwandte API-Elemente

Dieser Operator führt eine bitweise Verschiebung nach links (<<=) durch und speichert den Inhalt als Ergebnis in expression1. Die folgenden beiden Ausdrücke sind gleichwertig:

A <<= B
A = (A << B)

var x:Number = 4; 
// Shift all bits one slot to the left. 
x <<= 1; 
trace(x); // 8 
// 4 decimal = 0100 binary 
// 8 decimal = 1000 binary 

Verwandte API-Elemente

Wandelt expression in eine vorzeichenbehaftete 32-Bit-Ganzzahl um und bildet dann das bitweise Einerkomplement dazu. Das bedeutet, dass jedes 0-Bit im Ergebnis auf 1 gesetzt wird und und jedes 1-Bit auf 0. Das Ergebnis ist eine 32-Bit-Ganzzahl mit Vorzeichen. Dieser Operator wird auch als Einerkomplement-Operator bzw. als bitweiser Komplement-Operator bezeichnet.

So wird der Hexadezimalwert 0x7777 mit der folgenden Binärzahl dargestellt:

0111011101110111

Die bitweise Negation dieses Hexadezimalwerts, ~0x7777, ist diese Binärzahl:

1000100010001000

In hexadezimaler Schreibweise wird daraus 0x8888. Aus diesem Grund hat ~0x7777 den Wert 0x8888.

Bitweise Operatoren werden am häufigsten zur Darstellung von Flag-Bits verwendet (boolesche Werte, die jeweils aus einem Bit bestehen).

Eine Gleitkommazahl wird in eine Ganzzahl umgewandelt. Dabei werden alle Nachkommastellen abgeschnitten. Eine positive Ganzzahl wird in einen vorzeichenlosen Hexadezimalwert mit einem Maximalwert von 4294967295 bzw. hexadezimal 0xFFFFFFFF umgewandelt. Ist die ursprüngliche Zahl größer, werden die höchstwertigen Stellen bei der Umwandlung abgeschnitten, sodass das Ergebnis weiterhin ein 32-Bit-Wert ist. Eine negative Zahl wird mithilfe der Zweierkomplement-Darstellung in einen vorzeichenlosen Hexadezimalwert von maximal -2147483648 bzw. 0x800000000 konvertiert. Von einer kleineren Zahl wird das Zweierkomplement gebildet (mit höherer Genauigkeit), die höchstwertigen Stellen werden wiederum abgeschnitten.

Das Ergebnis wird als vorzeichenbehafteter 32-Bit-Zweierkomplementwert interpretiert, also handelt es sich bei diesem Wert um eine Ganzzahl zwischen -2147483648 und 2147483647.

var ReadOnlyFlag:int = 0x0001; // defines bit 0 as the read-only flag 
var flags:int = 0; 
trace(flags); 
/* To set the read-only flag in the flags variable, 
   the following code uses the bitwise OR: 
*/
flags |= ReadOnlyFlag; 
trace(flags); 
/* To clear the read-only flag in the flags variable, 
   first construct a mask by using bitwise NOT on ReadOnlyFlag. 
   In the mask, every bit is a 1 except for the read-only flag. 
   Then, use bitwise AND with the mask to clear the read-only flag. 
   The following code constructs the mask and performs the bitwise AND: 
*/ 
flags &= ~ReadOnlyFlag; 
trace(flags); 
// 0 1 0 

Verwandte API-Elemente

Wandelt expression1 und expression2 in vorzeichenlose 32-Bit-Ganzzahlen um und fügt eine 1 an jeder Bit-Position ein, an der die entsprechenden Bits von expression1 oder expression2 1 lauten.

Eine Gleitkommazahl wird in eine Ganzzahl umgewandelt. Dabei werden alle Nachkommastellen abgeschnitten. Eine positive Ganzzahl wird in einen vorzeichenlosen Hexadezimalwert mit einem Maximalwert von 4294967295 bzw. hexadezimal 0xFFFFFFFF umgewandelt. Ist die ursprüngliche Zahl größer, werden die höchstwertigen Stellen bei der Umwandlung abgeschnitten, sodass das Ergebnis weiterhin ein 32-Bit-Wert ist. Eine negative Zahl wird mithilfe der Zweierkomplement-Darstellung in einen vorzeichenlosen Hexadezimalwert von maximal -2147483648 bzw. 0x800000000 konvertiert. Von einer kleineren Zahl wird das Zweierkomplement gebildet (mit höherer Genauigkeit), die höchstwertigen Stellen werden wiederum abgeschnitten.

Das Ergebnis wird als vorzeichenbehafteter 32-Bit-Zweierkomplementwert interpretiert, also handelt es sich bei diesem Wert um eine Ganzzahl zwischen -2147483648 und 2147483647.

// 15 decimal = 1111 binary 
var a:Number = 15; 
// 9 decimal = 1001 binary 
var b:Number = 9; 
// 1111 | 1001 = 1111 
trace(a | b); // returns 15 decimal (1111 binary) 

Verwandte API-Elemente

Weist expression1 den Wert von expression1 | expression2 zu. Die beiden folgenden Anweisungen beispielsweise sind austauschbar:

x |= y; 
x = x | y; 

// 15 decimal = 1111 binary 
var a:Number = 15; 
// 9 decimal = 1001 binary 
var b:Number = 9; 
// 1111 |= 1001 = 1111 
trace(a |= b); // returns 15 decimal (1111 binary) 

Verwandte API-Elemente

Wandelt expression und shiftCount in 32-Bit-Ganzzahlen um und verschiebt alle Bits in expression um die Anzahl der Stellen nach rechts, die sich aus der ganzzahligen Umwandlung von shiftCount ergibt. Nach rechts verschobene Bits werden abgeschnitten. Um das Vorzeichen des ursprünglichen Ausdrucks zu bewahren, werden die Bits auf der linken Seite mit 0 aufgefüllt, wenn das höchstwertige Bit (das Bit ganz links) von expression gleich 0 ist. Wenn das höchstwertige Bit 1 ist, werden sie mit 1 aufgefüllt. Die Verschiebung eines Bits um eine Stelle nach rechts entspricht einer Division durch 2 und dem Abschneiden des Rests.

Eine Gleitkommazahl wird in eine Ganzzahl umgewandelt. Dabei werden alle Nachkommastellen abgeschnitten. Eine positive Ganzzahl wird in einen vorzeichenlosen Hexadezimalwert mit einem Maximalwert von 4294967295 bzw. hexadezimal 0xFFFFFFFF umgewandelt. Ist die ursprüngliche Zahl größer, werden die höchstwertigen Stellen bei der Umwandlung abgeschnitten, sodass das Ergebnis weiterhin ein 32-Bit-Wert ist. Eine negative Zahl wird mithilfe der Zweierkomplement-Darstellung in einen vorzeichenlosen Hexadezimalwert von maximal -2147483648 bzw. 0x800000000 konvertiert. Von einer kleineren Zahl wird das Zweierkomplement gebildet (mit höherer Genauigkeit), die höchstwertigen Stellen werden wiederum abgeschnitten.

Das Ergebnis wird als vorzeichenbehafteter 32-Bit-Zweierkomplementwert interpretiert, also handelt es sich bei diesem Wert um eine Ganzzahl zwischen -2147483648 und 2147483647.

var a:Number = 65535 >> 8; 
trace(a); // 255

    00000000000000001111111111111111 binary (65535 decimal)
>>                                 8 decimal
--------------------
    00000000000000000000000011111111 binary (255 decimal)

var a:Number = -8 >> 1;
trace(a); // -4

    11111111111111111111111111111000 binary (-8 decimal)
>>							    1 decimal
--------------------
    11111111111111111111111111111100 binary (-4 decimal)

Verwandte API-Elemente

Dieser Operator führt eine bitweise Verschiebung nach rechts durch und speichert das Ergebnis in expression.

Die folgenden beiden Anweisungen sind gleichwertig:

A >>= B; 
A = (A >> B);

function convertToBinary(numberToConvert:Number):String { 
	var result:String = ""; 
	for (var i = 0; i < 32; i++) { 
		// Extract least significant bit using bitwise AND. 
		var lsb:Number = numberToConvert & 1; 
		// Add this bit to the result.
		result = (lsb ? "1" : "0")+result; 
		// Shift numberToConvert right by one bit, to see next bit. 
		numberToConvert >>= 1; 
	} 
	return result; 
} 
trace(convertToBinary(479)); 
// Returns the string 00000000000000000000000111011111. 
// This string is the binary representation of the decimal number 479.

Verwandte API-Elemente

Entspricht dem Operator für bitweise Verschiebung nach rechts (>>), bewahrt jedoch nicht das Vorzeichen des ursprünglichen Ausdrucks, da die Bits auf der linken Seite stets mit 0 aufgefüllt werden.

Eine Gleitkommazahl wird in eine Ganzzahl umgewandelt. Dabei werden alle Nachkommastellen abgeschnitten. Eine positive Ganzzahl wird in einen vorzeichenlosen Hexadezimalwert mit einem Maximalwert von 4294967295 bzw. hexadezimal 0xFFFFFFFF umgewandelt. Ist die ursprüngliche Zahl größer, werden die höchstwertigen Stellen bei der Umwandlung abgeschnitten, sodass das Ergebnis weiterhin ein 32-Bit-Wert ist. Eine negative Zahl wird mithilfe der Zweierkomplement-Darstellung in einen vorzeichenlosen Hexadezimalwert von maximal -2147483648 bzw. 0x800000000 konvertiert. Von einer kleineren Zahl wird das Zweierkomplement gebildet (mit höherer Genauigkeit), die höchstwertigen Stellen werden wiederum abgeschnitten.

Das Ergebnis wird als vorzeichenlose 32-Bit-Ganzzahl interpretiert, also handelt es sich bei diesem Wert um eine Ganzzahl zwischen 0 und 4294967295.

Hinweis: Obwohl ActionScript keinen Operator für eine „vorzeichenlose bitweise Verschiebung nach links“ umfasst, können Sie den gleichen Effekt erreichen, indem Sie uint(expression << shiftCount) verwenden.

var a:Number = -1 >>> 1; 
trace(a); // 2147483647 

Verwandte API-Elemente

Dieser Operator führt eine vorzeichenlose bitweise Verschiebung nach rechts durch und speichert das Ergebnis in expression. Die folgenden beiden Anweisungen sind gleichwertig:

A >>>= B; 
A = (A >>> B); 

var a:Number = -1;
a >>>= 1; 
trace(a); // 2147483647 

Verwandte API-Elemente

Wandelt expression1 und expression2 in vorzeichenlose 32-Bit-Ganzzahlen um und fügt eine 1 an jeder Bit-Position ein, an der die entsprechenden Bits in expression1 oder expression2, jedoch nicht in beiden, 1 sind.

Eine Gleitkommazahl wird in eine Ganzzahl umgewandelt. Dabei werden alle Nachkommastellen abgeschnitten. Eine positive Ganzzahl wird in einen vorzeichenlosen Hexadezimalwert mit einem Maximalwert von 4294967295 bzw. hexadezimal 0xFFFFFFFF umgewandelt. Ist die ursprüngliche Zahl größer, werden die höchstwertigen Stellen bei der Umwandlung abgeschnitten, sodass das Ergebnis weiterhin ein 32-Bit-Wert ist. Eine negative Zahl wird mithilfe der Zweierkomplement-Darstellung in einen vorzeichenlosen Hexadezimalwert von maximal -2147483648 bzw. 0x800000000 konvertiert. Von einer kleineren Zahl wird das Zweierkomplement gebildet (mit höherer Genauigkeit), die höchstwertigen Stellen werden wiederum abgeschnitten.

Das Ergebnis wird als vorzeichenbehafteter 32-Bit-Zweierkomplementwert interpretiert, also handelt es sich bei diesem Wert um eine Ganzzahl zwischen -2147483648 und 2147483647.

// 15 decimal = 1111 binary 
// 9 decimal = 1001 binary 
var a:Number = 15 ^ 9; 
trace(a); 
// 1111 ^ 1001 = 0110 
// returns 6 decimal (0110 binary) 

Verwandte API-Elemente

Weist expression1 den Wert von expression1 ^ expression2 zu. Die beiden folgenden Anweisungen beispielsweise sind austauschbar:

x ^= y 
x = x ^ y 

// 15 decimal = 1111 binary 
var a:Number = 15; 
// 9 decimal = 1001 binary 
var b:Number = 9; 
trace(a ^= b); // returns 6 decimal (0110 binary) 

Verwandte API-Elemente

/* comment */

/* comment

   comment */

Begrenzt mindestens eine Skriptkommentarzeile. Der gesamte Text, der zwischen dem einleitenden Trennzeichen (/*) und dem abschließenden Trennzeichen (*/) steht, wird als Kommentar interpretiert und vom ActionScript-Interpreter ignoriert. Verwenden Sie diese Trennzeichen für Kommentare in mehreren aufeinander folgenden Zeilen. Für einzeilige Kommentare verwenden Sie das Trennzeichen //.

Wenn Sie vergessen, das abschließende Trennzeichen (*/) einzugeben, oder versuchen, Kommentare ineinander zu verschachteln, wird eine Fehlermeldung erzeugt. Nach einem einleitenden Trennzeichen (/*) führt bereits das erste schließende Trennzeichen (*/) zum Abschluss des Kommentars, unabhängig davon, wie viele einleitende Trennzeichen zwischen beiden stehen.

/* records the X and Y positions of 
the ball and bat movie clips */ 
var ballX:Number = ball_mc._x; 
var ballY:Number = ball_mc._y; 
var batX:Number = bat_mc._x; 
var batY:Number = bat_mc._y; 

/* This is an attempt to nest comments. 
/* But the first closing tag will be paired 
with the first opening tag */ 
and this text will not be interpreted as a comment */ 

Verwandte API-Elemente

 myXML = <{tagName} {attributeName} = {attributeValue}>{content}

Wertet einen Ausdruck aus, der in einem XML- oder XMLList-Initialisierer verwendet wird. Ein XML- oder XMLList-Initialisierer ist ein Literalwert, der einer Variablen des Typs XML oder XMLList zugewiesen ist. Ein Ausdruck, der von den XML-Operatoren { und } begrenzt ist, kann anstelle von Literalnamen oder Werten in einem XML- oder XMLList-Initialisierer verwendet werden. Ein Ausdruck kann anstelle von tagName, attributeName, attributeValue und content verwendet werden.

var tagname:String = "item"; 
var attributename:String = "id"; 
var attributevalue:String = "5"; 
var content:String = "Chicken"; 
var x:XML = <{tagname} {attributename}={attributevalue}>{content}</{tagname}>; 
trace(x.toXMLString()); // <item id="5">Chicken</item>

Verwandte API-Elemente

 myXML[expression]

Greift auf eine Eigenschaft oder ein Attribut eines XML- oder XMLList-Objekts zu. Der Klammern-Operator ermöglicht Ihnen den Zugriff auf Eigenschaftennamen, die mit dem Punkt-Operator (.) nicht zugänglich sind.

var myXML:XML = <a><foo-bar>44</foo-bar></a>;
trace(myXML["foo-bar"]);

Verwandte API-Elemente

Wertet zunächst expression1 aus, dann expression2 usw. Dieser Operator wird hauptsächlich in Verbindung mit der for-Schleifenanweisung und häufig zusammen mit dem Klammern-Operator () verwendet.

for (i = 0, j = 0; i < 3 && j < 3; i++, j+=2) { 
	trace("i = " + i + ", j = " + j); 
} 
// output: 
// i = 0, j = 0 
// i = 1, j = 2

var v:Number = 0; 
v = 4, 5, 6; 
trace(v); // 4 

var v:Number = 0; 
v = (4, 5, 6); 
trace(v); // 6 

var v:Number = 0; 
var z:Number = 0; 
v = v + 4 , z++, v + 6; 
trace(v); // 4 
trace(z); // 1 

var v:Number = 0; 
var z:Number = 0; 
v = (v + 4, z++, v + 6); 
trace(v); // 6 
trace(z); // 1 

Verwandte API-Elemente

Verkettet (verbindet) Strings. Wenn einer der Ausdrücke ein String ist, werden alle Ausdrücke in Strings umgewandelt und verkettet.

Wenn beide Ausdrücke Zahlen sind, verhält sich dieser Operator wie ein Additions-Operator.

var lastName:String = "Cola"; 
var instrument:String = "Drums"; 
trace(lastName + " plays " + instrument); // Cola plays Drums 

trace("Number " + 8 + 0); // Number 80

var a:String = 3 + 10 + "asdf"; 
trace(a); // 13asdf 
var b:String = "asdf" + 3 + 10; 
trace(b); // asdf310 

Verwandte API-Elemente

expression1 + expression2

Verkettet (verbindet) XML- oder XMLList-Werte in einem XMLList-Objekt. Ein XMLList-Objekt resultiert nur dann, wenn beide Operanden XML- oder XMLList-Werte sind.

var x1:XML = 
		<employee id = "42">
			<firstName>Joe</firstName>
			<lastName>Smith</lastName>
		</employee>;

var x2:XML = 
		<employee id = "43">
			<firstName>Susan</firstName>
			<lastName>Jones</lastName>
		</employee>;

var myXMLList:XMLList = x1 + x2;
	
trace(myXMLList.toXMLString()); 

Die Anweisung trace erzeugt die folgende Ausgabe:

<employee id = "42">
	<firstName>Joe</firstName>
	<lastName>Smith</lastName>
</employee>
<employee id = "43">
	<firstName>Susan</firstName>
	<lastName>Jones</lastName>
</employee>
	

Verwandte API-Elemente

Weist expression1 den Wert von expression1 + expression2 zu. Die folgenden Anweisungen sind beispielsweise gleichwertig:

x += y; 
x = x + y;

var x1:String = "My name is "; 
x1 += "Gilbert"; 
trace(x1); // My name is Gilbert 

Verwandte API-Elemente

expression1 += expression2

Weist expression1, ein XMLList-Objekt, den Wert von expression1 + expression2 zu. Die folgenden Anweisungen sind beispielsweise gleichwertig:

x += y; 
x = x + y; 

var x1:XML = <location>Athens</location>;	
var x2:XML = <location>Paris</location>;		
myXMLList = x1 + x2;

var x3:XML = <location>Springfield</location>;
myXMLList += x3;
		    
trace(myXMLList.toXMLString());

Die Anweisung trace erzeugt die folgende Ausgabe:

<location>Athens</location>
	
<location>Paris</location>	

<location>Springfield</location>

Verwandte API-Elemente

expression1 ? expression2 : expression3

Wertet expression1 aus. Wenn der Wert von expression1 gleich true ist, entspricht das Ergebnis dem Wert von expression2; andernfalls ist das Ergebnis der Wert von expression3.

var x:Number = 5; 
var y:Number = 10; 
var z = (x < 6) ? x: y; 
trace(z); // returns 5

var timecode:String = (new Date().getHours() < 11) ? "AM" : "PM"; 
trace(timecode); 

if (new Date().getHours() < 11) { 
	var timecode:String = "AM"; 
} else { 
	var timecode:String = "PM"; 
}
trace(timecode); 

--expression

expression--

Subtrahiert 1 vom Operanden. Der Operand kann eine Variable, ein Element in einem Array oder eine Objekteigenschaft sein. Die Prä-Dekrement-Form des Operators (--expression) subtrahiert 1 von expression und gibt das Ergebnis zurück. Die Post-Dekrement-Form des Operators (expression--) subtrahiert 1 von expression und gibt den Ausgangswert von expression (das Ergebnis vor der Subtraktion) zurück.

var x:Number = 3; 
var y:Number = --x; // y is equal to 2

var x:Number = 3; 
var y:Number = x--; // y is equal to 3

for (var i = 10; i > 0; i--) { 
	trace(i); 
}

 delete reference

Verwirft die durch reference angegebene Objekteigenschaft. Das Ergebnis ist true, wenn die Eigenschaft nach der vollständigen Ausführung des Vorgangs nicht mehr vorhanden ist, andernfalls false. Der delete-Operator gibt true zurück, wenn er eine nicht vorhandene Eigenschaft oder eine dynamische Eigenschaft, die nicht in einer Klasse definiert ist, aufruft.

Wenn der Parameter reference nicht gelöscht werden kann, schlägt der Operator delete möglicherweise fehl und es wird false zurückgegeben. Feste Eigenschaften oder Variablen, die mit der var-Anweisung deklariert wurden, können nicht gelöscht werden. Eine feste Eigenschaft ist eine Variable oder Methode, die in einer Klassendefinition definiert ist.

Der Operator delete kann nicht zum Löschen einer Klasseneigenschaft verwendet werden, es sei denn, es handelt sich um eine zur Laufzeit hinzugefügte dynamische Klasse. Die Eigenschaften versiegelter Klassen können nicht mit delete gelöscht werden. Setzen Sie die Eigenschaft stattdessen auf null.

Hinweis: Sie können ein Objekt nicht löschen, aber es durch einen Garbage Collector (Speichermanagement) entfernen lassen, indem Sie alle Verweise auf das Objekt entfernen. Der häufigste Verweis auf ein Objekt ist eine Variable, die auf dieses Objekt verweist. Sie können einen solchen Verweis löschen, indem Sie die Variable auf null setzen. Der Garbage Collector löscht alle Objekte, die keine Verweise enthalten.

// create the new object "account" 
var account:Object = new Object(); 
// assign property name to the account 
account.name = "Jon"; 
// delete the property 
delete account.name; 
trace(account.name); // undefined

// delete a nonexistent property
var fooDeleted:Boolean = delete account.foo;
trace(fooDeleted); // true

In dem folgenden Beispiel wird der Wert eines Array-Elements gelöscht, der Wert der Eigenschaft length aber nicht geändert:

var my_array:Array = new Array(); 
my_array[0] = "abc"; // my_array.length == 1 
my_array[1] = "def"; // my_array.length == 2 
my_array[2] = "ghi"; // my_array.length == 3 
// my_array[2] is deleted, but Array.length is not changed 
delete my_array[2]; 
trace(my_array.length); // 3 
trace(my_array); // abc,def,

Im folgenden Beispiel wird veranschaulicht, wie Sie den von delete zurückgegebenen booleschen Wert als eine Bedingung bei einer zukünftigen Codeausführung verwenden können. Hinweis: Wenn ein Element bereits gelöscht wurde, führt das erneute Aufrufen von delete zur Rückgabe von false.

var my_array:Array = [ "abc", "def", "ghi" ];
var deleteWasSuccessful:Boolean

deleteWasSuccessful = delete my_array[0];
if(deleteWasSuccessful) delete my_array[1];
deleteWasSuccessful = delete my_array[0];
if(deleteWasSuccessful) delete my_array[2];

trace(my_array) // outputs: undefined,undefined,ghi

Verwandte API-Elemente

 delete reference

Löscht die XML-Elemente oder -Attribute, die durch reference angegeben werden.

 
var x1:XML = <x1>
				<a id = "52">AYY</a>
				<a>AYY 2 </a>
				<b>BEE</b>
				<c>CEE</c>
			</x1>;

trace(x1.toXMLString());
trace("___________");

delete x1.a.@id;

trace(x1.toXMLString());
trace("___________");

delete x1.b;

trace(x1.toXMLString());
trace("___________");

delete x1.a;

trace(x1.toXMLString());

Dies erzeugt die folgende Ausgabe:

<x1>
  <a id="52">AYY</a>
  <a>AYY 2</a>
  <b>BEE</b>
  <c>CEE</c>
</x1>
___________
<x1>
  <a>AYY</a>
  <a>AYY 2</a>
  <b>BEE</b>
  <c>CEE</c>
</x1>
___________
<x1>
  <a>AYY</a>
  <a>AYY 2</a>
  <c>CEE</c>
</x1>
___________
<x1>
  <c>CEE</c>
</x1>

 
var xml:XML = 
			<order>
				<item id="121">hamburger</item>
				<item id="122">fries</item>
				<item id="123">chocolate shake</item>
			</order>;
delete xml.item[1].*;
delete xml.item[1].@*;
trace(xml);

Die Ausgabe für dieses Beispiel ist:

<order>
  <tem id="121">hamburger</item>
  <item/>
  <item id="123">chocolate shake</item>
</order>

 myXML..childElement1..@attributeName 

Navigiert zu den untergeordneten Elementen eines XML- oder XMLList-Objekts oder findet (in Verbindung mit dem @-Operator) die Attribute der untergeordneten Elemente. Die übereinstimmenden Elemente oder Attribute müssen dem XML- oder XMLList-Objekt nicht direkt untergeordnet sein, sie können sich auch auf einer niedrigeren Stufe in der Struktur befinden. Das Ergebnis ist ein XMLList-Objekt, da mehrere untergeordnete Elemente oder Attribute übereinstimmen können.

Die Reihenfolge der Knoten im zurückgegebenen XMLList-Objekt ist das Ergebnis der vorrangigen Tiefenprüfung. Berücksichtigen Sie beispielsweise Folgendes:

var myXML:XML = <a>
			<b>one
				<c> 
					<b>two</b> 
				</c> 
			</b>
			<b>three</b>
		</a>;

trace(myXML..b[0].toXMLString());
trace("______________");
trace(myXML..b[1].toXMLString());
trace("______________");
trace(myXML..b[2].toXMLString());

Dies erzeugt die folgende Ausgabe:

<b>
  one
  <c>
    <b>two</b>
  </c>
</b>
______________
<b>two</b>
______________
<b>three</b>

Um Nachfolger mit Namen zurückzugeben, die in ActionScript reservierten Worten entsprechen, verwenden Sie im XML-Code die Methode XML.descendants() anstelle des Nachfolger-Operators (.). Dies wird in dem folgenden Beispiel veranschaulicht:

var xml:XML = 
<enrollees>
	<student id="239">
		<class name="Algebra" />
 		<class name="Spanish 2"/>
	</student>
	<student id="206">
		<class name="Trigonometry" />
 		<class name="Spanish 2" />
	</student>
 </enrollees>;
 trace(xml.descendants("class")); 
 

var myXML:XML = 
	<employees>
		<employee id = "42">
			<firstName>Billy</firstName>
			<lastName>Einstein</lastName>
		</employee>
		<employee id = "43">
			<firstName>Sally</firstName>
			<lastName>Shostakovich</lastName>
		</employee>
	</employees>
	
trace(myXML..firstName); 
	// <firstName>Billy</firstName>
	// <firstName>Sally</firstName>
				
trace(myXML..@id); //4243

Verwandte API-Elemente

Dividiert expression1 durch expression2. Das Ergebnis der Division ist eine Gleitkommazahl mit doppelter Genauigkeit.

trace(3/0);   // Infinity
trace(-3/0);  // -Infinity
trace(0/0);   // NaN

Verwandte API-Elemente

Weist expression1 den Wert von expression1 / expression2 zu. Die beiden folgenden Anweisungen beispielsweise sind austauschbar:

x /= y; 
x = x / y;

var a:Number = 10; 
var b:Number = 2; 
a /= b; trace(a); // 5 

Verwandte API-Elemente

object.property_or_method

Dieser Operator greift auf die Variablen und Methoden einer Klasse zu, ruft Objekteigenschaften ab bzw. setzt sie und begrenzt importierte Pakete oder Klassen.

import flash.utils.Timer;

var obj:Object = new Object();
obj.propertyA = "hello";
trace(obj.propertyA);  // hello

Verwandte API-Elemente

myXML.childElement
myXML.@attributeName 

Navigiert zu den untergeordneten Elementen eines XML- oder XMLList-Objekts oder gibt (in Verbindung mit dem @-Operator) die Attribute eines XML- oder XMLList-Objekts zurück. Das zurückgegebene Objekt ist ein XMLList-Objekt, da mehrere untergeordnete Elemente oder Attribute übereinstimmen können.

Um Elemente mit Namen zurückgeben zu können, die in ActionScript reservierten Worten entsprechen, verwenden Sie im XML-Code die Methode XML.elements() oder die Methode XML.descendants() anstelle des XML-Punkt-Operators (.). Dies wird in dem folgenden Beispiel veranschaulicht:

var xml:XML = 
	<student id="206">
		<class name="Trigonometry" />
		<class name="Spanish 2" />
	</student>;
trace(xml.elements("class"));
trace(xml.descendants("class")); 

var myXML:XML = 
	<employee id = "42">
		<firstName>Billy</firstName>
		<lastName>Einstein</lastName>
	</employee>;

trace(myXML.firstName); // Billy
trace(myXML.@id);       // 42

Verwandte API-Elemente

Prüft zwei Ausdrücke auf Gleichheit. Das Ergebnis ist true, wenn die Ausdrücke gleich sind.

Wenn die Datentypen zweier Operanden übereinstimmen, hängt die Definition von „gleich“ vom Datentyp der Operanden ab:

• Werte mit den Datentypen „int“, „uint“ und „Boolean“ werden als gleich angesehen, wenn sie den gleichen Wert aufweisen.
• Zahlen mit gleichen Werten werden als gleich angesehen, es sei denn, sie sind beide NaN.
• Wenn der Wert beider Operanden null oder undefined lautet, werden sie als gleich angesehen.
• Stringausdrücke sind gleich, wenn sie dieselbe Anzahl von Zeichen enthalten und die Zeichen identisch sind.
• XML-Objekte:
  • Wenn ein Operand ein Text- oder Attributknoten ist und der andere Operand einfachen Inhalt enthält, werden beide Operanden mit der toString()-Methode in Strings konvertiert und als gleich angesehen, wenn die resultierenden Strings übereinstimmen.
  • Andernfalls werden die Objekte nur dann als gleich angesehen, wenn der qualifizierende Name, Attribute und untergeordnete Eigenschaften beider Objekte übereinstimmen.
• XMLList-Objekte werden als gleich angesehen, wenn sie die gleiche Anzahl an Eigenschaften aufweisen und die Reihenfolge und die Werte der Eigenschaften beider Objekte übereinstimmen.
• Bei Namespace-Objekten werden die Werte als gleich angesehen, wenn die uri-Eigenschaften beider Objekte übereinstimmen.
• Bei QName-Objekten werden die Werte als gleich angesehen, wenn die uri-Eigenschaften beider Objekte übereinstimmen und die localName-Eigenschaften beider Objekte übereinstimmen.
• Variablen, die Objekte, Arrays und Funktionen darstellen, werden anhand ihrer Referenzen verglichen. Zwei Variablen sind gleich, wenn sie auf dasselbe Objekt, dasselbe Array oder dieselbe Funktion verweisen. Zwei separate Arrays gelten nie als gleich, selbst wenn sie dieselbe Anzahl von Elementen aufweisen.

• Die Werte der Operanden lauten undefined und null. In diesem Fall ist das Ergebnis true.
• Die automatische Datentypkonvertierung wandelt Datentypen mit den Werten „String“, „Boolean“, „int“, „uint“ und „Number“ in kompatible Datentypen um. Die umgewandelten Werte sind gleich; in diesem Fall werden die Operanden als gleich angesehen.
• Ein Operand hat den Typ „XML“ mit einfachem Inhalt (hasSimpleContent() == true). Nachdem beide Operanden mit der toString()-Methode in Strings umgewandelt wurden, sind die resultierenden Strings gleich.
• Ein Operand hat den Typ „XMLList“, und eine der folgenden Bedingungen trifft zu:
  • Die length-Eigenschaft des XMLList-Objekts ist 0 und das andere Objekt ist undefined.
  • Die length-Eigenschaft des XMLList-Objekts ist 1, und das andere Element des XMLList-Objekts stimmt mit dem anderen Operanden überein.

var a:String = "David"
var b:String = "David"; 
if (a == b) { 
	trace("David is David"); 
} 

var a:Number = 5; 
var b:String = "5"; 
trace(a == b); // true

var c:Number = 1; 
var d:Boolean = true; 
trace(c == d); // true
var e:Number = 0; 
var f:Boolean = false; 
trace(e == f); // true

var g:String = "true";
var h:Boolean = true;
trace(g == h); // false

var firstArray:Array = new Array("one", "two", "three"); 
var secondArray:Array = new Array("one", "two", "three"); 
trace(firstArray == secondArray); // false 
/* Arrays are only considered equal 
if the variables refer to the same array. */
var thirdArray:Array = firstArray; 
trace(firstArray == thirdArray); // true 

Verwandte API-Elemente

Vergleicht zwei Ausdrücke und stellt fest, ob expression1 größer als expression2 ist. Ist dies der Fall, lautet das Ergebnis true. Wenn expression1 kleiner oder gleich expression2 ist, lautet das Ergebnis false.

Wenn beide Operanden den Datentyp „String“ aufweisen, werden die Operanden in alphabetischer Reihenfolge ausgewertet. Großbuchstaben haben Vorrang vor Kleinbuchstaben. Andernfalls werden die Operanden zunächst in Zahlen umgewandelt und dann verglichen.

var a:String = "first";
var b:String = "First";
trace(a > b); // true

var c:Number = 5;
var d:String = "4";
trace(c > d); // true

var e: Number = 2;
var f:Boolean = true;
trace(e > f); // true

Vergleicht zwei Ausdrücke und stellt fest, ob expression1 größer oder gleich expression2 (true) oder ob expression1 kleiner als expression2 (false) ist.

if (new Date().getHours() >= 12) { 
	trace("good afternoon"); 
} else { 
	trace("good morning"); 
}

Verwandte API-Elemente

Wertet aus, ob eine Eigenschaft ein Teil eines bestimmten Objekts ist. Um den in-Operator verwenden zu können, geben Sie einen Eigenschaftsnamen als ersten Operanden und ein Objekt als zweiten Operanden an. Wenn das von Ihnen angegebene Objekt eine solche Eigenschaft enthält, ist das Ergebnis true, andernfalls false.

Handelt es sich bei dem angegebenen Objekt um ein Array-Objekt, können Sie mit dem Operator in überprüfen, ob eine bestimmte Indexzahl gültig ist. Wenn Sie eine Ganzzahl als ersten Operanden übergeben, ist das Ergebnis true, wenn die Indexposition innerhalb des gültigen Bereichs von Indexpositionszahlen liegt, andernfalls false.

trace("PI" in Math);         // true
trace("myProperty" in Math); // false

Der folgende Beispielcode zeigt mit dem Operator in an, dass die Zahlen 0, 1 und 2 gültige Indexpositionszahlen im myArray-Objekt sind, die Zahl 3 jedoch nicht.

public var myArray:Array = ["zero", "one", "two"];
trace(0 in myArray); // true
trace(1 in myArray); // true
trace(2 in myArray); // true
trace(3 in myArray); // false

Verwandte API-Elemente

++expression

 expression++

Addiert 1 zu einem Ausdruck. Der Ausdruck kann eine Variable, ein Element in einem Array oder eine Objekteigenschaft sein. Die Prä-Inkrement-Form des Operators (++expression) addiert 1 zu expression und gibt das Ergebnis zurück. Die Post-Inkrement-Form des Operators (expression++) addiert 1 zu expression und gibt den Anfangswert von expression (das Ergebnis vor der Addition) zurück.

var preInc:Array = new Array(); 
var i:int = 0; 
while (i < 10) { 
    preInc.push(++i); 
} 
trace(preInc); // 1,2,3,4,5,6,7,8,9,10 

 
var postInc:Array = new Array(); 
var i:int = 0; 
while (i < 10) { 
   postInc.push(i++); 
} 
trace(postInc); // 0,1,2,3,4,5,6,7,8,9 

var i:int = 0; 
while (i++ < 5) { 
	trace("this is execution " + i); 
} 
/* output: 
   this is execution 1 
   this is execution 2 
   this is execution 3 
   this is execution 4 
   this is execution 5 
*/

Prüft auf das Gegenteil des Gleichheitsoperators (==). Wenn expression1 gleich expression2 ist, lautet das Ergebnis false. Wie auch beim Gleichheitsoperator (==) hängt die Definition von „gleich“ von den verglichenen Datentypen ab.

Wenn die Datentypen zweier Operanden übereinstimmen, hängt die Definition von „gleich“ vom Datentyp der Operanden ab:

• Werte mit den Datentypen „int“, „uint“ und „Boolean“ werden als gleich angesehen, wenn sie den gleichen Wert aufweisen.
• Zahlen mit gleichen Werten werden als gleich angesehen, es sei denn, sie sind beide NaN.
• Wenn der Wert beider Operanden null oder undefined lautet, werden sie als gleich angesehen.
• Stringausdrücke sind gleich, wenn sie dieselbe Anzahl von Zeichen enthalten und die Zeichen identisch sind.
• XML-Objekte:
  • Wenn ein Operand ein Text- oder Attributknoten ist und der andere Operand einfachen Inhalt enthält, werden beide Operanden mit der toString()-Methode in Strings konvertiert und als gleich angesehen, wenn die resultierenden Strings übereinstimmen.
  • Andernfalls werden die Objekte nur dann als gleich angesehen, wenn der qualifizierende Name, Attribute und untergeordnete Eigenschaften beider Objekte übereinstimmen.
• XMLList-Objekte werden als gleich angesehen, wenn sie die gleiche Anzahl an Eigenschaften aufweisen und die Reihenfolge und die Werte der Eigenschaften beider Objekte übereinstimmen.
• Bei Namespace-Objekten werden die Werte als gleich angesehen, wenn die uri-Eigenschaften beider Objekte übereinstimmen.
• Bei QName-Objekten werden die Werte als gleich angesehen, wenn die uri-Eigenschaften beider Objekte übereinstimmen und die localName-Eigenschaften beider Objekte übereinstimmen.
• Variablen, die Objekte, Arrays und Funktionen darstellen, werden anhand ihrer Referenzen verglichen. Zwei Variablen sind gleich, wenn sie auf dasselbe Objekt, dasselbe Array oder dieselbe Funktion verweisen. Zwei separate Arrays gelten nie als gleich, selbst wenn sie dieselbe Anzahl von Elementen aufweisen.

• Die Werte der Operanden lauten undefined und null. In diesem Fall ist das Ergebnis true.
• Die automatische Datentypkonvertierung wandelt Datentypen mit den Werten „String“, „Boolean“, „int“, „uint“ und „Number“ in kompatible Datentypen um. Die umgewandelten Werte sind gleich; in diesem Fall werden die Operanden als gleich angesehen.
• Ein Operand hat den Typ „XML“ mit einfachem Inhalt (hasSimpleContent() == true). Nachdem beide Operanden mit der toString()-Methode in Strings umgewandelt wurden, sind die resultierenden Strings gleich.
• Ein Operand hat den Typ „XMLList“, und eine der folgenden Bedingungen trifft zu:
  • Die length-Eigenschaft des XMLList-Objekts ist 0 und das andere Objekt ist undefined.
  • Die length-Eigenschaft des XMLList-Objekts ist 1, und das andere Element des XMLList-Objekts stimmt mit dem anderen Operanden überein.

trace(5 != 8); // true 
trace(5 != 5); // false 

var a:String = "David";
var b:String = "Fool";
if (a != b) { 
	trace("David is not a fool"); 
}

var a:Function = function() { trace("foo"); }; 
var b:Function = function() { trace("foo"); }; 
a(); // foo 
b(); // foo 
trace(a != b); // true 
a = b; 
a(); // foo 
b(); // foo 
trace(a != b); // false

var a:Array = [ 1, 2, 3 ]; 
var b:Array = [ 1, 2, 3 ]; 
trace(a);      // 1,2,3 
trace(b);      // 1,2,3 
trace(a != b); // true 
a = b; 
trace(a);      // 1,2,3 
trace(b);      // 1,2,3 
trace(a != b); // false

Verwandte API-Elemente

Wertet aus, ob die Prototypkette eines Ausdrucks das Prototypobjekt für function enthält. Der Operator instanceof ist aus Gründen der Abwärtskompatibiliät mit ECMAScript Edition 3 weiterhin vorhanden, kann aber auch von erfahrenen Programmierern eingesetzt werden, die die Prototyp-Vererbung mit Konstruktorfunktionen statt Klassen verwenden möchten.

Mit dem Operator is können Sie überprüfen, ob ein Objekt ein Mitglied eines bestimmten Datentyps ist.

Bei der Verwendung von Klassen ist der Operator instanceof vergleichbar mit dem Operator is, da die Prototypkette einer Klasse sämtliche übergeordneten Klassen enthält. Schnittstellen sind jedoch nicht in Prototypketten enthalten. Daher führt der Operator instanceof immer zum Ergebnis false, wenn er mit Schnittstellen verwendet wird. Der Operator is führt hingegen zum Ergebnis true, wenn ein Objekt einer Klasse angehört, die die angegebene Schnittstelle implementiert.

Hinweis: Der ActionScript-Operator is ist ein Äquivalent des Java-Operators instanceof.

var mySprite:Sprite = new Sprite();
trace(mySprite instanceof Sprite);        // true
trace(mySprite instanceof DisplayObject); // true

var mySprite:Sprite = new Sprite();
trace(mySprite instanceof IBitmapDrawable); // false
trace(mySprite is IBitmapDrawable);         // true

Verwandte API-Elemente

Wertet aus, ob ein Objekt mit einem bestimmten Datentyp, einer Klasse oder Schnittstelle kompatibel ist. Verwenden Sie für Vergleiche des Datentyps den Operator is anstelle des Operators instanceof. Sie können auch den Operator is verwenden, um zu überprüfen, ob ein Objekt eine Schnittstelle implementiert.

import flash.display.*;
import flash.events.IEventDispatcher;

var mySprite:Sprite = new Sprite();
trace(mySprite is Sprite);           // true
trace(mySprite is DisplayObject);    // true
trace(mySprite is IEventDispatcher); // true

Verwandte API-Elemente

Vergleicht zwei Ausdrücke und stellt fest, ob expression1 kleiner ist als expression2. Ist dies der Fall, lautet das Ergebnis true. Wenn expression1 größer oder gleich expression2 ist, lautet das Ergebnis false.

Wenn beide Operanden den Datentyp „String“ aufweisen, werden die Operanden in alphabetischer Reihenfolge ausgewertet. Großbuchstaben haben Vorrang vor Kleinbuchstaben. Andernfalls werden die Operanden zunächst in Zahlen umgewandelt und dann verglichen.

trace(5 < 10); // true 
trace(2 < 2);            // false 
trace(10 < 3);           // false 
trace("Allen" < "Jack"); // true 
trace("Jack" < "Allen"); // false 
trace("11" < "3");       // true 
trace("11" < 3);         // false (numeric comparison) 
trace("C" < "abc");      // true 
trace("A" < "a");        // true 

Vergleicht zwei Ausdrücke und stellt fest, ob expression1 kleiner als oder gleich expression2 ist. Ist dies der Fall, lautet das Ergebnis true. Wenn expression1 größer als expression2 ist, lautet das Ergebnis false.

Wenn beide Operanden den Datentyp „String“ aufweisen, werden die Operanden in alphabetischer Reihenfolge ausgewertet. Großbuchstaben haben Vorrang vor Kleinbuchstaben. Andernfalls werden die Operanden zunächst in Zahlen umgewandelt und dann verglichen.

trace(5 <= 10); // true 
trace(2 <= 2);            // true 
trace(10 <= 3);           // false 
trace("Allen" <= "Jack"); // true 
trace("Jack" <= "Allen"); // false 
trace("11" <= "3");       // true 
trace("11" <= 3);         // false (numeric comparison) 
trace("C" <= "abc");      // true 
trace("A" <= "a");        // true 

Kennzeichnet den Beginn eines Skriptkommentars. Text, der zwischen dem Kommentartrennzeichen (//) und dem Zeilenendezeichen steht, wird als Kommentar interpretiert und ignoriert. Verwenden Sie dieses Trennzeichen für einzeilige Kommentare. Für Kommentare in mehreren aufeinander folgenden Zeilen verwenden Sie die Trennzeichen /* und */.

// Any text following a line comment delimiter is ignored during compilation

Verwandte API-Elemente

Gibt expression1 zurück, wenn es false ist oder in false umgewandelt werden kann, andernfalls expression2. Beispiele für Werte, die in false konvertiert werden können, sind 0, NaN, null und undefined. Wenn Sie einen Funktionsaufruf als expression2 verwenden, wird die Funktion nicht aufgerufen, solange expression1 den Wert false ergibt.

Wenn beide Operanden booleschen Typs sind, ist das Ergebnis nur dann true, wenn beide Operanden true sind. Dies wird in der folgenden Tabelle verdeutlicht:

var turns:Number = 2; 
var score:Number = 77; 
if ((turns <= 3) && (score >= 75)) { 
	trace("You Win the Game!"); 
} else { 
	trace("Try Again!"); 
} 

Verwandte API-Elemente

Weist expression1 den Wert von expression1 && expression2 zu. Die beiden folgenden Anweisungen beispielsweise sind austauschbar:

x &&= y; 
x = x && y;