Flash 8 ActionScript 2.0 Language Reference

Operators

+

addition Operator

Adds numeric expressions or concatenates (combines) strings. If one expression is a string, all other expressions are converted to strings and concatenated.
If both expressions are integers, the sum is an integer; if either or both expressions are floating-point numbers, the sum is a floating-point number.

var name:String = "Cola"; 
var instrument:String = "Drums"; 
trace(name + " plays " + instrument); // output: Cola plays Drums 

trace(2 + 3); // output: 5 

trace(2.5 + 3.25); // output: 5.75 

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 a:String = 3 + 10 + "asdf"; 
trace(a); // 13asdf 
var b:String = "asdf" + 3 + 10; 
trace(b); // asdf310 

+=

addition assignment Operator

Assigns expression1 the value of expression1+ expression2. For example, the following two statements have the same result:

x += y; 
x = x + y; 

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

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

[]

array access Operator

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

Initializes a new array or multidimensional array with the specified elements (a0, and so on), or accesses elements in an array. The array access operator lets you dynamically set and retrieve instance, variable, and object names. It also lets you access object properties.

Usage 1: An array is an object whose properties are called elements, which are each identified by a number called an index. When you create an array, you surround the elements with the array access ([]) operator (or brackets). An array can contain elements of various types. For example, the following array, called employee, has three elements; the first is a number and the second two are strings (inside quotation marks):

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]);// output: 6 

name["mc" + i] = "left_corner"; 

var my_array:Array = []; 
var my_array:Array = new Array(); 

The following example creates an array called employee_array and uses the trace() statement to send the elements to the Output panel. In the fourth line, an element in the array is changed, and the fifth line sends the newly modified array to the Output panel:

The following example creates an array called employee_array and uses the trace() statement to send the elements to the log file. In the fourth line, an element in the array is changed, and the fifth line sends the newly modified array to the log file:

var employee_array = ["Barbara", "George", "Mary"]; 
trace(employee_array); // output: Barbara,George,Mary 
employee_array[2] = "Sam"; 
trace(employee_array); // output: Barbara,George,Sam 

myBtn_btn.onRelease = function() { 
    x = my_mc["piece"+i]; 
    trace(x); 
}; 

name_mc["A" + i]; 

eval("name_mc.A" & i); 

for (i in _root) { 
    trace(i+": "+_root[i]); 
} 

employee_array[2] = "Sam";

=

assignment Operator

Assigns the value of expression2 (the parameter on the right) to the variable, array element, or property in expression1. Assignment can be either by value or by reference. Assignment by value copies the actual value of expression2 and stores it in expression1 . Assignment by value is used when a variable is assigned a number or string literal. Assignment by reference stores a reference to expression2 in expression1. Assignment by reference is commonly used with the new operator. Use of the new operator creates an object in memory and a reference to that location in memory is assigned to a variable.

var x:Number = 5;

The following example uses assignment by value to assign the value "hello" to the variable x:

var x:String; 
x = " hello ";

The following example uses assignment by reference to create the moonsOfJupiter variable, which contains a reference to a newly created Array object. Assignment by value is then used to copy the value "Callisto" to the first element of the array referenced by the variable moonsOfJupiter:

var moonsOfJupiter:Array = new Array(); 
moonsOfJupiter[0] = "Callisto";

The following example uses assignment by reference to create a new object, and assign a reference to that object to the variable mercury. Assignment by value is then used to assign the value of 3030 to the diameter property of the mercury object:

var mercury:Object = new Object(); mercury.diameter = 3030; // in miles 
trace (mercury.diameter); // output: 3030

The following example builds upon the previous example by creating a variable named merkur (the German word for mercury) and assigning it the value of mercury. This creates two variables that reference the same object in memory, which means you can use either variable to access the object's properties. We can then change the diameter property to use kilometers instead of miles:

var merkur:Object = mercury;
merkur.diameter = 4878; // in kilometers
trace (mercury.diameter); // output: 4878

&

bitwise AND Operator

Converts expression1 and expression2 to 32-bit unsigned integers, and performs a Boolean AND operation on each bit of the integer parameters. Floating-point numbers are converted to integers by discarding any digits after the decimal point. The result is a new 32-bit integer.

