연산자 

숫자 표현식을 추가합니다. 두 표현식이 정수인 경우 그 합도 정수이며, 한 표현식 또는 두 표현식이 모두 부동 소수점 숫자인 경우 그 합도 부동 소수점 숫자입니다.

한 표현식이 문자열이면 다른 표현식도 모두 더해지는 대신 문자열로 변환된 후 연결됩니다. 그렇지 않고 한 표현식이 숫자가 아닌 경우에는 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의 값을 대입합니다. 예를 들어, 다음 두 명령문의 결과는 동일합니다.

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 등과 같은 지정된 요소를 사용하여 새 배열 또는 다차원 배열을 초기화하거나 배열의 요소에 액세스합니다. array access 연산자를 사용하면 인스턴스, 변수 및 객체 이름을 동적으로 설정하고 가져올 수 있습니다. 또한 객체 속성에 액세스할 수도 있습니다.

구문 1: 배열은 일종의 객체로 해당 속성은 요소라고 하며, 이 요소는 각각 인덱스라는 숫자에 의해 식별됩니다. 배열을 만드는 경우 array access([]) 연산자 또는 대괄호를 사용하여 요소를 묶습니다. 배열에는 다양한 유형의 요소가 포함될 수 있습니다. 예를 들어, 이름이 employee인 다음 배열에는 세 요소가 포함되어 있습니다. 첫 번째 요소는 숫자이고 두 번째 두 요소는 인용 부호로 묶여 있는 문자열입니다.

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

다음 예제에서는 요소가 세 개인 employee_array 배열을 만들고 배열의 세 번째 요소를 변경합니다.

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 요소

첫 번째 피연산자로 지정된 표현식이 두 번째 피연산자로 지정된 데이터 유형의 멤버인지 평가합니다. 첫 번째 피연산자가 해당 데이터 유형의 멤버이면 결과는 첫 번째 피연산자입니다. 그렇지 않으면 결과는 null 값입니다.

두 번째 피연산자에 사용된 표현식은 데이터 유형으로 평가되어야 합니다.

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의 값을 대입합니다. 예를 들어, 다음 두 표현식은 동일합니다.

x &= y; 
x = x & y; 

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

관련 API 요소

expression1 및 shiftCount를 32비트 정수로 변환하고, expression1의 모든 비트를 shiftCount 변환 결과 정수값으로 지정된 자릿수만큼 왼쪽으로 이동합니다. 이 연산을 수행한 결과 비어 있는 비트 위치는 0으로 채워지고 왼쪽 끝으로 이동된 비트는 제거됩니다. 값을 왼쪽으로 한 자리씩 이동하는 것은 산술적으로 2를 곱하는 것과 같습니다.

부동 소수점 숫자는 소수점 뒤의 숫자를 제거하여 정수로 변환됩니다. 양의 정수는 최대값이 4294967295 또는 0xFFFFFFFF인 부호 없는 16진수 값으로 변환되고, 최대값보다 큰 값은 변환될 때 32비트 값을 유지하기 위해 최상위 자릿수를 버립니다. 음수는 2의 보수 표기를 사용하여 최소값이 -2147483648 또는 0x800000000인 부호 없는 16진수 값으로 변환되고, 최소값 미만의 숫자는 정밀도가 더 높은 2의 보수로 변환된 후 최상위 자릿수를 버립니다.

결과는 32비트 2의 보수로 해석되므로 -2147483648에서 2147483647 범위의 정수가 됩니다.

결과가 음의 정수인 경우 결과를 uint 유형의 변수에 대입하려고 하면 런타임 오류가 발생합니다. ActionScript에는 "unsigned bitwise left shift" 연산자가 없지만 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 문은 비트가 왼쪽으로 세 자리 밀린 것을 보여 줍니다.

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

관련 API 요소

bitwise left shift(<<=) 연산을 수행하고 그 결과를 expression1에 저장합니다. 다음 두 표현식은 동일합니다.

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의 보수 연산자 또는 비트 보수 연산자라고도 합니다.

