function functionName(parameter0, parameter1, ...rest){ 
	// statement(s) 
} 

Gibt an, dass eine Funktion eine beliebige Anzahl von durch Kommata getrennten Argumenten akzeptiert. Die Liste der Argumente wird zu einem Array, das über den Hauptteil der Funktion verfügbar ist. Der Name des Array wird hinter den Zeichen ... in der Parameterdeklaration angegeben. Der Parameter kann jeden Namen annehmen, der kein reserviertes Wort ist.

Wenn dieser Parameter zusammen mit anderen Parametern verwendet wird, muss die ... (rest)-Parameterdeklaration der letzte angegebene Parameter sein. Das ... (rest)-Parameterarray wird nur dann aufgefüllt, wenn die Anzahl der an die Funktion übergebenen Argumente die Anzahl der anderen Parameter übersteigt.

Jedes Argument in einer durch Kommata getrennten Argumentliste wird in ein Element des Arrays eingefügt. Wenn Sie eine Instanz der Array-Klasse übergebenen, wird das gesamte Array in ein einzelnes Element des ... (rest)-Parameterarrays eingefügt.

Wenn Sie diesen Parameter verwenden, steht das Objekt arguments nicht mehr zur Verfügung. Obwohl Ihnen der ... (rest)-Parameter die gleichen Funktionen wie das arguments-Array und die arguments.length-Eigenschaft zur Verfügung stellt, verfügt es nicht über den Funktionsumfang, der Ihnen von arguments.callee bereitgestellt wird. Bevor Sie den arguments.callee (rest)-Parameter einsetzen, stellen Sie sicher, dass Sie ... nicht benötigen.

package {
    import flash.display.MovieClip;
    
    public class RestParamExample extends MovieClip {
        public function RestParamExample() {
            traceParams(100, 130, "two"); // Output: 100,130,two
            trace(average(4, 7, 13));     // Output: 8
        }
    }
}


function traceParams(... rest) {
     trace(rest);
 }
 
function average(... args) : Number{
    var sum:Number = 0;
    for (var i:uint = 0; i < args.length; i++) {
        sum += args[i];
    }
    return (sum / args.length);
}

Siehe auch

Definiert Methoden und Eigenschaften der ActionScript-Hauptklassen, bei denen es sich um feste Eigenschaften und nicht um Prototypeigenschaften handelt. Wenn Sie die Compileroption "-as3" auf true (which is the default setting in Flex Builder 2) setzen, wird der ActionScript 3.0-Namespace automatisch für alle Hauptklassen geöffnet. Dies bedeutet, dass eine Instanz der Hauptklasse feste Eigenschaften und Methoden anstelle der Versionen dieser Eigenschaften und Methoden verwendet, die an das Prototypobjekt das Klasse angefügt sind. Die Verwendung der festen Eigenschaften bietet in der Regel eine bessere Leistung, jedoch auf Kosten der Abwärtskompatibilität zur ECMAScript-Sprachspezifikation in der Ausgabe 3 (ECMA-262).

Siehe auch

Wird in einer Schleife (for, for..in, for each..in, do..while oder while) oder in einem Anweisungsblock angezeigt, der mit einer bestimmten Bedingung in einer switch-Anweisung verknüpft ist. Bei Ausführung in einer Schleife weist die Anweisung break Flash an, den restlichen Teil der Schleife zu überspringen, die Schleifenaktion abzubrechen und die Anweisung auszuführen, die auf die Schleifenanweisung folgt. Im Zusammenhang mit switch weist die break-Anweisung Flash an, die verbleibenden Anweisungen in diesem case-Block zu überspringen und zur ersten Anweisung zu springen, die auf die einschließende switch-Anweisung folgt.

Bei verschachtelten Schleifen überspringt break lediglich den Rest der unmittelbaren Schleife, bricht aber nicht aus der gesamten Serie der verschachtelten Schleifen aus. Informationen zum Ausbrechen aus verschachtelten Schleifen finden Sie im Abschnitt zu label oder try..catch..finally.

Die Anweisung break kann eine optionale Bezeichnung aufweisen, die mit der Bezeichnung einer äußeren Anweisung übereinstimmen muss. Die Verwendung einer Bezeichnung, die nicht mit der Bezeichnung einer äußeren Anweisung übereinstimmt, erzeugt einen Syntaxfehler. break-Anweisungen mit Bezeichnungen können zum Ausbrechen auf verschiedenen Ebenen von verschachtelten Schleifenanweisungen, switch-Anweisungen oder block-Anweisungen verwendet werden. Ein Beispiel finden Sie im Eintrag für die label-Anweisung.

var i:int = 0;
while (true) { 
    trace(i); 
    if (i >= 10) { 
        break; // this will terminate/exit the loop 
    } 
    i++; 
} 
/* output:
0 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10*/

Siehe auch

case jumpTarget: statements

Definiert ein Sprungziel für die switch-Anweisung. Wenn bei einem Vergleich der Parameter jumpTarget mit dem Parameter expression der switch-Anweisung mithilfe des strikten Gleichheits-Operators (===) übereinstimmt, führt Flash Player die im Parameter statements enthaltenen Anweisungen so lange aus, bis entweder eine break-Anweisung oder das Ende der switch-Anweisung erreicht wird.

Wenn Sie das Schlüsselwort case außerhalb einer switch-Anweisung verwenden, wird ein Fehler ausgegeben und das Skript nicht kompiliert.

Hinweis: Der Parameter statements muss immer mit einer break-Anweisung abgeschlossen werden. Wenn Sie die break-Anweisung im Parameter statements weglassen, wird die nächste case-Anweisung ausgeführt und die switch-Anweisung wird nicht verlassen.

var thisMonth:int = new Date().getMonth(); 
switch (thisMonth) { 
    case 0 : 
        trace("January"); 
        break; 
    case 1 : 
        trace("February"); 
        break; 
    case 5 : 
    case 6 : 
    case 7 : 
        trace("Some summer month"); 
        break; 
    case 8 : 
        trace("September"); 
        break; 
    default : 
        trace("some other month"); 
}

Siehe auch

[dynamic] [public | internal] [final] class className [ extends superClass ] [ implements interfaceName[, interfaceName... ] ] { 
	// class definition here
}

Definiert eine Klasse, mit der Objekte instanziiert werden können, die benutzerdefinierte Methoden und Eigenschaften gemeinsam verwenden. Wenn Sie beispielsweise ein Rechnungserfassungssystem entwickeln, können Sie eine Rechnungsklasse erstellen, die alle Methoden und Eigenschaften definiert, die eine Rechnung beinhalten soll. Anschließend erstellen Sie mit dem Befehl new Invoice() die einzelnen Rechnungsobjekte.

Jede ActionScript-Quelldatei kann nur eine Klasse enthalten, die für andere Quelldateien oder Skripts sichtbar ist. Bei der extern sichtbaren Klasse kann es sich um eine öffentliche oder interne Klasse handeln und Sie muss in einer Paketanweisung definiert sein. Wenn Sie weitere Klassen in die gleiche Datei aufnehmen, müssen die Klassen außerhalb der Paketanweisung und am Ende der Datei platziert werden.

Der Name der extern sichtbaren Klasse muss mit dem Namen der ActionScript-Quelldatei übereinstimmen, die diese Klasse enthält. Der Name der Quelldatei muss dem Klassennamen mit der angehängten Endung ".as" entsprechen. Wenn Sie beispielsweise einer Klasse den Namen Student geben, muss die Datei, die die Klasse definiert, den Namen Student.as erhalten.

Klassendefinitionen können nicht verschachtelt werden, d. h. Sie können innerhalb einer Klassendefinition keine zusätzlichen Klassen definieren.

Sie können eine Konstruktormethode definieren. Diese Methode wird stets ausgeführt, wenn eine neue Instanz der Klasse erstellt wird. Der Name der Konstruktormethode muss mit dem Namen der Klasse übereinstimmen. Wenn Sie keine Konstruktormethode definieren, wird ein Standardkonstruktor erstellt.

Um anzugeben, dass Objekte dynamische Eigenschaften zur Laufzeit hinzufügen und auf diese zugreifen können, stellen Sie der Klassenanweisung das Schlüsselwort dynamic voran. Wenn Sie deklarieren möchten, dass eine Klasse eine Schnittstelle implementiert, verwenden Sie das Schlüsselwort implements. Zum Erstellen von Unterklassen einer Klasse verwenden Sie das Schlüsselwort extends. (Eine Klasse kann nur eine Klasse erweitern, kann aber mehrere Schnittstellen implementieren.) Die Schlüsselwörter implements und extends können zusammen in einer Anweisung verwendet werden. Die folgenden Codes enthalten typische Beispiele für die Verwendung der Schlüsselwrter implements und extends :

class C implements Interface_i, Interface_j // OK 
class C extends Class_d implements Interface_i, Interface_j // OK 
class C extends Class_d, Class_e // not OK 

// Filename Plant.as 
package {
  public class Plant { 
    // Define property names and types 
    private var _leafType:String; 
    private var _bloomSeason:String; 
    // Following line is constructor 
    // because it has the same name as the class 
    public function Plant(param_leafType:String, param_bloomSeason:String) { 
        // Assign passed values to properties when new Plant object is created 
        _leafType = param_leafType; 
        _bloomSeason = param_bloomSeason; 
    } 
    // Create methods to return property values, because best practice 
    // recommends against directly referencing a property of a class 
    public function get leafType():String { 
        return _leafType; 
    } 
    public function get bloomSeason():String { 
        return _bloomSeason; 
    } 
  }
}

