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

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

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

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

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

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

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

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

}

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/

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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