ステートメント、キーワード、ディレクティブ 

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

関数が任意の数のカンマ区切りの引数を取るよう指定します。引数のリストは配列となり、関数本体を介してアクセスできます。配列の名前をパラメーター宣言にある ... 文字の後に指定します。パラメーターには、予約語ではない名前を指定することができます。

他のパラメーターと共に使用する場合は、最後のパラメーターとして ...（rest）パラメーター宣言を指定する必要があります。...（rest）パラメーター配列は、関数に渡された引数の数が他のパラメーターの数より多い場合のみ作成されます。

カンマ区切りリストの引数は、それぞれ配列のエレメントとして配置されます。Array クラスのインスタンスを渡す場合は、配列全体が ...（rest）パラメーター配列の 1 つのエレメントに配置されます。

このパラメーターを使用すると、arguments オブジェクトは使用できなくなります。...（rest）パラメーターには arguments 配列および arguments.length プロパティと同じ機能がありますが、arguments.callee のような機能はありません。...（rest）パラメーターを使用する前に、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);
}

関連する API エレメント

プロトタイププロパティの代わりに固定プロパティとして使用する、ActionScript コアクラスのメソッドおよびプロパティを定義します。"-as3" コンパイラーオプションを true に設定すると（これは Flex Builder 2 のデフォルト設定です）、AS3 名前空間は自動的にすべてのコアクラスに対してオープンになります。つまり、コアクラスのインスタンスでは、クラスのプロトタイプオブジェクトに割り当てられた同じプロパティおよびメソッドのバージョンの代わりに、固定プロパティおよびメソッドを使用します。固定プロパティを使用するとパフォーマンスが向上しますが、ECMAScript Edition 3 言語仕様（ECMA-262）との後方互換性が失われます。

関連する API エレメント

ループ（for、for..in、for each..in、do..while または while）で使用します。また、switch ステートメント内の特定のケースと関連するステートメントのブロック内でも使用します。break ステートメントをループ内で使用すると、ループ本体の残りの部分をスキップし、繰り返し処理を停止して、ループステートメントの次のステートメントを実行します。break ステートメントを switch 内で使用すると、case ブロック内の残りのステートメントをスキップし、囲んでいる switch ステートメントに続く最初のステートメントにジャンプします。

入れ子のループ内では、break は、そのループの残りの部分をスキップするだけで、入れ子の一連のループは終了しません。入れ子の一連のループを終了するには、label または try..catch..finally を使用します。

break ステートメントには、オプションのラベルを指定できますが、このラベルは外側のステートメントのラベルと一致している必要があります。外側のステートメントのラベルと一致しないラベルを使用すると、シンタックスエラーが発生します。ラベル付きの break ステートメントを使用すると、入れ子のループステートメント、switch ステートメントまたは block ステートメントの複数のレベルを終了できます。例については、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*/

関連する API エレメント

case jumpTarget: statements

switch ステートメントのジャンプターゲットを定義します。jumpTarget パラメーターと、厳密な等価（===）を使用している switch ステートメントの expression パラメーターが等しい場合、break ステートメントが見つかるか、または switch ステートメントの終わりに到達するまで、statements パラメーター内のステートメントが実行されます。

case ステートメントを switch ステートメントの外側で使用すると、エラーが発生し、スクリプトはコンパイルされません。

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

関連する API エレメント

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

独自で定義したメソッドとプロパティを共有するオブジェクトをインスタンス化できるクラスを定義します。例えば、送り状追跡システムを作成する場合に、送り状クラスを定義して、各送り状で必要になるすべてのメソッドとプロパティを定義します。その後、new Invoice() コマンドを使用して、送り状オブジェクトを作成します。

ActionScript ソースファイルごとに、他のソースファイルやスクリプトに対して表示されるクラスを 1 つ指定できます。この外部に表示されるクラスは、パブリッククラスでも内部クラスでも構いません。これは package ステートメント内で定義する必要があります。同じファイルに他のクラスを含める場合は、クラスを package ステートメントの外の、ファイルの末尾に配置する必要があります。

外部に対して表示されるクラスの名前は、そのクラスを含む ActionScript ソースファイルの名前と一致する必要があります。ソースファイルの名前は、クラス名にファイル拡張子 .as を付けた名前である必要があります。例えば、あるクラスに Student という名前を付ける場合、このクラスを定義するファイルの名前は Student.as になります。

クラス定義を入れ子にすることはできません。つまり、クラス定義内に別のクラスを定義することはできません。

