ADOBE Director MX 2004 Référence de scripting de Director [fr]

!"#$%&'#!!"

"##$

Référence de scripting de Director

Marques

Afterburner, AppletAce, Attain, Attain Enterprise Learning System, Attain Essentials, Attain Objects for Dreamweaver,
Authorware, Authorware Attain, Authorware Interactive Studio, Authorware Star, Authorware Synergy, Backstage, Backstage
Designer, Backstage Desktop Studio, Backstage Enterprise Studio, Backstage Internet Studio, Contribute, Design in Motion,
Director, Director Multimedia Studio, Doc Around the Clock, Dreamweaver, Dreamweaver Attain, Drumbeat, Drumbeat
2000, Extreme 3D, Fireworks, Flash, Fontographer, FreeHand, FreeHand Graphics Studio, Generator, Generator Developer's
Studio, Generator Dynamic Graphics Server, Knowledge Objects, Knowledge Stream, Knowledge Track, LikeMinds, Lingo,
Live Effects, MacRecorder Logo and Design, Macromedia, Macromedia Contribute, Macromedia Coursebuilder for
Dreamweaver, Macromedia M Logo & Design, Macromedia Flash, Macromedia Xres, Macromind, Macromind Action,
MAGIC, Mediamaker, Multimedia is the Message, Object Authoring, Power Applets, Priority Access, Roundtrip HTML,
Scriptlets, SoundEdit, ShockRave, Shockmachine, Shockwave, shockwave.com, Shockwave Remote, Shockwave Internet Studio,
Showcase, Tools to Power Your Ideas, Universal Media, Virtuoso, Web Design 101, Whirlwind et Xtra sont des marques de
Macromedia, Inc. et peuvent être déposées aux Etats-Unis et dans d'autres pays. Les autres noms de produits, logos, graphiques,
mises en page, titres, mots ou phrases mentionnés dans cette publication peuvent être des marques de commerce, des marques de
service ou des noms de marque appartenant à Macromedia, Inc. ou à d'autres entités et peuvent être déposés dans certains pays,
états ou provinces.

Cette publication contient des liens conduisant à des sites web qui ne sont pas sous le contrôle de Macromedia, qui n'est
aucunement responsable de leur contenu. L'accès à ces sites se fait sous votre seule responsabilité. Macromedia mentionne ces
liens pour référence, ce qui ne signifie pas son soutien, accord ou responsabilité quant au contenu des sites en question.

Limite de garantie et de responsabilité Apple

APPLE COMPUTER, INC. N'OFFRE AUCUNE GARANTIE, EXPRES OU IMPLICITE, CONCERNANT CE
LOGICIEL, SA CAPACITE A ETRE COMMERCIALISE OU A REPONDRE A UN BESOIN PARTICULIER.
L'EXCLUSION DES GARANTIES IMPLICITES EST INTERDITE PAR CERTAINS PAYS, ETATS OU PROVINCES.
L'EXCLUSION ENONCEE CI-DESSUS PEUT NE PAS S'APPLIQUER A VOTRE CAS PARTICULIER. CETTE
GARANTIE VOUS ASSURE DES DROITS SPECIFIQUES. D'AUTRES DROITS VARIANT D'UN PAYS A L'AUTRE
PEUVENT EGALEMENT VOUS ETRE ACCORDES.

Copyright © 2004 Macromedia, Inc. Tous droits réservés. La copie, photocopie, reproduction, traduction ou conversion
de ce manuel, en partie ou dans sa totalité, sous quelque forme que ce soit, mécanique ou électronique, est interdite sans
une autorisation préalable obtenue par écrit auprès de Macromedia, Inc. Numéro de pièce ZDR10M300F

Première édition : Janvier 2004

Macromedia, Inc.
600 Townsend St.
San Francisco, CA 94103
États-Unis

TABLE DES MATIERES

CHAPITRE 1 : Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

Public visé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

Nouveautés concernant le scripting de Director. . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

Nouveautés dans cette documentation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

Recherche d’informations en matière de scripting dans Director . . . . . . . . . . . . . . . 7

CHAPITRE 2 : Principes de base du scripting dans Director . . . . . . . . . . . . . . . . . 9

Types de scripts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

Terminologie de scripting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

Syntaxe de scripting. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

Types de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

Valeurs littérales. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

Opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

Constructions conditionnnelles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

Evénements, messages et gestionnaires. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

Listes linéaires et listes de propriétés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

Tableaux de la syntaxe JavaScript. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

CHAPITRE 3 : Rédaction de scripts dans Director . . . . . . . . . . . . . . . . . . . . . . . . 55

Choisir entre Lingo et la syntaxe JavaScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

Format de scripting à syntaxe à points. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

Introduction aux objets de Director. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

Diagramme de modèles d’objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

Fonctions et propriétés de haut niveau. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60

Introduction à la programmation orientée objet dans Director . . . . . . . . . . . . . . . 61

Programmation orientée objet avec Lingo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61

Programmation orientée objet avec la syntaxe JavaScript . . . . . . . . . . . . . . . . . . . . 72

Rédaction de scripts dans la fenêtre Script. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82

3

CHAPITRE 4 : Débogage de scripts dans Director. . . . . . . . . . . . . . . . . . . . . . . . 93

Bonnes habitudes de rédaction de scripts. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94

Opérations de débogage de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94

Débogage dans la fenêtre Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97

Débogage dans la fenêtre Messages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98

Débogage de l’inspecteur d’objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102

Débogage dans la fenêtre Débogueur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105

Débogage de projections et d’animations Shockwave. . . . . . . . . . . . . . . . . . . . . . 110

Débogage avancé. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111

CHAPITRE 5 : Objets principaux de Director . . . . . . . . . . . . . . . . . . . . . . . . . . . 113

CHAPITRE 6 : Types de médias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131

CHAPITRE 7 : Objets de scripting. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149

CHAPITRE 8 : Objets 3D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153

CHAPITRE 9 : Constantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165

CHAPITRE 10 : Evénements et messages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173

CHAPITRE 11 : Mots-clés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221

CHAPITRE 12 : Méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247

CHAPITRE 13 : Opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 635

CHAPITRE 14 : Propriétés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 659

INDEX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1165

4 Table des matières

CHAPITRE 1

Introduction

Ce référentiel propose des informations conceptuelles et pratiques sur le scripting dans Director
MX 2004 de Macromedia ainsi que des descriptions et des exemples concernant les API
(Interfaces de Programmation d’Applications) de scripting que vous utilisez pour rédiger des
scripts.

Les API de scripting vous permettent d’accéder aux fonctionnalités de Director et d’augmenter
le caractère interactif d’une animation. Ces API vous permettent non seulement de créer des
fonctionnalités interactives identiques à celles qui correspondent aux comportements prédéfinis
de Director, mais aussi d’en créer d’autres, à la fois plus puissantes et plus variées.

Les comportements prédéfinis vous permettent d’ajouter un caractère interactif de base à une
animation. Il est ainsi possible de déplacer la tête de lecture sur un numéro d’image ou de repère,
ou d’effectuer un zoom lorsqu’on clique sur une image-objet. Ils vous permettent également
d’utiliser des fonctionnalités non interactives telles que l’animation d’images-objets, le charge­ment de médias et la navigation au sein des images. Les API de scripting vous permettent de
développer et de personnaliser ces types de fonctionnalités.

Public visé

Ce référentiel vous concerne si vous envisagez d'effectuer une ou plusieurs des opérations
suivantes :

• Développer les fonctionnalités existantes des comportements prédéfinis à l’aide de scripts.

• Ajouter des fonctionnalités à une animation avec des scripts plutôt qu’à l’aide des comporte-

ments prédéfinis.

• Ajouter des fonctionnalités plus puissantes, plus variées et plus personnalisées à une animation

que celles offertes par les comportements prédéfinis.

Le but de ce référentiel est de vous fournir toutes les informations dont vous avez besoin pour
ajouter de l’interactivité à vos animations à l’aide de scripts. Il n’est donc pas nécessaire d’être un
programmeur chevronné pour rédiger des scripts efficaces dans Director.

Quel que soit votre niveau de familiarité avec la syntaxe de Director, Lingo ou JavaScript,
consultez le Chapitre 2, Principes de base du scripting dans Director, page 9 et le Chapitre 3,

Rédaction de scripts dans Director, page 55 avant de commencer à rédiger des scripts. Comme tout

autre produit, Director possède ses propres conventions de scripting, types de données, etc. Pour
pouvoir rédiger de bons scripts, il est essentiel que vous vous familiarisiez de façon approfondie
avec ces caractéristiques de Director.

5

Nouveautés concernant le scripting de Director

Si vous avez rédigé des scripts avec les versions précédentes de Director, veuillez prendre note des
innovations et changements importants apportés à cette nouvelle version de scripting.

Format de scripting avec syntaxe à base de points

Dans les versions précédentes de Director, il était possible de rédiger des scripts Lingo en utilisant
deux types de syntaxe : la syntaxe verbose ou celle à points. La syntaxe verbose est très similaire à
l’anglais, et les programmeurs débutants pouvaient l’apprendre facilement. Toutefois, les scripts
avec syntaxe verbose sont vite devenus longs, complexes et difficiles à déboguer.

