数値式を加算します。両方の式が整数の場合、合計は整数になります。いずれかの式または両方の式が浮動小数点数の場合、合計は浮動小数点数になります。

1 つの式がストリングの場合、他の式はすべてストリングに変換され、加算の代わりに連結されます。式がストリングでも数値でもない場合は、Flash^® Player により数値に変換されます。

trace(2 + 3); // 5

trace(2.5 + 3.25); // 5.75

trace("Number " + 8 + 0); // Number 80

var oldBalance:Number = 1345.23; 
var currentBalance = deposit_txt.text + oldBalance; 
trace(currentBalance); 

var oldBalance:Number = 1345.23; 
var currentBalance:Number = Number(deposit_txt.text) + oldBalance;
trace(currentBalance);

関連項目

expression1 に expression1 + expression2 の値を割り当てます。例えば、次の 2 つのステートメントは同じ結果になります。

x += y; 
x = x + y; 

var x:Number = 5; 
var y:Number = 10; 
x += y; 
trace(x); // 15 

関連項目

myArray = [a0, a1,...aN]
myArray[i] = value 
myObject[propertyName]

指定されたエレメント（a0 など）で新しい配列または多次元配列を初期化するか、配列内のエレメントにアクセスします。配列アクセス演算子を使用すると、インスタンス、変数、およびオブジェクト名を動的に設定および取得できます。この演算子を使用してオブジェクトのプロパティにアクセスすることもできます。

シンタックス 1：配列は、エレメントと呼ばれるプロパティを持つオブジェクトです。各エレメントはインデックスと呼ばれる番号で識別されます。配列を作成する場合は、エレメントを配列アクセス演算子（[]）（角括弧）で囲みます。配列には、様々なタイプのエレメントを格納できます。例えば、次の配列 employee には 3 つのエレメントがあります。最初のエレメントは数値、2 番目と 3 番目のエレメントはストリング（引用符内）です。

var employee:Array = [15, "Barbara", "Jay"]; 

var ticTacToe:Array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]; 
			
/* Select Debug > List Variables in test mode 
to see a list of the array elements.*/ 

var my_array:Array = new Array(); 
my_array[0] = 15; 
my_array[1] = "Hello"; 
my_array[2] = true; 

my_array[3] = "George"; 

var ticTacToe:Array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]; 
trace(ticTacToe[1][2]); // 6 

var obj:Object = new Object();
obj.prop1 = "foo";
trace(obj["prop" + 1]); // foo
obj.prop2 = "bar";
for (j in obj) {
	trace(obj[j]);
} 
/* Output of for loop: 
foo
bar */

var my_array:Array = []; 
var my_array:Array = new Array(); 

次の例では、3 つのエレメントを持つ employee_array という名前の配列を作成し、配列の 3 番目のエレメントを変更しています。

var employee_array = ["Barbara", "George", "Mary"]; 
trace(employee_array); // Barbara,George,Mary 
employee_array[2] = "Sam"; 
trace(employee_array); // Barbara,George,Sam 

var obj:Object = new Object();
obj.prop1 = "foo";
obj.prop2 = "bar";

for (var i:int = 1;i < 3;i++) {
    trace(obj["prop"+i]);
}
/* Output of for loop:
foo
bar */ 

関連項目

最初のオペランドで指定された式が、2 番目のオペランドで指定されたデータ型のメンバーであるかどうかを評価します。最初のオペランドがそのデータ型のメンバーである場合、結果は最初のオペランドになります。それ以外の場合、結果の値は null です。

2 番目のオペランドで使用される式は、評価結果がデータ型となる必要があります。

public var myArray:Array = ["one", "two", "three"];
trace(myArray as Array);  // one,two,three
trace(myArray as Number); // null
trace(myArray as int);    // null

関連項目

expression2 の値（右側のオペランド）を expression1 の変数、配列エレメント、またはプロパティに割り当てます。値による割り当てと、参照による割り当てがあります。値による割り当てでは、expression2 の実際の値がコピーされ、expression1 に格納されます。値による割り当ては、expression2 がプリミティブな値、つまりデータ型が Boolean、Number、int、uint、または String のいずれかである場合に使用されます。参照による割り当てでは、expression2 への参照が expression1 に格納されます。一般に、参照による割り当ては new 演算子と組み合わせて使用されます。new 演算子ではメモリ内にオブジェクトが作成され、そのオブジェクトが格納されたメモリ位置への参照が変数に割り当てられます。

メモ : ActionScript 3.0 では、プリミティブな値を含むすべての値がオブジェクトであり、すべての割り当ては参照によって行われますが、プリミティブなオブジェクトには特別な演算子があり、値による割り当てと同様の動作をします。

var z:Number = 5;

var x:String;
x = "hello";

var moonsOfJupiter:Array = new Array();
moonsOfJupiter[0] = "Callisto";

var mercury:Object = new Object();
mercury.diameter = 3030; // in miles
trace(mercury.diameter); // 3030

var merkur:Object = mercury;
merkur.diameter = 4878;  // in kilometers
trace(mercury.diameter); // 4878

関連項目

 myXML.@attributeName 

XML または XMLList オブジェクトの属性を識別します。例えば、myXML.@id では、myXML XML オブジェクトの id という名前の属性が識別されます。属性にアクセスするには、myXML.attribute("id")、myXML["@id"]、および myXML.@["id"] シンタックスを使用することもできます。推奨されるシンタックスは myXML.@id です。すべての属性名の XMLList オブジェクトを返すには、@* を使用します。ActionScript の予約語と名前が一致する属性を返すには、@ 演算子の代わりに attribute() メソッドを使用します。

var myXML:XML = 
    <item id = "42">
        <catalogName>Presta tube</catalogName>
        <price>3.99</price>
    </item>;

trace(myXML.@id); // 42

var xml:XML =<example id='123' color='blue'/>
 var xml2:XMLList = xml.@*;
 trace(xml2 is XMLList); // true
 trace(xml2.length());  // 2
 for (var i:int = 0; i < xml2.length(); i++)
 { 
    trace(typeof(xml2[i]));    // xml
    trace(xml2[i].nodeKind()); // attribute
    trace(xml2[i].name());     // id and color
 } 

var xml:XML = <example class='123'/>
trace(xml.attribute("class"));

関連項目

expression1 と expression2 を 32 ビット符号なし整数に変換し、整数パラメータをビット単位で論理積（AND）演算します。浮動小数点数は、小数点以下が切り捨てられ、整数に変換されます。結果は、新しい 32 ビット整数です。

正の整数は 4294967295（0xFFFFFFFF）を最大値とする符号なし 16 進数に変換されます。最大値より大きい値は、32 ビットを超えないように、変換時に最上位の桁が切り捨てられます。負の値は、2 の補数表現を使用して、-2147483648（0x800000000）を最小値とする符号なし 16 進数に変換されます。最小値より小さい値は、さらに高い精度で 2 の補数に変換された上で、最上位の桁が切り捨てられます。

結果は 32 ビットの 2 の補数として解釈されるため、-2147483648 ～ 2147483647 の範囲の整数になります。

var insert:Number = 13; 
var update:Number = 11; 
trace(insert & update); // 9 (or 1001 binary) 

  1101
& 1011
  ----
  1001

次の例は、戻り値の変換の動作を示しています。

trace(0xFFFFFFFF); // 4294967295 
trace(0xFFFFFFFF & 0xFFFFFFFF); // -1 
trace(0xFFFFFFFF & -1); // -1 
trace(4294967295 & -1); // -1 
trace(4294967295 & 4294967295); // -1 

関連項目

expression1 に expression1 & expression2 の値を割り当てます。例えば、次の 2 つの式は同じです。

x &= y; 
x = x & y; 

var x:Number = 15; 
var y:Number = 9; 
trace(x &= y); // 9 

関連項目

expression1 と shiftCount を 32 ビット整数に変換し、shiftCount の変換により生成された整数で指定される桁数だけ expression1 内のすべてのビットを左にシフトします。この演算の結果として空にされるビット位置には、0 が埋められます。シフト後、左端のビットは破棄されます。値を 1 桁左にシフトすることは、2 を掛けることと同じ意味になります。

