Instrukcje, słowa kluczowe i dyrektywy 

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

Określa, że funkcja może przyjmować dowolną liczbę argumentów oddzielonych przecinkami. Lista argumentów staje się tablicą i jest dostępna w treści funkcji. Nazwę tablicy podaje się po znakach ... w deklaracji parametrów. Parametr może mieć dowolną nazwę niebędącą słowem zastrzeżonym.

Deklaracja parametrów ... (rest), jeśli jest określona razem z innymi parametrami, musi być ostatnim parametrem. Tablica parametrów ... (rest) jest zapełniana tylko wtedy, gdy liczba argumentów przekazanych do funkcji jest większa od liczby pozostałych zadeklarowanych parametrów.

Każdy argument na liście argumentów oddzielanych przecinkami jest umieszczany w jednym elemencie tablicy. W wypadku przekazania instancji klasy Array cała tablica jest umieszczana w jednym elemencie tablicy parametrów ... (rest).

Użycie tego parametru powoduje, że obiekt arguments staje się niedostępny. Mimo że parametr ... (rest) zapewnia tę samą funkcjonalność, co tablica arguments i właściwość arguments.length, nie zapewnia funkcjonalności zbliżonej do oferowanej przez właściwość arguments.callee. Dlatego nie należy korzystać z parametru ... (rest) w sytuacjach, w których konieczne byłoby użycie właściwości arguments.callee.

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

Powiązane elementy interfejsu API

Definiuje metody i właściwości podstawowych klas języka ActionScript, które są właściwościami ustalonymi, a nie prototypowymi. Ustawienie opcji kompilatora "-as3" na true (w programie Flex Builder 2 jest to ustawienie domyślne) powoduje automatyczne otwarcie przestrzeni nazw AS3 dla wszystkich klas podstawowych. Oznacza to, że w instancji klasy podstawowej będą używane właściwości i metody ustalone, a nie wersje tych samych właściwości i metod dołączone do obiektu prototypowego klasy. Zastosowanie właściwości ustalonych zapewnia zwykle lepszą wydajność kosztem zgodności wstecz z wydaniem 3 specyfikacji języka ECMAScript (ECMA-262).

Powiązane elementy interfejsu API

Występuje w pętli (for, for...in, for each..in, do..while lub while) lub w bloku instrukcji skojarzonym z konkretnym warunkiem w instrukcji switch. Instrukcja break użyta w pętli nakazuje pominięcie pozostałej części treści pętli, przerwanie pętli i wykonanie instrukcji następującej po instrukcji pętli. Instrukcja break użyta wewnątrz instrukcji switch nakazuje pominięcie pozostałych instrukcji w danym bloku case i przejście do pierwszej instrukcji, jaka następuje po zamykającej instrukcji switch.

W pętlach zagnieżdżonych instrukcja break pomija tylko resztę bieżącej pętli i nie powoduje przerwania całego szeregu pętli zagnieżdżonych. Aby przerwać szereg pętli zagnieżdżonych, należy użyć instrukcji label lub try..catch..finally.

Z instrukcją break może być skojarzona opcjonalna etykieta identyczna z etykietą jednej z instrukcji zewnętrznych. Użycie etykiety, która nie ma odpowiednika w etykietach instrukcji zewnętrznych, jest błędem składniowym. Instrukcje break z etykietami mogą służyć do przerywania wielopoziomowych pętli zagnieżdżonych, instrukcji switch lub instrukcji block. Odpowiedni przykład zamieszczono przy opisie instrukcji label.

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

Powiązane elementy interfejsu API

case jumpTarget: statements

Definiuje miejsce docelowe skoku dla instrukcji switch. Jeśli parametr jumpTarget jest ściśle (zgodnie z działaniem operatora ===) równy parametrowi expression instrukcji switch, program Flash Player wykonuje instrukcje w parametrze statements, dopóki nie napotka instrukcji break lub końca instrukcji switch.

Użycie instrukcji case poza instrukcją switch spowoduje zgłoszenie błędu i uniemożliwi skompilowanie skryptu.

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

Powiązane elementy interfejsu API

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

Definiuje klasę, która umożliwia tworzenie instancji obiektów o wspólnych właściwościach i metodach zdefiniowanych w klasie. Na przykład, jeśli opracowujemy system rejestracji faktur, możemy utworzyć klasę Faktura definiującą wszystkie metody i właściwości wspólne dla każdej faktury. Następnie używalibyśmy polecenia new Faktura() do tworzenia obiektów klasy Faktura.

Każdy plik źródłowy ActionScript może zawierać tylko jedną klasę widoczną dla innych plików źródłowych lub skryptów. Ta klasa widoczna na zewnątrz może być klasą publiczną lub wewnętrzną i musi być zdefiniowana wewnątrz instrukcji package. Jeśli ten sam plik zawiera inne klasy, muszą one być umieszczone poza instrukcją package, na końcu pliku.

Nazwa klasy widocznej z zewnątrz musi być zgodna z nazwą pliku źródłowego ActionScript zawierającego tę klasę. Nazwa pliku źródłowego musi składać się z nazwy klasy z dodanym rozszerzeniem .as. Na przykład, jeśli nazwa klasy to Student, plik definiujący tę klasę musi nosić nazwę Student.as.

Nie jest dozwolone zagnieżdżanie definicji klas, tzn. nie można definiować dodatkowych klas wewnątrz definicji klasy.

Istnieje możliwość zdefiniowania metody-konstruktora, tj. metody wykonywanej za każdym razem, gdy jest tworzona nowa instancja klasy. Nazwa metody-konstruktora musi być identyczna z nazwą klasy. Jeśli metoda-konstruktor nie zostanie zdefiniowana jawnie, zostanie utworzony konstruktor domyślny.

