Options for organizing your code

You can use ActionScript 3.0 code to power everything from simple graphics animations to complex client-server transaction processing systems. Depending on the type of application you're building, you may prefer to use one or more of these different ways of including ActionScript in your project.

Subtopics

Storing code in frames in a Flash timeline

In the Flash authoring environment, you can add ActionScript code to any frame in a timeline. This code will be executed while the movie is playing back, when the playhead enters that frame.

Placing ActionScript code in frames provides a simple way to add behaviors to applications built in the Flash authoring tool. You can add code to any frame in the main timeline or to any frame in the timeline of any MovieClip symbol. However, this flexibility comes with a cost. When you build larger applications, it becomes easy to lose track of which frames contain which scripts. This can make the application more difficult to maintain over time.

Many developers simplify the organization of their ActionScript code in the Flash authoring tool by placing code only in the first frame of a timeline, or on a specific layer in the Flash document. This makes it easier to locate and maintain the code in your Flash FLA files. However, in order to use the same code in another Flash project, you must copy and paste the code into the new file.

If you want to be able to use your ActionScript code in other Flash projects in the future, you will want to store your code in external ActionScript files (text files with the .as extension).

Storing code in ActionScript files

If your project involves significant ActionScript code, the best way to organize your code is in separate ActionScript source files (text files with the .as extension). An ActionScript file can be structured in one of two ways, depending on how you intend to use it in your application.

Unstructured ActionScript code: Lines of ActionScript code, including statements or function definitions, written as though they were entered directly in a timeline script, MXML file, and so on.

ActionScript written in this way can be accessed using the include statement in ActionScript, or the <mx:Script> tag in Adobe Flex MXML. The ActionScript include statement causes the contents of an external ActionScript file to be inserted at a specific location and within a given scope in a script, as if it were entered there directly. In the Flex MXML language, the <mx:Script> tag lets you specify a source attribute that identifies an external ActionScript file to be loaded at that point in the application. For example, the following tag will load an external ActionScript file named Box.as:

<mx:Script source="Box.as" />

ActionScript class definition: A definition of an ActionScript class, including its method and property definitions.

When you define a class, you can access the ActionScript code in the class by creating an instance of the class and using its properties, methods, and events, just as you would with any of the built-in ActionScript classes. This requires two parts:

Use the import statement to specify the full name of the class, so the ActionScript compiler knows where to find it. For example, if you want to use the MovieClip class in ActionScript, you first need to import that class using its full name, including package and class:
```
import flash.display.MovieClip;
```

Alternatively, you can import the package that contains the MovieClip class, which is equivalent to writing separate import statements for each class in the package:

import flash.display.*;

The only exceptions to the rule that a class must be imported if you refer to that class in your code are the top-level classes, which are not defined in a package.

NOTE

In Flash, for scripts attached to frames on the Timeline, the built-in classes (in the flash.* packages) are automatically imported. However, when you write your own classes, or if you're working with Flash authoring components (the fl.* packages) or if you're working in Flex, you will need to explicitly import any class in order to write code that creates instances of that class.

Write code which specifically refers to the class name (usually declaring a variable with that class as its data type, and creating an instance of the class to store in the variable). By referring to another class name in ActionScript code, you tell the compiler to load the definition of that class. For example, given an external class called Box, this statement causes a new instance of the Box class to be created:
```
var smallBox:Box = new Box(10,20);
```

When the compiler comes across the reference to the Box class for the first time, it searches the loaded source code to locate the Box class definition.