The data we use in ActionScript programming comes in a variety of types. So far, we've seen numbers and text, but other types include Booleans, arrays, functions, and objects. Before we cover each datatype in detail, let's examine some datatype issues that relate specifically to variable usage.
Any ActionScript variable can contain any type of data, which may seem unremarkable, but the ability to store any kind of data in any variable is actually a bit unusual. Languages like C++ and Java use strictly typed variables; each variable can accept only one type of data, which must be specified when the variable is declared. ActionScript variables are automatically typed; when we assign data to a variable, the interpreter sets the variable's datatype for us.
Not only can ActionScript variables contain any datatype, they can also dynamically change datatypes. If we assign a variable a new value that has a different type than the variable's previous value, the variable is retyped automatically. So the following code is legal in ActionScript:
x = 1; // x is a number x = "Michael"; // x is now a string x = [4, 6, "hello"]; // x is now an array x = 2; // x is a number again
In languages that do not perform automatic retyping, such as C++ and Java, data of the wrong type is converted to the variable's existing datatype (or it causes an error if conversion cannot be performed). By comparison, VB.NET allows the programmer to decide whether the compiler should enforce strict typing. Strict typing may seem cumbersome, but it can prevent the errors that unsuspecting programmers may encounter due to automatic and dynamic typing, which we'll consider in the following sections.
In some contexts, ActionScript expects a specific type of data. If we use a variable whose value does not match the expected type, the interpreter attempts to convert the data to the necessary type. For example, if we use a text variable where a number is needed, the interpreter will try to convert the variable's text value to a numeric value for the sake of the current operation. In Example 2-2, z is set to 2. Why? Because the subtraction operator expects a number, the value of y is converted from the string "4" to the number 4, which is subtracted from 6 (the value of x), yielding the result 2.
x = 6; // x is a number, 6 y = "4"; // y is a string, "4" z = x - y; // This sets z to the number 2
Conversely, if we use a numeric variable where a string is expected, the interpreter attempts to convert the number to a string. In Example 2-3, z is set to the string "64", not the number 10. Why? Because the second operand in the expression x + y is a string. Therefore, the + operator performs string concatenation instead of mathematical addition. The value of x (6) is converted to the string "6" and then concatenated with the string "4" (the value of y), yielding the result "64".
x = 6; // x is a number, 6 y = "4"; // y is a string, "4" z = x + y; // This sets z to the string "64"
The automatic type conversion that occurs when evaluating a variable as part of an expression is performed on a copy of the variable's data—it does not affect the original variable's type. A variable's type changes only when the variable is assigned a data value that does not match its previous value's type. So, at the conclusion of Example 2-2 and Example 2-3, y remains a string, and x remains a number.
Notice that the operator on line 3 (- in Example 2-2, + in Example 2-3), has a profound impact on the value assigned to z. In Example 2-2 the string "4" becomes the number 4, whereas in Example 2-3 the opposite occurs (the number 6 becomes the string "6"), because the rules for datatype conversion are different for the + operator than for the - operator. We'll cover data conversion rules in Chapter 3 and operators in Chapter 5.
Automatic datatyping and conversion can be convenient, but, as Example 2-2 and Example 2-3 illustrate, they may also produce unexpected results. Before performing commands that operate on mixed datatypes, you may wish to determine a variable's datatype using the typeof operator:
productName = "Macromedia Flash"; // String value trace(typeof productName); // Displays: "string"
Once we know a variable's type, we can proceed conditionally. Here, for example, we check whether a variable is a number before proceeding:
if (typeof age = = "number") {
// okay to carry on
} else {
trace ("Age isn't a number"); // Display an error message
}
For full details on the typeof operator, see Chapter 5.
