What You Have Learned

The code represents the most common way of creating a function, as well as the syntax we'll use most frequently in this lesson. You'll see that the function declaration begins with the word function , followed by the name of the function (which can be anything you choose, as long as it follows typical naming conventions). Following the function name is an area enclosed by parentheses. You can leave this area blank or you can fill it with information (parameter data) that the function can use. By leaving the area within the parentheses blank, you create a "generic" functionthat is, one that performs the same way whenever it's called (used). If your function contains parameters, it will perform in a unique way each time it's called based on the parameter information it receives. Giving the function information in this way is called passing in arguments or passing in parameters . You can use as many parameters as you want. We'll tell you how to use parameter data a bit later in this lesson.

Following the optional parameter area is an open curly brace, followed by a carriage return and then some actions before the curly brace that concludes the function. In the space between the curly braces, you write the actions that you want your function to perform. These actions can also make use of any parameter information passed to the function (as you will see soon).

Syntax 2

This code represents the second syntax for creating functions:

myFunction = function (parameter1:DataType,parameter2:DataType,etc.)
    {/* actions go here */
  };

You would use this syntax to create a function dynamically or to define your own custom method of an object (which we'll discuss in Lesson 6, "Custom Classes"). The only difference between this syntax and Syntax 1 is in the way the function name is assigned: The function name appears first, and the syntax for defining how the function will work follows the = assignment operator.

Now that you understand the basic syntax for creating/defining a function, let's look at how a function is used, or called.

If a function contains no parameters, it can be called using the following syntax:

myFunction();

When you call a function, you're telling Flash to execute all the actions within that function. If myFunction() contained 20 actions, they all could be executed by using this single line of script.

If a function has been defined to accept parameter data, you can use the following syntax to call it:

myFunction(parameter1, parameter2);

If parameter1 had a value of cat and parameter2 had a value of 36 , those two values would be sent to the function for use by the actions within the function definition. At a later time, the same function could be called, but different parameter values sent. This would result in the same function working in a slightly different way from the first example because the actions within the function would be making use of different parameter values.

The foregoing examples assume that the function and function call reside on the same Timeline. Just as each Timeline contains its own variables and objects, each Timeline also contains any functions you've defined there. To call a function on a specific Timeline, you need to place the target path to that Timeline in front of the function call like this:

_root.clip1.clip2.myFunction();

In this exercise, you'll create a Power button on a television remote control. With this button, the Flash TV can be toggled on and off using a function.

Note

A function can be called dynamically based on a valuefor instance, _root[aVariableName](); . Thus, if aVariableName had a value of "sayHello" , the function call would actually look like _root.sayHello(); .

var tvPower:Boolean = false;
  function togglePower() {
    var newChannel:Number;
    if (tvPower) {
      newChannel = 0;
      tvPower = false;
    } else {
      newChannel = 1;
      tvPower = true;
    }
    tv_mc.screen_mc.gotoAndStop(newChannel+1);
    remote_mc.light_mc.play();
  }

remote_mc.power_btn.onRelease = togglePower;