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; 

var myVar:String = 'tag';
			myVar &&= "<" + myVar + "/>";
			trace (myVar); // output: <tag/>

var myVar:String = 'tag';
			if (myVar != '') {
			  myVar = "<" + myVar + "/>";
			}
			trace (myVar); // output: <tag/>

Verwandte API-Elemente

Kehrt den booleschen Wert einer Variablen oder eines Ausdrucks um. Ist expression eine Variable mit dem absolute bzw. konvertierten Wert von true, so hat !expression den Wert false. Wenn der Ausdruck x && y als false evaluiert wird, wird der Ausdruck !(x && y) als true gewertet.

Die folgenden Ausdrücke veranschaulichen die Verwendung des logischen NOT-Operators (!):

• !true gibt false zurück.
• !false gibt true zurück.

var happy:Boolean = false; 
if (!happy) { 
	trace("don't worry, be happy"); // don't worry, be happy 
} 

Verwandte API-Elemente

Gibt expression1 zurück, wenn es true ist oder in true umgewandelt werden kann, andernfalls expression2. Wenn Sie einen Funktionsaufruf als expression2 verwenden, wird die Funktion nicht aufgerufen, solange expression1 den Wert true ergibt.

Wenn beide Operanden booleschen Typs sind, ist das Ergebnis nur dann true, wenn ein oder beide Ausdrücke true sind. Das Ergebnis ist nur dann false, wenn beide Ausdrücke den Wert false ergeben. Dies wird in der folgenden Tabelle verdeutlicht:

var a:Number = 10; 
var b:Number = 250; 
var start:Boolean = false; 
if ((a > 25) || (b > 200) || (start)) { 
    trace("the logical OR test passed"); // the logical OR test passed 
} 

Das folgende Beispiel veranschaulicht, wie die Verwendung eines Funktionsaufrufs für den zweiten Operanden zu unerwarteten Ergebnissen führen kann. Wenn der Ausdruck links neben dem Operator true ergibt, wird dieses Ergebnis ohne die Auswertung des Ausdrucks auf der rechten Seite zurückgegeben (d. h. die Funktion fx2() wird nicht aufgerufen).

function fx1():Boolean { 
	trace("fx1 called"); 
	return true; 
} 
function fx2():Boolean { 
	trace("fx2 called"); 
	return true; 
} 
if (fx1() || fx2()) { 
	trace("IF statement entered");
}

Verwandte API-Elemente

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

x ||= y; 
x = x || y; 

myVar ||= "default";

Verwandte API-Elemente

Berechnet den Rest einer Division von expression1 geteilt durch expression2. Wenn einer der Operanden nicht numerisch ist, versucht der Modulo-Operator (%), ihn in eine Zahl umzuwandeln.

Das Vorzeichen des Modulo-Ergebnisses entspricht dem Vorzeichen des Dividenden (also der ersten Zahl). Beispiel: Sowohl -4 % 3 als auch -4 % -3 ergeben beide -1.

trace(12 % 5);    // 2 
trace(4.3 % 2.1); // 0.0999999999999996 
trace(4 % 4);     // 0 

Verwandte API-Elemente

Weist expression1 den Wert von expression1 % expression2 zu. Die folgenden beiden Anweisungen sind gleichwertig:

x %= y; 
x = x % y; 

var a:Number = 14; 
var b:Number = 5; 
a %= b;
trace(a); // 4 

Verwandte API-Elemente

Multipliziert zwei numerische Ausdrücke. Wenn beide Ausdrücke Ganzzahlen sind, ist das Produkt eine Ganzzahl. Wenn einer oder beide Ausdrücke Gleitkommazahlen sind, ist das Produkt eine Gleitkommazahl.

trace(2*3); // 6 

trace(2.0 * 3.1416); // 6.2832 

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

x *= y 
x = x * y 

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

var i:Number = 5; 
var c:Number = 4 - 6; 
var d:Number = i + 2; 
trace(c *= d); // -14 

Verwandte API-Elemente

namespace::property

namespace::method()

namespace::xmlObject.property

namespace::xmlObject.@attribute

Identifiziert den Namespace einer Eigenschaft, einer Methode, einer XML-Eigenschaft oder eines XML-Attributs.

public class NamespaceExample extends Sprite {
	public namespace French;
	public namespace Hawaiian;
	public function NamespaceExample() {
		trace(Hawaiian::hello()); // aloha
		trace(French::hello()); // bonjour
	}
    Hawaiian function hello():String {
        return "aloha";
    }

