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

関連項目

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

関連項目

ループ（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*/

関連項目

case jumpTarget: statements

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

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

メモ：statementsパラメータは、必ず break ステートメントで終了します。statements パラメータの break ステートメントを省略すると、switch ステートメントが終了せずに、次の case ステートメントが実行されます。

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

関連項目

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

関連項目

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

関連項目

continue [label]

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

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

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

for ループでは、continue ステートメントを使用して、ループ本体の残りをスキップできます。次の例では、i % 3 と 0 が等しい場合、trace(i) ステートメントはスキップされます。

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

関連項目

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

関連項目

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

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

}

この例の trace() 出力は次のようになります。

x1 ns: http://www.example.com/namespaces/
x3 ns: 
x4 ns: http://schemas.xmlsoap.org/soap/envelope/
x2 ns: http://www.example.com/namespaces/

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

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

var x2:XML = <test2 xmlns = "http://www.w3.org/1999/XSL/Transform/" />;
trace(x2.namespace());
    // http://www.w3.org/1999/XSL/Transform/

var x3:XML = <test3 xmlns:soap-env="http://schemas.xmlsoap.org/soap/envelope/" />;
trace(x3.namespace());
    // http://www.example.com/namespaces/

関連項目

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

関連項目

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

関連項目

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

関連項目

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

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

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

次の例では、Vehicle クラスを定義している "Vehicle.as" ファイルの内容を示します。

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

サブクラスがスーパークラスのコンストラクタへのアクセスに使用する super ステートメントを使用して、Vehicle クラスのサブクラスを記述することもできます。次の例では、同じディレクトリ内にある 3 番目の ActionScript ファイル "Truck.as" の内容を示します。Truck クラスは、コンストラクタおよびオーバーライドされた reverse() メソッドで super を使用します。

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

関連項目

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

次の例では、ストリング "false" がブール値 true に変換されることを示します。

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

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

関連項目

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

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

関連項目

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

関連項目

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

関連項目

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

関連項目

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 = 
        <body>
            <p>Hello</p>
            <p>Hola</p>
            <hr />
            <p>Bonjour</p>
        </body>;
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); 
}

関連項目

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

giants.name をトレースする際に、getter メソッドを使用してプロパティの値を返しています。

関連項目

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

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

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

関連項目

myClass implements interface01 [, interface02 , ...] 

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

メモ：このキーワードを使用するには、FLA ファイルのパブリッシュ設定ダイアログボックスの「Flash」タブで、ActionScript 2.0 および Flash Player 6 以降を指定する必要があります。このキーワードは、外部スクリプトファイルで使用する場合にのみサポートされ、アクションパネルに記述するスクリプトではサポートされません。

関連項目

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 メソッドを使用できます。

関連項目

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

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

関連項目

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 ラベルが付けられ、break ステートメントはブロック内の最後のステートメントをスキップできます。

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

関連項目

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 名前空間が参照されます。

関連項目

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

関連項目

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

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

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

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

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

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

関連項目

package packageName {
    class someClassName { 
    } 
}

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

関連項目

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

alpha はプライベート変数であるため、A クラスの外部やサブクラス B からもアクセスできません。プライベート変数にアクセスしようとすると、エラーが発生します。

関連項目

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

関連項目

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

User クラスのいずれかのパブリック変数をプライベート変数に変更した場合、User クラスの外から変数にアクセスしようとすると、コンパイル時エラーが生成されます。

関連項目

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

関連項目

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

関連項目

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 ステートメントを使用することはできません。

関連項目

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

関連項目

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 ブロックが例外をキャッチしない場合は、スローされた値のストリング表現が出力パネルに表示されます。If an exception is not caught by a catch or finally block, the string representation of the thrown value is sent to the log file.

一般には、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.

関連項目

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

次の例では、自動的な型指定によって true を数値 1 に変換する方法を示しています。

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

関連項目

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

関連項目

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

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

関連項目

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

関連項目

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

関連項目

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 ステートメントが呼び出されたタイムライン上に新しい値が設定されます。

with (someOther_mc) { 
    _x = 50; 
    _y = 100; 
    gotoAndStop(3); 
}

someOther_mc._x = 50; 
someOther_mc._y = 100; 
someOther_mc.gotoAndStop(3);

with ステートメントは、スコープチェーンリスト内の複数の項目に同時にアクセスする場合に便利です。次の例では、ビルトインの Math オブジェクトをスコープチェーンの前に設定します。Math をデフォルトオブジェクトとして設定すると、cos、sin、PI の各識別子がそれぞれ Math.cos、Math.sin、Math.PI に解決されます。a、x、y、r の各識別子は Math オブジェクトのメソッドやプロパティではありませんが、関数 polar() のオブジェクトアクティベーションスコープ内に存在するので、それぞれ対応するローカル変数として処理されます。

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