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.

Flash CS3

Comments

sneakyimp said on Sep 24, 2007 at 10:41 PM :

This explanation says nothing about where flash goes looking for the actionscript files that are imported. For instance, if I import:

com.mydomain.myPackage.*

then where do I have to put the actionscript files so flash can find them?

djtechwriter said on Sep 25, 2007 at 10:04 AM :

In ActionScript 2.0, the package name corresponded to the directory hierarchy relative to the original FLA file. However, with ActionScript 3.0, the package name doesn't necessarily correspond to the directory structure. It may (and usually does) show the directory path, but you can create a package name within your AS file that does not reflect the directory hierarchy. This new flexibility is explained here:

http://livedocs.adobe.com/flash/9.0/main/00000041.html under "Creating packages"

try_test said on Oct 4, 2007 at 9:49 PM :

"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."

Is it means that a class must have uniq name ?

adbe_paul said on Oct 8, 2007 at 1:25 PM :

All the classes within a single package must have unique names.

A class in one package can have the same name as a class in another package. Whichever class is imported with the import statement will determine which class is used. However, if you need to use two different classes that have the same name (and are in different packages) then you'll need to import them and also use the fully-qualified name (package-and-class name) within your code.

lvwarren said on Nov 30, 2007 at 7:27 AM :

that was wonderful, now let's try this:

Options for organizing your code:
1) script include: <mx:Script source="Box.as" />
2) include statement "include Box.as"
3) package reference "import Box"
4) compiled reference .... ?

MotherBrain said on Dec 21, 2007 at 8:00 AM :

If I understand this correctly. When you import a package into your fla file, the package name has no bearing on the import statement whatsoever?

For instance:
Ball.as is saved in a folder called classes.

package toybox
{
public class Ball extends MovieClip
...
}

Inside the fla file, I would do the following correct?

import classes.Ball;

Thus toybox is not utilized? If this is correct, what is reasoning behind using package names?

djtechwriter said on Dec 21, 2007 at 4:51 PM :

MotherBrain,

Actually, that's backwards; you can put your files in any directory hierarchy you want. What matters is how you declare your packages and what classes you declare within each package. So, you'd actually use
import toybox.Ball;

This page should help:
http://livedocs.adobe.com/flash/9.0/main/00000041.html

RSS feed | Send me an e-mail when comments are added to this page | Comment Report

Current page: http://livedocs.adobe.com/flash/9.0/main/00000028.html