연산자 

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

한 표현식이 문자열이면 다른 표현식도 모두 더해지는 대신 문자열로 변환된 후 연결됩니다. 그렇지 않고 한 표현식이 숫자가 아닌 경우에는 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;