Positive integers are converted to an unsigned hexadecimal value with a maximum value of 4294967295 or 0xFFFFFFFF; values larger than the maximum have their most significant digits discarded when they are converted, therefore their value is still 32-bit. Negative numbers are converted to an unsigned hexadecimal value using two's complement notation, with the minimum being -2147483648 or 0x800000000; numbers less than the minimum are converted to two's complement with greater precision and then have the most significant dig its discarded as well.

The return value is interpreted as a two's complement number with sign, so the return is an integer in the range -2147483648 to 2147483647.

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

The following examples show the behavior of the return value conversion:

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

&=

bitwise AND assignment Operator

Assigns expression1 the value of expression1 & expression2. For example, the following two expressions are equivalent:

x &= y; 
x = x & y; 

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

<<

bitwise left shift Operator

Converts expression1 and expression2 to 32-bit integer values; you can call them V1 and V2. Shifts all bits of the value of V1 to the left by V2 positions. Discards bits shifted off the left end of V1 by this operation, and inserts zeros in the bit positions on the right that are emptied. Shifting a value left by one position is the equivalent of multiplying it by 2.

Floating-point numbers are converted to integers by discarding any digits after the decimal point. Positive integers are converted to an unsigned hexadecimal value with a maximum value of 4294967295 or 0xFFFFFFFF; values larger than the maximum have their most significant digits discarded when they are converted so the value is still 32-bit. Negative numbers are converted to an unsigned hexadecimal value via the two's complement notation, with the minimum being -2147483648 or 0x800000000; numbers less than the minimum are converted to two's complement with greater precision and also have the most significant digits discarded.

The return value is interpreted as a two's complement number with sign, so the return value will be an integer in the range -2147483648 to 2147483647.

// 2 binary == 0010 
// 8 binary == 1000 
trace(2 << 2); // output: 8 

<<=

bitwise left shift and assignment Operator

This operator performs a bitwise left shift (<<=) operation and stores the contents as a result in expression1. The following two expressions are equivalent:

A <<= B; 
A = (A << B)

var x:Number = 4; 
// shift all bits one slot to the left. 
x <<= 1; 
trace(x); // output: 8 
// 4 decimal = 0100 binary 
// 8 decimal = 1000 binary 

~

bitwise NOT Operator

Also known as the one's complement operator or the bitwise complement operator. Converts the expression to a 32-bit signed integer, and then applies a bitwise one's complement. That is, every bit that is a 0 is set to 1 in the result, and every bit that is a 1 is set to 0 in the result. The result is a signed 32-bit integer.

For example, the hexadecimal value 0x7777 is represented as this binary number:
0111011101110111

The bitwise negation of that hexadecimal value, ~0x7777, is this binary number:
1000100010001000

In hexadecimal, this is 0x8888. Therefore, ~0x7777 is 0x8888.

The most common use of bitwise operators is for representing flag bits (Boolean values packed into 1 bit each).

Floating-point numbers are converted to integers by discarding any digits after the decimal point. Positive integers are converted to an unsigned hexadecimal value with a maximum value of 4294967295 or 0xFFFFFFFF; values larger than the maximum have their most significant digits discarded when they are converted so the value is still 32-bit. Negative numbers are converted to an unsigned hexadecimal value via the two's complement notation, with the minimum being -2147483648 or 0x800000000; numbers less than the minimum are converted to two's complement with greater precision and also have the most significant digits discarded.

The return value is interpreted as a two's complement number with sign, so the return value is an integer in the range -2147483648 to 2147483647.

var ReadOnlyFlag:Number = 0x0001; // defines bit 0 as the read-only flag 
var flags:Number = 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); 
// output: 0 1 0 

|

bitwise OR Operator

Converts expression1 and expression2 to 32-bit unsigned integers, and returns a 1 in each bit position where the corresponding bits of either expression1 or expression2 are 1. Floating-point numbers are converted to integers by discarding any digits after the decimal point. The result is a new 32-bit integer.

Positive integers are converted to an unsigned hexadecimal value with a maximum value of 4294967295 or 0xFFFFFFFF; values larger than the maximum have their most significant digits discarded when they are converted so the value is still 32-bit. Negative numbers are converted to an unsigned hexadecimal value via the two's complement notation, with the minimum being -2147483648 or 0x800000000; numbers less than the minimum are converted to two's complement with greater precision and also have the most significant digits discarded.

