Cours Actionscript

Tutoriel pour Apprendre à programmer en ActionScript 3


Télécharger Tutoriel pour Apprendre à programmer en ActionScript 3

★★★★★★★★★★3.5 étoiles sur 5 basé sur 1 votes.
Votez ce document:

Télécharger aussi :


Tutoriel pour Apprendre à programmer en ActionScript 3

...

1 introduction au tutoriel

Un programme ActionScript comprend zéro ou plusieurs définitions de package suivies de zéro ou plusieurs directives, y compris des définitions et des instructions autres que des packages. Les instructions à l'intérieur et à l'extérieur des définitions de paquet sont évaluées dans l'ordre, indépendamment de leur imbrication dans un paquet.

1.1 Bonjour tout le monde

Les sections suivantes présentent différentes manières de mettre en œuvre des programmes simples, tels que le programme familier "hello, world" dans ActionScript 3.0:

trace ("bonjour, monde");

Il s'agit d'une déclaration d'expression unique qui appelle une fonction nommée trace () avec l'argument qui est une chaîne littérale "hello, world". Une déclaration d'expression ne fait qu'exécuter une expression.

1.2 Expressions

Voici quelques exemples d'expressions:

x = 1 + 2

x = y ()

x = y..z

x = o.ns :: id

Les expressions évaluent des valeurs:

  • 1 + 2 est évalué à 3.
  • y () évalue le résultat de l'appel de la fonction y sans arguments.
  • y..z correspond à l'ensemble des propriétés identifiées par z dans la valeur de y et les descendants de y. L'opérateur d'accesseur de descendants (..) fait partie du code ActionScript.

3.0 implémentation de ECMAScript pour XML (E4X).

  • o.ns :: id correspond à la valeur de la propriété ns :: id de la valeur de o, où o représente un objet, ns représente un espace de noms et id représente un identificateur.

1.3 Déclarations

Les instructions sont exécutées dans l'ordre dans lequel elles apparaissent dans un bloc. Certaines instructions modifient le flux de contrôle par un achèvement brutal, tel que break et continue, ou par itération, tel que while et do. Voici un exemple d’instruction:

pour (var i: int = 0; i <5; i ++) {

 trace (i);

}

1.4 Variables

Les variables définissent des propriétés dont les valeurs peuvent changer lors de l'exécution. Ils peuvent être définis avec le mot-clé var ou le mot-clé const. Une variable définie avec le mot-clé var peut être assignée par tout code pouvant y accéder. Une variable définie avec le mot-clé const ne peut être définie que par son initialiseur ou par le constructeur d'instance de sa classe s'il s'agit d'une variable d'instance. Un exemple de variables suit:

var x = 10

const PI = 3.1415

1.5 fonctions

Les fonctions définissent les propriétés dont les valeurs peuvent être appelées. Voici un exemple de fonction:

function bonjour () {

 trace ("bonjour, monde")

}

salut()

Selon l'endroit où une fonction est définie, il en résulte une propriété dont la valeur est une fermeture de fonction ou une méthode. Une fermeture de fonction est un objet de première classe pouvant être traité comme une collection de propriétés ou un objet appelable. Une méthode est étroitement liée à l'objet auquel elle est associée. La référence this d'une fonction est liée à l'objet de base de l'expression d'appel ou à l'objet global si aucun n'est spécifié.



function bonjour () {

 trace ("bonjour, monde")

 trace (this) // cela fait référence à un objet global

}

salut()

Une méthode est une fonction étroitement liée à un objet. Une méthode peut être extraite de son instance, mais contrairement aux fermetures de fonctions, sa valeur fait toujours référence à l'instance à partir de laquelle elle est extraite.

1.6 classes

Une classe est un objet qui peut être utilisé en tant que constructeur d'instances qui partagent le même type et les mêmes propriétés. Voici un exemple de classe:

classe Greeter {

 var say = "bonjour tout le monde"

 function bonjour () {

 trace (en disant)

 }

}

var greeter: Greeter = new Greeter

greeter.hello ()

Les définitions de classe permettent de définir les propriétés fixes d'un objet de classe. Les définitions de propriété marquées avec l'attribut static deviennent des propriétés de l'objet de classe et celles qui ne le sont pas deviennent des propriétés d'instances de la classe. Les propriétés de classe et d'instance sont des méthodes ou des emplacements. Une méthode est définie par une définition de fonction dans une définition de classe. Une méthode a une définition (appelée trait trait) qui est partagée entre toutes les instances du même type. Contrairement à un objet fonction ordinaire, une méthode est étroitement liée à l'objet auquel elle est associée. Quelle que soit la manière dont elle est invoquée, le sens de l'expression est toujours le même. En fait, les méthodes peuvent être extraites de leur instance et traitées comme des objets de première classe (appelés méthodes liées), un peu comme les objets de fonction peuvent l'être. Il existe une différence importante entre une fermeture de fonction et une méthode liée. Avec une méthode liée, la référence this est liée à l'objet de sorte que chaque fois qu'il est appelé l'original, cette référence est utilisée. Avec une fermeture de fonction, celle-ci est générique et fait référence à tout objet auquel la fonction est associée lorsqu’elle est appelée. Les emplacements sont définis par des définitions de variables dans une définition de classe. Une variable d'instance a une définition (appelée trait de slot) partagée entre toutes les instances du même type, mais un emplacement unique dans chaque objet.

1.7 Interfaces

Une interface définit un contrat entre une instance et un code utilisant cette instance.

Lorsqu'une classe implémente une interface, elle garantit qu'elle fournira les méthodes déclarées dans cette interface. Une méthode d'implémentation doit être déclarée publique, auquel cas elle implémentera toutes les méthodes d'interface non implémentées avec le même identifiant. Voici un exemple d'interface:

interface Salutations {

 fonction bonjour ()

 fonction goodmorning ()

}

La classe Greeter implémente Greetings {

 fonction publique hello () {

 trace ("bonjour, monde")

 }

 fonction publique goodmorning () {

 trace ("goodmorning, world")

 }

}

var greeter: Greetings = new Greeter ()

greeter.hello ()

1.8 forfaits



Les packages dans ActionScript sont très similaires aux packages en Java et aux espaces de noms en C # et C ++. Les packages sont utiles pour organiser les frameworks (ou les kits d'outils, ou les API) en ensembles de définitions associées: classes, espaces de noms, interfaces, fonctions et variables.

 Le code client peut importer tout ou partie d'un package pour accéder à la fonctionnalité qu'il fournit sans encombrer son espace de noms global de noms inutiles. Dans l'exemple suivant, la directive import rend la classe Greeter visible pour le code global qui contient la directive import.

Acteurs du package {

 classe publique Greeter {

 fonction publique hello () {

 trace ("bonjour, monde")

 }

 }

}

Importer des acteurs.Greeter

var greeter: Greeter = new Greeter

greeter.hello ()

1.9 Espaces de noms

Les espaces de noms sont utiles pour contrôler la visibilité d'un ensemble de propriétés indépendamment de la structure principale du programme. Les packages, les classes et les interfaces, ainsi que leurs espaces de noms de contrôle d'accès définis implicitement, permettent aux auteurs de contrôler la visibilité des noms en parallèle avec l'organisation de ces packages, classes et interfaces. Mais il est parfois nécessaire de contrôler les noms indépendamment de la structure lexicale d'un programme. Voici des exemples:

  • Rendre l’interface publique d’un ensemble de classes différente de celle des différents modules clients
  • faire évoluer une classe dans le temps sans changer le comportement des programmes existants
  • Fournir un accès privilégié à un nombre limité de clients

Utilisez des packages pour donner ou accéder à un ensemble de fonctionnalités. Utilisez des espaces de noms pour donner ou accéder à une facette, une version ou un privilège particuliers, indépendamment de la structure d'un programme. Voici un exemple d'utilisation des espaces de noms:

// fichier ActionScript: acteurs / English.as

Acteurs du package {

 espace de noms public English =

"/ 2007 / Exemples / English";

}

// fichier ActionScript: acteurs / French.as

Acteurs du package {

 espace de noms public French = "/ 2007 / Exemples / French";

}

// fichier ActionScript: acteurs / BilingualGreeter.as

Acteurs du package {

 public class BilingualGreeter {

 Fonction anglaise hello (): void {

 trace ("bonjour, monde");

 }

 Fonction française hello (): void {

 trace ("bonjour, le monde");

 }

 }

}

// fichier ActionScript: Test.as

paquet {

 import flash.display.Sprite;

 Classe publique Test étend Sprite

 {

 fonction publique Test ()

 {

 }

 }

}

acteurs de l'importation. *;

var greeter: BilingualGreeter = new BilingualGreeter ();



use namespace English; // Crée tous les identifiants dans l'espace de noms anglais

 // visible

greeter.hello (); // Invoque la version anglaise

greeter.French :: hello (); // Invoquer la version française

2 perspective de conception

Il est parfois difficile de comprendre les décisions de conception sans comprendre le point de vue des concepteurs. Voici les principaux points de vue qui ont motivé les modifications de conception introduites dans ActionScript 3.0 et ECMA-262 édition 4.

2.1 Compatibilité avec les programmes existants

ECMAScript a été conçu et utilisé par les consommateurs de modèles d'objets hôtes.

ECMAScript étant l’un des langages de programmation les plus utilisés, il est important que les programmes existants compatibles avec ECMAScript continuent de fonctionner dans des systèmes mis à jour pour prendre en charge la nouvelle définition du langage.

Par conséquent, les programmes écrits pour ECMA-262 édition 3, profil compact ou ECMAScript pour XML (ECMA-357 édition 2, également appelé E4X) doivent continuer à se comporter de la même manière dans ActionScript 3.0 et ECMA-262 édition 4.

2.2 Compatibilité avec les modèles d'objet existants

En 10 ans d'utilisation, ECMAScript a été soumis à une forte pression pour devenir un langage permettant de créer des modèles d'objet. Ceci est une conséquence naturelle de la nécessité pour les développeurs d'applications et d'outils d'étendre et de remplacer les fonctionnalités des objets intégrés fournis par les environnements hôtes. Quelques exemples de cela incluent HTML, Flash, Acrobat et VoiceXML.

Ces incorporations contiennent des objets hôtes avec des comportements qui ne peuvent être approximés qu'avec les fonctionnalités de ECMA-262 édition 3 et, en tant que tels, sont implémentés de manière inefficace et fragile.

Par conséquent, l’un des mandats de l’édition 4 est de permettre la création de modèles d’objets, tels que les modèles intégrés ECMA-262 édition 3, HTML DOM et ActionScript API, de manière à rendre non seulement naturel ces objets. comportement de modèles comme les modèles d'objet existants, mais cela les rend également robustes et efficaces.

2.3 Contrôler la visibilité des noms

Un problème bien connu est que des conflits de noms surviennent lorsque des bibliothèques créées indépendamment sont utilisées par une seule application. Il est également courant que la signification d'un nom doive être diffrente pour différentes utilisations d'un même composant.

Par conséquent, l'édition 4 s'efforce de minimiser l'occurrence de conflits de noms lorsque des bibliothèques créées indépendamment sont utilisées par une seule application et permet de résoudre ces conflits lorsqu'ils surviennent. En outre, l'édition 4 s'efforce de permettre aux utilisateurs de sélectionner la signification des noms entre les versions et les utilisations.



199