Operators 

Converts 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. This operator is also known as the one's complement operator or the bitwise complement operator.

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

A floating-point number is converted to an integer by discarding any digits after the decimal point. A positive integer is converted to an unsigned hexadecimal value with a maximum value of 4294967295 or 0xFFFFFFFF; a value larger than the maximum has its most significant digits discarded when it is converted so the value is still 32-bit. A negative number is converted to an unsigned hexadecimal value using the two's complement notation, with a minimum value of -2147483648 or 0x800000000; a number less than the minimum is converted to two's complement with greater precision before the most significant digits are discarded.

The result is interpreted as a 32-bit two's complement number, so the result is an integer in the range -2147483648 to 2147483647.

var ReadOnlyFlag:int = 0x0001; // defines bit 0 as the read-only flag 
var flags:int = 0; 
trace(flags); 
/* To set the read-only flag in the flags variable, 
   the following code uses the bitwise OR: 
*/
flags |= ReadOnlyFlag; 
trace(flags); 
/* To clear the read-only flag in the flags variable, 
   first construct a mask by using bitwise NOT on ReadOnlyFlag. 
   In the mask, every bit is a 1 except for the read-only flag. 
   Then, use bitwise AND with the mask to clear the read-only flag. 
   The following code constructs the mask and performs the bitwise AND: 
*/ 
flags &= ~ReadOnlyFlag; 
trace(flags); 
// 0 1 0 

Related API Elements

Converts expression1 and expression2 to 32-bit unsigned integers, and places a 1 in each bit position where the corresponding bits of either expression1 or expression2 are 1.

A floating-point number is converted to an integer by discarding any digits after the decimal point. A positive integer is converted to an unsigned hexadecimal value with a maximum value of 4294967295 or 0xFFFFFFFF; a value larger than the maximum has its most significant digits discarded when it is converted so the value is still 32-bit. A negative number is converted to an unsigned hexadecimal value using the two's complement notation, with a minimum value of -2147483648 or 0x800000000; a number less than the minimum is converted to two's complement with greater precision before the most significant digits are discarded.

The result is interpreted as a 32-bit two's complement number, so the result is an integer in the range -2147483648 to 2147483647.

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

Related API Elements

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 a:Number = 15; 
// 9 decimal = 1001 binary 
var b:Number = 9; 
// 1111 |= 1001 = 1111 
trace(a |= b); // returns 15 decimal (1111 binary) 

Related API Elements

Converts expression and shiftCount to 32-bit integers, and shifts all the bits in expression to the right by the number of places specified by the integer that results from the conversion of shiftCount. 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 expression 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.

A floating-point number is converted to an integer by discarding any digits after the decimal point. A positive integer is converted to an unsigned hexadecimal value with a maximum value of 4294967295 or 0xFFFFFFFF; a value larger than the maximum has its most significant digits discarded when it is converted so the value is still 32-bit. A negative number is converted to an unsigned hexadecimal value using the two's complement notation, with a minimum value of -2147483648 or 0x800000000; a number less than the minimum is converted to two's complement with greater precision before the most significant digits are discarded.

The result is interpreted as a 32-bit two's complement number, so the result is an integer in the range -2147483648 to 2147483647.

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

    00000000000000001111111111111111 binary (65535 decimal)
>>                                 8 decimal
--------------------
    00000000000000000000000011111111 binary (255 decimal)

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

    11111111111111111111111111111000 binary (-8 decimal)
>>							    1 decimal
--------------------
    11111111111111111111111111111100 binary (-4 decimal)

Related API Elements

Performs a bitwise right-shift operation and stores the result in expression.

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

Related API Elements

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.

A floating-point number is converted to an integer by discarding any digits after the decimal point. A positive integer is converted to an unsigned hexadecimal value with a maximum value of 4294967295 or 0xFFFFFFFF; a value larger than the maximum has its most significant digits discarded when it is converted so the value is still 32-bit. A negative number is converted to an unsigned hexadecimal value using the two's complement notation, with a minimum value of -2147483648 or 0x800000000; a number less than the minimum is converted to two's complement with greater precision before the most significant digits are discarded.

The result is interpreted as a 32-bit unsigned integer, so the result is an integer in the range 0 to 4294967295.

Note: ActionScript has no complementary "bitwise unsigned left shift" operator, but you can achieve the same effect by using uint(expression << shiftCount).

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

Related API Elements

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

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

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

Related API Elements

Converts expression1 and expression2 to 32-bit unsigned integers, and places a 1 in each bit position where the corresponding bits in expression1 or expression2, but not both, are 1.