The return value is interpreted as a two's complement number with sign, so the return value will be an integer in the range -2147483648 to 2147483647.

// 15 decimal = 1111 binary 
var x:Number = 15; 
// 9 decimal = 1001 binary 
var y:Number = 9; 
// 1111 | 1001 = 1111 
trace(x | y); // returns 15 decimal (1111 binary) 

|=

bitwise OR assignment Operator

Assigns expression1 the value of expression1 | expression2. For example, the following two statements are equivalent:

x |= y;
x = x | y; 

// 15 decimal = 1111 binary 
var x:Number = 15; 
// 9 decimal = 1001 binary 
var y:Number = 9; 
// 1111 |= 1001 = 1111 
trace(x |= y); // returns 15 decimal (1111 binary) 

>>

bitwise right shift Operator

Converts expression1 and expression2 to 32-bit integers, and shifts all the bits in expression1 to the right by the number of places specified by the integer that results from the conversion of expression2 . Bits that are shifted off the right end are discarded. To preserve the sign of the original expression , the bits on the left are filled in with 0 if the most significant bit (the bit farthest to the left) of expression1 is 0, and filled in with 1 if the most significant bit is 1. Shifting a value right by one position is the equivalent of dividing by 2 and discarding the remainder.

Floating-point numbers are converted to integers by discarding any digits after the decimal point. Positive integers are converted to an unsigned hexadecimal value with a maximum value of 4294967295 or 0xFFFFFFFF; values larger than the maximum have their most significant digits discarded when they are converted so the value is still 32-bit. Negative numbers are converted to an unsigned hexadecimal value via the two's complement notation, with the minimum being -2147483648 or 0x800000000; numbers less than the minimum are converted to two's complement with greater precision and also have the most significant digits discarded.

The return value is interpreted as a two's complement number with sign, so the return value will be an integer in the range -2147483648 to 2147483647.

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

var x:Number = 255;

The following example converts -1 to a 32-bit integer and shifts it 1 bit to the right:

var x:Number = -1 >> 1;
trace(x); // outputs -1

var x:Number = -1;

>>=

bitwise right shift and assignment Operator

This operator performs a bitwise right-shift operation and stores the contents as a result in expression1.

The following two statements are equivalent:

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

>>>

bitwise unsigned right shift Operator

The same as the bitwise right shift (>>) operator except that it does not preserve the sign of the original expression because the bits on the left are always filled with 0.

Floating-point numbers are converted to integers by discarding any digits after the decimal point. Positive integers are converted to an unsigned hexadecimal value with a maximum value of 4294967295 or 0xFFFFFFFF; values larger than the maximum have their most significant digits discarded when they are converted so the value is still 32-bit. Negative numbers are converted to an unsigned hexadecimal value via the two's complement notation, with the minimum being -2147483648 or 0x800000000; numbers less than the minimum are converted to two's complement with greater precision and also have the most significant digits discarded.

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

This is because -1 decimal is 11111111111111111111111111111111 binary (thirty-two 1s), and when you shift right (unsigned) by 1 bit, the least significant (rightmost) bit is discarded, and the most significant (leftmost) bit is filled with a 0. The result is 01111111111111111111111111111111 binary, which represents the 32-bit integer 2147483647.

>>>=

bitwise unsigned right shift and assignment Operator

Performs an unsigned bitwise right-shift operation and stores the contents as a result in expression1. The following two statements are equivalent:

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

^

bitwise XOR Operator

Converts expression1 and expression2 to 32-bit unsigned integers, and returns a 1 in each bit position where the corresponding bits in expression1 or expression2, but not both, are 1. Floating-point numbers are converted to integers by discarding any digits after the decimal point. The result is a new 32-bit integer.

Positive integers are converted to an unsigned hexadecimal value with a maximum value of 4294967295 or 0xFFFFFFFF; values larger than the maximum have their most significant digits discarded when they are converted so the value is still 32-bit. Negative numbers are converted to an unsigned hexadecimal value via the two's complement notation, with the minimum being -2147483648 or 0x800000000; numbers less than the minimum are converted to two's complement with greater precision and also have the most significant digits discarded.

The return value is interpreted as a two's complement number with sign, so the return value will be an integer in the range -2147483648 to 2147483647.

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

^=

bitwise XOR assignment Operator