コンストラクターメソッドは定義できます。これは、クラスの新しいインスタンスが作成されるたびに実行されるメソッドです。コンストラクターメソッドの名前は、クラスの名前と一致する必要があります。コンストラクターメソッドを定義しない場合は、デフォルトのコンストラクターが作成されます。

実行時にオブジェクトが動的プロパティを追加したり、動的プロパティにアクセスしたりできるようにする場合は、クラスステートメントの前に dynamic キーワードを付加します。インターフェイスを実装するクラスを宣言するには、implements キーワードを使用します。クラスのサブクラスを作成するには、extends キーワードを使用します。クラスは 1 つしか拡張できませんが、インターフェイスは複数実装することができます。implements キーワードと extends キーワードは、1 つのステートメントで一緒に使うことができます。次の例では、implements キーワードと 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); 

関連する API エレメント

const identifier = value 

定数（値を 1 回だけ割り当てることができる変数）を指定します。

データタイプの後にコロン（:）を付けて、厳密に定数を型指定できます。

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

関連する API エレメント

continue [label]

ループの終わりまで制御が通過したかのように、最も内側のループ内の残りのステートメントをすべてスキップして、ループの次の反復を開始します。continue ステートメントはループの外部では作用しません。入れ子のループでは、オプションの label パラメーターを使用すると、最も内側のループ以外もスキップできます。

continue ステートメントには、オプションのラベルを指定できますが、このラベルは外側のステートメントのラベルと一致している必要があります。外側のステートメントのラベルと一致しないラベルを使用すると、シンタックスエラーが発生します。ラベル付きの continue ステートメントを使用すると、入れ子のループステートメントの複数のレベルをスキップできます。

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

関連する API エレメント

default: statements 

switch ステートメントのデフォルトケースを定義します。このステートメントが実行されるのは、switch ステートメントの expression パラメーターが、所定の switch ステートメントの case キーワードに続く expression パラメーターと等しくない場合です（厳密な等価 [===] を使用）。

switch ステートメントに default ケースステートメントは必須ではありません。default ケースステートメントは、リストの最後に置く必要はありません。default ステートメントを switch ステートメントの外側で使用すると、エラーが発生し、スクリプトはコンパイルされません。

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

関連する API エレメント

default xml namespace ディレクティブは、XML オブジェクトに使用するデフォルトの名前空間を設定します。

default xml namespace を設定しない場合、デフォルトの名前空間は名前のない名前空間となり、空の文字列に設定された URI が設定されます。default xml namespace 宣言のスコープは、変数のスコープと同じように関数ブロック内です。

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/

関連する API エレメント

do { statement(s) } while (condition)

while ループに似ていますが、条件の最初の評価に先立ってステートメントが実行される点が異なります。その後、ステートメントは、条件が true と評価された場合にのみ実行されます。

do..while ループの場合、ループ内のコードは少なくとも 1 回は必ず実行されます。while ループを使用して、実行するステートメントのコピーを while ループの開始前に配置することで同じ操作を実現できますが、多くのプログラマーは do..while ループの方が読みやすいと考えています。

条件が常に true と評価されると、do..while ループは無限ループになります。無限ループに陥ると、Flash Player に問題が発生し、警告メッセージが出力されたり、プレーヤーがクラッシュしたりすることがあります。ループの回数がわかっている場合は、できる限り for ループを使用してください。for ループは読みやすくデバッグも簡単ですが、あらゆる状況で do..while ループの代わりに使用できるわけではありません。

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

関連する API エレメント

