Syntaxe -- Flash CS3

La syntaxe d'un langage définit un ensemble de règles à suivre lors de l'écriture du code exécutable.

Sous-rubriques

Respect de la casse

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éé deux variables différentes :

var num1:int;
var Num1:int;

Syntaxe à point

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'instance, 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'instance 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 :

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

flash.events.EventDispatcher

Syntaxe à barre oblique

La syntaxe à barre oblique n'est pas prise en charge dans ActionScript 3.0. La syntaxe à barre oblique était utilisée dans des versions précédentes d'ActionScript pour indiquer le chemin d'un clip ou d'une variable.

Littéraux

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 instances des classes de base ActionScript : Object, Array, String, Number, int, uint, XML, XMLList et Boolean.

// Utilisation de l'instruction new.
var myStrings:Array = new Array(["alpha", "beta", "gamma"]);
var myNums:Array = new Array([1,2,3,5,8]);

// Affectation directe d'un littéral.
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 instance de la classe Object. Les littéraux d'objet sont placés entre accolades ({}) et utilisent la virgule pour séparer les propriétés de l'objet. 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'instance déclarée. L'exemple suivant crée un objet générique et l'initialise avec trois propriétés (propA, propB, et propC), chacune avec des valeurs définies sur 1, 2, et 3, respectivement :

// Utilisation de l'instruction new.
var myObject:Object = new Object({propA:1, propB:2, propC:3});

// Affectation directe d'un littéral.
var myObject:Object = {propA:1, propB:2, propC:3};

Points-virgules

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.

Parenthèses

Vous pouvez utiliser des parenthèses (()) de trois façons dans ActionScript 3.0. Premièrement, vous pouvez utiliser des parenthèses pour 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"); // bonjour

Commentaires

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 ignore le 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; // commentaire d'une seule ligne

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 (*/).

/* Il s'agit d'un commentaire de plusieurs lignes qui peut s'étendre sur
plus d'une ligne de code. */

Mots-clés et mots réservés

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 nom 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 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, mais certains d'entre eux peuvent être traités comme des mots-clés par des logiciels qui intègrent ActionScript 3.0. Vous pouvez utiliser un grand nombre de ces identifiants dans votre code, mais Adobe vous le déconseille car ils risquent d'apparaître sous la forme de mots-clés dans une version ultérieure du langage.

Constantes

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.

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 l'une des deux façons. 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; // erreur d'exécution

L'API de Flash Player API définit un grand nombre de constantes que vous pouvez utiliser. 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. Chacune d'entre elles 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";
    ...
  }
}

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

each	get	set	namespace
include	dynamic	final	native
override	static

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