Assigns expression1 the value of expression1 ^ expression2. For example, the following two statements are equivalent:

x ^= y; 
x = x ^ y; 

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

/*..*/

block comment delimiter Operator

/* comment */
/* comment
   comment */

Indicates one or more lines of script comments. Any characters that appear between the opening comment tag (/*) and the closing comment tag (*/), are interpreted as a comment and ignored by the ActionScript interpreter. Use the // (comment delimiter) to identify single-line comments. Use the /* comment delimiter to identify comments on multiple successive lines. Leaving off the closing tag (*/) when using this form of comment delimiter returns an error message. Attempting to nest comments also returns an error message. After an opening comment tag (/*) is used, the first closing comment tag (*/) will end the comment, regardless of the number of opening comment tags (/*) placed between them.

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

,

comma Operator

Evaluates expression1, then expression2, and so on. This operator is primarily used with the for loop statement and is often used with the parentheses () operator.

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); // output: 4 

var v:Number = 0; 
v = (4, 5, 6); 
trace(v); // output: 6 

var v:Number = 0; 
var z:Number = 0; 
v = v + 4 , z++, v + 6; 
trace(v); // output: 4 
trace(z); // output: 1 

var v:Number = 0; 
var z:Number = 0; 
v = (v + 4, z++, v + 6); 
trace(v); // output: 6 
trace(z); // output: 1 

add

concatenation (strings) Operator

Deprecated since Flash Player 5 — Macromedia recommends that you use the add (+) operator when creating content for Flash Player 5 or later. This operator is not supported in Flash Player 8 or later.

Concatenates two or more strings. The add (+) operator replaces the Flash 4 & operator; Flash Player 4 files that use the & operator are automatically converted to use the add (+) operator for string concatenation when brought into the Flash 5 or later authoring environment. Use the add (+) operator to concatenate strings if you are creating content for Flash Player 4 or earlier versions of the Player.

?:

conditional Operator

Instructs Flash to evaluate expression1, and if the value of expression1 is true, it returns the value of expression2; otherwise it returns the value of 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); 

--

decrement Operator

--expression
expression--

A pre-decrement and post-decrement unary operator that subtracts 1 from the expression . The expression can be a variable, element in an array, or property of an object. The pre-decrement form of the operator (--expression) subtracts 1 from expression and returns the result. The post-decrement form of the operator (expression--) subtracts 1 from the expression and returns the initial value of expression (the value prior to the subtraction).

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

/

division Operator

Divides expression1 by expression2. The result of the division operation is a double-precision floating-point number.

trace(Stage.width/2); 
trace(Stage.height/2); 

/=

division assignment Operator

Assigns expression1 the value of expression1 / expression2. For example, the following two statements are equivalent:

x /= y;
x = x / y;

var x:Number = 10; 
var y:Number = 2; 
x /= y; trace(x); // output: 5 

.

dot Operator

object.property_or_method
instancename.variable
instancename.childinstance
instancename.childinstance.variable

Used to navigate movie clip hierarchies to access nested (child) movie clips, variables, or properties. The dot operator is also used to test or set the properties of an object or top-level class, execute a method of an object or top-level class, or create a data structure.

person_mc.hairColor 

/person_mc:hairColor 

this.createEmptyMovieClip("container_mc", this.getNextHighestDepth()); 
this.container_mc.createTextField("date_txt", this.getNextHighestDepth(), 0, 0, 100, 22); 
this.container_mc.date_txt.autoSize = true; 
this.container_mc.date_txt.text = new Date(); 

==

equality Operator

Tests two expressions for equality. The result is true if the expressions are equal.

The definition of equal depends on the data type of the parameter:

• Numbers and Boolean values are compared by value and are considered equal if they have the same value.
• String expressions are equal if they have the same number of characters and the characters are identical.
• Variables representing objects, arrays, and functions are compared by reference. Two such variables are equal if they refer to the same object, array, or function. Two separate arrays are never considered equal, even if they have the same number of elements.

When comparing by value, if expression1 and expression2 are different data types, ActionScript will attempt to convert the data type of expression2 to match that of expression1.

var a:String = "David", b:String = "David"; 
if (a == b) { 
    trace("David is David"); 
} 

var x:Number = 5; 
var y:String = "5"; 
trace(x == y); // output: true 
var x:String = "5"; 
var y:String = "66"; 
trace(x == y); // output: false 
var x:String = "chris"; 
var y:String = "steve"; 
trace(x == y); // output: false 