Aby wskazać, że obiekty mogą w czasie wykonywania dodawać właściwości dynamiczne i uzyskiwać do nich dostęp, należy poprzedzić instrukcję class słowem kluczowym dynamic. Aby zadeklarować, że klasa implementuje interfejs, należy użyć słowa kluczowego implements. Do tworzenia podklas klasy służy słowo kluczowe extends. (Klasa może stanowić rozszerzenie tylko jednej klasy, ale może implementować kilka interfejsów). Słów kluczowych implements i extends można użyć w tej samej instrukcji. Następujący przykład ilustruje typowe zastosowania słów kluczowych implements i 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); 

Powiązane elementy interfejsu API

const identifier = value 

Określa stałą, czyli zmienną, której można przypisać wartość tylko jeden raz.

Możliwe jest ścisłe określenie typu stałej poprzez dopisanie za jej nazwą dwukropka (:) i typu danych.

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

Powiązane elementy interfejsu API

continue [label]

Przeskakuje poza wszystkie pozostałe instrukcje w najbardziej wewnętrznej pętli i rozpoczyna następną iterację pętli, tak jak przy normalnym przekazaniu sterowania na koniec pętli. Instrukcja continue nie ma wpływu na wykonywanie kodu poza pętlą. W pętlach zagnieżdżonych można użyć opcjonalnego parametru label w celu przeskoczenia nie tylko pętli najbardziej wewnętrznej, lecz także zewnętrznych.

Z instrukcją continue może być skojarzona opcjonalna etykieta identyczna z etykietą jednej z instrukcji zewnętrznych. Użycie etykiety, która nie ma odpowiednika w etykietach instrukcji zewnętrznych, jest błędem składniowym. Instrukcje continue z etykietami mogą służyć do przerywania wielopoziomowych pętli zagnieżdżonych.

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

Powiązane elementy interfejsu API

default: statements 

Definiuje domyślny przypadek w instrukcji switch. Instrukcje są wykonywane, jeśli parametr expression instrukcji switch nie równa się (ściśle, zgodnie z działaniem operatora [===]) żadnemu z parametrów expression następujących po słowach kluczowych case danej instrukcji switch.

Instrukcja switch nie musi zawierać instrukcji przypadku default. Instrukcja przypadku default nie musi być ostatnia na liście. Użycie instrukcji default poza instrukcją switch spowoduje zgłoszenie błędu i uniemożliwi skompilowanie skryptu.

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

Powiązane elementy interfejsu API

Dyrektywa default xml namespace określa domyślną przestrzeń nazw, jaka ma być używana dla obiektów XML.

Jeśli dyrektywa default xml namespace nie zostanie użyta, domyślną przestrzenią nazw będzie przestrzeń unnamed (z pustym ciągiem znaków jako identyfikatorem URI). Zasięg deklaracji default xml namespace to blok funkcji, podobnie jak zasięg zmiennej.

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/

Powiązane elementy interfejsu API

do { statement(s) } while (condition)

Podobna do pętli while z jednym wyjątkiem: instrukcje są zawsze wykonywane jeden raz przed pierwszym sprawdzeniem warunku. Następnie instrukcje są wykonywane tylko wtedy, gdy wynik wyrażenia warunkowego jest równy true.

Pętla do..while gwarantuje co najmniej jednokrotne wykonanie kodu zawartego w pętli. Mimo że ten sam rezultat można uzyskać za pomocą pętli while, umieszczając kopię instrukcji przeznaczonych do wykonania przed rozpoczęciem pętli while, w opinii wielu programistów pętle do..while są bardziej czytelne.

Jeśli wynikiem wyrażenia warunkowego zawsze jest true, pętla do..while jest nieskończona. Wejście w pętlę nieskończoną spowoduje problemy z działaniem programu Flash Player i ostatecznie doprowadzi do wyświetlenia komunikatu ostrzegawczego lub awarii odtwarzacza. Jeśli liczba wykonań pętli jest z góry znana, należy w miarę możliwości korzystać z pętli for. Mimo że pętle for są czytelne i łatwe w debugowaniu, nie we wszystkich okolicznościach mogą zastąpić pętle do..while.

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

Powiązane elementy interfejsu API