À présent que le modèle de scripting de Director est compatible avec les syntaxes Lingo et
JavaScript, les scripts doivent en principe être rédigés uniquement avec la syntaxe à points.
Beaucoup de programmeurs connaissent la syntaxe à points puisqu’elle est utilisée dans la plupart
des langages orientés objet tels que Java ou C++, et dans plusieurs langages de scripting web tels
que Microsoft JScript ou JavaScript.

Pour des raisons de compatibilité en amont, les scripts rédigés en utilisant la syntaxe verbose dans
les versions précédentes de Director continueront à être pris en charge. Toutefois, à partir de la
version Director MX 2004, la syntaxe à points est la syntaxe recommandée, et la seule qui sera
prise en charge et documentée à l’avenir.

Pour plus d’informations concernant l'utilisation de la syntaxe à points dans l'écriture de scripts,
consultez Format de scripting à syntaxe à points, page 56.

Compatibilité avec la syntaxe JavaScript

Director est désormais compatible avec la syntaxe JavaScript. Cela signifie que vous pouvez
non seulement créer et déboguer des scripts à l’aide de Lingo (le langage de scripting habituel
de Director) mais aussi choisir de créer et déboguer des scripts en utilisant la syntaxe JavaScript.
La version de JavaScript utilisée dans Director est appelée syntaxe JavaScript dans l'ensemble de
ce référentiel.

La prise en charge de la syntaxe JavaScript dans Director permet de créer un environnement
de scripting familier non seulement aux développeurs en JavaScript mais aussi à ceux habitués
à travailler avec les outils Macromedia Flash ActionScript, Flash Communication Server,
Dreamweaver, Authorware, ainsi qu’un certain nombre d’autres environnements.

La version de syntaxe JavaScript utilisée dans Director est JavaSript 1.5, ce qui signifie qu’elle est
entièrement compatible avec le standard ECMAScript Language Specification ECMA-262, 3ème
Édition. Pratiquement toutes les fonctions et fonctionnalités de JavaScript 1.5 sont désormais
disponibles dans Director.

Pour plus d’informations concernant le choix de la syntaxe Lingo ou JavaScript, reportez-vous à
la section Choisir entre Lingo et la syntaxe JavaScript, page 55.

Remarque : Ce référentiel se contente d’aborder les principales fonctions et fonctionnalités de la
version JavaScript 1.5 nécessaires à la rédaction de scripts utilisant la syntaxe JavaScript dans
Director. Il ne constitue pas un référentiel complet de JavaScript 1.5. Pour une information plus
détaillée sur JavaScript 1.5, consultez l’un des nombreux documents externes consacrés à ce sujet.

6 Chapitre 1 : Introduction

Nouvelles manières d’accéder aux API de scripting

Dans cette version de Director, les API de scripting ont été groupées par objets, et vous pouvez y
accéder par le biais de ces objets. Les objets en question comportent les fonctionnalités requises
pour ajouter de l’interactivité à vos animations et sont accessibles aux syntaxes Lingo et JavaScript
au sein de Director, des projections et de l'outil Macromedia Shockwave Player.

Même si la méthode pour y accéder peut être différente, vous avez accès aux mêmes API que dans
les versions précédentes, sans compter les toutes nouvelles API. La seule différence, c’est que vous
y accédez en utilisant les nouveaux objets.

Pour plus d’informations sur les objets et les API de scripting correspondantes, consultez

Introduction aux objets de Director, page 57.

Nouveautés dans cette documentation

Si vous avez appris à rédiger des scripts dans les versions précédentes de Director, veuillez prendre
note des changements apportés à la documentation de scripting dans cette nouvelle version. La
Référence de scripting de Director remplace le Dictionnaire Lingo accompagnant les versions
précédentes de Director. L’organisation de ce référentiel est différente de celle du Dictionnaire
Lingo.

Dans le Dictionnaire Lingo, les informations concernant le modèle de scripting étaient classées
par fonction. Par exemple, pour apprendre à utiliser les images-objets dans un script, vous
deviez consulter l’une des sections se trouvant sous l’en-tête Images-objets, telles que Glissement
d’images-objets, Dimensions des images-objets, etc. De plus, toutes les API de scripting étaient
répertoriées par ordre alphabétique dans une seule liste, et par conséquent les fonctions,
propriétés, événements, etc. figuraient tous dans la même liste.

Dans la Référence de scripting de Director, les informations concernant le modèle de scripting sont
classées par objet. Cette classification reflète fidèlement l’organisation des objets de scripting que
vous utilisez dans vos scripts. Par exemple, pour apprendre à utiliser les images-objets dans un
script, vous pouvez consulter la section Images-objets du chapitre Objets principaux de Director.

Les API de scripting sont toujours répertoriées par ordre alphabétique, mais sont classées par type
d’API. Par exemple, les méthodes sont toutes répertoriées par ordre alphabétique sous l’en-tête
Méthodes, les propriétés sont toutes classées par ordre alphabétique sous l’en-tête Propriétés, etc.

Recherche d’informations en matière de scripting dans Director

La nouvelle Référence de scripting de Director est organisé comme suit :

Principes de base du scripting dans Director fournit des informations sur les concepts et

composants de base que vous utilisez lorsque vous rédigez des scripts dans Director.

Rédaction de scripts dans Director fournit des informations sur l’environnement de scripting

de Director, en plus de celles concernant les concepts et techniques de scripting avancés.

Débogage de scripts dans Director fournit des informations sur la manière de résoudre les

problèmes liés à vos scripts.

Objets principaux de Director fournit une liste des objets et API utilisés pour accéder aux

principales fonctionnalités et fonctions de Director, telles que le moteur du lecteur de Director,
les fenêtres d'animation, les images-objets, les sons, etc.

Recherche d’informations en matière de scripting dans Director 7

Types de médias fournit une liste des types de médias et API que vous utilisez pour accéder

aux fonctionnalités des divers types de médias (RealMedia, DVD, GIF animé, etc.) et qui sont
ajoutés aux animations en tant qu'acteurs.

Objets de scripting fournit une liste d'objets de scripting, aussi appelés Xtras, et d'API utilisées

pour étendre les fonctionnalités de base de Director. Les Xtras permettent certaines actions telles
que l’importation de filtres et la connexion à Internet.

Objets 3D fournit une liste des objets utilisés pour ajouter des fonctionnalités 3D à une

animation.

Constantes fournit une liste des constantes disponibles dans Director.
Evénements et messages fournit une liste des événements disponibles dans Director.
Mots-clés fournit une liste des mots clés disponibles dans Director.
Méthodes fournit une liste des méthodes disponibles dans Director.
Opérateurs fournit une liste des opérateurs disponibles dans Director.
Propriétés fournit une liste des propriétés disponibles dans Director.

8 Chapitre 1 : Introduction

CHAPITRE 2

Principes de base du scripting dans Director

Si vous êtes novice en matière de programmation avec Macromedia Director MX 2004, prenez le
temps d’apprendre les principaux concepts de scripting qui vous aideront à créer des scripts dans
Director avant de commencer. Certains de ces principes de base comprennent des définitions de
termes importants, les règles de syntaxe, les types de données disponibles et des informations sur
les éléments de base de scripting dans Director, tels que les variables, les tableaux et les opérateurs.

Types de scripts

Une animation Director peut contenir quatre types de scripts : les comportements, les scripts
d’animation, les scripts parents et les scripts associés aux acteurs. Les comportements, les scripts
d’animation et les scripts parents figurent tous dans la fenêtre Distribution sous la forme d’acteurs
indépendants. Un script associé à un acteur figure dans la fenêtre Distribution et n’apparaît pas
indépendamment.

• Les comportements sont des scripts associés à des images-objets ou images dans le scénario et

sont appelés comportements d’image-objet ou comportements d’image. La miniature de la
fenêtre Distribution de chaque comportement contient une icône de comportement dans
l’angle inférieur droit.

Lorsqu’il est utilisé dans la Référence de scripting de Director, le terme comportement se rapporte
à un script associé à une image-objet ou une image. Cette définition diffère de celle des com­portements figurant dans la Palette des bibliothèques de Director. Pour plus d’informations
sur ces comportements de Director, consultez les rubriques Utilisation de Director du centre
de support de Director.

Tous les comportements ajoutés à une bibliothèque de distribution figurent dans le menu local
Comportements de l’inspecteur de comportement. Les autres types de scripts ne figurent pas
ici.

Vous pouvez placer le même comportement à plusieurs endroits du scénario. Lorsque vous
modifiez un comportement, la nouvelle version de ce comportement est appliquée à tous les
endroits auxquels il est associé dans le scénario.

• Les scripts d’animations contiennent des gestionnaires disponibles globalement ou au niveau

d’une animation. Les gestionnaires d’événement d’un script d’animation peuvent être appelés
depuis n’importe quel script de l’animation pendant la lecture.

Une icône de script d’animation apparaît dans l’angle inférieur droit de la miniature corres­pondante dans la fenêtre Distribution.

9

Les scripts d’animation sont disponibles pour l’animation entière, quelle que soit l’image où se
trouve la tête de lecture ou l’image-objet que l’utilisateur manipule. Lors de la lecture d’une
animation dans une fenêtre ou comme animation liée, un script d’animation n’est disponible
que pour sa propre animation.

• Les scripts parents sont des scripts spéciaux contenant les éléments Lingo utilisés pour créer des

