演算子 

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

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

関連する API エレメント

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

x += y; 
x = x + y; 

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

関連する API エレメント

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

関連する API エレメント

最初のオペランドで指定された式が、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

関連する API エレメント

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

関連する API エレメント

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

関連する API エレメント

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 

関連する API エレメント

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

x &= y; 
x = x & y; 

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

関連する API エレメント

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 

関連する API エレメント

ビット単位の左シフト（<<=）演算を行い、その内容を結果として 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 

関連する API エレメント

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 

関連する API エレメント

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) 

関連する API エレメント

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) 

関連する API エレメント

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)

関連する API エレメント

ビット単位の右シフト演算を行い、結果を 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.

関連する API エレメント

左側のビットは常に 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 

関連する API エレメント

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

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

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

関連する API エレメント

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) 

関連する API エレメント

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) 

関連する API エレメント

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

関連する API エレメント

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

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>

関連する API エレメント

 myXML[expression]

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

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

関連する API エレメント

式 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 

関連する API エレメント

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

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

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 

関連する API エレメント

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

trace ステートメントの出力は次のようになります。

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

関連する API エレメント

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

x += y; 
x = x + y;

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

関連する API エレメント

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

trace ステートメントの出力は次のようになります。

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

<location>Springfield</location>

関連する API エレメント

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

関連する API エレメント

 delete reference

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

 
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

関連する API エレメント

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

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

関連する API エレメント

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

x /= y; 
x = x / y;

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

関連する API エレメント

object.property_or_method

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

import flash.utils.Timer;

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

関連する API エレメント

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

関連する API エレメント

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 

関連する API エレメント

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

関連する API エレメント

プロパティが特定のオブジェクトの一部であるかどうかを評価します。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

関連する API エレメント

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

関連する API エレメント

式のプロトタイプチェーンに 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

関連する API エレメント

オブジェクトに特定のデータ型、クラス、またはインターフェイスと互換性があるかどうかを評価します。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

関連する API エレメント

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

関連する API エレメント

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

関連する API エレメント

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

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