You want to check if two values are equal.

Use the equality (or inequality) or strict equality (or strict inequality) operator to compare two values. To check whether a value is a valid number, use isNaN( ).

Equality expressions always return a Boolean value indicating whether the two values are equal. The equality (and inequality) operators come in both regular and strict flavors. The regular equality and inequality operators check whether the two expressions being compared can be resolved to the same value after converting them to the same datatype. For example, note that the string "6" and the number 6 are considered equal because the string "6" is converted to the number 6 before comparison:

trace(5 == 6);    // Displays: false
   trace(6 == 6);    // Displays: true
   trace(6 == "6");  // Displays: true
   trace(5 == "6");  // Displays: false

The logical inequality operator (!=) returns false if two values are equal and true if they are not equal. If necessary, the operands are converted to the same datatype before the comparison:

trace(5 != 6);    // Displays: true
   trace(6 != 6);    // Displays: false
   trace(6 != "6");  // Displays: false
   trace(5 != "6");  // Displays: true

On the other hand, the strict equality and inequality operators first check whether the values being compared are of the same datatype before performing the comparison. Differences in datatype cause the strict equality operator to return false and the strict inequality operator to return true:

trace(6 === 6);    // Displays: true
   trace(6 === "6");  // Displays: false
   trace(6 !== 6);    // Displays: false
 trace(6 !== "6");  // Displays: true

There is a big difference between the assignment operator (=) and the equality operator (==). If you use the assignment operator instead of the equality operator, you change the variable's value rather than testing its current value.

Using the wrong operator leads to unexpected results. In the following example, myVar equals 5 at first, so you might expect the subsequent if statement to always evaluate to false, preventing the trace( ) from being executed:

var myVar = 5;
   // The following code is wrong. It should be if (myVar == 6) instead
   if (myVar = 6) {
   trace("Rabbits are bunnies.");
   }
   trace("myVar is " + myVar);  // Displays: myVar is 6

However, the example mistakenly uses the assignment operator (=) instead of the equality operator (==). That is, the expression myVar = 6 sets myVar to 6 instead of testing whether myVar is 6. When used in an if clause, the expression myVar = 6 is treated as the number 6. Because any nonzero number used in a test expression converts to the Boolean true, the trace( ) action is called. Replace the test expression with myVar == 6 instead.

You can check an item's datatype using the typeof operator, as follows:

var myVar = 5;
   if (typeof myVar == "number") {
   trace("Yippee. It's a number.");
   }

But some numeric values are invalid. The following example results in myVar being set equal to NaN (a constant representing invalid numbers, short for "Not-a-Number") because the calculation cannot be performed in a meaningful way:

var myVar = 15 - "coffee";

Despite its name, NaN is a recognized value of the number datatype:

trace(typeof myVar);   // Displays: "number"

Therefore, to test if something is not only a number, but a valid number, you might try this:

var myVar = 15 - "coffee";
   if (typeof myVar == "number") {
   // Nice try, but this won't work.
   if (myVar != NaN) {
   trace("Yippee. It's a number.");
   }
 }

You can't simply compare a value to the constant NaN to check whether it is a valid number. Instead, you must use the special isNaN( ) function to perform the test.

To determine if a number is invalid, use the special isNaN( ) function, as follows:

var myVar = 15 - "coffee";
   if (isNaN(myVar)) {
   trace("Sorry, that is not a valid number.");
   }

To test the opposite of a condition (i.e., whether the condition is not true) use the logical NOT operator (!). For example, to check whether a variable contains a valid number, use !isNAN( ), as follows:

var myVar = 15 - "coffee";
   if (!isNaN(myVar)) {
   // The number is not invalid, so it must be a valid number.
   trace ("That is a valid number.");
   // This jumps to another frame, assuming you've labeled a frame "SuccessScreen".
   gotoAndStop ("SuccessScreen");
   }

Of course, you can perform comparisons using the well-known comparison operators. For example, you can use the > and < operators to check if one value is less than or greater than another value:

trace(5 < 6);    // Displays: true
   trace(5 > 5);    // Displays: false

Similarly, you can use the >= and <= operators to check if one value is less than or equal to, or greater than or equal to, another value:

trace(5 <= 6);   // Displays: true
   trace(5 >= 5);   // Displays: true

You should also be aware that ActionScript compares different datatypes differently. ActionScript data can be categorized into primitive datatypes (string, number, and Boolean) or composite datatypes (object, movieclip, and array). When you compare primitive datatypes, ActionScript compares them "by value." In this example, myVar and myOtherVar are considered equal because they both contain the value 6.

var myVar = 6;
   var myOtherVar = 6;
   trace (myVar == myOtherVar);         // Displays: true

However, when you compare composite datatypes, ActionScript compares them "by reference." Comparing items by reference means that the two items are considered equal only if both point to exactly the same object, not merely to objects with matching contents. For example, two arrays containing exactly the same values are not considered equal:

// Create two arrays with the same elements.
   arrayOne = new Array("a", "b", "c");
   arrayTwo = new Array("a", "b", "c");
   trace(arrayOne == arrayTwo);          // Displays: false

Two composite items are equal only if they both refer to the identical object, array, or movie clip. For example:

// Create a single array
   arrayOne = new Array("a", "b", "c");
   // Create another variable that references the same array.
   arrayOne = arrayTwo;
   trace(arrayOne == arrayTwo);          // Displays: true