ActionScript 3.0 is een hoofdlettergevoelige taal. Id's die alleen verschillen in hoofdlettergebruik, worden als verschillende id's beschouwd. Met de volgende code worden bijvoorbeeld twee verschillende variabelen gemaakt:

var num1:int; 
var Num1:int;

De puntoperator (.) biedt toegang tot de eigenschappen en methoden van een object. Met de puntnotatie kunt u verwijzen naar een klasseneigenschap of -methode door een instantienaam te gebruiken, gevolgd door de puntoperator en naam van de eigenschap of methode. Neem bijvoorbeeld de volgende klassendefinitie:

class DotExample 
{ 
    public var prop1:String; 
    public function method1():void {} 
}

Met behulp van de puntnotatie hebt u toegang tot de eigenschap prop1 en de methode method1() door de instantienaam te gebruiken die met de volgende code wordt gemaakt:

var myDotEx:DotExample = new DotExample(); 
myDotEx.prop1 = "hello"; 
myDotEx.method1();

U kunt de puntnotatie gebruiken wanneer u pakketten definieert. U gebruikt de puntoperator voor het verwijzen naar geneste pakketten. De klasse EventDispatcher bevindt zich bijvoorbeeld in een pakket met de naam events dat is genest binnen het pakket met de naam flash. U kunt met de volgende expressie verwijzen naar het pakket events:

flash.events

U kunt ook naar de klasse EventDispatcher verwijzen met deze expressie:

flash.events.EventDispatcher

De slash-notatie wordt niet ondersteund in ActionScript 3.0. De slash-notatie werd in eerdere versies van ActionScript gebruikt om het pad van een filmclip of variabele aan te geven.

Een letterlijk teken is een waarde die direct wordt weergegeven in uw code. De volgende voorbeelden zijn allemaal letterlijke tekens:

17 
"hello" 
-3 
9.4 
null 
undefined 
true 
false

U kunt letterlijke tekens ook groeperen om samengestelde letterlijke tekens te vormen. Arrays met letterlijke tekens worden ingesloten door vierkante haakjes ([]) en gebruiken de komma om arrayelementen te scheiden.

U kunt een array met letterlijke tekens gebruiken om een array te initialiseren. In de volgende voorbeelden worden twee arrays getoond die zijn geïnitialiseerd door middel van arrays met letterlijke tekens. U kunt de instructie new gebruiken en het samengestelde letterlijke teken als parameter doorgeven aan de klassenconstructor Array. U kunt echter ook direct letterlijke waarden toewijzen wanneer u instanties van de volgende kernklassen van ActionScript instantieert: Object, Array, String, Number, int, uint, XML, XMLList en Boolean.

// Use new statement. 
var myStrings:Array = new Array(["alpha", "beta", "gamma"]); 
var myNums:Array = new Array([1,2,3,5,8]); 
 
// Assign literal directly. 
var myStrings:Array = ["alpha", "beta", "gamma"]; 
var myNums:Array = [1,2,3,5,8];

U kunt letterlijke tekens ook gebruiken om een algemeen object te initialiseren. Een algemeen object is een instantie van de klasse Object. Letterlijke tekens voor objecten worden ingesloten door accolades ({}) en gebruiken komma's om objecteigenschappen te scheiden. Elke eigenschap wordt gedeclareerd met de dubbele punt (:), die de naam van de eigenschap scheidt van de waarde van de eigenschap.

U kunt een algemeen object maken met de instructie new en het letterlijke teken voor objecten als parameter doorgeven aan de klassenconstructor Object. U kunt ook het letterlijke teken voor objecten direct toewijzen aan de instantie die u declareert. Het volgende voorbeeld laat twee andere manieren zien om een nieuw algemeen object te maken en het object te initialiseren met drie eigenschappen (propA, propB en propC), elk met een waarde ingesteld op respectievelijk 1, 2 en 3:

// Use new statement and add properties. 
var myObject:Object = new Object(); 
myObject.propA = 1; 
myObject.propB = 2; 
myObject.propC = 3; 
 
// Assign literal directly. 
var myObject:Object = {propA:1, propB:2, propC:3};

U kunt het puntkommateken (;) gebruiken om een instructie te beëindigen. U kunt de puntkomma ook weglaten. De compiler gaat er dan van uit dat elke coderegel een enkele instructie vertegenwoordigt. Veel programmeurs zijn gewend met de puntkomma het einde van een instructie aan te geven. Uw code is dan ook wellicht beter leesbaar als u altijd puntkomma's gebruikt om instructies te beëindigen.

Wanneer u een puntkomma gebruikt om een instructie te beëindigen, kunt u meerdere instructies in een enkele regel plaatsen. Dit maakt uw code echter meestal minder leesbaar.

U kunt ronde haakjes (()) op drie manieren gebruiken in ActionScript 3.0. Ten eerste kunt u ronde haakjes gebruiken om de volgorde van de bewerkingen in een expressie te wijzigen. Bewerkingen die tussen ronde haakjes zijn gegroepeerd, worden altijd het eerst uitgevoerd. Ronde haakjes worden bijvoorbeeld gebruikt om de volgorde van de bewerkingen in de volgende code te wijzigen:

trace(2 + 3 * 4); // 14 
trace((2 + 3) * 4); // 20

Ten tweede kunt u ronde haakjes gebruiken met de kommaoperator (,) om een reeks expressies te evalueren en de resultaten te retourneren van de uiteindelijke expressie, zoals in het volgende voorbeeld wordt getoond:

var a:int = 2; 
var b:int = 3; 
trace((a++, b++, a+b)); // 7

Ten derde kunt u ronde haakjes gebruiken om een of meer parameters door te geven aan functies of methoden, zoals in het volgende voorbeeld wordt getoond. Hierin wordt een tekenreekswaarde doorgegeven aan de functie trace():

trace("hello"); // hello

Code in ActionScript 3.0 ondersteunt twee typen opmerkingen: opmerkingen van een enkele regel en opmerkingen van meerdere regels. Deze opmerkingsmechanismen lijken op die in C++ en Java. De compiler negeert tekst die als opmerking is gemarkeerd.

Opmerkingen van een enkele regel beginnen met twee slash-tekens (//) en lopen door tot het einde van de regel. De volgende code bevat bijvoorbeeld een opmerking van een enkele regel:

var someNumber:Number = 3; // a single line comment

Opmerkingen van meerdere regels beginnen met een slash en asterisk (/*) en eindigen met een asterisk en slash (*/).

/* This is multiline comment that can span 
more than one line of code. */

Gereserveerde woorden zijn woorden die u niet als id's in uw code kunt gebruiken, omdat de woorden zijn gereserveerd voor gebruik door ActionScript. Gereserveerde woorden omvatten lexicale trefwoorden, die uit de programmanaamruimte worden gehaald door de compiler. De compiler rapporteert een fout als u een lexicaal trefwoord als id gebruikt. In de volgende tabel worden de lexicale trefwoorden van ActionScript 3.0 weergegeven.

Er is een kleine set trefwoorden, syntactische trefwoorden genoemd, die als id's kunnen worden gebruikt maar in bepaalde contexten een speciale betekenis hebben. In de volgende tabel worden de syntactische trefwoorden van ActionScript 3.0 weergegeven.

Er zijn ook diverse id's die soms toekomstig gereserveerde woorden worden genoemd. Deze id's zijn niet gereserveerd door ActionScript 3.0, hoewel sommige ervan door software waarin ActionScript 3.0 is opgenomen mogelijk als trefwoorden worden behandeld. U kunt vele van deze id's wellicht in uw code gebruiken, maar Adobe geeft de aanbeveling dat niet te doen, omdat ze mogelijk als trefwoorden in een volgende versie van de taal worden gebruikt.

ActionScript 3.0 ondersteunt de instructie const, waarmee u constanten kunt maken. Constanten zijn eigenschappen met een vaste, onveranderbare waarde. U kunt maar één keer een waarde aan een constante toewijzen en de toewijzing moet plaatsvinden dicht bij de declaratie van de constante. Als een constante bijvoorbeeld als lid van een klasse wordt gedeclareerd, kunt u alleen een waarde aan die constante toewijzen als onderdeel van de declaratie of binnen de klassenconstructor.

Met de volgende code worden twee constanten gedeclareerd. De eerste constante, MINIMUM, krijgt een waarde toegewezen als onderdeel van de declaratie-instructie. De tweede constante, MAXIMUM, krijgt een waarde toegewezen in de constructor. Dit voorbeeld kan alleen worden gecompileerd in de standaardmodus, omdat in de strikte modus de waarde van een constante alleen op het moment van initialisatie kan worden toegewezen.

class A 
{ 
    public const MINIMUM:int = 0; 
    public const MAXIMUM:int; 
 
    public function A() 
    { 
        MAXIMUM = 10; 
    } 
} 
 
var a:A = new A(); 
trace(a.MINIMUM); // 0 
trace(a.MAXIMUM); // 10

Een fout treedt op als u op een andere wijze probeert een beginwaarde aan een constante toe te wijzen. Als u bijvoorbeeld probeert de beginwaarde van MAXIMUM buiten de klasse in te stellen, treedt een uitvoeringsfout op.

class A 
{ 
public const MINIMUM:int = 0; 
public const MAXIMUM:int; 
} 
 
var a:A = new A(); 
a["MAXIMUM"] = 10; // run-time error

ActionScript 3.0 definieert een groot aantal constanten die u kunt gebruiken. Volgens goed gebruik worden voor constanten in ActionScript hoofdletters gebruikt, waarbij woorden door het onderstrepingsteken ( _ ) worden gescheiden. De klassendefinitie MouseEvent gebruikt deze naamconventie bijvoorbeeld voor constanten, waarbij elke constante een gebeurtenis vertegenwoordigt die met de muisinvoer te maken heeft:

package flash.events 
{ 
    public class MouseEvent extends Event 
    { 
    public static const CLICK:String = "click"; 
    public static const DOUBLE_CLICK:String = "doubleClick"; 
    public static const MOUSE_DOWN:String = "mouseDown"; 
    public static const MOUSE_MOVE:String = "mouseMove"; 
    ... 
    } 
}