Programsatser, nyckelord och direktiv 

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

Anger att en funktion ska acceptera ett obegränsat antal kommaavgränsade argument. Argumentlistan blir en array som finns tillgänglig i hela funktionstexten. Arrayens namn anges efter ...-tecknen i parameterdeklarationen. Parametern kan heta vad som helst bara det inte är ett reserverat ord.

Vid användning med andra parametrar måste ... (rest)-parameterdeklarationen vara den sist angivna parametern. ... (rest)-parameterns array fylls bara i om antalet argument som skickas till funktionen överstiger antalet övriga parametrar.

Varje argument i den kommaavgränsade argumentlistan läggs in i ett argument i arrayen. Om du skickar en instans av klassen Array placeras hela arrayen i ett enda element i ... (rest)-parameterns array.

Om du använder den här parametern kan du inte använda objektet arguments. Även om parametern ... (rest) har samma funktioner som arrayen arguments och egenskapen arguments.length har den inte samma funktioner som arguments.callee. Försäkra dig om att du inte behöver använda arguments.callee innan du använder ... (rest)-parametern.

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

Relaterade API-element

Definierar metoder och egenskaper för kärnklasserna i ActionScript, vilka är fasta egenskaper i stället för prototypegenskaper. När du anger kompileringsalternativet "-as3" som true (vilket är standardinställningen i Flex Builder 2) öppnas AS3-namnutrymmet automatiskt för alla kärnklasser. Det innebär att en instans av en kärnklass använder fasta egenskaper och metoder i stället för de versioner av samma egenskaper och metoder som är länkade till klassens prototypobjekt. Användning av fasta egenskaper ger normalt bättre prestanda, men på bekostnad av bakåtkompatibiliteten med språkspecifikationen ECMAScript edition 3 (ECMA-262).

Relaterade API-element

Förekommer inom en slinga (for , for..in, for each..in, do..while eller while) eller inom ett block med programsatser som är kopplade till ett visst fall i en switch-programsats. När programsatsen break används i en slinga instruerar den Flash att hoppa över resten av slingan, avbryta slingåtgärden och sedan köra programsatsen som följer slingsatsen. När den används i en switch-sats instruerar break-programsatsen Flash att hoppa över resten av programsatsen i det case-blocket och hoppa till den första programsatsen som följer den omslutande switch-programsatsen.

I kapslade slingor hoppar break bara över resten av den omedelbara slingan och bryter inte ut ur hela serien med kapslade slingor. Om du vill bryta ut ur en hel serie med kapslade slingor ska du använda label eller try..catch..finally.

Programsats break kan ha en valfri etikett, som måste överensstämma med en yttre etiketterad programsats. Användning av en etikett som inte överensstämmer med etiketten för en yttre programsats utgör ett syntaxfel. Etiketterade break-programsatser kan användas för utbrytning ur flera nivåer med kapslade slingprogramsatser, switch-programsatser eller block-programsatser. Avsnittet om label-satsen innehåller ett exempel.

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

Relaterade API-element

case jumpTarget: statements

Definierar ett hoppmål för programsatsen switch. Om parametern jumpTarget är lika med parametern expression i switch-programsatsen när strikt likhet (===) används kör Flash Player programsatserna i parametern statementstills en break-sats eller slutet av switch-satsen påträffas.

Om du använder programsatsen case utanför en switch-programsats inträffar ett fel och skriptet kompileras inte.

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

Relaterade API-element

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

Definierar en klass med vilken du kan skapa instanser av objekt som delar metoder och egenskaper som du definierar. Om du till exempel utvecklar ett fakturaspårningssystem kan du skapa en fakturaklass som definierar alla metoder och egenskaper som varje faktura ska ha. Sedan använder du kommandot new Invoice() för att skapa fakturaobjekt.

Varje ActionScript-källfil kan bara innehålla en klass som är synlig från andra källfiler eller skript. Den externt synliga klassen kan vara en public eller intern klass, och måste definieras inuti en paketprogramsats. Om du tar med andra klasser i samma fil måste klasserna placeras utanför paketprogramsatsen och i slutet av filen.

Namnet på den externt synliga klassen måste matcha namnet på den ActionScript-källfil som innehåller klassen. Namnet på källfilen måste vara namnet på klassen med filtillägget .as. Om du till exempel kallar en klass för Student måste filen som definierar klassen heta Student.as.

Du kan inte kapsla klassdefinitioner – det vill säga, du kan inte definiera tilläggsklasser inom en klassdefinition.

