运算符 

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

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

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

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

public var myArray:Array = ["one", "two", "three"];
trace(myArray as Array);  // one,two,three
trace(myArray as Number); // null
trace(myArray as int);    // null

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

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

var insert:Number = 13; 
var update:Number = 11; 
trace(insert & update); // 9 (or 1001 binary) 

trace(0xFFFFFFFF); // 4294967295 
trace(0xFFFFFFFF & 0xFFFFFFFF); // -1 
trace(0xFFFFFFFF & -1); // -1 
trace(4294967295 & -1); // -1 
trace(4294967295 & 4294967295); // -1 

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

var num1:uint = 0xFF;
var num2:uint = uint(num1 << 24); // uint() prevents runtime error

x = 1 << 10

x = 7 << 8

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

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 

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 

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

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

var a:Number = 65535 >> 8; 
trace(a); // 255

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

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.

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

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

// 15 decimal = 1111 binary 
// 9 decimal = 1001 binary 
var a:Number = 15 ^ 9; 
trace(a); 
// 1111 ^ 1001 = 0110 
// returns 6 decimal (0110 binary) 

// 15 decimal = 1111 binary 
var a:Number = 15; 
// 9 decimal = 1001 binary 
var b:Number = 9; 
trace(a ^= b); // returns 6 decimal (0110 binary) 

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

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>

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

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 

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 

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

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

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

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

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

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

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,

var my_array:Array = [ "abc", "def", "ghi" ];
var deleteWasSuccessful:Boolean

deleteWasSuccessful = delete my_array[0];
if(deleteWasSuccessful) delete my_array[1];
deleteWasSuccessful = delete my_array[0];
if(deleteWasSuccessful) delete my_array[2];

trace(my_array) // outputs: undefined,undefined,ghi

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

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

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

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

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

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

import flash.utils.Timer;

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

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

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 

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

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

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

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

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

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

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

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

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

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 

trace(5 <= 10); // true 
trace(2 <= 2);            // true 
trace(10 <= 3);           // false 
trace("Allen" <= "Jack"); // true 
trace("Jack" <= "Allen"); // false 
trace("11" <= "3");       // true 
trace("11" <= 3);         // false (numeric comparison) 
trace("C" <= "abc");      // true 
trace("A" <= "a");        // true 

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

var turns:Number = 2; 
var score:Number = 77; 
if ((turns <= 3) && (score >= 75)) { 
	trace("You Win the Game!"); 
} else { 
	trace("Try Again!"); 
} 

var myVar:String = 'tag';
			myVar &&= "<" + myVar + "/>";
			trace (myVar); // output: <tag/>

var myVar:String = 'tag';
			if (myVar != '') {
			  myVar = "<" + myVar + "/>";
			}
			trace (myVar); // output: <tag/>

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

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 
} 

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

myVar ||= "default";

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

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

trace(2*3); // 6 

trace(2.0 * 3.1416); // 6.2832 

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 

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

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

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

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 

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

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

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 

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 

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

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

trace(5 - 2); // 3 

trace(3.25 - 1.5); // 1.75 

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 

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

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 

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