예를 들어, 16진수 값 0x7777은 다음과 같은 2진 숫자로 표시됩니다.

0111011101110111

이 16진수 값의 비트 부정 ~0x7777은 다음과 같은 이진 숫자입니다.

1000100010001000

16진수에서 이 값은 0x8888입니다. 따라서 ~0x7777은 0x8888입니다.

bitwise 연산자는 플래그 비트(각각 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의 값을 대입합니다. 예를 들어, 다음 두 명령문은 동일합니다.

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비트 정수로 변환하고, expression의 모든 비트를 shiftCount의 변환 결과로 나온 정수로 지정된 자릿수만큼 오른쪽으로 이동합니다. 오른쪽 끝으로 이동된 비트는 제거됩니다. 원래 표현식의 부호를 유지하려는 경우, expression의 최상위 비트(가장 왼쪽 비트)가 0이면 왼쪽 비트를 0으로 채우고 최상위 비트가 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 요소

bitwise right shift 연산을 수행하고 그 결과를 expression에 저장합니다.

다음 두 명령문은 동일합니다.

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이 채워지므로 원래 표현식의 부호가 유지되지 않는다는 점을 제외하면 bitwise right shift(>>) 연산자와 동일합니다.

부동 소수점 숫자는 소수점 뒤의 숫자를 제거하여 정수로 변환됩니다. 양의 정수는 최대값이 4294967295 또는 0xFFFFFFFF인 부호 없는 16진수 값으로 변환되고, 최대값보다 큰 값은 변환될 때 32비트 값을 유지하기 위해 최상위 자릿수를 버립니다. 음수는 2의 보수 표기를 사용하여 최소값이 -2147483648 또는 0x800000000인 부호 없는 16진수 값으로 변환되고, 최소값 미만의 숫자는 정밀도가 더 높은 2의 보수로 변환된 후 최상위 자릿수를 버립니다.

결과는 부호 없는 32비트 정수로 해석되므로 0에서 4294967295 범위의 정수가 됩니다.

참고: ActionScript에는 보완되는 "bitwise unsigned left shift" 연산자가 없지만 uint(expression << shiftCount)를 사용하여 동일한 작업을 수행할 수 있습니다.

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

관련 API 요소

부호 없는 bitwise right shift 연산을 수행하고 그 결과를 expression에 저장합니다. 다음 두 명령문은 동일합니다.

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의 값을 대입합니다. 예를 들어, 다음 두 명령문은 동일합니다.

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 컴파일러에서 무시됩니다. 이러한 기호를 사용하여 연속되는 여러 행으로 구성된 주석을 식별할 수 있으며, 한 줄 주석을 식별하려면 // 기호를 사용합니다.

닫기 블록 주석 기호(*/)를 생략하거나 주석을 중첩하려고 시도하면 오류 메시지가 표시됩니다. 열기 기호(/*)가 사용된 후 첫 번째 닫기 기호(*/)가 나타나면 닫기 기호 이전까지 배치된 열기 기호의 수와 상관 없이 주석이 끝납니다.

/* 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 객체의 속성 또는 특성에 액세스합니다. brackets 연산자를 사용하면 dot(.) 연산자로 액세스할 수 없는 속성 이름에 액세스할 수 있습니다.

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

관련 API 요소

expression1, expression2 등의 순서대로 평가합니다. 이 연산자는 주로 for 루프 명령문과 함께 사용되거나 parentheses () 연산자와 함께 사용됩니다.

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 요소

문자열을 연결 또는 결합합니다. 한 표현식이 문자열이면 다른 표현식도 모두 문자열로 변환된 후 연결됩니다.

두 표현식이 모두 숫자이면 이 연산자는 addition 연산자로 동작합니다.

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의 값을 대입합니다. 예를 들어, 다음 두 명령문의 결과는 동일합니다.

x += y; 
x = x + y;

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

관련 API 요소

expression1 += expression2

expression1에 XMLList 객체인 expression1 + expression2의 값을 대입합니다. 예를 들어, 다음 두 명령문의 결과는 동일합니다.

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 연산자를 사용할 수 없습니다. 봉인 클래스의 속성은 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 예약어와 일치하는 자손을 반환하려면 다음 예제와 같이 descendant(..) 연산자 대신 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의 값을 대입합니다. 예를 들어, 다음 두 명령문은 동일합니다.

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 dot(.) 연산자 대신 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 요소

두 표현식이 동일한지 여부를 테스트합니다. 두 표현식이 동일한 경우 결과는 true입니다.

두 피연산자의 데이터 유형이 일치할 경우 동일함에 대한 정의는 피연산자의 데이터 유형에 따라 다릅니다.

• int, uint 및 Boolean 유형의 값이 동일한 값을 갖고 있는 경우 서로 동일한 것으로 간주됩니다.
• NaN 이외의 일치하는 값을 갖고 있는 숫자의 경우 서로 동일한 것으로 간주됩니다.
• 두 피연산자의 값이 null 또는 undefined인 경우 서로 동일한 것으로 간주됩니다.
• 문자열 표현식은 문자가 동일하고 문자 수도 같은 경우 서로 동일한 것으로 간주됩니다.
• XML 객체의 경우:
  • 텍스트 또는 특성 노드인 피연산자와 간단한 내용을 갖고 있는 피연산자가 있는 경우 toString() 메서드를 사용하여 두 피연산자를 문자열로 변환한 다음 결과 문자열이 일치하면 두 피연산자는 동일한 것으로 간주됩니다.
  • 그렇지 않은 경우에는 두 객체의 정규화된 이름, 특성 및 자식 속성이 일치하는 경우에만 서로 동일한 것으로 간주됩니다.
• XMLList 객체는 속성의 수가 같고 속성의 순서 및 값이 모두 일치하는 경우 서로 동일한 것으로 간주됩니다.
• Namespace 객체의 경우, 두 객체의 uri 속성이 일치하면 값이 동일한 것으로 간주됩니다.
• QName 객체의 경우, 두 객체의 uri 속성 및 localName 속성이 모두 일치하면 값이 동일한 것으로 간주됩니다.
• 객체, 배열 및 함수를 나타내는 변수는 참조를 기준으로 비교됩니다. 이러한 두 변수는 동일한 객체, 배열 또는 함수를 참조하는 경우 서로 동일한 것으로 간주됩니다. 별도의 두 배열은 포함된 요소의 수가 같더라도 동일한 것으로 간주되지 않습니다.

• 피연산자의 값이 undefined 및 null인 경우 결과는 true입니다.
• 자동 데이터 유형 변환이 String, Boolean, int, uint 및 Number 값을 호환되는 유형으로 변환하며, 변환된 값이 서로 동일하면 피연산자는 서로 동일한 것으로 간주됩니다.
• 피연산자 중 하나가 간단한 내용(hasSimpleContent() == true)을 가진 XML 유형이고, toString() 메서드를 사용하여 두 피연산자를 문자열로 변환한 후 결과 문자열이 일치합니다.
• 피연산자 중 하나의 유형이 XMLList이고 다음 조건 중 하나가 true인 경우:
  • XMLList 객체의 length 속성이 0이고 다른 객체가 undefined입니다.
  • XMLList 객체의 length 속성이 1이고 XMLList 객체의 한 요소가 다른 피연산자와 일치합니다.

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 요소

두 표현식을 비교하여 expression1이 expression2보다 큰지 여부를 확인합니다. 큰 경우 결과는 true입니다. expression1이 expression2보다 작거나 같으면 결과는 false입니다.

피연산자의 유형이 모두 문자열인 경우 피연산자는 알파벳 순서로 비교되며, 소문자보다 대문자가 앞에 옵니다. 그렇지 않은 경우에는 피연산자가 숫자로 변환된 후 비교됩니다.

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

두 표현식을 비교하여 expression1이 expression2보다 크거나 같은지(true) 또는 expression1이 expression2보다 작은지(false) 확인합니다.

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

관련 API 요소

속성이 특정 객체에 속하는지 여부를 평가합니다. in 연산자를 사용하려면 속성 이름을 첫 번째 피연산자로 지정하고, 객체를 두 번째 피연산자로 지정합니다. 지정한 객체에 그러한 속성이 들어 있으면 결과가 true이고, 그렇지 않으면 false입니다.

지정된 객체가 Array 객체이면 in 연산자를 사용해서 특정 인덱스 번호가 유효한지 여부를 확인할 수 있습니다. 정수를 첫 번째 피연산자로 전달한 경우 색인이 유효한 색인 번호 범위 내에 있으면 결과가 true이고, 그렇지 않으면 false입니다.

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

다음 예제에서는 in 연산자를 사용하여 myArray 객체에서 숫자 0, 1 및 2는 유효한 색인 번호이지만 숫자 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 
*/

equality(==) 연산자의 정반대 상황을 테스트합니다. expression1이 expression2와 같으면 결과는 false입니다. equality(==) 연산자와 마찬가지로 동일함에 대한 정의는 비교되는 데이터의 유형에 따라 다릅니다.

두 피연산자의 데이터 유형이 일치할 경우 동일함에 대한 정의는 피연산자의 데이터 유형에 따라 다릅니다.

• int, uint 및 Boolean 유형의 값이 동일한 값을 갖고 있는 경우 서로 동일한 것으로 간주됩니다.
• NaN 이외의 일치하는 값을 갖고 있는 숫자의 경우 서로 동일한 것으로 간주됩니다.
• 두 피연산자의 값이 null 또는 undefined인 경우 서로 동일한 것으로 간주됩니다.
• 문자열 표현식은 문자가 동일하고 문자 수도 같은 경우 서로 동일한 것으로 간주됩니다.
• XML 객체의 경우:
  • 텍스트 또는 특성 노드인 피연산자와 간단한 내용을 갖고 있는 피연산자가 있는 경우 toString() 메서드를 사용하여 두 피연산자를 문자열로 변환한 다음 결과 문자열이 일치하면 두 피연산자는 동일한 것으로 간주됩니다.
  • 그렇지 않은 경우에는 두 객체의 정규화된 이름, 특성 및 자식 속성이 일치하는 경우에만 서로 동일한 것으로 간주됩니다.
• XMLList 객체는 속성의 수가 같고 속성의 순서 및 값이 모두 일치하는 경우 서로 동일한 것으로 간주됩니다.
• Namespace 객체의 경우, 두 객체의 uri 속성이 일치하면 값이 동일한 것으로 간주됩니다.
• QName 객체의 경우, 두 객체의 uri 속성 및 localName 속성이 모두 일치하면 값이 동일한 것으로 간주됩니다.
• 객체, 배열 및 함수를 나타내는 변수는 참조를 기준으로 비교됩니다. 이러한 두 변수는 동일한 객체, 배열 또는 함수를 참조하는 경우 서로 동일한 것으로 간주됩니다. 별도의 두 배열은 포함된 요소의 수가 같더라도 동일한 것으로 간주되지 않습니다.

• 피연산자의 값이 undefined 및 null인 경우 결과는 true입니다.
• 자동 데이터 유형 변환이 String, Boolean, int, uint 및 Number 값을 호환되는 유형으로 변환하며, 변환된 값이 서로 동일하면 피연산자는 서로 동일한 것으로 간주됩니다.
• 피연산자 중 하나가 간단한 내용(hasSimpleContent() == true)을 가진 XML 유형이고, toString() 메서드를 사용하여 두 피연산자를 문자열로 변환한 후 결과 문자열이 일치합니다.
• 피연산자 중 하나의 유형이 XMLList이고 다음 조건 중 하나가 true인 경우:
  • XMLList 객체의 length 속성이 0이고 다른 객체가 undefined입니다.
  • XMLList 객체의 length 속성이 1이고 XMLList 객체의 한 요소가 다른 피연산자와 일치합니다.

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 버전 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 요소

두 표현식을 비교하여 expression1이 expression2보다 작은지 여부를 확인합니다. 작은 경우 결과는 true입니다. expression1이 expression2보다 크거나 같으면 결과는 false입니다.

피연산자의 유형이 모두 문자열인 경우 피연산자는 알파벳 순서로 비교되며, 소문자보다 대문자가 앞에 옵니다. 그렇지 않은 경우에는 피연산자가 숫자로 변환된 후 비교됩니다.

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 

두 표현식을 비교하여 expression1이 expression2보다 작거나 같은지를 확인합니다. 작거나 같은 경우 결과는 true입니다. expression1이 expression2보다 크면 결과는 false입니다.

피연산자의 유형이 모두 문자열인 경우 피연산자는 알파벳 순서로 비교되며, 소문자보다 대문자가 앞에 옵니다. 그렇지 않은 경우에는 피연산자가 숫자로 변환된 후 비교됩니다.

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 

스크립트 주석의 시작을 나타냅니다. 주석 기호(//)와 행의 끝 문자 사이에 있는 문자는 주석으로 해석되며 무시됩니다. 이 기호는 한 줄 주석에 사용합니다. 연속되는 여러 행을 주석 처리할 경우 구분 기호로 /* 및 */를 사용합니다.

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

관련 API 요소

false이거나 false로 변환될 수 있으면 expression1을 반환하고, 그렇지 않으면 expression2를 반환합니다. 0, NaN, null, undefined 등이 false로 변환될 수 있는 값입니다. 함수 호출을 expression2로 사용하는 경우 expression1이 false로 평가되면 함수가 호출되지 않습니다.

다음 표와 같이 두 피연산자의 유형이 모두 부울이면 두 피연산자가 모두 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의 값을 대입합니다. 예를 들어, 다음 두 명령문은 동일합니다.

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

관련 API 요소

변수 또는 표현식의 부울 값을 반대로 합니다. expression이 절대값 또는 변환된 값 true가 포함된 변수이면 !expression 값은 false입니다. x && y 표현식이 false로 평가되면 !(x && y) 표현식은 true로 평가됩니다.

다음 표현식은 logical NOT(!) 연산자를 사용한 결과를 보여 줍니다.

• !true는 false를 반환합니다.
• !false는 true를 반환합니다.

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

관련 API 요소

true이거나 true로 변환될 수 있으면 expression1을 반환하고, 그렇지 않으면 expression2를 반환합니다. 함수 호출을 expression2로 사용하는 경우 expression1이·true로·평가되면·함수가·호출되지·않습니다.

다음 표와 같이 두 피연산자의 유형이 부울인 경우 표현식 중 하나 이상이 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 
} 

다음 예제에서는 함수 호출을 두 번째 피연산자로 사용하는 경우 예상치 않은 결과가 나타날 수 있음을 보여 줍니다. 연산자 왼쪽의 표현식이 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");
}