var pineTree:Plant = new Plant("Evergreen", "N/A"); 
// Confirm parameters were passed correctly 
trace(pineTree.leafType); 
trace(pineTree.bloomSeason); 

Siehe auch

const identifier = value 

Gibt eine Konstante an, bei der es sich um eine Variable handelt, der nur einmal ein Wert zugewiesen werden kann.

Sie können eine Konstante strikt typisieren, indem Sie einen Doppelpunkt (:) gefolgt von dem Datentyp anhängen.

const MIN_AGE:int = 21;
MIN_AGE = 18; // error

const product_array:Array = new Array("Studio", "Dreamweaver", "Flash", "ColdFusion", "Contribute", "Breeze"); 
product_array.push("Flex"); // array operations are allowed
product_array = ["Other"];  // assignment is an error
trace(product_array); 

Siehe auch

continue [label]

Überspringt sämtliche verbleibenden Anweisungen in der innersten Schleife und beginnt die nächste Iteration der Schleife, als wäre das Ende der Schleife normal erreicht worden. Die Anweisung continue hat außerhalb einer Schleife keine Auswirkungen. In verschachtelten Schleifen können Sie den optionalen Parameter label verwenden, um mehr als nur die innerste Schleife zu überspringen.

Die Anweisung continue kann eine optionale Bezeichnung aufweisen, die mit der Bezeichnung einer äußeren Anweisung übereinstimmen muss. Die Verwendung einer Bezeichnung, die nicht mit der Bezeichnung einer äußeren Anweisung übereinstimmt, erzeugt einen Syntaxfehler. continue-Anweisungen mit Bezeichnungen können zum Überspringen mehrerer Ebenen von verschachtelten Schleifenanweisungen verwendet werden.

var i:int = 0; 
while (i < 10) { 
    if (i % 3 == 0) { 
        i++; 
        continue; 
    } 
    trace(i); 
    i++; 
}

In einer for-Schleife kann die Anweisung continue auch dazu verwendet werden, den restlichen Teil der Schleife zu überspringen. Wenn im folgenden Beispiel i % 3 den Wert 0 ergibt, wird die Anweisung trace(i) übersprungen:

 
for (var i:int = 0; i < 10; i++) { 
    if (i % 3 == 0) { 
        continue; 
    } 
    trace(i); 
}

Siehe auch

default: statements 

Definiert die Standardbedingung für die switch-Anweisung. Die Anweisungen werden ausgeführt, wenn der Parameter expression der Anweisung switch bei Vergleich durch den strikten Gleichheitsoperator [===] mit keinem der Parameter von expression identisch ist, die auf die case-Schlüsselwörter in einer switch-Anweisung folgen.

In einer switch-Anweisung ist eine default-Bedingungsanweisung nicht unbedingt erforderlich. Eine default-Bedingungsanweisung muss in der Liste nicht an letzter Stelle stehen. Wenn Sie eine default-Anweisung außerhalb einer switch-Anweisung verwenden, wird ein Fehler ausgegeben und das Skript nicht kompiliert.

var dayOfWeek:int = new Date().getDay(); 
switch (dayOfWeek) { 
    case 1 : 
        trace("Monday"); 
        break; 
    case 2 : 
        trace("Tuesday"); 
        break; 
    case 3 : 
        trace("Wednesday"); 
        break; 
    case 4 : 
        trace("Thursday"); 
        break; 
    case 5 : 
        trace("Friday"); 
        break; 
    default : 
        trace("Weekend"); 
}

Siehe auch

Die Direktive default xml namespace richtet den mit XML-Objekten zu verwendenden Standard-Namespace ein.

Wenn Sie die Direktive default xml namespace nicht einrichten, ist der Standard-Namespace der unbenannte Namespace (bei dem der URI auf eine leere Zeichenfolge gesetzt ist). Der Gültigkeitsbereich einer default xml namespace-Deklaration erstreckt sich über einen Funktionsblock. Dies entspricht dem Gültigkeitsbereich einer Variablen.

var nsDefault1:Namespace = new Namespace("http://www.example.com/namespaces/");
default xml namespace = nsDefault1;
        
var x1:XML = <test1 />;
trace("x1 ns: " + x1.namespace());
            
scopeCheck();    

var x2:XML = <test2 />;
trace("x2 ns: " + x2.namespace());
        
function scopeCheck(): void {
    
    var x3:XML = <test3 />;
    trace("x3 ns: " + x3.namespace());
                
    var nsDefault2:Namespace = new Namespace("http://schemas.xmlsoap.org/soap/envelope/");
    default xml namespace = nsDefault2;
            
    var x4:XML = <test4 />;
    trace("x4 ns: " + x4.namespace());

}

Die Ausgabe trace() für dieses Beispiel ist:

x1 ns: http://www.example.com/namespaces/
x3 ns: 
x4 ns: http://schemas.xmlsoap.org/soap/envelope/
x2 ns: http://www.example.com/namespaces/

var nsDefault:Namespace = new Namespace("http://www.example.com/namespaces/");
default xml namespace = nsDefault;
            
var x1:XML = <test1 />;

trace(x1.namespace());
    // http://www.example.com/namespaces/

var x2:XML = <test2 xmlns = "http://www.w3.org/1999/XSL/Transform/" />;
trace(x2.namespace());
    // http://www.w3.org/1999/XSL/Transform/

var x3:XML = <test3 xmlns:soap-env="http://schemas.xmlsoap.org/soap/envelope/" />;
trace(x3.namespace());
    // http://www.example.com/namespaces/

Siehe auch

do { statement(s) } while (condition)

Ähnelt einer while-Schleife, nur werden die Anweisungen vor der ersten Auswertung der Bedingung einmal ausgeführt. Dann werden die Anweisungen nur ausgeführt, wenn die Bedingung true ergibt.

Mithilfe einer do..while-Schleife können Sie sicherstellen, dass der Code innerhalb der Schleife mindestens einmal ausgeführt wird. Dies kann zwar auch mit einer while-Schleife erreicht werden, indem die auszuführenden Anweisungen einmal vor die while-Schleife kopiert werden, viele Programmierer sind jedoch der Ansicht, dass do..while-Schleifen leichter zu lesen sind.

Wenn die Bedingung immer true ergibt, ist die do..while-Schleife eine Endlosschleife. Bei Endlosschleifen werden Sie unter Umständen Probleme mit Flash Player feststellen: Entweder Sie erhalten schließlich eine Fehlermeldung, oder der Player stürzt ab. Wenn Sie vorher wissen, wie oft eine Schleife durchlaufen werden soll, sollten Sie nach Möglichkeit eine for-Schleife verwenden. Auch wenn for-Schleifen leicht zu lesen und auf Fehler zu untersuchen sind, können sie doch die do..while-Schleifen nicht in allen Fällen ersetzen.

var myVar:Number = 0; 
do { 
    trace(myVar); 
    myVar++; 
} 
while (myVar < 5); 
/* output: 
0 
1 
2 
3 
4
*/

Siehe auch

