function functionName(parameter0, parameter1, ...rest){ 
	// 명령문
} 

함수가 쉼표로 구분된 인수를 무제한으로 받도록 지정합니다. 인수 목록은 함수 본문 어디에서나 사용할 수 있는 배열이 됩니다. 이 배열의 이름은 매개 변수 선언의 ... 문자 뒤에 지정됩니다. 매개 변수는 예약어가 아닌 어떤 이름이나 가질 수 있습니다.

다른 매개 변수와 함께 사용할 경우 ... (rest) 매개 변수 선언은 마지막 매개 변수로 지정해야 합니다. ... (rest) 매개 변수 배열은 함수에 전달된 인수의 수가 다른 매개 변수의 수를 초과한 경우에만 채워집니다.

쉼표로 구분된 인수 목록의 각 인수는 배열의 요소에 배치됩니다. Array 클래스의 인스턴스를 전달하면 전체 배열이 ... (rest) 매개 변수 배열의 단일 요소에 배치됩니다.

이 매개 변수를 사용하면 arguments 객체를 사용할 수 없습니다. ... (rest) 매개 변수는 arguments 배열 및 arguments.length 속성과 동일한 기능을 제공하지만 arguments.callee와 비슷한 기능은 제공하지 않기 때문입니다. ... (rest) 매개 변수를 사용하기 전에는 arguments.callee를 사용해야 할 일이 있는지 확인합니다.

package {
    import flash.display.MovieClip;
    
    public class RestParamExample extends MovieClip {
        public function RestParamExample() {
            traceParams(100, 130, "two"); // Output: 100,130,two
            trace(average(4, 7, 13));     // Output: 8
        }
    }
}


function traceParams(... rest) {
     trace(rest);
 }
 
function average(... args) : Number{
    var sum:Number = 0;
    for (var i:uint = 0; i < args.length; i++) {
        sum += args[i];
    }
    return (sum / args.length);
}

참고 사항

프로토타입 속성 대신 고정된 속성인 기본 ActionScript 클래스의 메서드와 속성을 정의합니다. "-as3" 컴파일러 옵션을 Flex Builder 2에서 기본 설정인 true로 설정하면 AS3 네임스페이스가 모든 기본 클래스에 대해 자동으로 열립니다. 즉, 기본 클래스의 인스턴스는 클래스의 프로토타입 객체에 첨부된 것과 동일한 속성 및 메서드 대신 고정된 속성 및 메서드를 사용합니다. 고정된 속성을 사용하면 일반적으로 성능이 향상되지만 ECMAScript 버전 3 언어 사양(ECMA-262)과의 호환성 비용이 늘어납니다.

참고 사항

루프(for, for..in, for each..in, do..while 또는 while) 내에 나타나거나 switch 문 내의 특정 case와 연관된 명령문 블록 내에 나타납니다. break 문은 루프에서 사용되면 루프 본문의 나머지를 건너뛰고, 루핑 액션을 중단하고 루프 문 다음의 명령문을 실행하도록 Flash에 지시합니다. break 문은 switch에서 사용되면 해당 case 블록에서 명령문의 나머지를 건너뛰고 포함 switch 문 다음의 첫 번째 명령문으로 이동합니다.

중첩 루프에서 break 문은 즉시 루프의 나머지만을 건너뛰고 일련의 전체 중첩 루프에서 빠져 나오지 않습니다. 전체 중첩 루프에서 벗어나려면 label 또는 try..catch..finally를 사용합니다.

break 문에는 레이블된 외부 명령문과 일치하는 레이블을 선택적으로 사용할 수 있습니다. 외부 명령문의 레이블과 일치하지 않는 레이블을 사용하면 구문 오류가 발생합니다. 레이블된 break 문은 여러 레벨의 중첩 루프 명령문, switch 문 또는 block 문을 빠져 나올 때 사용할 수 있습니다. label 문에 대한 항목을 예로 들어 보겠습니다.

var i:int = 0;
while (true) { 
    trace(i); 
    if (i >= 10) { 
        break; // this will terminate/exit the loop 
    } 
    i++; 
} 
/* output:
0 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10*/

참고 사항

case jumpTarget: statements

switch 문의 이동 대상을 정의합니다. jumpTarget 매개 변수가 완전 항등(===)을 사용하는 switch 문의 expression 매개 변수와 동일하면 Flash Player는 break 문 또는 switch 문의 끝을 만날 때까지 statements 매개 변수에서 명령문을 실행합니다.

switch 문 외부에서 case 문을 사용하면 오류가 발생하고 스크립트가 컴파일되지 않습니다.

중요: statements 매개 변수는 항상 break 문으로 끝납니다. statements 매개 변수에서 break 문을 생략하면 switch 문을 종료하는 대신 다음 case 문이 계속해서 실행됩니다.

var thisMonth:int = new Date().getMonth(); 
switch (thisMonth) { 
    case 0 : 
        trace("January"); 
        break; 
    case 1 : 
        trace("February"); 
        break; 
    case 5 : 
    case 6 : 
    case 7 : 
        trace("Some summer month"); 
        break; 
    case 8 : 
        trace("September"); 
        break; 
    default : 
        trace("some other month"); 
}

참고 사항

[dynamic] [public | internal] [final] class className [ extends superClass ] [ implements interfaceName[, interfaceName... ] ] { 
	// 여기에 클래스가 정의됩니다.
}

사용자가 정의한 메서드와 속성을 공유하는 객체를 인스턴스화하는 데 사용할 수 있는 클래스를 정의합니다. 예를 들어, 청구서 추적 시스템을 개발하는 경우 각 송장에 포함해야 할 모든 메서드와 속성을 정의하는 Invoice 클래스를 만들 수 있습니다. 그런 다음, new Invoice() 명령을 사용하여 Invoice 객체를 만듭니다.

각 ActionScript 소스 파일에는 다른 소스 파일 또는 스크립트에서 액세스할 수 있는 클래스를 하나만 포함할 수 있습니다. 외부에서 액세스할 수 있는 클래스는 공용 또는 내부 클래스이며 반드시 패키지 문 내부에 정의해야 합니다. 동일한 파일에 다른 클래스를 포함하는 경우 이러한 클래스는 패키지 문의 외부 즉, 파일의 끝에 배치해야 합니다.

외부에서 액세스할 수 있는 클래스의 이름은 해당 클래스가 포함된 ActionScript 소스 파일의 이름과 일치해야 합니다. 소스 파일의 이름은 파일 확장명 .as가 추가된 클래스 이름이어야 합니다. 예를 들어, 클래스 이름을 Student로 지정하면 이 클래스를 정의하는 파일의 이름은 Student.as로 지정해야 합니다.

클래스 정의를 중첩할 수 없습니다. 즉, 클래스 정의 내에 다른 클래스를 정의할 수 없습니다.

클래스의 새 인스턴스가 만들어질 때마다 실행되는 생성자 메서드를 정의할 수 있습니다. 생성자 메서드의 이름은 클래스의 이름과 일치해야 합니다. 생성자 메서드를 정의하지 않으면 기본 생성자가 자동으로 만들어집니다.

객체가 런타임에 동적 속성을 추가하거나 액세스할 수 있음을 나타내려면 class 문 앞에 dynamic 키워드를 지정합니다. 클래스가 인터페이스를 구현함을 선언하려면 implements 키워드를 사용합니다. 클래스의 하위 클래스를 만들려면 extends 키워드를 사용합니다. 클래스는 하나의 클래스만 확장할 수 있지만 여러 인터페이스를 구현할 수 있습니다. implements와 extends를 하나의 명령문에 사용할 수 있습니다. 다음 예제에서는 implements 및 extends 키워드의 일반적인 사용법을 보여줍니다.

class C implements Interface_i, Interface_j // OK 
class C extends Class_d implements Interface_i, Interface_j // OK 
class C extends Class_d, Class_e // not OK 

// Filename Plant.as 
package {
  public class Plant { 
    // Define property names and types 
    private var _leafType:String; 
    private var _bloomSeason:String; 
    // Following line is constructor 
    // because it has the same name as the class 
    public function Plant(param_leafType:String, param_bloomSeason:String) { 
        // Assign passed values to properties when new Plant object is created 
        _leafType = param_leafType; 
        _bloomSeason = param_bloomSeason; 
    } 
    // Create methods to return property values, because best practice 
    // recommends against directly referencing a property of a class 
    public function get leafType():String { 
        return _leafType; 
    } 
    public function get bloomSeason():String { 
        return _bloomSeason; 
    } 
  }
}