A floating-point number is converted to an integer by discarding any digits after the decimal point. A positive integer is converted to an unsigned hexadecimal value with a maximum value of 4294967295 or 0xFFFFFFFF; a value larger than the maximum has its most significant digits discarded when it is converted so the value is still 32-bit. A negative number is converted to an unsigned hexadecimal value using the two's complement notation, with a minimum value of -2147483648 or 0x800000000; a number less than the minimum is converted to two's complement with greater precision before the most significant digits are discarded.

The result is interpreted as a 32-bit two's complement number, so the result is an integer in the range -2147483648 to 2147483647.

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

Related API Elements

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 a:Number = 15; 
// 9 decimal = 1001 binary 
var b:Number = 9; 
trace(a ^= b); // returns 6 decimal (0110 binary) 

Related API Elements

/* comment */

/* comment

   comment */

Delimits one or more lines of script comments. Characters that appear between the opening delimiter (/*) and the closing delimiter (*/) are interpreted as a comment and ignored by the ActionScript compiler. Use these delimiters to identify comments on multiple successive lines; for single-line comments, use the // delimiter.

You will receive an error message if you omit the closing block comment delimiter (*/), or if you attempt to nest comments. After an opening delimiter (/*) is used, the first closing delimiter (*/) ends the comment, regardless of the number of opening delimiters placed before it.

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

Related API Elements

 myXML = {content}{tagName}>

Evaluates an expression that is used in an XML or XMLList initializer. An XML or XMLList initializer is a literal value that is assigned to a variable of type XML or XMLList. An expression that is delimited by the XML { and } operators can be used in an XML or XMLList initializer instead of literal names or values. An expression can be used in place of tagName, attributeName, attributeValue, and content.

var tagname:String = "item"; 
var attributename:String = "id"; 
var attributevalue:String = "5"; 
var content:String = "Chicken"; 
var x:XML = <{tagname} {attributename}={attributevalue}>{content}</{tagname}>; 
trace(x.toXMLString()); // <item id="5">Chicken</item>

Related API Elements

 myXML[expression]

Accesses a property or attribute of an XML or XMLList object. The brackets operator allows you to access property names that are not accessible with the dot (.) operator.

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

Related API Elements

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

Related API Elements

Concatenates (combines) strings. If one expression is a string, all other expressions are converted to strings and concatenated.

If both expressions are numbers, this operator behaves as an addition operator.

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 

Related API Elements

expression1 + expression2

Concatenates (combines) XML or XMLList values into an XMLList object. An XMLList object results only if both operands are XML or XMLList values.

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

The trace statement produces the following output:

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

Related API Elements

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); // My name is Gilbert 

Related API Elements

expression1 += expression2

Assigns expression1, which is an XMLList object, the value of expression1 + expression2. For example, the following two statements have the same result:

x += y; 
x = x + y; 

var x1:XML = <location>Athens</location>;	
var x2:XML = <location>Paris</location>;		
myXMLList = x1 + x2;

var x3:XML = <location>Springfield</location>;
myXMLList += x3;
		    
trace(myXMLList.toXMLString());

The trace statement produces the following output:

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

<location>Springfield</location>

Related API Elements

expression1 ? expression2 : expression3

Evaluates expression1, and if the value of expression1 is true, the result is the value of expression2; otherwise the result is 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); 

--expression

expression--

Subtracts 1 from the operand. The operand 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 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); 
}

 delete reference

Destroys the object property specified by reference; the result is true if the property does not exist after the operation completes, and false otherwise. The delete operator returns true if it is called on a nonexistent property or a dynamic property not defined in a class.

The delete operator can fail and return false if the reference parameter cannot be deleted. You cannot delete fixed properties or variables that are declared with the var statement. A fixed property is a variable or method defined in a class definition.

The delete operator cannot be used to destroy a property of a class, unless that class is a dynamic class added at runtime. Properties of sealed classes cannot be destroyed using delete. Set the property to null instead.

Note: You cannot delete an object, but you can make an object eligible for garbage collection by removing all references to the object. The most common reference to an object is a variable that points to it. You can remove such a reference by setting the variable to null. The garbage collector removes any object that has no references.

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

The following example deletes the value of an array element, but the value of the length property is not changed:

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,

The following example shows how the returned Boolean from delete can be used as a condition for future code execution. Note that if an item has already been deleted, calling delete on the item again will return false.

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

Related API Elements

 delete reference

Deletes the XML elements or attributes specified by reference.

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

The output is as follows:

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

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

The output for this example is the following:

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

 myXML..childElement1..@attributeName 