var firstArray:Array = new Array("one", "two", "three"); 
var secondArray:Array = new Array("one", "two", "three"); 
trace(firstArray == secondArray); 
// will output false 
// Arrays are only considered equal 
// if the variables refer to the same array. 
var thirdArray:Array = firstArray; 
trace(firstArray == thirdArray); // will output true 

eq

equality (strings) Operator

Deprecated since Flash Player 5 — This operator was deprecated in favor of the == (equality) operator.

Compares two expressions for equality and returns a value of true if the string representation of expression1 is equal to the string representation of expression2, false otherwise.

>

greater than Operator

Compares two expressions and determines whether expression1 is greater than expression2; if it is, the operator returns true. If expression1 is less than or equal to expression2, the operator returns false. String expressions are evaluated using alphabetical order; all capital letters come before lowercase letters.

if (score_txt.text>90) { 
    trace("Congratulations, you win!"); 
} else { 
    trace("sorry, try again"); 
} 

gt

greater than (strings) Operator

Deprecated since Flash Player 5 — This operator was deprecated in favor of the > (greater than) operator.

Compares the string representation of expression1 with the string representation of expression2 and returns true if expression1 is greater than expression2, false otherwise.

>=

greater than or equal to Operator

Compares two expressions and determines whether expression1 is greater than or equal to expression2 (true) or expression1 is less than expression2 (false).

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

ge

greater than or equal to (strings) Operator

Deprecated since Flash Player 5 — This operator was deprecated in favor of the >= (greater than or equal to) operator.

Compares the string representation of expression1 with the string representation of expression2 and returns true if expression1 is greater than or equal to expression2, false otherwise.

++

increment Operator

++expression
expression++

A pre-increment and post-increment unary operator that adds 1 to expression . The expression can be a variable, element in an array, or property of an object. The pre-increment form of the operator (++expression) adds 1 to expression and returns the result. The post-increment form of the operator (expression++ ) adds 1 to expression and returns the initial value of expression (the value prior to the addition).

The pre-increment form of the operator increments x to 2 (x + 1 = 2) and returns the result as y:

var x:Number = 1; 
var y:Number = ++x; 
trace("x:"+x); //traces x:2 
trace("y:"+y); //traces y:2

var x:Number = 1; 
var y:Number = x++; 
trace("x:"+x); //traces x:2 
trace("y:"+y); //traces y:1

var i:Number = 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 
*/

var a:Array = new Array(); 
var i:Number = 0; 
while (i < 10) { 
    a.push(++i); 
} 
trace(a.toString()); //traces: 1,2,3,4,5,6,7,8,9,10 

var a:Array = []; 
for (var i = 1; i <= 10; ++i) { 
    a.push(i); 
} 
trace(a.toString()); //traces: 1,2,3,4,5,6,7,8,9,10 

// using a while loop 
var a:Array = new Array(); 
var i:Number = 0; 
while (i < 10) { 
    a.push(i++); 
} 
trace(a.toString()); //traces 0,1,2,3,4,5,6,7,8,9 

// using a for loop 
var a:Array = new Array(); 
for (var i = 0; i < 10; i++) { 
    a.push(i); 
} 
trace(a.toString()); //traces 0,1,2,3,4,5,6,7,8,9 

0,1,2,3,4,5,6,7,8,9 

!=

inequality Operator

Tests for the exact opposite of the equality ( ==) operator. If expression1 is equal to expression2 , the result is false. As with the equality (==) operator, the definition of equal depends on the data types being compared, as illustrated in the following list:

• Numbers, strings, and Boolean values are compared by value.
• Objects, arrays, and functions are compared by reference.
• A variable is compared by value or by reference, depending on its type.

Comparison by reference means that two expressions are equal only if they both refer to the same object, array, or function. Values inside the object, array, or function are not compared.

When comparing by value, if expression1 and expression2 are different data types, ActionScript will attempt to convert the data type of expression2 to match that of expression1.

trace(5 != 8); // returns true 
trace(5 != 5) //returns 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 
// trace statement output: foo foo true foo foo 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 
// trace statement output: 1,2,3 1,2,3 true 1,2,3 1,2,3 false 

<>

inequality Operator