浮動小数点数は、小数点以下が切り捨てられ、整数に変換されます。正の整数は 4294967295（0xFFFFFFFF）を最大値とする符号なし 16 進数に変換されます。最大値より大きい値は、32 ビットを超えないように、変換時に最上位の桁が切り捨てられます。負の値は、2 の補数表現を使用して、-2147483648（0x800000000）を最小値とする符号なし 16 進数に変換されます。最小値より小さい値は、さらに高い精度で 2 の補数に変換された上で、最上位の桁が切り捨てられます。

結果は 32 ビットの 2 の補数として解釈されるため、-2147483648 ～ 2147483647 の範囲の整数になります。

結果が負の整数である場合、結果を uint 型の変数に割り当てようとすると、ランタイムエラーが発生します。ActionScript には "符号なしビット単位の左シフト" 演算子はありませんが、uint(expression1 << shiftCount) を使用して同様の結果を実現し、ランタイムエラーを回避できます。

var num1:uint = 0xFF;
var num2:uint = uint(num1 << 24); // uint() prevents runtime error

x = 1 << 10

   00000000001 binary 
<<          10 decimal
--------------
   10000000000 binary equals 1024 decimal 

次の例では、整数 7 を左に 8 ビットシフトします。

x = 7 << 8

   00000000111 binary 
<<           8 decimal
--------------
   11100000000 binary equals 1792 decimal 

次の trace ステートメントでは、ビットを左に 3 ビットシフトしています。

// 1 binary == 0001 
// 8 binary == 1000 
trace(1 << 3); // 8 

関連項目

ビット単位の左シフト（<<=）演算を行い、その内容を結果として expression1 に格納します。次の 2 つの式は等価です。

A <<= B
A = (A << B)

var x:Number = 4; 
// Shift all bits one slot to the left. 
x <<= 1; 
trace(x); // 8 
// 4 decimal = 0100 binary 
// 8 decimal = 1000 binary 

関連項目

expression を 32 ビット符号付き整数に変更し、ビット単位で 1 の補数を適用します。つまり、0 を保持するすべてのビットは 1 に設定され、1 を保持するすべてのビットは 0 に設定されます。結果は、符号付き 32 ビット整数です。この演算子は、1 の補数演算子またはビット単位の補数演算子とも呼ばれます。

例えば、0x7777 という 16 進数値は、2 進数では次のように表現されます。

0111011101110111

この 16 進数値をビット単位で符号反転（~0x7777）すると、次の 2 進数になります。

1000100010001000

これは、16 進数の 0x8888 に相当します。したがって、~0x7777 は 0x8888 となります。

ビット単位演算子は、フラグビットを表現する場合に最もよく使用されます（ブール値をそれぞれ 1 ビットにパックすることができます）。

浮動小数点数は、小数点以下が切り捨てられ、整数に変換されます。正の整数は 4294967295（0xFFFFFFFF）を最大値とする符号なし 16 進数に変換されます。最大値より大きい値は、32 ビットを超えないように、変換時に最上位の桁が切り捨てられます。負の値は、2 の補数表現を使用して、-2147483648（0x800000000）を最小値とする符号なし 16 進数に変換されます。最小値より小さい値は、さらに高い精度で 2 の補数に変換された上で、最上位の桁が切り捨てられます。

結果は 32 ビットの 2 の補数として解釈されるため、-2147483648 ～ 2147483647 の範囲の整数になります。

var ReadOnlyFlag:int = 0x0001; // defines bit 0 as the read-only flag 
var flags:int = 0; 
trace(flags); 
/* To set the read-only flag in the flags variable, 
   the following code uses the bitwise OR: 
*/
flags |= ReadOnlyFlag; 
trace(flags); 
/* To clear the read-only flag in the flags variable, 
   first construct a mask by using bitwise NOT on ReadOnlyFlag. 
   In the mask, every bit is a 1 except for the read-only flag. 
   Then, use bitwise AND with the mask to clear the read-only flag. 
   The following code constructs the mask and performs the bitwise AND: 
*/ 
flags &= ~ReadOnlyFlag; 
trace(flags); 
// 0 1 0 

関連項目

expression1 と expression2 を 32 ビット符号なし整数に変換し、expression1 と expression2 の対応ビットの少なくとも一方が 1 である各ビット位置に 1 を設定します。

浮動小数点数は、小数点以下が切り捨てられ、整数に変換されます。正の整数は 4294967295（0xFFFFFFFF）を最大値とする符号なし 16 進数に変換されます。最大値より大きい値は、32 ビットを超えないように、変換時に最上位の桁が切り捨てられます。負の値は、2 の補数表現を使用して、-2147483648（0x800000000）を最小値とする符号なし 16 進数に変換されます。最小値より小さい値は、さらに高い精度で 2 の補数に変換された上で、最上位の桁が切り捨てられます。

結果は 32 ビットの 2 の補数として解釈されるため、-2147483648 ～ 2147483647 の範囲の整数になります。

// 15 decimal = 1111 binary 
var a:Number = 15; 
// 9 decimal = 1001 binary 
var b:Number = 9; 
// 1111 | 1001 = 1111 
trace(a | b); // returns 15 decimal (1111 binary) 

関連項目

expression1 に expression1 | expression2 の値を割り当てます。例えば、次の 2 つのステートメントは同じです。

x |= y; 
x = x | y; 

// 15 decimal = 1111 binary 
var a:Number = 15; 
// 9 decimal = 1001 binary 
var b:Number = 9; 
// 1111 |= 1001 = 1111 
trace(a |= b); // returns 15 decimal (1111 binary) 

関連項目

expression と shiftCount を 32 ビット整数に変換し、shiftCount の変換により生成された整数で指定される桁数だけ expression 内のすべてのビットを右にシフトします。シフト後、右端のビットは破棄されます。元の式の符号を保持するには、expression の最上位ビット（左端のビット）が 0 である場合は左側のビットに 0 を置き、最上位ビットが 1 である場合は 1 を置きます。値を右に 1 つシフトすることは、2 で割って剰余を切り捨てることと同じです。

浮動小数点数は、小数点以下が切り捨てられ、整数に変換されます。正の整数は 4294967295（0xFFFFFFFF）を最大値とする符号なし 16 進数に変換されます。最大値より大きい値は、32 ビットを超えないように、変換時に最上位の桁が切り捨てられます。負の値は、2 の補数表現を使用して、-2147483648（0x800000000）を最小値とする符号なし 16 進数に変換されます。最小値より小さい値は、さらに高い精度で 2 の補数に変換された上で、最上位の桁が切り捨てられます。

結果は 32 ビットの 2 の補数として解釈されるため、-2147483648 ～ 2147483647 の範囲の整数になります。

var a:Number = 65535 >> 8; 
trace(a); // 255

    00000000000000001111111111111111 binary (65535 decimal)
>>                                 8 decimal
--------------------
    00000000000000000000000011111111 binary (255 decimal)

var a:Number = -8 >> 1;
trace(a); // -4

    11111111111111111111111111111000 binary (-8 decimal)
>>                                1 decimal
--------------------
    11111111111111111111111111111100 binary (-4 decimal)

関連項目

ビット単位の右シフト演算を行い、結果を expression に格納します。

次の 2 つのステートメントは等価です。

A >>= B; 
A = (A >> B);

function convertToBinary(numberToConvert:Number):String { 
    var result:String = ""; 
    for (var i = 0; i < 32; i++) { 
        // Extract least significant bit using bitwise AND. 
        var lsb:Number = numberToConvert & 1; 
        // Add this bit to the result.
        result = (lsb ? "1" : "0")+result; 
        // Shift numberToConvert right by one bit, to see next bit. 
        numberToConvert >>= 1; 
    } 
    return result; 
} 
trace(convertToBinary(479)); 
// Returns the string 00000000000000000000000111011111. 
// This string is the binary representation of the decimal number 479.

関連項目

左側のビットは常に 0 で埋められるため、元の式の符号が保持されないという点を除いて、ビット単位の右シフト（>>）演算子と同じです。