dynamic class className { // class definition here }

Określa, że instancje klasy mogą mieć właściwości dynamiczne, dodawane w czasie wykonywania. Nadanie klasie atrybutu dynamic umożliwi dodawanie właściwości do instancji tej klasy w czasie wykonywania. Klasy nieoznaczone jako dynamic są uznawane za zapieczętowane, co oznacza, że do ich instancji nie można dodawać właściwości.

Jeśli klasa jest zapieczętowana (a nie dynamiczna), próba pobrania lub ustawienia właściwości w jej instancji spowoduje błąd. Jeśli kompilator działa w trybie ścisłym i podczas tworzenia instancji określony zostanie typ danych, próba dodania właściwości do obiektu zapieczętowanego spowoduje błąd kompilatora; w przeciwnym razie wystąpi błąd w czasie wykonywania.

Atrybut dynamic nie jest dziedziczony przez podklasy. W przypadku rozszerzenia klasy dynamicznej podklasa jest dynamiczna tylko wtedy, gdy zostanie zadeklarowana z atrybutem 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

Powiązane elementy interfejsu API

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

Określa instrukcje, które mają być wykonane, jeśli wyrażenie warunkowe w instrukcji if zwróci wartość false. Jeśli w ramach instrukcji else ma być wykonana tylko jedna instrukcja, nie jest wymagane ujmowanie jej w nawiasy sześcienne ({}).

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

Powiązane elementy interfejsu API

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

Definiuje klasę będącą podklasą innej klasy. Podklasa dziedziczy wszystkie metody, właściwości, funkcje itp. zdefiniowane w nadklasie. Klasy oznaczone jako final nie mogą być rozszerzane.

Możliwe jest również użycie słowa kluczowego extends w celu rozszerzenia interfejsu. Interfejs rozszerzający inny interfejs zawiera wszystkie deklaracje metod oryginalnego interfejsu.

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

Powiązane elementy interfejsu API

false

Wartość typu Boolean reprezentująca fałsz. Wartość typu Boolean może być równa albo true, albo false; wartością przeciwną do false jest true.

Gdy w wyniku automatycznej konwersji typu wartość false jest przekształcana w liczbę, staje się wartością 0; gdy wartość false jest przekształcana w ciąg znaków, staje się ciągiem "false".

Uwaga: Wynikiem konwersji ciągu znaków "false" na typ Boolean jest wartość 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

Powiązane elementy interfejsu API

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

Określa, że nie można przesłonić metody lub że nie można rozszerzyć klasy. Próba przesłonięcia metody lub rozszerzenia klasy oznaczonej jako final spowoduje zgłoszenie błędu.

Powiązane elementy interfejsu API

Definiuje metody klasy Proxy. Metody klasy Proxy należą do ich własnej przestrzeni nazw, co pozwala uniknąć konfliktów nazw w sytuacji, gdy podklasa Proxy zdefiniowana przez użytkownika zawiera metody instancji o nazwach identycznych z metodami klasy Proxy.

Powiązane elementy interfejsu API

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

Jednokrotnie wyznacza wartość wyrażenia init (inicjacja) i rozpoczyna wykonywanie pętli. Każde wykonanie pętli rozpoczyna się od wyznaczenia wartości wyrażenia condition. Jeśli wynikiem wyrażenia condition jest true, wykonywana jest instrukcja statement i obliczane jest wyrażenie next. Następnie rozpoczyna się kolejne wykonanie pętli — od ponownego obliczenia wyrażenia condition.

Jeśli w ramach instrukcji for ma być wykonana tylko jedna instrukcja, nie jest wymagane ujmowanie jej w nawiasy sześcienne ({}).

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

Powiązane elementy interfejsu API

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

Przechodzi iteracyjnie do kolejnych dynamicznych właściwości obiektu lub elementów tablicy i wykonuje na każdym z nich instrukcję statement. Kolejność przechowywania właściwości w poszczególnych obiektach nie jest jednoznacznie określona, dlatego właściwości mogą być wybierane w pozornie losowym porządku. Właściwości ustalone, takie jak zmienne i metody zdefiniowane w klasie, nie są wyliczane przez instrukcję for..in. W celu uzyskania listy właściwości ustalonych należy zastosować funkcję describeType(), która znajduje się w pakiecie 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
*/

Powiązane elementy interfejsu API

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

Iteracyjnie przechodzi przez kolejne elementy kolekcji i wykonuje na każdym z nich instrukcję statement. Instrukcja for each..in wprowadzona jako element rozszerzeń języka E4X, może być stosowana nie tylko w odniesieniu do obiektów XML, lecz także innych obiektów i tablic. Pętla for each..in uwzględnia tylko właściwości dynamiczne obiektu, a nie właściwości ustalone. Właściwość ustalona to właściwość zdefiniowana jako część definicji klasy. Aby możliwe było zastosowanie instrukcji for each..in do instancji klasy zdefiniowanej przez użytkownika, należy zadeklarować tę klasę z atrybutem dynamic.

W przeciwieństwie do instrukcji for..in, instrukcja for each..in wybiera iteracyjnie wartości właściwości obiektu, a nie ich nazwy.

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

Zawiera zestaw instrukcji zdefiniowanych w celu wykonywania określonego zadania. Funkcję można zdefiniować w jednym miejscu i wywoływać ją z różnych skryptów w pliku SWF. Definiując funkcję, można również określić jej parametry. Parametry reprezentują wartości, na których funkcja operuje. W każdym wywołaniu funkcji można przekazać do niej inne parametry, co pozwala na stosowanie tej samej funkcji w różnych sytuacjach.

Instrukcja return w bloku statement(s) funkcji powoduje wygenerowanie, inaczej mówiąc zwrócenie, wartości przez funkcję.

Zastosowanie 1: Słowa kluczowego function można użyć do zdefiniowania funkcji o określonej nazwie, z określonymi parametrami, zawierającej określone instrukcje. Gdy skrypt wywołuje funkcję, wykonywane są instrukcje zawarte w jej definicji. Dozwolone są poprzedzające odwołania do funkcji — wywołanie funkcji może poprzedzać jej deklarację w tym samym skrypcie. Definicja funkcji zastępuje wszelkie wcześniejsze definicje tej samej funkcji. Składni tej można użyć w każdym miejscu, w którym dozwolone jest użycie instrukcji.

Zastosowanie 2: Słowa kluczowego function można także użyć do utworzenia funkcji anonimowej i zwrócenia referencji do niej. Ta składnia jest stosowana w wyrażeniach i bywa szczególnie przydatna do instalowania metod w obiektach.

Zastosowanie obiektu arguments w definicji funkcji stwarza pewne dodatkowe możliwości. Obiekt arguments jest często stosowany do tworzenia funkcji przyjmujących zmienną liczbę parametrów i do tworzenia rekurencyjnych funkcji anonimowych.

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

Powiązane elementy interfejsu API

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

Definiuje funkcję pobierającą, tj. metodę, którą można odczytywać tak, jak właściwość. Funkcja pobierająca jest to specjalna funkcja, która zwraca wartość właściwości zadeklarowanej przy użyciu słowa kluczowego var lub const. W przeciwieństwie do innych metod, funkcję pobierającą wywołuje się bez nawiasów (()), przez co jej wywołanie wygląda jak zmienna.

Funkcje pobierające umożliwiają realizację koncepcji ukrywania informacji, pozwalając na tworzenie interfejsu publicznego dla właściwości prywatnej. Zaletą ukrywania informacji jest zachowanie tego samego interfejsu publicznego niezależnie od ewentualnych zmian implementacji właściwości prywatnej.

Inna zaleta funkcji pobierających to możliwość przesłaniania ich w podklasach, która odróżnia je od właściwości zadeklarowanych przy użyciu słów kluczowych var lub const.

Funkcję pobierającą można utworzyć w parze z funkcją ustawiającą, tworząc tym samym właściwość z możliwością odczytu i zapisu. Aby utworzyć właściwość tylko do odczytu, należy utworzyć funkcję pobierającą bez odpowiadającej jej funkcji ustawiającej. Aby utworzyć właściwość tylko do zapisu, należy utworzyć funkcję ustawiającą bez odpowiadającej jej funkcji pobierającej.

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

Powiązane elementy interfejsu API

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

Sprawdza warunek w celu określenia, którą instrukcję należy wykonać jako następną. Jeżeli warunek jest spełniony (true), program Flash Player wykonuje instrukcje w nawiasach sześciennych ({}). Jeśli wynikiem sprawdzenia warunku jest false, program Flash Player pomija instrukcje w nawiasach sześciennych i wykonuje instrukcje, które znajdują się za tymi nawiasami. Zastosowanie instrukcji if razem z instrukcją else umożliwia tworzenie rozgałęzionych struktur logicznych skryptów.

Jeśli w ramach instrukcji if ma być wykonana tylko jedna instrukcja, nie jest wymagane ujmowanie jej w nawiasy sześcienne ({}).

Powiązane elementy interfejsu API

myClass implements interface01 [, interface02 , ...] 

Określa, że klasa implementuje jeden lub więcej interfejsów. Klasa, która implementuje interfejs, musi definiować wszystkie metody zadeklarowane w interfejsie. Każda instancja klasy implementującej interfejs jest uznawana za należącą do typu danych zdefiniowanego przez interfejs. W rezultacie operator is zwraca wartość true, gdy instancja klasy jest pierwszym operandem, a interfejs jest drugim operandem; ponadto działają (w obie strony) wymuszenia typu danych zdefiniowanego przez interfejs.

Powiązane elementy interfejsu API

import packageName.className 
import packageName.*

Udostępnia dla lokalnego kodu klasy i pakiety zdefiniowane zewnętrznie względem niego. Na przykład, aby użyć klasy flash.display.Sprite we własnym skrypcie, należy zaimportować tę klasę. To wymaganie stanowi różnice w stosunku do poprzednich wersji języka ActionScript, w których dyrektywa import była opcjonalna.

Po zastosowaniu dyrektywy import można używać pełnej nazwy klasy, wraz z nazwą pakietu, lub samej nazwy klasy.

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

Jeśli pakiet zawiera kilka klas, do których chcemy uzyskać dostęp, można je wszystkie zaimportować w ramach jednej instrukcji, do ilustruje poniższy przykład:

import flash.display.*;

Dyrektywa import importuje tylko klasy, funkcje i zmienne znajdujące się na najwyższym poziomie importowanego pakietu. Pakiety zagnieżdżone należy zaimportować jawnie.

Jeśli klasa zostanie zaimportowana, ale nie będzie używana w skrypcie, to nie zostanie wyeksportowana w ramach pliku SWF. Oznacza to, że można importować obszerne pakiety bez obaw o nadmierny rozmiar pliku SWF; kod bajtowy skojarzony z klasą zostanie umieszczony w pliku SWF tylko wówczas, gdy klasa będzie faktycznie używana. Niedogodnością związaną z importowaniem nieużywanych klas jest zwiększenie prawdopodobieństwa konfliktów nazw.

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

include "[path]filename.as"

Włącza zawartość określonego pliku w taki sposób, jak gdyby polecenia zawarte w tym pliku były częścią skryptu wywołującego. Dyrektywę include wywołuje się w czasie kompilacji. Dlatego po wprowadzeniu jakichkolwiek zmian do włączonego pliku należy go zapisać i ponownie skompilować wszystkie pliki SWG, w których jest używany.

 interface InterfaceName [extends InterfaceName ] {}

Definiuje interfejs. Interfejsy są to typy danych definiujące zestaw metod; każda klasa implementująca dany interfejs musi zawierać definicje wszystkich jego metod.

Interfejs przypomina klasę, z następującymi ważnymi wyjątkami:

• Interfejsy zawierają tylko deklaracje metod, a nie ich implementacje. Oznacza to, że każda klasa, która implementuje interfejs, musi zawierać implementacje wszystkich metod zadeklarowanych w tym interfejsie.
• Definicje metod interfejsu nie mogą mieć atrybutów, takich jak public lub private, ale zaimplementowane metody muszą być oznaczone jako public w definicji klasy implementującej interfejs.
• Jeden interfejs może dziedziczyć inne interfejsy przy wykorzystaniu instrukcji extends lub za pośrednictwem klasy, przy użyciu instrukcji implements.

Inaczej niż w wersji języka ActionScript 2.0, w języku ActionScript 3.0 dozwolone jest używanie metod (funkcji) pobierających i ustawiających w definicjach interfejsów.

Powiązane elementy interfejsu API

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

Określa, że klasa, zmienna, stała lub funkcja jest dostępna dla dowolnego kodu wywołującego w ramach tego samego pakietu. Klasy, właściwości i metody domyślnie należą do przestrzeni nazw internal.

Powiązane elementy interfejsu API

label: statement
label: {
    statements
}

Kojarzy instrukcję z identyfikatorem, do którego można odwoływać się w instrukcji break lub continue. W pętlach zagnieżdżonych instrukcja break lub continue, która nie odwołuje się do etykiety, może przeskoczyć tylko za pozostałą część bieżącej pętli, ale nie poza cały szereg pętli. Jeśli jednak z instrukcją definiującą szereg pętli jest skojarzona etykieta, instrukcja break lub continue może przeskoczyć cały szereg pętli, odwołując się do tej etykiety.

Etykiety umożliwiają również wymuszone wyjście z instrukcji blokowej. Nie jest dozwolone użycie instrukcji break, która nie odwołuje się do etykiety wewnątrz instrukcji blokowej, chyba że instrukcja blokowa jest częścią pętli. Jeśli z instrukcją blokową jest skojarzona etykieta, można użyć instrukcji break odwołującej się do tej etykiety wewnątrz instrukcji blokowej.

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

Powiązane elementy interfejsu API

namespace name [= uri]

Umożliwia sterowanie widocznością definicji. Do wstępnie zdefiniowanych przestrzeni nazw należą: public, private, protected i internal.

Poniżej przedstawiono krok po kroku sposób tworzenia przestrzeni nazw, stosowania jej i odwoływania się do niej:

• Najpierw zdefiniuj niestandardową przestrzeń nazw, korzystając ze słowa kluczowego namespace. Na przykład kod namespace version1 tworzy przestrzeń nazw o nazwie version1.
• Następnie zastosuj przestrzeń nazw do właściwości lub metody, umieszczając nazwę własnej niestandardowej przestrzeni nazw w deklaracji właściwości lub metody. Na przykład kod version1 myProperty:String tworzy właściwość myProperty, która należy do przestrzeni nazw version1.
• Na koniec odwołaj się do przestrzeni nazw, korzystając ze słowa kluczowego use lub poprzedzając identyfikator nazwą przestrzeni nazw. Na przykład kod use namespace version1; powoduje, że następne wiersze kodu będą odwoływały się do przestrzeni nazw version1, natomiast kod version1::myProperty odwołuje się do właściwości myProperty w przestrzeni nazw version1.

Powiązane elementy interfejsu API

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

Określa, że funkcja lub metoda jest zaimplementowana w kodzie macierzystym programu Flash Player. W programie Flash Player słowo kluczowe native jest używane wewnętrzne do deklarowania funkcji metod w interfejsie programowania aplikacji (API, ang. application programming interface) języka ActionScript. To słowo kluczowe nie może być używane we własnym kodzie użytkownika.  

null

Wartość specjalna, która może być przypisywana zmiennym lub zwracana przez funkcję w przypadku braku danych. Wartość specjalna null może reprezentować wartości nieistniejące lub takie, które nie mają zdefiniowanego typu danych.

Wartości null nie należy mylić z wartością specjalną undefined. Porównanie wartości null i undefined z pomocą operatora równości (==) wykaże ich równoważność. Porównanie wartości null i undefined za pomocą operatora ścisłej równości (===) wykaże jednak, że te wartości nie są równoważne.

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

Powiązane elementy interfejsu API

Definiuje metody klasy ObjectProxy. Metody klasy ObjectProxy należą do ich własnej przestrzeni nazw, co pozwala uniknąć konfliktów nazw w sytuacji, gdy podklasa Proxy zawiera metody instancji o nazwach identycznych z metodami klasy Proxy.

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

Określa, że metoda zastępuje metodę dziedziczoną. Aby przesłonić metodę dziedziczoną, należy użyć atrybutu override i zadbać o to, aby nazwa metody, atrybut właściwości klasy, liczba i typy jej parametrów oraz typ wartości zwracanej były dokładnie takie same, jak w metodzie przesłanianej. Błędem jest próba przesłonięcia metody bez użycia atrybutu override. Nie jest również dozwolone użycie atrybutu override w sytuacji, gdy nie istnieje zgodna metoda dziedziczona, którą dana metoda mogłaby przesłonić.

Nie jest dozwolone użycie atrybutu override w odniesieniu do:

• zmiennych;
• Stałe
• metod statycznych;
• metod, które nie zostały odziedziczone;
• metod, które implementują metodę zadeklarowaną w interfejsie;
• metod dziedziczonych, które są w nadklasie oznaczone jako final.

Mimo że nie jest dozwolone przesłonięcie właściwości zadeklarowanej za pomocą słowa kluczowego var lub const, można osiągnąć podobny efekt, deklarując właściwość klasy bazowej jako funkcję pobierającą-ustawiającą i przesłaniając metody zdefiniowane z użyciem słów kluczowych get i set.

Powiązane elementy interfejsu API

package packageName {
    class someClassName { 
    } 
}

Pozwala podzielić kod na odrębne grupy, które można importować do innych skryptów. Aby wskazać, że dana klasa wchodzi w skład pakietu, należy użyć słowa kluczowego package.

Powiązane elementy interfejsu API

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

Określa, że zmienna, stała lub metoda jest dostępna tylko w tej klasie, w której ją zadeklarowano lub zdefiniowano. Inaczej niż w języku ActionScript 2.0, w języku ActionScript 3.0 atrybut private nie umożliwia już dostępu do podklas. Ponadto atrybut private ogranicza dostęp zarówno w czasie kompilacji, jak i w czasie wykonywania. Domyślnie zmienna lub funkcja jest dostępna dla całego kodu wywołującego w ramach tego samego pakietu. Opisywanego słowa kluczowego należy użyć w celu ograniczenia dostępu do zmiennej lub funkcji.

Tego słowa kluczowego można używać wyłącznie w definicjach klas, a nie w definicjach interfejsów. Słowa kluczowego private nie można stosować do definicji klas lub innych definicji na poziomie pakietu.

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

Powiązane elementy interfejsu API

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

Określa, że zmienna, stała, metoda lub przestrzeń nazw jest dostępna tylko w tej klasie, w której ją zdefiniowano, oraz we wszystkich podklasach tej klasy. Definicja atrybutu protected w języku ActionScript 3.0 jest podobna do definicji atrybutu private w języku ActionScript 2.0, z tym że atrybut protected ogranicza dostęp zarówno w czasie kompilacji, jak i w czasie wykonywania. Domyślnie zmienna lub funkcja jest dostępna dla całego kodu wywołującego w ramach tego samego pakietu. Opisywanego słowa kluczowego należy użyć w celu ograniczenia dostępu do zmiennej lub funkcji.

Tego słowa kluczowego można używać wyłącznie w definicjach klas, a nie w definicjach interfejsów. Słowa kluczowego private nie można stosować do definicji klas lub innych definicji na poziomie pakietu.

Definicja atrybutu protected w języku ActionScript 3.0 jest bardziej restrykcyjna niż definicja atrybutu protected w języku programowania Java. W języku ActionScript 3.0 atrybut protected zezwala na dostęp wyłącznie do podklas, natomiast w języku Java atrybut protected zezwala również na dostęp do wszystkich klas w tym samym pakiecie. Na przykład, jeśli klasa o nazwie Base zawiera właściwość oznaczoną jako protected, w języku ActionScript 3.0 dostęp do tej właściwości będzie możliwy tylko z klas rozszerzających klasę Base. W języku Java dostęp do właściwości chronionej (protected) miałaby każda klasa w tym samym pakiecie, co klasa Base, w tym również klasy niebędące podklasami 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
  }
}