dynamic class className { // class definition here }

実行時に追加された dynamic プロパティをクラスのインスタンスで保有するよう指定します。クラスで dynamic 属性を使用する場合は、実行時にクラスのインスタンスにプロパティを追加できます。dynamic と指定されていないクラスは sealed と見なされます。sealed クラスのインスタンスには、プロパティを追加できません。

クラスが dynamic ではなく sealed の場合、クラスインスタンスでプロパティを取得または設定しようとすると、結果はエラーとなります。コンパイラーを strict モードに設定し、インスタンスを作成するときにデータタイプを指定する場合は、プロパティを sealed オブジェクトに追加しようとすると、コンパイラーエラーまたはランタイムエラーが発生します。

dynamic 属性はサブクラスに継承されません。dynamic クラスを拡張した場合は、サブクラスで dynamic 属性を宣言した場合にのみサブクラスが 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

関連する API エレメント

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

if ステートメントの条件が false を返したときに実行するステートメントを指定します。実行するステートメントが 1 つしかない場合、else ステートメントで実行するステートメントを囲む中括弧（{}）は必要ありません。

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

関連する API エレメント

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

他のクラスのサブクラスとするクラスを定義します。サブクラスは、スーパークラスで定義されているメソッド、プロパティ、関数などをすべて継承します。final とマークされたクラスは拡張できません。

extends キーワードを使用して、インターフェイスを拡張することもできます。他のインターフェイスを拡張したインターフェイスには、元のインターフェイスのメソッド宣言がすべて含まれます。

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

関連する API エレメント

false

false を表すブール値です。ブール値は true または false のいずれかです。false の反対は true です。

自動的な型指定により false を数値に変換すると、その結果は 0 となります。false を文字列に変換すると、その結果は "false" となります。

注意：文字列 "false" はブール値 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

関連する API エレメント

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

メソッドのオーバーライドまたはクラスの拡張を制限します。final と指定されたメソッドのオーバーライドや、クラスの拡張を試行すると、結果はエラーとなります。

関連する API エレメント

Proxy クラスのメソッドを定義します。Proxy クラスメソッドは自身の名前空間内にあり、Proxy クラスメソッド名と一致するインスタンスメソッド名が Proxy サブクラスに含まれる場合に、名前が競合しないようになっています。

関連する API エレメント

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

init（初期化）式を 1 回だけ評価してから、ループシーケンスを開始します。ループシーケンスは、condition 式を評価することで開始されます。condition 式の評価結果が true の場合は、statement が実行され、next が評価されます。その後、condition 式の評価からループシーケンスが再び開始されます。

実行するステートメントが 1 つしかない場合、for ステートメントで実行するステートメントブロックを囲む中括弧（{}）は必要ありません。

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

関連する API エレメント

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

オブジェクトの動的プロパティまたは配列のエレメントに対して反復処理を行い、各プロパティまたはエレメントに対して statement を実行します。オブジェクトのプロパティは特定の順序では維持されないので、プロパティは予期しない順序で表示されることがあります。for..in ステートメントでは、クラスに定義された変数やメソッドなどの固定プロパティは列挙されません。固定プロパティのリストを取得するには、flash.utils パッケージにある describeType() 関数を使用します。

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

関連する API エレメント

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

コレクションのアイテムに対して反復処理を行い、各アイテムに対して statement を実行します。E4X の言語拡張の一部として導入された for each..in ステートメントは、XML オブジェクトだけでなくオブジェクトや配列にも使用できます。for each..in ステートメントは、固定プロパティではなくオブジェクトの動的プロパティを介してのみ反復処理を行います。固定プロパティは、クラス定義の一部として定義されるプロパティです。ユーザー定義クラスのインスタンスで for each..in ステートメントを使用するには、クラスの属性を dynamic と宣言する必要があります。

for..in ステートメントとは異なり、for each..in ステートメントは、プロパティ名ではなくオブジェクトのプロパティの値に対して反復処理を行います。

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

特定のタスクを実行するよう定義した一連のステートメントで構成されます。ある位置で関数を定義し、SWF ファイルの異なるスクリプトからその関数を呼び出すことができます。関数を定義する場合、その関数のパラメーターも指定できます。パラメーターは、関数が処理する値のプレースホルダーです。関数を呼び出すたびに異なるパラメーターを渡すことができます。これにより、1 つの関数を異なる状況で再利用できます。

関数で値を生成する、つまり値を返すには、関数の statement(s) ブロックで return ステートメントを使用します。

シンタックス 1：function キーワードを使用して、関数名、パラメーターおよびステートメントを指定した関数を定義できます。スクリプトによって関数が呼び出されると、関数定義内のステートメントが実行されます。関数は前方参照が許されます。つまり、同じスクリプト内では、関数を呼び出す箇所よりも後に関数を宣言できます。関数定義は、同じ関数の以前の定義を置き換えます。ステートメントが許されている場所であれば、どこでもこのシンタックスを使用できます。

シンタックス 2：function を使用して匿名関数を作成し、その関数への参照を返すこともできます。このシンタックスは式の中で使用され、特にオブジェクト内にメソッドを組み込む場合に便利です。

さらに、関数定義内で arguments オブジェクトを使用することができます。一般に、arguments オブジェクトは、可変数のパラメーターを受け取る関数や再帰的な匿名関数を作成する場合に使用します。

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

関連する API エレメント

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

プロパティと同じように読み取り可能なメソッドである getter を定義します。getter は特別な関数で、var または const キーワードで宣言されたプロパティの値を返します。他のメソッドとは異なり、getter の呼び出しには括弧（()）を使用しないため、変数のように見えます。

getter では、プライベートプロパティにパブリックインターフェイスを作成して、非表示の情報の規則を適用できます。情報を非表示にすると、基になるプライベートプロパティの実装が変更された場合でも、パブリックインターフェイスを変更する必要がないというメリットがあります。

getter には、サブクラス内でオーバーライドできるというメリットもあります。var または const で宣言されたプロパティはオーバーライドできません。

getter は、setter と組み合わせて、読み取り／書き込み可能なプロパティを作成できます。読み取り専用プロパティを作成するには、対応する setter なしで getter を作成します。書き込み専用プロパティを作成するには、対応する getter なしで setter を作成します。

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

関連する API エレメント

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

条件を評価して、次のステートメントを実行するかどうかを判定します。条件が true の場合は、条件に続く中括弧（{}）内のステートメントが実行されます。条件が false の場合は、中括弧内のステートメントをスキップし、中括弧の後のステートメントが実行されます。スクリプト内に分岐処理を作成するには、if ステートメントと else ステートメントを組み合わせます。

実行するステートメントが 1 つしかない場合、if ステートメントで実行するステートメントを囲む中括弧（{}）は必要ありません。

関連する API エレメント

myClass implements interface01 [, interface02 , ...] 

クラスでインターフェイスを実装するかどうかを指定します。クラスでインターフェイスを実装する場合、インターフェイスで宣言されているすべてのメソッドをクラスで定義する必要があります。インターフェイスを実装するクラスのインスタンスは、インターフェイスが定義するデータタイプのメンバーと見なされます。このため、is 演算子は、最初のオペランドがクラスインスタンスで、次のオペランドがインターフェイスとなっており、さらに、データタイプの強制型変換がインターフェイス操作で定義されている場合に true を返します。

関連する API エレメント

import packageName.className 
import packageName.*

外部で定義されたクラスおよびパッケージをコードで使用できるようにします。例えば、スクリプトで flash.display.Sprite クラスを使用する場合は、これを読み込む必要があります。import ディレクティブはオプションだったため、この要件は以前のバージョンの ActionScript とは異なります。

import ディレクティブを使用した後は、パッケージ名を含む完全なクラス名かクラス名のみのいずれかを使用できます。

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

アクセス対象のクラスがパッケージ内に複数存在する場合は、次の例に示すように、1 つのステートメントですべてのクラスを読み込むことができます。

import flash.display.*;

import ディレクティブは、読み込んだパッケージの最上位レベルにあるクラス、関数および変数のみを読み込みます。入れ子のパッケージは明示的に読み込む必要があります。

読み込んだクラスをスクリプト内で使用しない場合、そのクラスは SWF ファイルには出力されません。したがって、SWF ファイルのサイズを気にすることなく、大きなパッケージを読み込むことができます。クラスに関連付けられたバイトコードは、実際に使用された場合のみ、SWF ファイルに含められます。必要のないクラスを読み込むと、名前の競合が起こりやすくなるというデメリットがあります。

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

include "[path]filename.as"

指定したファイル内のコマンドを呼び出し元のスクリプトにインクルードし、そのスクリプトの一部であるかのように扱います。include ディレクティブは、コンパイル時に呼び出されます。このため、インクルードファイルに何らかの変更を行った場合は、ファイルを保存し、ファイルを使用する SWF ファイルを再コンパイルする必要があります。

 interface InterfaceName [extends InterfaceName ] {}

インターフェイスを定義します。インターフェイスとは、メソッドのセットを定義するデータタイプです。このメソッドは、インターフェイスを実装するすべてのクラスで定義される必要があります。

インターフェイスはクラスに似ていますが、次に示す重要な違いがあります。

• インターフェイスにはメソッドの宣言だけが含まれます。メソッド実装は含まれません。つまり、インターフェイスを実装するすべてのクラスは、インターフェイスで宣言されている各メソッドの実装を定義する必要があります。
• インターフェイスメソッドの定義では、public または private などの属性を指定できませんが、実装されたメソッドはインターフェイスを実装するクラスの定義で public と指定する必要があります。
• extends ステートメントまたは implements ステートメントを介したクラスを使用して、インターフェイスで複数のインターフェイスを継承することができます。

ActionScript 2.0 とは異なり、ActionScript 3.0 ではインターフェイス定義で getter および setter メソッドを使用できます。

関連する API エレメント

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

クラス、変数、定数または関数に同じパッケージ内のすべての呼び出し元からアクセスできるよう指定します。デフォルトでは、クラス、プロパティおよびメソッドは internal 名前空間に属します。

関連する API エレメント

label: statement
label: {
    statements
}

ステートメントを break または continue で参照可能な識別子と関連付けます。入れ子のループでは、ラベルを参照しない break または continue ステートメントは、そのループの残りの部分のみスキップし、一連のループはスキップしません。ただし、一連のループを定義するステートメントに関連付けられたラベルがある場合、break または continue ステートメントはこのラベルを参照することにより、一連のループをスキップできます。

また、ラベルによりブロックステートメントを終了することもできます。ブロックステートメントがループの一部である場合以外は、ラベルを参照しない break ステートメントをブロックステートメント内に配置することはできません。ブロックステートメントに関連付けられたラベルがある場合は、このラベルを参照する break ステートメントをブロックステートメント内に配置できます。

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

関連する API エレメント

namespace name [= uri]

定義の可視性を制御できます。定義済みの名前空間には、public、private、protected および internal があります。

次に、名前空間を作成、適用、参照する手順を示します。

• 最初に、namespace キーワードを使用して、カスタム名前空間を定義します。例えば、コード namespace version1 では version1 という名前空間が作成されます。
• 次に、プロパティまたはメソッドの宣言でカスタム名前空間を使用して、プロパティまたはメソッドに名前空間を適用します。例えば、コード version1 myProperty:String では version1 名前空間に属する myProperty という名前のプロパティが作成されます。
• 次に、use キーワードを使用するか、接頭辞として識別子に名前空間を付けて、名前空間を参照します。例えば、コード use namespace version1; では以後のコード行で version1 名前空間が参照されます。コード version1::myProperty では myProperty プロパティに対して version1 名前空間が参照されます。

関連する API エレメント

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

Flash Player がネイティブコードで関数またはメソッドを実装するよう指定します。Flash Player では、native キーワードを内部的に使用して、ActionScript アプリケーションプログラミングインターフェイス（API）で関数およびメソッドを宣言します。このキーワードは、独自に作成するコードでは使用できません。

null

変数に割り当てることができる特別な値、またはデータがない場合に関数から返される特殊な値です。null は、存在しない、または定義されていないデータタイプを表す値として使用されます。

null 値は特殊な値 undefined と混同しないようにしてください。null と undefined を等価演算子（==）で比較すると、結果は true になります。ただし、null と undefined を厳密な等価演算子（===）で比較すると、結果は false になります。

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

関連する API エレメント

ObjectProxy クラスのメソッドを定義します。ObjectProxy クラスメソッドは自身の名前空間内にあり、Proxy クラスメソッド名と一致するインスタンスメソッド名が Proxy サブクラスに含まれる場合に、名前が競合しないようになっています。

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

メソッドで継承したメソッドを置き換えるよう指定します。継承したメソッドをオーバーライドするには、override 属性を使用する必要があります。名前、クラスプロパティ属性、パラメーターの数と型および戻り値の型は完全に一致する必要があります。override 属性を使用せずにメソッドをオーバーライドしようとするとエラーが発生します。同様に、メソッドに一致する継承されたメソッドがない場合に、override 属性を使用するとエラーが発生します。

次の場所で override 属性を使用することはできません。

• 変数
• 定数
• 静的メソッド
• 継承されたものでないメソッド
• インターフェイスメソッドを実装するメソッド
• スーパークラスで final と指定されている継承されたメソッド

var または const で宣言されたプロパティをオーバーライドすることはできませんが、基本クラスのプロパティを getter-setter とし、get および set で定義されたメソッドをオーバーライドすることで、同様の機能を実現することができます。

関連する API エレメント

package packageName {
    class someClassName { 
    } 
}

他のスクリプトから読み込んだ個別のグループにコードを分類できます。クラスがパッケージのメンバーであることを示すには、package キーワードを使用する必要があります。

関連する API エレメント

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

変数、定数またはメソッドを宣言または定義したクラスからのみアクセスできるよう指定します。ActionScript 2.0 とは異なり、ActionScript 3.0 の private ではサブクラスへのアクセスも制限されます。さらに、private ではコンパイル時および実行時の両方でアクセスが制限されます。デフォルトでは、同じパッケージにある呼び出し元は変数または関数にアクセスできます。このキーワードは、変数や関数へのアクセスを制限する場合に使用します。

このキーワードは、クラス定義でのみ使用できます。インターフェイス定義では使用できません。private は、クラスまたはその他のすべてのパッケージレベルの定義には適用できません。

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

関連する API エレメント

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

変数、定数、メソッドまたは名前空間を定義したクラスとそのサブクラスからのみアクセスできるよう指定します。ActionScript 3.0 の protected の定義は、ActionScript 2.0 の private と似ていますが、protected ではコンパイル時および実行時の両方でアクセスが制限される点が異なります。デフォルトでは、同じパッケージにある呼び出し元は変数または関数にアクセスできます。このキーワードは、変数や関数へのアクセスを制限する場合に使用します。

このキーワードは、クラス定義でのみ使用できます。インターフェイス定義では使用できません。private は、クラスまたは他のすべてのパッケージレベルの定義には適用できません。

ActionScript 3.0 の protected の定義には、Java プログラミング言語の protected より多くの制限があります。ActionScript 3.0 の protected ではサブクラスへのアクセスが厳密に制限されますが、Java の protected では同じパッケージ内のすべてのクラスへのアクセスが許可されます。例えば、Base という名前のクラスに protected と指定されたプロパティが含まれる場合、ActionScript 3.0 では Base の拡張クラスのみが保護されたプロパティにアクセスできます。Java では、Base と同じパッケージにあるすべてのクラスが保護されたプロパティにアクセスでき、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
  }
}

