Now that you know how a typical statement is formed, skim Table 6-1 to acquaint yourself with some of the things that ActionScript statements do.
|
Statement |
Syntax |
Use |
|---|---|---|
break; |
Aborts a loop or switch statement |
|
|
case |
case expression: statements |
Identifies a statement to be executed conditionally in a switch statement |
continue; |
Skips the remaining statements in the current loop and begins the next iteration at the top of the loop |
|
|
default |
default: statements |
Identifies the statement(s) to execute in a switch statement when the test expression does not match any case clauses |
do {
statements
} while (expression);
|
A variation of a while loop that ensures at least one iteration of the loop is performed |
|
|
empty statement |
; |
Holds a place where a statement is expected; used with evaluate in Normal Mode |
for (init; test; increment) {
statements
}
|
Executes a statement block repetitively (a for loop) |
|
for (property in object) {
statements
}
|
Enumerates the properties of an object |
|
function name (parameters) {
statements
}
|
Declares a function |
|
if (expression) {
statements
} else if (expression) {
statements
} else {
statements
}
|
Executes one or more statements, based on a condition or a series of conditions |
|
ifFrameLoaded (frame) {
statements
}
|
Executes specified code if a certain frame has loaded; deprecated as of Flash 5 |
|
return; return expression; |
Exits and optionally returns a value from a function |
|
set(variable, value); |
Assigns a value to a dynamically named variable |
|
|
switch |
switch (expression) {
statements
}
|
Executes specified code, based on a condition or a series of conditions (alternative to if-else if-else) |
var variableName; var variableName = expression; |
Declares and optionally initializes a variable |
|
while (expression) {
statements
}
|
Executes a statement block repetitively (a while loop) |
|
with (objectName) {
statements
}
|
Executes a statement block in the scope of a given object |
We've already had several informal encounters with loops and conditionals. Together, these two statement types account for the majority of complex flow in our programs. Loops allow us to execute statement blocks repeatedly, and conditionals allow us to execute statement blocks under only the specified circumstances. See Chapter 7 and Chapter 8 for complete details.
Although any expression can be used independently as a valid statement, if the expression performs no action and we don't do anything with the result, the exercise is rather pointless:
"hi there"; // This doesn't do much 345 + 5; // Neither does this
Some expressions, however, have side effects that change the state of a system through variable or property assignments or by physically altering the Flash environment. In this example, an expression changes the value of x:
x = 345 + 5; // Much more useful
Function calls are the most powerful type of expression statement. Even if a function doesn't return a useful value, it may have a very useful side effect. For example, gotoAndStop( ) returns the value undefined but has an important side effect—it moves the playhead to another frame:
gotoAndStop(5); // The value of _currentframe is changed to 5.
We'll learn more about function calls in Chapter 9 under "Running Functions."
The var statement declares a new variable:
var x;
You can assign the new variable's initial value as part of a var statement:
var x = 10;
When used outside a function, the var statement creates a variable scoped to the timeline containing the statement. When used inside a function, the var statement creates a variable local to that function (i.e., one that dies when the function finishes). Refer back to Chapter 2 for more information on variables.
For most variable assignments, we use an assignment expression in statement form, like this:
x = 30;
This kind of expression, however, requires us to know the name of our variable in advance. If we want to generate the name of a variable dynamically during an assignment, we can use the set statement, which has the following syntax:
set(variable, expression);
where variable is a string expression to be used as the variable name in the assignment and expression is the new value to assign to it. For example:
var x;
set("x", 10); // x is now 10
var firstName;
set("first" + "Name", "jane"); // firstName is now "jane"
In the following, trickier example, y is not set in the set statement. Instead, y's value ("x") is retrieved and that value is used as the name of the variable to set:
// Pay close attention to this one... var y = "x"; var x; set(y, 15); // x is now 15, y is still "x".
In Flash 4, set was called Set Variable, and it was often used to dynamically assign variables that had programmatically generated sequential names. It allowed programmers to simulate arrays, which were not a native part of Flash 4 ActionScript. Since arrays were added in Flash 5, set is rarely used anymore. In most cases, a variable can be referenced dynamically with the object property access operator, [ ]. For example,
// Set the value of firstName in the form_mc movie clip. form_mc["first" + "Name"] = "jane"; // Set the value of firstName in the current movie clip. this["first" + "Name"] = "jane";
However, set is required when dynamically referring to a local variable in a function (because local variables are not properties of any exposed ActionScript object).
Just as the var statement is used to declare (i.e., create) variables, the function statement is used to declare functions. The function statement has the following syntax:
function funcName (param1, param2, param3,...paramn) {
statements
}
The keyword function begins the statement; funcName is the name of the function being declared; param1 through paramn define the parameters required by the function when it executes (parameters are separated by commas); statements is a list of one or more statements that will be executed when the function is called.
The function statement declares a function for later use but does not execute that function. To execute a function, we use the function's name in a function call statement, which we'll discuss next.
A function call statement executes a built-in or user-defined function simply by using the function's name and providing the inputs that the function needs to perform its job. The terms call, run, and invoke are often used interchangeably to mean that a function's name has been used to cause it to execute. Function call statements have the following general syntax:
funcName(arg1, arg2, ... argn);
where funcName is the name of the function we want to execute and arg1 through argn is the list of arguments (i.e., input values) that the function expects when it runs.
The function call statement is an extremely powerful and fundamental device; it's our primary means of controlling Flash movies. When we want to manipulate a movie in some way, we often call a function. Here are a few examples:
play(); // Plays the current movie
gotoAndStop(5); // Sends the playhead to frame 5
startDrag("crosshair", true); // Makes the "crosshair" instance follow
// the mouse pointer
Function calls are also used with objects to invoke methods:
circle.getArea(); today.getDate();
Because movie clip instances are objects, we frequently use method invocation in our scripts:
ball_mc.play()
intro_mc.gotoAndStop("end");
We'll cover the use of functions in Chapter 9, and in Chapter 12 we'll see how functions can become object methods.
When we call a function, we can optionally pass it one or more values (parameters or arguments) to manipulate during execution. Likewise, a function can send us back a return value (a value that results from the execution of a function and is sent back to the caller). Within the body of a function, we use the return statement to conclude the function's execution and optionally return a value. A return statement takes one of the following forms:
return; return expression;
The optional expression, if included, becomes the return value of the function. A return statement without a return value exits the function and returns the value undefined. All return statements exit the current function. Note that return statements are not required in functions; a function without a return statement simply ends after the last statement in the function body and implicitly returns undefined. See Chapter 9 for more details on creating, calling, and terminating functions.
The with statement provides a shorthand way to refer to properties of an object without having to retype the object's name repeatedly. A with statement takes the general form:
with (object) {
statements
}
When a property is referenced within a with statement block, object is checked for the specified property. In other words, with temporarily adds object to the end of the scope chain for the currently executing code. If the property exists in object, then object's property is used to resolve the property reference. If the property does not exist in object, the remainder of the current scope chain is consulted for the property in question, as described in Chapter 2.
The following example shows the difference between executing a statement inside a with statement and outside a with statement:
PI = 10; // Set a timeline variable, PI
with (Math) { // Execute statements in the context of Math
trace("pi is: " + PI); // Displays: 3.1459... (PI is a property of Math)
}
trace("PI is: " + PI); // Displays: 10 (Math is no longer accessed)
In addition to providing convenient access to object properties, with can be used to invoke object methods:
x = 10;
y = 11;
with (Math) {
larger = max(x, y);
}
trace(larger); // Displays: 11
It is not possible to define a new property on an object that is the target of a with statement. For example, in the preceding code, the variable larger does not exist on the Math object, so the property assignment creates a new variable on the timeline that contains the with statement (not on Math!). The following code shows a misguided attempt to set a variable in theClip_mc:
with (theClip_mc) {
var x = 10; // x is set on the current timeline, not theClip_mc
}
We can, however, legitimately use with to affect movie clip instances in other ways. It can provide a handy way to work with deeply nested instance structures. For example, we can change this:
this.player_mc.eyes_mc.blinkRate = 30;
this.player_mc.eyes_mc.gotoAndStop("eyesOpen");
to this:
with (this.player_mc.eyes_mc) {
blinkRate = 30; // Resets an existing variable in eyes_mc instance
gotoAndStop("eyesOpen"); // Function applied to eyes_mc instance
}
But with is not our only means of achieving this convenience. We can also simply assign our instance to a variable and use that variable in our references:
var eyes = this.player_mc.eyes_mc;
eyes.blinkRate = 30;
eyes.gotoAndStop("eyesOpen");
Many developers find the variable approach easier to read and work with than the with statement, but both are valid. We'll learn more about treating movie clips as objects in Chapter 13.
Note that inside a with statement, the value of the this keyword does not change; it retains the value it had outside the with statement. For example:
// Place the following code on _level0
// On _level0, create a ball object with a radius property
_level0.ball = { radius: 20 };
// Check the value of 'this' outside of the with statement
trace(this); // Displays: _level0
// Start our with statement
with (_level0.ball) {
// Check the value of 'this' inside the with statement
trace(this); // Still displays: _level0 (not ball!)
// Check the radius of the ball object
trace(radius); // Displays: 20
}
The deprecated ifFrameLoaded statement executes its substatements only if the specified frame has been loaded. Here's the syntax:
ifFrameLoaded (frame_expression) {
statements
}
where frame_expression must be either the number of a frame or a string indicating a frame label. If the frame indicated by frame_expression has downloaded to the Player, statements are executed; if not, the statement block is skipped.
Because ifFrameLoaded lacks an else clause, it was deprecated in Flash 4. In Flash 4 and later, you should use the _totalframes and _framesloaded properties with if-else statements to create a more versatile preloader. For example:
if (_totalframes > 0 && _framesloaded = = _totalframes) {
gotoAndPlay("beginMovie");
} else {
gotoAndPlay(_currentframe - 1);
}
For the sake of completeness, we should mention that it is legal to issue a statement with no content using a lone semicolon:
;
The empty statement has very little practical application, except that it can be used as a placeholder anywhere a statement is normally expected. It is not needed if you simply want to add blank lines to your code. ActionScript ignores blank vertical lines, which can be used to improve code readability.
In Flash's Normal Mode, the lone semicolon appears when the evaluate Action is added to a block of code. An arbitrary statement can then be added by typing into the Expression field of the Parameters panel.
