수치식을 가산합니다. 양쪽 모두의 식이 정수의 경우, 합계는 정수가 됩니다. 몇개의 식 또는 양쪽 모두의 식이 부동 소수점수(실수)의 경우, 합계는 부동 소수점수(실수)가 됩니다.

1 개의 식이 string의 경우, 다른 식은 모두 string에 변환되어 가산 대신에 연결됩니다. 식이 string도 수치도 아닌 경우는, 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);

See also

expression1 에 expression1 + expression2 의 값을 할당합니다. 예를 들어, 다음의 2 개의 명령문(statement)는 같은 결과가 됩니다.

x += y; 
x = x + y;

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

See also

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

지정된 엘리먼트 (a0 등)로 새로운 배열 또는 다차원 배열을 초기화하는지, 배열내의 엘리먼트에 액세스 합니다. 배열 액세스 연산자를 사용하면, 인스턴스, 변수, 및 object명을 동적으로 설정 및 취득할 수 있습니다. 이 연산자를 사용해 object의 property에 액세스 할 수도 있습니다.

문장구조법 1 : 배열은, 엘리먼트로 불리는 property를 가지는 object입니다. 각 엘리먼트는 인덱스로 불리는 번호로 식별됩니다. 배열을 작성하는 경우는, 엘리먼트를 배열 액세스 연산자 ([]) (꺽쇄묶음)로 둘러쌉니다. 배열에는, 다양한 타입의 엘리먼트를 포함할 수 있습니다. 예를 들어, 다음의 배열 employee 에는 3 개의 엘리먼트가 있습니다. 최초의 엘리먼트는 수치, 2 번째와 3 번째의 엘리먼트는 string (인용부호내)입니다.

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

See also

최초의 오퍼랜드로 지정된 식이, 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

See also

expression2 의 값 (우측의 오퍼랜드)을 expression1 의 변수, 배열 엘리먼트, 또는 property에 할당합니다. 값에 의한 할당과 참조에 의한 할당이 있습니다. 값에 의한 할당에서는,expression2 의 실제의 값이 복사되어expression1 에 포함됩니다. 값에 의한 할당은,expression2 가 원시적인 값, 즉 데이터형이 Boolean, Number, int, uint, 또는 String 의 언젠가인 경우에 사용됩니다. 참조에 의한 할당에서는,expression2 에의 참조가 expression1 에 포함됩니다. 일반적으로, 참조에 의한 할당은 new 연산자와 조합해 사용됩니다. new 연산자에서는 메모리내에 object가 작성되어 그 object가 포함된 메모리 위치에의 참조를 변수에 할당할 수 있습니다.

메모 : ActionScript 3.0 에서는, 원시적인 값을 포함한 모든 값이 object이며, 모든 할당은 참조에 의해 행해집니다만, 원시적인 object에는 특별한 연산자가 있어, 값에 의한 할당과 같은 동작을 합니다.

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

See also

 myXML. @attributeName 

XML 또는 XMLList object의 속성을 식별합니다. 예를 들어,myXML. @id 에서는,myXML XML object의 id 라는 이름의 속성이 식별됩니다. 다음의 문장구조법 myXML.attribute("id"),myXML["@id"], 및 myXML. @["id"] 를 사용해, 속성에 액세스 할 수도 있습니다.. 추천 되는 문장구조법은 myXML. @id 입니다. 모든 속성명의 XMLList object를 돌려주려면,@* 를 사용합니다. ActionScript 의 예약어(reserved word)와 이름이 일치하는 속성을 돌려주려면 ,@ 연산자 대신에 attribute() Methods를 사용합니다.

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

See also