Du kan definiera en konstruktormetod, som är en metod som körs varje gång en ny instans av klassen skapas. Namnet på konstruktormetoden måste överensstämma med klassens namn. Om du inte definierar någon konstruktormetod skapas en standardkonstruktor åt dig.

Om du vill ange att objekt ska kunna lägga till och komma åt dynamiska egenskaper vid körning ska nyckelordet dynamic föregå klassprogramsatsen. Om du vill deklarera att en klass ska implementera ett gränssnitt använder du nyckelordet implements. Om du vill skapa underklasser av en klass använder du nyckelordet extends. (En klass kan bara utöka en klass, men kan implementera flera gränssnitt). Du kan använda implements och extends i en enskild programsats. I följande exempel visas typiska användningsområden för nyckelorden implements och 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); 

Relaterade API-element

const identifier = value 

Anger en konstant, det vill säga en variabel som bara kan tilldelas ett värde en gång.

Du kan skriva en konstant genom att bara lägga till ett kolontecken (:) följt av datatypen.

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

Relaterade API-element

continue [label]

Hoppar förbi alla återstående programsatser i den innersta slingan och startar nästa iteration i slingan, som om kontrollen gått till slutet av slingan. Programsatsen continue har ingen effekt utanför en slinga. I kapslade slingor använder du den valfria parametern label för att hoppa över mer än bara den innersta slingan.

Programsatsen continue kan ha en valfri etikett, som måste överensstämma med en yttre etiketterad programsats. Användning av en etikett som inte överensstämmer med etiketten för en yttre programsats utgör ett syntaxfel. Etiketterade continue-programsatser kan användas för att hoppa över flera nivåer av kapslade slingprogramsatser.

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

Relaterade API-element

default: statements 

Definierar standardfallet för en switch-programsats. Programsatserna körs om parametern expression i programsatsen switch inte är lika med (med strikt likhet [===]) någon av de expression-parametrar som följer case-nyckelorden för en viss switch-programsats.

En switch-programsats kräver ingen default-fallprogramsats. En default-fallprogramsats behöver inte vara sist i listan. Om du använder en default-programsats utanför en switch-programsats inträffar ett fel och skriptet kompileras inte.

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

Relaterade API-element

Direktivet default xml namespace anger det standardnamnutrymme som ska användas för XML-objekt.

Om du inte anger default xml namespace är standardnamnutrymmet det namnlösa namnutrymmet (med URI:n angiven till en tom sträng). Omfånget för en default xml namespace-deklaration ligger inom ett funktionsblock, i likhet med en variabels omfång.

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/

Relaterade API-element

do { statement(s) } while (condition)

Liknar en while-slinga, förutom att programsatserna körs en gång före den första utvärderingen av villkoret. Följaktligen körs programsatserna bara om villkoret utvärderas till true.

En do..while-slinga säkerställer att koden inuti slingan körs minst en gång. Även om detta kan utföras med en while-slinga, genom att köra en kopia av programsatserna innan while-slingan börjar, tycker många programmerare att do..while-slingor är lättare att läsa.

Om villkoret alltid utvärderas till true är do..while-slingan oändlig. Om du anger en oändlig slinga får du problem med Flash Player och får så småningom ett varningsmeddelande, eller så kraschar spelaren. Om du vet hur många gånger du vill repetera bör du alltid använda en for-slinga, om det går. for-slingor är enkla att läsa och felsöka men de kan inte ersätta do..while-slingor under alla omständigheter.

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

Relaterade API-element