var pineTree:Plant = new Plant("Evergreen", "N/A"); 
// Confirm parameters were passed correctly 
trace(pineTree.leafType); 
trace(pineTree.bloomSeason); 

참고 사항

const identifier = value 

값을 한 번만 대입할 수 있는 변수인 상수를 지정합니다.

데이터 유형 앞에 콜론(:) 문자를 추가하면 상수를 고정 유형으로 지정할 수 있습니다.

const MIN_AGE:int = 21;
MIN_AGE = 18; // error

const product_array:Array = new Array("Studio", "Dreamweaver", "Flash", "ColdFusion", "Contribute", "Breeze"); 
product_array.push("Flex"); // array operations are allowed
product_array = ["Other"];  // assignment is an error
trace(product_array); 

참고 사항

continue [label]

가장 안쪽의 루프에 남아 있는 명령문을 모두 전달하고 제어가 루프의 끝까지 정상적으로 전달된 것처럼 루프의 다음 반복을 시작합니다. continue 문은 루프 외부에는 적용되지 않습니다. 중첩 루프에서 선택적 label 매개 변수를 사용하여 가장 안쪽의 루프를 제외한 모든 루프를 건너뜁니다.

continue 문은 외부 레이블된 명령문과 일치해야 하는 선택적 레이블을 가질 수 있습니다. 외부 명령문의 레이블과 일치하지 않는 레이블을 사용하면 구문 오류가 발생합니다. 레이블된 continue 문을 사용하여 여러 레벨의 중첩 루프 명령문을 건너뛸 수 있습니다.

var i:int = 0; 
while (i < 10) { 
    if (i % 3 == 0) { 
        i++; 
        continue; 
    } 
    trace(i); 
    i++; 
}

for 루프에서도 continue 문을 사용하여 루프 본문의 나머지를 건너뛸 수 있습니다. 다음 예제에서는 i % 3이 0과 같은 경우 trace(i) 문이 생략됩니다.

 
for (var i:int = 0; i < 10; i++) { 
    if (i % 3 == 0) { 
        continue; 
    } 
    trace(i); 
}

참고 사항

default: statements 

switch 문에 대한 기본 case를 정의합니다. switch 문의 expression 매개 변수가 해당 switch 문의 case 키워드를 따르는 expression 매개 변수와 하나도 동일하지 않으면(완전 항등[===] 연산자 사용) 명령문이 실행됩니다.

switch 문에서는 default case 문이 필요하지 않습니다. default case 문을 목록의 마지막에 배치할 필요도 없습니다. default 문을 switch 문 외부에 사용하면 오류가 발생하고 스크립트가 컴파일되지 않습니다.

var dayOfWeek:int = new Date().getDay(); 
switch (dayOfWeek) { 
    case 1 : 
        trace("Monday"); 
        break; 
    case 2 : 
        trace("Tuesday"); 
        break; 
    case 3 : 
        trace("Wednesday"); 
        break; 
    case 4 : 
        trace("Thursday"); 
        break; 
    case 5 : 
        trace("Friday"); 
        break; 
    default : 
        trace("Weekend"); 
}

참고 사항

default xml namespace 지시문은 XML 객체에 사용할 기본 네임스페이스를 설정합니다.

default xml namespace를 설정하지 않은 경우 기본 네임스페이스는 이름이 지정되지 않은 네임스페이스(빈 문자열로 설정된 URI 포함)입니다. default xml namespace 선언의 범위는 변수의 범위와 마찬가지로 함수 블록 내입니다.

var nsDefault1:Namespace = new Namespace("http://www.example.com/namespaces/");
default xml namespace = nsDefault1;
        
var x1:XML = <test1 />;
trace("x1 ns: " + x1.namespace());
            
scopeCheck();    

var x2:XML = <test2 />;
trace("x2 ns: " + x2.namespace());
        
function scopeCheck(): void {
    
    var x3:XML = <test3 />;
    trace("x3 ns: " + x3.namespace());
                
    var nsDefault2:Namespace = new Namespace("http://schemas.xmlsoap.org/soap/envelope/");
    default xml namespace = nsDefault2;
            
    var x4:XML = <test4 />;
    trace("x4 ns: " + x4.namespace());

}

이 예제의 trace() 출력은 다음과 같습니다.

x1 ns: http://www.example.com/namespaces/
x3 ns: 
x4 ns: http://schemas.xmlsoap.org/soap/envelope/
x2 ns: http://www.example.com/namespaces/

var nsDefault:Namespace = new Namespace("http://www.example.com/namespaces/");
default xml namespace = nsDefault;
            
var x1:XML = <test1 />;

trace(x1.namespace());
    // http://www.example.com/namespaces/

var x2:XML = <test2 xmlns = "http://www.w3.org/1999/XSL/Transform/" />;
trace(x2.namespace());
    // http://www.w3.org/1999/XSL/Transform/

var x3:XML = <test3 xmlns:soap-env="http://schemas.xmlsoap.org/soap/envelope/" />;
trace(x3.namespace());
    // http://www.example.com/namespaces/

참고 사항

do { statement(s) } while (condition)

조건을 처음 평가하기 전에 명령문이 한 번 실행된다는 점을 제외하고는 while 루프와 유사합니다. 그 후에 명령문은 조건이 true로 평가된 경우에만 실행됩니다.

do..while 루프를 사용하면 루프 내의 코드가 한 번 이상 실행됩니다. while 루프를 사용하고 실행할 명령문의 복사본을 while 루프가 시작되기 전에 배치하여도 같은 결과를 얻을 수 있지만 대부분의 프로그래머는 do..while 루프가 더 읽기 쉽다고 생각하고 있습니다.

조건이 항상 true로 평가되면 do..while 루프는 무한 루프입니다. 무한 루프 상태가 되면 Flash Player에 문제가 발생하여 경고 메시지가 나타나거나 플레이어에서 충돌이 발생할 수 있습니다. 루핑할 횟수를 아는 경우에는 가능하면 for 루프를 사용합니다. for 루프는 읽기 및 디버그가 쉽지만 모든 상황에서 do..while 루프를 대체할 수 있는 것은 아닙니다.

var myVar:Number = 0; 
do { 
    trace(myVar); 
    myVar++; 
} 
while (myVar < 5); 
/* output: 
0 
1 
2 
3 
4
*/

참고 사항