浮動小数点数は、小数点以下が切り捨てられ、整数に変換されます。正の整数は 4294967295（0xFFFFFFFF）を最大値とする符号なし 16 進数に変換されます。最大値より大きい値は、32 ビットを超えないように、変換時に最上位の桁が切り捨てられます。負の値は、2 の補数表現を使用して、-2147483648（0x800000000）を最小値とする符号なし 16 進数に変換されます。最小値より小さい値は、さらに高い精度で 2 の補数に変換された上で、最上位の桁が切り捨てられます。

結果は 32 ビットの符号なし整数として解釈されるため、0 ～ 4294967295 の範囲の整数になります。

メモ：ActionScript には補完的な "ビット単位の符号なし左シフト" 演算子はありませんが、uint(expression << shiftCount) を使用して同様の結果を実現することができます。

var a:Number = -1 >>> 1; 
trace(a); // 2147483647 

関連項目

ビット単位の符号なし右シフト演算を行い、結果を expression に格納します。次の 2 つのステートメントは等価です。

A >>>= B; 
A = (A >>> B); 

var a:Number = -1;
a >>>= 1; 
trace(a); // 2147483647 

関連項目

expression1 と expression2 を 32 ビット符号なし整数に変換し、expression1 と expression2 の対応ビットのいずれか一方のみが 1 である各ビット位置に 1 を設定します。

浮動小数点数は、小数点以下が切り捨てられ、整数に変換されます。正の整数は 4294967295（0xFFFFFFFF）を最大値とする符号なし 16 進数に変換されます。最大値より大きい値は、32 ビットを超えないように、変換時に最上位の桁が切り捨てられます。負の値は、2 の補数表現を使用して、-2147483648（0x800000000）を最小値とする符号なし 16 進数に変換されます。最小値より小さい値は、さらに高い精度で 2 の補数に変換された上で、最上位の桁が切り捨てられます。

結果は 32 ビットの 2 の補数として解釈されるため、-2147483648 ～ 2147483647 の範囲の整数になります。

// 15 decimal = 1111 binary 
// 9 decimal = 1001 binary 
var a:Number = 15 ^ 9; 
trace(a); 
// 1111 ^ 1001 = 0110 
// returns 6 decimal (0110 binary) 

関連項目

expression1 に expression1 ^ expression2 の値を割り当てます。例えば、次の 2 つのステートメントは同じです。

x ^= y 
x = x ^ y 

// 15 decimal = 1111 binary 
var a:Number = 15; 
// 9 decimal = 1001 binary 
var b:Number = 9; 
trace(a ^= b); // returns 6 decimal (0110 binary) 

関連項目

/* comment */

/* comment

   comment */

スクリプトコメントのブロックを区切ります。開始区切り記号（/*）と終了区切り記号（*/）の間の文字はコメントと解釈され、ActionScript コンパイラでは無視されます。コメントが連続した複数行の場合はこれらの区切り記号を使用し、1 行の場合は // の区切り記号を使用します。

終了ブロックコメント区切り記号（*/）が抜けている場合や、コメントをネストしようとした場合は、エラーメッセージが表示されます。開始区切り記号（/*）の後に開始区切り記号が何個ある場合でも、最初の終了区切り記号（*/）でコメントの終わりと見なされます。

/* records the X and Y positions of 
the ball and bat movie clips */ 
var ballX:Number = ball_mc._x; 
var ballY:Number = ball_mc._y; 
var batX:Number = bat_mc._x; 
var batY:Number = bat_mc._y; 

/* This is an attempt to nest comments. 
/* But the first closing tag will be paired 
with the first opening tag */ 
and this text will not be interpreted as a comment */ 

関連項目

 myXML = <{tagName} {attributeName} = {attributeValue}>{content}</{tagName}>

XML または XMLList 初期化子で使用されている式を評価します。XML または XMLList 初期化子は、XML または XMLList 型の変数に割り当てられるリテラル値です。XML { および } 演算子で区切られる式は、XML または XMLList 初期化子でリテラルの名前または値の代わりに使用できます。式は、tagName、attributeName、attributeValue、および content の代わりに使用できます。

var tagname:String = "item"; 
var attributename:String = "id"; 
var attributevalue:String = "5"; 
var content:String = "Chicken"; 
var x:XML = <{tagname} {attributename}={attributevalue}>{content}</{tagname}>; 
trace(x.toXMLString()); // <item id="5">Chicken</item>

関連項目

 myXML[expression]

XML または XMLList オブジェクトのプロパティまたは属性にアクセスします。括弧演算子を使用すると、ドット（.）演算子でアクセスできないプロパティ名にアクセスできます。

var myXML:XML = <a><foo-bar>44</foo-bar></a>;
trace(myXML["foo-bar"]);

関連項目

式 expression1、式 expression2、... の順に評価します。通常、この演算子は for ループステートメントで使用します。括弧 () 演算子と組み合わせて使用することもあります。

for (i = 0, j = 0; i < 3 && j < 3; i++, j+=2) { 
    trace("i = " + i + ", j = " + j); 
} 
// output: 
// i = 0, j = 0 
// i = 1, j = 2

var v:Number = 0; 
v = 4, 5, 6; 
trace(v); // 4 

var v:Number = 0; 
v = (4, 5, 6); 
trace(v); // 6 

var v:Number = 0; 
var z:Number = 0; 
v = v + 4 , z++, v + 6; 
trace(v); // 4 
trace(z); // 1 

var v:Number = 0; 
var z:Number = 0; 
v = (v + 4, z++, v + 6); 
trace(v); // 6 
trace(z); // 1 

関連項目

ストリングを連結（結合）します。ある式がストリングの場合、他の式はすべてストリングに変換され、連結されます。

両方の式が数値である場合、この演算子は加算演算子として動作します。

var lastName:String = "Cola"; 
var instrument:String = "Drums"; 
trace(lastName + " plays " + instrument); // Cola plays Drums 

trace("Number " + 8 + 0); // Number 80

var a:String = 3 + 10 + "asdf"; 
trace(a); // 13asdf 
var b:String = "asdf" + 3 + 10; 
trace(b); // asdf310 

関連項目

expression1 + expression2

XML または XMLList 値を XMLList オブジェクトに連結（結合）します。両方のオペランドが XML または XMLList 値の場合のみ、結果が XMLList オブジェクトになります。

var x1:XML = 
        <employee id = "42">
            <firstName>Joe</firstName>
            <lastName>Smith</lastName>
        </employee>;

var x2:XML = 
        <employee id = "43">
            <firstName>Susan</firstName>
            <lastName>Jones</lastName>
        </employee>;

var myXMLList:XMLList = x1 + x2;
    
trace(myXMLList.toXMLString()); 

The trace statement produces the following output:

<employee id = "42">
    <firstName>Joe</firstName>
    <lastName>Smith</lastName>
</employee>
<employee id = "43">
    <firstName>Susan</firstName>
    <lastName>Jones</lastName>
</employee>
    

関連項目

expression1 に expression1 + expression2 の値を割り当てます。例えば、次の 2 つのステートメントは同じ結果になります。

x += y; 
x = x + y;

var x1:String = "My name is "; 
x1 += "Gilbert"; 
trace(x1); // My name is Gilbert 

関連項目

expression1 += expression2

XMLList オブジェクトの expression1 に expression1 + expression2 の値を割り当てます。例えば、次の 2 つのステートメントは同じ結果になります。

x += y; 
x = x + y; 

var x1:XML = <location>Athens</location>;    
var x2:XML = <location>Paris</location>;        
myXMLList = x1 + x2;

var x3:XML = <location>Springfield</location>;
myXMLList += x3;
            
trace(myXMLList.toXMLString());

The trace statement produces the following output:

<location>Athens</location>
    
<location>Paris</location>    

<location>Springfield</location>

関連項目

expression1 ? expression2 : expression3

expression1 を評価し、expression1 の値が true である場合、結果は expression2 の値となり、そうでない場合は expression3 の値となります。

var x:Number = 5; 
var y:Number = 10; 
var z = (x < 6) ? x: y; 
trace(z); // returns 5

var timecode:String = (new Date().getHours() < 11) ? "AM" : "PM"; 
trace(timecode); 

