Programmeerinstructies, gereserveerde woorden en compileraanwijzingen 

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

Geeft op dat een functie een willekeurig aantal door komma's gescheiden argumenten accepteert. De lijst met argumenten wordt een array die beschikbaar is in de gehele hoofdtekst van de functie. De naam van de array wordt opgegeven na de tekens ... in de parameterdeclaratie. De parameter kan elke naam hebben die geen trefwoord is.

Bij gebruik met andere parameters moet de parameterdeclaratie ... (rest) de laatste parameter zijn die wordt opgegeven. De parameterarray ... (rest) wordt alleen gevuld wanneer het aantal argumenten dat aan de functie is doorgegeven, hoger is dan het aantal overige parameters.

Elk argument in de lijst met door komma's gescheiden argumenten wordt in een element van de array geplaatst. Wanneer u een instantie van de klasse Array doorgeeft, wordt de gehele array in één element van de parameterarray ... (rest).

Wanneer u deze parameter gebruikt, is het object arguments niet beschikbaar. Hoewel de parameter ... (rest) dezelfde functionaliteit biedt als de array arguments en de eigenschap arguments.length, biedt deze niet dezelfde soort functionaliteit als arguments.callee. Zorg ervoor dat u arguments.callee niet hoeft te gebruiken voordat de parameter ... (rest) wordt gebruikt.

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

Verwante API-elementen

Definieert methoden en eigenschappen van de kernklassen van ActionScript, die vaste eigenschappen zijn in plaats van eigenschappen prototype. Als u de compileroptie "-as3" instelt op true (de standaardinstelling in Flex Builder 2), wordt de naamruimte AS3 automatisch geopend voor alle kernklassen. Dit betekent dat een instantie van een kernklasse vaste eigenschappen en methoden gebruikt in plaats van de versies van diezelfde eigenschappen en methoden die aan het prototypeobject van de klasse zijn gekoppeld. Het gebruik van vaste eigenschappen resulteert doorgaans in betere prestaties, maar dit gaat wel ten koste van achterwaartse compatibiliteit met de ECMAScript Language Specification (ECMA-262), 3rd Edition.

Verwante API-elementen

Wordt gebruikt binnen een lus (for, for..in, for each..in, do..while of while) of binnen een blok instructies voor een bepaalde case in een switch-instructie. Wanneer u de instructie break in een lus gebruikt, instrueert deze instructie Flash de resterende inhoud van de lus over te slaan, de herhaling te beëindigen en de instructie na de lusinstructie uit te voeren. Als u de instructie break in een switch gebruikt, geeft deze aan Flash door de rest van de instructies in het blok case over te slaan en naar de eerste instructie na de omsluitende switch-instructie te springen.

De instructie break slaat in geneste lussen alleen de rest van de huidige lus over en stapt niet uit de gehele reeks geneste lussen. Als u de gehele reeks geneste lussen wilt verlaten, gebruikt u label of try..catch..finally.

De instructie break kan een optioneel label hebben. Dit moet overeenkomen met het label van een instructie buiten de lus. Het gebruik van een label dat niet overeenkomt met het label van een instructie buiten de lus, is een syntaxisfout. Gelabelde break-instructies kunnen worden gebruikt om meerdere niveaus van geneste lusinstructies, switch-instructies of block-instructies te verlaten. Zie de vermelding voor de instructie label voor een voorbeeld.

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

Verwante API-elementen

case jumpTarget: statements

Definieert een sprongdoel voor de instructie switch. Als de parameter jumpTarget gelijk is aan de parameter expression van de switch-instructie die strikte gelijkheid gebruikt (===), voert Flash Player de instructies in de parameter statements uit totdat een break-instructie of het einde van de switch-instructie wordt aangetroffen.

Als u de instructie case buiten een switch-instructie gebruikt, genereert deze een fout en kan het script niet worden gecompileerd.

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

Verwante API-elementen

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

Definieert een klasse waarmee u objecten kunt instantiëren die methoden en eigenschappen delen die u definieert. Wanneer u bijvoorbeeld een trackingsysteem voor facturen ontwikkelt, kunt u een klasse Invoice maken die alle methoden en eigenschappen definieert die elke factuur moet hebben. U gebruikt vervolgens de opdracht new Invoice() om objecten Invoice te maken.

Elk ActionScript-bronbestand kan slechts één klasse bevatten die zichtbaar is voor andere bronbestanden of scripts. De extern zichtbare klasse kan een klasse van het type public of internal zijn en moet binnen een pakketinstructie worden gedefinieerd. Wanneer u andere klassen in hetzelfde bestand opneemt, moeten de klassen buiten de pakketinstructie en aan het einde van het bestand worden geplaatst.

De naam van de extern zichtbare klasse moet overeenkomen met de naam van het ActionScript-bronbestand dat de klasse bevat. De naam van het bronbestand moet de naam zijn van de klasse met de bestandsextensie .as. Wanneer u bijvoorbeeld een klasse Student benoemt, moet het bestand dat de klasse definieert de naam Student.as hebben.

Klassedefinities kunnen niet worden genest. U kunt dus geen extra klassen definiëren binnen een klassedefinitie.

U kunt een constructormethode definiëren. Dit is een methode die wordt uitgevoerd zodra een nieuwe instantie van de klasse wordt gemaakt. De naam van de constructormethode moet overeenkomen met de naam van de klasse. Wanneer u geen constructormethode definieert, wordt een standaardconstructor gemaakt.