    French function hello():String { 
        return "bonjour";
    }
}

var soap:Namespace = new Namespace("http://schemas.xmlsoap.org/wsdl/soap/");
var w:Namespace = new Namespace("http://weather.example.org/forecast");
var myXML:XML = 
	<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"> 
	 <soap:Body>
	  <w:forecast xmlns:w="http://weather.example.org/forecast">
	   <w:city>Quito</w:city>
	   <w:country>Ecuador</w:country>
	   <date>2006-01-14</date>
	  </w:forecast>
	  </soap:Body>
	</soap:Envelope>;
	
trace(myXML.soap::Body.w::forecast.w::city); // Quito

Verwandte API-Elemente

Dieser Operator instanziiert eine Klasseninstanz. Der Operator new kann mit einer Klasse oder einer Variablen des Typs „Class“ verwendet werden, um eine Instanz einer Klasse zu erstellen. Im Allgemeinen wird der Operator new mit einem Klassenobjekt verwendet, um eine Instanz einer Klasse zu erstellen. Beispielsweise erstellt die Anweisung new Sprite() eine Instanz der Sprite-Klasse.

Darüber hinaus kann eine Klasse mit dem Operator new mit einem eingebetteten Bestand verknüpft werden. Dies kann eine Grafik, ein Sound oder eine Schrift sein, die in einer SWF-Datei kompiliert ist. Jeder eingebettete Bestand wird durch eine einmalige eingebettete Bestandklasse repräsentiert. Um auf einen eingebetteten Bestand zugreifen zu können, müssen Sie den Operator new verwenden, damit die verknüpfte Klasse instanziiert wird. Anschließend können Sie geeignete Methoden und Eigenschaften der eingebetteten Bestandsklasse aufrufen, um den eingebetteten Bestand zu bearbeiten.

Wenn Sie Klassen mit Function-Objekten anstelle des Schlüsselworts class definieren möchten, können Sie mit dem Operator new Objekte basierend auf Konstruktorfunktionen erstellen. Verwechseln Sie Konstruktorfunktionen jedoch nicht mit den Konstruktormethoden einer Klasse. Eine Konstruktorfunktion ist ein Function-Objekt, das mit dem Schlüsselwort function definiert wird, das aber kein Teil einer Klassendefinition ist. Wenn Sie Konstruktorfunktionen zum Erstellen von Objekten verwenden, müssen Sie die prototype-Vererbung anstelle der class-Vererbung verwenden.

class Book {
  var bName:String;
  var bPrice:Number;
  
  public function Book(nameParam:String, priceParam:Number){
    bName = nameParam;
    bPrice = priceParam;
  }
}

var book1:Book = new Book("Confederacy of Dunces", 19.95);
var book2:Book = new Book("The Floating Opera", 10.95);
trace(book1); // [object Book]

var golfCourse:Array = new Array(18);

Verwandte API-Elemente

object = {name1 : value1, name2 : value2,... nameN : valueN}

Erstellt ein neues Objekt und initialisiert es mit den angegebenen Eigenschaftspaaren aus name und value. Die Verwendung dieses Operators entspricht dem Aufruf von new Object und dem anschließendem Zuweisen der Eigenschaftspaare mithilfe des Zuweisungs-Operators. Der Prototyp des neu erstellten Objekts wird allgemein als Object-Objekt bezeichnet.

Mithilfe dieses Operators können auch Blöcke von aufeinander folgenden Codezeilen markiert werden, die mit Anweisungen und Funktionen zur Ablaufsteuerung (for, while, if, else, switch) verknüpft sind.

var object:Object = {}; 
var object:Object = new Object(); 

var account:Object = {name:"Adobe Systems, Inc.", address:"601 Townsend Street", city:"San Francisco", state:"California", zip:"94103", balance:"1000"}; 
for (i in account) { 
	trace("account."+i+" = "+account[i]); 
} 

var person:Object = {name:"Gina Vechio", children:["Ruby", "Chickie", "Puppa"]}; 

var person:Object = new Object(); 
person.name = "Gina Vechio"; 
person.children = new Array(); 
person.children[0] = "Ruby"; 
person.children[1] = "Chickie"; 
person.children[2] = "Puppa"; 

Verwandte API-Elemente

(expression1[, expression2])

(expression1, expression2)

function(parameter1,..., parameterN) 

