function functionName(parameter0, parameter1, ...rest){ 
	// ステートメント
} 

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

他のパラメータと共に使用する場合は、最後のパラメータとして ... (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"); // Output: 100,130,two
            trace(average(4, 7, 13));     // Output: 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 (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++; 
} 
/* output:
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... ] ] { 
	// ここにクラス定義を記述
}

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

ActionScript ソースファイルごとにパブリッククラスを 1 つ指定できます。同じファイルにパブリッククラス以外のクラスを含める場合、パブリッククラスは他のすべてのクラスの下に配置する必要があります。ファイル内の最後のクラスの名前は、そのクラスを含む 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); 
/* output: 
0 
1 
2 
3 
4
*/

関連項目

dynamic class className { // ここにクラス定義を記述 }

実行時に追加された 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); // output: new

var mySealed:Sealed = new Sealed();
mySealed.prop1 = "newer"; // error

関連項目

if (condition) { 
	// ステートメント
} 
else {
	// ステートメント
}

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(); // output: [Vehicle] start 
myNewCar.stop(); // output: [Car] stop with anti-lock brakes 
myNewCar.activateCarAlarm(); // output: [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(); // output: [Truck] make beeping sound [Vehicle] reverse 
myTruck.stop(); // output: [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")); // output: true

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

関連項目

final function methodName() { 
	// ここにステートメントを記述
}
final class className {}

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

関連項目

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

関連項目

for ([init]; [condition]; [next]) { 
	// ステートメント
}

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); // output: 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); // output: 5050

var sum:Number = 0; 
for (var i:Number = 1; i <= 100; i++) 
    sum += i; 
trace(sum); // output: 5050

関連項目

for (variableIterant:String in object){ 
	// ステートメント
} 

オブジェクトの動的プロパティまたは配列のエレメントに対して反復処理を行い、各プロパティまたはエレメントに対して 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]); 
} 
/* output:
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); 
    } 
}
/* output:
I have a string property named city
I have a string property named firstName
*/

関連項目

for each (variableIterant in object){ 
	// ステートメント
} 

コレクションのアイテムに対して反復処理を行い、各アイテムに対して 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); 
} 
/* output:
Tara
27
San Francisco
*/

var myArray:Array = new Array("one", "two", "three"); 
for each(var item in myArray) 
    trace(item); 
/* output: 
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); 
    } 
}

/* output:
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);
}

/* output:
Hello
Hola
Bonjour
*/

関連項目

function functionName([parameter0, parameter1,...parameterN]) :returnType{ 
	// ステートメント
} 
var functionName:Function = function ([parameter0, parameter1,...parameterN]) :returnType{ 
	// ステートメント
} 

特定のタスクを実行するよう定義した一連のステートメントで構成されます。ある位置で関数を定義し、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); // output: 9

var yNum:Number = sqr(3); 
trace(yNum); // output: 9 
function sqr(xNum:Number) { 
    return Math.pow(xNum, 2); 
}

関連項目

function get property() :returnType{ 
	// ここにステートメントを記述
}

プロパティと同じように読み取り可能なメソッドである 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); 
/* output: 
San Fran San Francisco */

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

関連項目

if (condition) {
	// ステートメント
}

条件を評価して、次のステートメントを実行するかどうかを判定します。条件が 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 ファイルに含められます。必要のないクラスを読み込むと、名前の競合が起こりやすくなるというデメリットがあります。

// FLA のフレーム 1 :  
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()  { 
	// ここにステートメントを記述
}
[internal] class className{
	// ここにステートメントを記述
}
[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);
    }
}
/* output:
1
2
...
79
*/

次の例では、ブロックステートメントでのラベルの使用方法を示します。ブロックステートメントには foo ラベルが付けられ、break ステートメントはブロック内の最後のステートメントをスキップできます。

foo: {
    trace("a");
    break foo;
    trace("b");
}
// output: 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");
    }
}

/* output: 
testArray[2] == null
testArray[3] == null
testArray[5] == null
*/

関連項目

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

override function name() { 
	// ここにステートメントを記述
}

メソッドで継承したメソッドを置き換えるよう指定します。継承したメソッドをオーバーライドするには、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() { 
		// ここにステートメントを記述
	}
	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() { 
		// ここにステートメントを記述
	}
	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);  // output: Access attempt from subclass succeeded
  }
}

関連項目

public var varName
public const kName
public function functionName()  { 
	// ここにステートメントを記述
}
public class className {
	// ここにステートメントを記述
}
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); // output: 27 jimmy

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

関連項目