Navigates to descendant elements of an XML or XMLList object, or (combined with the @ operator) finds matching attributes of descendants. The matching elements or attributes need not be direct children of the XML or XMLList object; they can be lower in the tree (for example, grandchildren). The result is an XMLList object, because more than one child element or attribute can match.

The order of nodes in the XMLList object returned is the result of a depth-first traversal. For example, consider the following:

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

The following output would result:

<b>
  one
  <c>
    <b>two</b>
  </c>
</b>
______________
<b>two</b>
______________
<b>three</b>

To return descendants with names that match ActionScript reserved words, use the XML.descendants() method instead of the descendant (..) operator, as the following example shows:

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

Related API Elements

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

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

Related API Elements

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

x /= y; 
x = x / y;

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

Related API Elements

object.property_or_method

Accesses class variables and methods, gets and sets object properties, and delimits imported packages or classes.

import flash.utils.Timer;

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

Related API Elements

myXML.childElement
myXML.@attributeName 

Navigates to child elements of an XML or XMLList object, or (combined with the @ operator) returns attributes of an XML or XMLList object. The object returned is an XMLList, because more than one child element or attribute can match.

To return elements with names that match ActionScript reserved words, use the XML.elements() method or the XML.descendants() method instead of the XML dot (.) operator, as the following example shows:

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

Related API Elements

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

If the data types of the two operands match, the definition of equal depends on the data type of the operands:

• Values of type int, uint, and Boolean are considered equal if they have the same value.
• Numbers with matching values are considered equal, unless they are both NaN.
• If the value of both operands is null or undefined, they are considered equal.
• String expressions are equal if they have the same number of characters and the characters are identical.
• For XML objects:
  • If one operand is a text or attribute node and the other has simple content, both operands are converted to strings with the toString() method and are considered equal if the resulting strings match.
  • Otherwise, objects are considered equal only if the qualified name, attributes, and child properties for both objects match.
• XMLList objects are considered equal if they have the same number of properties and both the order and values of the properties match.
• For Namespace objects, values are considered equal if the uri properties of both objects match.
• For QName objects, values are considered equal if the uri properties of both objects match and the localName properties of both objects match.
• 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.

• The operands' values are undefined and null, in which case the result is true.
• Automatic data type conversion converts the data types of String, Boolean, int, uint, and Number values to compatible types and the converted values are equal, in which case operands are considered equal.
• One operand is of type XML with simple content (hasSimpleContent() == true), and after both operands are converted to strings with the toString() method, the resulting strings match.
• One operand is of type XMLList, and either of the following conditions is true:
  • The length property of the XMLList object is 0, and the other object is undefined.
  • The length property of the XMLList object is 1, and one element of the XMLList object matches the other operand.

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 

Related API Elements

Compares two expressions and determines whether expression1 is greater than expression2; if it is, the result is true. If expression1 is less than or equal to expression2, the result is false.

If both operands are of type String, the operands are compared using alphabetical order; all capital letters come before lowercase letters. Otherwise, operands are first converted to numbers, then compared.

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

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

Related API Elements

Evaluates whether a property is part of a specific object. To use the in operator, specify a property name as the first operand and an object as the second operand. If the object you specify contains such a property, the result is true; otherwise the result is false.

If the specified object is an Array object, you can use the in operator to check whether a particular index number is valid. If you pass an integer as the first operand, the result is true if the index is within the valid range of index numbers, and false otherwise.

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

The following example uses the in operator to show that the numbers 0, 1, and 2 are valid index numbers in the myArray object, but that the number 3 is not.

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

Related API Elements

++expression

 expression++

Adds 1 to an expression. The expression can be a variable, an element in an array, or a 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).

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

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.

If the data types of the two operands match, the definition of equal depends on the data type of the operands:

• Values of type int, uint, and Boolean are considered equal if they have the same value.
• Numbers with matching values are considered equal, unless they are both NaN.
• If the value of both operands is null or undefined, they are considered equal.
• String expressions are equal if they have the same number of characters and the characters are identical.
• For XML objects:
  • If one operand is a text or attribute node and the other has simple content, both operands are converted to strings with the toString() method and are considered equal if the resulting strings match.
  • Otherwise, objects are considered equal only if the qualified name, attributes, and child properties for both objects match.
• XMLList objects are considered equal if they have the same number of properties and both the order and values of the properties match.
• For Namespace objects, values are considered equal if the uri properties of both objects match.
• For QName objects, values are considered equal if the uri properties of both objects match and the localName properties of both objects match.
• 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.

