Fügt numerische Ausdrücke hinzu. Wenn beide Ausdrücke Ganzzahlen sind, ist die Summe eine Ganzzahl. Wenn ein oder beide Ausdrücke Gleitkommazahlen sind, ist die Summe eine Gleitkommazahl.

Wenn einer der Ausdrücke ein String ist, werden alle Ausdrücke in Strings umgewandelt und verkettet anstatt summiert. Andernfalls, wenn ein Ausdruck keine Zahl ist, wird er von Flash^® Player ihn in eine Zahl konvertiert.

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);

Siehe auch

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 

Siehe auch

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-Zugriffs-Operator 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, so genannte Elemente, durch eine Zahl (den so genannten 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 mit der Bezeichnung employee weist beispielsweise drei Elemente auf: Das erste ist eine Zahl, das zweite und dritte sind Zeichenfolgen 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 */ 

Siehe auch

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

Siehe auch

Weist den Wert von expression2 (dem rechten Operanden) der Variablen, dem Array-Element oder der Eigenschaft in expression1 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, Number, int, uint oder String. Bei einer Zuweisung durch eine Referenz wird die Referenz auf expression2 in expression1 gespeichert. Die Zuweisung über einen Verweis 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 wenn 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

Siehe auch

 myXML.@attributeName 

Kennzeichnet die Attribute eines XML- oder XMLList-Objekts. Beispielsweise kennzeichnet myXML.@id Attribute mit der Bezeichnung id für das XML-Objekt myXML. Die Zugriff auf Attribute können Sie auch die folgende Syntax verwenden: 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 Methode attribute() 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"));

Siehe auch

Wandelt expression1 und expression2 in vorzeichenlose 32-Bit-Ganzzahlen um und führt eine Boolean AND-Operation für jedes einzelne Bit der ganzzahligen Parameter aus. Gleitkommazahlen werden in Ganzzahlen umgewandelt. Dabei werden alle Nachkommastellen abgeschnitten. Das Ergebnis ist eine neue 32-Bit-Ganzzahl.

Eine positive Ganzzahl wird in einen vorzeichenlosen Hexadezimalwert mit einem Maximalwert von 4294967295 bzw. 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 mindestens -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 

Siehe auch

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

x &= y; 
x = x & y; 

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

Siehe auch

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 als Ergebnis dieser Operation geleerten Bit-Positionen 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. 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 mindestens -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 

Siehe auch

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 

Siehe auch

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 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 (Boolean-Werte, die jeweils aus 1 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. 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 mindestens -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 

Siehe auch

Wandelt expression1 und expression2 in vorzeichenlose 32-Bit-Ganzzahlen um und platziert eine 1 an jeder Bitposition, an der die entsprechenden Bits in expression1 oder expression2 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. 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 mindestens -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) 

Siehe auch

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

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) 

Siehe auch

Wandelt expression und shiftCount in 32-Bit-Ganzzahlen um und verschiebt alle Bits in expression um die Anzahl der Stellen nach links, 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. 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 mindestens -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)

Siehe auch

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.

Siehe auch

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. 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 mindestens -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 ein "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 

Siehe auch

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 

Siehe auch

Wandelt expression1 und expression2 in vorzeichenlose 32-Bit-Ganzzahlen um und platziert eine 1 an jeder Bit-Position, 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. 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 mindestens -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) 

Siehe auch

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

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) 

Siehe auch

/* 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 */ 

Siehe auch

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

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>

Siehe auch

 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"]);

Siehe auch

Wertet expression1 aus, dann expression2 usw. Dieser Operator wird hauptsächlich in Verbindung mit for-Schleifenanweisungen und häufig zusammen mit dem ()-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 

Siehe auch

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 

Siehe auch

expression1 + expression2

Verkettet (verbindet) XML- oder XMLList-Werte zu 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>
    

Siehe auch

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 

Siehe auch

expression1 += expression2

Weist expression1, also einem 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>

Siehe auch

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); 

Siehe auch

--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); 
}

Siehe auch

 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, anderenfalls 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 delete nicht gelöscht werden kann, schlägt der Operator false möglicherweise fehl, und es wird reference 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 demonstriert, wie der Boolean-Wert, der von delete zurückgegebene wird, als Bedingung für die zukünftige Ausführung des Codes verwendet werden kann. 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

Siehe auch

 delete reference

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

Bei Verwendung mit einem XMLList-Operanden ist das Ergebnis des delete-Operators immer true, weil der XMLList Operand immer auf ein gültiges (wenn auch möglicherweise leeres) XMLList-Objekt verweist.

 
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);

Dies erzeugt die folgende Ausgabe:

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

 myXML..childElement1..@attributeName 

Navigiert zu den Nachfolgerelementen eines XML- oder XMLList-Objekts oder findet (in Verbindung mit dem @-Operator) die übereinstimmenden Attribute der Nachfolger. 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 die XML.descendants()-Methode anstelle des Nachfolger-Operators (..). Dies wird im 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

Siehe auch

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

Siehe auch

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

x /= y; 
x = x / y;

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

Siehe auch

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 und Klassen.

import flash.utils.Timer;

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

Siehe auch

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 die Methode XML.elements() oder XML.descendants() anstelle des Punkt-Operators (.). Dies wird im 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

Siehe auch

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.
• String-Ausdrü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 einfachen 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 

Siehe auch