Führt eine Gruppierungsoperation mit mindestens einem Parameter bzw. eine sequentielle Auswertung von Ausdrücken durch oder umgibt mindestens einen Parameter und übergibt diesen als Argument an eine Funktion, die vor den runden Klammern steht.

Verwendung 1: Legt die Reihenfolge fest, in der die Operatoren ausgeführt werden. Runde Klammern setzen die automatische Rangfolge außer Kraft und bewirken, dass die Ausdrücke in Klammern zuerst ausgewertet werden. Bei verschachtelten Klammern wird der Inhalt der inneren Klammern vor dem Inhalt der äußeren Klammern ausgewertet.

Verwendung 2: Wertet eine Reihe von durch Kommata abgetrennten Ausdrücken der Reihe nach aus und gibt das Ergebnis des endgültigen Ausdrucks zurück.

Verwendung 3: Umgibt mindestens einen Parameter und übergibt diesen an die Funktion, die vor den runden Klammern steht.

trace((2 + 3) * (4 + 5)); // 45 
trace(2 + (3 * (4 + 5))); // 29
trace(2 + (3 * 4) + 5);   // 19
trace(2 + (3 * 4) + 5);   // 19

var a:Number = 1; 
var b:Number = 2; 
function foo() { 
  a += b; 
} 
function bar() { 
  b *= 10; 
} 
trace((foo(), bar(), a + b)); // 23 

var today:Date = new Date(); 
trace(today.getFullYear()); // outputs current year 
function traceParameter(param):void { 
  trace(param); 
} 
traceParameter(2 * 2); // 4 

Verwandte API-Elemente

myXML.(expression)

Wertet einen Ausdruck in einem ECMAScript für XML (E4X) XML-Konstrukt aus. Beispielsweise identifiziert myXML.(lastName == "Smith") XML-Elemente mit der Bezeichnung lastName und dem Wert "Smith". Das Ergebnis ist ein XMLList-Objekt.

var myXML:XML = 
	<employees>
		<employee id = "42">
			<firstName>Joe</firstName>
			<lastName>Smith</lastName>
		</employee>
		<employee id = "43">
			<firstName>Susan</firstName>
			<lastName>Jones</lastName>
		</employee>
		<employee id = "44">
			<firstName>Anne</firstName>
			<lastName>Smith</lastName>
		</employee>
	</employees>;
	
trace(myXML.employee.(lastName == "Smith").@id.toXMLString()); 
	// 42
	// 44
                
trace(myXML.employee.(Number(@id) > 42).@id.toXMLString()); 
	// 43
	// 44

Verwandte API-Elemente

/pattern/flags