関連する API エレメント

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

クラス、変数、定数またはメソッドにすべての呼び出し元からアクセスできるよう指定します。クラス、変数およびメソッドはデフォルトでは内部クラスです。つまり、現在のパッケージ内にのみ表示されます。クラス、変数またはメソッドにすべての呼び出し元からアクセスできるようにするには、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

関連する API エレメント

function functionName () {
	return [expression]
}

実行を呼び出し元の関数に直ちに返します。return ステートメントの後に式が続く場合は、式が評価されて結果が返されます。

関数の定義に戻り値の型が含まれている場合は、return ステートメントの後に式を続ける必要があります。戻り値の型が指定されておらず、return ステートメントが単独で使用されている場合は、undefined を返します。

複数の値を取得することはできません。複数の値を取得しようとした場合は、最後の値だけが返されます。次の例では、c が返されます。

return a, b, c ;

複数の値を取得する必要がある場合は、代わりに配列またはオブジェクトを使用します。

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

関連する API エレメント

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

パブリックインターフェイスでプロパティとして表示されるメソッドである setter を定義します。setter は特別なメソッドで、var キーワードで宣言されたプロパティの値を設定します。他のメソッドとは異なり、setter の呼び出しには括弧（()）を使用しないため、変数のように見えます。

setter では、プライベートプロパティにパブリックインターフェイスを作成して、非表示の情報の規則を適用できます。情報を非表示にすると、基になるプライベートプロパティの実装が変更された場合でも、パブリックインターフェイスを変更する必要がないというメリットがあります。

