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

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) 

関連項目

/* コメント */

/* コメント

   コメント */

スクリプトコメントのブロックを区切ります。開始区切り記号 (/*) と終了区切り記号 (*/) の間の文字はコメントと解釈され、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()); 

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

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