Wanneer u wilt aangeven dat objecten bij uitvoering eigenschappen van het type dynamic kunnen toevoegen en gebruiken, plaatst u het gereserveerde woord dynamic vóór de instructie class. Wanneer u wilt declareren dat een klasse een interface implementeert, gebruikt u het gereserveerde woord implements. Wanneer u subklassen van een klasse wilt maken, gebruikt u het gereserveerde woord extends. (Een klasse kan slechts één klasse uitbreiden, maar kan wel verschillende interfaces implementeren.) U kunt implements en extends in één instructie gebruiken. In de volgende voorbeelden ziet u hoe de trefwoorden implements en extends meestal worden gebruikt:

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

Verwante API-elementen

const identifier = value 

Geeft een constante op. Dit is een variabele waaraan maar eenmaal een waarde kan worden toegekend.

U kunt een constante strikt invoeren door een dubbele punt (:) toe te voegen, gevolgd door het gegevenstype.

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

Verwante API-elementen

continue [label]

Springt over alle resterende instructies in de binnenste lus start en de volgende herhaling van de lus alsof het op normale wijze bij het einde was aangekomen. De instructie continue heeft geen effect buiten een lus. Gebruik in geneste lussen de optionele parameter label wanneer u meer dan alleen de binnenste lus wilt overslaan.

De instructie continue kan een optioneel label hebben. Dit moet overeenkomen met het label van een instructie buiten de lus. Het gebruik van een label dat niet overeenkomt met het label van een instructie buiten de lus, is een syntaxisfout. Gelabelde instructies continue kunnen worden gebruikt om meerdere niveaus van geneste lusinstructies over te slaan.

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

Verwante API-elementen

default: statements 

Definieert de standaard-case voor een instructie switch. De instructies worden uitgevoerd als de parameter expression van de instructie switch (via de operator voor strikte gelijkheid [===]) ongelijk is aan de expression-parameters volgend op de case-trefwoorden voor een bepaalde switch-instructie.

Een switch-instructie heeft geen default-case-instructie nodig. De instructie default hoeft niet de laatste in de lijst van case-instructies te zijn. Als u een default-instructie buiten een switch-instructie gebruikt, genereert deze een fout en kan het script niet worden gecompileerd.

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

Verwante API-elementen

Met de aanwijzing default xml namespace wordt de standaardnaamruimte ingesteld die voor XML-objecten moet worden gebruikt.

Wanneer u default xml namespace niet instelt, is de standaardnaamruimte de onbenoemde naamruimte (waarbij de URI op een lege tekenreeks is ingesteld). Het bereik van een declaratie default xml namespace valt binnen een functieblok, zoals het bereik van een variabele.

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/

Verwante API-elementen

do { statement(s) } while (condition)

Lijkt op een lus while, met dit verschil dat de instructies eenmaal worden uitgevoerd voorafgaand aan de eerste evaluatie van de voorwaarde. De instructies worden hierna alleen uitgevoerd als de voorwaarde de waarde true oplevert.

Een do..while-lus zorgt ervoor dat de code binnen de lus ten minste één keer wordt uitgevoerd. Hoewel u dit ook met een while-lus kunt doen (door een kopie van de instructies die moeten worden uitgevoerd voor het begin van de while-lus te plaatsen), zijn veel programmeurs van mening dat do..while-lussen gemakkelijker te lezen zijn.

Als de voorwaarde altijd true oplevert, is de lus do..while oneindig. Wanneer u een oneindige lus invoert, doen zich problemen voor met Flash Player en wordt uiteindelijk een foutmelding gegenereerd of loopt de speler vast. Gebruik waar mogelijk een lus for als u weet hoeveel keer u de lus wilt uitvoeren. Hoewel for-lussen gemakkelijker te lezen en op fouten te controleren zijn, kunnen ze do..while lussen niet in alle omstandigheden vervangen.

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

Verwante API-elementen