setter には、サブクラス内でオーバーライドできるというメリットもあります。var で宣言されたプロパティはオーバーライドできません。

setter の戻り値の型は、void または指定なしのいずれかである必要があります。

setter は、getter と組み合わせて、読み取り／書き込み可能なプロパティを作成できます。読み取り専用プロパティを作成するには、対応する setter なしで getter を作成します。書き込み専用プロパティを作成するには、対応する getter なしで setter を作成します。

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

関連する API エレメント

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

変数、定数またはメソッドがクラスのインスタンスではなくクラスに属するよう指定します。

静的クラスメンバーにアクセスするには、インスタンス名の代わりにクラス名を使用します。例えば、Date クラスにある parse() という名前の静的メソッドは、次のシンタックスでのみ呼び出すことができます。

Date.parse()

parse() メソッドは、Date クラスのインスタンスで呼び出すことはできません。例えば、次のコードではエラーが発生します。

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

static は、クラス定義でのみ使用できます。インターフェイス定義では使用できません。

静的クラスメンバーは継承されません。Java や C++ のように、サブクラス名を使用して静的クラスメンバーを参照することはできません。ただし、修飾子を使用せずに、クラスまたはサブクラス内の静的変数またはメソッドを参照できます。次の例を参照してください。

静的メソッド内では、super ステートメントまたは 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])