objets enfants. Vous pouvez utiliser des scripts parents pour générer des objets scripts qui ont
une réponse et un comportement similaires tout en se comportant indépendamment les uns
des autres. Une icône de script parent apparaît dans l’angle inférieur droit de la miniature
correspondante dans la fenêtre Distribution.

Pour obtenir des informations sur l’utilisation des scripts parents et des objets enfants,
consultez Programmation orientée objet avec Lingo, page 61.

La syntaxe JavaScript n’utilise pas de scripts parents ou d’objets enfants. Elle utilise des techni­ques de programmation orientée objet de style JavaScript normales. Pour plus d’informations
sur la programmation orientée objet dans la syntaxe JavaScript, consultez Programmation orien-

tée objet avec la syntaxe JavaScript, page 72.

• Les scripts associés aux acteurs sont des scripts directement associés à un acteur, indépendam-

ment du scénario. Lorsque ces acteurs sont affectés à des images-objets, leurs scripts sont mis à
la disposition de ces dernières.

Contrairement aux comportements, aux scripts parents et aux scripts d’animation, les scripts
d’acteurs n’apparaissent pas dans la fenêtre Distribution. Cependant, si l’option Afficher les
icônes de script des acteurs est sélectionnée dans la boîte de dialogue Préférences de la fenêtre
Distribution, les acteurs auxquels sont associés des scripts sont identifiés par une petite icône
de script dans l’angle inférieur gauche de leur miniature dans la fenêtre Distribution.

Terminologie de scripting

La syntaxe Lingo et la syntaxe JavaScript utilisent toutes deux des termes qui sont propres à
chaque langage, en plus de certains termes qui sont partagés par ces langages.

Les termes importants sont présentés ici par ordre alphabétique. Ces termes sont couramment
utilisés dans la Référence de scripting de Director, et il est donc nécesaire de bien les assimiler avant
de continuer.

• Les constantes sont des éléments dont les valeurs ne changent jamais. Par exemple, en

Lingo, les constantes telles que
peuvent pas être modifiées. Dans la syntaxe JavaScript, les constantes telles que Math.PI et

Number.MAX_VALUE ont toujours les mêmes valeurs et ne peuvent pas être modifiées. Vous

pouvez également créer vos propres constantes dans la syntaxe JavaScript à l’aide du mot clé

const.

Pour plus d’informations sur les constantes, consultez Constantes, page 21.

TAB, EMPTY et RETURN ont toujours les mêmes valeurs et ne

• Les événements sont des actions qui se produisent pendant la lecture d’une animation. Les

événements se produisent à l’arrêt d’une animation, au démarrage d’une image-objet, à l’entrée
de la tête de lecture dans une image, lors de l’emploi du clavier par l’utilisateur, etc. Les événe­ments de Director sont tous prédéfinis et ont toujours le même sens.

Pour plus d’informations sur les événements, consultez Evénements, page 36.

10 Chapitre 2 : Principes de base du scripting dans Director

• Les expressions sont des parties d’instruction produisant une valeur. Par exemple, 2 + 2 est

une expression.

• Les fonctions font référence à des fonctions de haut niveau ou à des types spécifiques de codes

de la syntaxe JavaScript.
Une fonction de haut niveau ordonne à une animation de faire quelque chose pendant la

lecture de l’animation ou renvoie une valeur, mais elle n’est pas appelée à partir d’un objet
spécifique. Par exemple, vous appelez la fonction de haut niveau

list(). Comme c’est le cas pour une fonction, une méthode ordonne également à une

list() en utilisant la syntaxe

animation de faire quelque chose pendant la lecture de l’animation ou renvoie une valeur,
mais elle est toujours appelée à partir d’un objet.

En JavaScript, une fonction représente un gestionnaire d’événement, un objet personnalisé,
une méthode personnalisée, etc. L‘utilisation des fonctions JavaScripts dans des cas pareils est
expliquée dans les rubriques appropriées, plus loin dans cette référentiel.

• Les gestionnaires ou gestionnaires d’événement sont des ensembles d’instructions placées

dans un script et exécutées en réponse à un événement déterminé et à un message subséquent.
Lorsqu’un événement se produit, Director génère et envoie un message correspondant
aux scripts et un gestionnaire approprié est exécuté en réponse au message. Les noms des
gestionnaires sont toujours les mêmes que les événements et messages auxquels ils répondent.

Remarque : Bien qu’un événement soit géré par une fonction dans la syntaxe JavaScript, le terme

gestionnaire désigne, dans ce référentiel, à la fois les gestionnaires Lingo et les fonctions de la
syntaxe JavaScript qui gèrent les événements.

Pour plus d’informations sur les gestionnaires, consultez Gestionnaires, page 38.

• Les instructions sont des instructions valides que Director peut exécuter. Les scripts sont com-

posés d’ensembles d’instructions. L’instruction Lingo suivante est une instruction complète.

_movie.go("Auteur")

Pour plus d’informations sur la rédaction d’instructions, consultez Format de scripting à syntaxe

à points, page 56.

• Les listes (Lingo) ou tableaux (syntaxe JavaScript) sont des ensembles ordonnés de valeurs

qui permettent le suivi et la mise à jour d’un ensemble de données, comme une série de noms
ou de valeurs affectés à un ensemble de variables. Un exemple simple de liste est une liste de
nombres tels que

[1, 4, 2].

Pour plus d’informations sur l’utilisation des listes en Lingo et dans la syntaxe JavaScript,
consultez Listes linéaires et listes de propriétés, page 42.

Pour plus d’informations sur l’utilisation des tableaux de la syntaxe JavaScript, consultez

Tableaux de la syntaxe JavaScript, page 50.

• Les messages sont des avertissements envoyés aux scripts par Director lorsque des événements

déterminés se produisent dans une animation. Par exemple, lorsque la tête de lecture entre
dans une image donnée, l’événement

enterFrame. Si un script contient un gestionnaire enterFrame, les instructions de ce gestion-

naire seront exécutées puisque le gestionnaire a reçu le message enterFrame. Si aucun script ne
contient de gestionnaire de message, le message est ignoré dans le script.

Pour plus d’informations sur les messages, consultez Messages, page 37.

enterFrame se produit et Director envoie un message

Terminologie de scripting 11

• Les méthodes sont des termes entraînant une action pendant la lecture de l’animation ou le

renvoi d’une valeur, et sont appelées à partir d’un objet. Par exemple, vous appelez la méthode

insertFrame() de l’objet Animation en utilisant la syntaxe _movie.insertFrame(). Bien

que leurs fonctionnalités soient similaires aux fonctions de haut niveau, les méthodes sont
toujours appelées à partir d’un objet, contrairement aux fonctions de haut niveau.

• Mots-clés : mots réservés ayant un sens particulier. Par exemple, en Lingo, le mot clé end

indique la fin d’un gestionnaire. Dans la syntaxe JavaScript, le mot clé
terme suivant est une variable.

var indique que le

• Les opérateurs calculent une nouvelle valeur à partir d’une ou de plusieurs valeurs. Par

exemple, l’opérateur d’addition (
nouvelle valeur.

Pour plus d’informations sur les opérateurs, consultez Opérateurs, page 27.

+) additionne deux valeurs ou plus pour produire une

• Les paramètres sont des repères permettant de transmettre des valeurs aux scripts. Les

paramètres s’appliquent aux méthodes et gestionnaires d’événement, mais pas aux propriétés.
Ils sont exigés par certaines méthodes, mais ne sont pas obligatoires pour d’autres.

Par exemple, la méthode

go() de l’objet Animation envoie la tête de lecture à une image

précise, et indique éventuellement le nom de l’animation dans laquelle se trouve l’image.
Pour effectuer cette tâche, la méthode

go() nécessite au moins un paramètre et en accepte

un autre. Le premier paramètre requis précise l’image à laquelle doit être envoyée la tête de
lecture, le second paramètre facultatif indiquant l’animation dans laquelle se trouve l’image.
Vu que le premier paramètre est obligatoire, une erreur de script sera renvoyée s’il n’est pas
présent au moment où la méthode

go() est invoquée. Étant donné que le second paramètre

est facultatif, la méthode effectuera sa tâche même si ce paramètre n’est pas présent.

• Les propriétés sont des attributs définissant un objet. Par exemple, l’image-objet d’une

animation possède des attributs précis tels que sa largeur, sa hauteur, la couleur de son arrière­plan, etc. Pour accéder aux valeurs de ces trois attributs, vous devez utiliser les propriétés

width, height et backColor de l’objet de l’image-objet.

Pour plus d’informations sur l’attribution de propriétés aux variables, consultez Stockage et mise

à jour de valeurs dans des variables, page 22.

• Les variables sont des éléments servant à stocker et à mettre à jour des valeurs. Les variables

doivent commencer par une lettre, un trait de soulignement (
caractères suivants du nom d’une variable peuvent être des chiffres (0-9). Pour attribuer des
valeurs aux variables ou changer les valeurs de plusieurs propriétés, utilisez l’opérateur égal à
(

=).

Pour plus d’informations sur l’utilisation des variables, consultez Variables, page 22.

_) ou le signe dollar ($). Les

12 Chapitre 2 : Principes de base du scripting dans Director

Syntaxe de scripting

Les règles générales suivantes s’appliquent à la syntaxe Lingo et JavaScript.

• Les repères de commentaires varient de Lingo à la syntaxe JavaScript.