관련 API 요소

expression1에 expression1 || expression2의 값을 대입합니다. 예를 들어, 다음 두 명령문은 동일합니다.

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

myVar ||= "default";

관련 API 요소

expression1을 expression2로 나눈 나머지를 계산합니다. 피연산자 중 하나가 숫자가 아닌 경우 modulo(%) 연산자는 해당 피연산자를 숫자로 변환하려고 합니다.

modulo 결과의 부호는 피제수(첫 번째 숫자)의 부호와 일치합니다. 예를 들어, -4 % 3 및 -4 % -3은 모두 -1로 평가됩니다.

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

관련 API 요소

expression1에 expression1 % expression2의 값을 대입합니다. 다음 두 명령문은 동일합니다.

x %= y; 
x = x % y; 

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

관련 API 요소

두 개의 숫자 표현식을 곱합니다. 두 표현식이 모두 정수인 경우에는 곱한 값도 정수이고 두 표현식 중 하나라도 부동 소수점 숫자인 경우에는 곱한 값도 부동 소수점 숫자입니다.

trace(2*3); // 6 

trace(2.0 * 3.1416); // 6.2832 

expression1에 expression1 * expression2의 값을 대입합니다. 예를 들어, 다음 두 표현식은 동일합니다.

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 

관련 API 요소

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