メソッドやコンストラクターのスーパークラスまたは親バージョンを呼び出します。クラスコンストラクターの本体内で使用する場合、super() ステートメントはコンストラクターのスーパークラスバージョンを呼び出します。スーパークラスコンストラクターの呼び出しには、正しい数の引数が指定されている必要があります。スーパークラスコンストラクターは、明示的に呼び出すかどうかに関わらず、必ず呼び出されます。明示的に呼び出さない場合、呼び出しは引数なしでサブクラスのコンストラクター本体の最初のステートメントの前に自動的に挿入されます。つまり、サブクラスでコンストラクター関数を定義し、スーパークラスコンストラクターが引数を取る場合は、正しい数の引数を指定してスーパークラスコンストラクターを明示的に呼び出す必要があります。そうでない場合は、エラーが発生します。ただし、ActionScript 2.0 とは異なり、スーパークラスコンストラクターへの呼び出しは、サブクラスコンストラクターの最初のステートメントである必要はありません。

インスタンスメソッドの本体で使用する場合は、super をドット（.）演算子と共に使用して、メソッドのスーパークラスバージョンを呼び出すことができます。また、オプションとしてスーパークラスメソッドに引数 (arg1 ... argN) を渡すこともできます。このスタイルは、スーパークラスのメソッドにビヘイビアーを追加するだけでなく、そのメソッドを呼び出して元のビヘイビアーを実行するようなサブクラスメソッドを作成する場合に便利です。