Powiązane elementy interfejsu API

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

Określa, że klasa, zmienna, stała lub metoda jest dostępna dla dowolnego kodu wywołującego. Klasy, zmienne i metody są domyślnie wewnętrzne (należą do przestrzeni nazw internal), czyli są widoczne tylko wewnątrz swojego pakietu. Aby klasa, zmienna lub metoda była widoczna dla każdego kodu wywołującego, należy użyć atrybutu 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

Powiązane elementy interfejsu API

function functionName () {
	return [expression]
}

Powoduje natychmiastowe przekazanie sterowania (powrót) do funkcji wywołującej. Jeśli po instrukcji return następuje wyrażenie, wyznaczana jest jego wartość i zwracany jest wynik.

Jeśli w definicji funkcji zadeklarowano typ zwracanej wartości, po instrukcji return musi następować wyrażenie. Jeśli nie zadeklarowano typu zwracanej wartości i instrukcja return zostanie użyta bez wyrażenia, zwraca wartość undefined.

Nie jest możliwe zwrócenie więcej niż jednej wartości. Próba taka spowoduje zwrócenie tylko ostatniej wartości. W następującym przykładzie zostanie zwrócona wartość c:

return a, b, c ;

Jeśli zachodzi konieczność zwrócenia wielu wartości, należy posłużyć się tablicą lub obiektem.

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