• The operands' values are undefined and null, in which case the result is true.
• Automatic data type conversion converts the data types of String, Boolean, int, uint, and Number values to compatible types and the converted values are equal, in which case operands are considered equal.
• One operand is of type XML with simple content (hasSimpleContent() == true), and after both operands are converted to strings with the toString() method the resulting strings match.
• One operand is of type XMLList, and either of the following conditions is true:
  • The length property of the XMLList object is 0, and the other object is undefined.
  • The length property of the XMLList object is 1, and one element of the XMLList object matches the other operand.

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

Related API Elements

Evaluates whether an expression's prototype chain includes the prototype object for function. The instanceof operator is included for backward compatibility with ECMAScript edition 3, and may be useful for advanced programmers who choose to use prototype-based inheritance with constructor functions instead of classes.

To check whether an object is a member of a specific data type, use the is operator.

When used with classes, the instanceof operator is similar to the is operator because a class's prototype chain includes all of its superclasses. Interfaces, however, are not included on prototype chains, so the instanceof operator always results in false when used with interfaces, whereas the is operator results in true if an object belongs to a class that implements the specified interface.

Note: The ActionScript is operator is the equivalent of the Java instanceof operator.

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

Related API Elements

Evaluates whether an object is compatible with a specific data type, class, or interface. Use the is operator instead of the instanceof operator for type comparisons. You can also use the is operator to check whether an object implements an interface.

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

Related API Elements

Compares two expressions and determines whether expression1 is less than expression2; if so, the result is true. If expression1 is greater than or equal to expression2, the result is false.

If both operands are of type String, the operands are compared using alphabetical order; all capital letters come before lowercase letters. Otherwise, operands are first converted to numbers, then compared.

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 

Compares two expressions and determines whether expression1 is less than or equal to expression2; if it is, the result is true. If expression1 is greater than expression2, the result is false.

If both operands are of type String, the operands are compared using alphabetical order; all capital letters come before lowercase letters. Otherwise, operands are first converted to numbers, then compared.

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 

Indicates the beginning of a script comment. Characters that appear between the comment delimiter (//) and the end-of-line character are interpreted as a comment and are ignored. Use this delimiter for single-line comments; for comments on multiple successive lines, use the /* and */ delimiters.

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

Related API Elements

Returns expression1 if it is false or can be converted to false, and expression2 otherwise. Examples of values that can be converted to false are 0, NaN, null, and undefined. If you use a function call as expression2, the function is not called if expression1 evaluates to false.

If both operands are of type Boolean, the result is true only if both operands are true, as shown in the following table:

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

Related API Elements

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

x &&= y; 
x = x && y; 

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

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

Related API Elements

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"); // don't worry, be happy 
} 

Related API Elements

Returns expression1 if it is true or can be converted to true, and expression2 otherwise. If you use a function call as expression2, the function is not called if expression1 evaluates to true.

If both operands are of type Boolean, the result is true if either or both expressions are true; the result is false only if both expressions are false, as shown in the following table:

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 
} 

The following example demonstrates how using a function call as the second operand 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");
}

Related API Elements

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

x ||= y; 
x = x || y; 

myVar ||= "default";

Related API Elements

Calculates the remainder of expression1 divided by expression2. If either operand is non-numeric, the modulo (%) operator attempts to convert it to a number.

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

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

Related API Elements

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

x %= y; 
x = x % y; 

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

Related API Elements

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

trace(2.0 * 3.1416); // 6.2832 

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

x *= y 
x = x * y 

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

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

Related API Elements

namespace::property

namespace::method()

namespace::xmlObject.property

namespace::xmlObject.@attribute

Identifies the namespace of a property, a method, an XML property, or an XML attribute.

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

Related API Elements

Instantiates a class instance. The new operator can be used with a class or a variable of type Class to create an instance of a class. The new operator is commonly used with a class object to create an instance of a class. For example, the statement new Sprite() creates an instance of the Sprite class.

The new operator can also be used to associate a class with an embedded asset, which is an external object such as an image, sound, or font that is compiled into a SWF file. Each embedded asset is represented by a unique embedded asset class. To access an embedded asset, you must use the new operator to instantiate its associated class. Subsequently, you can call the appropriate methods and properties of the embedded asset class to manipulate the embedded asset.

If you prefer to define classes with Function objects instead of the class keyword, you can use the new operator to create objects based on constructor functions. Do not confuse constructor functions with constructor methods of a class. A constructor function is a Function object that is defined with the function keyword, but that is not part of a class definition. If you use constructor functions to create objects, you must use prototype inheritance instead of class inheritance.