静的メソッドで super ステートメントを使用することはできません。

関連する API エレメント

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

式の値に応じて、ステートメントへの転送を制御します。switch ステートメントには、どの case ステートメントも式に一致しない場合に実行するデフォルトケースを指定する必要があります。それぞれの case ステートメントは、break ステートメントで終了する必要があります。これにより、フォールスルーエラーを回避できます。フォールスルーエラーが発生すると、ケースがテスト式に一致しない場合でも、次の case ステートメントのコードが実行されます。

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

関連する API エレメント

this

メソッドに含まれるオブジェクトへの参照です。スクリプトの実行時には、this キーワードはそのスクリプトを含むオブジェクトを参照します。メソッド本体内では、this キーワードは呼び出されたメソッドを含むクラスインスタンスを参照します。

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

catch コードブロックによって処理（キャッチ）できるエラーを生成（スロー）します。catch ブロックが例外をキャッチしない場合は、スローされた値の文字列表現が出力パネルに表示されます。catch または finally ブロックが例外をキャッチしない場合は、スローされた値の文字列表現がログファイルに送られます。

一般には、Error クラスまたはそのサブクラスのインスタンスをスローします。「例」を参照してください。

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.

関連する API エレメント

true

true を表すブール値です。ブール値は true または false のいずれかです。true の反対は false です。自動的な型指定により true を数値に変換すると、その結果は 1 となります。true を文字列に変換すると、その結果は "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

関連する API エレメント

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

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

エラーが発生する可能性のあるコードブロックを囲み、そのエラーに対処します。try..catch..finally ステートメントを使用して実装される例外処理は、ActionScript 3.0 でランタイムエラーの条件処理に使用される主要なメカニズムです。ランタイムエラーが発生すると、Flash Player は例外をスローして、通常の実行を一時停止し、Error 型の特殊なオブジェクトを作成します。次に、最初にアクセス可能な catch ブロックにエラーオブジェクトをパス（スロー）します。アクセス可能な catch ブロックがない場合、例外は不明な例外と見なされます。不明な例外が発生すると、スクリプトは終了します。

throw ステートメントを使用して、コードで例外を明示的にスローすることができます。任意の値をスローできますが、柔軟性があり Flash Player のビヘイビアーに一致するオブジェクトをスローすることが推奨されます。

例外をキャッチするには、Flash Player または作成したコードでスローするかに関わらず、例外をスローするコードを try ブロックに配置します。try ブロック内のコードが例外をスローすると、制御は catch ブロックがある場合はこれに移動し、次に finally ブロックがある場合はこれに移動します。finally ブロックは、例外がスローされたかどうかに関わらず、必ず実行されます。try ブロック内のコードが例外をスローしなかった場合（try ブロックが正常終了した場合）、catch ブロック内のコードは無視されますが、finally ブロック内のコードは実行されます。return ステートメントを使用して try ブロックを終了した場合でも、finally ブロックは実行されます。

try ブロックの後には、catch ブロックまたは finally ブロック、またはその両方を続ける必要があります。1 つの try ブロックに対して複数の catch ブロックを指定できますが、finally ブロックは 1 つしか記述できません。try ブロックは、必要なだけ何レベルでも入れ子にできます。

catch ハンドラーで指定する error パラメーターには、e、theException または x のような単純な識別子を使用します。パラメーターの型を指定することもできます。複数の catch ブロックを使用する場合は、型指定したパラメーターを使用することで、1 つの try ブロックからスローされた複数の型のエラーオブジェクトをキャッチできます。