dynamic class className { // class definition here }

Gibt an, dass Klasseninstanzen dynamische Eigenschaften besitzen können, die zur Laufzeit hinzugefügt werden. Wenn Sie einer Klasse das Attribut dynamic zuweisen, können den Instanzen dieser Klasse zur Laufzeit Eigenschaften hinzugefügt werden. Klassen, die nicht als dynamic gekennzeichnet sind, werden als sealed (versiegelt) betrachtet, dies bedeutet, dass den Klasseninstanzen keine Eigenschaften hinzugefügt werden können.

Bei einer versiegelten ("sealed") Klasse (also einer nicht dynamischen Klasse), erzeugen Versuche, Eigenschaften von Klasseninstanzen abzurufen und einzustellen, eine Fehlermeldung. Wenn der Compiler auf strikten Modus eingestellt ist und Sie Datentypen beim Erstellen von Instanzen angeben, wird bei dem Versuch, Eigenschaften zu versiegelten ("sealed") Objekten hinzuzufügen, ein Compiler-Fehler erzeugt; andernfalls tritt ein Laufzeitfehler auf.

Das Attribut dynamic kann von Unterklassen nicht übernommen werden. Wenn Sie eine dynamische Klasse erweitern, ist die Unterklasse nur dann dynamisch, wenn sie mit dem Attribut dynamic deklariert wird.

package {

    dynamic class Expando  {
    }
    
    class Sealed {
    }
}

var myExpando:Expando = new Expando();
myExpando.prop1 = "new";
trace(myExpando.prop1); // output: new

var mySealed:Sealed = new Sealed();
mySealed.prop1 = "newer"; // error

Siehe auch

if (condition) { 
	// statement(s)
} 
else {
	// statement(s)
}

Gibt die Anweisungen an, die ausgeführt werden, wenn die Bedingung in der if-Anweisung als false ausgewertet wird. Die geschweiften Klammern ({}), die die von der else-Anweisung auszuführenden Anweisungen einschließen, sind nicht erforderlich, wenn nur eine Anweisung ausgeführt wird.

if (age_txt.text>=18) { 
    trace("welcome, user"); 
} 
else { 
    trace("sorry, junior"); 
    userObject.minor = true; 
    userObject.accessAllowed = false;
}

if (age_txt.text>18) { 
    trace("welcome, user");
} 
else trace("sorry, junior");

if (score_txt.text>90) { 
    trace("A"); 
} 
else if (score_txt.text>75) { 
    trace("B"); 
} 
else if (score_txt.text>60) { 
    trace("C"); 
} 
else { 
    trace("F"); 
}

Siehe auch

class className extends otherClassName {}
interface interfaceName extends otherInterfaceName {} 

Definiert eine Klasse, die eine Unterklasse einer anderen Klasse ist. Die Unterklasse übernimmt alle Methoden, Eigenschaften, Funktionen usw., die in der übergeordneten Klasse definiert sind. Als final markierte Klassen können nicht erweitert werden.

Zur Erweiterung einer Schnittstelle können Sie auch das Schlüsselwort extends verwenden. Eine Schnittstelle, die eine andere Schnittstelle erweitert, enthält sämtliche Methodendeklarationen der ursprünglichen Schnittstelle.

Das folgende Beispiel stellt den Inhalt einer Datei mit Namen Vehicle.as dar, mit der die Vehicle-Klasse definiert wird:

package {
    class Vehicle { 
        var numDoors:Number; 
        var color:String; 
        public function Vehicle(param_numDoors:Number = 2, param_color:String = null) { 
            numDoors = param_numDoors; 
            color = param_color; 
        } 
        public function start():void { 
            trace("[Vehicle] start"); 
        } 
        public function stop():void { 
            trace("[Vehicle] stop"); 
        } 
        public function reverse():void { 
            trace("[Vehicle] reverse"); 
        } 
    }    
}

package {

    public class Car extends Vehicle { 
        var fullSizeSpare:Boolean; 
        public function Car(param_numDoors:Number, param_color:String, param_fullSizeSpare:Boolean) { 
            numDoors = param_numDoors; 
            color = param_color; 
            fullSizeSpare = param_fullSizeSpare; 
        } 
        public function activateCarAlarm():void { 
            trace("[Car] activateCarAlarm"); 
        } 
        public override function stop():void { 
            trace("[Car] stop with antilock brakes"); 
        } 
    }
}

var myNewCar:Car = new Car(2, "Red", true); 
myNewCar.start(); // output: [Vehicle] start 
myNewCar.stop(); // output: [Car] stop with anti-lock brakes 
myNewCar.activateCarAlarm(); // output: [Car] activateCarAlarm

Mithilfe der Anweisung super können Sie zudem eine Unterklasse der Vehicle-Klasse schreiben, mit der die Unterklasse auf den Konstruktor der übergeordneten Klasse zugreifen kann. {\cf11 In dem folgenden Beispiel wird eine dritte ActionScript-Datei mit der Bezeichnung }"{\cf11 Truck.as}"{\cf11 vorgestellt, die ebenfalls im gleichen Verzeichnis gespeichert ist.} Die Truck-Klasse verwendet das Schlüsselwort super sowohl im Konstruktor als auch in der außer Kraft gesetzten reverse()-Methode.

package {
    class Truck extends Vehicle {
        var numWheels:Number;
        public function Truck(param_numDoors:Number, param_color:String, param_numWheels:Number) { 
            super(param_numDoors, param_color); 
            numWheels = param_numWheels; 
        } 
        public override function reverse():void { 
            beep();
            super.reverse();
        } 
        public function beep():void { 
            trace("[Truck] make beeping sound"); 
        } 
    }
}

var myTruck:Truck = new Truck(2, "White", 18); 
myTruck.reverse(); // output: [Truck] make beeping sound [Vehicle] reverse 
myTruck.stop(); // output: [Vehicle] stop

Siehe auch

false

Ein boolescher Wert, der "falsch" darstellt. Die beiden möglichen booleschen Werte sind true (wahr) und false (falsch). Das Gegenteil von false ist true.

Wenn die automatische Typisierung false in eine Zahl umwandelt, wird daraus 0. Bei der Umwandlung von false in eine Zeichenfolge wird der Wert zu einem literalen "false".

Note: Die Zeichenfolge "false" wird in den booleschen Wert true konvertiert.

var bool1:Boolean = Boolean(false);

// converts it to the number 0
trace(1 + bool1); // outputs 1

// converts it to a string
trace("String: " + bool1); // outputs String: false

In dem folgenden Beispiel wird gezeigt, wie die Zeichenfolge "false" in den booleschen Wert true konvertiert wird:

trace(Boolean("false")); // output: true

if ("false") {
    trace("condition expression evaluated to true");
}
else {
    trace("condition expression evaluated to false");
}
// output: condition expression evaluated to true

Siehe auch

final function methodName() { 
	// your statements here 
}
final class className {}

Gibt an, dass eine Methode nicht außer Kraft gesetzt oder eine Klasse nicht erweitert werden kann. Der Versuch, eine Methode außer Kraft zu setzen oder eine als final gekennzeichnete Klasse zu erweitern, führt zu einer Fehlermeldung.

Siehe auch

Definiert Methoden der Proxy-Klasse. Die Methoden der Proxy-Klasse befinden sich in ihrem eigenen Namespace, um Namenskonflikte in Fällen zu vermeiden, in denen Ihre Proxy-Unterklasse Namen von Instanzenmethoden enthält, die mit anderen Methodennamen in der Proxy-Klasse übereinstimmen.

Siehe auch

for ([init]; [condition]; [next]) { 
	// statement(s)
}

Wertet den Ausdruck init (initialisieren) einmal aus und beginnt dann eine Schleifensequenz. Die Schleifensequenz beginnt zunächst mit der Auswertung des Ausdrucks condition. Wenn der Ausdruck condition den Wert true ergibt, wird statement ausgeführt und next ausgewertet. Die Schleifensequenz beginnt dann mit der Auswertung des Ausdrucks condition.

Die geschweiften Klammern ({}), die den von der for-Anweisung auszuführenden Anweisungsblock einschließen, sind nicht erforderlich, wenn nur eine Anweisung ausgeführt wird.

var my_array:Array = new Array(); 
for (var i:Number = 0; i < 10; i++) { 
    my_array[i] = (i + 5) * 10;  
} 
trace(my_array); // output: 50,60,70,80,90,100,110,120,130,140 

var sum:Number = 0; 
for (var i:Number = 1; i <= 100; i++) { 
    sum += i; 
} 
trace(sum); // output: 5050

var sum:Number = 0; 
for (var i:Number = 1; i <= 100; i++) 
    sum += i; 
trace(sum); // output: 5050

Siehe auch

for (variableIterant:String in object){ 
	// statement(s)
} 

Durchläuft die dynamischen Eigenschaften eines Objekts bzw. die Elemente in einem Array und führt die Anweisung statement für jede Eigenschaft bzw. jedes Element aus. Objekteigenschaften werden nicht in einer bestimmten Reihenfolge angeordnet, sodass Eigenschaften scheinbar nach dem Zufallsprinzip wiedergegeben werden können. Feste Eigenschaften, z. B. Variablen und Methoden, die in einer Klasse definiert sind, werden von der for..in-Anweisung nicht verarbeitet. Verwenden Sie die Funktion describeType() aus dem flash.utils-Paket, um eine Liste der festen Eigenschaften anzuzeigen.

var myObject:Object = {firstName:"Tara", age:27, city:"San Francisco"}; 
for (var prop in myObject) { 
    trace("myObject."+prop+" = "+myObject[prop]); 
} 
/* output:
myObject.firstName = Tara 
myObject.age = 27 
myObject.city = San Francisco
*/

var myObject:Object = {firstName:"Tara", age:27, city:"San Francisco"}; 
for (var name in myObject) { 
    if (typeof (myObject[name]) == "string") { 
        trace("I have a string property named "+name); 
    } 
}
/* output:
I have a string property named city
I have a string property named firstName
*/

Siehe auch

for each (variableIterant in object){ 
	// statement(s)
} 

Durchläuft die Elemente in einer Sammlung und führt statement für jedes Element aus. Die Anweisung for each..in wurde als Teil der E4X-Spracherweiterungen eingeführt und kann nicht nur für XML-Objekte, sondern auch für Objekte und Arrays eingesetzt werden. Die Anweisung for each..in durchläuft nur die dynamischen Eigenschaften eines Objekts, nicht jedoch die festen Eigenschaften. Eine feste Eigenschaft ist eine Eigenschaft, die als Teil einer Klassendefinition definiert ist. Wenn Sie die Anweisung for each..in mit einer Instanz einer benutzerdefinierten Klasse verwenden möchten, müssen Sie die Klasse als dynamic deklarieren.

Im Gegensatz zu einer for..in-Anweisung durchläuft die for each..in-Anweisung die Werte der Objekteigenschaften anstelle der Eigenschaftennamen.

var myObject:Object = {firstName:"Tara", age:27, city:"San Francisco"}; 
for each (var item in myObject) { 
    trace(item); 
} 
/* output:
Tara
27
San Francisco
*/

var myArray:Array = new Array("one", "two", "three"); 
for each(var item in myArray) 
    trace(item); 
/* output: 
one
two
three
*/

var myObject:Object = {firstName:"Tara", age:27, city:"San Francisco"}; 
for each (var item in myObject) { 
    if (item is String) {  
        trace("I have a string property with value " + item); 
    } 
}

/* output:
I have a string property with value Tara
I have a string property with value San Francisco
*/

var doc:XML = 
        <body>
            <p>Hello</p>
            <p>Hola</p>
            <hr />
            <p>Bonjour</p>
        </body>;
for each (var item in doc.p) {
    trace(item);
}

/* output:
Hello
Hola
Bonjour
*/

Siehe auch

function functionName([parameter0, parameter1,...parameterN]) : returnType{ 
	// statement(s) 
} 
var functionName:Function = function ([parameter0, parameter1,...parameterN]) : returnType{ 
	// statement(s) 
} 

Umfasst eine Gruppe von Anweisungen, die zur Ausführung einer bestimmten Aufgabe definiert werden. Sie können eine Funktion an einer Stelle definieren und dann von anderen Skripts in einer SWF-Datei aufrufen. Beim Definieren einer Funktion können Sie auch Parameter für diese Funktion angeben. Parameter sind Platzhalter für Werte, die von der Funktion für die Ausführung verwendet werden. Sie können einer Funktion bei jedem neuen Aufruf andere Parameter übergeben, sodass Sie ein und dieselbe Funktion an mehreren Stellen verwenden können.

Mit der Anweisung return im Funktionsblock (statement(s) ) können Sie die Funktion veranlassen, einen Wert zu generieren oder zurückzugeben.

Verwendung 1: Sie können das Schlüsselwort function verwenden, um eine Funktion mit dem angegebenen Namen, den angegebenen Parametern und den angegebenen Anweisungen zu definieren. Ruft ein Skript dann eine Funktion auf, werden die Anweisungen in der Funktionsdefinition ausgeführt. Vorwärtsreferenzen sind zulässig; eine Funktion kann innerhalb eines Skripts auch noch nach ihrem Aufruf deklariert werden. Eine Funktionsdefinition ersetzt alle vorigen Definitionen dieser Funktion. Sie können diese Syntax an jeder Stelle verwenden, an der eine Anweisung zulässig ist.

Verwendung 2: Mithilfe von function können Sie auch eine anonyme Funktion erstellen und einen Verweis auf diese Funktion zurückgeben. Diese Syntax wird in Ausdrücken verwendet und eignet sich besonders zur Installation von Methoden in Objekten.

Weitere Möglichkeiten ergeben sich durch die Verwendung eines arguments-Objekts in der Funktionsdefinition. Häufig werden die arguments-Objekte dazu verwendet, Funktionen zu erstellen, die unterschiedlich viele Parameter annehmen können. Aber auch rekursive anonyme Funktionen können auf diese Weise erstellt werden.

function sqr(xNum:Number) { 
    return Math.pow(xNum, 2); 
} 
var yNum:Number = sqr(3); 
trace(yNum); // output: 9

var yNum:Number = sqr(3); 
trace(yNum); // output: 9 
function sqr(xNum:Number) { 
    return Math.pow(xNum, 2); 
}

Siehe auch

function get property() : returnType{ 
	// your statements here 
}

Definiert eine get-Methode. Dies ist eine Methode, die wie eine Eigenschaft gelesen werden kann. Eine get-Methode ist eine Sonderfunktion, die den Wert einer Eigenschaft zurückgibt, die mit dem Schlüsselwort var oder const deklariert wurde. Im Gegensatz zu anderen Methoden wird eine get-Methode ohne Klammern (()) aufgerufen. Daher sieht eine get-Methode wie eine Variable aus.

Get-Methoden ermöglichen Ihnen das Verbergen von Informationen, in dem Sie eine öffentliche ("public") Schnittstelle für eine private Eigenschaft erstellen. Der Vorteil beim Verbergen von Informationen besteht darin, dass die öffentliche Schnittstelle auch dann gleich bleibt, wenn sich die zu Grunde liegende Implementierung der privaten Eigenschaft ändert.

Ein weiterer Vorteil der get-Methoden besteht darin, dass sie in Unterklassen außer Kraft gesetzt werden können. Dies ist bei Eigenschaften, die mit var oder const deklariert wurden, nicht möglich.

Eine get-Methode kann mit set-Methode kombiniert werden, um eine Eigenschaft mit Lese- und Schreibzugriff zu erstellen. Zum Erstellen einer schreibgeschützten Eigenschaft verwenden Sie eine get-Methode ohne eine entsprechende set-Methode. Zum Erstellen einer Eigenschaft mit Schreibzugriff verwenden Sie eine set-Methode ohne eine entsprechende get-Methode.

package {
    public class Team { 
        var teamName:String; 
        var teamCode:String; 
        var teamPlayers:Array = new Array(); 
        public function Team(param_name:String, param_code:String) { 
            teamName = param_name; 
            teamCode = param_code; 
        } 
        public function get name():String { 
            return teamName; 
        } 
        public function set name(param_name:String):void { 
            teamName = param_name; 
        }
    } 
}

var giants:Team = new Team("San Fran", "SFO"); 
trace(giants.name); 
giants.name = "San Francisco"; 
trace(giants.name); 
/* output: 
San Fran San Francisco */

Bei der Anzeige von giants.name verwenden Sie eine get-Methode, um den Wert der Eigenschaft zurückzugeben.

Siehe auch

if (condition) {
	// statement(s)
}

Wertet eine Bedingung aus, um die nächste auszuführende Anweisung festzulegen. Wenn die Bedingung trueergibt, führt Flash Player die Anweisungen aus, die in geschweiften Klammern ({}) auf die Bedingung folgen. Wenn die Bedingung false ist, überspringt Flash Player die Anweisungen in geschweiften Klammern und führt die Anweisungen nach den geschweiften Klammern aus. Verwenden Sie die if-Anweisung zusammen mit der else-Anweisung, um logische Verzweigungen in den Skripts zu erstellen.

Die geschweiften Klammern ({}), die die von der if-Anweisung auszuführenden Anweisungen einschließen, sind nicht erforderlich, wenn nur eine Anweisung ausgeführt wird.

Siehe auch

myClass implements interface01 [, interface02, ...] 

Gibt an, dass eine Klasse mindestens eine Schnittstelle implementiert. Wenn eine Klasse eine Schnittstelle implementiert, muss die Klasse alle Methoden definieren, die in der Schnittstelle deklariert sind. Jede Instanz einer Klasse, die eine Schnittstelle implementiert, wird als ein Mitglied des von der Schnittstelle definierten Datentyps angesehen. Daher gibt der Operator is den Wert true zurück, wenn die Klasseninstanz der erste Operand und die Schnittstelle der zweite Operand ist. Darüber hinaus finden Datentyp-Konvertierungen von und in den von der Schnittstelle definierten Datentyp statt.

Hinweis: Um dieses Schlüsselwort verwenden zu können, müssen Sie auf der Registerkarte "Flash" im Dialogfeld "Einstellungen für Veröffentlichungen" der FLA-Datei die Einstellung "ActionScript 2.0" aktivieren und "Flash Player 6" oder höher auswählen. Dieses Schlüsselwort wird nur in externen Skriptdateien unterstützt, nicht jedoch in Skripts, die im Bedienfeld "Aktionen" erstellt wurden.

Siehe auch

import packageName.className 
import packageName.*

Stellt extern definierte Klassen und Pakete für Ihren Code zur Verfügung. Wenn Sie beispielsweise die Klasse flash.display.Sprite in einem Skript verwenden möchten, muss sie importiert werden. Dieser Anforderung unterscheidet sich von früheren ActionScript-Versionen, in denen die Direktive import optional war.

Nach Verwendung der Direktive import können Sie den vollständigen Klassennamen, der auch den Paketnamen umfasst, oder nur den Klassennamen verwenden.

 
import flash.display.Sprite; 

// name of class only
var mySprite:Sprite = new Sprite();

// full class name
var mySprite:flash.display.Sprite = new flash.display.Sprite();

Enthält das Paket, auf die Sie zugreifen möchten, mehrere Klassen, können Sie diese in einer Anweisung importieren. Dies wird in dem folgendem Beispiel veranschaulicht:

import flash.display.*;

Die import-Direktive importiert nur die Klassen, Funktionen und Variablen, die auf der obersten Ebene des importierten Pakets gespeichert sind. Verschachtelte Pakete müssen explizit importiert werden.

Wenn Sie eine Klasse importieren, diese jedoch im Skript nicht verwenden, wird die Klasse nicht zusammen mit der SWF-Datei exportiert. Dies bedeutet, dass Sie große Pakete importieren können, ohne sich später um die Größe der SWF-Datei Gedanken machen zu müssen. Der mit einer Klasse verknüpfte Bytecode ist in einer SWF-Datei nur dann enthalten, wenn die entsprechende Klasse tatsächlich verwendet wird. Ein Nachteil beim Importieren von Klassen besteht darin, dass Sie die Wahrscheinlichkeit von Namenskonflikten vergrößern.

// On Frame 1 of a FLA: 
import adobe.example.*; 
var myFoo:foo = new foo();

Siehe auch

include "[path]filename.as"

Bezieht den Inhalt der angegebenen Datei so ein, als wären die Befehle in der Datei Teil des aufrufenden Skripts. Die include-Direktive wird bei der Kompilierung aufgerufen. Wenn Sie eine eingeschlossene Datei ändern, müssen Sie sie daher speichern und alle SWF-Dateien neu kompilieren, die diese Datei verwenden.

Siehe auch

 interface InterfaceName [extends InterfaceName ] {}

Definiert eine Oberfläche. Schnittstellen sind Datentypen, die eine Reihe von Methoden definieren; die Methoden müssen von einer Klasse definiert werden, die die Schnittstelle implementiert.

Eine Schnittstelle ähnelt einer Klasse, wobei jedoch die folgenden wichtigen Unterschiede zu beachten sind:

• Schnittstellen umfassen lediglich Deklarationen von Methoden, nicht aber ihre Implementierung. Das heißt, jede Klasse, die eine Schnittstelle implementiert, muss für jede in der Schnittstelle deklarierte Methode eine Implementierung bereitstellen.
• Methodendefinitionen in Schnittstellen können keine Attribute wie public oder private besitzen, implementierte Methoden müssen jedoch in der Definition der Klasse, die die Schnittstelle implementiert, als public (öffentlich) gekennzeichnet werden.
• Mehrere Schnittstellen können mithilfe der Anweisung extends von einer Schnittstelle, oder mithilfe der Anweisung implements von einer Klasse übernommen werden.

Im Gegensatz zu ActionScript 2.0 gestattet ActionScript 3.0 die Verwendung von get- und set-Methoden in Schnittstellendefinitionen.

Siehe auch

[internal] var varName
[internal] const kName
[internal] function functionName()  { 
	// your statements here 
}
[internal] class className{
	// your statements here 
}
[internal] namespace nsName

Gibt an, dass eine Klasse, Variable, Konstante oder Funktion jedem aufrufenden Objekt im gleichen Paket zur Verfügung steht. Klassen, Eigenschaften und Methoden gehören standardmäßig zum internal (internen) Namespace.

Siehe auch

label: statement
label: {
    statements
}

Verknüpft eine Anweisung mit einem Bezeichner, auf den mithilfe von break oder continue verwiesen werden kann. Bei verschachtelten Schleifen kann eine break- oder continue-Anweisung, die nicht auf eine Bezeichnung verweist, lediglich aus dem Rest der unmittelbaren Schleife ausbrechen, nicht jedoch aus der gesamten Serie der verschachtelten Schleifen. Wenn die Anweisung, die die gesamte Serie von Schleifen definiert, mit einer Bezeichnung verknüpft ist, kann eine break- oder continue-Anweisung aus der gesamten Serie von Schleifen ausbrechen, indem sie auf diese Bezeichnung verweist.

Darüber hinaus können Sie mit Bezeichnungen aus einer Blockanweisung ausbrechen. Sie können eine break-Anweisung, die nicht auf eine Bezeichnung verweist, nicht in eine Blockanweisung einfügen, es sei denn, die Blockanweisung ist Teil einer Schleife. Wenn die Blockanweisung mit einer Bezeichnung verknüpft ist, können Sie eine break-Anweisung einfügen, die auf diese Bezeichnung innerhalb der Blockanweisung verweist.

outerLoop: for (var i:int = 0; i < 10; i++) {
    for (var j:int = 0; j < 10; j++) {
        if ( (i == 8) && (j == 0)) {
            break outerLoop;
        }
        trace(10 * i + j);
    }
}
/* output:
1
2
...
79
*/

In dem folgenden Beispiel wird veranschaulicht, wie eine Bezeichnung mit einer Blockanweisung verwendet wird. In dem folgenden Code wird eine Blockanweisung mit der Bezeichnung foo erstellt, die es der Anweisung break ermöglicht, die letzte Anweisung im Block zu überspringen:

foo: {
    trace("a");
    break foo;
    trace("b");
}
// output: a

Siehe auch

namespace name [= uri]

Ermöglicht Ihnen, die Sichtbarkeit von Definitionen zu bestimmen. Die vordefinierten Namespaces umfassen public, private, protected und internal (diese Namespaces werden auch als Spezifizierer der Zugangskontrolle bezeichnet und in der Dokumentation im Themenbereich "Attribute von Klasseneigenschaften" erörtert). Wenn die vordefinierten Namespaces nicht Ihren Anforderungen entsprechen, können Sie eigene Namespaces definieren.

Die folgenden Schritte zeigen Ihnen, wie Sie einen benutzerdefinierten Namespace erstellen, anwenden und referenzieren:

• Zunächst definieren Sie den benutzerdefinierten Namespace mithilfe des Schlüsselworts namespace. So erzeugt der Code namespace version1 beispielsweise einen Namespace mit der Bezeichnung version1.
• Dann wenden Sie den Namespace an einer Eigenschaft oder Methode an, indem Sie Ihren benutzerdefinierten Namespace in der Deklaration der Eigenschaft oder Methode verwenden. Beispielsweise erzeugt der Code version1 myProperty:String eine Eigenschaft mit der Bezeichnung myProperty, die zum Namespace version1 gehört.
• Im dritten Schritt erstellen Sie mithilfe des Schlüsselworts use oder durch das Voranstellen eines Bezeichners mit dem Namespace einen Verweis auf den Namespace. So verweist der Code use namespace version1; für die nachfolgenden Codezeilen auf den Namespace version1 und der Code version1::myProperty verweist für die Eigenschaft version1 auf den Namespace myProperty.

Siehe auch

native function functionName();
class className { 
	native function methodName();
}

Gibt an, dass eine Funktion oder Methode im nativen Code von Flash Player implementiert wird. Flash Player verwendet intern das Schlüsselwort native, um Funktionen und Methoden in der ActionScript Application Programming Interface (API) zu deklarieren. Dieses Schlüsselwort kann in Ihrem Code nicht verwendet werden.

null

Ein Sonderwert, der Variablen zugewiesen werden kann oder von einer Funktion zurückgegeben wird, wenn keine Daten angegeben wurden. Mit null können Sie fehlende Werte oder Werte ohne definierten Datentyp darstellen.

Der Wert null darf nicht mit dem Sonderwert undefined verwechselt werden. Wenn null und undefined anhand des Gleichheitsoperators (==) verglichen werden, gelten sie als identisch. Wenn null und undefined dagegen mit dem Operator für strikte Gleichheit (===) verglichen werden, sind sie nicht identisch.

var testArray:Array = new Array();
testArray[0] = "fee";
testArray[1] = "fi";
testArray[4] = "foo";

for (i = 0; i < 6; i++) {
    if (testArray[i] == null) {
        trace("testArray[" + i + "] == null");
    }
}

/* output: 
testArray[2] == null
testArray[3] == null
testArray[5] == null
*/

Siehe auch

Definiert Methoden der ObjectProxy-Klasse. Die Methoden der ObjectProxy-Klasse befinden sich in ihrem eigenen Namespace, um Namenskonflikte in Fällen zu vermeiden, in denen eine Proxy-Unterklasse Namen von Instanzenmethoden enthält, die mit anderen Methodennamen in der Proxy-Klasse übereinstimmen.

override function name() { 
	// your statements here 
}

Gibt an, dass eine Methode eine übernommene Methode ersetzt. Um eine übernommene Methode außer Kraft zusetzen, verwenden Sie das Attribut override und achten darauf, dass Name, Anzahl und Datentyp der Parameter sowie Rückgabetyp exakt übereinstimmen. Der Versuch, eine Methode ohne das Attribut override außer Kraft zusetzen, führt zu einer Fehlermeldung. Entsprechend wird eine Fehlermeldung erzeugt, wenn das Attribut override verwendet wird, obwohl die Methode keine entsprechende übernommene Methode besitzt.

Sie können das Attribut override für folgende Elemente nicht verwenden:

• Variablen
• Konstanten
• Statische Methoden
• Methoden, die nicht geerbt wurden
• Methoden, die eine Schnittstellenmethode implementieren
• Geerbte Methoden, die in der übergeordneten Klasse als final gekennzeichnet sind

Eine mit var oder const deklarierte Eigenschaft kann nicht außer Kraft gesetzt werden. Sie erzielen jedoch eine ähnliche Funktion, indem Sie die Basisklasseneigenschaft in einen Getter-Setter umwandeln und mit get und set definierte Methoden außer Kraft setzen.

Siehe auch

package packageName {
    class someClassName { 
    } 
}

Ermöglicht Ihnen das Strukturieren Ihres Code in diskreten Gruppen, die von anderen Skripts importiert werden können. Mit dem Schlüsselwort package geben Sie an, dass eine Klasse ein Mitglied eines Pakets ist.

Siehe auch

class className{ 
	private var varName;
	private const kName;
	private function methodName() { 
		// your statements here 
	}
	private namespace nsName;
}

Gibt an, dass eine Variable, Konstante oder Methode nur für die sie deklarierende oder definierende Klasse verfügbar ist. Im Gegensatz zu ActionScript 2.0 bietet private in ActionScript 3.0 keinen Zugriff auf Unterklassen. Darüber hinaus schränkt private den Zugriff sowohl während der Kompilierung als auch zur Laufzeit ein. In der Standardeinstellung stehen Variablen oder Funktionen jedem aufrufenden Objekt im gleichen Paket zur Verfügung. Verwenden Sie dieses Schlüsselwort zur Einschränkung des Zugriffs auf eine Variable oder Funktion.

Sie können dieses Schlüsselwort nur in Klassendefinitionen verwenden, nicht in Schnittstellendefinitionen. Sie können private nicht an einer Klasse oder an anderen Definitionen auf Paketebene anwenden.

class A { 
  private var alpha:String = "visible only inside class A"; 
  public var beta:String = "visible everywhere"; 
}
    
class B extends A {
  function B() {
    alpha = "Access attempt from subclass"; // error
  }
}

Da alpha eine private Variable ist, können Sie nicht von außerhalb der Klasse A auf sie zugreifen, auch nicht von der Unterklasse B. Versuche, auf eine Variable zuzugreifen, erzeugen eine Fehlermeldung.

Siehe auch

class className{ 
	protected var varName;
	protected const kName;
	protected function methodName() { 
		// your statements here 
	}
	protected namespace nsName;
}

Gibt an, dass eine Variable, Konstante, Methode oder ein Namespace nur für die sie definierende Klasse und allen Unterklassen dieser Klasse verfügbar ist. Die Definition von protected in ActionScript 3.0 ähnelt der Definition von private in der ActionScript 2.0-Version, außer dass protected den Zugriff sowohl während der Kompilierung als auch zur Laufzeit einschränkt. In der Standardeinstellung stehen Variablen oder Funktionen jedem aufrufenden Objekt innerhalb des gleichen Pakets zur Verfügung. Verwenden Sie dieses Schlüsselwort zur Einschränkung des Zugriffs auf eine Variable oder Funktion.

Sie können dieses Schlüsselwort nur in Klassendefinitionen verwenden, nicht in Schnittstellendefinitionen. Sie können private nicht an einer Klasse oder an anderen Definitionen auf Paketebene anwenden.

Die Definition von protected in ActionScript 3.0 ist stärker einschränkend als die Definition von protected in der Programmiersprache Java. In ActionScript 3.0 schränkt protected den Zugriff auf Unterklassen strikt ein, während protected in Java auch den Zugriff auf andere Klassen im gleichen Paket gestattet. Wenn eine Klasse mit der Bezeichnung Base eine als protected gekennzeichnete Eigenschaft enthält, können in ActionScript 3.0 nur Klassen, die die Basisklasse erweitern, auf die geschützte Eigenschaft zugreifen. In Java hat jede Klasse im gleichen Paket wie die Basisklasse Zugriff auf die geschützte Eigenschaft, selbst wenn die Klasse keine Unterklasse der Basisklasse ist.

class A { 
  private var alpha:String = "visible only inside class A"; 
  protected var beta:String = "visible inside class A and its subclasses"; 
}
    
class B extends A {
  public function B() {
    beta = "Access attempt from subclass succeeded";
    trace(beta);  // output: Access attempt from subclass succeeded
  }
}

Siehe auch

public var varName
public const kName
public function functionName()  { 
	// your statements here 
}
public class className {
	// your statements here 
}
public namespace nsName

Gibt an, dass eine Klasse, Variable, Konstante oder Methode für jedes aufrufende Objekt verfügbar ist. Klasse, Variablen und Methoden sind standardmäßig "internal" (intern). Dies bedeutet, dass sie nur innerhalb des aktuellen Pakets sichtbar sind. Um eine Klasse, Variable oder Methode für alle aufrufenden Objekte sichtbar zu machen, verwenden Sie das Attribut public (öffentlich).

class User { 
    public var age:Number; 
    public var fname:String; 
} // end of class User definition
 
var jimmy:User = new User(); 
jimmy.age = 27; 
jimmy.fname = "jimmy";
trace(jimmy.age, jimmy.fname); // output: 27 jimmy

Wenn Sie eine der öffentlichen Variablen der User-Klasse in eine private Variable ändern, wird bei jedem Versuch, außerhalb der User-Klasse auf diese Variable zuzugreifen, während der Kompilierung eine Fehlermeldung erzeugt.

Siehe auch

function functionName () {
	return [expression]
}

Zwingt die Ausführung, unmittelbar zur aufrufenden Funktion zurückzukehren. Wenn der Anweisung return ein Ausdruck folgt, wird der Ausdruck ausgewertet und das Ergebnis zurückgegeben.

Wenn eine Funktionsdefinition einen Rückgabetyp enthält, muss der Anweisung return ein Ausdruck folgen. Wenn kein Rückgabetyp angegeben ist und die Anweisung return allein verwendet wird, gibt sie undefined zurück.

Es kann immer nur ein Wert zurückgegeben werden. Wenn Sie versuchen, mehrere Werte zurückzugeben, so erhalten Sie immer nur den letzten Wert. Im folgenden Beispiel wird c zurückgegeben:

return a, b, c ;

Wenn Sie erreichen möchten, dass mehrere Werte zurückgegeben werden, müssen Sie ein Array oder ein Objekt verwenden.

function sum(a:Number, b:Number, c:Number):Number { 
    return (a + b + c); 
} 
var newValue:Number = sum(4, 32, 78); 
trace(newValue); // output: 114

Siehe auch

function set property(newValue:*) : void{ 
	// your statements here 
}

Definiert eine set-Methode. Dies ist eine Methode, die in der öffentlichen Schnittstelle als eine Eigenschaft erscheint. Eine set-Methode ist eine spezielle Methode, die den Wert einer mit dem Schlüsselwort var deklarierten Eigenschaft einstellt. Im Gegensatz zu anderen Methoden wird eine set-Methode ohne Klammern (()) aufgerufen. Daher sieht eine set-Methode wie eine Variable aus.

Mit set-Methoden können Sie Informationen verbergen, in dem Sie eine öffentliche Schnittstelle für eine private Eigenschaft erstellen. Der Vorteil beim Verbergen von Informationen besteht darin, dass die öffentliche Schnittstelle auch dann gleich bleibt, wenn sich die zu Grunde liegende Implementierung der privaten Eigenschaft ändert.

Ein weiterer Vorteil der set-Methoden besteht darin, dass sie in Unterklassen außer Kraft gesetzt werden können. Dies ist bei Eigenschaften, die mit var oder deklariert wurden, nicht möglich.

Der Rückgabetyp einer set-Definition darf nicht angegeben werden oder muss void lauten.

Eine set-Methode kann mit get-Methode kombiniert werden, um eine Eigenschaft mit Lese- und Schreibzugriff zu erstellen. Zum Erstellen einer schreibgeschützten Eigenschaft verwenden Sie eine get-Methode ohne eine entsprechende set-Methode. Zum Erstellen einer Eigenschaft mit Schreibzugriff verwenden Sie eine set-Methode ohne eine entsprechende get-Methode.

package {
    class User { 
        private var userAge:Number; 
        
        public function get age():Number {
            return userAge;
        }
        
        public function set age(x:Number):void {
            userAge = x;    
        }
    } 
} 

var myUser:User = new User();
myUser.age = 25;
trace(myUser.age); // output: 25

Siehe auch

class someClassName{ 
	static var varName; 
	static const kName;
	static function methodName() { 
		// your statements here
	} 
}

Gibt an, dass eine Variable, Konstante oder Methode zu der Klasse und nicht zu Instanzen dieser Klasse gehört.

Für den Zugriff auf ein statisches Mitglied einer Klasse müssen Sie den Namen der Klasse anstelle des Instanznamens verwenden. Beispielsweise verfügt die Date-Klasse über eine statische Methode mit der Bezeichnung parse(), die nur mithilfe der folgenden Syntax aufgerufen werden kann:

Date.parse()

Die parse()-Methode kann nicht für eine Instanz der Klasse aufgerufen werden. Der folgende Code erzeugt beispielsweise eine Fehlermeldung:

var myDate:Date = new Date();
			myDate.parse("Jan 01 00:00:00 2006"); // error

Sie können das Schlüsselwort static nur in Klassendefinitionen verwenden, nicht in Schnittstellendefinitionen.

Statische Klassenmitglieder werden nicht übernommen. Sie können nicht mithilfe des Namens einer Unterklasse auf ein statisches Klassenmitglied verweisen, wie es beispielsweise in Java oder C++ möglich ist. Sie können jedoch ohne einen Qualifizierter auf eine statische Variable oder Methode innerhalb einer Klasse bzw. Unterklasse verweisen. Betrachten Sie dazu das folgende Beispiel.

Mit einer statische Methode kann die Anweisung super bzw. das Schlüsselwort this nicht verwendet werden.

class Users { 
    private static var numInstances:Number = 0; 
    function Users() { 
        numInstances++; 
    } 
    static function get instances():Number { 
        return numInstances; 
    } 
}

trace(Users.instances); 
var user1:Users = new Users(); 
trace(Users.instances); 
var user2:Users = new Users(); 
trace(Users.instances); 

class PowerUsers extends Users{
    function PowerUsers() {
        instances++;  // unqualified reference to static property Users.instances is legal
    }
}

trace(PowerUsers.instances); // error, cannot access static property using PowerUsers class

Siehe auch

super([arg1, ..., argN])
super.method([arg1, ..., argN])

Ruft die Superclass-Version einer Methode oder eines Konstruktors auf. Wenn die Anweisung super() innerhalb des Hauptteils eines Klassenkonstruktors verwendet wird, ruft sie die Superclass-Version des Konstruktors auf. Der Aufruf des Superclass-Konstruktors muss die richtige Anzahl an Argumenten aufweisen. Beachten Sie, dass der Superclass-Konstruktor immer aufgerufen wird, unabhängig davon, ob Sie ihn explizit aufrufen oder nicht. Wenn der Aufruf nicht explizit erfolgt, wird automatisch ein argumentloser Aufruf vor der ersten Anweisung im Hauptteil des Subclass-Konstruktors eingefügt. Wenn Sie also eine Konstruktorfunktion in einer Unterklasse definieren und der Superclass-Konstruktor mindestens ein Argument besitzt, müssen Sie den Superclass-Konstruktor explizit mit der richtigen Anzahl an Argumenten aufrufen oder es wird eine Fehlermeldung erzeugt. Der Aufruf des Superclass-Konstruktors muss jedoch nicht die erste Anweisung im Subclass-Konstruktor sein. Diese Anforderung besteht nur in ActionScript 2.0.

Wenn super im Hauptteil einer Instanzmethode eingesetzt wird, kann es mit dem Punkt-Operator (.) verwendet werden, um die Superclass-Version einer Methode aufzurufen. Optional können auch Argumente (arg1 ... argN) an die Superclass-Methode übergeben werden. Auf diese Weise lassen sich Unterklassen-Methoden erstellen, die Superclass-Methoden nicht nur ein zusätzliches Verhalten zu hinzufügen, sondern die Superclass-Methoden auch zur Ausführung des ursprünglichen Verhaltens aufrufen.

Sie können die Anweisung super nicht in einer statischen Methode verwenden.

Siehe auch

switch (expression) {
	caseClause: 
	[defaultClause:] 
}

Führt abhängig vom Wert eines Ausdrucks dazu, dass die Steuerung an eine von mehreren Anweisungen übergeben wird. Alle switch-Anweisungen sollten eine case-Standardanweisung enthalten, die dann ausgeführt wird, wenn keine der case-Anweisungen dem Ausdruck entsprechen. Jede case-Anweisung muss mit einer break-Anweisung beendet werden, um einen Fall-Through-Fehler zu vermeiden. Wenn nach einer case-Anweisung ein "Fall-Though" auftritt, wird der Code in der nächsten case-Anweisung ausgeführt, auch wenn dieser Fall dem Test-Ausdruck nicht entspricht.

var switchExpression:int = 3;
        
switch (switchExpression) {
    case 0:
        trace(0);
        break;
    case 1:
        trace(1);
        break;
    case 2:
        trace(2);
        break;
    default:
        trace("Not 0, 1, or 2");
}

// output: Not 0, 1, or 2

Siehe auch

this

Ein Verweis auf die in einem Objekt enthaltene Methode. Bei der Ausführung eines Skripts verweist das Schlüsselwort this auf das Objekt, in dem das Skript enthalten ist. Im Hauptteil der Methode verweist das Schlüsselwort this auf die Klasseninstanz, in der die aufgerufene Methode enthalten ist.

// incorrect version of Simple.as
/*
dynamic class Simple {
    function callfunc() {
        func();
    }
}
*/
// correct version of Simple.as
dynamic class Simple {
    function callfunc() {
        this.func();
    }
}

var simpleObj:Simple = new Simple();
simpleObj.func = function() {
    trace("hello there");
}
simpleObj.callfunc();

Siehe auch

throw expression 

Erzeugt einen Fehler, der durch einen catch-Codeblock abgefangen bzw. verarbeitet werden kann. Wird eine Ausnahme nicht durch einen catch-Block abgefangen, wird die Stringdarstellung des ausgegebenen Werts an die Ausgabe gesendet. If an exception is not caught by a catch or finally block, the string representation of the thrown value is sent to the log file.

Normalerweise werden Instanzen der Fehlerklasse oder der dazugehörigen Unterklassen erzeugt (siehe Beispiele unten).

function checkEmail(email:String) { 
    if (email.indexOf("@") == -1) { 
        throw new Error("Invalid email address"); 
    } 
} 
checkEmail("someuser_theirdomain.com");

try { 
    checkEmail("Joe Smith"); 
} 
catch (e) { 
    trace(e); 
}
// output: Error: Invalid email address.

// Define Error subclass InvalidEmailError 
class InvalidEmailAddress extends Error { 
    public function InvalidEmailAddress() {
        message = "Invalid email address."; 
    }
}

import InvalidEmailAddress; 
function checkEmail(email:String) { 
    if (email.indexOf("@") == -1) { 
        throw new InvalidEmailAddress(); 
    } 
} 
try { 
    checkEmail("Joe Smith"); 
} 
catch (e) { 
    trace(e);
}
// output: Error: Invalid email address.

Siehe auch

true

Ein boolescher Wert, der "wahr" darstellt. Die beiden möglichen booleschen Werte sind true (wahr) und false (falsch). Das Gegenteil von true ist false. Wenn die automatische Typisierung true in eine Zahl umwandelt, wird daraus 1. Bei der Umwandlung von true in eine Zeichenfolge wird der Wert zu einem literalen "true".

var shouldExecute:Boolean;
// ...
// code that sets shouldExecute to either true or false goes here
// shouldExecute is set to true for this example:

shouldExecute = true;

if (shouldExecute == true) {
    trace("your statements here");
}

// true is also implied, so the if statement could also be written:
// if (shouldExecute) {
//         trace("your statements here");
// }

Das folgende Beispiel veranschaulicht die Umwandlung von true durch die automatische Typisierung in den Wert 1:

var myNum:Number;
myNum = 1 + true;
trace(myNum); // output: 2

Siehe auch

try { 
    // try block 
} finally { 
    // finally block  
} 

try { 
    // try block 
} catch(error[:ErrorType1]) {
    // catch block 
} [catch(error[:ErrorTypeN]) { 
    // catch block 
}] [finally {
    // finally block 
}]

Schließt einen Codeblock ein, in dem ein Fehler auftreten kann, und reagiert anschließend auf den Fehler. Die Ausnahmebehandlung, die mithilfe der try..catch..finally-Anweisungen implementiert wird, ist der primäre Mechanismus zur Handhabung von Laufzeitfehlern in ActionScript 3.0. Bei einem Laufzeitfehler gibt Flash Player einen Ausnahmefehler aus. Dies bedeutet, dass Flash Player die normale Ausführung unterbricht und ein Sonderobjekt des Typs Error erstellt. Dann übergibt Flash Player das fehlerhafte Objekt an den ersten verfügbaren catch-Codeblock. Falls keine catch-Codeblöcke verfügbar sind, wird die Ausnahme als eine nicht abgefangene Ausnahme angesehen. Nicht abgefangene Ausnahmen führen dazu, dass das Skript abgebrochen wird.

Sie können die Anweisung throw dazu verwenden, explizit Ausnahmen in Ihrem Code auszugeben. Sie können jeden Wert ausgeben, am besten bewährt hat sich jedoch die Ausgabe eines Objekts, da es eine gewisse Flexibilität aufweist und dem Verhalten von Flash Player entspricht.

Um eine Ausnahme abzufangen, platzieren Sie den Code, der einen Ausnahmefehler ausgibt, in einem try-Codeblock. Dabei spielt es keine Rolle, ob der Ausnahmefehler von Flash Player oder Ihrem Code ausgegeben wird. Wenn durch einen Code innerhalb des try-Codeblocks ein Ausnahmefehler ausgegeben wird, wird die Steuerung ggf. an den catch-Block und anschließend ggf. an den finally-Codeblock übergeben. Der finally-Block wird immer ausgeführt, unabhängig davon, ob ein Ausnahmefehler ausgegeben wurde. Auch wenn der Code im try-Block keinen Ausnahmefehler ausgibt (der try-Block also normal ausgeführt wird), wird der Code im catch-Block ignoriert, aber der Code im finally-Block wird trotzdem ausgeführt. Der finally-Block wird selbst dann ausgeführt, wenn der try-Block vorhanden ist und die Anweisung return verwendet.

Auf einen try-Block müssen entweder ein catch-Block, ein finally-Block oder beide Blöcke folgen. Ein einzelner try-Block kann mehrere catch-Blöcke enthalten, jedoch nur einen finally-Block. Sie können try-Blöcke über beliebig viele Ebenen ineinander verschachteln.

Der Parameter error, der in einer catch-Prozedur angegeben wurde, muss ein einfacher Bezeichner wie e, theException oder x sein. Der Parameter kann auch typisiert sein. Wenn mehrere catch-Blöcke verwendet werden, können Sie mit typisierten Parametern mehrere Fehlerobjekte abfangen, die von einem einzigen try-Block ausgegeben wurden.

Wenn die ausgegebene Ausnahme ein Objekt ist, ist der Typ korrekt, sofern das erzeugte Objekt eine Unterklasse des angegebenen Typs ist. Wenn ein Fehler eines bestimmten Typs erzeugt wird, wird der catch-Block ausgeführt, der den entsprechenden Fehler abfängt. Wenn eine Ausnahme eines nicht angegebenen Typs erzeugt wird, wird der catch-Block nicht ausgeführt und die Ausnahme wird automatisch vom try-Block an eine passende catch-Prozedur übergeben.

Wenn ein Fehler innerhalb einer Funktion ausgegeben wird und die Funktion keine catch-Prozedur enthält, werden diese Funktion und alle Aufruffunktionen von Flash Player beendet, bis ein catch-Block gefunden wird. Während dieses Prozesses werden auf allen Ebenen finally-Prozeduren aufgerufen.

import flash.display.Sprite;

var spr:Sprite = new Sprite();
try {
    spr.addChild(spr);
}
catch (e:ArgumentError) {
    trace(e); // output: ArgumentError: Error #2024: An object may not be added as a child of itself.
}

class RecordSetException extends Error { 
    public function RecordSetException () {
        message = "Record set exception occurred."; 
    }
}

class MalformedRecord extends Error { 
    public function MalformedRecord {
        message = "Malformed record exception occurred."; 
    }
}

class RecordSet { 
    public function sortRows() { 
        var returnVal:Number = randomNum(); 
        if (returnVal == 1) { 
            throw new RecordSetException(); 
        } 
        else if (returnVal == 2) { 
            throw new MalformedRecord(); 
        } 
    }
    public function randomNum():Number { 
        return Math.round(Math.random() * 10) % 3; 
    }
}

import RecordSet; 
var myRecordSet:RecordSet = new RecordSet();
try { 
    myRecordSet.sortRows(); 
    trace("everything is fine"); 
} 
catch (e:RecordSetException) { 
    trace(e.toString()); 
} 
catch (e:MalformedRecord) { 
    trace(e.toString()); 
}

Siehe auch

use namespace ns1[, ns2, ...nsN]

Führt dazu, dass die angegebenen Namespaces zum Satz der offenen Namespaces hinzuaddiert werden. Die angegebenen Namespaces werden aus dem Satz der offenen Namespaces entfernt, wenn der aktuelle Codeblock beendet wird. Die Direktive use namespace kann auf der obersten Ebene eines Programms, einer Paketdefinition oder Klassendefinition erscheinen.

Siehe auch

var variableName [= value1][...,variableNameN[=valueN]] 

Gibt eine Variable an. Wenn Sie Variablen innerhalb einer Funktion deklarieren, sind die Variablen lokal. Sie sind ausschließlich in dieser Funktion definiert und verlieren am Ende des Funktionsaufrufs ihre Gültigkeit.

Wenn Sie Variablen außerhalb einer Funktion deklarieren, stehen diese Variablen über die Zeitleiste zur Verfügung, die die Anweisung enthält.

Sie können eine Variable, die innerhalb eines anderen Objekts gültig ist, nicht als lokale Variable deklarieren.

my_array.length = 25; // ok 
var my_array.length = 25; // syntax error 

Sie können einer Variablen einen Datentyp zuweisen, indem Sie einen Doppelpunkt (:) gefolgt von dem Datentyp anhängen.

Außerdem haben Sie die Möglichkeit, mehrere Variablen mit nur einer Anweisung zu deklarieren, indem Sie die einzelnen Deklarationen mit Kommata abtrennen (wenn auch auf Kosten der syntaktischen Klarheit des Codes):

var first:String = "Bart", middle:String = "J.", last:String = "Bartleby";

var product_array:Array = new Array("Studio", "Dreamweaver", "Flash", "ColdFusion", "Contribute", "Breeze"); 
product_array.push("Flex"); 
trace(product_array); 
// output: Studio,Dreamweaver,Flash,ColdFusion,Contribute,Breeze,Flex

Siehe auch

while (condition) { 
	// statement(s)
}

Wertet eine Bedingung aus. Ergibt die Bedingung den Wert true, wird mindestens eine Anweisung ausgeführt, bevor die Logik zum Beginn der Schleife zurückkehrt und die Bedingung erneut auswertet. Bei false werden die nachfolgenden Anweisungen übersprungen und die Schleife endet.

Die Anweisung while führt folgende Schritte durch: Jede Wiederholung der Schritte 1 bis 4 wird als eine Iteration der Schleife bezeichnet. Die Bedingung wird wie in den folgenden Schritten zu Beginn jeder Iteration erneut getestet:

1. Der Ausdruck condition wird ausgewertet.
2. Wenn condition als true ausgewertet wird oder als ein Wert, der in den booleschen Wert true umgewandelt werden kann, z. B. in eine Zahl ungleich Null, fahren Sie mit Schritt 3 fort. Andernfalls wird die Anweisung while vollständig ausgeführt und die Ausführung wird mit der nächsten Anweisung nach der Schleife while fortgesetzt.
3. Der Anweisungsblock statement(s) wird ausgeführt. Wenn eine continue-Anweisung auftritt, überspringen Sie die verbleibenden Anweisungen und gehen zu Schritt 1. Wenn jedoch eine break-Anweisung auftritt, wird die while-Anweisung vollständig ausgeführt und die Ausführung setzt mit der nächsten Anweisung hinter der while-Schleife fort.
4. Gehe zurück zu Schritt 1.

Schleifen werden in der Regel zur Ausführung einer Aktion in Abhängigkeit von einer Zählervariablen verwendet, die unter einem bestimmten Wert liegen muss. Am Ende jeder Schleife wird der Zähler erhöht, bis der angegebene Wert erreicht ist. An dieser Stelle hat der Parameter condition nicht mehr den Wert true, und die Schleife wird verlassen.

Die geschweiften Klammern ({}), die die von der Anweisung auszuführenden Anweisungen einschließen, while sind nicht erforderlich, wenn nur eine Anweisung ausgeführt wird.

var i:Number = 0; 
while (i < 20) { 
    trace(i); 
    i += 3; 
}
/* output:
0 
3 
6 
9 
12
15 
18
*/

Siehe auch

with (object:Object) { 
	// statement(s)
}

Richtet ein Standardobjekt ein, das für die Ausführung einer oder mehrerer Anweisungen verwendet werden soll. Auf diese Weise reduzieren Sie die Menge an Code, die geschrieben werden muss.

Der Parameter object wird zum Kontext, in dem die Eigenschaften, Variablen und Funktionen im Parameter statement(s) interpretiert werden. Angenommen, object ist my_array und zwei der angegebenen Eigenschaften sind length und concat, werden diese Eigenschaften automatisch als my_array.length und my_array.concat gelesen. Wenn object in einem anderen Beispiel den Wert state.california hat, werden Aktionen oder Anweisungen innerhalb der with-Anweisung von innerhalb der Instanz california aufgerufen.

Um den Wert eines Bezeichners im Parameter statement(s) zu ermitteln, beginnt ActionScript am Anfang der durch object angegebenen Gültigkeitsbereichskette und sucht in einer bestimmten Reihenfolge auf jeder Stufe der Gültigkeitsbereichskette nach diesem Bezeichner.

Die in der with-Anweisung zum Auflösen von Bezeichnern verwendete Gültigkeitsbereichskette beginnt mit dem ersten und endet mit dem letzten der in der folgenden Liste aufgeführten Elemente:

• Das im Parameter object der innersten with-Anweisung angegebene Objekt.
• Das im Parameter object der äußersten with-Anweisung angegebene Objekt.
• Das Aktivierungsobjekt (ein temporäres Objekt, das automatisch beim Aufruf einer Funktion erstellt wird und die in der Funktion aufgerufenen lokalen Variablen enthält).
• Das Objekt, in dem das zurzeit ausgeführte Skript enthalten ist.
• Das globale Objekt (vordefinierte Objekte, z. B. "Math" oder "String").

Um eine Variable innerhalb einer with-Anweisung setzen zu können, muss die Variable bereits außerhalb der with-Anweisung deklariert worden sein. Andernfalls müssen Sie den vollständigen Pfad zu der Zeitleiste eingeben, in der die Variable verwendet werden soll. Wenn Sie eine Variable innerhalb einer with-Anweisung setzen, die nicht zuvor deklariert wurde, sucht die Anweisung with deren Wert entsprechend der Gültigkeitsbereichskette. Wenn die Variable noch nicht vorhanden ist, wird der neue Wert auf der Zeitleiste gesetzt, von der aus die with-Anweisung aufgerufen wurde.

with (someOther_mc) { 
    _x = 50; 
    _y = 100; 
    gotoAndStop(3); 
}

someOther_mc._x = 50; 
someOther_mc._y = 100; 
someOther_mc.gotoAndStop(3);

Die Anweisung with bietet sich für den Zugriff auf mehrere Elemente in einer Gültigkeitsbereichskette an. In dem folgenden Beispiel wird das integrierte Math-Objekt an die erste Position der Gültigkeitsbereichskette gestellt. Wenn Sie "Math" als Standardobjekt festlegen, werden die Bezeichner cos, sin und PI entsprechend zu Math.cos, Math.sin und Math.PI aufgelöst. Die Bezeichner a, x, y und r sind keine Methoden oder Eigenschaften des Math-Objekts, sondern werden zu den entsprechenden lokalen Variablen aufgelöst, da sie sich im Aktivierungsbereich der Funktionpolar() befinden.

function polar(r:Number):void { 
    var a:Number, x:Number, y:Number; 
    with (Math) { 
        a = PI * pow(r, 2); 
        x = r * cos(PI); 
        y = r * sin(PI / 2); 
    } 
    trace("area = " + a); 
    trace("x = " + x); 
    trace("y = " + y); 
} polar(3);
/* output: 
area = 28.2743338823081 
x = -3 
y = 3
*/