expression1 와 expression2 를 32 비트 부호 없음 정수로 변환해, 정수 Parameters를 비트 단위로 논리적 (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 

See also

expression1 에 expression1 & expression2 의 값을 할당합니다. 예를 들어, 다음의 2 개의 식은 같습니다.

x &= y; 
x = x & y; 

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

See also

expression1 와 shiftCount 를 32 비트 정수로 변환해,shiftCount 의 변환에 의해 생성된 정수로 지정되는 자리수만 expression1 내의 모든 비트를 왼쪽으로 쉬프트 합니다. 이 연산의 결과로서 empty로 되는 비트 위치에는, 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 명령문(statement)에서는, 비트를 왼쪽으로 3 비트 쉬프트 하고 있습니다.

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

See also

비트 단위의 왼쪽 쉬프트 (<<=) 연산을 실시해, 그 내용을 결과적으로 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 

See also

expression 를 32 비트 부호 첨부 정수로 변경해, 비트 단위로 1 의 보수를 적용합니다. 즉, 0 을 보관 유지하는 모든 비트는 1 으로 설정되어 1 을 보관 유지하는 모든 비트는 0 으로 설정됩니다. 결과는, 부호 첨부 32 비트 정수입니다. 이 연산자는, 1 의 보수 연산자 또는 비트 단위의 보수 연산자라고도 불립니다.

예를 들어, 0x7777 라고 하는 16 진수치는, 2 진수에서는 다음과 같이 표현됩니다.

0111011101110111

이 16 진수치를 비트 단위로 부호 반전 (~0x7777)하면, 다음의 2 진수가 됩니다.

1000100010001000

이것은, 16 진수의 0x8888 에 상당합니다. 따라서, ~0x7777 는 0x8888 가 됩니다.

비트 단위 연산자는, flag bit를 표현하는 경우에 가장 자주(잘) 사용됩니다 (불리언 값을 각각 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 

See also

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) 

See also

expression1 에 expression1 | expression2 의 값을 할당합니다. 예를 들어, 다음의 2 개의 명령문(statement)는 같습니다.

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) 

See also

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)

See also

비트 단위의 오른쪽 쉬프트 연산을 실시해, 결과를 expression 에 포함합니다.

다음의 2 개의 명령문(statement)는 등가입니다.

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. 

See also

좌측의 비트는 항상 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 

See also

비트 단위의 부호 없음 오른쪽 쉬프트 연산을 실시해, 결과를 expression 에 포함합니다. 다음의 2 개의 명령문(statement)는 등가입니다.

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

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

See also

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) 

See also

expression1 에 expression1 ^ expression2 의 값을 할당합니다. 예를 들어, 다음의 2 개의 명령문(statement)는 같습니다.

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) 

See also

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

See also

 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>

See also

 myXML[expression]

XML 또는 XMLList object의 property 또는 속성에 액세스 합니다. 괄호 연산자를 사용하면, 닷 (. ) 연산자로 액세스 할 수 없는 property명에 액세스 할 수 있습니다.

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

See also

식 expression1, 식 expression2,... 의 순서에 평가합니다. 통상, 이 연산자는 for 루프 명령문(statement)로 사용합니다. 괄호 () 연산자와 조합해 사용하는 일도 있습니다.

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 

See also

string를 연결 (결합)합니다. 어느 식이 string의 경우, 다른 식은 모두 string에 변환되어 연결됩니다.

양쪽 모두의 식이 수치인 경우, 이 연산자는 가산 연산자로서 동작합니다.

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 

See also

expression1 + expression2

XML 또는 XMLList 값를 XMLList object에 연결 (결합)합니다. 양쪽 모두의 오퍼랜드가 XML 또는 XMLList 값의 경우만, 결과가 XMLList object가 됩니다.

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 명령문(statement)의 출력은 다음과 같이 됩니다.

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

See also

expression1 에 expression1 + expression2 의 값을 할당합니다. 예를 들어, 다음의 2 개의 명령문(statement)는 같은 결과가 됩니다.

x += y; 
x = x + y;

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

See also

expression1 += expression2

XMLList object의 expression1 에 expression1 + expression2 의 값을 할당합니다. 예를 들어, 다음의 2 개의 명령문(statement)는 같은 결과가 됩니다.

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 명령문(statement)의 출력은 다음과 같이 됩니다.

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

<location>Springfield</location>

See also

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

See also

--expression

expression--

오퍼랜드로부터 1 을 감산합니다. 오퍼랜드는, 변수, 배열의 엘리먼트, 또는 object의 property입니다. 프리데크리먼트 형식의 연산자 (--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); 
}

See also

 delete reference

reference 에 의해 지정된 object property를 파기합니다. 처리 후에 property가 존재하지 않는 경우, 결과는 true 가 되어, 존재하는 경우는 false 가 됩니다. 존재하지 않는 property로 불려 갔을 경우,delete 연산자는 true 를 돌려줍니다.

reference Parameters를 삭제할 수 없는 경우,delete 연산자는 처리할 수 없기 때문에 false 를 돌려줍니다. 고정 property 또는 var 명령문(statement)로 선언된 변수는 삭제할 수 없습니다. 고정 property란, 클래스 정의로 정의되는 변수 또는 Methods입니다.