관련 API 요소

클래스 인스턴스를 인스턴스화합니다. 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);

관련 API 요소

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

지정된 name 및 value 속성 쌍으로 새 객체를 만들거나 초기화합니다. 이 연산자를 사용하면 new Object 구문을 사용하고 assignment 연산자를 사용하여 속성 쌍을 채우는 것과 동일한 결과가 됩니다. 새로 만들어진 객체의 프로토타입은 일반적으로 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"; 

관련 API 요소

(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 

관련 API 요소

myXML.(expression)

XML(E4X) XML 구문을 위한 ECMAScript의 표현식을 평가합니다. 예를 들어, 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

관련 API 요소

/pattern/flags

문자의 앞/뒤에 사용하면 해당 문자에 리터럴 값이 있으므로 이 문자를 변수, 문자열 또는 다른 ActionScript 요소가 아니라 일반 표현식(RegExp)으로 간주해야 함을 나타냅니다. 그러나 연속되는 두 개의 슬래시 문자(//)는 주석의 시작을 나타냅니다.

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

관련 API 요소

두 표현식이 동일한지 테스트합니다. 그러나 자동 데이터 변환은 수행하지 않습니다. 데이터 유형을 포함하여 두 표현식이 동일한 경우 결과는 true입니다.

strict equality(===) 연산자는 다음 세 가지 면에서 equality(==) 연산자와 동일합니다.

• 숫자 및 부울 값은 값을 기준으로 비교되고 값이 동일한 경우 서로 동일한 것으로 간주됩니다.
• 문자열 표현식은 문자가 동일하고 문자 수도 같은 경우 서로 동일한 것으로 간주됩니다.
• 객체, 배열 및 함수를 나타내는 변수는 참조를 기준으로 비교됩니다. 이러한 두 변수는 동일한 객체, 배열 또는 함수를 참조하는 경우 서로 동일한 것으로 간주됩니다. 별도의 두 배열은 포함된 요소의 수가 같더라도 동일한 것으로 간주되지 않습니다.

• strict equality 연산자는 숫자 유형(Number, int 및 uint)에 대해서만 자동 데이터 변환을 수행하는 반면 equality 연산자는 모든 원시 데이터 유형에 대해 자동 데이터 변환을 수행합니다.
• null과 undefined를 비교할 때 strict equality 연산자는 false를 반환합니다.

먼저 ActionScript 3.0의 경우 원시 값과 동일한 값을 갖고 있는 원시 객체를 비교하면 true가 반환되지만 이전 버전에서는 false가 반환됩니다. 이전 버전의 경우 원시 값의 데이터 유형은 Boolean, Number 또는 String인 반면 원시 객체의 데이터 유형은 Boolean, Number 또는 String이 아니라 항상 Object입니다. 다음 코드를 통해 이 차이점의 실제 효과를 확인할 수 있습니다. 이전 버전의 ActionScript에서는 피연산자의 데이터 유형이 일치하지 않기 때문에 true가 반환되지만 ActionScript 3.0에서는 원시 값이 객체로 래핑되었는지 여부와 상관 없이 Boolean, Number, int, uint 또는 String 유형으로 지정되므로 false가 반환됩니다.

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 

관련 API 요소

strict equality(===) 연산자의 정반대 상황을 테스트합니다. strict inequality 연산자는 int 및 uint 데이터 유형이 변환되지 않는다는 점을 제외하면 inequality 연산자와 동일한 동작을 수행합니다.

expression1과 expression2가 동일하고 각각의 데이터 유형이 동일한 경우 그 결과는 false입니다.

strict inequality(!==) 연산자는 다음 세 가지 면에서 inequality(!=) 연산자와 동일합니다.

• 숫자 및 부울 값은 값을 기준으로 비교되고 값이 동일한 경우 서로 동일한 것으로 간주됩니다.
• 문자열 표현식은 문자가 동일하고 문자 수도 같은 경우 서로 동일한 것으로 간주됩니다.
• 객체, 배열 및 함수를 나타내는 변수는 참조를 기준으로 비교됩니다. 이러한 두 변수는 동일한 객체, 배열 또는 함수를 참조하는 경우 서로 동일한 것으로 간주됩니다. 별도의 두 배열은 포함된 요소의 수가 같더라도 동일한 것으로 간주되지 않습니다.

• strict inequality(!==) 연산자는 숫자 유형, 숫자, int 및 uint에 대해서만 자동 데이터 변환을 수행하는 반면 inequality(!=) 연산자는 모든 원시 데이터 유형에 대해 자동 데이터 변환을 수행합니다.
• null과 undefined를 비교할 때 strict inequality(!==) 연산자는 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 

관련 API 요소

 "text" 

문자의 앞/뒤에 사용하면 해당 문자에 리터럴 값이 있으므로 이 문자를 변수, 숫자 값 또는 다른 ActionScript 요소가 아니라 문자열로 간주해야 함을 나타냅니다.

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

관련 API 요소

-expression

 expression1 - expression2

부정하거나 빼는 데 사용됩니다.

구문 1: 부정에 사용되는 경우 이 연산자는 숫자 표현식의 부호를 반전시킵니다.

구문 1: 빼기에 사용되면 두 개의 숫자 표현식에서 산술 빼기를 수행하여 expression1에서 expression2를 뺍니다. 두 표현식이 모두 정수인 경우에는 빼기 결과도 정수이고 두 표현식 중 하나라도 부동 소수점 숫자인 경우에는 빼기 결과도 부동 소수점 숫자입니다.

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

trace(5 - 2); // 3 

다음 명령문은 부동 소수점 숫자 3.25에서 부동 소수점 숫자 1.5를 뺍니다.

trace(3.25 - 1.5); // 1.75 

expression1에 expression1 - expression2의 값을 대입합니다. 예를 들어, 다음 두 명령문은 동일합니다.

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 

관련 API 요소

[modifiers] var variableName:type

function functionName():type { ... }

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

데이터 유형 대입에 사용되는 이 연산자는 변수 유형, 함수 반환 유형 또는 함수 매개 변수 유형을 지정합니다. 이 연산자는 변수를 선언하거나 대입하는 데 사용되는 경우 해당 변수의 유형을 지정하고 함수를 선언하거나 정의하는 데 사용될 경우에는 해당 함수의 반환 유형을 지정합니다. 또한 함수 정의에서 함수 매개 변수와 함께 사용될 경우에는 해당 매개 변수에 필요한 변수 유형을 지정합니다.

유형 검사는 런타임에 항상 발생합니다. 그러나 컴파일러가 Strict 모드로 설정된 경우에는 컴파일 타임에 모든 유형이 검사되며, 일치하지 않는 유형이 있으면 오류가 생성됩니다. 대입 연산과 함수 호출 중 및 dot(.) 연산자를 사용하는 클래스 멤버의 참조를 해제하는 동안 유형 불일치가 발생할 수 있습니다.

사용할 수 있는 유형은 모든 기본 객체 유형, 사용자가 정의하는 클래스와 인터페이스 및 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)); 

관련 API 요소

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 

관련 API 요소

표현식을 평가한 후 그 값을 버리고 undefined를 반환합니다. void 연산자는 == 연산자를 사용한 비교를 통해 정의되지 않은 값을 테스트할 때 자주 사용됩니다.

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

XML 리터럴의 XML 태그를 정의합니다. 슬래시(/)를 사용하여 닫는 태그를 정의합니다.

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

관련 API 요소