Deprecated since Flash Player 5 — This operator has been deprecated. Macromedia recommends that you use the != (inequality) operator.

Tests for the exact opposite of the equality (==) operator. If expression1 is equal to expression2, the result is false. As with the equality (==) operator, the definition of equal depends on the data types being compared:

• Numbers, strings, and Boolean values are compared by value.
• Objects, arrays, and functions are compared by reference.
• Variables are compared by value or by reference depending on their type.

instanceof Operator

Tests whether object is an instance of classConstructor or a subclass of classConstructor. The instanceof operator does not convert primitive types to wrapper objects. For example, the following code returns true:

new String("Hello") instanceof String;

"Hello" instanceof String;

<

less than Operator

Compares two expressions and determines whether expression1 is less than expression2; if so, the operator returns true. If expression1 is greater than or equal to expression2, the operator returns false. String expressions are evaluated using alphabetical order; all capital letters come before lowercase letters.

trace(3 < 10); // 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 

lt

less than (strings) Operator

Deprecated since Flash Player 5 — This operator was deprecated in favor of the < (less than) operator.

Compares expression1 to expression2 and returns true if expression1 is less than expression2, false otherwise.

<=

less than or equal to Operator

Compares two expressions and determines whether expression1 is less than or equal to expression2; if it is, the operator returns true. If expression1 is greater than expression2, the operator returns false. String expressions are evaluated using alphabetical order; all capital letters come before lowercase letters.

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 

le

less than or equal to (strings) Operator

Deprecated since Flash Player 5 — This operator was deprecated in Flash 5 in favor of the <= (less than or equal to) operator.

Compares expression1 to expression2 and returns a value of true if expression1 is less than or equal to expression2, false otherwise.

//

line comment delimiter Operator