スローした例外がオブジェクトである場合、スローしたオブジェクトが指定した型のサブクラスであれば、型が一致します。特定の型のエラーがスローされた場合は、対応するエラーを処理する catch ブロックが実行されます。指定した型ではない例外がスローされた場合、catch ブロックは実行されず、try ブロックからそのエラーに一致する catch ハンドラーに対して例外が自動的にスローされます。

関数の内部でエラーがスローされ、その関数に catch ハンドラーが含まれていない場合、その関数は終了します。catch ブロックが見つからない限り、呼び出し元の関数もすべて終了します。このプロセスの間に、すべてのレベルの finally ハンドラーが呼び出されます。

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

関連する API エレメント

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

指定した名前空間をオープンな名前空間のセットに追加します。指定した名前空間は、現在のコードブロックが終了すると、オープンな名前空間のセットから削除されます。use namespace ディレクティブは、プログラム、パッケージ定義またはクラス定義の最上位のレベルに表示できます。

関連する API エレメント

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

変数を指定します。関数内で変数を宣言した場合、その変数はローカルです。変数はその関数用に定義され、関数呼び出しの終了時にスコープから外れます。

別のオブジェクトのスコープ内の変数をローカル変数として宣言することはできません。

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

データタイプの後にコロンを付けて、変数にデータタイプを割り当てることができます。

カンマで宣言を区切ることにより、1 つのステートメントで複数の変数を宣言できます。ただし、このシンタックスを使用すると、コードが読みにくくなる場合があります。

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

関連する API エレメント

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

条件を評価して、条件の評価結果が true になる場合はステートメントを実行します。その後、ループの先頭に戻り、再び条件を評価します。条件の評価結果が false になると、ステートメントはスキップされ、ループは終了します。

while ステートメントは、次の手順を実行します。手順 1 ～ 4 の各繰り返しはループの反復と呼ばれます。次の手順に示すように、条件は各反復の始めにテストされます。

1. 式 condition が評価されます。
2. condition の評価が true であるか、ブール値 true に変換される値（ゼロ以外の数値など）である場合は、手順 3 に進みます。それ以外の場合は、while ステートメントが完了し、while ループの直後のステートメントから実行が再開されます。
3. ステートメントブロック statement(s) を実行します。continue ステートメントが検出された場合は、残りのステートメントをスキップし、手順 1 に進みます。break ステートメントが検出された場合は、while ステートメントを終了し、while ループの直後のステートメントから実行が再開されます。
4. 手順 1 に進みます。

一般にループ処理は、カウンター変数が指定値より小さい間にアクションを実行するために使用します。各ループの最後で、指定された値に達するまでカウンターがインクリメントされます。指定された値に達すると、condition は true でなくなり、ループは終了します。

実行するステートメントが 1 つしかない場合、while ステートメントで実行するステートメントを囲む中括弧（{}）は必要ありません。

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

関連する API エレメント

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

ステートメントの実行に使用するデフォルトのオブジェクトを設定します。記述するコードの量を減らすことができます。

object パラメーターは、statement(s) パラメーターのプロパティ、変数および関数を読み取るときのコンテキストになります。例えば、object が my_array であり、指定されたプロパティのうちの 2 つが length と concat である場合、これらのプロパティは my_array.length および my_array.concat として自動的に読み取られます。別の例で、object が state.california である場合、with ステートメント内のアクションまたはステートメントは california インスタンス内から呼び出されます。

statement(s) パラメーターで識別子の値を検索する場合、ActionScript は object で指定されたスコープチェーンの先頭から開始し、特定の順序でスコープチェーンの各レベルで識別子を検索します。

識別子を解決するために with ステートメントで使用されるスコープチェーンは、次のリストの最初の項目から始まり、最後の項目まで続きます。

• 最も内側の with ステートメントの object パラメーターで指定されたオブジェクト
• 最も外側の with ステートメントの object パラメーターで指定されたオブジェクト
• Activation オブジェクト（スクリプトが関数内で呼び出されたローカル変数を持つ関数を呼び出すときに自動的に作成されるテンポラリオブジェクト）
• 実行中のスクリプトを含むオブジェクト
• Global オブジェクト（Math や String などの定義済みオブジェクト）

with ステートメント内に変数を設定するには、with ステートメントの外側で変数を宣言しておくか、変数を設定するタイムラインへのフルパスを入力する必要があります。変数を宣言せずに with ステートメントに設定すると、with ステートメントはスコープチェーンに従って値を検索します。変数がまだ存在しない場合、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
*/