class Book {
  var bName:String;
  var bPrice:Number;
  
  public function Book(nameParam:String, priceParam:Number){
    bName = nameParam;
    bPrice = priceParam;
  }
}

var book1:Book = new Book("Confederacy of Dunces", 19.95);
var book2:Book = new Book("The Floating Opera", 10.95);
trace(book1); // [object Book]

var golfCourse:Array = new Array(18);

Related API Elements

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

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

Related API Elements

(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 arguments to a function that precedes the parentheses.

Usage 1: Controls the order in which the operators execute. 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 to the function that precedes the parentheses.

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 

Related API Elements

myXML.(expression)

Evaluates an expression in an ECMAScript for XML (E4X) XML construct. For example, myXML.(lastName == "Smith") identifies XML elements with the name lastName and the value "Smith". The result is an XMLList object.

var myXML:XML = 
	<employees>
		<employee id = "42">
			<firstName>Joe</firstName>
			<lastName>Smith</lastName>
		</employee>
		<employee id = "43">
			<firstName>Susan</firstName>
			<lastName>Jones</lastName>
		</employee>
		<employee id = "44">
			<firstName>Anne</firstName>
			<lastName>Smith</lastName>
		</employee>
	</employees>;
	
trace(myXML.employee.(lastName == "Smith").@id.toXMLString()); 
	// 42
	// 44
                
trace(myXML.employee.(Number(@id) > 42).@id.toXMLString()); 
	// 43
	// 44

Related API Elements

/pattern/flags

When used before and after characters, indicates that the characters have a literal value and are considered a regular expression (RegExp), not a variable, string, or other ActionScript element. Note, however, that two sequential forward slash characters (//) indicate the beginning of a comment.

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

Related API Elements

Tests two expressions for equality, but does not perform automatic data conversion. The result is true if both expressions, including their data types, are equal.

The strict equality (===) operator is the same as the equality (==) operator in three ways:

• 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.

• The strict equality operator performs automatic data conversion only for the number types (Number, int, and uint), whereas the equality operator performs automatic data conversion for all primitive data types.
• When comparing null and undefined, the strict equality operator returns false.

First, comparisons between primitive values and primitive objects that contain the same value return true in ActionScript 3.0, but false in earlier versions. In earlier versions, the data type of a primitive value is either Boolean, Number, or String, whereas the data type of a primitive object is always Object rather than Boolean, Number or String. The practical effect of this difference is that the following code results in false in previous versions of ActionScript because the data types of the operands do not match, but the result is true in ActionScript 3.0 because primitive values are typed as either Boolean, Number, int, uint, or String, whether they are wrapped in an object or not.

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 

Related API Elements

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

If expression1 is equal to expression2, and their data types are equal, the result is false.

The strict inequality (!==) operator is the same as the inequality (!=) operator in three ways:

• 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.

• The strict inequality (!==) operator performs automatic data conversion only for the number types, Number, int, and uint, whereas the inequality (!=) operator performs automatic data conversion for all primitive data types.
• When comparing null and undefined, the strict inequality (!==) operator returns true.

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

Related API Elements

 "text" 

When used before and after characters, indicates 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); }; 
// Prince Edward Island

Related API Elements

-expression

 expression1 - expression2

Used for negating or subtracting.

Usage 1: When used for negating, the operator reverses the sign of a numerical expression.

Usage 2: When used for subtracting, the operator 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)); // -5 

trace(5 - 2); // 3 

The following statement subtracts the floating-point number 1.5 from the floating-point number 3.25:

trace(3.25 - 1.5); // 1.75 

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, the result is NaN (not a number).

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 

Related API Elements

[modifiers] var variableName:type

function functionName():type { ... }

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

Used for assigning a data type; 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.

Type checking always occurs at run time. However, when the compiler is set to strict mode, all types are also 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.

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

If you do not assign a data type, the variable, function return value, or function parameter is considered untyped, which means that the value can be of any data type. If you wish to make clear your intent to use an untyped value, you can use the asterisk (*) character as the type annotation. When used as a type annotation, the asterisk character is equivalent to leaving a variable, function return type, or function parameter untyped.

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

Related API Elements

Evaluates expression and returns a string specifying the expression's data type. The result is limited to six possible string values: boolean, function, number, object, string, and xml. If you apply this operator to an instance of a user-defined class, the result is the string object. The typeof operator is included for backward compatibility. Use the is operator to check type compatibility.

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 

Related API Elements

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

 myXML= {content}{tagName}>

Defines an XML tag in an XML literal. Use the forward slash / to define the closing tag.

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

Related API Elements