Indicates the beginning of a script comment. Any characters that appear between the comment delimiter (//) and the end-of-line character are interpreted as a comment and ignored by the ActionScript interpreter.

// record the X position of the ball movie clip 
var ballX:Number = ball_mc._x; 
// record the Y position of the ball movie clip 
var ballY:Number = ball_mc._y; 
// record the X position of the bat movie clip 
var batX:Number = bat_mc._x; 
// record the Y position of the ball movie clip 
var batY:Number = bat_mc._y; 

&&

logical AND Operator

Performs a Boolean operation on the values of both expressions. If expression1 and expression2 are both true, then true is returned; otherwise, false is returned.

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

and

logical AND Operator

Deprecated since Flash Player 5 — Macromedia recommends that you use the logical AND (&&) operator.

Performs a logical AND (&&) operation in Flash Player 4. If both expressions evaluate to true, the entire expression is true.

!

logical NOT Operator

Inverts the Boolean value of a variable or expression. If expression is a variable with the absolute or converted value true, the value of ! expression is false. If the expression x && y evaluates to false, the expression !(x && y) evaluates to true.

The following expressions illustrate the result of using the logical NOT (!) operator:

! true returns false
! false returns true

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

not

logical NOT Operator

Deprecated since Flash Player 5 — This operator was deprecated in favor of the ! (logical NOT) operator.

Performs a logical NOT (!) operation in Flash Player 4.

||

logical OR Operator

Evaluates expression1 (the expression on the left side of the operator) and returns true if the expression evaluates to true. If expression1 evaluates to false, expression2 (the expression on the right side of the operator) is evaluated. If expression2 evaluates to false, the final result is false; otherwise, it is true.

If you use a function call as expression2, the function will not be executed by that call if expression1 evaluates to true.

The result is true if either or both expressions evaluate to true; the result is false only if both expressions evaluate to false. You can use the logical OR operator with any number of operands; if any operand evaluates to true, the result is true.

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

The following example demonstrates how using a function call as expression2 can lead to unexpected results. If the expression on the left of the operator evaluates to true, that result is returned without evaluating the expression on the right (the function fx2() is not called).

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

or

logical OR Operator

Deprecated since Flash Player 5 — This operator was deprecated in favor of the || (logical OR) operator.

Evaluates condition1 and condition2, and if either expression is true, the whole expression is true.

%

modulo Operator

Calculates the remainder of expression1 divided by expression2. If either of the expression parameters are non-numeric, the modulo (%) operator attempts to convert them to numbers. The expression can be a number or string that converts to a numeric value.

The sign of the result of modulo operation matches the sign of the dividend (the first number). For example, -4 % 3 and -4 % -3 both evaluate to -1.

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

%=

modulo assignment Operator

Assigns expression1 the value of expression1 % expression2. The following two statements are equivalent:

x %= y; 
x = x % y;

var x:Number = 14; 
var y:Number = 5; 
trace(x = y); // output: 4 

*

multiplication Operator

Multiplies two numerical expressions. If both expressions are integers, the product is an integer. If either or both expressions are floating-point numbers, the product is a floating-point number.

trace(2*3); // output: 6 

trace(2.0 * 3.1416); // output: 6.2832 

*=

multiplication assignment Operator

Assigns expression1 the value of expression1 * expression2. For example, the following two expressions are equivalent:

x *= y;
x = x * y 

var x:Number = 5; 
var y:Number = 10; 
trace(x *= y); // output: 50 

var i:Number = 5; 
var x:Number = 4 - 6; 
var y:Number = i + 2; 
trace(x *= y); // output: -14 

new Operator

Creates a new, initially anonymous, object and calls the function identified by the constructor parameter. The new operator passes to the function any optional parameters in parentheses, as well as the newly created object, which is referenced using the keyword this. The constructor function can then use this to set the variables of the object.

function Book(name, price){
  this.name = name;
  this.price = price;
}

book1 = new Book("Confederacy of Dunces", 19.95);
book2 = new Book("The Floating Opera", 10.95);

golfCourse_array = new Array(18);

ne

not equal (strings) Operator

Deprecated since Flash Player 5 — This operator was deprecated in favor of the != (inequality) operator.

Compares expression1 to expression2 and returns true if expression1 is not equal to expression2; false otherwise.

{}

object initializer Operator

object = { name1 : value1 , name2 : value2 ,... nameN : valueN }
{expression1; [...expressionN]}

Creates a new object and initializes it with the specified name and value property pairs. Using this operator is the same as using the new Object syntax and populating the property pairs using the assignment operator. The prototype of the newly created object is generically named the Object object.

This operator is also used to mark blocks of contiguous code associated with flow control statements (for, while, if, else, switch) and functions.

var object:Object = {}; 
var object:Object = new Object(); 

var account:Object = {name:"Macromedia, Inc.", address:"600 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"; 

var person:Object = new Object(); 
person.name = "Gina Vechio"; 
person.children = new Array("Ruby", "Chickie", "Puppa"); 

()

parentheses Operator

(expression1 [, expression2])
( expression1, expression2 )
function ( parameter1,..., parameterN ) 

Performs a grouping operation on one or more parameters, performs sequential evaluation of expressions, or surrounds one or more parameters and passes them as parameters to a function outside the parentheses.

Usage 1: Controls the order in which the operators execute in the expression. Parentheses override the normal precedence order and cause the expressions within the parentheses to be evaluated first. When parentheses are nested, the contents of the innermost parentheses are evaluated before the contents of the outer ones.

Usage 2: Evaluates a series of expressions, separated by commas, in sequence, and returns the result of the final expression.

Usage 3: Surrounds one or more parameters and passes them as parameters to the function outside the parentheses.

Usage 1: The following statements show the use of parentheses to control the order in which expressions are executed (the value of each expression is written to the log file):

trace((2 + 3)*(4 + 5)); // Output: 45 
trace((2 + 3) * (4 + 5)); // Output: 45trace(2 + (3 * (4 + 5))); // // writes 29 
trace(2 + (3 * (4 + 5))); // Output: 29trace(2+(3*4)+5); // writes 19 
trace(2 + (3 * 4) + 5); // Output: 19 

var a:Number = 1; 
var b:Number = 2; 
function foo() { a += b; } 
function bar() { b *= 10; } 
trace((foo(), bar(), a + b)); // outputs 23 

var today:Date = new Date(); 
trace(today.getFullYear()); // traces current year 
function traceParameter(param):Void { trace(param); } 
traceParameter(2 * 2); //traces 4 

===

strict equality Operator

Tests two expressions for equality; the strict equality (===)operator performs in the same way as the equality (==) operator, except that data types are not converted. The result is true if both expressions, including their data types, are equal.

The definition of equal depends on the data type of the parameter:

• Numbers and Boolean values are compared by value and are considered equal if they have the same value.
• String expressions are equal if they have the same number of characters and the characters are identical.
• Variables representing objects, arrays, and functions are compared by reference. Two such variables are equal if they refer to the same object, array, or function. Two separate arrays are never considered equal, even if they have the same number of elements.

// Both return true because no conversion is done 
var string1:String = "5"; 
var string2:String = "5"; 
trace(string1 == string2); // true 
trace(string1 === string2); // true 
// Automatic data typing in this example converts 5 to "5" 
var string1:String = "5"; 
var num:Number = 5; 
trace(string1 == num); // true 
trace(string1 === num); // false 
// Automatic data typing in this example converts true to "1" 
var string1:String = "1"; 
var bool1:Boolean = true; 
trace(string1 == bool1); // true 
trace(string1 === bool1); // false 
// Automatic data typing in this example converts false to "0" 
var string1:String = "0"; 
var bool2:Boolean = false; 
trace(string1 == bool2); // true 
trace(string1 === bool2); // false 

// Create a string variable using a literal value 
var str:String = "asdf"; 
// Create a variable that is a reference 
var stringRef:String = new String("asdf"); 
// The equality operator does not distinguish among literals, variables, 
// and references 
trace(stringRef == "asdf"); // true 
trace(stringRef == str); // true 
trace("asdf" == str); // true 
// The strict equality operator considers variables that are references 
// distinct from literals and variables 
trace(stringRef === "asdf"); // false 
trace(stringRef === str); // false 

!==

strict inequality Operator

Tests for the exact opposite of the strict equality (=== )operator. The strict inequality operator performs the same as the inequality operator except that data types are not converted.

If expression1 is equal to expression2, and their data types are equal, the result is false. As with the strict equality (===) operator, the definition of equal depends on the data types being compared, as illustrated in the following list:

• Numbers, strings, and Boolean values are compared by value.
• Objects, arrays, and functions are compared by reference.
• A variable is compared by value or by reference, depending on its type.

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 

"

string delimiter Operator

When used before and after characters, quotation marks (") indicate that the characters have a literal value and are considered a string, not a variable, numerical value, or other ActionScript element.

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

-

subtraction Operator

(Negation) -expression
(Subtraction) expression1 - expression2

Used for negating or subtracting.

Usage 1: When used for negating, it reverses the sign of the numerical expression.
Usage 2: When used for subtracting, it performs an arithmetic subtraction on two numerical expressions, subtracting expression2 from expression1. When both expressions are integers, the difference is an integer. When either or both expressions are floating-point numbers, the difference is a floating-point number.

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

trace(5-2); // output: 3 

trace(3.25-1.5); // output: 1.75 

-=

subtraction assignment Operator

Assigns expression1 the value of expression1- expression2. For example, the following two statements are equivalent: x -= y ; x = x - y;

String expressions must be converted to numbers; otherwise, NaN (not a number) is returned.

var x:Number = 5; 
var y:Number = 10; 
x -= y; trace(x); // output: -5 

var x:String = "5"; 
var y:String = "10"; 
x -= y; trace(x); // output: -5 

:

type Operator

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

Used for strict data typing; this operator specifies the variable type, function return type, or function parameter type. When used in a variable declaration or assignment, this operator specifies the variable's type; when used in a function declaration or definition, this operator specifies the function's return type; when used with a function parameter in a function definition, this operator specifies the variable type expected for that parameter.

Types are a compile-time-only feature. All types are checked at compile time, and errors are generated when there is a mismatch. Mismatches can occur during assignment operations, function calls, and class member dereferencing using the dot (.) operator. To avoid type mismatch errors, use strict data typing.

Types that you can use include all native object types, classes and interfaces that you define, and Function and Void. The recognized native types are Boolean, Number, and String. All built-in classes are also supported as native types.

var userName:String = ""; 

function randomInt(integer:Number):Number { 
    return Math.round(Math.random()*integer); 
} 
trace(randomInt(8)); 

function squareRoot(val:Number):Number { 
    return Math.sqrt(val); 
} 
trace(squareRoot(121)); 

typeof Operator

Evaluates the expression and returns a string specifying whether the expression is a String, MovieClip, Object, Function, Number, or Boolean value.

void Operator

The void operator evaluates an expression and then discards its value, returning undefined. The void operator is often used in comparisons using the == operator to test for undefined values.