메모 : object를 삭제할 수 없습니다만, object에의 모든 참조를 삭제해, 가베지 콜렉션의 대상이 되는 object를 작성할 수 있습니다. 가장 일반적인 object에의 참조는, object를 참조하는 변수입니다. 이러한 참조는, 변수를 null 로 설정하는 것으로 삭제할 수 있습니다. 가베지 콜렉션에서는, 참조를 가지지 않는 object가 모두 삭제됩니다.

// 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 property의 값은 변경되지 않습니다.

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,

See also

 delete reference

reference 로 지정된 XML 엘리먼트 또는 속성을 삭제합니다.

XMLList 오퍼랜드는, empty의 경우에서도 항상 유효한 object를 참조하기 위해(때문에), XMLList 오퍼랜드와 함께 사용했을 경우,delete 연산자의 결과는 항상 true 가 됩니다.

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

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

delete x1.a. @id;

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

delete x1.b;

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

delete x1.a;

trace(x1.toXMLString());

출력은 다음과 같이 됩니다.

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

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

이 예의 출력은 다음과 같이 됩니다.

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

 myXML..childElement1..@attributeName 

XML 또는 XMLList object의 자손 엘리먼트로 이동합니다. @ 연산자와 함께 사용했을 경우는, 일치하는 자손의 속성을 검색합니다. 검색되는 엘리먼트나 속성은, XML 또는 XMLList object의 직접적인 child 뿐만이 아니라, 손자등의 트리내의 하위의 계층도 대상이 됩니다. 복수의 child 엘리먼트 또는 속성이 일치할 가능성이 있기 (위해)때문에, 결과는 XMLList object가 됩니다.

XMLList object내의 노드는, 깊이 우선 탐색의 결과순서에 돌려주어집니다. 다음에 예를 나타냅니다.

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 의 예약어(reserved word)와 이름이 일치하는 자손을 돌려주려면 , 다음의 예로 가리키도록(듯이), 자손 (..) 연산자 대신에 XML.descendants() Methods를 사용합니다.

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

See also

expression1 를 expression2 로 제산합니다. 제산 연산의 결과는 배정밀도의 부동 소수점수(실수)입니다.

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

See also

expression1 에 expression1 / expression2 의 값을 할당합니다. 예를 들어, 다음의 2 개의 명령문(statement)는 같습니다.

x /= y; 
x = x / y;

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

See also

object.property_or_method

클래스 변수 및 Methods에 액세스 해, object property의 취득 및 설정을 실시해, 읽힌 패키지 또는 클래스를 단락짓습니다.

import flash.utils.Timer;

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

See also

myXML.childElement
myXML. @attributeName 

XML 또는 XMLList object의 child 엘리먼트로 이동합니다. @ 연산자와 함께 사용했을 경우는, XML 또는 XMLList object의 속성을 돌려줍니다. 복수의 child 엘리먼트 또는 속성이 일치할 가능성이 있기 (위해)때문에, 돌려주어지는 object는 XMLList 가 됩니다.

ActionScript 의 예약어(reserved word)와 이름이 일치하는 엘리먼트를 돌려주려면 , 다음의 예로 가리키도록(듯이), XML 닷 (. ) 연산자 대신에 XML.elements() Methods 또는 XML.descendants() Methods를 사용합니다.

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

See also

2 개의 식의 등가성을 테스트합니다. 식이 동일한 경우, 결과는 true 입니다.

2 개의 오퍼랜드의 데이터형이 일치하는 경우, 등가의 정의는 오퍼랜드의 데이터형에 의해 정해집니다.

• int, uint, 및 Boolean 형의 값은, 값이 같은 경우에 동일하다고 보여집니다.
• Number 형은, 값이 같아 양쪽 모두 NaN 가 아닌 경우에 동일하다고 보여집니다.
• 2 개의 오퍼랜드의 값이 null 또는 undefined 의 경우는, 동일하다고 보여집니다.
• string식은, 캐릭터수가 같아, 같은 캐릭터로 구성되어 있는 경우에, 동일하다고 보여집니다.
• XML 오프제크트의 경우 :
  • 한편의 오퍼랜드가 텍스트 또는 속성 노드로, 이제(벌써) 한편의 오퍼랜드에 단순 내용이 포함되는 경우는, 오퍼랜드를 양쪽 모두 toString() Methods로 string로 변환해, 결과의 string가 일치하는 경우에 동일하다고 보여집니다.
  • 그 이외의 경우, object는, 양쪽 모두의 object의 수식명, 속성, 및 child property가 일치하는 경우에게만 동일하다고 보여집니다.