if (new Date().getHours() < 11) { 
    var timecode:String = "AM"; 
} else { 
    var timecode:String = "PM"; 
}
trace(timecode); 

関連項目

--expression

expression--

オペランドから 1 を減算します。オペランドは、変数、配列のエレメント、またはオブジェクトのプロパティです。プリデクリメント形式の演算子（--expression）は、expression から 1 を減算し、結果を返します。ポストデクリメント形式の演算子（expression--）は、expression から 1 を減算し、expression の初期値（減算前の値）を返します。

var x:Number = 3; 
var y:Number = --x; // y is equal to 2

var x:Number = 3; 
var y:Number = x--; // y is equal to 3

for (var i = 10; i > 0; i--) { 
    trace(i); 
}

関連項目

 delete reference

reference によって指定されたオブジェクトプロパティを破棄します。処理後にプロパティが存在しない場合、結果は true になり、存在する場合は false になります。存在しないプロパティまたはクラスで定義されていない動的プロパティで呼び出された場合、delete 演算子は true を返します。

reference パラメータを削除できない場合、delete 演算子は処理できないため false を返します。固定プロパティまたは var ステートメントで宣言された変数は削除できません。固定プロパティとは、クラス定義で定義される変数またはメソッドです。

クラスが実行時に追加された動的クラスでない限り、delete 演算子を使用してそのクラスのプロパティを破棄することはできません。sealed クラスのプロパティは、delete を使用して破棄することはできません。代わりに、プロパティを null に設定してください。

メモ：オブジェクトを削除することはできませんが、オブジェクトへのすべての参照を削除して、ガベージコレクションの対象となるオブジェクトを作成できます。最も一般的なオブジェクトへの参照は、オブジェクトを参照する変数です。これらの参照は、変数を null に設定することで削除できます。ガベージコレクションでは、参照を持たないオブジェクトがすべて削除されます。

// create the new object "account" 
var account:Object = new Object(); 
// assign property name to the account 
account.name = "Jon"; 
// delete the property 
delete account.name; 
trace(account.name); // undefined

// delete a nonexistent property
var fooDeleted:Boolean = delete account.foo;
trace(fooDeleted); // true

次の例では、配列エレメントの値を削除していますが、length プロパティの値は変更されません。

var my_array:Array = new Array(); 
my_array[0] = "abc"; // my_array.length == 1 
my_array[1] = "def"; // my_array.length == 2 
my_array[2] = "ghi"; // my_array.length == 3 
// my_array[2] is deleted, but Array.length is not changed 
delete my_array[2]; 
trace(my_array.length); // 3 
trace(my_array); // abc,def,

次の例は、delete から返されたブール値を後でコード実行時の条件として使用する方法を示しています。アイテムが既に削除されている場合、そのアイテムで再度 delete を呼び出すと、false が返されます。

var my_array:Array = [ "abc", "def", "ghi" ];
var deleteWasSuccessful:Boolean

deleteWasSuccessful = delete my_array[0];
if(deleteWasSuccessful) delete my_array[1];
deleteWasSuccessful = delete my_array[0];
if(deleteWasSuccessful) delete my_array[2];

trace(my_array) // outputs: undefined,undefined,ghi

関連項目

 delete reference

reference で指定された XML エレメントまたは属性を削除します。

XMLList オペランドは、空の場合でも常に有効な XMLList オブジェクトを参照するため、XMLList オペランドと共に使用した場合、delete 演算子の結果は常に true になります。

 
var x1:XML = <x1>
                <a id = "52">AYY</a>
                <a>AYY 2 </a>
                <b>BEE</b>
                <c>CEE</c>
            </x1>;

trace(x1.toXMLString());
trace("___________");

delete x1.a.@id;

trace(x1.toXMLString());
trace("___________");

delete x1.b;

trace(x1.toXMLString());
trace("___________");

delete x1.a;

trace(x1.toXMLString());

出力は次のようになります。

<x1>
  <a id="52">AYY</a>
  <a>AYY 2</a>
  <b>BEE</b>
  <c>CEE</c>
</x1>
___________
<x1>
  <a>AYY</a>
  <a>AYY 2</a>
  <b>BEE</b>
  <c>CEE</c>
</x1>
___________
<x1>
  <a>AYY</a>
  <a>AYY 2</a>
  <c>CEE</c>
</x1>
___________
<x1>
  <c>CEE</c>
</x1>

 
var xml:XML = 
            <order>
                <item id="121">hamburger</item>
                <item id="122">fries</item>
                <item id="123">chocolate shake</item>
            </order>;
delete xml.item[1].*;
delete xml.item[1].@*;
trace(xml);

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

<order>
  <tem id="121">hamburger</item>
  <item/>
  <item id="123">chocolate shake</item>
</order>

 myXML..childElement1..@attributeName 

XML または XMLList オブジェクトの子孫エレメントに移動します。@ 演算子と共に使用した場合は、一致する子孫の属性を検索します。検索されるエレメントや属性は、XML または XMLList オブジェクトの直接の子だけでなく、孫などのツリー内の下位の階層も対象となります。複数の子エレメントまたは属性が一致する可能性があるため、結果は XMLList オブジェクトになります。

XMLList オブジェクト内のノードは、深さ優先探索の結果順に返されます。次に例を示します。

var myXML:XML = <a>
			<b>one
				<c> 
					<b>two</b> 
				</c> 
			</b>
			<b>three</b>
		</a>;

trace(myXML..b[0].toXMLString());
trace("______________");
trace(myXML..b[1].toXMLString());
trace("______________");
trace(myXML..b[2].toXMLString());

結果は次のように出力されます。

<b>
  one
  <c>
    <b>two</b>
  </c>
</b>
______________
<b>two</b>
______________
<b>three</b>

ActionScript の予約語と名前が一致する子孫を返すには、次の例で示すように、子孫（..）演算子の代わりに XML.descendants() メソッドを使用します。

var xml:XML = 
<enrollees>
	<student id="239">
		<class name="Algebra" />
 		<class name="Spanish 2"/>
	</student>
	<student id="206">
		<class name="Trigonometry" />
 		<class name="Spanish 2" />
	</student>
 </enrollees>;
 trace(xml.descendants("class")); 
 

var myXML:XML = 
    <employees>
        <employee id = "42">
            <firstName>Billy</firstName>
            <lastName>Einstein</lastName>
        </employee>
        <employee id = "43">
            <firstName>Sally</firstName>
            <lastName>Shostakovich</lastName>
        </employee>
    </employees>
    
trace(myXML..firstName); 
    // <firstName>Billy</firstName>
    // <firstName>Sally</firstName>
                
trace(myXML..@id); //4243

関連項目

expression1 を expression2 で除算します。除算演算の結果は倍精度の浮動小数点数です。

trace(3/0);   // Infinity
trace(-3/0);  // -Infinity
trace(0/0);   // NaN

関連項目

expression1 に expression1 / expression2 の値を割り当てます。例えば、次の 2 つのステートメントは同じです。

x /= y; 
x = x / y;

var a:Number = 10; 
var b:Number = 2; 
a /= b; trace(a); // 5 

関連項目

object.property_or_method

クラス変数およびメソッドにアクセスし、オブジェクトプロパティの取得および設定を行い、読み込まれたパッケージまたはクラスを区切ります。

import flash.utils.Timer;

var obj:Object = new Object();
obj.propertyA = "hello";
trace(obj.propertyA);  // hello

関連項目

myXML.childElement
myXML.@attributeName 

XML または XMLList オブジェクトの子エレメントに移動します。@ 演算子と共に使用した場合は、XML または XMLList オブジェクトの属性を返します。複数の子エレメントまたは属性が一致する可能性があるため、返されるオブジェクトは XMLList になります。

ActionScript の予約語と名前が一致するエレメントを返すには、次の例で示すように、XML ドット（.）演算子の代わりに XML.elements() メソッドまたは XML.descendants() メソッドを使用します。

var xml:XML = 
	<student id="206">
		<class name="Trigonometry" />
		<class name="Spanish 2" />
	</student>;
trace(xml.elements("class"));
trace(xml.descendants("class")); 