dynamic class className { // class definition here }

Anger att instanser av en klass kan innehålla dynamiska egenskaper som läggs till under körning. Om du använder attributet dynamic på en klass kan du lägga till egenskaper i instanser av den klassen vid körning. Klasser som inte markerats som dynamic betraktas som slutna, vilket innebär att egenskaper inte kan läggas till i instanser av klassen.

Om en klass som är sluten (inte dynamisk) försöker hämta eller lägga in egenskaper för klassinstanser resulterar ett fel. Om kompileraren ställts in för strikt läge, och du anger datatypen när du skapar instanser, kommer försök att lägga till egenskaper till slutna objekt att generera ett kompileringsfel; i annat fall uppträder ett körningsfel.

Attributet dynamic ärvs inte av underklasser. Om du utökar en dynamisk klass blir underklassen bara dynamisk om du deklarerar den med attributet dynamic.

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

Relaterade API-element

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

Anger de programsatser som ska köras om villkoret i programsatsen if returnerar false. Klammerparenteserna ({}) som omger de programsatser som ska köras av else-programsatsen är inte nödvändiga om bara en programsats ska köras.

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

Relaterade API-element

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

Definierar en klass som är en underklass till en annan klass. Subklassen ärver alla metoder, egenskaper, funktioner och så vidare som definierats i superklassen. Klasser som markerats som final kan inte utökas.

Du kan också använda nyckelordet extends för att utöka ett gränssnitt. Ett gränssnitt som utökar ett annat gränssnitt innefattar alla metoddeklarationer från det ursprungliga gränssnittet.

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

Relaterade API-element

false

Ett booleskt värde som representerar false. Ett booleskt värde är antingen true eller false, och motsatsen till false är true.

När automatisk datatypbestämning konverterar false till ett tal blir det 0. Vid konvertering av false till en sträng blir den "false".

Obs! Strängen "false" konverteras till det booleska värdet 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

Relaterade API-element

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

Anger att metoden inte kan åsidosättas eller att en klass inte kan utökas. Ett försök att åsidosätta en metod, eller utöka en klass, som markerats som final resulterar i ett fel.

Relaterade API-element

Definierar metoder för klassen Proxy. Proxy-klassmetoderna har sina egna namnutrymmen för att undvika namnkonflikter i de fall då din Proxy-underklass innehåller instansmetodnamn som matchar några Proxy-klassmetodnamn.

Relaterade API-element

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

Utvärderar uttrycket init (initialize) en gång och startar en repetitionssekvens. Repetitionssekvensen börjar med att uttrycket condition utvärderas. Om uttrycket condition utvärderas till true körs statement och next utvärderas. Repetitionssekvensen börjar sedan om med en utvärdering av uttrycket condition.

Klammerparenteserna ({}) som omger de programsatser som ska köras av for-programsatsen är inte nödvändiga om bara en programsats ska köras.

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

Relaterade API-element

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

Itererar genom de dynamiska egenskaperna för ett objekt eller element i en array och kör statement för varje egenskap eller element. Objektegenskaper sparas inte i någon särskild ordningsföljd och egenskaperna kan därför visas i en synbarligen slumpmässig ordning. Fasta egenskaper, såsom variabler och metoder som definierats i en klass, räknas inte upp av for..in-satsen. Använd funktionen describeType() i flash.utils-paketet för att få en lista över fasta egenskaper.

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

Relaterade API-element

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

Itererar genom objekten i en samling och kör statement för vart och ett av dem. Programsatsen for each..in infördes som en del av E4X-språktillägget och den kan användas inte bara för XML-objekt, utan även för objekt och arrayer. Programsatsen for each..in itererar bara genom ett objekts dynamiska egenskaper, inte dess fasta egenskaper. En fast egenskap är en egenskap som definierats som en del av en klassdefinition. Om du använder for each..in -satsen med en instans av en användardefinierad klass, måste du deklarera klassen med attributet dynamic.

Till skillnad mot for..in-satsen, kommer for each..in-satsen att itereras över värdena för ett objekts egenskaper i stället för egenskapsnamnen.

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

Består av en uppsättning satser som du definierar för att utföra en viss uppgift. Du kan definiera en funktion på ett ställe och anropa den (call) från olika skript i en SWF-fil. När du definierar en funktion kan du även ange parametrar för funktionen. Parametrar är platshållare för de värden där funktionen utförs. Du kan skicka olika parametrar till en funktion varje gång du anropar den och på så vis använda en funktion i olika situationer.

Använd programsatsen return i en funktions statement(s)-block om du vill att funktionen ska generera, eller returnera, ett värde.

Användning 1: Du kan använda nyckelordet function för att definiera en funktion med angivet funktionsnamn, angivna parametrar och angivna programsatser. När ett skript anropar en funktion körs programsatserna i funktionsdefinitionen. Framåtreferens är tillåten. Inom samma skript kan en funktion deklareras efter att den har anropats. En funktionsdefinition ersätter alla tidigare definitioner för samma funktion. Du kan använda den här syntaxen överallt där en programsats är tillåten.

Användning 2: Du kan även använda function för att skapa en anonym funktion och returnera en referens till den. Syntaxen används i uttryck och är framför allt användbar när metoder ska installeras i objekt.

Om du vill ha fler funktioner kan du använda objektet arguments i funktionsdefinitionen. Objektet arguments används vanligen för att skapa en funktion som accepterar ett varierande antal parametrar samt för att skapa en rekursiv anonym funktion.

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

Relaterade API-element

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

Definierar en get-metod, som är en metod som kan läsas som en egenskap. En get-metod är en specialfunktion som returnerar värdet för en egenskap som deklarerats med nyckelordet var eller const. Till skillnad från andra metoder anropas en get-metod utan parenteser (()), vilket får get-metoden att framstå som en variabel.

Med hjälp av get-metoder kan du tillämpa principen för dold information genom att skapa ett publikt gränssnitt för en privat egenskap. Fördelen med dold information är att det publika gränssnittet förblir oförändrat även om den bakomliggande implementeringen av den privata egenskapen ändras.

En annan fördel med get-metoder är att de kan åsidosättas i underklasser, vilket egenskaper som deklareras med var eller const inte kan.

En get-metod kan kombineras med en set-metod för att skapa en skriv/läsegenskap. För att skapa en skrivskyddad egenskap skapar man en get-metod utan någon motsvarande set-metod. För att skapa en lässkyddad egenskap skapar man en set-metod utan någon motsvarande get-metod.

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

Relaterade API-element

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

Utvärderar ett villkor för att bestämma nästa programsats som ska köras. Om villkoret är true kör Flash Player de programsatser som följer villkoret inom klammerparenteserna ({}). Om villkoret är false hoppar Flash Player över programsatserna inom klammerparenteserna och kör programsatserna efter klammerparenteserna. Använd programsatsen if tillsammans med programsatsen else för att skapa förgreningslogik i skripten.

Klammerparenteserna ({}) som omger de programsatser som ska köras av if-programsatsen är inte nödvändiga om bara en programsats ska köras.

Relaterade API-element

myClass implements interface01 [, interface02 , ...] 

Specificerar att en klass implementerar ett eller flera gränssnitt. När en klass implementerar ett gränssnitt måste klassen definiera samtliga metoder som deklarerats i gränssnittet. Varje instans av en klass som implementerar ett gränssnitt betraktas som en medlem av den datatyp som definierats av gränssnittet. Som en följd av det returnerar operatorn is värdet true när klassinstansen är den första operanden och gränssnittet är den andra; dessutom fungerar typtvång till och från den datatyp som definieras av gränssnittet.

Relaterade API-element

import packageName.className 
import packageName.*

Gör externt definierade klasser och paket tillgängliga för koden. Om du exempelvis vill använda klassen flash.display.Sprite i ett skript så måste du importera den. Detta krav skiljer sig från tidigare versioner av ActionScript, där import-direktivet var valfritt.

När du har använt import-direktivet kan du använda det fullständiga klassnamnet, som inkluderar paketnamnet, eller bara namnet på klassen.

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

Om det finns flera klasser i paketet som du vill få åtkomst till kan du importera alla filer med en enda programsats, som följande exempel visar:

import flash.display.*;

Direktivet import importerar enbart de klasser, funktioner och variabler som finns på det importerade paketets översta nivå. Kapslade paket måste importeras explicit.

Om du importerar en klass men inte använder den i skriptet exporteras inte klassen som en del av SWF-filen. Det betyder att du kan importera stora paket utan att tänka på SWF-filens storlek. Bytekoden som kopplas till en klass innefattas bara i en SWF-fil om klassen faktiskt används. En nackdel med att importera klasser som du inte behöver är att du ökar sannolikheten för namnkonflikter.

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

include "[path]filename.as"

Inkluderar innehållet i den angivna filen, som om kommandona i filen var en del av det anropande skriptet. Direktivet include anropas vid kompilering. Om du gör några ändringar i en inkluderad fil måste du därför spara filen och kompilera om alla SWF-filer som använder den.

 interface InterfaceName [extends InterfaceName ] {}

Definierar ett gränssnitt. Gränssnitt är datatyper som definierar en uppsättning metoder; metoderna måste vara definierade av en klass som implementerar gränssnittet.

Ett gränssnitt liknar en klass, men med två viktiga skillnader:

• Gränssnitt innehåller bara deklarationer för metoder, inte deras implementering. Det innebär att varje klass som implementerar ett gränssnitt måste ange en implementering för varje metod som deklareras i gränssnittet.
• Gränssnittsmetoddefinitioner kan inte ha attribut som public eller private, men implementerade metoder måste märkas som public i definitionen av den klass som implementerar gränssnittet.
• Flera gränssnitt kan ärvas av ett gränssnitt via programsatsen extends eller av en klass via programsatsen implements.

Till skillnad mot ActionScript 2.0 så tillåter ActionScript 3.0 användning av get- och set-metoder i gränssnittsdefinitioner.

Relaterade API-element

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

Anger att en klass, en variabel, en konstant eller en funktion är tillgänglig för alla anropare i samma paket. Klasser, egenskaper och metoder tillhör som standard namnutrymmet internal.

Relaterade API-element

label: statement
label: {
    statements
}

Associerar en programsats med en identifierare som kan refereras av break eller continue. I kapslade slingor kan en break- eller continue-sats, som inte refererar till en etikett, endast hoppa över resten av den omedelbara slingan och hoppar inte över hela serien med slingor. Men om den programsats som definierar hela serien med slingor har en associerad etikett, så kan en break- eller continue-programsats hoppa över hela serien med slingor genom att referera till den etiketten.

Etiketter ger dig dessutom möjlighet att bryta ut ur en blockprogramsats. Du kan inte placera en break-programsats som inte refererar till en etikett inuti en blockprogramsats, såvida inte blockprogramsatsen utgör en del av en slinga. Om blockprogramsatsen har en associerad etikett kan du placera en break-programsats som refererar till den etiketten inuti blockprogramsatsen.

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

Relaterade API-element

namespace name [= uri]

Gör att du kan styra definitionernas synlighet. Fördefinierade namnutrymmen är till exempel public, private, protected och internal.

Stegen nedan visar hur du skapar, tillämpar och refererar till ett namnutrymme:

• Börja med att definiera det anpassade namnutrymmet med hjälp av nyckelordet namespace. Koden namespace version1 skapar till exempel ett namnutrymme som heter version1.
• Fortsätt med att koppla namnutrymmet till en egenskap eller metod genom att använda ditt anpassade namnutrymme i egenskaps- eller metoddeklarationen. Koden version1 myProperty:String skapar till exempel en egenskap med namnet myProperty som tillhör namnutrymmet version1.
• Referera sedan till namnutrymmet med hjälp av nyckelordet use eller genom att infoga en identifierare som prefix med namnutrymmet. Koden use namespace version1; refererar till exempel till namnutrymmet version1 för efterföljande rader med kod, och koden version1::myProperty refererar till namnutrymmet version1 för egenskapen myProperty.

Relaterade API-element

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

Anger att en funktion eller metod implementeras av Flash Player i inbyggd kod. Flash Player använder nyckelordet native för att internt deklarera funktioner och metoder i programmeringsgränssnittet (API:t) för ActionScript. Detta nyckelord kan inte användas i din egen kod.  

null

Ett specialvärde som kan tilldelas variabler eller returneras av en funktion om inga data har erhållits. Du kan använda null för att representera värden som saknas eller som inte har en definierad datatyp.

Värdet null ska inte sammanblandas med specialvärdet undefined. När null och undefined jämförs med likhetsoperatorn (==) betraktas de som lika. När null och undefined jämförs med operatorn strikt likhet (===) betraktas de som olika.

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

Relaterade API-element

Definierar metoder för klassen ObjectProxy. ObjectProxy-klassmetoderna har sina egna namnutrymmen för att undvika namnkonflikter i de fall då din Proxy-underklass innehåller instansmetodnamn som matchar några Proxy-klassmetodnamn.

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

Anger att en metod ersätter en ärvd metod. Om du vill åsidosätta en ärvd metod måste du använda attributet override och försäkra dig om att namn, attribut för klassegenskap, antal och typ av parametrar samt returtyp matchar exakt. Det är fel att försöka åsidosätta en metod utan att använda attributet override. Det är också fel att använda attributet override om metoden inte har någon motsvarande ärvd metod.

Du kan inte använda attributet override på följande:

• Variabler
• Konstanter
• Statiska metoder
• Metoder som inte ärvs
• Metoder som implementerar en gränssnittsmetod
• Ärvda metoder som markerats som final i superklassen

Du kan visserligen inte åsidosätta en egenskap som deklarerats med var eller const, men du kan uppnå en liknande effekt genom att ange basklassegenskapen som en get- och set-metod och åsidosätta de metoder som definierats med get och set.

Relaterade API-element

package packageName {
    class someClassName { 
    } 
}

Gör att du kan ordna koden i åtskilda grupper som kan importeras av andra skript. Du måste använda nyckelordet package för att ange att en klass är medlem av ett paket.

Relaterade API-element

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

Anger att en variabel, en konstant eller en metod bara är tillgänglig(-t) för den klass som deklarerar eller definierar den. Till skillnad från ActionScript 2.0 ger private i ActionScript 3.0 inte längre tillgång till underklasser. Dessutom begränsar private åtkomst vid såväl kompilering som körning. Som standard är en variabel eller en funktion tillgänglig för alla anropare i samma paket. Använd det här nyckelordet om du vill begränsa åtkomsten till en variabel eller en funktion.

Du kan bara använda det här nyckelordet i klassdefinitioner, inte i gränssnittsdefinitioner. Du kan inte använda private på en klass eller på andra definitioner på paketnivå.

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

Relaterade API-element

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

Anger att en variabel, en konstant, en metod eller ett namnutrymme bara är tillgänglig för den klass som definierar den, samt för eventuella subklasser till den klassen. Definitionen för protected i ActionScript 3.0 liknar definitionen för ActionScript 2.0-versionen av private, förutom att protected begränsar åtkomsten vid både kompilering och körning. Som standard är en variabel eller en funktion tillgänglig för alla anropare i samma paket. Använd det här nyckelordet om du vill begränsa åtkomsten till en variabel eller en funktion.

Du kan bara använda det här nyckelordet i klassdefinitioner, inte i gränssnittsdefinitioner. Du kan inte använda private på en klass eller på andra definitioner på paketnivå.

Definitionen av protected i ActionScript 3.0 är mer restriktiv än den för protected i programmeringsspråket Java. I ActionScript 3.0 begränsar protected tillgången till enbart underklasser, medan protected i Java ger tillgång till alla klasser i samma paket. Om en klass med namnet Base till exempel innehåller en egenskap som märkts som protected, så kan i ActionScript 3.0 endast klasser som utökar Base få tillgång till den skyddade egenskapen. I Java har varje klass i samma paket som Base åtkomst till den skyddade egenskapen, även om klassen inte är en subklass till Base.

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

Relaterade API-element

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

Anger att en klass, en variabel, en konstant eller en metod är tillgänglig för alla anropare. Klasser, variabler och metoder är interna som standard, vilket innebär att de bara är synliga inom det aktuella paketet. Om du vill göra en klass, variabel eller metod synlig för alla anropare måste du använda attributet public.

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

Relaterade API-element

function functionName () {
	return [expression]
}

Gör att körningen genast returneras till anropsfunktionen. Om programsatsen return följs av ett uttryck utvärderas uttrycket och resultatet returneras.

Om en funktionsdefinition inkluderar en returtyp måste programsatsen return följas av ett uttryck. Om ingen returtyp anges och programsatsen return används ensam returneras undefined.

Det går inte att returnera flera värden. Om du försöker göra det returneras bara det sista värdet. I följande exempel returneras c:

return a, b, c ;

Om du behöver returnera flera värden ska du använda en array eller ett objekt i stället.

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

Relaterade API-element

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

Definierar en setter, det vill säga en metod som visas i det offentliga gränssnittet som en egenskap. En set-metod är en specialmetod som anger värdet för en egenskap som deklarerats med nyckelordet var. Till skillnad från andra metoder anropas en set-metod utan parenteser (()), vilket får set-metoden att framstå som en variabel.

Med set-metoder kan du tillämpa principen för dold information genom att skapa ett publikt gränssnitt för en privat egenskap. Fördelen med dold information är att det publika gränssnittet förblir oförändrat även om den bakomliggande implementeringen av den privata egenskapen ändras.

En annan fördel med set-metoder är att de kan åsidosättas i underklasser, vilket egenskaper som deklareras med var inte kan.

En set-metods returtyp måste vara antingen void eller inte specificerad.

En set-metod kan kombineras med en get-metod för att skapa en skriv/läsegenskap. För att skapa en skrivskyddad egenskap skapar man en get-metod utan någon motsvarande set-metod. För att skapa en lässkyddad egenskap skapar man en set-metod utan någon motsvarande get-metod.

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

Relaterade API-element

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

Anger att en variabel, en konstant eller en metod tillhör klassen och inte instanser av klassen.

För att komma åt en statisk klassmedlem använder du namnet på klassen i stället för namnet på en instans. Date-klassen har exempelvis en statisk metod med namnet parse() som bara kan anropas med följande syntax:

Date.parse()

parse()-metoden kan inte anropas på en instans av Date-klassen. Följande kod genererar exempelvis ett fel:

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

Du kan bara använda static i klassdefinitioner, inte i gränssnittsdefinitioner.

Statiska klassmedlemmar ärvs inte. Du kan inte referera till en statisk klassmedlem med namnet på en subklass, som man kan i Java eller C++. Du kan emellertid referera till en statisk metod inom en klass eller subklass, utan att använda en kvalificerare. Se exemplet nedan.

Du kan inte använda programsatsen super eller nyckelordet this i en statisk metod.

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

Anropar superklassens eller den överordnade klassens metod eller konstruktor. Vid användning inom en klasskonstruktors brödtext startar programsatsen super() superklassversionen av konstruktorn. Anropet till superklasskonstruktorn måste ha rätt antal argument. Observera att superklasskonstruktorn alltid anropas antingen du anropar den explicit eller inte. Om du inte anropar det explicit, läggs ett anrop utan argument in automatiskt före den första programsatsen i subklasskonstruktorbrödtexten. Det innebär att om du definierar en konstruktorfunktion i en subklass, och superklasskonstruktorn tar ett eller flera argument, så måste du anropa superklasskonstruktorn explicit med rätt antal argument för att ett fel inte ska uppkomma. Anropet till superklasskonstruktorn behöver emellertid inte vara den första programsatsen i din subklasskonstruktor, vilket var nödvändigt i ActionScript 2.0.

Vid användning i brödtexten för en instansmetod kan super användas med punktoperatorn (.) för att anropa superklassversionen av en metod och kan om så önskas skicka argument (arg1 ... argN) till superklassmetoden. Detta är användbart när du skapar subklassmetoder som inte bara lägger till ytterligare beteende till superklassermetoder, och syntaxstilen anropar även superklassens metoder så att de utför sitt vanliga beteende.

Du kan inte använda programsatsen super i en statisk metod.

Relaterade API-element

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

Överför kontrollen till en av flera satser, beroende på ett uttrycks värde. Alla switch-programsatser ska innefatta ett standardfall, som körs om ingen av case-programsatserna matchar uttrycket. Varje case-programsats ska avslutas med en break-programsats, som förhindrar ett genomfallsfel. När ett fall faller igenom kör det koden i nästa case-programsats, trots att fallet eventuellt inte matchar testuttrycket.

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

Relaterade API-element

this

En referens till metodens behållarobjekt. När ett skript körs refererar nyckelordet this till det objekt som innehåller skriptet. I en metodbrödtext refererar nyckelordet this till den klassinstans som innehåller den anropade metoden.

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

Skapar (eller orsakar) ett fel som kan hanteras (eller fångas) av ett catch-kodblock. Om undantaget inte fångas av ett catch-block skickas strängrepresentationen för det kastade värdet till utdatapanelen. Om undantaget inte fångas av ett catch- eller finally-block skickas strängrepresentationen för det kastade värdet till loggfilen.

Vanligtvis genereras instanser av Error-klassen eller dess underklasser (se avsnittet Exempel).

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.

Relaterade API-element

true

Ett booleskt värde som representerar true. Ett booleskt värde är antingen true eller false, och motsatsen till true är false. När automatisk datatypbestämning konverterar true till ett tal blir det 1. Vid konvertering av true till en sträng blir den "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

Relaterade API-element

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

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

Stänger ett block med kod som ett fel kan uppstå i. Därefter hanteras felet. Undantagshantering, som implementeras med try..catch..-satser, är det primära sättet att hantera körningsfel i ActionScript 3.0. När ett körningsfel inträffar genererar Flash Player ett undantagsfel, vilket betyder att Flash Player upphör med normal körning och skapar ett specialobjekt av typen Error. Sedan skickas (eller kastas) felobjektet till det första tillgängliga catch-blocket. Om det inte finns några catch-block tillgängliga betraktas undantaget som ett ohanterat undantag. Ej infångade undantag får skriptet att avslutas.

Du kan använda programsatsen throw för att generera undantag explicit i koden. Du kan generera valfritt värde, men det bästa är att generera ett objekt för att det ger flexibilitet och matchar Flash Players beteende.

För att fånga ett undantag, oavsett om det genererats av Flash Player eller av din egen kod, placerar du den kod som kan generera undantaget i ett try-block. Om kod i try-blocket genererar ett undantag skickas kontrollen till catch-blocket, om det finns ett sådant, och sedan till finally-blocket, om det finns ett sådant. finally-blocket körs alltid, oavsett om ett undantag har genererats. Om kod i try-blocket inte genererar ett undantag (det vill säga om try-blocket slutförs normalt) ignoreras koden i catch-blocket, men koden i finally-blocket körs ändå. finally-blocket körs även om try-blocket avslutas med en return-programsats.

Ett try-block måste följas av ett catch-block, ett finally-block eller bådadera. Ett enskilt try-block kan ha flera catch-block, men bara ett finally-block. Du kan kapsla try-block på hur många nivåer som helst.

Den error-parameter som anges i en catch-hanterare måste vara en enkel identifierare, till exempel e, theException eller x. Parametern kan också typbestämmas. Vid användning med flera catch-block ger typbestämda parametrar dig möjlighet att fånga flera typer av felobjekt som genererats från ett enda try-block.

Om undantaget som kastas är ett objekt, matchar typen om det kastade objektet är en subklass av den typ som angetts. Om ett fel av en viss typ genereras körs det catch-block som hanterar motsvarande fel. Om ett undantag som inte är av den angivna typen genereras körs inte catch-blocket, och undantaget kastas automatiskt ut från try-blocket till en catch-hanterare som matchar det.

Om ett fel genereras inom en funktion, och funktionen inte innehåller en catch-hanterare, avslutar Flash Player den funktionen och alla anropsfunktioner tills ett catch-block har hittats. Under den här processen anropas finally-hanterare på alla nivåer.

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

Relaterade API-element

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

Gör att de angivna namnutrymmena läggs till i uppsättningen med öppna namnutrymmen. De specificerade namnutrymmena tas bort från uppsättningen öppna namnutymmen när det aktuella kodblocket inaktiveras. Direktivet use namespace kan visas på den översta nivån i ett program, en paketdefinition eller en klassdefinition.

Relaterade API-element

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

Anger en variabel. Om du deklarerar variabler inuti en funktion är variablerna lokala. De definieras för funktionen och förfaller vid slutet av funktionsanropet.

Du kan inte deklarera en variabel som ligger inom omfånget för ett annat objekt som lokal variabel.

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

Du kan tilldela en datatyp till en variabel genom att bara lägga till ett kolontecken följt av datatypen.

Du kan deklarera flera variabler i ett uttryck och avgränsa deklarationerna med kommatecken (även om den syntaxen kan begränsa kodens klarhet):

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

Relaterade API-element

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

Utvärderar ett villkor. Om villkoret utvärderas till true körs en eller flera programsatser innan villkoret utvärderas igen. När villkoret utvärderats till false hoppas programsatserna över och slingan avslutas.

Programsatsen while utför nedanstående steg. Varje repetition av steg från 1 till 4 kallas en iteration av slingan. Villkoret testas om i början av varje iteration, vilket visas i följande steg:

1. Uttrycket condition utvärderas.
2. Om condition utvärderas till true eller ett värde som kan konverteras till det booleska värdet true, till exempel ett tal som inte är noll, går den till steg 3. Annars slutförs while-satsen och körningen återupptas vid nästa programsats efter while-slingan.
3. Kör satsblocket statement(s). Om en continue-sats påträffas hoppas resten av programsatserna över och den går till steg 1. Om en break-sats påträffas slutförs while-satsen och körningen återupptas vid nästa programsats efter while-slingan.
4. Gå till steg 1.

Slingor används ofta för att utföra en åtgärd medan en räkningsvariabel är mindre än ett angivet värde. Vid slutet av varje slinga inkrementeras räknaren tills det angivna värdet har nåtts. Då är condition inte längre true och slingan avslutas.

Klammerparenteserna ({}) som omger de programsatser som ska köras av while-programsatsen är inte nödvändiga om bara en programsats ska köras.

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

Relaterade API-element

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

Upprättar ett standardobjekt som ska användas för körning av en eller flera programsatser och eventuellt reducera den mängd programkod som behöver skrivas.

Parametern object blir den kontext i vilken egenskaperna, variablerna och funktionerna i statement(s)-parametern läses. Om object till exempel är my_array, och två av de angivna egenskaperna är length och concat, läses de egenskaperna automatiskt som my_array.length och my_array.concat. Om object till exempel är state.california anropas alla åtgärder och programsatser inuti programsatsen with inifrån california-instansen.

För att hitta värdet på en identifierare i statement(s)-parametern startar ActionScript från början av den omfångskedja som anges av object och söker efter identifieraren på alla nivåer i omfångskedjan i en viss ordning.

Omfångskedjan som används av with-programsatsen för att tolka identifierare startar med det första objektet i följande lista och fortsätter till det sista objektet:

• Det objekt som anges i object-parametern i den innersta with-programsatsen.
• Det objekt som anges i object-parametern i den yttersta with-programsatsen.
• Aktiveringsobjektet (ett tillfälligt objekt som skapas automatiskt när skriptet anropar en funktion som innehåller de lokala variabler som anropas i funktionen)
• Det objekt som innehåller det skript som körs.
• Det globala objektet (inbyggda objekt som Math och String)

Om du vill ange en variabel inuti en with-sats måste du ha deklarerat variabeln utanför programsatsen with eller så måste du ange den fullständiga sökvägen till den tidslinje på vilken du vill att variabeln ska finnas. Om du anger en variabel i en with-programsats utan att deklarera den kommer with-programsatsen att söka efter värdet enligt omfångskedjan. Om variabeln inte redan finns ställs det nya värdet in på den tidslinje från vilken with-programsatsen anropades.

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