Powiązane elementy interfejsu API

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

Definiuje funkcję ustawiającą, tj. metodę widoczną w interfejsie publicznym jako właściwość. Funkcja ustawiająca jest to specjalna metoda, która ustawia wartość właściwości zadeklarowanej przy użyciu słowa kluczowego var. W przeciwieństwie do innych metod, funkcję ustawiającą wywołuje się bez nawiasów (()), przez co jej wywołanie wygląda jak zmienna.

Funkcje ustawiające umożliwiają realizację koncepcji ukrywania informacji, pozwalając na tworzenie interfejsu publicznego dla właściwości prywatnej. Zaletą ukrywania informacji jest zachowanie tego samego interfejsu publicznego niezależnie od ewentualnych zmian implementacji właściwości prywatnej.

Inna zaleta funkcji ustawiających to możliwość przesłaniania ich w podklasach, która odróżnia je od właściwości zadeklarowanych przy użyciu słowa kluczowego var.

Typ zwracany przez funkcję ustawiającą musi być zadeklarowany jako void albo nieokreślony.

Funkcję ustawiającą można utworzyć w parze z funkcją pobierającą, tworząc tym samym właściwość z możliwością odczytu i zapisu. Aby utworzyć właściwość tylko do odczytu, należy utworzyć funkcję pobierającą bez odpowiadającej jej funkcji ustawiającej. Aby utworzyć właściwość tylko do zapisu, należy utworzyć funkcję ustawiającą bez odpowiadającej jej funkcji pobierającej.

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