var myXML:XML = 
    <employee id = "42">
        <firstName>Billy</firstName>
        <lastName>Einstein</lastName>
    </employee>;

trace(myXML.firstName); // Billy
trace(myXML.@id);       // 42

関連項目

2 つの式の等価性をテストします。式が等しい場合、結果は true です。

2 つのオペランドのデータ型が一致する場合、等価の定義はオペランドのデータ型によって決まります。

• int、uint、および Boolean 型の値は、値が同じ場合に等しいと見なされます。
• Number 型は、値が同じで両方とも NaN でない場合に等しいと見なされます。
• 2 つのオペランドの値が null または undefined の場合は、等しいと見なされます。
• ストリング式は、文字数が同じで、同じ文字で構成されている場合に、等しいと見なされます。
• XML オプジェクトの場合：
  • 一方のオペランドがテキストまたは属性ノードで、もう一方のオペランドに単純内容が含まれる場合は、オペランドを両方とも toString() メソッドでストリングに変換し、結果のストリングが一致する場合に等しいと見なされます。
  • それ以外の場合、オブジェクトは、両方のオブジェクトの修飾名、属性、および子プロパティが一致する場合にのみ等しいと見なされます。
• XMLList オブジェクトの場合は、プロパティの数が同じで、プロパティの順序および値が一致する場合に等しいと見なされます。
• Namespace オブジェクトの場合は、両方のオブジェクトの uri プロパティが一致する場合に値が等しいと見なされます。
• QName オブジェクトの場合は、両方のオブジェクトの uri プロパティおよび localName プロパティが一致する場合に値が等しいと見なされます。
• オブジェクト、配列、および関数を表す変数は、参照により比較されます。2 つの変数が同じオブジェクト、配列、または関数を参照する場合、それらの変数は等価です。2 つの別個の配列は、エレメント数が同じである場合でも、等しいとは見なされません。

• オペランドの値が undefined および null の場合。この場合、結果は true になります。
• 自動データ型変換により String、Boolean、int、uint、および Number のデータ型の値が互換性のある型に変換され、変換された値が等しい場合。この場合、オペランドは等しいと見なされます。
• 一方のオペランドが単純内容（hasSimpleContent() == true）を持つ XML 型で、両方のオペランドを toString() メソッドでストリングに変換し、結果のストリングが一致する場合。
• 一方のオペランドが XMLList 型で、次のいずれかの条件に該当する場合。
  • XMLList オプジェクトの length プロパティが 0 で、もう一方のオブジェクトが undefined である。
  • XMLList オプジェクトの length プロパティが 1 で、XMLList オブジェクトの 1 つのエレメントがもう一方のオペランドに一致する。

var a:String = "David"
var b:String = "David"; 
if (a == b) { 
    trace("David is David"); 
} 

var a:Number = 5; 
var b:String = "5"; 
trace(a == b); // true

var c:Number = 1; 
var d:Boolean = true; 
trace(c == d); // true
var e:Number = 0; 
var f:Boolean = false; 
trace(e == f); // true

var g:String = "true";
var h:Boolean = true;
trace(g == h); // false

var firstArray:Array = new Array("one", "two", "three"); 
var secondArray:Array = new Array("one", "two", "three"); 
trace(firstArray == secondArray); // false 
/* Arrays are only considered equal 
if the variables refer to the same array. */
var thirdArray:Array = firstArray; 
trace(firstArray == thirdArray); // true 

関連項目

2 つの式を比較し、expression1 が expression2 より大きいかどうかを判定します。大きい場合、結果は true になります。expression1 が expression2 より小さいか等しい場合、結果は false になります。

両方のオペランドが String 型である場合、オペランドはアルファベット順で大文字、小文字の順に比較されます。それ以外の場合、オペランドは数値に変換されてから比較されます。

var a:String = "first";
var b:String = "First";
trace(a > b); // true

var c:Number = 5;
var d:String = "4";
trace(c > d); // true

var e: Number = 2;
var f:Boolean = true;
trace(e > f); // true

2 つの式を比較し、expression1 が expression2 より大きいか等しい（true）、または expression1 が expression2 より小さい（false）かどうかを判定します。

if (new Date().getHours() >= 12) { 
    trace("good afternoon"); 
} else { 
    trace("good morning"); 
}

関連項目

プロパティが特定のオブジェクトの一部であるかどうかを評価します。in 演算子を使用するには、最初のオペランドとしてプロパティ名を指定し、2 番目のオペランドとしてオブジェクトを指定します。指定したオブジェクトに該当のプロパティが含まれている場合、結果は true になります。それ以外の場合、結果は false になります。

指定したオブジェクトが Array オブジェクトである場合、in 演算子を使用して特定のインデックス番号が有効であるかどうかをチェックできます。最初のオペランドとして整数を渡す場合、インデックスが有効なインデックス番号の範囲内にあれば結果は true になり、そうでない場合は false になります。

trace("PI" in Math);         // true
trace("myProperty" in Math); // false

次の例では、in 演算子を使用し、数値 0、1、および 2 が myArray オブジェクトの有効なインデックス番号であり、3 はそうでないことを示しています。

public var myArray:Array = ["zero", "one", "two"];
trace(0 in myArray); // true
trace(1 in myArray); // true
trace(2 in myArray); // true
trace(3 in myArray); // false

関連項目

++expression

 expression++

式に 1 を加算します。式は、変数、配列のエレメント、またはオブジェクトのプロパティです。プリインクリメント形式の演算子（++expression）は、expression に 1 を加算し、結果を返します。ポストインクリメント形式の演算子（expression++）は、expression に 1 を加算し、expression の初期値（加算前の値）を返します。

var preInc:Array = new Array(); 
var i:int = 0; 
while (i < 10) { 
    preInc.push(++i); 
} 
trace(preInc); // 1,2,3,4,5,6,7,8,9,10 

 
var postInc:Array = new Array(); 
var i:int = 0; 
while (i < 10) { 
   postInc.push(i++); 
} 
trace(postInc); // 0,1,2,3,4,5,6,7,8,9 

var i:int = 0; 
while (i++ < 5) { 
    trace("this is execution " + i); 
} 
/* output: 
   this is execution 1 
   this is execution 2 
   this is execution 3 
   this is execution 4 
   this is execution 5 
*/

関連項目

等価（==）演算子の正反対が真であるかどうかをテストします。expression1 が expression2 に等しい場合、結果は false になります。等価（==）演算子の場合と同様に、等価の定義は比較するデータ型により異なります。

2 つのオペランドのデータ型が一致する場合、等価の定義はオペランドのデータ型によって決まります。

• int、uint、および Boolean 型の値は、値が同じ場合に等しいと見なされます。
• Number 型は、値が同じで両方とも NaN でない場合に等しいと見なされます。
• 2 つのオペランドの値が null または undefined の場合は、等しいと見なされます。
• ストリング式は、文字数が同じで、同じ文字で構成されている場合に、等しいと見なされます。
• XML オプジェクトの場合：
  • 一方のオペランドがテキストまたは属性ノードで、もう一方のオペランドに単純内容が含まれる場合は、オペランドを両方とも toString() メソッドでストリングに変換し、結果のストリングが一致する場合に等しいと見なされます。
  • それ以外の場合、オブジェクトは、両方のオブジェクトの修飾名、属性、および子プロパティが一致する場合にのみ等しいと見なされます。
• XMLList オブジェクトの場合は、プロパティの数が同じで、プロパティの順序および値が一致する場合に等しいと見なされます。
• Namespace オブジェクトの場合は、両方のオブジェクトの uri プロパティが一致する場合に値が等しいと見なされます。
• QName オブジェクトの場合は、両方のオブジェクトの uri プロパティおよび localName プロパティが一致する場合に値が等しいと見なされます。
• オブジェクト、配列、および関数を表す変数は、参照により比較されます。2 つの変数が同じオブジェクト、配列、または関数を参照する場合、それらの変数は等価です。2 つの別個の配列は、エレメント数が同じである場合でも、等しいとは見なされません。