dynamic class className { // 여기에 클래스 정의를 입력하십시오.}

클래스의 인스턴스가 런타임에 추가되는 동적 속성을 가질 수 있도록 지정합니다. 클래스에서 dynamic 속성을 사용하는 경우 런타임에 속성을 해당 클래스의 인스턴스에 추가할 수 있습니다. dynamic으로 표시되지 않은 클래스는 속성을 클래스의 인스턴스에 추가할 수 없는 봉인된 클래스로 간주됩니다.

동적 클래스가 아닌 봉인된 클래스의 경우 클래스 인스턴스에 속성을 가져오거나 설정하려고 하면 오류가 발생합니다. 컴파일러를 Strict 모드로 설정하고 데이터 유형을 지정한 경우 인스턴스를 만들 때 봉인된 객체에 속성을 추가하려고 시도하면 컴파일러 오류가 발생하며, 컴파일러 오류가 발생하지 않은 경우에는 런타임 오류가 발생합니다.

dynamic 속성은 하위 클래스에 상속되지 않습니다. 동적 클래스를 확장한 경우에는 dynamic 속성을 사용하여 하위 클래스를 선언해야만 하위 클래스가 동적 클래스가 됩니다.

package {

    dynamic class Expando  {
    }
    
    class Sealed {
    }
}

var myExpando:Expando = new Expando();
myExpando.prop1 = "new";
trace(myExpando.prop1); // output: new

var mySealed:Sealed = new Sealed();
mySealed.prop1 = "newer"; // error

참고 사항

if (condition) {
	// 명령문
} 
else {
	// 명령문
}

if 문의 조건이 false를 반환하는 경우 실행할 명령문을 지정합니다. else 문이 실행할 명령문을 둘러싸는 중괄호({})는 하나의 명령문만을 실행할 경우에는 필요하지 않습니다.

if (age_txt.text>=18) { 
    trace("welcome, user"); 
} 
else { 
    trace("sorry, junior"); 
    userObject.minor = true; 
    userObject.accessAllowed = false;
}

if (age_txt.text>18) { 
    trace("welcome, user");
} 
else trace("sorry, junior");

if (score_txt.text>90) { 
    trace("A"); 
} 
else if (score_txt.text>75) { 
    trace("B"); 
} 
else if (score_txt.text>60) { 
    trace("C"); 
} 
else { 
    trace("F"); 
}

참고 사항

class className extends otherClassName {}
interface interfaceName extends otherInterfaceName {} 

다른 클래스의 하위 클래스인 클래스를 정의합니다. 하위 클래스는 수퍼 클래스에 정의된 모든 메서드, 속성, 함수 등을 상속합니다. final로 표시된 클래스는 확장할 수 없습니다.

또한 extends 키워드를 사용하여 인터페이스를 확장할 수 있습니다. 다른 인터페이스를 확장하는 인터페이스는 원본 인터페이스의 모든 메서드 선언을 포함합니다.

다음 예제에서는 Vehicle 클래스를 정의하는 Vehicle.as 파일의 내용을 보여 줍니다.

package {
    class Vehicle { 
        var numDoors:Number; 
        var color:String; 
        public function Vehicle(param_numDoors:Number = 2, param_color:String = null) { 
            numDoors = param_numDoors; 
            color = param_color; 
        } 
        public function start():void { 
            trace("[Vehicle] start"); 
        } 
        public function stop():void { 
            trace("[Vehicle] stop"); 
        } 
        public function reverse():void { 
            trace("[Vehicle] reverse"); 
        } 
    }    
}

package {

    public class Car extends Vehicle { 
        var fullSizeSpare:Boolean; 
        public function Car(param_numDoors:Number, param_color:String, param_fullSizeSpare:Boolean) { 
            numDoors = param_numDoors; 
            color = param_color; 
            fullSizeSpare = param_fullSizeSpare; 
        } 
        public function activateCarAlarm():void { 
            trace("[Car] activateCarAlarm"); 
        } 
        public override function stop():void { 
            trace("[Car] stop with antilock brakes"); 
        } 
    }
}

var myNewCar:Car = new Car(2, "Red", true); 
myNewCar.start(); // output: [Vehicle] start 
myNewCar.stop(); // output: [Car] stop with anti-lock brakes 
myNewCar.activateCarAlarm(); // output: [Car] activateCarAlarm

또한 super 문을 사용하여 Vehicle 클래스의 하위 클래스를 작성할 수 있으며, 이 하위 클래스를 사용하여 수퍼 클래스의 생성자에 액세스할 수 있습니다. 다음 예제에서는 역시 같은 디렉토리에서 세 번째 ActionScript 파일인 Truck.as 파일을 보여 줍니다. Truck 클래스는 생성자와 재정의된 reverse() 메서드에서 super를 사용합니다.

package {
    class Truck extends Vehicle {
        var numWheels:Number;
        public function Truck(param_numDoors:Number, param_color:String, param_numWheels:Number) { 
            super(param_numDoors, param_color); 
            numWheels = param_numWheels; 
        } 
        public override function reverse():void { 
            beep();
            super.reverse();
        } 
        public function beep():void { 
            trace("[Truck] make beeping sound"); 
        } 
    }
}

var myTruck:Truck = new Truck(2, "White", 18); 
myTruck.reverse(); // output: [Truck] make beeping sound [Vehicle] reverse 
myTruck.stop(); // output: [Vehicle] stop

참고 사항

false

false를 나타내는 부울 값입니다. 부울 값은 true 또는 false이며, false의 반대는 true입니다.

자동 데이터 유형 지정 기능이 false를 숫자로 변환하면 0이 됩니다. false를 문자열로 변환하면 "false"가 됩니다.

중요: 문자열 "false"는 부울 값 true로 변환됩니다.

var bool1:Boolean = Boolean(false);

// converts it to the number 0
trace(1 + bool1); // outputs 1

// converts it to a string
trace("String: " + bool1); // outputs String: false

다음 예제에서는 문자열 "false"가 부울 값 true로 변환되는 것을 보여 줍니다.

trace(Boolean("false")); // output: true

if ("false") {
    trace("condition expression evaluated to true");
}
else {
    trace("condition expression evaluated to false");
}
// output: condition expression evaluated to true

참고 사항

final function methodName() { 
	// 여기에 명령문을 입력하십시오.
}
final class className {}

메서드 재정의 또는 클래스 확장을 수행할 수 없도록 지정합니다. final로 표시된 메서드를 재정의하거나 클래스를 확장하려고 시도하면 오류가 발생합니다.

참고 사항

Proxy 클래스의 메서드를 정의합니다. Proxy 하위 클래스에 Proxy 클래스 메서드와 일치하는 인스턴스 메서드 이름이 포함된 경우 발생할 수 있는 이름 충돌을 피하기 위해 Proxy 클래스 메서드는 자체 네임스페이스에 있습니다.

참고 사항

for ([init]; [condition]; [next]) { 
	// 명령문
}

init(초기화) 표현식을 한 번 평가한 다음 루핑 시퀀스를 시작합니다. 루핑 시퀀스는 condition 표현식을 평가하여 시작합니다. condition 표현식이 true로 평가되면 statement가 실행되고 next가 평가됩니다. 그런 다음, condition 표현식을 평가하여 루핑 시퀀스가 다시 시작됩니다.

for 문이 실행할 명령문 블록을 둘러싸는 중괄호({})는 하나의 명령문만을 실행할 경우에는 필요하지 않습니다.

var my_array:Array = new Array(); 
for (var i:Number = 0; i < 10; i++) { 
    my_array[i] = (i + 5) * 10;  
} 
trace(my_array); // output: 50,60,70,80,90,100,110,120,130,140 

var sum:Number = 0; 
for (var i:Number = 1; i <= 100; i++) { 
    sum += i; 
} 
trace(sum); // output: 5050

var sum:Number = 0; 
for (var i:Number = 1; i <= 100; i++) 
    sum += i; 
trace(sum); // output: 5050

참고 사항

for (variableIterant:String in object){ 
	// 명령문
} 

객체의 동적 속성이나 배열 요소를 반복 실행하고 각 속성이나 요소에 대해 statement를 실행합니다. 객체 속성 간에 특정한 순서가 있는 것은 아니므로 속성은 임의의 순서에 따라 나타날 수 있습니다. 클래스에 정의된 변수 및 메서드와 같이 고정된 속성은 for..in 문으로 열거되지 않습니다. 고정된 속성 목록을 얻으려면 flash.utils 패키지에 있는 describeType() 함수를 사용합니다.

var myObject:Object = {firstName:"Tara", age:27, city:"San Francisco"}; 
for (var prop in myObject) { 
    trace("myObject."+prop+" = "+myObject[prop]); 
} 
/* output:
myObject.firstName = Tara 
myObject.age = 27 
myObject.city = San Francisco
*/

var myObject:Object = {firstName:"Tara", age:27, city:"San Francisco"}; 
for (var name in myObject) { 
    if (typeof (myObject[name]) == "string") { 
        trace("I have a string property named "+name); 
    } 
}
/* output:
I have a string property named city
I have a string property named firstName
*/

참고 사항

for each (variableIterant in object){ 
	// 명령문
} 

컬렉션의 항목을 반복하고 각 항목에 대해 statement를 실행합니다. E4X 언어 확장의 일부로 도입된 for each..in 문은 XML 객체뿐만 아니라 객체 및 배열에 대해서도 사용할 수 있습니다. for each..in 문은 객체의 속성 중 고정된 속성은 제외하고 동적 속성만 반복합니다. 고정된 속성은 클래스 정의의 일부로 정의된 속성입니다. for each..in 문을 사용자 정의 클래스의 인스턴스와 함께 사용하려면 dynamic 속성을 사용하여 클래스를 선언해야 합니다.

for..in 문과는 달리 for each..in 문은 속성 이름 대신 객체의 속성 값을 반복합니다.

var myObject:Object = {firstName:"Tara", age:27, city:"San Francisco"}; 
for each (var item in myObject) { 
    trace(item); 
} 
/* output:
Tara
27
San Francisco
*/

var myArray:Array = new Array("one", "two", "three"); 
for each(var item in myArray) 
    trace(item); 
/* output: 
one
two
three
*/

var myObject:Object = {firstName:"Tara", age:27, city:"San Francisco"}; 
for each (var item in myObject) { 
    if (item is String) {  
        trace("I have a string property with value " + item); 
    } 
}

/* output:
I have a string property with value Tara
I have a string property with value San Francisco
*/

var doc:XML = 
        <body>
            <p>Hello</p>
            <p>Hola</p>
            <hr />
            <p>Bonjour</p>
        </body>;
for each (var item in doc.p) {
    trace(item);
}

/* output:
Hello
Hola
Bonjour
*/

참고 사항

function functionName([parameter0, parameter1,...parameterN]) : returnType{ 
	// 명령문
} 
var functionName:Function = function ([parameter0, parameter1,...parameterN]) : returnType{ 
	// 명령문
} 

특정 작업을 수행하기 위해 정의하는 일련의 명령문을 구성합니다. 특정 위치에서 함수를 정의하거나 SWF 파일 내의 다른 스크립트에서 함수를 호출할 수 있습니다. 함수를 정의할 때 해당 함수의 매개 변수도 지정할 수 있습니다. 매개 변수는 함수가 적용되는 값에 대한 자리 표시자입니다. 다른 상황에서 함수를 다시 사용할 수 있도록 함수를 호출할 때마다 함수에 다른 매개 변수를 전달할 수 있습니다.

함수의 statement(s) 블록에서 return 문을 사용하여 함수가 값을 생성하거나 반환하도록 할 수 있습니다.

구문 1: function 키워드를 사용하여 지정된 함수 이름, 매개 변수 및 명령문을 가진 함수를 정의할 수 있습니다. 스크립트에서 함수를 호출하면 함수 정의의 명령문이 실행됩니다. 전방 참조가 허용되므로 같은 스크립트 내에서 함수를 먼저 호출한 후에 선언할 수 있습니다. 함수 정의는 동일한 함수의 이전 정의를 모두 대체합니다. 명령문을 사용할 수 있으면 어디에서나 이 구문을 사용할 수 있습니다.

구문 2: function을 사용하여 익명 함수를 만들고 해당 함수에 대한 참조를 반환할 수도 있습니다. 이 구문은 표현식에 사용되며 특히 객체에 메서드를 설치하는 데 유용합니다.

추가 기능을 사용하려면 함수 정의에서 arguments 객체를 사용하면 됩니다. arguments 객체는 일반적으로 매개 변수의 변수 번호를 승인하는 함수를 만들고 익명의 순환 함수를 만드는 데 사용됩니다.

function sqr(xNum:Number) { 
    return Math.pow(xNum, 2); 
} 
var yNum:Number = sqr(3); 
trace(yNum); // output: 9

var yNum:Number = sqr(3); 
trace(yNum); // output: 9 
function sqr(xNum:Number) { 
    return Math.pow(xNum, 2); 
}

참고 사항

function get property() : returnType{ 
	// 여기에 명령문을 입력하십시오.
}

속성처럼 읽을 수 있는 메서드인 getter를 정의합니다. getter는 var 또는 const 키워드로 선언된 속성 값을 반환하는 특수 함수입니다. 다른 메서드와는 달리 getter는 괄호(()) 없이 호출되므로 변수처럼 보입니다.

getter를 사용하면 전용 속성에 대한 공용 인터페이스를 만들어서 정보 은폐 원칙을 적용할 수 있습니다. 정보 은폐 기술을 사용하면 전용 속성의 기본 구현이 변경되더라도 공용 인터페이스를 그대로 유지할 수 있습니다.

또한 var 또는 const로 선언된 속성은 하위 클래스에서 재정의할 수 없는 반면 getter는 하위 클래스에서 재정의할 수 있습니다.

getter와 setter를 결합하여 읽기/쓰기 속성을 만들 수 있습니다. 읽기 전용 속성을 만들려면 해당 setter는 만들지 않고 getter만 만듭니다. 쓰기 전용 속성을 만들려면 해당 getter는 만들지 않고 setter만 만듭니다.

package {
    public class Team { 
        var teamName:String; 
        var teamCode:String; 
        var teamPlayers:Array = new Array(); 
        public function Team(param_name:String, param_code:String) { 
            teamName = param_name; 
            teamCode = param_code; 
        } 
        public function get name():String { 
            return teamName; 
        } 
        public function set name(param_name:String):void { 
            teamName = param_name; 
        }
    } 
}

var giants:Team = new Team("San Fran", "SFO"); 
trace(giants.name); 
giants.name = "San Francisco"; 
trace(giants.name); 
/* output: 
San Fran San Francisco */

giants.name을 추적할 경우 getter 메서드를 사용하여 속성 값을 반환합니다.

참고 사항

if (condition) {
	// 명령문
}

조건을 평가하여 다음에 실행할 명령문을 결정합니다. 조건이 true이면 중괄호({}) 안에서 조건 뒤에 있는 명령문이 실행됩니다. 조건이 false이면 중괄호 안의 명령문을 건너뛰고 중괄호 다음의 명령문이 실행됩니다. if 문을 else 문과 함께 사용하면 스크립트에 분기 논리를 만들 수 있습니다.

if 문이 실행할 명령문을 둘러싸는 중괄호({})는 하나의 명령문만을 실행할 경우에는 필요하지 않습니다.

참고 사항

myClass implements interface01 [, interface02 , ...] 

클래스가 하나 이상의 인터페이스를 구현하도록 지정합니다. 클래스가 인터페이스를 구현할 때 클래스는 인터페이스에 선언된 모든 메서드를 정의해야 합니다. 인터페이스를 구현한 클래스의 모든 인스턴스는 인터페이스에 정의된 데이터 유형의 멤버로 간주됩니다. 결과적으로 is 연산자는 클래스 인스턴스가 첫 번째 피연산자이고 인터페이스가 두 번째 피연산자일 때 true를 반환하며, 인터페이스에 정의된 데이터 유형과의 강제 형 변환이 수행됩니다.

중요: 이 키워드를 사용하려면 FLA 파일의 [제작 설정] 대화 상자에 있는 [Flash] 탭에서 ActionScript 2.0 및 Flash Player 6 이상을 지정해야 합니다. 이 키워드는 외부 스크립트 파일에 사용되는 경우에만 지원되고 [액션] 패널에서 작성된 스크립트에는 사용할 수 없습니다.

참고 사항

import packageName.className 
import packageName.*

외부적으로 정의된 클래스 및 패키지를 코드에서 사용할 수 있도록 만듭니다. 예를 들어, flash.display.Sprite 클래스를 스크립트에서 사용하려면 해당 클래스를 가져와야 합니다. 이 요구 사항은 이전 버전의 ActionScript에서 달라진 것입니다. 이전 버전에서는 import 지시문이 선택 사항이었습니다.

import 지시문을 사용한 후에는 클래스 이름만 포함되거나 패키지 이름이 포함된 전체 클래스 이름을 사용할 수 있습니다.

 
import flash.display.Sprite; 

// name of class only
var mySprite:Sprite = new Sprite();

// full class name
var mySprite:flash.display.Sprite = new flash.display.Sprite();

액세스하려는 패키지에 여러 개의 클래스가 있으면 다음 예제에서처럼 해당 파일을 모두 하나의 명령문으로 가져올 수 있습니다.

import flash.display.*;

import 지시문은 가져온 패키지의 최상위에 있는 클래스, 함수 및 변수만을 가져옵니다. 중첩 패키지는 명시적으로 가져와야 합니다.

클래스를 가져왔지만 스크립트에서 사용하지 않는 경우 클래스는 SWF 파일의 일부로 내보내지지 않습니다. 따라서 대규모의 패키지를 가져올 때 SWF 파일의 크기를 걱정할 필요가 없습니다. 클래스와 관련된 바이트코드는 해당 클래스가 실제로 사용되는 경우에만 SWF 파일에 포함됩니다. 필요하지 않은 클래스를 가져오게 되면 이름이 충돌할 가능성이 높아지는 단점이 있습니다.

// FLA의 프레임 1:
import adobe.example.*; 
var myFoo:foo = new foo();

참고 사항

include "[path]filename.as"

지정된 파일의 내용을 포함합니다. 파일 내의 명령은 호출하는 스크립트의 일부인 것처럼 사용됩니다. include 지시문은 컴파일 타임에 호출됩니다. 그러므로 포함된 파일을 변경하게 되면 변경한 파일을 저장한 후 이 파일을 사용하는 SWF 파일을 다시 컴파일해야 합니다.

참고 사항

 interface InterfaceName [extends InterfaceName ] {}

인터페이스를 정의합니다. 인터페이스는 해당 인터페이스를 구현하는 클래스에 의해 정의되어야 하는 일련의 메서드를 정의하는 데이터 유형입니다.

인터페이스는 클래스와 비슷하지만 다음과 같은 중요한 차이가 있습니다.

• 인터페이스에는 구현되지 않은 메서드 선언만 포함됩니다. 즉, 인터페이스를 구현하는 모든 클래스에서는 인터페이스에 선언된 각 메서드를 구현해야 합니다.
• 인터페이스 메서드 정의는 public 또는 private와 같은 속성을 가질 수 없지만 구현된 메서드는 해당 인터페이스를 구현하는 클래스의 정의에서 public으로 표시되어야 합니다.
• 인터페이스에서 extends 문을 사용하거나 클래스에서 implements 문을 사용하여 여러 인터페이스를 상속할 수 있습니다.

ActionScript 2.0과는 달리 ActionScript 3.0에서는 getter 및 setter 메서드를 인터페이스 정의에 사용할 수 있습니다.

참고 사항

[internal] var varName
[internal] const kName
[internal] function functionName()  { 
	// 여기에 명령문을 입력하십시오.
}
[internal] class className{
	// 여기에 명령문을 입력하십시오.
}
[internal] namespace nsName

클래스, 변수, 상수 또는 함수를 동일한 패키지 내의 모든 호출자에서 사용할 수 있도록 지정합니다. 클래스, 속성 및 메서드는 기본적으로 internal 네임스페이스에 속합니다.

참고 사항

label: statement
label: {
    statements
}

명령문을 break 또는 continue로 참조할 수 있는 식별자와 연결합니다. 중첩 루프에서 레이블을 참조하지 않는 break 또는 continue 명령문은 즉시 루프의 나머지 부분만을 건너뛸 수 있으며 전체 루프를 건너뛸 수는 없습니다. 그러나 전체 루프를 정의하는 명령문에 연결된 레이블이 있는 경우 break 또는 continue 문은 해당 레이블을 참조하여 전체 루프를 건너뛸 수 있습니다.

또한 레이블을 사용하여 블록 명령문을 빠져 나올 수 있습니다. 블록 명령문이 루프의 일부가 아닌 경우에는 레이블을 참조하지 않는 break 문을 배치할 수 블록 명령문 내에 배치할 수 없습니다. 블록 명령문에 연결된 레이블이 있는 경우에는 해당 레이블을 참조하는 break 문을 블록 명령문 내에 배치할 수 있습니다.

outerLoop: for (var i:int = 0; i < 10; i++) {
    for (var j:int = 0; j < 10; j++) {
        if ( (i == 8) && (j == 0)) {
            break outerLoop;
        }
        trace(10 * i + j);
    }
}
/* output:
1
2
...
79
*/

다음 예제에서는 레이블을 블록 명령문과 함께 사용하는 방법을 보여 줍니다. 다음 예제에서는 break 문이 블록의 마지막 명령문을 건너뛰도록 블록 명령문에 foo라는 레이블이 지정됩니다.

foo: {
    trace("a");
    break foo;
    trace("b");
}
// output: a

참고 사항

namespace name [= uri]

정의의 가시성을 제어할 수 있습니다. 미리 정의된 네임스페이스에는 public, private, protected 및 internal이 포함됩니다. 이러한 특정 네임스페이스는 "액세스 제어 지정자"라고도 하며 "클래스 속성 특성"에 대한 설명서에서도 설명됩니다. 미리 정의된 네임스페이스가 사용자 요구에 적합하지 않는 경우 사용자 정의 네임스페이스를 정의할 수 있습니다.

다음 단계에서는 사용자 정의 네임스페이스를 만들고, 적용하고 참조하는 방법을 보여 줍니다.

• 먼저 namespace 키워드를 사용하여 사용자 정의 네임스페이스를 정의합니다. 예를 들어, namespace version1 코드는 version1이라는 네임스페이스를 만듭니다.
• 그런 다음 속성 또는 메서드 선언에 있는 사용자 정의 네임스페이스를 사용하여 속성 또는 메서드에 네임스페이스를 적용합니다. 예를 들어, version1 myProperty:String 코드는 version1 네임스페이스에 속하는 myProperty 속성을 만듭니다.
• 그런 다음 use 키워드를 사용하거나 네임스페이스 형식으로 식별자를 접두어로 사용하여 네임스페이스를 참조합니다. 예를 들어, use namespace version1; 코드는 이후 행에 대한 version1 네임스페이스를 참조하고, version1::myProperty 코드는 myProperty 속성에 대한 version1 네임스페이스를 참조합니다.

참고 사항

native function functionName();
class className {
	native function methodName();
}

함수 또는 메서드가 Flash Player에 의해 기본 코드로 구현되도록 지정합니다. Flash Player는 내부적으로 native 키워드를 사용하여 ActionScript API(application programming interface)에서 함수 및 메서드를 선언합니다. 이 키워드는 사용자의 코드에 사용할 수 없습니다. 

null

데이터가 제공되지 않은 경우 변수에 지정하거나 함수에서 반환할 수 있는 특수한 값입니다. null을 사용하여 찾을 수 없거나 정의된 데이터 유형이 없는 값을 나타낼 수 있습니다.

null 값과 특수 값 undefined를 혼동해서는 안 됩니다. 항등(==) 연산자를 사용하여 null과 undefined를 비교하면 동일한 것으로 나타납니다. 그러나 완전 항등(===) 연산자를 사용하여 null과 undefined를 비교하면 이들은 같지 않은 것으로 나타납니다.

var testArray:Array = new Array();
testArray[0] = "fee";
testArray[1] = "fi";
testArray[4] = "foo";

for (i = 0; i < 6; i++) {
    if (testArray[i] == null) {
        trace("testArray[" + i + "] == null");
    }
}

/* output: 
testArray[2] == null
testArray[3] == null
testArray[5] == null
*/

참고 사항

ObjectProxy 클래스의 메서드를 정의합니다. Proxy 하위 클래스에 Proxy 클래스 메서드와 일치하는 인스턴스 메서드 이름이 포함된 경우 발생할 수 있는 이름 충돌을 피하기 위해 ObjectProxy 클래스 메서드는 자체 네임스페이스에 있습니다.

override function name() { 
	// 여기에 명령문을 입력하십시오.
}

메서드가 상속된 메서드를 대체하도록 지정합니다. 상속된 메서드를 재정의하려면 override 속성을 사용하고, 이름, 번호, 매개 변수 유형 및 반환 유형이 정확히 일치하는지 확인해야 합니다. override 속성을 사용하지 않고 메서드를 재정의하려고 하면 오류가 발생합니다. 마찬가지로 override 속성을 사용할 때 메서드에 일치하는 상속된 메서드가 없으면 오류가 발생합니다.

다음과 같은 항목에 대해서는 override 속성을 사용할 수 없습니다.

• 변수
• 상수
• 정적 메서드
• 상속되지 않은 메서드
• 인터페이스 메서드를 구현한 메서드
• 수퍼 클래스에서 final로 표시된 상속된 메서드

var 또는 const로 선언된 속성을 재정의할 수는 없지만 기본 클래스 속성을 getter-setter로 만들고 get 및 set를 사용하여 정의된 메서드를 재정의하여 비슷한 기능을 얻을 수 있습니다.

참고 사항

package packageName {
    class someClassName{ 
    } 
}

다른 스크립트에서 가져올 수 있도록 코드를 여러 그룹으로 분할해서 구성할 수 있습니다. package 키워드를 사용하여 클래스가 패키지의 멤버임을 나타내야 합니다.

참고 사항

class className {
	private var varName;
	private const kName;
	private function methodName() { 
		// 여기에 명령문을 입력하십시오.
	}
	private namespace nsName;
}

변수, 상수 또는 메서드를 선언하거나 정의하는 클래스에서만 변수, 상수 또는 메서드를 사용할 수 있도록 지정합니다. ActionScript 2.0과는 달리 ActionScript 3.0에서는 private가 더 이상 하위 클래스에 대한 액세스를 제공하지 않습니다. 게다가 private는 컴파일 타임 및 런타임에서의 액세스를 제한합니다. 기본적으로 변수 또는 함수는 동일한 패키지의 모든 호출자에서 사용할 수 있습니다. 변수나 함수에 대한 액세스를 제한하려는 경우에 이 키워드를 사용합니다.

이 키워드는 클래스 정의에만 사용할 수 있으며 인터페이스 정의에는 사용할 수 없습니다. private는 클래스 또는 다른 패키지 레벨 정의에 적용할 수 없습니다.

class A { 
  private var alpha:String = "visible only inside class A"; 
  public var beta:String = "visible everywhere"; 
}
    
class B extends A {
  function B() {
    alpha = "Access attempt from subclass"; // error
  }
}

alpha는 전용 변수이므로 A 클래스의 외부에서 액세스할 수 없습니다. 하위 클래스 B 또한 A 클래스의 외부이므로 이 변수에 액세스할 수 없습니다. 전용 변수에 액세스하려고 시도하면 오류가 발생합니다.

참고 사항

class className {
	protected var varName;
	protected const kName;
	protected function methodName() { 
		// 여기에 명령문을 입력하십시오.
	}
	protected namespace nsName;
}

변수, 상수, 메서드 또는 네임스페이스를 정의하는 클래스 또는 해당 클래스의 하위 클래스에서만 변수, 상수, 메서드 또는 네임스페이스를 사용할 수 있도록 지정합니다. ActionScript 3.0의 protected 정의는 ActionScript 2.0 버전의 private 정의와 비슷하지만 protected가 컴파일 타임 및 런타임에서의 액세스를 제한한다는 점이 다릅니다. 기본적으로 변수 또는 함수는 동일한 패키지의 모든 호출자에서 사용할 수 있습니다. 변수나 함수에 대한 액세스를 제한하려는 경우에 이 키워드를 사용합니다.

이 키워드는 클래스 정의에만 사용할 수 있으며 인터페이스 정의에는 사용할 수 없습니다. private는 클래스 또는 다른 패키지 레벨 정의에 적용할 수 없습니다.

ActionScript 3.0의 protected 정의는 Java 프로그래밍 언어의 protected 정의보다 제한적입니다. ActionScript 3.0 protected는 하위 클래스에 대한 액세스를 엄격하게 제한하는 반면 Java protected는 동일한 패키지 내의 모든 클래스에 대한 액세스를 허용합니다. 예를 들어, Base라는 클래스에 protected로 표시된 속성이 들어 있는 경우 ActionScript 3.0에서는 Base를 확장한 클래스만 protected 속성에 액세스할 수 있습니다. Java에서는 Base의 하위 클래스가 아니더라도 Base와 동일한 패키지에 있는 모든 클래스에서 protected 속성에 액세스할 수 있습니다.

class A { 
  private var alpha:String = "visible only inside class A"; 
  protected var beta:String = "visible inside class A and its subclasses"; 
}
    
class B extends A {
  public function B() {
    beta = "Access attempt from subclass succeeded";
    trace(beta);  // output: Access attempt from subclass succeeded
  }
}

참고 사항

public var varName
public const kName
public function functionName()  { 
	// 여기에 명령문을 입력하십시오.
}
public class className {
	// 여기에 명령문을 입력하십시오.
}
public namespace nsName

모든 호출자가 클래스, 변수, 상수 또는 메서드를 사용할 수 있도록 지정합니다. 클래스, 변수 및 메서드는 기본적으로 내부 항목이므로 현재 패키지 내에서만 볼 수 있습니다. 클래스, 변수 또는 메서드를 모든 호출자에서 볼 수 있게 하려면 public 속성을 사용해야 합니다.

class User { 
    public var age:Number; 
    public var fname:String; 
} // end of class User definition
 
var jimmy:User = new User(); 
jimmy.age = 27; 
jimmy.fname = "jimmy";
trace(jimmy.age, jimmy.fname); // output: 27 jimmy

User 클래스의 공용 변수 중 하나를 전용 변수로 변경하는 경우 User 클래스 외부에서 해당 변수에 액세스하려고 하면 컴파일 타임 오류가 발생합니다.

참고 사항

function functionName () {
	return [expression]
}

실행 시에 호출하는 함수에 즉시 반환됩니다. return 문 뒤에 표현식이 있는 경우에는 해당 표현식이 평가되고 결과가 반환됩니다.

함수 정의에 반환 유형이 들어 있는 경우 return 문은 표현식 뒤에 있어야 합니다. 반환 유형이 지정되지 않은 채로 return 문이 단독으로 사용된 경우에는 undefined가 반환됩니다.

여러 값을 반환할 수는 없습니다. 반환값을 여러 개 지정하면 마지막 값만 반환됩니다. 다음 예제에서는 c가 반환됩니다.

return a, b, c ;

여러 값을 반환해야 하는 경우에는 대신 배열이나 객체를 사용합니다.

function sum(a:Number, b:Number, c:Number):Number { 
    return (a + b + c); 
} 
var newValue:Number = sum(4, 32, 78); 
trace(newValue); // output: 114

참고 사항

function set property(newValue:*) : void{ 
	// 여기에 명령문을 입력하십시오.
}

공용 인터페이스에 속성으로 표시되는 메서드인 setter를 정의합니다. setter는 var 키워드로 선언된 속성 값을 설정하는 특수 메서드입니다. 다른 메서드와는 달리 setter는 괄호(()) 없이 호출되므로 변수처럼 보입니다.

setter를 사용하면 전용 속성에 대한 공용 인터페이스를 만들어서 정보 은폐 원칙을 적용할 수 있습니다. 정보 은폐 기술을 사용하면 전용 속성의 기본 구현이 변경되더라도 공용 인터페이스를 그대로 유지할 수 있습니다.

또한 setter를 사용하면 하위 클래스에서 재정의할 수 있는 반면 var로 선언된 속성은 하위 클래스에서 재정의할 수 없습니다.

setter의 반환 유형은 void이거나 지정되지 않아야 합니다.

setter와 getter를 결합하여 읽기/쓰기 속성을 만들 수 있습니다. 읽기 전용 속성을 만들려면 해당 setter는 만들지 않고 getter만 만듭니다. 쓰기 전용 속성을 만들려면 해당 getter는 만들지 않고 setter만 만듭니다.

package {
    class User { 
        private var userAge:Number; 
        
        public function get age():Number {
            return userAge;
        }
        
        public function set age(x:Number):void {
            userAge = x;    
        }
    } 
} 

var myUser:User = new User();
myUser.age = 25;
trace(myUser.age); // output: 25

참고 사항

class someClassName{ 
	static var varName; 
	static const kName;
	static function methodName() { 
		// 여기에 명령문을 입력하십시오.
	} 
}

변수, 상수 또는 메서드가 클래스의 인스턴스가 아니라 클래스에 속한 것으로 지정합니다.

정적 클래스 멤버에 액세스하려면 인스턴스 이름 대신 클래스 이름을 사용합니다. 예를 들어, Date 클래스에는 다음 구문을 사용해서 호출할 수 있는 parse()라는 정적 메서드가 있습니다.

Date.parse()

parse() 메서드는 Date 클래스의 인스턴스에서 호출될 수 없습니다. 예를 들어, 다음 코드에서는 오류가 발생합니다.

var myDate:Date = new Date();
			myDate.parse("Jan 01 00:00:00 2006"); // error

static은 클래스 정의에만 사용할 수 있습니다. 인터페이스 정의에는 사용할 수 없습니다.

정적 클래스 멤버는 상속되지 않습니다. Java 또는 C++에서처럼 하위 클래스의 이름을 사용하여 정적 클래스 멤버를 참조할 수 없습니다. 그러나 한정자를 사용하지 않고서도 클래스 또는 하위 클래스 내에서 정적 변수나 메서드를 참조할 수 있습니다. 다음 예제를 참조하십시오.

정적 메서드 내에서는 super 문이나 this 키워드를 사용할 수 없습니다.

class Users { 
    private static var numInstances:Number = 0; 
    function Users() { 
        numInstances++; 
    } 
    static function get instances():Number { 
        return numInstances; 
    } 
}

trace(Users.instances); 
var user1:Users = new Users(); 
trace(Users.instances); 
var user2:Users = new Users(); 
trace(Users.instances); 

class PowerUsers extends Users{
    function PowerUsers() {
        instances++;  // unqualified reference to static property Users.instances is legal
    }
}

trace(PowerUsers.instances); // error, cannot access static property using PowerUsers class

참고 사항

super([arg1, ..., argN])
super.method([arg1, ..., argN])

메서드나 생성자의 수퍼 클래스 또는 부모 버전을 호출합니다. 클래스 생성자 본문 내에서 사용되는 super() 문은 생성자의 수퍼 클래스 버전을 호출합니다. 수퍼 클래스 생성자를 호출할 경우에는 올바른 개수의 인수가 있어야 합니다. 수퍼 클래스 생성자는 명시적으로 호출하지 않더라도 항상 호출됩니다. 명시적으로 호출하지 않은 경우에는 인수가 없는 호출이 하위 클래스 생성자 본문의 첫 번째 명령문 앞에 자동으로 삽입됩니다. 즉 하위 클래스에서 생성자 함수를 정의하고 수퍼 클래스 생성자가 하나 이상의 인수를 받는 경우에는 올바른 수의 인수를 가지고 수퍼 클래스 생성자를 명시적으로 호출해야 하며, 그렇지 않은 경우 오류가 발생합니다. 그러나 수퍼 클래스 생성자 호출은 하위 클래스 생성자의 첫 번째 명령문이 아니어도 됩니다. ActionScript 2.0에서는 첫 번째 명령문이어야 했습니다.

인스턴스 메서드의 본문에서 super를 도트(.) 연산자와 함께 사용하여 수퍼 클래스 버전의 메서드를 호출하고 (arg1 ... argN) 인수를 선택적으로 수퍼 클래스 메서드에 전달할 수 있습니다. 이 방법은 수퍼 클래스 메서드에 비헤이비어를 추가할 뿐만 아니라 수퍼 클래스 메서드를 호출하여 원래 비헤이비어를 수행하는 하위 클래스 메서드를 만드는 데 유용합니다.

super 문은 정적 멤버에서 사용할 수 없습니다.

참고 사항

switch (expression) {
	caseClause:
	[defaultClause:]
}

표현식의 값에 따라 여러 명령문 중 하나에 제어가 전달됩니다. 모든 switch 문에는 표현식과 일치하는 case 문이 없을 때 실행되는 기본 case가 있어야 합니다. 각 case 문에는 다음 case로 진행하는 것을 방지하기 위한 break 문이 들어 있어야 합니다. case 문이 완료되면 다음 case가 테스트 표현식과 일치하지 않더라도 실행됩니다.

var switchExpression:int = 3;
        
switch (switchExpression) {
    case 0:
        trace(0);
        break;
    case 1:
        trace(1);
        break;
    case 2:
        trace(2);
        break;
    default:
        trace("Not 0, 1, or 2");
}

// output: Not 0, 1, or 2

참고 사항

this

메서드의 포함 객체에 대한 참조입니다. 스크립트가 실행되면 this 키워드는 스크립트를 포함한 객체를 참조합니다. 메서드 본문 내에서 this 키워드는 호출된 메서드를 포함한 클래스 인스턴스를 참조합니다.

// incorrect version of Simple.as
/*
dynamic class Simple {
    function callfunc() {
        func();
    }
}
*/
// correct version of Simple.as
dynamic class Simple {
    function callfunc() {
        this.func();
    }
}

var simpleObj:Simple = new Simple();
simpleObj.func = function() {
    trace("hello there");
}
simpleObj.callfunc();

참고 사항

throw expression 

catch 코드 블록이 처리할 수 있거나 catch할 수 있는 오류를 생성하거나 throw합니다. catch 블록으로 예외를 catch할 수 없으면 throw된 값의 문자열 표시가 출력 패널로 전송됩니다. catch 또는 finally 블록으로 예외를 catch할 수 없으면 throw된 값의 문자열 표시가 로그 파일로 전송됩니다.

일반적으로 Error 클래스 또는 하위 클래스의 인스턴스를 throw합니다. 자세한 내용은 예제 단원을 참조하십시오.

function checkEmail(email:String) { 
    if (email.indexOf("@") == -1) { 
        throw new Error("Invalid email address"); 
    } 
} 
checkEmail("someuser_theirdomain.com");

try { 
    checkEmail("Joe Smith"); 
} 
catch (e) { 
    trace(e); 
}
// output: Error: Invalid email address.

// Define Error subclass InvalidEmailError 
class InvalidEmailAddress extends Error { 
    public function InvalidEmailAddress() {
        message = "Invalid email address."; 
    }
}

import InvalidEmailAddress; 
function checkEmail(email:String) { 
    if (email.indexOf("@") == -1) { 
        throw new InvalidEmailAddress(); 
    } 
} 
try { 
    checkEmail("Joe Smith"); 
} 
catch (e) { 
    trace(e);
}
// output: Error: Invalid email address.

참고 사항

true

true를 나타내는 부울 값입니다. 부울 값은 true 또는 false이며, true의 반대는 false입니다. 자동 데이터 유형 지정 기능이 true를 숫자로 변환하면 1이 됩니다. true를 문자열로 변환하면 "true"가 됩니다.

var shouldExecute:Boolean;
// ...
// code that sets shouldExecute to either true or false goes here
// shouldExecute is set to true for this example:

shouldExecute = true;

if (shouldExecute == true) {
    trace("your statements here");
}

// true is also implied, so the if statement could also be written:
// if (shouldExecute) {
//         trace("your statements here");
// }

다음 예제에서는 자동 데이터 유형 지정 기능이 true를 숫자 1로 변환하는 방법을 보여 줍니다.

var myNum:Number;
myNum = 1 + true;
trace(myNum); // output: 2

참고 사항

try { 
    // try 블록 
} finally { 
    // finally 블록 
} 

try { 
    // try 블록 
} catch(error[:ErrorType1]) {
    // catch 블록 
} [catch(error[:ErrorTypeN]) { 
    // catch 블록 
}] [finally {
    // finally 블록 
}]

오류가 발생할 수 있는 코드 블록을 포함하고 오류에 대응합니다. try..catch..finally 문을 사용하여 구현되는 예외 처리는 ActionScript 3.0의 런타임 오류 조건을 처리하는 기본 메커니즘입니다. 런타임 오류가 발생하면 예외가 throw되어 정상적인 실행이 중지되고 Error 유형의 특수 객체가 만들어집니다. 그런 다음 사용할 수 있는 첫 번째 catch 블록에 오류 객체가 전달 또는 throw됩니다. 사용할 수 있는 catch 블록이 없는 경우에는 예외가 catch되지 않는 예외인 것으로 간주됩니다. catch되지 않는 예외가 발생하면 스크립트가 종료됩니다.

코드에서 throw 문을 사용하여 예외를 명시적으로 throw할 수 있습니다. 아무 값이나 throw할 수 있지만 유연성이 좋고 Flash Player의 동작과 일치하는 객체를 throw하는 것이 좋습니다.

예외가 Flash Player나 사용자 코드에서 throw되었는지 상관 없이 예외를 catch하려면 예외를 throw하는 코드를 try 블록에 배치합니다. try 블록 내의 코드가 예외를 throw하면 catch 블록(있는 경우)에 제어가 전달된 다음 finally 블록(있는 경우)으로 전달됩니다. finally 블록은 예외가 throw되었는지 여부에 관계 없이 항상 실행됩니다. try 블록 내의 코드가 예외를 throw하지 않은 경우, 즉 try 블록이 정상적으로 완료된 경우에는 catch 블록 내의 코드가 무시되지만 finally 블록 내의 코드는 실행됩니다. finally 블록은 try 블록이 return 문을 사용하여 종료된 경우에도 실행됩니다.

try 블록 다음에는 catch 블록이나 finally 블록 또는 둘 모두가 와야 합니다. 단일 try 블록에는 여러 catch 블록이 포함될 수 있지만 finally 블록은 하나만 포함됩니다. try 블록은 무제한 중첩될 수 있습니다.

catch 핸들러에 지정된 error 매개 변수는 e, theException 또는 x와 같은 간단한 식별자여야 합니다. 매개 변수의 유형도 지정할 수 있습니다. 여러 catch 블록을 사용할 때 유형 지정된 매개 변수를 사용하면 단일 try 블록에서 throw된 여러 유형의 오류 객체를 catch할 수 있습니다.

throw된 예외가 객체인 경우 throw된 객체가 특정 유형의 하위 클래스이면 유형이 일치하게 됩니다. 특정 유형의 오류가 throw되면 해당 오류를 처리하는 catch 블록이 실행됩니다. 지정된 유형이 아닌 예외가 throw되면, catch 블록이 실행되지 않고 예외는 자동으로 try 블록 밖으로 throw되어 일치하는 catch 핸들러로 이동합니다.

오류가 함수 내에서 throw되고 함수에 catch 핸들러가 없으면 Flash Player는 catch 블록이 발견될 때까지 해당 함수는 물론 호출자 함수도 종료합니다. 이러한 과정에서 finally 핸들러는 모든 단계에서 호출됩니다.

import flash.display.Sprite;

var spr:Sprite = new Sprite();
try {
    spr.addChild(spr);
}
catch (e:ArgumentError) {
    trace(e); // output: ArgumentError: Error #2024: An object may not be added as a child of itself.
}

class RecordSetException extends Error { 
    public function RecordSetException () {
        message = "Record set exception occurred."; 
    }
}

class MalformedRecord extends Error { 
    public function MalformedRecord {
        message = "Malformed record exception occurred."; 
    }
}

class RecordSet { 
    public function sortRows() { 
        var returnVal:Number = randomNum(); 
        if (returnVal == 1) { 
            throw new RecordSetException(); 
        } 
        else if (returnVal == 2) { 
            throw new MalformedRecord(); 
        } 
    }
    public function randomNum():Number { 
        return Math.round(Math.random() * 10) % 3; 
    }
}

import RecordSet; 
var myRecordSet:RecordSet = new RecordSet();
try { 
    myRecordSet.sortRows(); 
    trace("everything is fine"); 
} 
catch (e:RecordSetException) { 
    trace(e.toString()); 
} 
catch (e:MalformedRecord) { 
    trace(e.toString()); 
}

참고 사항

use namespace ns1[, ns2, ...nsN]

지정된 네임스페이스가 열려 있는 네임스페이스 세트에 추가되도록 합니다. 지정된 네임스페이스는 현재 코드 블록이 종료될 때 열려 있는 네임스페이스 세트에서 제거됩니다. use namespace 지시문은 최상위 프로그램, 패키지 정의 또는 클래스 정의에 나타날 수 있습니다.

참고 사항

var variableName [= value1][...,variableNameN[=valueN]] 

변수를 지정합니다. 함수 내에서 변수를 선언하면 로컬 변수가 됩니다. 로컬 변수는 함수에 대해 정의되며 함수 호출이 끝나면 만료됩니다.

함수 외부에 변수를 선언하면 변수는 명령문을 포함하는 타임라인 전체에서 사용할 수 있습니다.

다른 객체의 범위에 있는 변수는 로컬 변수로 선언할 수 없습니다.

my_array.length = 25; // ok 
var my_array.length = 25; // syntax error 

데이터 유형 앞에 콜론 문자를 추가하면 데이터 유형을 변수에 대입할 수 있습니다.

구문을 작성할 때 각 선언을 쉼표로 구분하면 코드가 명확하지 않을 수도 있지만 단일 명령문에 여러 변수를 선언할 수 있습니다.

var first:String = "Bart", middle:String = "J.", last:String = "Bartleby";

var product_array:Array = new Array("Studio", "Dreamweaver", "Flash", "ColdFusion", "Contribute", "Breeze"); 
product_array.push("Flex"); 
trace(product_array); 
// output: Studio,Dreamweaver,Flash,ColdFusion,Contribute,Breeze,Flex

참고 사항

while (condition) { 
	// 명령문
}

조건을 평가하고 조건이 true로 평가되면 하나 이상의 명령문을 실행한 후 루프로 돌아가서 조건을 다시 평가합니다. 조건이 false로 평가되면 명령문이 생략되고 루프가 종료됩니다.

while 문은 다음과 같은 일련의 단계를 수행합니다. 1단계~4단계까지의 각 반복을 루프 반복이라고 합니다. 다음 단계와 같이 반복을 시작할 때마다 조건을 테스트합니다.

1. condition 표현식이 평가됩니다.
2. condition이 true 또는 부울 값 true로 변환되는 값(예: 0이 아닌 숫자)으로 평가되면 3단계로 이동하십시오. 그렇지 않으면 while 문이 완료되고 while 루프 이후의 다음 명령문에서 실행이 재개됩니다.
3. 명령문 블록 statement(s)를 실행합니다. continue 문이 나타나면 나머지 명령문을 건너뛰고 1단계로 이동합니다. break 문이 나타나면 while 문이 완료되고 while 루프 후 다음 명령문에서 실행이 다시 시작됩니다.
4. 1단계로 이동합니다.

일반적으로 반복은 카운터 변수가 지정된 값보다 작을 때 액션을 수행하기 위해 사용됩니다. 각 루프가 끝나면 지정된 값이 될 때까지 카운터가 증가합니다. 이 때 condition은 더 이상 true가 아니며 루프가 끝납니다.

while 문이 실행할 명령문을 둘러싸는 중괄호({})는 하나의 명령문만을 실행할 경우에는 필요하지 않습니다.

var i:Number = 0; 
while (i < 20) { 
    trace(i); 
    i += 3; 
}
/* output:
0 
3 
6 
9 
12
15 
18
*/

참고 사항

with (object:Object) { 
	// 명령문
}

명령문을 실행하는 데 사용할 기본 객체를 만듭니다. 이 객체를 사용하면 작성해야 하는 코드의 양을 줄일 수 있습니다.

object 매개 변수는 statement(s) 매개 변수의 속성, 변수 및 함수를 읽는 컨텍스트가 됩니다. 예를 들어, object가 my_array이고 지정된 두 개의 속성이 length 및 concat이면 이러한 속성은 자동으로 my_array.length 및 my_array.concat로 판독됩니다. 다른 예로, object가 state.california이면 with 문 내의 액션 또는 명령문은 california 인스턴스 내에서 호출됩니다.

statement(s) 매개 변수에서 식별자 값을 찾기 위해 ActionScript는 object가 지정한 범위 체인이 시작되는 곳에서 시작하고 특정 순서대로 범위 체인의 각 수준에서 식별자를 검색합니다.

식별자를 확인하기 위해 with 문에서 사용하는 범위 체인은 다음 목록의 첫 항목에서 시작하여 마지막 항목까지 계속됩니다.

• 가장 안쪽에 있는 with 문의 object 매개 변수에 지정된 객체
• 가장 바깥쪽에 있는 with 문의 object 매개 변수에 지정된 객체
• Activation 객체(함수에서 호출되는 로컬 변수를 갖고 있는 함수를 스크립트에서 호출할 때 자동으로 만들어지는 임시 객체)
• 현재 실행 중인 스크립트가 포함된 객체
• 전역 객체(Math와 String 같은 내장 객체)

with 문 안에서 변수를 설정하려면 변수가 with 문 외부에 선언되어 있거나 변수를 활성화할 타임라인의 전체 경로를 입력해야 합니다. 변수를 선언하지 않고 with 문에 설정하면 with 문은 범위 체인에 따라 값을 찾습니다. 변수가 아직 없으면 with 문이 호출된 타임라인에 새 값이 설정됩니다.

with (someOther_mc) { 
    _x = 50; 
    _y = 100; 
    gotoAndStop(3); 
}

someOther_mc._x = 50; 
someOther_mc._y = 100; 
someOther_mc.gotoAndStop(3);

with 문은 범위 체인 목록에 있는 여러 항목을 동시에 액세스할 때 유용합니다. 다음 예제에서는 내장 Math 객체가 범위 체인의 맨 앞에 옵니다. Math를 기본 객체로 설정하면 식별자 cos, sin 및 PI는 각각 Math.cos, Math.sin 및 Math.PI로 확인됩니다. 식별자 a, x, y 및 r는 Math 객체의 메서드나 속성은 아니지만 polar() 함수의 객체 활성화 범위 내에 존재하기 때문에 해당 로컬 변수로 확인됩니다.

function polar(r:Number):void { 
    var a:Number, x:Number, y:Number; 
    with (Math) { 
        a = PI * pow(r, 2); 
        x = r * cos(PI); 
        y = r * sin(PI / 2); 
    } 
    trace("area = " + a); 
    trace("x = " + x); 
    trace("y = " + y); 
} polar(3);
/* output: 
area = 28.2743338823081 
x = -3 
y = 3
*/