Operator Precedence

The output of this script, shown in Figure 2.11, demonstrates the use of the pre- and post-increment operators. These operators add 1 to the variable they operate on. The only difference between putting the ++ before and putting it after has to do with when the variable is incremented.

Figure 2.11: The pre- and post-increment operators both add 1 to a variable ”the difference is when it happens.

When a variable is used in an expression along with the pre-increment operator (the operator goes before the variable), the variable is incremented; afterward, its value is plugged into the rest of the expression. On the other hand, when the post-increment operator is used (the operator goes after the variable), the expression is evaluated with the original (non-incremented) value; afterward, the variable is incremented.

Pre-Decrement and Post-Decrement (--)

Let's have another example to further demonstrate the pre- and post-operations. This time, we'll use the decrement operator, which subtracts 1 from the variable. In terms of pre and post, the decrement operator works identically to the increment operator:

myNumber = 10;
result = --myNumber * 2;
trace(result);
myNumber = 10;
result = myNumber-- * 2;
trace(result);

This output of this script, revealed in Figure 2.12, shows the first result to be 18 and the second result to be 20. That's because the first result used the pre-decrement operator, so the myNumber variable was first reduced from 10 to 9 and then multiplied by 2 for a result of 18. In the second case, the post-decrement operator was used, which caused the multiplication to be evaluated first while the value of myNumber was still at 10; afterward, myNumber was decremented down to 9.

Figure 2.12: The pre- and post-decrement operators work identically to increment except that they subtract 1 instead of adding it.

Modulus (%)

The modulus operator, which is invoked by using the percent symbol, is an interesting little operator that has more uses than you might expect at first glace. In essence, modulus gives you the remainder after integer division. In other words, the operand before modulus is divided by the operand after modulus, and the remainder is what ends up coming out of the expression. An example will make things clearer:

trace( 5 % 2 );
trace( 10 % 2 );
trace( 10 % 3 );
trace( 1 % 5 );
trace( 7 % 0 );

The script, whose output can be seen in Figure 2.13, outputs the following values: 1 , , 3 , 1 , NaN . Let's consider each line one at a time. The first line shows 5 modulus 2. The result of 5 / 2 is 2 with a remainder of 1, so 1 is the output. The second line shows 10 modulus 2.

Figure 2.13: The modulus operator gives the remainder after integer division.

Because 10 can be divided by 2 a total of 5 times with no remainder, the output is . The third line shows 10 modulus 3. When 3 is divided into 10, it can go 3 times with a remainder of 1, so the output is 1 . On line 4, the script says 1 modulus 5. Because 5 cannot be divided into 1, the remainder is 1, and so is the output. Finally, in line 5, the expression reads 7 modulus 0, but modulus of 0 is undefined in mathematics, so the expression cannot properly evaluate. As a result, the output is NaN , which stands for Not a Number. NaN is Flash's way of telling you that the expression cannot be evaluated as a real number.

Compound Assignments (+=, -=, *=, /=, %=)

Many of your scripts will involve evaluating expressions and assigning the result to a variable. While doing this, you will notice that a great deal of the time, you are using the same variable in the expression that you are assigning to. For example, if you had a variable and you wanted to add 100 to it, you could do something like the following:

myNumber = myNumber + 100;

In ActionScript, however, you could write that expression in a more efficient way that involves the use of what is called a compound assignment . Consider the following alternative statement:

myNumber += 100;