• オペランドの値が undefined および null の場合。この場合、結果は true になります。
• 自動データ型変換により String、Boolean、int、uint、および Number のデータ型の値が互換性のある型に変換され、変換された値が等しい場合。この場合、オペランドは等しいと見なされます。
• 一方のオペランドが単純内容（hasSimpleContent() == true）を持つ XML 型で、両方のオペランドを toString() メソッドでストリングに変換し、結果のストリングが一致する場合。
• 一方のオペランドが XMLList 型で、次のいずれかの条件に該当する場合。
  • XMLList オプジェクトの length プロパティが 0 で、もう一方のオブジェクトが undefined である。
  • XMLList オプジェクトの length プロパティが 1 で、XMLList オブジェクトの 1 つのエレメントがもう一方のオペランドに一致する。

trace(5 != 8); // true 
trace(5 != 5); // false 

var a:String = "David";
var b:String = "Fool";
if (a != b) { 
    trace("David is not a fool"); 
}

var a:Function = function() { trace("foo"); }; 
var b:Function = function() { trace("foo"); }; 
a(); // foo 
b(); // foo 
trace(a != b); // true 
a = b; 
a(); // foo 
b(); // foo 
trace(a != b); // false

var a:Array = [ 1, 2, 3 ]; 
var b:Array = [ 1, 2, 3 ]; 
trace(a);      // 1,2,3 
trace(b);      // 1,2,3 
trace(a != b); // true 
a = b; 
trace(a);      // 1,2,3 
trace(b);      // 1,2,3 
trace(a != b); // false

関連項目

式のプロトタイプチェーンに function のプロトタイプオブジェクトが含まれるかどうかを評価します。instanceof 演算子は、ECMAScript Edition 3 との後方互換性を維持するために提供されており、クラスの代わりにコンストラクタ関数を含むプロトタイプベースの継承を使用する上級プログラマにとって役立つ場合があります。

オブジェクトが特定のデータ型のメンバーであるかどうかをチェックするには、is 演算子を使用します。

instanceof 演算子は、クラスと共に使用する場合、is 演算子と似たものになります。クラスのプロトタイプチェーンには、そのスーパークラスがすべて含まれているからです。ただし、インターフェイスはプロトタイプチェーンに含まれないため、instanceof 演算子をインターフェイスと共に使用すると結果は常に false になりますが、is 演算子の場合、指定されたインターフェイスを実装するクラスにオブジェクトが属している場合は true になります。

メモ： ActionScript の is 演算子は、Java の instanceof 演算子と同じです。

var mySprite:Sprite = new Sprite();
trace(mySprite instanceof Sprite);        // true
trace(mySprite instanceof DisplayObject); // true

var mySprite:Sprite = new Sprite();
trace(mySprite instanceof IBitmapDrawable); // false
trace(mySprite is IBitmapDrawable);         // true

関連項目

オブジェクトに特定のデータ型、クラス、またはインターフェイスと互換性があるかどうかを評価します。instanceof 演算子の代わりに、is 演算子を使用して型の比較を行います。is 演算子を使用して、オブジェクトにインターフェイスが実装されているかどうかをチェックすることもできます。

import flash.display.*;
import flash.events.IEventDispatcher;

var mySprite:Sprite = new Sprite();
trace(mySprite is Sprite);           // true
trace(mySprite is DisplayObject);    // true
trace(mySprite is IEventDispatcher); // true

関連項目

2 つの式を比較し、expression1 が expression2 より小さいかどうかを判定します。小さい場合、結果は true になります。expression1 が expression2 より大きいか等しい場合、結果は false になります。

両方のオペランドが String 型である場合、オペランドはアルファベット順で大文字、小文字の順に比較されます。それ以外の場合、オペランドは数値に変換されてから比較されます。

trace(5 < 10); // true 
trace(2 < 2);            // false 
trace(10 < 3);           // false 
trace("Allen" < "Jack"); // true 
trace("Jack" < "Allen"); // false 
trace("11" < "3");       // true 
trace("11" < 3);         // false (numeric comparison) 
trace("C" < "abc");      // true 
trace("A" < "a");        // true 

2 つの式を比較し、expression1 が expression2 より小さいまたは等しいかどうかを判定します。小さいか等しい場合、結果は true になります。 expression1 が expression2 より大きい場合、結果は false になります。

両方のオペランドが String 型である場合、オペランドはアルファベット順で大文字、小文字の順に比較されます。それ以外の場合、オペランドは数値に変換されてから比較されます。

trace(5 <= 10); // true 
trace(2 <= 2);            // true 
trace(10 <= 3);           // false 
trace("Allen" <= "Jack"); // true 
trace("Jack" <= "Allen"); // false 
trace("11" <= "3");       // true 
trace("11" <= 3);         // false (numeric comparison) 
trace("C" <= "abc");      // true 
trace("A" <= "a");        // true 

スクリプトコメントの先頭を示します。コメント行区切り記号（//）と行末の間に表示される文字はコメントと解釈され、無視されます。コメントが 1 行の場合はこのコメント行区切り記号を使用し、連続した複数行の場合は /* および */ の区切り記号を使用します。

// Any text following a line comment delimiter is ignored during compilation

関連項目

false である場合または false に変換できる場合は expression1 を返し、そうでない場合は expression2 を返します。false に変換できる値の例としては、0、NaN、null、および undefined があります。expression2 で関数呼び出しを使用する場合、expression1 の評価結果が false であれば、関数は呼び出されません。

両方のオペランドが Boolean 型である場合、次の表に示すように、両方のオペランドが true である場合にのみ結果が true となります。

var turns:Number = 2; 
var score:Number = 77; 
if ((turns <= 3) && (score >= 75)) { 
    trace("You Win the Game!"); 
} else { 
    trace("Try Again!"); 
} 

関連項目

expression1 に expression1 && expression2 の値を代入します。例えば、次の 2 つのステートメントは同じです。

x &&= y; 
x = x && y; 

var myVar:String = 'tag';
myVar &&= "<" + myVar + "/>";
trace (myVar); // output: <tag/>

var myVar:String = 'tag';
if (myVar != '') {
  myVar = "<" + myVar + "/>";
}
trace (myVar); // output: <tag/>

関連項目

変数や式のブール値を反転します。expression が変数で、その絶対値または変換された値が true である場合、!expression の値は false になります。式 x && y の評価が false である場合、式 !(x && y) の評価は true になります。

次の式は、論理否定（!）演算子を使用した結果を示しています。

• !true は false を返します。
• !false は true を返します。

var happy:Boolean = false; 
if (!happy) { 
    trace("don't worry, be happy"); // don't worry, be happy 
} 

関連項目

true である場合または true に変換できる場合は expression1 を返し、そうでない場合は expression2 を返します。expression2 で関数呼び出しを使用する場合、expression1 の評価結果が true であれば、関数は呼び出されません。

次の表に示すように、両方のオペランドが Boolean 型で、いずれかまたは両方の式が true である場合、結果は true になります。両方の式が false である場合、結果は false になります。

var a:Number = 10; 
var b:Number = 250; 
var start:Boolean = false; 
if ((a > 25) || (b > 200) || (start)) { 
    trace("the logical OR test passed"); // the logical OR test passed 
} 

次のように、2 番目のオペランドに関数呼び出しを指定すると、予期しない結果が生じる場合があります。演算子の左側の式が true と評価された場合、右側の式は評価されずに（関数 fx2() は呼び出されずに）、左側の式の結果だけが返されます。

function fx1():Boolean { 
    trace("fx1 called"); 
    return true; 
} 
function fx2():Boolean { 
    trace("fx2 called"); 
    return true; 
} 
if (fx1() || fx2()) { 
    trace("IF statement entered");
}

関連項目

expression1 に expression1 || expression2 の値を代入します。例えば、次の 2 つのステートメントは同じです。

x ||= y; 
x = x || y; 

myVar ||= "default";

関連項目

expression1 を expression2 で割ったときの剰余を計算します。いずれかのオペランドが数値でない場合は、剰余（%）演算子により数値への変換が試行されます。

剰余演算結果の符号は、被除数（最初の数値）の符号と一致します。例えば、-4 % 3 と -4 % -3 の評価結果は共に -1 になります。