Powiązane elementy interfejsu API

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

Określa, że zmienna, stała lub metoda należy do klasy, a nie do instancji klasy.

Aby uzyskać dostęp do statycznego elementu klasy, należy zamiast nazwy instancji użyć nazwy klasy. Na przykład klasa Date ma metodę statyczną o nazwie parse(), którą można wywołać tylko przy użyciu następującej składni:

Date.parse()

Metody parse() nie można wywoływać z instancji klasy Date. Na przykład poniższy kod spowoduje wygenerowanie błędu:

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

Słowa kluczowego static można używać wyłącznie w definicjach klas, a nie w definicjach interfejsów.

Statyczne elementy klas nie są dziedziczone. Nie można odwoływać się do statycznego elementu klasy, używając nazwy podklasy, tak jak jest to dozwolone w językach Java lub C++. Możliwe jest natomiast odwoływanie się do zmiennych i metod statycznych wewnątrz klasy lub podklasy, bez stosowania jakiegokolwiek kwalifikatora. Ilustruje to poniższy przykład.

Wewnątrz metody statycznej nie można używać instrukcji super ani słowa kluczowego this.

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

Wywołuje nadklasę (czyli wersję będącą przodkiem) metody lub konstruktora. Instrukcja super() użyta w treści konstruktora klasy wywołuje wersję konstruktora zdefiniowaną w nadklasie. W wywołaniu konstruktora nadklasy musi być podana poprawna liczba argumentów. Należy zwrócić uwagę, że konstruktor nadklasy jest wywoływany zawsze, niezależnie od tego, czy zostanie wywołany jawnie. W wypadku braku wywołania jawnego przed pierwszą instrukcją w treści konstruktora podklasy zostanie automatycznie wstawione wywołanie bez argumentów. Oznacza to, że jeśli w podklasie jest zdefiniowany konstruktor, a konstruktor nadklasy przyjmuje co najmniej jeden argument, należy jawnie wywołać konstruktor nadklasy z poprawną liczbą argumentów, gdyż w przeciwnym razie zostanie zgłoszony błąd. Wywołanie konstruktora nadklasy nie musi być pierwszą instrukcją w konstruktorze podklasy (było to wymagane w języku ActionScript 2.0).