Les commentaires Lingo sont tous précédés de doubles tirets (
mentaire constitué de plusieurs lignes doit être précédée de doubles tirets.

-- Ceci est un commentaire Lingo à une seule ligne.

-- Ceci est un

-- commentaire Lingo à plusieurs lignes.

Les commentaires d’une seule ligne utilisant la syntaxe JavaScript sont précédés de deux barres
obliques (

// Ceci est un commentaire JavaScript d’une seule ligne.

/* Ceci est un
commentaire JavaScript de plusieurs lignes.*/

//). Les commentaires à plusieurs lignes sont précédés du signe /* suivi du signe */.

Vous pouvez placer un commentaire sur une ligne séparée ou après une instruction. Le texte
qui suit les repères de commentaires sur la même ligne sera ignoré.

Les commentaires peuvent être variés : il peut s’agir de notes concernant un script ou d’un ges­tionnaire particulier ou d’une instruction dont l’objectif n’est pas évident. Ces commentaires
vous permettent de vous familiariser avec une procédure que vous n’avez pas utilisée depuis
longtemps.

L’ajout d’un grand nombre de commentaires n’augmente pas la taille de votre fichier d’anima­tion lorsqu’il est enregistré sous forme d’un fichier compressé DCR ou DXR. Les commentai­res seront supprimés du fichier lors du processus de décompression.

Vous pouvez également utiliser les repères de commentaires pour ignorer les sections de code
que vous souhaitez désactiver à des fins de test ou de débogage. En ajoutant des repères de
commentaires à votre code au lieu de le supprimer, vous le transformez provisoirement en
commentaires. Sélectionnez le code à activer ou à désactiver et utilisez les boutons Insérer une
marque de commentaire ou Supprimer la marque de commentaire de la fenêtre Script pour
ajouter ou retirer rapidement les repères de commentaires.

--). Chaque ligne d’un com-

• Les parenthèses sont nécessaires après chaque nom de méthode et de fonction. Par exemple,

lorsque vous appelez la méthode
après le mot beep. Autrement, une erreur de script se produira.

// Syntaxe JavaScript
_sound.beep(); // cette instruction fonctionnera correctement
_sound.beep; // cette instruction entraînera une erreur de script

Lorsque vous appelez une méthode, une fonction ou un gestionnaire à partir d’une autre
méthode ou fonction ou d’un autre gestionnaire, vous devez inclure des parenthèses dans
l’instruction d’appel. Dans l’exemple suivant, la méthode
un appel de gestionnaire

objetCliquée

ne contient pas de parenthèses, vous obtenez une erreur de script.

beep() de l’objet Son, vous devez insérer des parenthèses

modifierImage-objet() contient

image-objetCliquée. Si l’appel du gestionnaire image-

Syntaxe de scripting 13

// Syntaxe JavaScript
function modifierImage-objet() {

image-objetCliquée(); // cet appel du gestionnaire fonctionnera
correctement
image-objetCliquée; // cet appel du gestionnaire entraînera une erreur de
script

}

function image-objetCliquée() {

// code gestionnaire ici

}

Vous pouvez également utiliser des parenthèses pour ignorer l’ordre de priorité dans les
opérations mathématiques ou pour simplifier la lecture de vos instructions. Par exemple,
la première expression mathématique ci-dessous renverra le résultat 13, tandis que la seconde
expression renverra le résultat 5 :

5 * 3 - 2 -- renvoie 13
5 * (3 - 2) -- renvoie 5

• La syntaxe des gestionnaires d’événements varie de Lingo à JavaScript. En Lingo, les

gestionnaires utilisent la syntaxe
considérés comme des fonctions et utilisent la syntaxe
exemple, les instructions suivantes contiennent un gestionnaire qui émet un bip lorsque
l’utilisateur clique sur la souris :

--Syntaxe Lingo
on mouseDown

_sound.beep()

end

// Syntaxe JavaScript
function mouseDown() {

_sound.beep();

}

on nomDeGestionnaire. En JavaScript, les gestionnaires sont

function nomDeGestionnaire(). Par

• La syntaxe des paramètres des gestionnaires d’événements peut varier de Lingo à la syntaxe

JavaScript. Lingo et JavaScript supportent tous deux les paramètres passés à un gestionnaire et
mis entre parenthèses. Si plusieurs paramètres sont passés, chaque paramètre est séparé par une
virgule. En Lingo, vous pouvez également passer des paramètres qui ne sont pas mis entre
parenthèses. Par exemple, le gestionnaire
et

b.

--Syntaxe Lingo
on additionParam a, b -- sans parenthèses

c = a + b

end

additionParam suivant reçoit les deux paramètres a

on additionParam(a, b) -- avec parenthèses

c = a + b

end

// Syntaxe JavaScript
function additionParam(a, b) {

c = a + b;

}

14 Chapitre 2 : Principes de base du scripting dans Director

• Le mot-clé const peut être utilisé dans la syntaxe JavaScript pour préciser une constante dont

la valeur ne change pas. Lingo possède son propre ensemble de constantes prédéfinies (TAB,

EMPTY, etc.) ; le mot-clé const ne s’applique donc pas à Lingo.

Par exemple, l’instruction suivante indique une constante appelée

intAuthors et définit sa

valeur comme étant 12. Cette valeur sera toujours 12 et ne pourra pas être modifiée dans le
script.

// Syntaxe JavaScript
const intAuthors = 12;

• Le mot-clé var dans la syntaxe JavaScript peut être placé devant un mot pour préciser que ce

terme est une variable. L’instruction suivante crée une variable appelée

// Syntaxe JavaScript
var valeurDébut = 0;

Remarque : Bien que l’utilisation de var dans la syntaxe JavaScript soit facultative, il est recom-
mandé de toujours déclarer les variables JavaScript locales ou celles au sein d’une fonction à
l’aide de var. Pour plus d’informations sur l’utilisation des variables, consultez Variables, page 22.

valeurDébut.

• Le symbole de continuation (\) de Lingo indique qu’une longue ligne d’exemples de codes

s’étale sur deux ou plusieurs lignes. Les lignes Lingo divisées de cette manière ne représentent
pas des lignes de codes séparées. Par exemple, le code suivant sera valide.

--Syntaxe Lingo
tTexture = member("3D").model("Boîte") \

.shader.texture

La syntaxe JavaScript ne comporte pas de symbole de continuation de ligne. Pour diviser une
longue chaîne de codes JavaScript en plusieurs lignes, il vous suffit d’ajouter un retour à la ligne
à la fin d’une ligne.

• Le point-virgule peut être utilisé pour indiquer la fin d’une instruction en code JavaScript.

Le point-virgule ne s’applique pas à Lingo.
L‘utilisation du point-virgule est facultative. Lorsqu’il est utilisé, il doit être placé à la fin d’une

instruction complète. Par exemple, les deux instructions suivantes créent une variable appelée

valeurDébut.
// Syntaxe JavaScript

var valeurDébut = 0
var valeurDébut = 0;

Un point-virgulevirgule n’indique pas nécessairement la fin d’une ligne de codes JavaScript, et
plusieurs instructions peuvent être placées sur une ligne. Toutefois, et pour des raisons de
clarté, il est conseillé de placer des instructions sur des lignes séparées. Par exemple, les trois
instructions suivantes occupent une seule ligne de codes et sont valides, mais la lecture des
codes n’est pas aisée.

// Syntaxe JavaScript
_movie.go("Auteur"); var valeurDébut = 0; _sound.beep();

• Les espaces entre les caractères au sein des expressions et instructions sont ignorés en Lingo et

en JavaScript. Dans les chaînes de caractères entre guillemets droits, les espaces sont considérés
comme des caractères. Si vous souhaitez insérer des espaces dans une chaîne, vous devez les y
placer explicitement. Par exemple, la première instruction ci-dessous ignore les espaces entre les
éléments de la liste, et la seconde inclut les espaces.

--Syntaxe Lingo
maListe1 = ["1", "2", "3"] -- renvoie ["1", "2", "3"]
maListe2 = [" 1 ", " 2 ", " 3 "] -- renvoie [" 1 ", " 2 ", " 3 "]

Syntaxe de scripting 15

• La sensibilité à la casse varie de Lingo à la syntaxe JavaScript.

Lingo ne fait pas la différence entre les majuscules et les minuscules, ce qui vous permet
d’utiliser les majuscules et les minuscules comme bon vous semble. Par exemple, les quatre
instructions suivantes sont équivalentes :

--Syntaxe Lingo
member("Chat").hilite = true
member("chat").hiLite = True
MEMBER("CHAT").HILITE = TRUE
Member("Chat").Hilite = true

Bien que Lingo ne soit pas sensible à la casse, il est recommandé de choisir une casse et de
l’utiliser de manière cohérente dans les scripts. Cette habitude permet d’identifier plus
facilement les noms de gestionnaires, variables, acteurs, etc.

La syntaxe JavaScript est sensible à la casse lorsqu’elle fait référence à des objets, propriétés de
haut niveau ou méthodes liées aux variables définies par l’utilisateur. Par exemple, la méthode
de haut niveau

sprite() renvoie un référence à une image-objet précise, et est implementée

dans Director avec des lettres minuscules. La première instruction ci-dessous se rapporte au
nom de la première image-objet d’une animation, tandis que les deux instructions suivantes
entraînent une erreur de script.

// Syntaxe JavaScript
sprite(1).name // Cette instruction fonctionne normalement
Sprite(1).name // Cette instruction entraîne une erreur de script
SPRITE(1).name // Cette instruction entraîne une erreur de script

Les chaînes littérales sont toujours sensibles à la casse en Lingo et en JavaScript.
Pour plus d’informations sur l’utilisation des chaînes, consultez Chaînes, page 19.

Types de données

Un type de données est un ensemble de données dont les valeurs possèdent des caractéristiques
similaires et prédéfinies. Chaque valeur de variable et de propriété dans Directeur est d’un type de
données précis, et les valeurs renvoyées par les méthodes sont d’un type de données précis.

Par exemple, considérons les deux instructions suivantes. Dans la première instruction, il a été
attribué à la variable
nombre entier. Dans la seconde instruction, il a été attribué à la variable
de valeurs de caractères, c’est-à-dire une chaîne. La variable

entX le nombre entier 14. La variable entX est donc du type de données

chaîneX une séquence

chaîneX est donc du type de données

chaîne.

--Syntaxe Lingo
entX = 14
chaîneX = "Nouvelles du jour"

// Syntaxe JavaScript
var entX = 14;
var chaîneX = "Nouvelles du jour";

Les valeurs renvoyées par les méthodes ou fonctions appartiennent également à un type de
données. Par exemple, la méthode

windowPresent() de l’objet Lecteur renvoie une valeur

indiquant si une fenêtre est présente. La valeur renvoyée est TRUE (1) ou FALSE (0).

16 Chapitre 2 : Principes de base du scripting dans Director

Certains types de données sont partagés par Lingo et JavaScript, et d’autres se rapportent à l’un ou
l’autre langage. L‘ensemble de types de données pris en charge par Director est fixe et ne peut être
modifié, ce qui signifie qu’il n’est pas possible d’ajouter de nouveaux types de données ou de
supprimer les types de données existants. Director supporte les types de données suivants.

Type de données Description

# (symbole) Unité autonome pouvant représenter une condition ou un indicateur.

Array (Syntaxe JavaScript seulement) Bien qu’il ne s’agisse pas exactement

Boolean Une valeur

Color Représente la couleur d’un objet.

Constant Une donnée dont la valeur ne change pas.

Date Bien qu’il ne s’agisse pas exactement d’un type de données, un objet Date

Float (Lingo seulement) Nombre à virgule flottante. Par exemple, 2,345 ou

Function (Syntaxe JavaScript seulement) Bien qu’il ne s’agisse pas exactement

Integer (Lingo seulement) Nombre entier. Par exemple, 5 ou 298.

List Une liste linéaire ou de propriétés composée respectivement de noms de

Math (Syntaxe JavaScript seulement) Bien qu’il ne s’agisse pas exactement

null (Syntaxe JavaScript seulement) Indique une variable dont la valeur

Number (Syntaxe JavaScript seulement) Bien qu’il ne s’agisse pas exactement

Par exemple,

d’un type de données, un objet Array (tableau) peut être utilisé sur des
listes linéaires de valeurs. La fonctionnalité d’un objet Array est identique à
celle du type de données Liste de Lingo.

sont de simples constantes de nombres entiers, 1 pour
Dans la syntaxe JavaScript, toutes les valeurs
défaut, les vraies valeurs booléennes
quement converties, le cas échéant, en simples constantes de nombres
entiers dans Director.
En Lingo,
syntaxe JavaScript,

peut être utilisé avec les dates en JavaScript. En Lingo, utilisez la méthode
date() pour travailler avec les dates.

45,43.

d’un type de données, un objet Function peut être utilisé pour préciser une
chaîne ou un code à exécuter.

valeurs ou de propriétés, et de valeurs.

d’un type de données, un objet Math peut être utilisé pour effectuer des
opérations mathématiques.

correspond à 0 dans les contextes numériques et à FALSE dans les
contextes booléens.

d’un type de données, un objet Number peut être utilisé pour représenter
des constantes numériques telles qu’une valeur maximale, une valeur not­a-number (NaN) et une infinité.

#list ou #word.

TRUE (1) ou FALSE (0). En Lingo, toutes les valeurs TRUE ou FALSE

TRUE, 0 pour FALSE.

true ou false sont, par

true ou false, mais sont automati-

TRUE et FALSE peuvent être en majuscules ou minuscules. Dans la

true et false doivent toujours être en minuscules.

Types de données 17

Type de données Description

Object Bien qu’il ne s’agisse pas exactement d’un type de données, un objet

Point Point sur la scène ayant une coordonnée à la fois horizontale et verticale.

Rect Rectangle sur la scène.

RegExp (JavaScript seulement) Modèle d’expression régulier correspondant à des

String Chaîne de symboles clavier ou de valeurs de caractères. Par exemple,

undefined (Syntaxe JavaScript seulement) Indique une variable qui n’a pas de valeur.

Vector Point dans l’espace 3D.

VOID (Lingo seulement) Indique une valeur vide.

Remarque : Plusieurs types de données et d’objets de la syntaxe JavaScript possèdent leur propre
ensemble de méthodes et propriétés qui peuvent être utilisées pour manipuler ces types. Bien que la
Référence de scripting de Director donne parfois des informations sur certaines de ces méthodes et
propriétés, ces informations ne sont pas complètes. Pour plus d’informations sur ces types de
données et objets, et leur méthodes et propriétés, consultez l’une des nombreuses ressources sur le
sujet.

Object peut être utilisé pour créer un conteneur personnalisé de données
et des méthodes agissant sur les données.

combinaisons de caractères dans des chaînes.

"Director" ou "$5.00".

Les propriétés intégrées de Director, telles que la propriété name de l’objet Acteur, ne peuvent
recevoir que des valeurs qui sont du même type de données que celui de la propriété. Par exemple,
le type de données de propriété du
être une chaîne telle que

Nouvelle du jour. Si vous essayez d’attribuer une valeur de type de

name de l’objet Auteur est une chaîne, et la valeur doit donc

données différent à cette propriété, telle que le nombre entier 20, vous obtenez une erreur de
script.

Si vous créez vos propres propriétés, leurs valeurs peuvent être de n’importe quel type de données,
quel que soit le type de données de la valeur initiale.

Les syntaxes Lingo et JavaScript sont toutes deux dynamiques. Cela signifie que vous n’avez pas à
préciser le type de données d’une variable lorsque vous la déclarez et que les types de données sont
automatiquement convertis lors de l’exécution d’un script.

Par exemple, la syntaxe JavaScript suivante définit la variable

monAnimation comme étant un

nombre entier, et plus tard, est définie comme étant une chaîne. Lors de l’exécution du script, le
type de données de

--Syntaxe Lingo
monAnimation = 15 -- monAnimation est défini, au départ, en tant que nombre

entier
...
monAnimation = "Animations" -- monAnimation est défini, par la suite, en tant

que chaîne

monAnimation est converti automatiquement.

// Syntaxe JavaScript
var monAnimation = 15; // monAnimation est défini, au départ, en tant que

nombre entier
...
monAnimation = "Animations " -- monAnimation est défini, par la suite, en tant

que chaîne

18 Chapitre 2 : Principes de base du scripting dans Director

Valeurs littérales

Une valeur littérale est une partie d’instruction ou d’expression qui doit être traitée telle quelle,
et non comme une variable ou un élément de script. Les valeurs littérales que vous pourrez
rencontrer dans un script sont les chaînes de caractères, les entiers, les nombres décimaux, les
noms et numéros d’acteurs, les noms et numéros d’images et d’animations, les symboles et les
constantes.

Chaque type de valeur littérale est régi par ses propres règles.

Chaînes

Les chaînes sont des mots ou des groupes de caractères que le script traite en tant que mots
standard, et non en tant que variables. Elles doivent être encadrées de guillemets droits. Par
exemple, vous pouvez utiliser des chaînes pour transmettre des messages aux utilisateurs de
votre animation ou pour attribuer des noms aux acteurs. Dans l’instruction suivante,
et Salutations sont des chaînes. Bonjour est le texte littéral placé dans l’acteur texte et

Salutations est le nom de ce dernier.

--Syntaxe Lingo
member("Salutations").text = "Bonjour"

De même, lorsque vous testez une chaîne, vous devez l’encadrer de guillemets droits, comme dans
l’exemple suivant :

--Syntaxe Lingo
if "Bonjour M. Dupont" contains "Bonjour" then gestionnaireAudio

Lingo et JavaScript considèrent les espaces figurant au début ou à la fin d’une chaîne comme une
partie littérale de la chaîne. L’expression suivante comprend un espace après le mot à :

// Syntaxe JavaScript
trace("Mes pensées se résument à ");

Bien que Lingo ne distingue pas les majuscules des minuscules lorsqu’il fait référence aux acteurs,
aux variables, etc., les chaînes littérales sont sensibles à la casse. Par exemple, les deux instructions
suivantes placent un texte différent dans l’acteur indiqué, car
chaînes littérales.

--Syntaxe Lingo
member("Salutations").text = "Bonjour"
member("Salutations").text = "BONJOUR"

En Lingo, la fonction string() peut convertir une valeur numérique en une chaîne. Dans la
syntaxe JavaScript, la méthode

Remarque : Si vous essayez d’utiliser la méthode toString() de la syntaxe JavaScript sur une
valeur null ou undefined, vous obtenez une erreur de script. Ceci n’est pas le cas en Lingo, dont la
fonction string() s’applique à toutes les valeurs, y compris celles qui sont VOID.

toString() peut convertir une valeur numérique en une chaîne.

Bonjour et BONJOUR sont des

Bonjour

Valeurs littérales 19

Nombres

Il existe deux types de nombres en Lingo : entiers et décimaux.
Un nombre entier ne comporte ni fraction ni décimale, dans les plages -2 147 483 648 et

[phone]. Entrez des nombres entiers sans utiliser de virgule. Utilisez le signe moins (
pour les nombres négatifs.

Un nombre décimal, également appelé nombre à virgule flottante, est un nombre qui inclut une
virgule décimale. En Lingo, la propriété

floatPrecision détermine le nombre de décimales

utilisées pour l’affichage de ces nombres. Director utilise toujours le nombre tout entier, jusqu’à
15 chiffres utiles , dans ses calculs ; il arrondit tout nombre comportant plus de 15 chiffres utiles.

JavaScript ne fait pas de distinction entre les nombres entiers et les nombres à virgule flottante, et
n’utilise que des nombres. Par exemple, les instructions suivantes montrent que le nombre 1 est
un nombre entier en Lingo et un nombre dans la syntaxe JavaScript, et que le nombre décimal

1.05 est un nombre à virgule flottante en Lingo et un nombre en JavaScript :

--Syntaxe Lingo
put(ilk(1)) -- #integer
put(ilk(1.05)) -- #float

// Syntaxe JavaScript
trace(typeof(1)); // nombre
trace(typeof(1.05)); // nombre

En Lingo, vous pouvez convertir un nombre décimal en nombre entier avec la fonction

integer(). Vous pouvez également convertir un nombre entier en nombre décimal en effectuant

une opération mathématique sur le nombre entier, par exemple en multipliant le nombre entier
par le nombre décimal. En JavaScript, la fonction
chaîne ou un nombre décimal en nombre entier. Contrairement à la fonction
Lingo,

parseInt() arrondit au plus petit. Par exemple, l’instruction suivante arrondit le nombre

parseInt() vous permet de convertir une

integer() de

décimal 3.9 et le convertit au nombre entier 4 (Lingo) et 3 (JavaScript).

--Syntaxe Lingo
leNombre = integer(3.9) – renvoie la valeur 4

-)

// Syntaxe JavaScript
var leNombre = parseInt(3.9); // renvoie la valeur 3

En Lingo, la fonction value() peut convertir une chaîne en une valeur numérique.
Vous pouvez également utiliser une notation exponentielle avec les nombres décimaux : par

exemple, -

1.1234e-100 ou 123.4e+9.

En Lingo, vous pouvez convertir un nombre entier ou une chaîne en nombre décimal avec la
fonction

float(). En JavaScript, la fonction parseFloat() vous permet de convertir une

chaîne en nombre décimal. Par exemple, l’instruction suivante enregistre la valeur 3.0000 (Lingo)
et 3 (syntaxe JavaScript) dans la variable

--Syntaxe Lingo
leNombre = float(3) – renvoie une valeur de 3.0000

// Syntaxe JavaScript
var leNombre = parseFloat(3) // renvoie une valeur de 3

20 Chapitre 2 : Principes de base du scripting dans Director

leNombre.

Constantes

Une constante est une valeur déclarée dont le contenu ne change jamais.
En Lingo, les termes prédéfinis

TRUE, FALSE, VOID et EMPTY sont des constantes car leur valeur ne

change jamais. Les termes prédéfinis BACKSPACE, ENTER, QUOTE, RETURN, SPACE et TAB sont des
constantes qui font référence aux touches du clavier. Par exemple, pour tester si la dernière touche
enfoncée par l’utilisateur était la barre Espace, utilisez l’instruction suivante :

--Syntaxe Lingo
if _key.keyPressed() = SPACE then beep()

En JavaScript, vous pouvez accéder à des constantes prédéfinies à l’aide de types de données
propres à la syntaxe JavaScript. Par exemple, objet Number contient des constantes telles que

Number.MAX_VALUE et Number.NaN, l’objet Math renferme des constantes telles que Math.PI et
Math.E, etc.

Remarque : Ce référentiel ne fournit pas d’informations complètes sur les constantes prédéfinies
dans la syntaxe JavaScript. Pour plus d’informations sur ces constantes, consultez les nombreuses
autres ressources consacrées à ce sujet.

Dans la syntaxe JavaScript, vous pouvez également définir vos propres constantes à l’aide du mot­clé

const. Par exemple, l’instruction suivante crée une constante appelée items et lui attribue la

valeur 20. Cette valeur ne peut pas être modifiée après sa création.

// Syntaxe JavaScript
const items = 20;

Pour plus d’informations sur les constantes, consultez le Chapitre 9, Constantes, page 165.

Symboles

En Lingo, un symbole est une chaîne ou toute autre valeur précédée du signe dièse (

#).

Les symboles sont des constantes définies par l’utilisateur. Les comparaisons utilisant des
symboles s’effectuent très rapidement, créant ainsi un code plus efficace.

Par exemple, la première instruction ci-dessous s’exécute plus rapidement que la seconde :

--Syntaxe Lingo
niveauUtilisateur = #novice
niveauUtilisateur = "novice"

Les symboles ne peuvent contenir ni espace ni ponctuation.
En Lingo et en JavaScript, convertissez une chaîne en symbole à l’aide de la méthode

--Syntaxe Lingo
x = symbol("novice") – renvoie le résultat #novice

symbol().

// Syntaxe JavaScript
var x = symbol("novice"); // renvoie le résultat #novice

Reconvertissez un symbole en chaîne à l’aide de la fonction string() (Lingo) ou la méthode

toString() (syntaxe JavaScript).

--Syntaxe Lingo
x = string(#novice) -- renvoie "novice"

// Syntaxe JavaScript
var x = symbol("novice").toString(); // renvoie le résultat "novice"

Valeurs littérales 21

Dans la syntaxe JavaScript, vous ne pouvez pas comparer des symboles du même nom pour
déterminer s’ils font référence au même symbole. Pour comparer des symboles du même nom,
vous devez d’abord les convertir en chaîne en utilisant la méthode

toString().

Variables

Director utilise des variables pour conserver et actualiser les valeurs. Comme son nom l’indique,
une variable contient une valeur qui peut être modifiée ou mise à jour pendant la lecture de
l’animation. En modifiant la valeur d’une variable pendant la lecture de l’animation, vous pouvez
par exemple stocker une URL, mémoriser le nombre de fois qu’un utilisateur prend part à une
session de discussion en ligne, enregistrer si une opération réseau est terminée ou non, etc.

Il est conseillé de toujours attribuer une valeur connue à une variable la première fois que vous la
déclarez. Cette opération est appelée « initialisation d’une variable ». L’initialisation d’une variable
facilite le suivi de cette variable et permet de comparer ses différentes valeurs au fur et à mesure de
la lecture de l’animation.

Les variables peuvent être globales ou locales. Une variable locale n’existe que tant que le
gestionnaire dans lequel elle a été définie est en cours d’exécution. Une variable globale peut
exister et conserver sa valeur tant que l’application Director est en cours d’exécution, notamment
lorsqu’une animation passe à une autre animation. Une variable peut être globale au sein d’un
gestionnaire individuel, un script spécifique ou une animation entière ; la portée dépend de la
manière dont la variable globale est initialisée.

Puisque les variables globales doivent en général être disponibles durant toute l’animation,
il est d’usage de les déclarer dans un gestionnaire

prepareMovie()

(syntaxe JavaScript). Elles sont ainsi disponibles dès le début de l’animation.

Pour plus d’informations sur l’utilisation des variables globales et locales, consultez Utilisation de

variables globales, page 24 et Utilisation de variables locales, page 26.

on prepareMovie (Lingo) ou function

Stockage et mise à jour de valeurs dans des variables

Les variables peuvent contenir des données pour tous les types de données de Director, qu’il
s’agisse de nombres entiers, de chaînes, de valeurs

TRUE ou FALSE, de symboles, de listes ou du

résultat d’un calcul. Pour stocker les valeurs des propriétés et des variables, utilisez l’opérateur égal
à (

=).

Comme indiqué dans la section Types de données de ce référentiel, les variables de Lingo et
JavaScript sont dynamiques, ce qui signifie qu’elles contiennent des types de données différents à
des moments différents. (La possibilité de modifier le type d’une variable distingue Lingo d’autres
langages tels que Java et C++, où cette possibilité n’existe pas.)

Par exemple, l’instruction

set x = 1 crée la variable x, qui est une variable nombre entier, car

vous lui avez attribué un entier. Si vous utilisez ensuite l’instruction set x = "un", la variable x
devient une variable à chaîne puisqu’elle contient maintenant une chaîne.

Vous pouvez convertir une chaîne en nombre à l’aide de la fonction
méthode

string() (Lingo) ou de la méthode toString() (syntaxe JavaScript).

22 Chapitre 2 : Principes de base du scripting dans Director

parseInt() (syntaxe JavaScript), ou un nombre en chaîne à l’aide de la fonction

value() (Lingo) ou de la

Les valeurs de certaines propriétés peuvent être définies (la valeur est attribuée) et renvoyées
(la valeur est récupérée), et les valeurs de certaines propriétés ne peuvent être que renvoyées.
Les propriétés dont les valeurs peuvent être à la fois définies et renvoyées sont appelées lecture/
écriture, celles qui peuvent seulement être renvoyées étant appelées lecture seule.

Il s’agit en général de propriétés décrivant une condition échappant au contrôle de Director. Par
exemple, vous ne pouvez pas définir la propriété d’acteur

numChannels, qui indique le nombre de

pistes d’une animation possédant un contenu Macromedia Shockwave. Par contre, vous pouvez
récupérer le nombre de pistes en faisant référence à la propriété

Pour attribuer une valeur à une variable :

numChannels d’un acteur.

• Utilisez l’opérateur égal à (=).

Par exemple, l’instruction suivante attribue une URL à la variable

// Syntaxe JavaScript
var endroitsAvisiter = "http://www.macromedia.com";

Les variables peuvent également contenir le résultat d’opérations mathématiques. Par exemple,
l’instruction suivante ajoute le résultat d’une addition à la variable

--Syntaxe Lingo
maSomme = 5 + 5 -- ceci définit maSomme comme étant égale à 10

En guise d’exemple supplémentaire, l’instruction suivante renvoie l’acteur affecté à l’image-objet
2 en récupérant la valeur de la propriété

ActeurTexte.

--Syntaxe Lingo
ActeurTexte = sprite(2).member

member de l’image-objet, et la place dans la variable

Il est recommandé d’utiliser des noms de variables indiquant le rôle de ces variables. Vos scripts
n’en seront que plus faciles à lire. Par exemple, la variable

maSomme indique que cette variable

contient le résultat d’une addition.

endroitsAvisiter :

maSomme:

Pour tester la valeur de propriétés ou de variables :

• Utilisez la fonction put() ou trace() dans la fenêtre Messages ou cochez les valeurs de la

fenêtre Surveillance ;

disponibles en Lingo et la syntaxe JavaScript.
Par exemple, l’instruction suivante affiche la valeur attribuée à la variable

fenêtre Messages.

--Syntaxe Lingo
monNuméro = 20 * 7
put(monNuméro) -- affiche 140 dans la fenêtre Messages

// Syntaxe JavaScript
var monNuméro = 20 * 7;
trace(monNuméro); // affiche 140 dans la fenêtre Messages

put() et trace() proposent des fonctionnalités identiques et sont

monNuméro dans la

Variables 23

Utilisation de variables globales

Les variables globales peuvent être partagées par les gestionnaires, les scripts ou les animations.
Une variable globale existe et garde sa valeur tant que Director est en cours d’exécution ou jusqu’à
ce que vous appeliez la méthode

clearGlobals.

Dans Macromedia Shockwave Player, les variables globales subsistent dans les animations
affichées par la méthode

goToNetPage().

goToNetMovie(), mais pas dans celles affichées par la méthode

Chaque gestionnaire déclarant une variable globale peut utiliser la valeur de cette variable.
S’ils modifient cette valeur, la nouvelle valeur est accessible à tous les autres gestionnaires qui
considèrent cette variable comme globale.

Il est d’usage de démarrer les noms de toutes les variables globales par un g minuscule. Cette
convention permet d’identifier plus facilement les variables globales lors de l’examen du code.

Director propose une manière d’afficher toutes les variables globales actuelles et leurs valeurs
courantes, et d’effacer les valeurs de toutes les variables globales.

Pour afficher toutes les variables globales et leurs valeurs actuelles :

• Utilisez la méthode showGlobals() de l’objet Global dans la fenêtre Messages.

Pour plus d’informations sur la fenêtre Messages, consultez Débogage dans la fenêtre Messages,

page 98.

Pour supprimer toutes les variables globales actuelles :

• Utilisez la méthode clearGlobals() de l’objet Global de la fenêtre Messages pour attribuer à

toutes les variables globales la valeur
Le contrôle des valeurs des variables globales, lors de la lecture d’une animation, s’effectue par le

biais de l’inspecteur d’objet. Pour plus d’informations sur l’inspecteur d’objet, consultez Débogage

de l’inspecteur d’objet, page 102.

VOID (Lingo) ou undefined (syntaxe JavaScript).

Variables globales en Lingo

En Lingo, les variables sont, par défaut, considérées comme des variables locales, et vous n’avez
donc pas besoin d’insérer un mot-clé avant le nom d’une variable. Pour déclarer une variable
globale, vous devez insérer le mot-clé

global avant la variable.

Si vous déclarez une variable globale en haut de la fenêtre Script et avant un gestionnaire,
cette variable sera disponible pour tous les gestionnaires de ce script. Si vous déclarez une
variable globale au sein d’un gestionnaire, cette variable sera à la disposition de ce gestionnaire
uniquement ; toutefois, si vous déclarez une variable globale du même nom au sein de deux
gestionnaires distincts, et que vous mettez à jour la valeur de la variable dans un gestionnaire,
vous mettez également à jour la valeur de la variable dans l’autre gestionnaire.

24 Chapitre 2 : Principes de base du scripting dans Director

Les exemples suivants illustrent ce qui se passe avec deux variables globales : gScript, qui est à
la disposition de tous les gestionnaires dans le script, et gGestionnaire, qui est disponible au
sein de son propre gestionnaire et de tout autre gestionnaire qui la déclare à sa première ligne.

--Syntaxe Lingo
global gScript -- gScript est à la disposition de tous les gestionnaires

on mouseDown

gGestionnaire global

gScript = 25

gGestionnaire = 30
end

on mouseUp

gGestionnaire global

trace(gGestionnaire) -- affiche 30
end

En Lingo, lorsque vous utilisez le terme global pour définir les variables globales, ces dernières
reçoivent automatiquement la valeur initiale

VOID.

Variables globales dans la syntaxe JavaScript

Dans la syntaxe JavaScript, les variables sont considérées comme des variables globales par défaut.
La portée d’une variable globale peut être déterminée par la manière dont elle est déclarée et la
position à laquelle elle est déclarée.

• Si vous déclarez une variable au sein d’une fonction de la syntaxe JavaScript sans la faire

précéder du mot-clé

la contient.

var, cette variable sera disponible pour toutes les fonctions du script qui

• SI vous déclarez une variable en dehors d’une fonction de la syntaxe JavaScript, avec ou sans le

mot-clé

var, cette variable sera disponible pour toutes les fonctions du script qui la contient.

• Si vous déclarez une variable à l’intérieur ou à l’extérieur d’une fonction de la syntaxe

JavaScript en utilisant la syntaxe

les scripts d’une animation.
L’exemple suivant utilise la syntaxe

en tant que variable globale. Cette variable est à la disposition de tous les scripts d’une animation.

// Syntaxe JavaScript
_global.gFilm = 1; // déclare gFilm dans un script

_global.nomVar, cette variable sera disponible pour tous

_global.gFilm dans un script pour déclarer la variable gFilm

// Crée une fonction dans un script séparé qui agit sur gFilm
function mouseDown() {

_global.gFilm++;

return(_global.gFilm);
}

Variables 25

L’exemple suivant déclare la variable globale gScript dans un script. Cette variable est unique­ment à la disposition des fonctions de ce script.

// Syntaxe JavaScript
var gScript = 1; // déclare gScript dans un script

// gScript est uniquement à la disposition des fonctions du script qui le

définit
function mouseDown() {

gScript++;

return(gScript);
}

Dans la syntaxe JavaScript, lorsque vous définissez des variables avant les gestionnaires, elles
reçoivent automatiquement la valeur intiale

undefined.

Utilisation de variables locales

Une variable locale n’existe que tant que le gestionnaire dans lequel elle a été définie est en cours
d’exécution. Toutefois, après avoir créé un variable locale, vous pouvez l’utiliser dans d’autres
expressions ou modifier sa valeur tant qu’un script se trouve dans le gestionnaire qui a défini la
variable.

Il est préférable de définir une variable comme locale lorsque vous ne souhaitez l’utiliser que
provisoirement dans un gestionnaire. Vous limitez ainsi les risques de modification accidentelle
de sa valeur dans d’autres gestionnaires utilisant le même nom de variable.

Pour créer une variable locale :

• En Lingo, attribuez une valeur à la variable avec l’opérateur égal à (=).

• Dans la syntaxe JavaScript, et à l’intérieur d’une fonction, insérez le mot-clé var avant le nom

de la variable puis attribuez-lui une valeur à l’aide de l’opérateur égal à.

Remarque : Vu que les variables de la syntaxe JavaScript sont, par défaut, globales, si vous

essayez de déclarer une variable locale à l’intérieur d’une fonction sans utiliser le mot-clé var,

votre script risque de créer un comportement inattendu. Ainsi, et bien que l’utilisation de var soit

facultative, il est fortement recommandé de déclarer toutes les variables JavaScript locales à l’aide

de var pour éviter tout comportement inattendu.

Pour afficher toutes les variables locales d’un gestionnaire :

• En Lingo seulement, utilisez la fonction showLocals().

En Lingo, vous pouvez utiliser cette méthode dans la fenêtre Messages ou dans des gestionnaire
pour faciliter le débogage des scripts. Le résultat apparaît dans la fenêtre Messages. La méthode

showLocals() ne s’applique pas à la syntaxe JavaScript.

Pour contrôler les valeurs des variables locales lors de la lecture d’une animation, utilisez
l’inspecteur d’objet. Pour plus d’informations sur l’inspecteur d’objet, consultez Débogage de

l’inspecteur d’objet, page 102.

26 Chapitre 2 : Principes de base du scripting dans Director

Opérateurs

Les opérateurs sont des éléments indiquant à Lingo et JavaScript comment combiner, comparer
ou modifier les valeurs d’une expression. Plusieurs des opérateurs de Director sont partagés par la
syntaxe Lingo et la syntaxe JavaScript, et certains sont propres à un langage.

Certains types d’opérateurs comprennent :

• Des opérateurs arithmétiques (tels que +, -, / et *)

• Des opérateurs de comparaison (tels que <, > et >=), qui comparent deux arguments

• Des opérateurs logiques (not, and, or) qui combinent des conditions simples en conditions

composées

• Des opérateurs de chaînes (tels que &, &&, et +) qui relient ou concatènent des chaînes de

caractères.

Remarque : Il existe beaucoup plus de types d’opérateurs dans la syntaxe JavaScript qu’en Lingo, et
ils ne sont pas tous décrits dans ce référentiel. Pour plus d’informations sur les autres opérateurs en
JavaScript 1.5, consultez les nombreuses autres ressources consacrées à ce sujet.

Les éléments sur lesquels les opérateurs agissent sont appelés des opérandes. En Lingo, il n’existe
que des opérateurs binaires. Dans la syntaxe JavaScript, il existe des opérateurs binaires et unaires.
Un opérateur binaire nécessite deux opérandes, l’un placé avant l’opérateur et l’autre après. Un
opérateur unaire nécessite un seul opérande, placé soit avant soit après l’opérateur.

Dans l’exemple suivant, la première instruction illustre un opérateur binaire où les variables
sont des opérandes et le signe plus (
unaire où la variable

// Syntaxe JavaScript
x + y; // opérateur binaire
i++; // opérateur unaire

i est l’opérande et ++ l’opérateur.

Pour plus d’informations sur les opérateurs, consultez le Chapitre 13, Opérateurs, page 635.

+) l’opérateur. La seconde instruction illustre un opérateur

x et y

Ordre de priorité des opérateurs

Lorsqu’un ou plusieurs opérateurs sont utilisés dans la même instruction, certains opérateurs sont
prioritaires par rapport à d’autres selon une hiérarchie précise qui détermine les opérateurs à
exécuter en premier. Cette hiérarchie est appelée « ordre de priorité des opérateurs ». Par exemple,
une multiplication est toujours effectuée avant une addition. Cependant, les éléments entre
parenthèses sont prioritaires par rapport à la multiplication. Dans l’exemple suivant, en l’absence
de parenthèses, la multiplication de cette instruction se produit en premier :

--Syntaxe Lingo
total = 2 + 4 * 3 – renvoie une valeur de 14

Lorsque l’addition apparaît entre parenthèses, l’addition s’effectue en premier :

--Syntaxe Lingo
total = (2 + 4) * 3 – renvoie une valeur de 18

Vous trouverez ci-dessous une description des types d’opérateurs et leur ordre de priorité. Les
opérateurs possédant une priorité élevée sont exécutés en premier. Par exemple, un opérateur
dont l’ordre de priorité est 5 est exécuté avant un opérateur dont l’ordre de priorité est 4. Les
opérations qui ont le même ordre de priorité sont exécutées de gauche à droite.

Opérateurs 27

Opérateurs arithmétiques

Les opérateurs arithmétiques additionnent, soustraient, multiplient, divisent et effectuent d’autres
opérations arithmétiques. Les parenthèses et le signe moins sont aussi des opérateurs
arithmétiques.

Opérateur Effet Ordre de priorité

( )

-

*

mod

/

%

++

--

+

-

Opérations permettant de contrôler la priorité. 5

Lorsque placé devant un chiffre, en inverse la valeur. 5

Effectue une multiplication. 4

(Lingo seulement) Effectue des opérations de modulos. 4

Effectue une division. 4

(Syntaxe JavaScript seulement) Renvoie le reste du nombre
entier résultant d’une division de deux opérandes.

(Syntaxe JavaScript seulement) Ajoute un à son opérande.
Lorsque utilisé comme opérateur préfixe (
son opérande après avoir ajouté un. Lorsque utilisé comme
opérateur postfixe (
d’ajouter un.

(Syntaxe JavaScript seulement) Soustrait un de son opérande. La
valeur renvoyée est analogue à celle de l’opérateur d’incréments.

Lorsque placé entre deux chiffres, effectue une addition. 3

Lorsque placé entre deux chiffres, effectue une soustraction. 3

x++), renvoie la valeur de son opérande avant

++x), renvoie la valeur de

4

4

4

Remarque : En Lingo, lorsque seuls des nombres entiers sont utilisés dans une opération, le résultat
est un nombre entier. Si vous utilisez des entiers et des nombres à virgule flottante dans la même
opération, le résultat est toujours un nombre à virgule flottante. Dans la syntaxe JavaScript, tous les
calculs renvoient comme résultat des nombres à virgule flottante.

Si le résultat de la division d’un entier par un autre entier n’est pas un nombre entier, Lingo
arrondit le résultat au nombre entier inférieur le plus proche. Par exemple, le résultat de
Dans la syntaxe JavaScript, la valeur à virgule flottante, 1.333, est renvoyée.

Pour forcer Lingo à calculer une valeur sans arrondir le résultat, utilisez
plusieurs des valeurs dans l’expression. Par exemple, le résultat de

28 Chapitre 2 : Principes de base du scripting dans Director

float() avec une ou

4/float(3) est 1.333.

4/3 est 1.

Opérateurs de comparaison

Les opérateurs de comparaison comparent deux valeurs et déterminent si la comparaison est vraie
(true) ou fausse (false).

Opérateur Signification Ordre de priorité

==

===

!=

!==

<>

<

<=

>

>=

=

(Syntaxe JavaScript seulement) Deux opérandes sont égaux. Si
les opérandes ne sont pas du même type de données, la syntaxe
JavaScript essaie de les convertir en type de données approprié
afin d’effectuer une comparaison.

(Syntaxe JavaScript seulement) Deux opérandes sont égaux et
du même type.

(Syntaxe JavaScript seulement) Deux opérandes ne sont pas
égaux. Si les opérandes ne sont pas du même type de données, la
syntaxe JavaScript essaie de les convertir en type de données
approprié afin d’effectuer une comparaison.

(Syntaxe JavaScript seulement) Deux opérandes ne sont pas
égaux et/ou du même type.

(Syntaxe Lingo seulement) Deux opérandes ne sont pas égaux. 1

L’opérande de gauche est inférieur à l’opérande de droite. 1

L’opérande de gauche est inférieur ou égal à l’opérande de droite. 1

L’opérande de gauche est supérieur à l’opérande de droite. 1

L’opérande de gauche est supérieur ou égal à l’opérande de
droite.

(Lingo seulement) Deux opérandes sont égaux 1

1

1

1

1

1

Opérateurs d’affectation

Un opérateur d’affectation attribue une valeur à son opérande de gauche en fonction de la valeur
de son opérande de droite. A l’exception de l’opérateur d’affectation de base égal à (

=), tous les

opérateurs d’affectation de raccourcis suivants ne s’appliquent qu’à la syntaxe JavaScript.

Opérateur Signification Ordre de priorité

= Egal à 1

x += y (Syntaxe JavaScript seulement) x = x + y 1

x -= y (Syntaxe JavaScript seulement) x = x - y 1

x *= y (Syntaxe JavaScript seulement) x = x * y 1

x /= y (Syntaxe JavaScript seulement) x = x / y 1

x %= y (Syntaxe JavaScript seulement) x = x % y 1

Opérateurs 29

Opérateurs logiques

Les opérateurs logiques testent si deux expressions logiques sont vraies (true) ou fausses (false).
Faites attention lorsque vous utilisez les opérateurs logiques et les opérateurs de chaînes en Lingo

et en JavaScript. Par exemple, dans la syntaxe JavaScript,
mine si deux expressions sont vraies, mais en Lingo,

&& est un opérateur logique qui déter-

&& est un opérateur de chaînes qui concatène

deux chaînes et insère un espace entre deux expressions.

Opérateur Effet Ordre de priorité

and

&&

ou

||

not

!

(Lingo seulement) Détermine si les deux expressions sont vraies. 4

(Syntaxe JavaScript seulement) Détermine si les deux
expressions sont vraies.

(Lingo seulement) Détermine si une ou les deux expressions sont
vraies.

(Syntaxe JavaScript seulement) Détermine si une ou les deux
expressions sont vraies.

(Lingo seulement) Inverse une expression 5

(JavaScript seulement) Inverse une expression 5

4

4

4

L’opérateur

TRUE ou FALSE à la valeur opposée. Par exemple, l’instruction suivante active le son s’il est

not (Lingo) ou ! (Syntaxe JavaScript) est utile lorsqu’il s’agit de faire passer la valeur

désactivé, ou le désactive s’il est activé :

--Syntaxe Lingo
_sound.soundEnabled = not (_sound.soundEnabled)

// Syntaxe JavaScript
_sound.soundEnabled = !(_sound.soundEnabled);

30 Chapitre 2 : Principes de base du scripting dans Director