trace(12 % 5);    // 2 
trace(4.3 % 2.1); // 0.0999999999999996 
trace(4 % 4);     // 0 

関連項目

expression1 に expression1 % expression2 の値を割り当てます。次の 2 つのステートメントは等価です。

x %= y; 
x = x % y; 

var a:Number = 14; 
var b:Number = 5; 
a %= b;
trace(a); // 4 

関連項目

2 つの数値や式を乗算します。両方の式が整数であれば、その積は整数です。いずれかの式または両方の式が浮動小数点数であれば、その積は浮動小数点数になります。

trace(2*3); // 6 

trace(2.0 * 3.1416); // 6.2832 

関連項目

expression1 に expression1 * expression2 の値を割り当てます。例えば、次の 2 つの式は同じです。

x *= y 
x = x * y 

var a:Number = 5; 
var b:Number = 10; 
trace(a *= b); // 50 

var i:Number = 5; 
var c:Number = 4 - 6; 
var d:Number = i + 2; 
trace(c *= d); // -14 

関連項目

namespace::property

namespace::method()

namespace::xmlObject.property

namespace::xmlObject.@attribute

プロパティ、メソッド、XML プロパティ、または XML 属性の名前空間を識別します。

public class NamespaceExample extends Sprite {
    public namespace French;
    public namespace Hawaiian;
    public function NamespaceExample() {
        trace(Hawaiian::hello()); // aloha
        trace(French::hello()); // bonjour
    }
    Hawaiian function hello():String {
        return "aloha";
    }

    French function hello():String { 
        return "bonjour";
    }
}

var soap:Namespace = new Namespace("http://schemas.xmlsoap.org/wsdl/soap/");
var w:Namespace = new Namespace("http://weather.example.org/forecast");
var myXML:XML = 
    <soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"> 
     <soap:Body>
      <w:forecast xmlns:w="http://weather.example.org/forecast">
       <w:city>Quito</w:city>
       <w:country>Ecuador</w:country>
       <date>2006-01-14</date>
      </w:forecast>
      </soap:Body>
    </soap:Envelope>;
    
trace(myXML.soap::Body.w::forecast.w::city); // Quito

関連項目

クラスインスタンスをインスタンス化します。new 演算子をクラスまたは Class 型の変数で使用して、クラスのインスタンスを作成できます。一般的に new 演算子は、クラスのインスタンスを作成するため、クラスオブジェクトで使用します。例えば、ステートメント new Sprite() では、Sprite クラスのインスタンスが作成されます。

new 演算子を使用して、クラスを埋め込みアセットと関連付けることもできます。埋め込みアセットとは、SWF ファイルにコンパイルされるイメージ、サウンド、フォントなどの外部オブジェクトのことです。埋め込みアセットは、それぞれ固有の埋め込みアセットクラスによって表されます。埋め込みアセットにアクセスするには、new 演算子を使用して、関連付けられたクラスをインスタンス化します。次に、埋め込みアセットクラスの該当するメソッドおよびプロパティを呼び出して、埋め込みアセットを操作します。

class キーワードではなく、Function オブジェクトによりクラスを定義する場合は、new 演算子を使用して、コンストラクタ関数に基づくオブジェクトを作成できます。コンストラクタ関数を、クラスのコンストラクタメソッドと混同しないよう注意してください。コンストラクタ関数は、function キーワードによって定義される Function オブジェクトで、クラス定義の一部ではありません。コンストラクタ関数を使用してオブジェクトを作成する場合は、クラス継承の代わりに、プロトタイプ継承を使用します。

class Book {
  var bName:String;
  var bPrice:Number;
  
  public function Book(nameParam:String, priceParam:Number){
    bName = nameParam;
    bPrice = priceParam;
  }
}

var book1:Book = new Book("Confederacy of Dunces", 19.95);
var book2:Book = new Book("The Floating Opera", 10.95);
trace(book1); // [object Book]

var golfCourse:Array = new Array(18);

関連項目

object = {name1 : value1, name2 : value2,... nameN : valueN}

新しいオブジェクトを作成し、指定された name と value のプロパティペアで初期化します。この演算子を使用することは、new Object シンタックスを使用して代入演算子でプロパティペアを設定するのと同じです。新しく作成されるオブジェクトのプロトタイプとして、汎用の Object オブジェクトがあります。

また、フローを制御するステートメント（for、while、if、else、switch）や関数で、ひとかたまりのコードブロックであることを示すときにも、この演算子が使用されます。

var object:Object = {}; 
var object:Object = new Object(); 

var account:Object = {name:"Adobe Systems, Inc.", address:"601 Townsend Street", city:"San Francisco", state:"California", zip:"94103", balance:"1000"}; 
for (i in account) { 
    trace("account."+i+" = "+account[i]); 
} 

var person:Object = {name:"Gina Vechio", children:["Ruby", "Chickie", "Puppa"]}; 

var person:Object = new Object(); 
person.name = "Gina Vechio"; 
person.children = new Array(); 
person.children[0] = "Ruby"; 
person.children[1] = "Chickie"; 
person.children[2] = "Puppa"; 

関連項目

(expression1[, expression2])

(expression1, expression2)

function(parameter1,..., parameterN) 

パラメータに対してグループ化演算を実行するか、複数の式を順番に評価します。または、パラメータを囲み、引数として括弧の前の関数に渡します。

シンタックス 1：演算子が実行される順番を制御します。括弧は通常の優先順位を無効にし、括弧内の式を最初に評価します。括弧がネストされている場合は、最も内側の括弧から順に外側の括弧へと内容が評価されます。

シンタックス 2：カンマ区切りの一連の式を順番に評価し、最後に実行された式の結果を返します。

シンタックス 3：パラメータを囲み、括弧の前の関数に渡します。

trace((2 + 3) * (4 + 5)); // 45 
trace(2 + (3 * (4 + 5))); // 29
trace(2 + (3 * 4) + 5);   // 19
trace(2 + (3 * 4) + 5);   // 19

var a:Number = 1; 
var b:Number = 2; 
function foo() { 
  a += b; 
} 
function bar() { 
  b *= 10; 
} 
trace((foo(), bar(), a + b)); // 23 

var today:Date = new Date(); 
trace(today.getFullYear()); // outputs current year 
function traceParameter(param):void { 
  trace(param); 
} 
traceParameter(2 * 2); // 4 

関連項目

myXML.(expression)

ECMAScript for XML（E4X）の XML 構造内の式を評価します。例えば、myXML.(lastName == "Smith") では、名前が lastName で値が "Smith" の XML エレメントが識別されます。結果は XMLList オブジェクトです。

var myXML:XML = 
    <employees>
        <employee id = "42">
            <firstName>Joe</firstName>
            <lastName>Smith</lastName>
        </employee>
        <employee id = "43">
            <firstName>Susan</firstName>
            <lastName>Jones</lastName>
        </employee>
        <employee id = "44">
            <firstName>Anne</firstName>
            <lastName>Smith</lastName>
        </employee>
    </employees>;
    
trace(myXML.employee.(lastName == "Smith").@id.toXMLString()); 
    // 42
    // 44
                
trace(myXML.employee.(Number(@id) > 42).@id.toXMLString()); 
    // 43
    // 44

関連項目

/pattern/flags

文字の前後を囲んで使用する場合、囲まれた文字はリテラル値を表し、変数やストリング、その他の ActionScript エレメントではなく、正規表現（RegExp）と見なされます。ただし、2 つの連続したスラッシュ（//）で始まる場合は、コメントの最初であることを表します。

var myRegExp:RegExp = /foo-\d+/i; 
trace(myRegExp.exec("ABC Foo-32 def.")); // Foo-32 

関連項目

自動データ変換を行わずに、2 つの式が等しいかどうかをテストします。両方の式が、そのデータ型も含めて等しい場合、結果は true になります。

厳密な等価（===）演算子は、次の 3 つの点で等価（==）演算子と同じです。

• 数値とブール値は値により比較され、それらの値が同じであれば、等しいと見なされます。
• ストリング式は、文字数が同じで、同じ文字で構成されている場合に、等しいと見なされます。
• オブジェクト、配列、および関数を表す変数は、参照により比較されます。2 つの変数が同じオブジェクト、配列、または関数を参照する場合、それらの変数は等価です。2 つの別個の配列は、エレメント数が同じである場合でも、等しいとは見なされません。