Instrukcja super zastosowana w metodzie instancji może być uzupełniona o operator (.) w celu wywołana wersji metody z nadklasy i opcjonalnego przekazania do niej argumentów (arg1 ... argN). Jest to użyteczne w przypadku tworzenia metod podklasy, które nie tylko uzupełniają metody nadklasy o dodatkowe zachowanie, lecz również wywołują metody nadklasy w celu zrealizowania ich pierwotnego zachowania.

Nie jest dozwolone użycie instrukcji super w metodzie statycznej.

Powiązane elementy interfejsu API

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

Przekazuje sterowanie do jednej z kilku instrukcji, w zależności od wartości wyrażenia. Wszystkie instrukcje switch powinny uwzględniać przypadek domyślny, który zostanie wykonany, jeśli wartość wyrażenia nie będzie pasować do żadnej z instrukcji case. Każda instrukcja case powinna kończyć się instrukcją break, która zapobiega niekontrolowanemu przejściu do następnego przypadku. Niekontrolowane przejście polega na wykonaniu kodu w następnej instrukcji case, nawet jeśli nie pasuje ona do wartości testowanego wyrażenia.

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

Powiązane elementy interfejsu API

this

Odwołanie do obiektu zawierającego metodę. Podczas wykonywania skryptu słowo kluczowe this oznacza odwołanie do obiektu, w którym ten skrypt jest zawarty. W treści metody słowo kluczowe this oznacza odwołanie do instancji klasy zawierającej wywołaną metodę.

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

Generuje (pot. wyrzuca, ang. throw) błąd, który może być obsłużony (pot. przechwycony, ang. catch) przez blok kodu catch. Jeśli wyjątek nie zostanie przechwycony przez blok catch, ciąg znaków reprezentujący wygenerowaną wartość zostanie wyświetlony w panelu Wyjście. Jeśli wyjątek nie zostanie przechwycony przez blok catch lub finally, ciąg reprezentujący wygenerowaną wartość zostanie zapisany w pliku dziennika.

Zwykle za pomocą instrukcji throw generowane są instancje klasy Error lub jej podklas (zob. sekcja Przykład).

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.

Powiązane elementy interfejsu API

true

Wartość typu Boolean reprezentująca prawdę. Wartość typu Boolean może być równa albo true, albo false; wartością przeciwną do true jest false. Gdy w wyniku automatycznej konwersji typów wartość true jest przekształcana w liczbę, staje się wartością 1; gdy wartość true jest przekształcana w ciąg znaków, staje się ciągiem "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

Powiązane elementy interfejsu API

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

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

Otacza blok kodu, w którym może wystąpić błąd, i pozwala zareagować na błąd. Obsługa wyjątków, implementowana za pomocą instrukcji try..catch..finally jest podstawowym mechanizmem, jaki język ActionScript 3.0 oferuje do obsługi błędów występujących w czasie wykonywania. Gdy w czasie wykonywania wystąpi błąd, program Flash Player generuje wyjątek, a tym samym zawiesza normalne wykonywanie kodu i tworzy specjalny obiekt typu Error. Następnie program Flash Player przekazuje (pot. wyrzuca) obiekt błędu o pierwszego dostępnego bloku catch. Jeśli nie ma dostępnych bloków catch, wyjątek jest uznawany za nieprzechwycony. Nieprzechwycone wyjątki powodują zakończenie wykonywania skryptu.

Instrukcja throw umożliwia jawne generowanie wyjątków w kodzie. Dozwolone jest generowanie dowolnej wartości, ale dobrą praktyką jest generowanie obiektów, ponieważ taki sposób postępowania jest zgodny z zachowaniem samego odtwarzacza Flash Player i zapewnia elastyczność.

Aby przechwycić wyjątek wygenerowany przez program Flash Player lub przez własny kod użytkownika, należy umieścić kod, który może wygenerować wyjątek, wewnątrz bloku try. Jeśli kod w bloku try wygeneruje wyjątek, sterowanie jest przekazywane do bloku catch, o ile taki blok istnieje, a następnie do bloku finally, o ile taki blok istnieje. Blok finally jest wykonywany zawsze, niezależnie od tego, czy wyjątek został wygenerowany. Jeśli kod w bloku try nie wygeneruje wyjątku (tj. blok kodu try zostanie wykonany bezbłędnie), kod w bloku catch zostanie zignorowany, ale kod w bloku finally i tak zostanie wykonany. Blok finally jest wykonywany nawet wówczas, gdy wyjście z bloku try nastąpi poprzez użycie instrukcji return.

Po bloku try musi następować blok catch, blok finally lub oba te bloki. Z jednym blokiem try może być skojarzonych wiele bloków catch, ale tylko jeden blok finally. Dozwolone jest zagnieżdżanie bloków try na dowolną głębokość.

Parametr error określony w bloku obsługi catch musi być prostym identyfikatorem, takim jak e, theException lub x. Parametr ten może również mieć określony typ. Parametry o określonym typie, używane razem z wieloma blokami catch, pozwalają na przechwytywanie wielu typów obiektów błędów w jednym bloku try.

Jeśli wygenerowany wyjątek jest obiektem, typ zostanie uznany za dopasowany, jeśli wygenerowany obiekt będzie podklasą określonego typu. Jeśli zostanie wygenerowany błąd określonego typu, zostanie wykonany blok catch obsługujący błędy tego typu. Jeśli zostanie wygenerowany wyjątek nienależący do określonego typu, blok catch nie zostanie wykonany, a wyjątek zostanie automatycznie przekazany poza blok try do pasującego bloku obsługi catch.

