ActionScript 3.0 lexical structure

An ActionScript 3.0 file is a sequence of tokens: identifiers, keywords, literals, operators and punctuation, separated by white space, line breaks and comments. This page lists them all.

Basics

Case – the language is case-sensitive: num1 and Num1 are two different names, and Var is not the keyword var.
Identifiers – a name starts with a letter, _ or $, followed by letters, digits, _ or $. Letters outside ASCII are allowed. A keyword cannot be used as a name.
Semicolons – a semicolon ends a statement. It is optional at the end of a line: without one, the compiler takes the line as one statement. Several statements can share a line when semicolons separate them.
Dot syntax – . reaches properties and methods (sprite.x, sprite.addChild(c)) and separates the parts of a package name (flash.display.Sprite).
No slash syntax – the /path/to:variable notation of Flash 4 and the older versions is not supported.
White space – spaces, tabs and line breaks separate tokens and are otherwise ignored, except inside string, regular expression and XML literals.

Comments

Form	Meaning
`// text`	A comment to the end of the line.
`/* text */`	A comment over any number of lines. Comments of this kind do not nest: the first `*/` ends it.
`/** text */`	An ASDoc comment: an ordinary block comment that the ASDoc tool turns into reference pages.

ASDoc comments

An ASDoc comment goes directly before the declaration it describes: a class, interface, property, method, constant or an [Event], [Style] or [Effect] metadata tag. Each line usually starts with * and a space, which ASDoc removes. The main description comes first; its first sentence, ending at the first full stop followed by a space or line break, is the summary. HTML is allowed but must be well formed, so < is written < and @ in text @. Tags start at the first line that begins with @.

Tag	Meaning
`@param name text`	Describes a parameter, in the order of the signature.
`@return text`	Describes the return value; the type is taken from the code.
`@throws Class text`	An error the method can throw.
`@see reference [text]`	A See also link to a class, member, package or URL.
`@default value`	The default value of a property, style or effect.
`@eventType constant`	On an `[Event]` tag, the constant that names the event.
`@example text`	A code example, in `<listing>` tags.
`@includeExample file`	Includes an example file from the examples path.
`@exampleText text`	Text in an example file to show with it.
`@inheritDoc`	Copies the comment of the overridden or implemented member.
`@copy reference`	Copies the description, parameters and return value from elsewhere.
`@private`	Leaves the element out of the output.
`@internal text`	Text that does not appear in the output.
`@since text`	A Since section.

/**
 * Moves the sprite by a distance in pixels.
 *
 * <p>Negative values move it left or up.</p>
 *
 * @param dx Distance along the x axis.
 * @param dy Distance along the y axis.
 * @return The new position.
 * @throws ArgumentError if either value is NaN.
 * @see flash.geom.Point
 */
public function moveBy(dx:Number, dy:Number):Point {

An ASDoc comment on a method.

Keywords and reserved words

Adobe’s documentation sorts the reserved words into three lists. Its lists name native among both the keywords and the syntactic keywords, and to among both the keywords and the future reserved words; they are given here as Adobe gives them.

Keywords

These can never be used as names; the compiler reports an error.

`as`	`break`	`case`	`catch`	`class`	`const`
`continue`	`default`	`delete`	`do`	`else`	`extends`
`false`	`finally`	`for`	`function`	`if`	`implements`
`import`	`in`	`instanceof`	`interface`	`internal`	`is`
`native`	`new`	`null`	`package`	`private`	`protected`
`public`	`return`	`super`	`switch`	`this`	`throw`
`to`	`true`	`try`	`typeof`	`use`	`var`
`void`	`while`	`with`

Syntactic keywords

These can be used as names, but mean something special in particular places.

Word	Where it is special
`each`	After `for`, in `for each (… in …)`.
`get`	After `function`, declaring a getter.
`set`	After `function`, declaring a setter.
`namespace`	Declaring a namespace, and in `use namespace` and `default xml namespace`.
`include`	As a directive followed by a string: `include "file.as"`.
`dynamic`	As a class attribute.
`final`	As a class or method attribute.
`native`	As a method attribute, for methods the runtime implements; not allowed in ordinary code.
`override`	As a method attribute.
`static`	As a class member attribute.

Future reserved words

ActionScript 3.0 does not reserve these, but Adobe advises against them as names because a later version might. ActionScript Compiler 2.0, in the AIR SDK, does reject goto.

`abstract`	`boolean`	`byte`	`cast`	`char`	`debugger`
`double`	`enum`	`export`	`float`	`goto`	`intrinsic`
`long`	`prototype`	`short`	`synchronized`	`throws`	`to`
`transient`	`type`	`virtual`	`volatile`

Literals

A literal is a value written directly in the code.

Kind	Examples	Notes
Number	`42`, `-7`, `3.14`, `.5`, `1e6`, `2.5E-3`	Decimal; whole values fit `int` or `uint` where the type allows.
Hexadecimal	`0xFF`, `0x00CC33`	Common for colours: `0xRRGGBB`, or `0xAARRGGBB` with alpha.
String	`"text"`, `'text'`	Either quote; escapes below.
Boolean	`true`, `false`
Null	`null`	No object.
Undefined	`undefined`	A global constant rather than a keyword; only untyped (`*`) variables hold it.
Array	`[1, 2, 3]`, `[]`, `["a", [1, 2]]`	The same as `new Array(1, 2, 3)`.
Object	`{x: 1, y: 2}`, `{"full name": "Ann"}`	A plain `Object` with those properties.
Vector	`new <int>[1, 2, 3]`	A `Vector.<int>`; needs Flash Player 10 or AIR 1.5.
Regular expression	`/ab+c/gi`	Between slashes, then flags. See Regular expressions.
XML	`<item id="1">Pen</item>`	An `XML` object, written as XML in the code. See XML and E4X.
XMLList	`<><a/><b/></>`	An `XMLList` of the elements between `<>` and `</>`.
Function	`function (a:int):int { return a * 2; }`	A function expression; see Functions.

String escape sequences

Escape	Character
`\b`	Backspace (U+0008)
`\f`	Form feed (U+000C)
`\n`	Line feed (U+000A)
`\r`	Carriage return (U+000D)
`\t`	Tab (U+0009)
`\"`	Double quote
`\'`	Single quote
`\\`	Backslash
`\unnnn`	The UTF-16 code unit with four hexadecimal digits `nnnn`
`\xnn`	The character with two hexadecimal digits `nn`

Punctuation

Token	Use
`{ }`	Blocks, package, class and function bodies, object literals, and expressions inside XML literals.
`( )`	Grouping, calls, parameter lists, conditions, and E4X filters.
`[ ]`	Array literals, indexing, and metadata tags such as `[Embed(…)]`.
`:`	Type annotations (`var n:int`), object literal keys, labels and `case` labels.
`::`	Namespace qualification: `flash_proxy::callProperty`, `CONFIG::debug`.
`.<`	Opens a type parameter: `Vector.<String>`.
`...`	A rest parameter: `function f(...args)`.
`;` and `,`	End a statement; separate list items, or the comma operator.

Operators are listed on the Operators page.

.AS File Format – Lexical structure