Wenn Sie diesen Operator vor und nach einer Zeichenfolge eingeben, kennzeichnen Sie, dass es sich dabei um einen Literalwert handelt, der als ein regulärer Ausdruck (RegExp) betrachtet wird und nicht um eine Zeichenfolge, eine Variable oder ein anderes ActionScript-Element. Achten Sie jedoch darauf, dass zwei aufeinander folgende Schrägstriche (//) den Beginn eines Kommentars kennzeichnen.

var myRegExp:RegExp = /foo-\d+/i; 
trace(myRegExp.exec("ABC Foo-32 def.")); // Foo-32 

Verwandte API-Elemente

Überprüft zwei Ausdrücke auf Gleichheit, führt aber keine automatische Datenkonvertierung durch. Das Ergebnis ist true, wenn die beiden Ausdrücke, einschließlich Datentypen, gleich sind.

Der strikte Ungleichheitsoperator (===) arbeitet in dreierlei Hinsicht genau wie der Gleichheitsoperator (==):

• Zahlen und boolesche Werte werden anhand ihres Werts verglichen und gelten als gleich, wenn sie den gleichen Wert haben.
• Stringausdrücke sind gleich, wenn sie dieselbe Anzahl von Zeichen enthalten und die Zeichen identisch sind.
• 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.

• Der strikte Gleichheitsoperator führt automatische Datenkonvertierungen nur für die Zahlentypen („Number“, „int“ und „uint“) durch, während der Gleichheits-Operator bei allen primitiven Datentypen automatische Datenkonvertierungen vornimmt.
• Beim Vergleich von null und undefined gibt der strikte Gleichheitsoperator den Wert false zurück.

Zum einen geben Vergleiche zwischen Grundwerten und Grundobjekten, die den gleichen Wert enthalten, in ActionScript 3.0 true, und in früheren Versionen von ActionScript false zurück. In früheren Versionen ist der Datentyp eines Grundwerts entweder „Boolean“, „Number“ oder „String“, während der Datentyp eines Grundobjekts immer „Object“ und nicht „Boolean“, „Number“ oder „String“ ist. Eine praktische Auswirkung dieses Unterschieds besteht darin, dass der folgende Code in früheren Versionen von ActionScript als false ausgewertet wird, da die Datentypen der Operanden nicht übereinstimmen, das Ergebnis in ActionScript 3.0 jedoch true lautet, da die Grundwerte entweder als „Boolean“, „Number“, „int“, „uint“ oder „String“ typisiert sind, je nachdem, ob sie ein Wrapper-Objekt darstellen oder nicht.

var num1:Number = 1;
var num2:Number = new Number(1);
trace(num1 === num2); // true in ActionScript 3.0, false in ActionScript 2.0
			

var num1:Number = new Number(1);
var num2:Number = new Number(1);
trace(num1 == num2);  // true in ActionScript 3.0, false in ActionScript 2.0
trace(num1 === num2); // true in ActionScript 3.0, false in ActionScript 2.0

var string1:String = "5"; 
var string2:String = "5"; 
trace(string1 == string2);  // true 
trace(string1 === string2); // true

// The equality (==) operator converts 5 to "5", but the strict equality operator does not
var string1:String = "5"; 
var num:Number = 5; 
trace(string1 == num);  // true 
trace(string1 === num); // false 

var num:Number = 1;
var bool:Boolean = true;
trace(num == bool);  // true 
trace(num === bool); // false

var num1:Number = 1;
var num2:int = 1;
var num3:uint = 1;
trace(num1 === num2); // true
trace(num1 === num3); // true

trace(null == undefined);  // true 
trace(null === undefined); // false 

Verwandte API-Elemente

Prüft auf das Gegenteil des Gleichheitsoperators (===). Der strikte Ungleichheitsoperator bewirkt das Gleiche wie der Ungleichheitsoperator, es werden jedoch nur die Datentypen und umgewandelt.

Wenn expression1 gleich expression2 ist und die Datentypen übereinstimmen, lautet das Ergebnis false.

Der strikte Ungleichheitsoperator (!==) arbeitet in dreierlei Hinsicht genau wie der Ungleichheitsoperator (!=):

• Zahlen und boolesche Werte werden anhand ihres Werts verglichen und gelten als gleich, wenn sie den gleichen Wert haben.
• Stringausdrücke sind gleich, wenn sie dieselbe Anzahl von Zeichen enthalten und die Zeichen identisch sind.
• 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.

• Der strikte Ungleichheitsoperator (!==) führt die automatische Datenumwandlung nur für numerische Typen durch („Number“, „int“ und „uint“), während der Ungleichheits-Operator (!=) die automatische Datenumwandlung für alle primitiven Datentypen durchführt.
• Beim Vergleich von null und undefined gibt der strikte Ungleichheitsoperator (!==) den Wert true zurück.

var s1:String = "5"; 
var s2:String = "5"; 
var s3:String = "Hello"; 
var n:Number = 5; 
var b:Boolean = true; 
trace(s1 == s2);  // true 
trace(s1 == s3);  // false 
trace(s1 == n);   // true 
trace(s1 == b);   // false 
trace(s1 === s2); // true 
trace(s1 === s3); // false 
trace(s1 === n);  // false 
trace(s1 === b);  // false 
trace(s1 !== s2); // false 
trace(s1 !== s3); // true 
trace(s1 !== n);  // true 
trace(s1 !== b);  // true 

Verwandte API-Elemente

 "text" 

Wenn Sie diesen Operator vor und nach einem String eingeben, kennzeichnen Sie, dass es sich dabei um einen Literalwert, d. h. um einen String, und nicht um eine Variable, einen numerischen Wert oder ein anderes ActionScript-Element handelt.

var yourGuess:String = "Prince Edward Island"; 
submit_btn.onRelease = function() { trace(yourGuess); }; 
// Prince Edward Island

Verwandte API-Elemente

-expression

 expression1 - expression2

Dient zur Negation oder Subtraktion.

Verwendung 1: In einer Negation kehrt dieser Operator das Vorzeichen des numerischen Ausdrucks um.

Verwendung 2: In einer Subtraktion führt der Operator eine arithmetische Subtraktion von zwei numerischen Ausdrücken durch, wobei expression 2 von expression1 subtrahiert wird. Wenn beide Ausdrücke Ganzzahlen sind, ist die Differenz eine Ganzzahl. Wenn einer oder beide Ausdrücke Gleitkommazahlen sind, ist die Differenz eine Gleitkommazahl.

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

trace(5 - 2); // 3 

Die folgende Anweisung subtrahiert die Gleitkommazahl 1,5 von der Gleitkommazahl 3,25:

trace(3.25 - 1.5); // 1.75 

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

x -= y ;
x = x - y;

String-Ausdrücke müssen in Zahlen umgewandelt werden, andernfalls wird NaN (Not a Number – keine Zahl) zurückgegeben.

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

var x:String = "5"; 
var y:String = "10"; 
x -= y; 
trace(x); // -5 

Verwandte API-Elemente

[modifiers] var variableName:type

function functionName():type { ... }

function functionName(parameter1:type, ..., parameterN:type) [:type]{ ... } 

Dieser Operator wird für die Zuweisung eines Datentyps verwendet. Er gibt den Variablentyp, den Rückgabetyp einer Funktion oder den Parametertyp einer Funktion an. Bei Verwendung in einer Variablendeklaration oder Variablenzuweisung gibt dieser Operator den Typ der Variablen an. Bei Verwendung in einer Funktionsdeklaration oder Funktionsdefinition gibt dieser Operator den Rückgabetyp der Funktion an. Bei Verwendung mit einem Funktionsparameter in einer Funktionsdefinition gibt dieser Operator den erwarteten Variablentyp für diesen Parameter an.

Die Überprüfung des Datentyps findet immer zur Laufzeit statt. Ist der Compiler jedoch auf strikten Modus eingestellt, werden alle Datentypen auch während der Kompilierung überprüft. Bei einer Diskrepanz wird eine Fehlermeldung erzeugt. Diskrepanzen können während Zuweisungsoperationen, Funktionsaufrufen und während der Dereferenzierung von Klassenelementen mit dem Punkt-Operator (.) auftreten.

Zu den verwendbaren Typen gehören alle nativen Objekttypen, Klassen und benutzerdefinierte Schnittstellen sowie void. Die erkannten nativen Typen sind „Boolean“, „Number“, „int“, „uint“ und „String“. Auch sämtliche integrierten Klassen werden als native Typen unterstützt.

Wenn Sie keinen Datentyp zuweisen, wird die Variable, der Rückgabewert der Funktion oder der Funktionsparameter als nicht typisiert angesehen. Dies bedeutet, der Wert kann einen beliebigen Datentyp annehmen. Wenn Sie verdeutlichen möchten, dass die Verwendung eines nicht typisierten Werts beabsichtigt ist, können Sie das Asteriskzeichen (*) als Typanmerkung verwenden. Wenn das Asteriskzeichen als Typanmerkung verwendet wird, entspricht dies dem Nichttypisieren einer Variablen, eines Rückgabetyps einer Funktion oder eines Funktionsparameters.

var userName:String = ""; 

function randomInt(integer:int):int { 
	return Math.round(Math.random()*integer); 
} 
trace(randomInt(8)); 

function squareRoot(val:Number):Number { 
	return Math.sqrt(val); 
} 
trace(squareRoot(121)); 

Verwandte API-Elemente

Wertet expression aus und gibt eine Zeichenfolge zurück, die den Datentyp des Ausdrucks angibt. Das Ergebnis ist auf sechs mögliche Stringwerte beschränkt: boolean, function, number, object, stringund xml. Wenn Sie diesen Operator auf eine Instanz einer benutzerdefinierten Klasse anwenden, ist das Ergebnis die Zeichenfolge object. Der typeof-Operator ist aus Gründen der Abwärtskompatibilität vorhanden. Verwenden Sie den is-Operator zur Überprüfung der Typenkompatibilität.

trace(typeof Array); // object
trace(typeof Date);  // object
trace(typeof 3);     // number

var a:String = "sample";
var b:String = new String("sample");
trace(typeof a); // string
trace(typeof b); // string 

Verwandte API-Elemente

Wertet einen Ausdruck aus und verwirft dann dessen Wert und gibt undefined zurück. Der Operator void wird häufig in Vergleichsoperationen mit dem Operator == verwendet, um zu prüfen, ob Werte undefiniert sind.

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

Definiert ein XML-Tag in einem XML-Literal. Verwenden Sie den Schrägstrich /, um das schließende Tag zu definieren.

var x:XML = <item id= "324">cola</item>; 

Verwandte API-Elemente