• XMLList object의 경우는, property의 수가 같아, property의 순서 및 값이 일치하는 경우에 동일하다고 보여집니다.
• Namespace object의 경우는, 양쪽 모두의 object의 uri property가 일치하는 경우에 값이 동일하다고 보여집니다.
• QName object의 경우는, 양쪽 모두의 object의 uri property 및 localName property가 일치하는 경우에 값이 동일하다고 보여집니다.
• object, 배열, 및 함수를 나타내는 변수는, 참조에 의해 비교됩니다. 2 개의 변수가 같은 object, 배열, 또는 함수를 참조하는 경우, 그러한 변수는 등가입니다. 2 개의 별개의 배열은, 엘리먼트수가 같은 경우에서도, 동일하다고는 보여지지 않습니다.

• 오퍼랜드의 값이 undefined 및 null 의 경우. 이 경우, 결과는 true 가 됩니다.
• 자동 데이터형 변환에 의해 String, Boolean, int, uint, 및 Number 의 데이터형의 값이 호환성이 있는 형태에 변환되어 변환된 값이 동일한 경우. 이 경우, 오퍼랜드는 동일하다고 보여집니다.
• 한편의 오퍼랜드가 단순 내용 (hasSimpleContent() == true)를 가지는 XML 형으로, 양쪽 모두의 오퍼랜드를 toString() Methods로 string로 변환해, 결과의 string가 일치하는 경우.
• 한편의 오퍼랜드가 XMLList 형으로, 다음의 몇개의 조건에 해당하는 경우.
  • XMLList 오프제크트의 length property가 0 으로, 이제(벌써) 한편의 object가 undefined 이다.
  • XMLList 오프제크트의 length property가 1 으로, XMLList object의 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 

See also

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

See also

property가 특정의 object의 일부일지 어떨지를 평가합니다. in 연산자를 사용하려면 , 최초의 오퍼랜드로서 property명을 지정해, 2 번째의 오퍼랜드로서 object를 지정합니다. 지정한 object에 해당의 property가 포함되어 있는 경우, 결과는 true 가 됩니다. 그 이외의 경우, 결과는 false 가 됩니다.

지정한 object가 Array object인 경우,in 연산자를 사용해 특정의 인덱스 번호가 유효한지 어떤지를 체크할 수 있습니다. 최초의 오퍼랜드로서 정수를 건네주는 경우, 인덱스가 유효한 인덱스 번호의 범위내에 있으면 결과는 true 가 되어, 그렇지 않은 경우는 false 가 됩니다.

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

다음의 예에서는,in 연산자를 사용해, 수치 0, 1, 및 2 가 myArray object의 유효한 인덱스 번호이며, 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

See also

++expression

 expression++