Jeśli błąd zostanie wygenerowany wewnątrz funkcji, a funkcja nie zawiera bloku obsługi catch, program Flash Player wychodzi z tej funkcji, a potem z funkcji, które ją wywołały, dopóki nie napotka bloku catch. W trakcie tego procesu na wszystkich poziomach wykonywane są bloki obsługi finally.

Uwaga: Jeśli na przykład blok try zawiera obiekt wywołujący zdarzenie jego modułu obsługi zdarzeń, blok catch nie przechwytuje błędu w przypadku wygenerowania błędu przez ten moduł. Każdy błąd wygenerowany później może zostać przechwycony przez wykrywanie zdarzenia LoaderInfo.uncaughtErrorEvents.

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

Powiązane elementy interfejsu API

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

Powoduje dodanie określonych przestrzeni nazw do zestawu otwartych przestrzeni nazw. Określone przestrzenie nazw zostaną usunięte z zestawu otwartych przestrzeni nazw po wyjściu z bieżącego bloku kodu. Dyrektywa use namespace może być umieszczona na najwyższym poziomie programu, definicji pakietu lub definicji klasy.

Powiązane elementy interfejsu API

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

Określa zmienną. Zmienne zadeklarowane wewnątrz funkcji są lokalne. Są zdefiniowane dla tej funkcji i przestają istnieć po zakończeniu wywołania funkcji.

Zmiennej, która znajduje się w zasięgu innego obiektu, nie można zadeklarować jako lokalnej.

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

Zmiennej można przypisać typ danych, dopisując za jej nazwą dwukropek i typ danych.

W jednej instrukcji można zadeklarować wiele zmiennych, oddzielając deklaracje przecinkami (jednak użycie takiej składni może zmniejszyć przejrzystość kodu):

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

Powiązane elementy interfejsu API

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

Wyznacza wartość warunku i jeśli wartość ta jest równa true, wykonuje jedną lub wiele instrukcji, po czym wraca na początek pętli i ponownie wyznacza wartość warunku. Gdy wyznaczona wartość warunku to false, instrukcje w pętli są pomijane i pętla kończy się.

Instrukcja while wykonuje następującą sekwencję kroków. Każde powtórzenie kroków od 1 do 4 jest nazywane iteracją pętli. Na początku każdej iteracji testowany jest warunek. Działanie instrukcji dokładniej opisano w poniższych krokach:

1. Wyznaczana jest wartość wyrażenia condition.
2. Jeśli wyznaczona wartość wyrażenia condition jest równa true lub jest wartością, która po przekonwertowaniu na typ Boolean daje wartość true (np. liczbą niezerową), następuje przejście do kroku 3. W przeciwnym razie wykonywanie instrukcji while kończy się, a sterowanie przechodzi do następnej instrukcji po pętli while.
3. Wykonywany jest blok instrukcji statement(s). W razie napotkania instrukcji continue pozostałe instrukcje są pomijane i następuje powrót do kroku 1. W razie napotkania instrukcji break wykonywanie instrukcji while kończy się, a sterowanie jest przekazywane do następnej instrukcji po pętli while.
4. Następuje powrót do kroku 1.

Pętle są często stosowane do wykonywania pewnej operacji tak długo, jak długo zmienna licznikowa jest mniejsza od określonej wartości. Na końcu każdej pętli licznik jest inkrementowany, aż do osiągnięcia określonej wartości. W tym momencie wyrażenie condition przestaje mieć wartość true i pętla kończy się.

Jeśli w ramach instrukcji while ma być wykonana tylko jedna instrukcja, nie jest wymagane ujmowanie jej w nawiasy sześcienne ({}).

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

Powiązane elementy interfejsu API

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

Ustanawia obiekt domyślny, na którym mają być wykonywane instrukcje, pozwalając na skrócenie kodu programu.

Parametr object staje się kontekstem, w którym interpretowane są właściwości, zmienne i funkcje w parametrze statement(s). Na przykład, jeśli object to tablica my_array, a dwie spośród określonych właściwości to length i concat, właściwości te będą automatycznie interpretowane jako my_array.length i my_array.concat. A oto inny przykład: jeśli object to state.california, wszelkie operacje lub instrukcje wewnątrz instrukcji with będą traktowane tak, jak gdyby były wywoływane z instancji california.

Aby wyznaczyć wartość identyfikatora w parametrze statement(s), kompilator języka ActionScript rozpoczyna analizę od początku łańcucha zasięgu określonego przez object i szuka identyfikatora na każdym poziomie łańcucha zasięgu, w ustalonej kolejności.

Łańcuch zasięgu używany w instrukcji with do interpretacji identyfikatorów zaczyna się od pierwszego elementu na poniższej liście i zawiera kolejne elementy tej listy:

• Obiekt określony w parametrze object najbardziej wewnętrznej instrukcji with.
• Obiekt określony w parametrze object najbardziej zewnętrznej instrukcji with.
• Obiekt Activation (obiekt tymczasowy tworzony automatycznie, gdy skrypt wywołuje funkcję zawierającą zmienne lokalne wywoływane w funkcji).
• Obiekt zawierający obecnie wykonywany skrypt.
• Obiekt Global (do tej klasy należą obiekty wbudowane, takie jak Math i String).

Aby wewnątrz instrukcji with można było nadać wartość zmiennej, zmienna ta musi być zadeklarowana poza instrukcją with lub należy wprowadzić pełną ścieżkę do osi czasu, na której ta zmienna ma istnieć. Próba nadania niezadeklarowanej zmiennej wartości wewnątrz instrukcji with spowoduje, że deklaracja zmiennej będzie poszukiwana zgodnie z łańcuchem zasięgu. Jeśli zmienna jeszcze nie istnieje, nowa wartość zostanie ustawiona na osi czasu, z której wywołano instrukcję with.

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