Recipe 1.2 Checking Equality or Comparing Values
1.2.1 Problem
You want to check if two values are
equal.
1.2.2 Solution
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(
).
1.2.3 Discussion
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
1.2.4 See Also
Recipe 6.8
|