식에 1 을 가산합니다. 식은, 변수, 배열의 엘리먼트, 또는 object의 property입니다. 프리인크리먼트 형식의 연산자 (++expression)는, expression 에 1 을 가산해, 결과를 돌려줍니다. 포스트인크리먼트(increment) 형식의 연산자 (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 
*/

See also

등가 (==) 연산자의 정반대가 진일지 어떨지를 테스트합니다. expression1 가 expression2 에 동일한 경우, 결과는 false 가 됩니다. 등가 (==) 연산자의 경우와 같게, 등가의 정의는 비교하는 데이터형에 의해 다릅니다.

2 개의 오퍼랜드의 데이터형이 일치하는 경우, 등가의 정의는 오퍼랜드의 데이터형에 의해 정해집니다.

• int, uint, 및 Boolean 형의 값은, 값이 같은 경우에 동일하다고 보여집니다.
• Number 형은, 값이 같아 양쪽 모두 NaN 가 아닌 경우에 동일하다고 보여집니다.
• 2 개의 오퍼랜드의 값이 null 또는 undefined 의 경우는, 동일하다고 보여집니다.
• string식은, 캐릭터수가 같아, 같은 캐릭터로 구성되어 있는 경우에 동일하다고 보여집니다.
• XML 오프제크트의 경우 :
  • 한편의 오퍼랜드가 텍스트 또는 속성 노드로, 이제(벌써) 한편의 오퍼랜드에 단순 내용이 포함되는 경우는, 오퍼랜드를 양쪽 모두 toString() Methods로 string로 변환해, 결과의 string가 일치하는 경우에 동일하다고 보여집니다.
  • 그 이외의 경우, object는, 양쪽 모두의 object의 수식명, 속성, 및 child property가 일치하는 경우에게만 동일하다고 보여집니다.
• XMLList object의 경우는, property의 수가 같아, property의 순서 및 값이 일치하는 경우에 동일하다고 보여집니다.
• Namespace object의 경우는, 양쪽 모두의 object의 uri property가 일치하는 경우에 값이 동일하다고 보여집니다.
• QName object의 경우는, 양쪽 모두의 object의 uri property 및 localName property가 일치하는 경우에 값이 동일하다고 보여집니다.
• object, 배열, 및 함수를 나타내는 변수는, 참조에 의해 비교됩니다. 2 개의 변수가 같은 object, 배열, 또는 함수를 참조하는 경우, 그러한 변수는 등가입니다. 2 개의 별개의 배열은, 엘리먼트수가 같은 경우에서도, 동일하다고는 보여지지 않습니다.

• 오퍼랜드의 값이 undefined 및 null 의 경우. 이 경우, 결과는 true 가 됩니다.
• 자동 데이터형 변환에 의해 String, Boolean, int, uint, 및 Number 의 데이터형의 값이 호환성이 있는 형태에 변환되어 변환된 값이 동일한 경우. 이 경우, 오퍼랜드는 동일하다고 보여집니다.
• 한편의 오퍼랜드가 단순 내용 (hasSimpleContent() == true)를 가지는 XML 형으로, 양쪽 모두의 오퍼랜드를 toString() Methods로 string로 변환해, 결과의 string가 일치하는 경우.
• 한편의 오퍼랜드가 XMLList 형으로, 다음의 몇개의 조건에 해당하는 경우.
  • XMLList 오프제크트의 length property가 0 으로, 이제(벌써) 한편의 object가 undefined 이다.
  • XMLList 오프제크트의 length property가 1 으로, XMLList object의 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

See also

식의 prototype 체인에 function 의 prototype object가 포함될지 어떨지를 평가합니다. instanceof 연산자는, ECMAScript Edition 3 과의 후방 호환성을 유지하기 위해서 제공되고 있습니다만, prototype 체인을 사용하는 상급 프로그래머에게 있어 도움이 되는 경우가 있습니다. object가 특정의 데이터형의 멤버일지 어떨지를 체크하려면 ,is 연산자를 사용합니다.

메모 : ActionScript 의 is 연산자는, Java 의 instanceof 연산자와 같습니다.

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

See also

object에 특정의 데이터형, 클래스, 또는 인터페이스와 호환성이 있을지 어떨지를 평가합니다. instanceof 연산자 대신에,is 연산자를 사용해 형태의 비교를 실시합니다. is 연산자를 사용해, object에 인터페이스가 Implements되고 있는지 어떤지를 체크할 수도 있습니다.

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

See also

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

See also

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

See also

변수나 식의 불리언 값을 반전합니다. expression 가 변수로, 그 절대치 또는 변환된 값이 true 인 경우,! expression 의 값은 false 가 됩니다. 식 x && y 의 평가가 false 인 경우, 식 ! (x && y) 의 평가는 true 가 됩니다.

다음의 식은, 논리 부정 (! ) 연산자를 사용한 결과를 나타내고 있습니다.

! true 는 false 를 돌려주어,
! false 는 true 를 돌려줍니다.

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

See also

true 인 경우 또는 true 로 변환할 수 있는 경우는 expression1 를 돌려주어, 그렇지 않은 경우는 expression2 를 돌려줍니다. expression2 로 함수 호출을 사용하는 경우,expression1 의 평가 결과가 true 이면, 함수는 불려 가지 않습니다.

다음의 겉(표)에 나타내도록(듯이), 양쪽 모두의 오퍼랜드가 Boolean 형으로, 언젠가 또는 양쪽 모두의 식이 true 인 경우, 결과는 true 가 됩니다. 양쪽 모두의 식이 false 인 경우, 결과는 false 가 됩니다.

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

다음과 같이, 2 번째의 오퍼랜드에 함수 호출을 지정하면, 예기치 않은 결과가 생기는 경우가 있습니다. 연산자의 좌측의 식이 true 라고 평가되었을 경우, 우측의 식은 평가되지 않고 (함수 fx2() 는 불려 가지 않고 ), 좌측의 식의 결과만이 돌려주어집니다.

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

See also

expression1 를 expression2 로 나누었을 때의 잉여를 계산합니다. 몇개의 오퍼랜드가 수치가 아닌 경우는, 잉여 (%) 연산자에 의해 수치에의 변환이 시행됩니다.

잉여 연산 결과의 부호는, 피제수 (최초의 수치)의 부호와 일치합니다. 예를 들어,-4 % 3 으로 -4 % -3 의 평가 결과는 모두 -1 가 됩니다.

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

See also

expression1 에 expression1 % expression2 의 값을 할당합니다. 다음의 2 개의 명령문(statement)는 등가입니다.

x %= y; 
x = x % y; 

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

See also

2 개의 수치나 식을 곱셈합니다. 양쪽 모두의 식이 정수이면, 그 적은 정수입니다. 몇개의 식 또는 양쪽 모두의 식이 부동 소수점수(실수)이면, 그 적은 부동 소수점수(실수)가 됩니다.

trace(2*3); // 6 

trace(2.0 * 3.1416); // 6.2832 

See also

expression1 에 expression1 * expression2 의 값을 할당합니다. 예를 들어, 다음의 2 개의 식은 같습니다.

x *= y
x = x * y 

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

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

See also

namespace::property

namespace::method()

namespace::xmlObject.property

namespace::xmlObject. @attribute

property, Methods, XML property, 또는 XML 속성의 namespace를 식별합니다.

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

See also

클래스 인스턴스를 인스턴스화합니다. new 연산자를 클래스 또는 Class 형의 변수로 사용해, 클래스의 인스턴스를 작성할 수 있습니다. 일반적으로 new 연산자는, 클래스의 인스턴스를 작성하기 위해(때문에), 클래스 object로 사용합니다. 예를 들어, 명령문(statement) new Sprite() 에서는, Sprite 클래스의 인스턴스가 작성됩니다.

new 연산자를 사용해, 클래스에 포함(Embed)되어 있는 Assets과 관련지을 수도 있습니다. 포함(Embed)되어 있는 Assets이란, SWF 파일에 컴파일 되는 이미지, 사운드, 폰트등의 외부 object입니다. 포함(Embed)되어 있는 Assets은, 각각 고유의 포함(Embed)되어 있는 Assets 클래스에 의해 나타내집니다. 포함(Embed)되어 있는 Assets에 액세스 하려면 ,new 연산자를 사용해, 관련지을 수 있었던 클래스를 인스턴스화합니다. 다음에, 포함(Embed)되어 있는 Assets 클래스의 해당하는 Methods 및 property를 호출해, 포함(Embed)되어 있는 Assets을 조작합니다.

class 키워드는 아니고, Function object에 의해 클래스를 정의하는 경우는,new 연산자를 사용해, constructor　 　 함수에 근거하는 object를 작성할 수 있습니다. constructor　 　 함수를, 클래스의 constructor　 　 Methods와 혼동 하지 않게 주의해 주세요. constructor　 　 함수는,function 키워드에 의해 정의되는 Function object로, 클래스 정의의 일부에서는 없습니다. constructor　 　 함수를 사용해 object를 작성하는 경우는, 클래스 Inheritance 대신에, prototype Inheritance을 사용합니다.

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

See also

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

새로운 object를 작성해, 지정된 name 와 value 의 property 페어로 초기화합니다. 이 연산자를 사용하는 것은,new Object 문장구조법을 사용해 대입 연산자로 property 페어를 설정하는 것과 같습니다. 새롭게 작성되는 object의 prototype로서 범용의 Object object가 있습니다.

또, 플로우(flow)를 제어하는 명령문(statement) (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"; 

See also

(expression1 [, expression2])

(expression1, expression2)

function(parameter1,..., parameterN) 

Parameters에 대해서 그룹화 연산을 실행하는지, 복수의 식을 차례로 평가합니다. 또는, Parameters를 둘러싸, 인수로서 괄호의 전의 함수에 건네줍니다.

문장구조법 1 : 연산자가 실행되는 차례를 제어합니다. 괄호는 통상의 우선 순위를 무효로 해, 괄호내의 식을 최초로 평가합니다. 괄호가 네스트 되고 있는 경우는, 가장 안쪽의 괄호로부터 순서에 외측의 괄호로 내용이 평가됩니다.

문장구조법 2 : 칸마 단락의 일련의 식을 차례로 평가해, 마지막에 실행된 식의 결과를 돌려줍니다.

문장구조법 3 : Parameters를 둘러싸, 괄호의 전의 함수에 건네줍니다.

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 

See also

myXML. (expression)

ECMAScript for XML (E4X)의 XML 구조내의 식을 평가합니다. 예를 들어,myXML. (lastName == "Smith") 에서는, 이름이 lastName 로 값이 "Smith" 의 XML 엘리먼트가 식별됩니다. 결과는 XMLList object입니다.

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

See also

/pattern/flags

캐릭터의 전후를 둘러싸 사용하는 경우, 둘러싸인 캐릭터는 리터럴치를 나타내, 변수나 string, 그 외의 ActionScript 엘리먼트는 아니고, 정규 표현 (RegExp)이라고 보여집니다. 다만, 2 개이 연속한 slash (//)로 시작되는 경우는, 코멘트의 최초인 것을 나타냅니다.

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

See also

자동 데이터 변환을 실시하지 않고 , 2 개의 식이 동일한지 어떤지를 테스트합니다. 양쪽 모두의 식이, 그 데이터형도 포함해 동일한 경우, 결과는 true 가 됩니다.

엄밀한 등가 (===) 연산자는, 다음의 3 개의 점으로써 등가 (==) 연산자와 같습니다.

• 수치와 불리언 값은 값에 의해 비교되어 그러한 값이 같으면, 동일하다고 보여집니다.
• string식은, 캐릭터수가 같아, 같은 캐릭터로 구성되어 있는 경우에, 동일하다고 보여집니다.
• object, 배열, 및 함수를 나타내는 변수는, 참조에 의해 비교됩니다. 2 개의 변수가 같은 object, 배열, 또는 함수를 참조하는 경우, 그러한 변수는 등가입니다. 2 개의 별개의 배열은, 엘리먼트수가 같은 경우에서도, 동일하다고는 보여지지 않습니다.

• 엄밀한 등가 () 연산자는 Number, int, 및 uint 형만 자동 데이터 변환을 실시해, 등가 () 연산자는 모든 원시적 데이터형의 자동 데이터 변환을 실시합니다.
• null 와 undefined 를 비교하는 경우, 엄밀한 등가 연산자에서는 false 가 돌려주어집니다.

1 번째는, 원시적치와 같은 값을 가지는 원시적 object를 비교하는 경우입니다. ActionScript 3.0 에서는 true 가 돌려주어집니다만, 이전의 버젼에서는 false 가 돌려주어집니다. 이전의 버젼에서는, 원시적치의 데이터형은 Boolean, Number, 또는 String 의 어느쪽이든이었지만, 원시적 object의 데이터형은 Boolean, Number, 또는 String 는 아니고 Object 였습니다. 실질적인 차이로서 다음의 코드의 결과는, 이전의 버젼의 ActionScript 에서는 오퍼랜드의 데이터형이 일치하지 않기 때문에 false 가 됩니다만, ActionScript 3.0 에서는, object내에 랩 되고 있는지 어떤지에 관련되지 않고, 원시적치의 데이터형은 Boolean, Number, int, uint, 또는 String 의 언젠가이기 (위해)때문에, 결과는 true 가 됩니다.

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

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

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

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

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

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

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

See also

엄밀한 등가 (===) 연산자의 정반대가 진일지 어떨지를 테스트합니다. 엄밀한 등가 연산자는, int 및 uint 의 데이터형만이 변환된다고 하는 점 이외는 부등값연산자와 같습니다.

expression1 가 expression2 와 동일하고, 양쪽 모두의 데이터형이 같은 경우, 결과는 false 가 됩니다.

엄밀한 부등값 (! ==) 연산자는, 다음의 3 개의 점으로써 부등값 (! =) 연산자와 같습니다.

• 수치와 불리언 값은 값에 의해 비교되어 그러한 값이 같으면, 동일하다고 보여집니다.
• string식은, 캐릭터수가 같아, 같은 캐릭터로 구성되어 있는 경우에, 동일하다고 보여집니다.
• object, 배열, 및 함수를 나타내는 변수는, 참조에 의해 비교됩니다. 2 개의 변수가 같은 object, 배열, 또는 함수를 참조하는 경우, 그러한 변수는 등가입니다. 2 개의 별개의 배열은, 엘리먼트수가 같은 경우에서도, 동일하다고는 보여지지 않습니다.

• 엄밀한 부등값 (! ==) 연산자는 Number, int, 및 uint 형만 자동 데이터 변환을 실시해, 부등값 (! =) 연산자는 모든 원시적 데이터형의 자동 데이터 변환을 실시합니다.
• null 와 undefined 를 비교하는 경우, 엄밀한 부등값 (! ==) 연산자에서는 true 가 돌려주어집니다.

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

See also

 "text" 

캐릭터의 전후를 둘러싸 사용하는 경우, 둘러싸인 캐릭터는 리터럴치를 나타내, 변수나 수치, 그 외의 ActionScript 엘리먼트는 아니고, string라고 보여집니다.

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

See also

-expression

 expression1 - expression2

부호 반전이나 감산에 사용합니다.

문장구조법 1 : 부호 반전에 사용하는 경우, 식의 부호를 반대로 합니다.
문장구조법 2 : 감산에 사용하는 경우, 2 개의 식에 대해서 산술적인 감산을 실시해,expression1 로부터 expression2 를 감산합니다. 양쪽 모두의 식이 정수이면, 그 차이는 정수입니다. 몇개의 식 또는 양쪽 모두의 식이 부동 소수점수(실수)이면, 그 차이는 부동 소수점수(실수)입니다.

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

trace(5 - 2); // 3 

다음의 명령문(statement)는, 부동 소수점수(실수) 3.25 로부터 부동 소수점수(실수) 1.5 를 감산합니다.

trace(3.25 - 1.5); // 1.75 

See also

expression1 에 expression1 - expression2 의 값을 할당합니다. 예를 들어, 다음의 2 개의 명령문(statement)는 같습니다.

x -= y ;
x = x - y;

string식은 수치에 변환될 필요가 있습니다. 변환되지 않는 경우, 결과는 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 

See also

[modifiers] var variableName:type

function functionName() :type { ...}

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

데이터형을 할당하기 위해서(때문에) 사용합니다. 이 연산자는, 변수의 형태, 함수의 반환값의 형태, 또는 함수 Parameters의 형태를 지정합니다. 변수의 선언 또는 할당으로 사용하는 경우는, 변수의 형태를 지정합니다. 함수의 선언 또는 정의로 사용하는 경우는, 함수의 반환값의 형태를 지정합니다. 함수 정의의 함수 Parameters로 사용하는 경우는, 그 Parameters의 변수의 형태를 지정합니다.

형태 체크는 실행시에 반드시 행해집니다. 다만, 컴파일러가 strict 모드로 설정되어 있는 경우는, 컴파일시에도 모든 형태의 체크를 해 형태의 불일치가 있는 경우에 에러가 발생합니다. 형태의 불일치는, 할당 조작, 함수의 호출해, 닷 (. ) 연산자를 사용한 클래스 멤버의 역참조 시에 발생할 가능성이 있습니다.

사용할 수 있는 형태로서는, 모든 네이티브 object형, 독자적으로 정의한 클래스와 인터페이스, 및 void 가 있습니다. 인식되는 네이티브형에는, 불 (Boolean), 수치 (Number), 정수 (int), 부호 없음 정수 (uint), string (String)가 있습니다. 또, 모든 빌트인 클래스는, 네이티브형으로서 지원(support)됩니다.

데이터형을 할당하지 않는 경우, 변수, 함수의 반환값, 또는 함수의 Parameters는 형태 지정 없음이라고 보여져 어떠한 데이터형의 값도 받을 수가 있습니다. 형태 지정이 없는 값을 사용하는 것을 명시하려면 , 형태 주석에 asterisk (*) 캐릭터를 사용합니다. asterisk 캐릭터를 형태 주석에 사용하면, 변수, 함수의 반환값의 형태, 또는 함수의 Parameters의 형태를 지정하지 않는 것이라고 같은 것이 됩니다.

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

See also

expression 를 평가해, 식의 데이터형을 나타내는 string를 돌려줍니다. 결과는 6 개의 string치로 한정되어boolean,function,number,object,string, 및 xml 중 한쪽이 돌려주어집니다. 유저 정의 클래스의 인스턴스에 이 연산자를 적용하는 경우, 결과는 object 의 string가 됩니다. 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 

See also

식을 평가한 후, 그 값을 파기해,undefined 를 돌려줍니다. void 연산자는, 많은 경우,== 연산자를 사용해 undefined 값를 테스트하는 비교에 있어 사용합니다.

See also

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

XML 리터럴내의 XML 태그를 정의합니다. 종료 태그는 slash / 를 사용해 정의합니다.

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

See also