dynamic class className { // class definition here }

Geeft op dat instanties van een klasse dynamische eigenschappen kunnen bezitten die bij uitvoering worden toegevoegd. Wanneer u het kenmerk dynamic voor een klasse gebruikt, kunt u bij uitvoering eigenschappen aan instanties van die klasse toevoegen. Klassen die niet zijn gemarkeerd als dynamic, worden als verzegeld beschouwd, zodat geen eigenschappen aan instanties van de klasse kunnen worden toegevoegd.

Wanneer de klasse is verzegeld (niet dynamisch), resulteren pogingen tot het ophalen of instellen van eigenschappen van klasse-instanties in een fout. Wanneer u de compiler op strikte modus instelt en het gegevenstype opgeeft wanneer u instanties maakt, wordt bij pogingen om eigenschappen aan verzegelde objecten toe te voegen een compileerfout gegenereerd; anders treedt een fout bij uitvoering op.

Het kenmerk dynamic wordt niet overerfd door subklassen. Wanneer u een klasse van het type dynamic uitbreidt, is de subklasse alleen van het type dynamic wanneer u de subklasse met het kenmerk dynamic declareert.

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

Verwante API-elementen

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

Geeft op welke instructies moeten worden uitgevoerd als de voorwaarde in de instructie if de waarde false retourneert. De accolades ({}) rondom de instructies die moeten worden uitgevoerd door de instructie else zijn niet nodig als slechts één instructie wordt uitgevoerd.

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

Verwante API-elementen

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

Definieert een klasse die een subklasse van een andere klasse is. De subklasse overerft alle methoden, eigenschappen, functies, enzovoort, die in de superklasse zijn gedefinieerd. Klassen die zijn gemarkeerd als final, kunnen niet worden uitgebreid.

U kunt ook het gereserveerde woord extends gebruiken om een interface uit te breiden. Een interface die een andere interface uitbreidt, omvat alle methodedeclaraties van de oorspronkelijke interface.

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

Verwante API-elementen

false

Booleaanse waarde die false vertegenwoordigt. Een Booleaanse waarde is true of false; het tegengestelde van false is true.

Wanneer false via automatische gegevenstypering in een getal wordt omgezet, wordt de waarde 0; wanneer false in een tekenreeks wordt omgezet, is het resultaat "false".

Opmerking: de tekenreeks "false" wordt omgezet in de Booleaanse waarde true.

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

Verwante API-elementen

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

Geeft op dat een methode niet kan worden overschreven of dat een klasse niet kan worden uitgebreid. Een poging tot het overschrijven van een methode of tot het uitbreiden van een klasse die als final is gemarkeerd, resulteert in een fout.

Verwante API-elementen

Definieert de methoden van de klasse Proxy. De methoden van de klasse Proxy bevinden zich in hun eigen naamruimte om naamconflicten te vermijden in situaties waarbij de Proxy-subklasse instantiemethodenamen bevat die overeenkomen met namen van methoden van de klasse Proxy.

Verwante API-elementen

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

Evalueert de expressie init (initialiseren) eenmaal en start vervolgens een herhalingsreeks. De herhalingsreeks begint door de expressie condition te evalueren. Als de expressie condition de waarde true oplevert, wordt statement uitgevoerd en wordt next geëvalueerd. De herhalingsreeks begint vervolgens opnieuw met de evaluatie van de expressie condition.

De accolades ({}) rondom het blok instructies die door de instructie for moeten worden uitgevoerd, zijn niet nodig als slechts één instructie wordt uitgevoerd.

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

Verwante API-elementen

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

Doorloopt de dynamische eigenschappen van een object of elementen in een array en voert de statement uit voor elke eigenschap of elk element. Objecteigenschappen worden niet in een bepaalde volgorde opgeslagen en kunnen dus in schijnbaar willekeurige volgorde worden weergegeven. Vaste eigenschappen, zoals variabelen en methoden die in een klasse zijn gedefinieerd, worden niet opgesomd door de instructie for..in. Voor een lijst van vaste eigenschappen gebruikt u de functie describeType() in het pakket flash.utils.

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

Verwante API-elementen

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

Doorloopt de items van een verzameling en voert voor elk item statement uit. De instructie for each..in, die als onderdeel van de uitbreidingen van de E4X-taal is geïntroduceerd, kan niet alleen voor XML-objecten worden gebruikt maar ook voor objecten en arrays. De instructie for each..in doorloopt alleen de dynamische eigenschappen van een object, niet de vaste eigenschappen. Een vaste eigenschap is een eigenschap die is gedefinieerd als deel van een klassedefinitie. Als u de instructie for each..in met een instantie van een door de gebruiker gedefinieerde klasse wilt gebruiken, moet u de klasse met het kenmerk dynamic declareren.

In tegenstelling tot de instructie for..in, doorloopt de instructie for each..in de waarden van de eigenschappen van een object en niet de eigenschapsnamen.

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

Bestaat uit een set instructies die u definieert om een bepaalde taak uit te voeren. U kunt een functie op één locatie definiëren en deze vanuit verschillende scripts in een SWF-bestand gebruiken of aanroepen . Wanneer u een functie definieert, kunt u ook parameters voor de functie opgeven. Parameters worden gebruikt als houders voor waarden waarop de functie wordt uitgevoerd. U kunt telkens wanneer u een functie aanroept verschillende parameters doorgeven, zodat de functie in verschillende situaties opnieuw kan worden gebruikt.

Gebruik de instructie return in het blok statement(s) van een functie om te zorgen dat de functie een waarde genereert of retourneert .

Gebruik 1: u kunt het trefwoord function gebruiken om een functie met de opgegeven functienaam, parameters en instructies te definiëren. Wanneer een script een functie aanroept, worden de instructies in de functiedefinitie uitgevoerd. Vooruit verwijzen is toegestaan; een functie kan binnen hetzelfde script worden gedeclareerd nadat deze is aangeroepen. Een functiedefinitie vervangt een vorige definitie van dezelfde functie. U kunt deze syntaxis overal waar een instructie is toegestaan gebruiken.

Gebruik 2: u kunt function ook gebruiken om een anonieme functie te maken en een verwijzing daarnaar te retourneren. Deze syntaxis wordt in expressies gebruikt en is met name nuttig bij het installeren van methoden in objecten.

U kunt het object arguments in de functiedefinitie gebruiken voor extra functionaliteit. Het object arguments wordt vaak gebruikt bij het maken van een functie die een variabel aantal parameters accepteert en bij het maken van een recursieve anonieme functie.

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

Verwante API-elementen

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

Definieert een getter, een methode die als een eigenschap kan worden gelezen. Een getter is een speciale functie die de waarde retourneert van een eigenschap die met het trefwoord var of const is gedeclareerd. In tegenstelling tot andere methoden wordt een getter aangeroepen zonder haakjes ( ()), zodat de getter een variabele lijkt.

Met behulp van getters kunt u informatie verbergen door een openbare interface voor een eigenschap van het type private te maken. Het voordeel van het verbergen van informatie is dat de openbare interface gelijk blijft ook al verandert de onderliggende implementatie van de eigenschap van het type private.

Een ander voordeel van getters is dat ze kunnen worden overschreven in subklassen, terwijl dat niet mogelijk is bij eigenschappen die met var of const worden gedeclareerd.

Een getter kan met een setter worden gecombineerd om een lezen-schrijven eigenschap te maken. Wanneer u een alleen-lezen eigenschap wilt maken, maakt u een getter zonder overeenkomende setter. Wanneer u een alleen-schrijven eigenschap wilt maken, maakt u een setter zonder overeenkomende getter.

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

Verwante API-elementen

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

Evalueert een voorwaarde om te bepalen welke instructie vervolgens moet worden uitgevoerd. Als de voorwaarde true is, voert Flash Player de instructies uit die tussen accolades ({}) op de voorwaarde volgen. Wanneer de voorwaarde false is, slaat Flash de instructies binnen de accolades over en voert de instructies uit die op de accolades volgen. Gebruik de instructie if samen met de instructie else om vertakkende logica in uw scripts te maken.

De accolades ({}) rondom de instructies die moeten worden uitgevoerd door de instructie if zijn niet nodig als slechts één instructie wordt uitgevoerd.

Verwante API-elementen

myClass implements interface01 [, interface02 , ...] 

Geeft op dat een klasse een of meer interfaces implementeert. Wanneer een klasse een interface implementeert, moet de klasse alle methoden definiëren die in de interface zijn gedeclareerd. Elke instantie van een klasse die een interface implementeert, wordt beschouwd als lid van het gegevenstype dat door de interface is gedefinieerd. Als gevolg hiervan retourneert de operator is de waarde true als de klasse-instantie de eerste operand is en de interface de tweede. Bovendien werkt omzetting van en naar het gegevenstype dat door de interface is gedefinieerd.

Verwante API-elementen

import packageName.className 
import packageName.*

Maakt klassen en pakketten beschikbaar voor uw code. Wanneer u bijvoorbeeld de klasse flash.display.Sprite in een script wilt gebruiken, moet u deze importeren. Deze vereiste verschilt van lagere versies van ActionScript, waar de aanwijzing import optioneel was.

Na gebruik van de aanwijzing import kunt u de volledige klassenaam gebruiken, inclusief de pakketnaam, of alleen de naam van de klasse.

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

Wanneer het pakket verschillende klassebestanden bevat waartoe u toegang wilt hebben, kunt u ze allemaal importeren in een enkele instructie, zoals in het volgende voorbeeld wordt getoond:

import flash.display.*;

Met de aanwijzing import worden alleen de klassen, functies en variabelen geïmporteerd die zich op het bovenste niveau van het geïmporteerde pakket bevinden. Geneste pakketten moeten expliciet worden geïmporteerd.

Wanneer u een klasse importeert maar niet gebruikt in uw script, wordt de klasse niet als onderdeel van het SWF-bestand geëxporteerd. Dit betekent dat u grote pakketten kunt importeren zonder dat u zich zorgen hoeft te maken over de grootte van het SWF-bestand; de bytecode die aan een klasse is gekoppeld, wordt alleen in een SWF-bestand opgenomen wanneer die klasse daadwerkelijk wordt gebruikt. Een nadeel van het importeren van klassen die u niet nodig hebt, is dat de kans op naamconflicten toeneemt.

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

include "[path]filename.as"

Zorgt dat de inhoud van het opgegeven bestand wordt opgenomen alsof de opdrachten in het bestand deel zijn van het aanroepende script. De compileraanwijzing include wordt tijdens de compilatie aangeroepen. Daarom moet u het bestand opslaan wanneer u wijzigingen in een opgenomen bestand doorvoert en de SWF-bestanden die dit bestand gebruiken, opnieuw compileren.

 interface InterfaceName [extends InterfaceName ] {}

Definieert een interface. Interfaces zijn gegevenstypen die een set methoden definiëren. De methoden moeten worden gedefinieerd door een klasse die de interface implementeert.

Een interface is vergelijkbaar met een klasse, maar met de volgende belangrijke verschillen:

• Interfaces bevatten slechts declaraties van methoden, niet hun implementatie. Met andere woorden, elke klasse die een interface implementeert, moet een implementatie bieden voor elke methode die in de interface wordt gedeclareerd.
• Definities van interfacemethoden kunnen geen kenmerken zoals public of private hebben, maar geïmplementeerde methoden moeten als public worden gemarkeerd in de definitie van de klasse die de interface implementeert.
• Er kunnen meerdere interfaces worden overgeërfd door een interface via de instructie extends, of door een klasse via de instructie implements.

In tegenstelling tot ActionScript 2.0 staat ActionScript 3.0 het gebruik van methoden getter en setter in interfacedefinities toe.

Verwante API-elementen

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

Geeft op dat een klasse, variabele, constante of functie beschikbaar is voor elke aanroeper in hetzelfde pakket. Klassen, eigenschappen en methoden behoren standaard tot de naamruimte internal.

Verwante API-elementen

label: statement
label: {
    statements
}

Koppelt een instructie aan een id waarnaar kan worden verwezen met break of continue. In geneste lussen kan een instructie break of continue die niet naar een label verwijst, alleen het restant van de huidige lus overslaan, niet de gehele reeks lussen. Als de instructie die de gehele reeks lussen definieert echter een gekoppeld label heeft, kan een instructie break of continue de gehele reeks lussen overslaan door naar dat label te verwijzen.

Met labels kunt u ook uit een blokinstructie breken. U kunt een instructie break die niet naar een label verwijst niet binnen een blokinstructie plaatsen, tenzij de blokinstructie deel uitmaakt van een lus. Wanneer de blokinstructie een gekoppeld label heeft, kunt u een instructie break plaatsen die verwijst naar dat label binnen de blokinstructie.

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

Verwante API-elementen

namespace name [= uri]

Hiermee kunt u de zichtbaarheid van definities beheren. Vooraf gedefinieerde naamruimten zijn public, private, protected en internal.

Met de volgende stappen wordt getoond hoe u een naamruimte maakt, toepast en ernaar verwijst:

• Definieer eerst de aangepaste naamruimte met het gereserveerde woord namespace. Met de code namespace version1 wordt bijvoorbeeld een naamruimte met de naam version1 gemaakt.
• Pas de naamruimte vervolgens toe op een eigenschap of methode door de aangepaste naamruimte in de declaratie van de eigenschap of methode te gebruiken. Met de code version1 myProperty:String wordt bijvoorbeeld een eigenschap met de naam myProperty gemaakt die deel uitmaakt van de naamruimte version1.
• Verwijs daarna naar de naamruimte met het gereserveerde woord use of door de naamruimte als voorvoegsel van een id te gebruiken. De code use namespace version1; verwijst bijvoorbeeld naar de naamruimte version1 voor volgende regels code en de code version1::myProperty verwijst naar de naamruimte version1 voor de eigenschap myProperty.

Verwante API-elementen

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

Geeft op dat een functie of methode door Flash Player in native code wordt geïmplementeerd. Flash Player gebruikt het gereserveerde woord native intern om functies en methoden in de ActionScript-API (programmeerinterface voor toepassingen) te declareren. Dit gereserveerde woord kan niet in uw eigen code worden gebruikt.  

null

Een speciale waarde die aan variabelen kan worden toegewezen of door een functie kan worden geretourneerd wanneer geen gegevens zijn opgegeven. U kunt null gebruiken om meerdere waarden te vertegenwoordigen die ontbreken of geen gedefinieerd gegevenstype hebben.

De waarde null mag niet worden verward met de speciale waarde undefined. Wanneer null en undefined met de operator == (gelijk aan) worden vergeleken, worden ze als gelijk geïnterpreteerd. Wanneer null en undefined echter met de operator === (strikt gelijk aan) worden vergeleken, worden ze niet als gelijk geïnterpreteerd.

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

Verwante API-elementen

Definieert de methoden van de klasse ObjectProxy. De methoden van de klasse ObjectProxy bevinden zich in hun eigen naamruimte om naamconflicten te vermijden in situaties waarbij de Proxy-subklasse instantiemethodenamen bevat die overeenkomen met namen van methoden van de klasse Proxy.

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

Geeft op dat een methode een overerfde methode vervangt. Als u een overgeërfde methode wilt overschrijven, moet u het kenmerk override gebruiken en ervoor zorgen dat de naam, het kenmerk van de klasseneigenschap, het aantal en het type parameters, en het retourneringstype exact overeenkomen. Er treedt een fout op wanneer u probeert een methode te overschrijven zonder het kenmerk override te gebruiken. Er treedt ook een fout op wanneer u het kenmerk override gebruikt terwijl de methode geen overeenkomende overerfde methode heeft.

U kunt het kenmerk override niet gebruiken voor:

• Variabelen
• Constanten
• Methoden van het type static
• Methoden die niet zijn overerfd.
• Methoden die een interfacemethode implementeren.
• Overerfde methoden die zijn gemarkeerd als final in de superklasse.

Hoewel u een eigenschap die is gedeclareerd met var of const niet kunt overschrijven, kunt u vergelijkbare functionaliteit verkrijgen door van de basisklasse-eigenschap een getter-setter te maken en de methoden te overschrijven die met get en set zijn gedefinieerd.

Verwante API-elementen

package packageName {
    class someClassName { 
    } 
}

Hiermee kunt u uw code in discrete groepen ordenen die door andere scripts kunnen worden geïmporteerd. U moet het gereserveerde woord package gebruiken om aan te geven dat een klasse lid is van een pakket.

Verwante API-elementen

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

Geeft op dat een variabele, constante of methode alleen beschikbaar is voor de klasse die deze declareert of definieert. In tegenstelling tot ActionScript 2.0 biedt private in ActionScript 3.0 geen toegang meer tot subklassen. Bovendien legt private zowel tijdens bij compileren als bij uitvoering toegangsbeperkingen op. Een variabele of een functie is standaard beschikbaar voor elke aanroeper in hetzelfde pakket. Gebruik dit gereserveerde woord wanneer u de toegang tot een variabele of een functie wilt beperken.

U kunt dit gereserveerde woord alleen in klassedefinities gebruiken, niet in interfacedefinities. U kunt private niet toepassen op een klasse of op andere definities op pakketniveau.

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

Verwante API-elementen

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

Geeft op dat een variabele, constante, methode of naamruimte alleen beschikbaar is voor de klasse die deze declareert of definieert en voor subklassen van die klasse. De definitie van protected in ActionScript 3.0 is vergelijkbaar met de definitie van de ActionScript 2.0-versie van private, met dit verschil dat protected zowel tijdens het compileren als bij uitvoering toegangsbeperkingen oplegt. Een variabele of een functie is standaard beschikbaar voor elke aanroeper in hetzelfde pakket. Gebruik dit gereserveerde woord wanneer u de toegang tot een variabele of een functie wilt beperken.

U kunt dit gereserveerde woord alleen in klassedefinities gebruiken, niet in interfacedefinities. U kunt private niet toepassen op een klasse of op andere definities op pakketniveau.

De definitie van protected in ActionScript 3.0 brengt meer beperkingen met zich mee dan die van protected in de programmeertaal Java. In ActionScript 3.0 beperkt protected de toegang exclusief tot subklassen, terwijl in Java protected ook toegang tot klassen binnen hetzelfde pakket toestaat. Als een klasse met de naam Base bijvoorbeeld een eigenschap bevat die als protected is gemarkeerd, krijgen in ActionScript 3.0 alleen klassen die Base uitbreiden toegang tot de eigenschap van het type protected. In Java hebben alle klassen binnen hetzelfde pakket als Base toegang tot de eigenschap van het type protected, zelfs wanneer de klasse geen subklasse van Base is.

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

Verwante API-elementen

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

Geeft op dat een klasse, variabele, constante of methode beschikbaar is voor elke aanroeper. Klassen, variabelen en methoden zijn standaard van het type internal. Dit betekent dat deze alleen zichtbaar zijn binnen het huidige pakket. Wanneer u een klasse, variabele of methode voor alle aanroepers zichtbaar wilt maken, moet u het kenmerk public gebruiken.

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

Verwante API-elementen

function functionName () {
	return [expression]
}

Hiermee wordt bij uitvoering onmiddellijk naar de aanroepende functie teruggekeerd. Wanneer de instructie return door een expressie wordt gevolgd, wordt de expressie geëvalueerd en het resultaat geretourneerd.

Wanneer een functiedefinitie een retourneringstype bevat, moet de instructie return door een expressie worden gevolgd. Als er geen retourneringstype is opgegeven en alleen de instructie return wordt gebruikt, wordt undefined geretourneerd.

U kunt niet meerdere waarden retourneren. Wanneer u dit probeert, wordt alleen de laatste waarde geretourneerd. In het volgende voorbeeld wordt c geretourneerd:

return a, b, c ;

Wanneer u meerdere waarden wilt retourneren, gebruikt u een array of object.

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

Verwante API-elementen

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

Definieert een setter. Dit is een methode die in de openbare interface als eigenschap wordt weergegeven. Een setter is een speciale methode die de waarde instelt van een eigenschap die met het gereserveerde woord var is gedeclareerd. In tegenstelling tot andere methoden wordt een setter aangeroepen zonder haakjes ( ()), zodat de setter een variabele lijkt.

Met behulp van setters kunt u informatie verbergen door een openbare interface voor een eigenschap van het type private te maken. Het voordeel van het verbergen van informatie is dat de openbare interface gelijk blijft ook al verandert de onderliggende implementatie van de eigenschap van het type private.

Een ander voordeel van setters is dat deze kunnen worden overschreven in subklassen, terwijl dat niet mogelijk is bij eigenschappen die met var worden gedeclareerd.

Het retourneringstype van een setter moet void of niet opgegeven zijn.

Een setter kan met een getter worden gecombineerd om een lezen-schrijven eigenschap te maken. Wanneer u een alleen-lezen eigenschap wilt maken, maakt u een getter zonder overeenkomende setter. Wanneer u een alleen-schrijven eigenschap wilt maken, maakt u een setter zonder overeenkomende getter.

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

Verwante API-elementen

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

Geeft op dat een variabele, constante of methode tot de klasse behoort en niet tot de instanties van de klasse.

Als u toegang wilt hebben tot een klasselid van het type static, gebruikt u de naam van de klasse in plaats van de naam van een instantie. De klasse Date heeft bijvoorbeeld een methode van het type static met de naam parse() die alleen kan worden aangeroepen met de volgende syntaxis:

Date.parse()

De methode parse() kan niet worden aangeroepen voor een instantie van de klasse Date. De volgende code genereert bijvoorbeeld een fout:

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

U kunt static alleen in klassedefinities gebruiken, niet in interfacedefinities.

Klasseleden van het type static worden niet overerfd. U kunt niet naar een klasselid van het type static verwijzen via de naam van een subklasse, zoals wel mogelijk is in Java of C++. U kunt echter naar een variabele of methode van het type static binnen een klasse of subklasse verwijzen zonder een kwalificatie te gebruiken. Zie het onderstaande voorbeeld.

U kunt de instructie super of het trefwoord this niet gebruiken in een methode van het type static.

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

Roept de versie van een methode of constructor in de superklasse of bovenliggende klasse aan. Wanneer de instructie super() in de hoofdtekst van een klasseconstructor wordt gebruikt, wordt de superklasseversie van de constructor aangeroepen. De aanroep van de superklasseconstructor moet het juiste aantal argumenten bevatten. De superklasseconstructor wordt altijd aangeroepen, ongeacht of u deze wel of niet expliciet aanroept. Wanneer u deze niet expliciet aanroept, wordt automatisch een aanroep zonder argumenten voor de eerste instructie in de hoofdtekst van de subklasseconstructor ingevoegd. Wanneer u een constructorfunctie in een subklasse definieert en de superklasseconstructor een of meer argumenten gebruikt, moet u daarom de superklasseconstructor expliciet met het juiste aantal argumenten aanroepen. Anders wordt een fout gegenereerd. De aanroep van de superklasseconstructor hoeft echter niet de eerste instructie in de subklasseconstructor te zijn, zoals wel vereist was in ActionScript 2.0.

Bij gebruik in de hoofdtekst van een instantiemethode kan super worden gebruikt met de puntoperator (.) om de superklasseversie van een methode aan te roepen en om optioneel argumenten (arg1 ... argN) aan de superklassemethode door te geven. Dit is nuttig voor het maken van methoden van subklassen die niet alleen aanvullend gedrag aan methoden van superklassen toevoegen, maar ook de methoden van superklassen aanroepen om het oorspronkelijke gedrag uit te voeren.

U kunt de instructie super niet in een methode van het type static gebruiken.

Verwante API-elementen

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

Hiermee wordt het beheer overgedragen naar één van verschillende instructies, afhankelijk van de waarde van een expressie. Alle switch-instructies moeten een standaard-case bevatten die wordt uitgevoerd als geen van de case-instructies overeenkomt met de expressie. Elke case-instructie moet worden afgesloten met een break-instructie, waarmee een fout wordt voorkomen die tot mislukking kan leiden. Wanneer een case mislukt, wordt de code in de volgende instructie case uitgevoerd, hoewel die case mogelijk niet overeenkomt met de testexpressie.

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

Verwante API-elementen

this

Een verwijzing naar het object dat een methode bevat Wanneer een script wordt uitgevoerd, verwijst het gereserveerde woord this naar het object dat het script bevat. In de hoofdtekst van een methode verwijst het gereserveerde woord this naar de klasse-instantie die de aangeroepen methode bevat.

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

Genereert een fout die kan worden afgehandeld, of afgevangen, door een codeblok catch. Als een uitzondering niet door een blok catch wordt afgevangen, wordt de tekenreeksweergave van de gegenereerde waarde naar het deelvenster Uitvoer verzonden. Als een uitzondering niet door een blok catch of finally wordt afgevangen, wordt de tekenreeksweergave van de gegenereerde waarde naar het logbestand verzonden.

Doorgaans genereert u instanties van de klasse Error of subklassen ervan (zie de voorbeeldsectie).

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.

Verwante API-elementen

true

Booleaanse waarde die true vertegenwoordigt. Een Booleaanse waarde is true of false; het tegengestelde van true is false. Wanneer true via automatische gegevenstypering in een getal wordt omgezet, wordt de waarde 1; wanneer true in een tekenreeks wordt omgezet, is het resultaat "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

Verwante API-elementen

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

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

Omsluit een codeblok waarin een fout kan optreden en reageert vervolgens op de fout. Uitzonderingsafhandeling, die wordt geïmplementeerd via de instructies try..catch..finally, vormt het primaire mechanisme voor afhandeling van fouten bij uitvoering in ActionScript 3.0. Wanneer bij uitvoering een fout optreedt, genereert Flash Player een uitzondering. Dit betekent dat Flash Player de normale uitvoering onderbreekt en een speciaal object van het type Error maakt. Flash Player geeft, of passeert , het foutobject door aan het eerste beschikbare blok catch. Wanneer geen blokken catch beschikbaar zijn, wordt de uitzondering beschouwd als een niet-afgevangen uitzondering. Bij niet-afgevangen uitzonderingen wordt het script beëindigd.

U kunt de instructie throw gebruiken om expliciet uitzonderingen in de code te genereren. U kunt elke gewenste waarde genereren, maar u kunt het beste een object genereren, aangezien dit flexibiliteit biedt en goed aansluit bij het gedrag van Flash Player.

Wanneer u een uitzondering wilt afvangen, ongeacht of deze door Flash Player of door uw eigen code is gegenereerd, plaatst u de code die de uitzondering kan genereren in een blok try. Als code in het blok try een uitzondering genereert, wordt eerst het blok catch uitgevoerd (indien aanwezig) en vervolgens het blok finally (indien aanwezig). Het blok finally wordt altijd uitgevoerd, ongeacht of een uitzondering is gegenereerd. Als de code in het blok try geen uitzondering genereert (met andere woorden: als het blok try op normale wijze wordt voltooid), wordt de code in het blok catch genegeerd, maar wordt de code in het blok finally nog wel uitgevoerd. Het blok finally wordt ook uitgevoerd als het blok try wordt afgesloten met een return-instructie.

Een blok try moet worden gevolgd door een blok catch en/of een blok finally. Eén try-blok kan meerdere catch-blokken bevatten, maar slechts één finally-blok. U kunt blokken try tot een willekeurig niveau nesten.

De parameter error die in een catch-handler wordt opgegeven, moet een eenvoudige id zijn, zoals e of theException of x. De parameter kan ook worden opgegeven. Als getypeerde parameters in meerdere catch-blokken worden gebruikt, kunt u meerdere typen foutobjecten afvangen die vanuit één try-blok zijn gegenereerd.

Wanneer de gegenereerde uitzondering een object is, komt het type overeen als het gegenereerde object een subklasse van het opgegeven type is. Wanneer een fout van een specifiek type wordt gegenereerd, wordt het blok catch uitgevoerd dat de bijbehorende fout afhandelt. Als een uitzondering wordt gegenereerd die niet van het opgegeven type is, wordt het blok catch niet uitgevoerd en springt de interpreter automatisch van het blok try naar een catch-handler die wel overeenkomt met het type.

Als een fout in een functie wordt gegenereerd en de functie geen catch-handler bevat, sluit Flash Player die functie, en eventuele aanroepende functies, af totdat een blok catch wordt gevonden. Tijdens dit proces worden handlers finally op alle niveaus aangeroepen.

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

Verwante API-elementen

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

Hiermee wordt de opgegeven naamruimten toegevoegd aan de reeks open naamruimten. De opgegeven naamruimten worden uit de set open naamruimten verwijderd wanneer het huidige codeblok wordt afgesloten. De aanwijzing use namespace kan zich op het hoogste niveau van een programma, pakketdefinitie of klassedefinitie bevinden.

Verwante API-elementen

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

Geeft een variabele op. Wanneer u variabelen binnen een functie declareert, zijn het lokale variabelen. Deze worden voor de functie gedefinieerd en verlopen aan het einde van de functieaanroep.

U kunt een variabele die binnen het bereik van een ander object is geplaatst, niet als een lokale variabele declareren.

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

U kunt een gegevenstype aan een variabele toewijzen door een dubbele punt toe te voegen, gevolgd door het gegevenstype.

U kunt meerdere variabelen in een enkele instructie declareren door de declaraties met komma's te scheiden (hoewel deze notatie de code minder duidelijk kan maken).

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

Verwante API-elementen

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

Evalueert een voorwaarde. Wanneer deze de waarde true oplevert, worden een of meer instructies uitgevoerd voordat de voorwaarde opnieuw wordt geëvalueerd. Nadat de voorwaarde false heeft opgeleverd, worden de instructies overgeslagen en wordt de lus beëindigd.

De instructie while voert de volgende reeks stappen uit. Elke keer dat de stappen 1 tot en met 4 worden doorlopen wordt een herhaling van de lus genoemd. De voorwaarde wordt getest aan het begin van elke herhaling, zoals in de volgende stappen wordt getoond:

1. De expressie condition wordt geëvalueerd.
2. Als condition de waarde true oplevert of een waarde die in de Booleaanse waarde true wordt omgezet (bijvoorbeeld een getal dat niet gelijk is aan nul), gaat u naar stap 3. Als dit niet het geval is, wordt de instructie while voltooid en wordt de volgende instructie na de lus while uitgevoerd.
3. Voer het blok met instructies ( statement(s)) uit. Als een continue-instructie wordt aangetroffen, slaat u de resterende instructies over en gaat u naar stap 1. Als een break-instructie wordt aangetroffen, wordt de instructie while voltooid en wordt de volgende instructie na de lus while uitgevoerd.
4. Ga naar stap 1.

Een lusbewerking wordt doorgaans gebruikt om een handeling uit te voeren wanneer een tellervariabele lager is dan een opgegeven waarde. Aan het einde van elke lus wordt de teller verhoogd totdat de opgegeven waarde is bereikt. Op dat punt is de waarde van condition niet langer true en eindigt de lus.

De accolades ({}) rondom de instructies die moeten worden uitgevoerd door de instructie while zijn niet nodig als slechts één instructie wordt uitgevoerd.

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

Verwante API-elementen

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

Stelt een standaardobject in dat wordt gebruikt voor uitvoering van een instructie of instructies, waardoor de hoeveelheid te schrijven code mogelijk wordt verminderd.

De parameter object wordt de context waarin de eigenschappen, variabelen en functies in de parameter statement(s) worden gelezen. Als object bijvoorbeeld my_array is en twee van de opgegeven eigenschappen length en concat zijn, worden die eigenschappen automatisch gelezen als my_array.length en my_array.concat. Of, als object bijvoorbeeld state.california is, worden handelingen of instructies binnen de instructie with aangeroepen vanuit de instantie california.

Om de waarde te vinden van een id in de parameter statement(s), start ActionScript aan het begin van de bereikketen die is opgegeven door object. Vervolgens wordt op elk niveau van de bereikketen in een bepaalde volgorde naar de id gezocht.

De bereikketen die door de instructie with wordt gebruikt om id's om te zetten, begint met het eerste item in de volgende lijst en gaat door tot het laatste item:

• Het object dat in de parameter object in de binnenste instructie with is opgegeven.
• Het object dat in de parameter object in de buitenste instructie with is opgegeven.
• Het object Activation (een tijdelijk object dat automatisch wordt gemaakt wanneer het script een functie aanroept die de lokale variabelen bevat die in de functie worden aangeroepen).
• Het object dat het script bevat dat momenteel wordt uitgevoerd.
• Het object Global (ingebouwde objecten zoals Math en String).

Wanneer u een variabele binnen een instructie with wilt instellen, moet u de variabele buiten de instructie with hebben gedeclareerd of moet u het volledige pad invoeren naar de tijdlijn waarin u de variabele wilt gebruiken. Wanneer u een variabele in een instructie with instelt zonder deze te declareren, zoekt de instructie with naar de waarde volgens de bereikketen. Wanneer de variabele nog niet bestaat, wordt de nieuwe waarde ingesteld in de tijdlijn van waaruit de instructie with is aangeroepen.

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