Vergleicht zwei Ausdrücke und stellt fest, ob expression1 größer ist als expression2. 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 ist (true) oder ob expression1 kleiner als expression2 (false).

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

Siehe auch

Wertet aus, ob eine Eigenschaft ein Teil eines bestimmten Objekts ist. Um den in-Operator verwenden zu können, geben Sie einen Eigenschaftennamen 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 der Index innerhalb des gültigen Bereichs von Indexzahlen 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 Indexzahlen 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

Siehe auch

++expression

 expression++

Addiert 1 zu einem Ausdruck. Der Ausdruck kann eine Variable, ein Element in einem Array oder eine Objekteigenschaft erstellt. 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 Ausgangswert von expression (den Wert 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 
*/

Siehe auch

Prüft auf das genaue Gegenteil des Gleichheits-Operators (==). Wenn expression1 gleich expression2 ist, lautet das Ergebnis false. Wie auch beim Gleichheits-Operator (==) 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.
• String-Ausdrü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 einfachen 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

Siehe auch

Wertet aus, ob die Prototypkette eines Ausdrucks das Prototypobjekt für function enthält. Der instanceof-Operator ist aus Gründen der Abwärtskompatibilitä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

Siehe auch

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 ein 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

Siehe auch

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 oder gleich expression2 ist. Falls ja, lautet das Ergebnis true. Wenn expression1 größer 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

Siehe auch

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 vom Typ Boolean 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!"); 
} 

Siehe auch

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

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/>

Siehe auch

Kehrt den Boolean-Wert einer Variablen oder eines Ausdrucks um. Ist expression eine Variable mit dem absoluten bzw. konvertierten Wert von true, so hat !expression den Wert false. Wenn der Ausdruck x && y den Wert false annimmt, nimmt der Ausdruck !(x && y) den Wert true an.

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 
} 

Siehe auch

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 dem Typ Boolean angehören, ist das Ergebnis nur dann true, wenn beide Ausdrücke true sind. Das Ergebnis ist nur dann false, wenn beide Ausdrücke als false ausgewertet werden. 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 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");
}

Siehe auch

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

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

myVar ||= "default";

Siehe auch

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). Sowohl -4 % 3 als auch -4 % -3 ergeben beispielsweise beide -1.

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

Siehe auch

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 

Siehe auch

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 

Siehe auch

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

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 

Siehe auch

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

Siehe auch

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 einer Klasse mit dem Operator new ein eingebetteter Bestand zugewiesen 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 zugewiesene 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);

Siehe auch

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 in Anweisungen und Funktionen zur Ablaufsteuerung (for, while, if, else, switch) eingebunden 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"; 

Siehe auch

(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 Vorrangreihenfolge 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 

Siehe auch

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

Siehe auch

/pattern/flags

Wenn Sie diesen Operator vor und nach einem String eingeben, kennzeichnen Sie, dass es sich dabei um einen Literalwert handelt, der als ein regulärer Ausdruck (RegExp) betrachtet wird und nicht um einen String, 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 

Siehe auch

Ü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 Gleichheits-Operator (===) arbeitet in dreierlei Hinsicht genau wie der Gleichheits-Operator (==):

• Zahlen und Boolean-Werte werden anhand ihres Werts verglichen und gelten als gleich, wenn sie den gleichen Wert haben.
• String-Ausdrü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 die automatische Datenumwandlung nur für numerische Typen durch (Number, int unduint). Der Ungleichheitsoperator führt hingegen die automatische Datenumwandlung für alle Grunddatentypen durch.
• Beim Vergleich von null und undefined gibt der strikte Gleichheits-Operator 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 ist und nicht Boolean, Number oder String. 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 als entweder Boolean, Number, int, uint oder String typisiert sind, unabhängig davon, ob sie sich in einem Objekt befinden.

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 

Siehe auch

Prüft auf das genaue Gegenteil des strikten Gleichheits-Operators (===). Der strikte Ungleichheits-Operator bewirkt das Gleiche wie der Ungleichheits-Operator, es werden jedoch nur die Datentypen int und uint umgewandelt.

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

Der strikte Ungleichheits-Operator !==) arbeitet in dreierlei Hinsicht genau wie der Ungleichheits-Operator (!=):

• Zahlen und Boolean-Werte werden anhand ihres Werts verglichen und gelten als gleich, wenn sie den gleichen Wert haben.
• String-Ausdrü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). Der Ungleichheitsoperator (!=) führt hingegen die automatische Datenumwandlung für alle Grunddatentypen durch.
• Beim Vergleich von null und undefined gibt der strikte Ungleichheits-Operator (!==) 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 

Siehe auch

 "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

Siehe auch

-expression

 expression1 - expression2

Wird bei Negationen oder Subtraktionen verwendet.

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 expression2 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 (bzw. Gleitpunktzahl) 1.5 von der Gleitkommazahl 3.25:

trace(3.25 - 1.5); // 1.75 

Siehe auch

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

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 

Siehe auch

[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 Ergebnistyp 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)); 

Siehe auch

Wertet expression aus und gibt eine Zeichenfolge zurück, die den Datentyp des Ausdrucks angibt. Das Ergebnis ist auf sechs mögliche Strings beschränkt: boolean, function, number, object, string und xml. Wenn Sie diesen Operator an einer Instanz einer benutzerdefinierten Klasse anwenden, ist das Ergebnis der String 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 

Siehe auch

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

Siehe auch

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

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>; 

Siehe auch