Anweisungen, Schlüsselwörter und Direktiven 

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.

Bei der Verwendung zusammen mit anderen Parametern muss der Parameter ... (rest) als letzter angegeben werden. 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 übergeben, wird das gesamte Array in ein einzelnes Element des ... (rest)-Parameterarrays platziert.

Wenn Sie diesen Parameter verwenden, steht das Objekt arguments nicht mehr zur Verfügung. Obwohl Ihnen der Parameter ... (rest) die gleichen Funktionsmerkmale wie das arguments-Array und die arguments.length-Eigenschaft zur Verfügung stellt, verfügt er nicht über die Funktionsmerkmale, die Ihnen von arguments.callee bereitgestellt werden. Bevor Sie den ... (rest)-Parameter einsetzen, stellen Sie sicher, dass Sie arguments.callee nicht verwenden müssen.

package {
	import flash.display.MovieClip;
	
	public class RestParamExample extends MovieClip {
		public function RestParamExample() {
			traceParams(100, 130, "two"); // 100,130,two
			trace(average(4, 7, 13));     // 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);
}

Verwandte API-Elemente

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 setzen (Standardeinstellung in Flex Builder 2), 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).

Verwandte API-Elemente

Erscheint in einer Schleife (for, for..in, for each..in, do..while oder while) oder in einem Block von Anweisungen, die mit einem bestimmten Fall in einer switch-Anweisung verknüpft sind. Bei Verwendung in einer Schleift weist die break-Anweisung Flash an, den Rest des Schleifenhauptteils zu überspringen und die Anweisung auszuführen, die nach der Schleife 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++; 
} 
/*
0 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10*/

Verwandte API-Elemente

case jumpTarget: statements

Definiert ein Sprungziel für die switch-Anweisung. Wenn bei einem Vergleich mithilfe des strikten Gleichheitsoperators (===) der Parameter jumpTarget mit dem Parameter expression der switch-Anweisung übereinstimmt, führt Flash Player die im Parameter statements enthaltenen Anweisungen 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.

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

Verwandte API-Elemente

[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 zur Laufzeit dynamische Eigenschaften 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. Um Unterklassen einer Klasse zu erstellen, verwenden Sie das Schlüsselwort extends. (Eine Klasse kann nur eine Klasse erweitern, kann jedoch 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üsselwörter 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); 

Verwandte API-Elemente

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

Verwandte API-Elemente

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

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

Verwandte API-Elemente

default: statements 

Definiert die Standardbedingung für die switch-Anweisung. Die Anweisungen werden ausgeführt, wenn der Parameter expression der Anweisung switch bei Vergleich mit dem 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 auch nicht an letzter Stelle stehen. Wenn Sie die Anweisung default 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"); 
}

Verwandte API-Elemente

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

Wenn Sie die 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 = ;
trace("x1 ns: " + x1.namespace());
			
scopeCheck();	

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

}

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

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

var x2:XML = ;
trace(x2.namespace());
	// http://www.w3.org/1999/XSL/Transform/

var x3:XML = ;
trace(x3.namespace());
	// http://www.example.com/namespaces/

Verwandte API-Elemente

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.

Eine do..while-Schleife stellt sicher, dass der Code 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 als true, ausgewertet wird, ist die do..while-Schleife endlos. 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. Obwohl for-Schleifen leicht zu lesen und zu debuggen sind, können sie die do..while-Schleifen nicht unter allen Umständen ersetzen.

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

Verwandte API-Elemente

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

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

Verwandte API-Elemente

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

Gibt die Anweisungen an, die ausgeführt werden, wenn die Bedingung in der if-Anweisung false zurückgibt. 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"); 
}

Verwandte API-Elemente

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.

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(); // [Vehicle] start 
myNewCar.stop(); // [Car] stop with anti-lock brakes 
myNewCar.activateCarAlarm(); // [Car] activateCarAlarm

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(); // [Truck] make beeping sound [Vehicle] reverse 
myTruck.stop(); // [Vehicle] stop

Verwandte API-Elemente

false

Ein boolescher Wert, der „false“ (falsch) darstellt. Die beiden möglichen booleschen Werte sind true (wahr) oder 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 einen String wird der Wert zu einem literalen false.

Hinweis: 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

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

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

Verwandte API-Elemente

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.

Verwandte API-Elemente

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.

Verwandte API-Elemente

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 die 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); // 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); // 5050

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

Verwandte API-Elemente

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]); 
} 
/*
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); 
	} 
}
/*
I have a string property named city
I have a string property named firstName
*/

Verwandte API-Elemente

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

Durchläuft die Elemente in einer Sammlung und führt statement für jedes Element aus. Die als Teil der E4X-Spracherweiterungen eingeführte for each..in-Anweisung kann nicht nur für XML-Objekte, sondern auch für Objekte und Arrays verwendet werden. Die for each..in -Anweisung 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. Um die for each..in-Anweisung mit einer Instanz einer benutzerdefinierten Klasse zu verwenden, müssen Sie die Klasse als dynamic deklarieren.

Im Gegensatz zur for..in-Anweisung durchläuft die for each..in-Anweisung die Werte der Objekteigenschaften und nicht die Eigenschaftsnamen.

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

var myArray:Array = new Array("one", "two", "three"); 
for each(var item in myArray) 
	trace(item); 
/*
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); 
	} 
}

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

var doc:XML = 
		
			
Hello
			
Hola
			

			
Bonjour
		;
for each (var item in doc.p) {
	trace(item);
}

/*
Hello
Hola
Bonjour
*/

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

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

Verwandte API-Elemente

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, indem 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 einer 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); 
/*
San Fran San Francisco */

Verwandte API-Elemente

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

Wertet eine Bedingung aus, um die nächste auszuführende Anweisung festzulegen. Wenn die Bedingung true ergibt, 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.