• 厳密な等価（）演算子は Number、int、および uint 型のみ自動データ変換を行い、等価（）演算子はすべてのプリミティブデータ型の自動データ変換を行います。
• null と undefined を比較する場合、厳密な等価演算子では false が返されます。

1 つ目は、プリミティブ値と同じ値を持つプリミティブオブジェクトを比較する場合です。ActionScript 3.0 では true が返されますが、以前のバージョンでは false が返されます。以前のバージョンでは、プリミティブ値のデータ型は Boolean、Number、または String のいずれかでしたが、プリミティブオブジェクトのデータ型は Boolean、Number、または String ではなく Object でした。実質的な違いとして、次のコードの結果は、以前のバージョンの ActionScript ではオペランドのデータ型が一致しないため false になりますが、ActionScript 3.0 では、オブジェクト内にラップされているかどうかに関わらず、プリミティブ値のデータ型は Boolean、Number、int、uint、または String のいずれかであるため、結果は true となります。

var num1:Number = 1;
var num2:Number = new Number(1);
trace(num1 === num2); // true in ActionScript 3.0, false in ActionScript 2.0
			

var num1:Number = new Number(1);
var num2:Number = new Number(1);
trace(num1 == num2);  // true in ActionScript 3.0, false in ActionScript 2.0
trace(num1 === num2); // true in ActionScript 3.0, false in ActionScript 2.0

var string1:String = "5"; 
var string2:String = "5"; 
trace(string1 == string2);  // true 
trace(string1 === string2); // true

// The equality (==) operator converts 5 to "5", but the strict equality operator does not
var string1:String = "5"; 
var num:Number = 5; 
trace(string1 == num);  // true 
trace(string1 === num); // false 

var num:Number = 1;
var bool:Boolean = true;
trace(num == bool);  // true 
trace(num === bool); // false

var num1:Number = 1;
var num2:int = 1;
var num3:uint = 1;
trace(num1 === num2); // true
trace(num1 === num3); // true

trace(null == undefined);  // true 
trace(null === undefined); // false 

関連項目

厳密な等価（===）演算子の正反対が真であるかどうかをテストします。厳密な等価演算子は、int および uint のデータ型のみが変換されるという点以外は不等価演算子と同じです。

expression1 が expression2 と等しく、両方のデータ型が同じである場合、結果は false になります。

厳密な不等価（!==）演算子は、次の 3 つの点で不等価（!=）演算子と同じです。

• 数値とブール値は値により比較され、それらの値が同じであれば、等しいと見なされます。
• ストリング式は、文字数が同じで、同じ文字で構成されている場合に、等しいと見なされます。
• オブジェクト、配列、および関数を表す変数は、参照により比較されます。2 つの変数が同じオブジェクト、配列、または関数を参照する場合、それらの変数は等価です。2 つの別個の配列は、エレメント数が同じである場合でも、等しいとは見なされません。

• 厳密な不等価（!==）演算子は Number、int、および uint 型のみ自動データ変換を行い、不等価（!=）演算子はすべてのプリミティブデータ型の自動データ変換を行います。
• null と undefined を比較する場合、厳密な不等価（!==）演算子では true が返されます。

var s1:String = "5"; 
var s2:String = "5"; 
var s3:String = "Hello"; 
var n:Number = 5; 
var b:Boolean = true; 
trace(s1 == s2);  // true 
trace(s1 == s3);  // false 
trace(s1 == n);   // true 
trace(s1 == b);   // false 
trace(s1 === s2); // true 
trace(s1 === s3); // false 
trace(s1 === n);  // false 
trace(s1 === b);  // false 
trace(s1 !== s2); // false 
trace(s1 !== s3); // true 
trace(s1 !== n);  // true 
trace(s1 !== b);  // true 

関連項目

 "text" 

文字の前後を囲んで使用する場合、囲まれた文字はリテラル値を表し、変数や数値、その他の ActionScript エレメントではなく、ストリングと見なされます。

var yourGuess:String = "Prince Edward Island"; 
submit_btn.onRelease = function() { trace(yourGuess); }; 
// Prince Edward Island

関連項目

-expression

 expression1 - expression2

符号反転や減算に使用します。

シンタックス 1：符号反転に使用する場合、式の符号を逆にします。

シンタックス 2：減算に使用する場合、2 つの式に対して算術的な減算を行い、expression1 から expression2 を減算します。両方の式が整数であれば、その差は整数です。いずれかの式または両方の式が浮動小数点数であれば、その差は浮動小数点数です。

trace(-(2 + 3)); // -5 

trace(5 - 2); // 3 

次のステートメントは、浮動小数点数 3.25 から浮動小数点数 1.5 を減算します。

trace(3.25 - 1.5); // 1.75 

関連項目

expression1 に expression1 - expression2 の値を割り当てます。例えば、次の 2 つのステートメントは同じです。

x -= y ;
x = x - y;

ストリング式は数値に変換される必要があります。変換されない場合、結果は NaN（非数）となります。

var x:Number = 5; 
var y:Number = 10; 
x -= y; 
trace(x); // -5 

var x:String = "5"; 
var y:String = "10"; 
x -= y; 
trace(x); // -5 

関連項目

[modifiers] var variableName:type

function functionName():type { ... }

function functionName(parameter1:type, ..., parameterN:type) [:type]{ ... } 

データ型を割り当てるために使用します。この演算子は、変数の型、関数の戻り値の型、または関数パラメータの型を指定します。変数の宣言または割り当てで使用する場合は、変数の型を指定します。関数の宣言または定義で使用する場合は、関数の戻り値の型を指定します。関数定義の関数パラメータで使用する場合は、そのパラメータの変数の型を指定します。

型チェックは実行時に必ず行われます。ただし、コンパイラが strict モードに設定されている場合は、コンパイル時にもすべての型のチェックが行われ、型の不一致がある場合にエラーが発生します。型の不一致は、割り当て操作、関数の呼び出し、ドット（.）演算子を使用したクラスメンバーの逆参照の際に発生する可能性があります。

使用できる型としては、すべてのネイティブオブジェクト型、独自に定義したクラスとインターフェイス、および void があります。認識されるネイティブ型には、ブール（Boolean）、数値（Number）、整数（int）、符号なし整数（uint）、ストリング（String）があります。また、すべてのビルトインクラスは、ネイティブ型としてサポートされます。

データ型を割り当てない場合、変数、関数の戻り値、または関数のパラメータは型指定なしと見なされ、どのようなデータ型の値も取ることができます。型指定のない値を使用することを明示するには、型注釈にアスタリスク（*）文字を使用します。アスタリスク文字を型注釈に使用すると、変数、関数の戻り値の型、または関数のパラメータの型を指定しないのと同じことになります。

var userName:String = ""; 

function randomInt(integer:int):int { 
    return Math.round(Math.random()*integer); 
} 
trace(randomInt(8)); 

function squareRoot(val:Number):Number { 
    return Math.sqrt(val); 
} 
trace(squareRoot(121)); 

関連項目

expression を評価し、式のデータ型を表すストリングを返します。結果は、boolean、function、number、object、string、および xml の、6 つのストリング値に限定されます。ユーザー定義クラスのインスタンスにこの演算子を適用する場合、結果は object のストリングになります。typeof 演算子は、後方互換性を維持するために提供されています。型の互換性をチェックするには、is 演算子を使用します。

trace(typeof Array); // object
trace(typeof Date);  // object
trace(typeof 3);     // number

var a:String = "sample";
var b:String = new String("sample");
trace(typeof a); // string
trace(typeof b); // string 

関連項目

式を評価した後、その値を破棄して、undefined を返します。void 演算子は、多くの場合、== 演算子を使用して undefined 値をテストする比較において使用します。

関連項目

 myXML= <{tagName} {attributeName} = {attributeValue}>{content}</{tagName}>

XML リテラル内の XML タグを定義します。終了タグはスラッシュ / を使用して定義します。

var x:XML = <item id= "324">cola</item>; 

関連項目