Chapter 5. Operators

5.1.1. Operators and Expressions

player1score + bonusScore;              // Operands are variables
(x + y) - (Math.PI * radius * radius);  // Operands are complex expressions

Observe in the second example that both the left and right operands of the - operator are expressions that themselves involve other operations. We can use complex expressions to create even larger expressions, such as:

((x + y) - (Math.PI * radius * radius)) / 2  // Divide the whole thing by 2

When expressions become very large, consider using variables to hold interim results for both convenience and clarity. Remember to name your variables descriptively, such as:

var radius = 10;
var height = 25;
var circleArea = (Math.PI * radius * radius);
var cylinderVolume = circleArea * height;

5.1.2. Number of Operands

-x                                         // One operand
x * y                                      // Two operands
(x == y) ? "true result" : "false result"  // Three operands

Single-operand operators are called unary operators; operators with two operands are called binary operators; operators with three operands are called ternary operators. For our purposes, we'll look at operators according to what they do, not the number of operands they take.

5.1.3. Operator Precedence

4 + 5 * 6  // Yields 34, because 4 + 30 = 34

(4 + 5) * 6  // Yields 54, because 9 * 6 = 54

Even if not strictly necessary, parentheses can make a complicated expression more readable. The expression:

// x is greater than y or y equals z
x > y || y == z

may be difficult to comprehend without consulting a precedence table. It's a lot easier to read with parentheses added:

(x > y) || (y == z)  // Much better!

Table 5-1. ActionScript Operator Associativity and Precedence

5.1.4. Operator Associativity

As we've just learned, operator precedence indicates the pecking order of operators: those with a higher precedence are executed before those with a lower precedence. But what happens when multiple operators occur together and have the same level of precedence? In such a case, we apply the rules of operator associativity, which indicate the direction of an operation. Operators are either left-associative (performed left to right) or right-associative (performed right to left). For example, consider this expression:

a = b * c / d

The * and / operators are left-associative, so the * operation on the left (b * c) is performed first. The preceding example is equivalent to:

a = (b * c) / d

In contrast, the = (assignment) operator is right-associative, so the expression:

a = b = c = d

says "assign d to c, then assign c to b, then assign b to a," as in:

a = (b = (c = d))

5.1.5. Datatypes and Operators