Verwandte API-Elemente

myClass implements interface01 [, interface02 , ...] 

Gibt an, das 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 zum von der Schnittstelle definierten Datentyp statt.

Verwandte API-Elemente

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

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.

 interface InterfaceName [extends InterfaceName ] {}

Definiert eine Schnittstelle. 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 erlaubt ActionScript 3.0 die Verwendung von get- und set-Methoden in Schnittstellendefinitionen.

Verwandte API-Elemente

[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.

Verwandte API-Elemente

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 den Rest der unmittelbaren Schleife überspringen, nicht jedoch die gesamte Serie der verschachtelten Schleifen. Wenn die Anweisung, die eine gesamte Serie von Schleifen definiert, mit einer Bezeichnung verknüpft ist, kann eine break- oder continue-Anweisung die gesamte Serie von Schleifen überspringen, 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);
	}
}
/*
1
2
...
79
*/

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

Verwandte API-Elemente

namespace name [= uri]

Ermöglicht Ihnen, die Sichtbarkeit von Definitionen zu bestimmen. Die vordefinierten Namespaces umfassen public, private, protected und internal.

Die folgenden Schritte zeigen Ihnen, wie Sie einen 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 myProperty auf den Namespace version1.

Verwandte API-Elemente

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

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

Verwandte API-Elemente

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 zu setzen, verwenden Sie das Attribut override und achten darauf, dass Name, Klasseneigenschaftsattribut, Anzahl und Typ der Parameter sowie der 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.

Verwandte API-Elemente

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.

Verwandte API-Elemente

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 auf eine Klasse oder andere 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
  }
}

Verwandte API-Elemente

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 auf eine Klasse oder andere 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 erlaubt. 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);  // Access attempt from subclass succeeded
  }
}

Verwandte API-Elemente

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); // 27 jimmy

Verwandte API-Elemente

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, 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); // 114

Verwandte API-Elemente

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.

Set-Methoden ermöglichen Ihnen das Verbergen von Informationen, indem 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 set-Methoden besteht darin, dass sie in Unterklassen außer Kraft gesetzt werden können. Dies ist bei Eigenschaften, die mit var deklariert wurden, nicht möglich.

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

Eine set-Methode kann mit einer 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); // 25

Verwandte API-Elemente

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 Date-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 Qualifizierer auf eine statische Variable oder Methode innerhalb einer Klasse bzw. Unterklasse verweisen. Betrachten Sie dazu das folgende Beispiel.

Mit einer statischen 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

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

Ruft die Superclass- oder übergeordnete 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 die 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 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.

Verwandte API-Elemente

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

// Not 0, 1, or 2

Verwandte API-Elemente

this

Ein Verweis auf das in einer Methode enthaltene Objekt. 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();

throw expression 

Erzeugt bzw. gibt einen Fehler aus, der durch einen catch-Codeblock abgefangen werden kann. Wird eine Ausnahme nicht durch einen catch-Block abgefangen, wird die Stringdarstellung des ausgegebenen Werts an die Ausgabe gesendet. Wird eine Ausnahme nicht durch einen catch- oder finally-Block abgefangen, wird die Stringdarstellung des ausgegebenen Werts an die Protokolldatei gesendet.

Normalerweise werden Instanzen der Fehlerklasse oder der zugehö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); 
}
// 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);
}
// Error: Invalid email address.

Verwandte API-Elemente

true

Ein boolescher Wert, der „true“ (wahr) darstellt. Die beiden möglichen booleschen Werte sind true (wahr) oder false (falsch). Das Gegenteil von true ist falsch. Wenn die automatische Typisierung true in eine Zahl umwandelt, wird daraus 1. Bei der Umwandlung von true in einen String 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");
// }

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

Verwandte API-Elemente

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. Ausnahmebehandlung, die mit den try..catch..finally-Anweisungen implementiert wird, ist der primäre Mechanismus für die Verarbeitung von Fehlerbedingungen in ActionScript 3.0. Wenn ein Laufzeitfehler auftritt, gibt Flash Player eine Ausnahme aus, was bedeutet, dass Flash Player nicht mehr normal ausgeführt wird und ein spezielles Objekt 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 wird.

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 error-Parameter, 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 Fehlertypen 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, wird diese Funktion sowie alle Aufruffunktionen von Flash Player beendet, bis ein catch-Block gefunden wird. Während dieses Prozesses werden auf allen Ebenen finally-Prozeduren aufgerufen.

Hinweis: Wenn Sie in einem Versuchsblock sind, gibt es einen Ereignisverteiler, der seinen Ereignishandler aufruft. Der Erfassungsblock erfasst den Fehler nicht, wenn er in einem Ereignishandler auftritt. Jeder Fehler, der anschließend ausgegeben wird, kann von LoaderInfo.uncaughtErrorEvents erfasst werden.

import flash.display.Sprite;

var spr:Sprite = new Sprite();
try {
	spr.addChild(spr);
}
catch (e:ArgumentError) {
	trace (e); // 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()); 
}

Verwandte API-Elemente

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.

Verwandte API-Elemente

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.

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 trennen (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); 
// Studio,Dreamweaver,Flash,ColdFusion,Contribute,Breeze,Flex

Verwandte API-Elemente

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 whilefortgesetzt.
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 nach der while-Schleife fort.
4. Weiter mit 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 beendet.

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

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

Verwandte API-Elemente

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 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 zur 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 with-Anweisung deren Wert entsprechend der Gültigkeitsbereichskette. Wenn die Variable noch nicht vorhanden ist, wird der neue Wert auf der Zeitleiste gesetzt, über die die with-Anweisung aufgerufen wurde.

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);
/* 
area = 28.2743338823081 
x = -3 
y = 3
*/