ActionScript 3.0 est un langage qui fait la distinction entre les majuscules et les minuscules. Les identifiants qui diffèrent au niveau de la casse uniquement sont considérés comme différents. Par exemple, le code suivant crée deux variables différentes :

var num1:int; 
var Num1:int;

L’opérateur point (.) permet d’accéder aux propriétés et aux méthodes d’un objet. La syntaxe à point vous permet de vous rapporter à une méthode ou à une propriété de classe à l’aide d’un nom d’occurrence, suivi par l’opérateur point et le nom de la méthode ou de la propriété. Par exemple, considérez la définition de classe suivante :

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

La syntaxe à point vous permet d’accéder à la propriété prop1 et à la méthode method1() à l’aide du nom d’occurrence créé dans le code suivant :

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

Vous pouvez utiliser la syntaxe à point lorsque vous définissez des packages. Vous utilisez l’opérateur point pour référencer des packages imbriqués. Par exemple, la classe EventDispatcher se trouve dans un package appelé events qui est imbriqué dans le package nommé flash. Vous pouvez référencer le package events à l’aide de l’expression suivante :

flash.events

Vous pouvez également référencer la classe EventDispatcher au moyen de cette expression :

flash.events.EventDispatcher

La syntaxe à barre oblique n’est pas prise en charge dans ActionScript 3.0. Elle était utilisée dans les versions antérieures d’ActionScript pour indiquer le chemin d’un clip ou d’une variable.

Un littéral est une valeur qui apparaît directement dans votre code. Voici quelques exemples de littéraux :

17 
"hello" 
-3 
9.4 
null 
undefined 
true 
false

Les littéraux peuvent également être regroupés pour former des littéraux composés. Les littéraux de tableau sont placés entre crochets ([]) et utilisent la virgule pour séparer les éléments du tableau.

Un littéral de tableau permet d’initialiser un tableau. Les exemples suivants présentent deux tableaux initialisés par des littéraux de tableau. Vous pouvez utiliser l’instruction new et transmettre le littéral composé sous forme de paramètre au constructeur de classe Array, ou affecter directement les valeurs littérales lors de l’instanciation des occurrences des classes de base ActionScript suivantes : Object, Array, String, Number, int, uint, XML, XMLList et 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];

Les littéraux permettent également d’initialiser un objet générique. Un objet générique est une occurrence de la classe Object. Les littéraux d’objet sont placés entre accolades ({}) et séparent les propriétés de l’objet par une virgule. Chaque propriété est déclarée avec le caractère deux-points (:), séparant le nom et la valeur de la propriété.

Vous pouvez créer un objet générique via l’instruction new et transmettre le littéral d’objet sous forme de paramètre au constructeur de classe Object ou affecter directement le littéral d’objet à l’occurrence déclarée. L’exemple suivant illustre deux méthodes différentes de créer un objet générique et de l’initialiser avec trois propriétés (propA, propB et propC), chacune avec des valeurs définies sur 1, 2, et 3, respectivement :

// 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};

Vous pouvez utiliser le point-virgule (;) à la fin d’une instruction. Si vous omettez ce caractère, le compilateur suppose que chaque ligne de code représente une instruction distincte. Etant donné que de nombreux programmeurs ont l’habitude d’utiliser le point-virgule pour marquer la fin d’une instruction, vous pouvez faciliter la lecture de votre code en procédant de la sorte.

L’ajout d’un point-virgule à la fin d’une instruction permet de placer plusieurs instructions sur une même ligne, mais rend la lecture de votre code plus difficile.

Vous pouvez utiliser les parenthèses (()) de trois façons dans ActionScript 3.0. Premièrement, elles permettent de modifier l’ordre des opérations dans une expression. Les opérations regroupées à l’intérieur de parenthèses sont toujours exécutées en premier lieu. Par exemple, vous pouvez utiliser des parenthèses pour modifier l’ordre des opérations dans le code suivant :

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

Deuxièmement, vous pouvez utiliser des parenthèses avec l’opérateur virgule (,) pour évaluer une série d’expressions et renvoyer le résultat de l’expression finale, comme indiqué dans l’exemple suivant :

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

Troisièmement, vous pouvez utiliser des parenthèses pour transmettre un ou plusieurs paramètres à des fonctions ou à des méthodes, comme indiqué dans l’exemple suivant, qui transmet une valeur String à la fonction trace() :

trace("hello"); // hello

Le code ActionScript 3.0 prend en charge deux types de commentaires : les commentaires d’une ligne et les commentaires de plusieurs lignes. Ces mécanismes de commentaire sont semblables aux mécanismes de commentaire de C++ et Java. Le compilateur ne tient pas compte du texte marqué comme commentaire.

Les commentaires d’une ligne commencent par deux barres obliques (//) et continuent jusqu’à la fin de la ligne. Par exemple, le code suivant contient un commentaire d’une ligne :

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

Les commentaires de plusieurs lignes commencent par une barre oblique et un astérisque (/*) et se terminent pas un astérisque et une barre oblique (*/).

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

Les mots réservés ne peuvent pas servir d’identifiants dans votre code car leur utilisation est réservée à ActionScript. Les mots réservés comprennent les mots lexicaux qui sont supprimés de l’espace de noms du programme par le compilateur. Le compilateur signale une erreur si vous utilisez un mot-clé lexical comme identifiant. Le tableau suivant répertorie les mots lexicaux d’ActionScript 3.0.

Il existe un petit ensemble de mots-clés, appelés mots-clés syntaxiques qui peuvent servir d’identifiants, mais qui possèdent une signification spéciale dans certains contextes. Le tableau suivant répertorie les mots-clés syntaxiques d’ActionScript 3.0.

Il existe également plusieurs identifiants auxquels il est parfois fait référence sous le terme mots réservés pour une utilisation future. Ces identifiants ne sont pas réservés par ActionScript 3.0, même si certains risquent d’être considérés comme des mots-clés par le logiciel incorporant ActionScript 3.0. Vous pourrez peut-être utiliser un grand nombre d’entre eux dans votre code, mais Adobe vous le déconseille car il est possible qu’ils soient utilisés en tant que mots-clés dans une version ultérieure du langage.

ActionScript 3.0 prend en charge l’instruction const que vous pouvez utiliser pour créer des constantes. Les constantes sont des propriétés dont la valeur est fixe et non modifiable. Vous pouvez affecter une valeur à une constante une seule fois, et l’affectation doit avoir lieu à proximité de la déclaration de la constante. Par exemple, si une constante est déclarée en tant que membre d’une classe, vous pouvez lui affecter une valeur uniquement dans la déclaration ou dans le constructeur de classe.

Le code suivant déclare deux constantes. La première constante, MINIMUM, a une valeur affectée dans l’instruction de déclaration. La seconde constante, MAXIMUM, a une valeur affectée dans le constructeur. Observez que cet exemple compile uniquement en mode standard car, en mode strict, il est uniquement possible d’affecter une valeur de constante lors de l’initialisation.

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

Une erreur se produit si vous tentez d’affecter une valeur initiale à une constante de toute autre façon. Par exemple, si vous tentez de définir la valeur initiale de MAXIMUM en dehors de la classe, une erreur d’exécution se produit.

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 définit un large éventail de constantes à votre usage. Par convention, les constantes dans ActionScript utilisent toutes des majuscules, avec des mots séparés par le caractère de soulignement ( _ ). Par exemple, la définition de classe MouseEvent utilise cette convention d’appellation pour ses constantes, dont chacune représente un événement lié à une action de la souris :

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