Accueil > Présentation
AppleScript est un langage de scripting permettant d'automatiser une série de tâches sur votre ordinateur, de contrôler directement des applications. Au lieu d'utiliser la souris, le clavier ou un autre dispositif pour manipuler les menus, boutons ou autres, vous pouvez créer un jeu d'instructions - appelé Scripts - pour automatiser les tâches répétitives, personnaliser les applications.
Un de ces points forts est sa capacité à envoyer des commandes aux objets de différentes application, y compris le Finder ou certains composants du logiciel système, comme un tableau de bord.
Vous pouvez contrôler plusieurs applications, locales ou distantes, ou les deux, dans un seul script. Un script peut envoyer des instructions à une application, recevoir en retour des données, puis les transférer à une ou plusieurs applications différentes de la première. Par exemple, un script peut collecter des données dans une base de données puis les copier dans un tableur.
Dans le même ordre d'idée, un script peut utiliser une application pour exécuter une action sur les données d'une autre application. Par exemple, supposons qu'un traitement de texte comporte un correcteur orthographique et intègre une commande AppleScript dédiée à cette tâche, comme Check Spelling dans l'application AppleWorks. Vous pouvez alors utiliser cette commande AppleScript dans un script pour vérifier l'orthographe d'un bloc de texte d'une application dépourvue de correction orthographique.
Une application pilotable est une application pouvant répondre à une ou plusieurs commandes AppleScript. Toutes les applications ne sont pas pilotables et certaines ne supportent qu'un nombre limité de commandes AppleScript, comme Open ou Quit. Pour déterminer si une application est pilotable ou non, vous pouvez essayer de lire son dictionnaire avec l'application Éditeur de Scripts. L'application Éditeur de Scripts est fournie d'office avec Mac OS, elle permet la création, la compilation, le test et la modification de scripts. Pour ouvrir le dictionnaire d'une application, soit vous déposez son icone sur celle de l'application Éditeur de Scripts, soit vous l'ouvrez depuis le menu "ouvrir un dictionnaire" du menu "Fichier" de l'application Éditeur de Scripts.
Certaines applications pilotables sont aussi mémorisables, c'est à dire que vous pouvez utiliser Éditeur de Scripts pour enregistrer les actions exécutées dans l'application, comme avec les macros.
Pour finir, certaines applications sont aussi attachables. Une application attachable est une application pouvant être personnalisée en attachant des scripts aux objets spécifiques de cette application, comme des boutons ou des menus. Les scripts sont alors déclenchés par une action de l'utilisateur, comme en choisissant le menu ou en cliquant le bouton associé au script. Pour déterminer si une application est attachable ou non, se référer à sa documentation.
AppleScript travaille par l'envoi de messages, appelés Apple Events, aux applications. Lorsque vous écrivez un script, vous écrivez un ou plusieurs groupes d'instructions. Lors de l'exécution du script, les instructions sont envoyées à l'extension AppleScript, laquelle les interprète et envoie alors des Apple Events à ou aux applications concernées. L'application visée répond alors aux Apple Events en exécutant les actions demandées, comme insérer un texte, extraire une valeur ou ouvrir un document. Les applications peuvent aussi, lorsqu'un résultat est attendu par le script, retourner des Apple Events à l'extension AppleScript pour signaler ce résultat, l'extension enverra alors le résultat obtenu au script.
Les instructions sont le fondement des scripts, lorsque vous écrivez un script, vous composez un texte qui décrit les actions devant être exécutées. AppleScript fournit plusieurs types particuliers d'instructions, comme par exemple les instructions conditionnelles (If...Then...Else), de répétition (Repeat), permettant de contrôler quand et comment les instructions sont exécutées. Ce type d'instruction est appelé instruction de contrôle.
Toutes les instructions, y compris les instructions de contrôle, sont soit des instructions simples, soit des instruction composées ou bloc.
Une instruction simple est une instruction écrite sur une seule ligne, comme dans l'exemple suivant :
tell application "Finder" to close front window
Une instruction composée est une instruction écrite sur plusieurs lignes pouvant contenir d'autres instructions composées. Une instruction composée peut contenir un nombre illimité d'instructions et la dernière ligne commence toujours par le mot end (suivi facultativement par le nom de l'instruction composée). L'instruction composée suivante est équivalente à l'instruction simple montrée précédemment :
tell application "Finder" close the front window end tell
Le bloc Tell inclut les lignes tell application "Finder" et end tell, ainsi que les instructions simples entre ces deux lignes.
Par exemple, ci-dessous, un bloc Tell contenant deux instructions :
tell application "Finder" set windowName to name of front window close front window end tell
Cet exemple montre l'avantage d'utiliser une instruction composée : vous pouvez rajouter des instructions à l'intérieur de celle-ci.
Notez que l'exemple précédent contient l'instruction close front window au lieu de close the front window. AppleScript autorise l'ajout ou la suppression du terme the n'importe où dans un script sans modifier les actions recherchées. Le terme the sert simplement à rapprocher la rédaction des instructions du langage courant, facilitant ainsi la lecture et la compréhension.
Toutefois, attention, certaines commandes contiennent dans leur orthographe le terme the et celui-ci dans ce cas est obligatoire. Par exemple, les commandes The Clipboard ou Set The Clipboard To contiennent le terme the.
Voici un autre exemple d'instruction composée :
if the name of the front window is "Loulou" then close front window end if
Les instructions contenues dans une instruction composée peuvent elles-mêmes être des instructions composées, comme dans l'exemple suivant :
tell application "Finder"
if the name of the front window is "Loulou" then
close front window
end if
end tell
Les commandes sont des termes ou des phrases utilisées dans les instructions AppleScript pour demander des actions ou des résultats. Chaque commande est adressée à une cible, laquelle est l'objet répondant à la commande. La cible d'une commande est généralement un objet d'application. Les objets d'application sont des objets appartenant à une application, comme une fenêtre, ou des objets d'un document, comme les mots ou les paragraphes dans un fichier texte. Les commandes peuvent aussi être adressées à des objets système, objets spécifiques appartenant au système Mac OS, comme un service d'impression ou un thème du tableau de bord Apparence.
Un objet est un élément, comme un fichier ou un dossier pour le Finder, un mot ou un paragraphe dans un traitement de texte, pouvant répondre aux commandes conformément aux actions exécutées. AppleScript détermine dynamiquement - c'est à dire chaque fois que nécessaire - les objets et les commandes reconnus par une application, en se basant sur les informations stockées dans chaque application pilotable.
Les scripts-objets sont des objets définis et utilisés dans les scripts. Comme les objets d'application, les scripts-objets répondent aux commandes et contiennent des informations spécifiques associées. Seule différence avec les objets d'application, les scripts-objets sont définis dans les scripts.
Les scripts-objets sont une caractéristique avancée d'AppleScript. Ils permettent d'utiliser les techniques de programmation orientée-objet (POO) pour définir de nouveaux objets ou commandes. Les informations contenues dans les scripts-objets peuvent être sauvegardées et utilisées par d'autres scripts.
Chaque objet a des informations spécifiques associées à lui et il peut répondre à des commandes spécifiques. Par exemple, dans le Finder, un objet fenêtre supporte la commande Close.
L'exemple suivant montre comment utiliser la commande Close pour demander au Finder de fermer la fenêtre à l'avant-plan :
tell application "Finder" close the front window end tell
La commande Close est insérée dans un bloc Tell. Un bloc Tell sert à spécifier les cibles par défaut des commandes qu'il contient. La cible par défaut est l'objet qui reçoit les commandes si aucun objet n'est spécifié ou si l'objet est spécifié incomplètement dans la commande. Dans l'exemple précédent, l'instruction Close précise bien qu'elle vise un objet fenêtre mais sans préciser l'application visée, aussi AppleScript utilise le nom de l'application indiquée dans l'instruction Tell pour déterminer la bonne fenêtre devant recevoir la commande Close.
Dans le langage AppleScript, vous utiliserez des références pour spécifier les objets. Une référence est un nom composé, similaire à un nom de rue ou à une adresse, spécifiant un objet. Par exemple, la phrase suivante est une référence :
front window of application "Finder" -- résultat : la fenêtre du Finder en avant-plan
Cette phrase indique un objet fenêtre appartenant à l'application Finder. L'application elle-même est aussi un objet. AppleScript supporte différents types de référence permettant de spécifier un même objet de plusieurs manières.
Les objets peuvent contenir d'autres objets, appelés éléments. Dans l'exemple précédent, la fenêtre en avant-plan est un élément de l'objet application Finder. De même, dans l'exemple suivant, un élément fichier est contenu dans un élément dossier, lequel est contenu dans un élément disque :
file 1 of folder 1 of startup disk
Chaque objet appartient une classe d'objet, laquelle est simplement une étiquette pour des objets ayant des caractéristiques identiques. Parmi les caractéristiques, qui sont les mêmes pour les objets d'une classe, se trouvent les commandes pouvant agir sur les objets et les éléments qu'ils peuvent contenir.
Pour examiner la définition d'une classe d'objet, d'une commande, ou les termes supportés par une application, vous pouvez ouvrir son dictionnaire avec l'application Éditeur de Scripts. Pour pouvoir utiliser les termes du dictionnaire d'une application dans un script, vous devez la nommer, par exemple en spécifiant l'application en question dans un bloc Tell :
tell application "Finder" clean up the front window end tell
Lorsqu'il rencontre une instruction Tell Application, AppleScript lit les termes du dictionnaire de l'application spécifiée et les utilise pour interpréter les instructions contenues dans ce bloc Tell. Par exemple, AppleScript utilise les termes du dictionnaire du Finder pour interpréter la commande Clean Up dans l'exemple précédent.
Lorsque vous utilisez une instruction Tell ou que vous spécifiez un nom d'application dans ce bloc, l'extension AppleScript obtient la ressource dictionnaire de cette application et peut alors lire ses commandes, objets et autres termes. Chaque application pilotable a une ressource dictionnaire (de type 'aete') définissant les commandes, objets et autres termes utilisables dans les scripts pour contrôler ces applications.
En plus des termes définis dans les dictionnaires des applications, AppleScript dispose de son propre dictionnaire. À la différence des termes contenus dans les dictionnaires des applications, les termes du dictionnaire de l'extension AppleScript sont utilisables à tout moment, vous pouvez utiliser ces termes (comme If, Tell, etc...) n'importe où dans un script.
Les termes définis dans les dictionnaires sont appelés des mots réservés. Lorsque vous définissez des mots nouveaux dans vos scripts - comme des identificateurs pour les variables - vous ne pouvez pas utiliser ces mots réservés.
En plus de manipuler les objets des autres applications, AppleScript peut stocker et manipuler ses propres données, appelées valeurs. Une valeur est une donnée structurée pouvant être représentée, stockée et manipulée dans AppleScript.
Une valeur peut être stockée soit dans une propriété, soit dans une variable. AppleScript reconnaît plusieurs types de valeurs, comme les chaînes de caractères, les nombres entiers, les listes ou les dates. Les valeurs sont fondamentalement différentes des objets d'application, lesquels peuvent également être manipulés dans AppleScript mais sont contenus dans les applications ou leurs documents. Les valeurs peuvent être créées dans les scripts ou résultées des commandes envoyées aux applications.
Les valeurs facilitent grandement les échanges de données dans AppleScript. Lorsque vous demandez des informations sur un objet d'une application, comme par exemple une propriété, elles sont en général retournées sous forme de valeurs.
AppleScript reconnaît un nombre limité de types de valeurs. Vous ne pouvez pas définir un ou des types de valeurs supplémentaires, ni modifier la manière de les représenter. Les différents types de valeurs AppleScript sont appelés classes de valeur.
Une constante est un mot réservé avec une valeur prédéfinie. AppleScript fournit des constantes facilitant ainsi certaines tâches, comme lors des comparaisons ou des opérations arithmétiques.
Une expression est une série de termes AppleScript correspondant à une valeur. Les expressions sont utilisées dans les scripts pour identifier ou donner des valeurs. Lorsque vous exécutez un script, AppleScript convertit les expressions en valeurs, ce procédé est appelé évaluation.
Les opérations et les variables sont deux types courants d'expressions. Une opération est une expression qui donne une nouvelle valeur à partir d'une ou de deux autres valeurs. Une variable est un contenant nominatif dans lequel une valeur est stockée.
Vous trouverez ci-dessous des exemples d'opérations AppleScript et leurs valeurs respectives. La valeur de chaque opération est indiquée dans le commentaire (--).
3 + 4 -- résultat : 7
(12 > 4) -- résultat : true
(12 > 4) and (12 = 4) -- résultat : false
Chaque opération contient un opérateur. Le signe plus (+) dans la première expression, ainsi que les symboles supérieur à (>), égal à (=) et le mot and dans la troisième expression sont des opérateurs. Les opérateurs transforment des valeurs ou des paires de valeurs en d'autres valeurs. Les opérateurs qui agissent sur deux valeurs sont appelés des opérateurs binaires. Les opérateurs qui agissent sur une seule valeur sont appelés des opérateurs unitaires. Vous pouvez utiliser des opérations à l'intérieur des instructions AppleScript, comme dans cet exemple :
tell application "Finder" open folder (3 + 2) of startup disk end tell
Lorsque vous exécutez ce script, AppleScript évalue d'abord l'expression (3 + 2) puis utilise ce résultat pour indiquer au Finder quel dossier doit être ouvert.
Lorsqu'AppleScript rencontre une variable dans un script, il l'évalue en obtenant sa valeur. Pour créer une variable, il suffit de lui assigner une valeur :
copy "Nicolas" to monPrenom
La commande Copy prend la valeur - la chaîne de caractères "Nicolas" - et la met dans la variable monPrenom. Vous pouvez faire la même chose avec la commande Set :
set monPrenom to "Nicolas"
Les instructions qui assignent des valeurs aux variables sont appelées des instructions d'assignation.
Vous pouvez obtenir la valeur d'une variable grâce à la commande Get ou simplement en spécifiant son nom.
set monPrenom to "Nicolas" get monPrenom -- résultat : "Nicolas" monPrenom -- résultat : "Nicolas"
Vous pouvez modifier la valeur d'une variable en lui assignant une nouvelle valeur, mais attention car cette nouvelle valeur viendra écraser l'ancienne valeur sans possibilité de revenir en arrière. De plus, une variable ne peut contenir qu'une valeur à la fois. AppleScript étant un langage de programmation à typage faible, vous pourrez sans problème modifier le type de valeur contenue dans la variable, par exemple vous pourrez, dans un même script, y stocker indifféremment une chaîne de caractères (string), puis un nombre entier (integer), une référence de dossier, une date, etc... Les variables peuvent contenir n'importe quel type de valeurs au cours d'un script, la limite ne portant que sur le nombre, une à la fois.
set monPrenom to "Nicolas" set monPrenom to 12 get monPrenom -- résultat : 12
Vous avez aussi la possibilité d'étendre les capacités d'AppleScript, grâce notamment aux compléments de pilotage ou OSAX. Les compléments de pilotage sont des fichiers qui fournissent des commandes ou des coercitions supplémentaires au langage AppleScript, de la même manière qu'un plug-in. Ils sont utilisables partout dans un script. Pour qu'AppleScript puisse accéder à un complément de pilotage, celui-ci doit être mis, sous Mac OS 9, dans le dossier "Compléments de pilotage" du dossier système et, sous Mac OS X, dans le dossier "ScriptingAdditions" de votre librairie ou de la librairie générale. Si le dossier "ScriptingAdditions" n'existe pas, il suffit de le créer, c'est aussi simple.
Un seul fichier complément de pilotage peut contenir une ou plusieurs commandes ou coercitions, ou les deux. Le complément standard distribué avec AppleScript comporte, par exemple, des commandes pour interagir avec le presse-papier ou résumer des textes.
À la différence des autres commandes utilisées dans AppleScript, les compléments de pilotage travaillent de la même façon quelle que soit la cible indiquée. Par exemple, la commande Beep, qui fait partie du complément standard, déclenche une alerte sonore quelle que soit l'application recevant cette commande.
Vous trouverez sur le site web <www.osaxen.com> des centaines de compléments de pilotage librement téléchargeables, la plupart étant en freeware.
Une coercition est un procédé qui transforme la classe d'une valeur en une autre classe, comme un nombre entier convertit en nombre réel ou en chaînes de caractères. La plupart des coercitions peuvent voir leur effet inversé, la valeur de départ n'est pas modifiée par les transformations successives, mais certaines coercitions sont irréversibles, comme transformer une liste en chaîne de caractères (list -> string), faire l'inverse (string -> list) ne donnera pas la valeur de départ.
set maListe to {"il pleut", 3, "gouttes"}
set maChaine to maListe as string
-- résultat : "il pleut3gouttes"
maChaine as list
-- résultat : {"il pleut3gouttes"}
Les paragraphes suivants traiteront des règles de syntaxe à respecter pendant l'écriture des scripts.
Une instruction simple doit normalement être écrite sur une seule ligne. Si une instruction est trop longue pour tenir sur une seule ligne, vous pouvez la prolonger en insérant un caractère de continuation (¬) à la fin de la première ligne, ainsi vous pourrez écrire sur la ligne suivante et AppleScript saura que l'instruction est en fait écrite sur plusieurs lignes.
Vous pouvez taper ce caractère dans la plupart des traitements de texte en appuyant simultanément sur les touches Option + L. Dans l'Éditeur de Scripts, vous devez appuyer sur les touches Option + Entrée, le caractère de continuation sera alors inséré dans le texte et le point d'insertion sera automatiquement positionné sur la ligne suivante. Plusieurs lignes séparées par le caractère de continuation seront considérées comme une seule ligne lors de l'exécution du script.
L'instruction suivante :
open the second file of the first folder of the startup disk
peut être écrite sur deux lignes, comme ceci :
open the second file of the first folder ¬ of the startup disk
Le caractère de continuation n'est pas une obligation de syntaxe, c'est simplement un mécanisme permettant d'écrire une instruction sur plusieurs lignes sans qu'AppleScript n'y voie une erreur de syntaxe.
Le seul endroit où un caractère de continuation ne fonctionne pas de cette manière, est à l'intérieur d'une chaîne de caractères (string), il est alors considéré comme du texte :
"caractère de ¬ continuation" -- résultat : "caractère de ¬ continuation"
Pour utiliser une très longue chaîne de caractères, vous pouvez soit tout faire tenir sur une seule ligne en ne mettant un retour-chariot qu'à la fin, soit vous pouvez répartir la chaîne sur plusieurs lignes en utilisant l'opérateur de concaténation (&) pour les joindre, comme dans l'exemple suivant :
open the second file of the first folder of disk "Disque " ¬ & "Dur"
Vous avez la possibilité dans votre code AppleScript d'ajouter des commentaires. Les commentaires servent principalement à expliquer le fonctionnement d'un script, facilitant par la suite la maintenance de ceux-ci. Un commentaire est un texte qui reste après compilation présent dans le code mais qui est ignoré par AppleScript lors de l'exécution. Il existe deux sortes de commentaires : le commentaire de fin de ligne et les blocs de commentaires.
Un bloc de commentaires est délimité par des balises, la balise ouvrante est (*, la balise fermante est *), tout le texte situé entre ces deux balises est considéré comme du commentaire. Un bloc de commentaires doit être situé entre des instructions, non sur les mêmes lignes que celles-ci, et il ne peut pas être inséré dans une instruction simple.
Un commentaire de fin de ligne est simplement délimité par une balise ouvrante, deux tirets (--) marquent le début d'une ligne de commentaires, aucun caractère particulier n'est requis pour indiquer la fin de celle-ci, à part un saut de ligne. Un commentaire de fin de ligne ne peut pas couvrir plusieurs lignes, il doit tenir une seule ligne. Un bloc de commentaires peut couvrir plusieurs lignes mais il ne peut pas partager ses lignes avec des lignes de codes sinon le code sera considéré comme du commentaire.
Vous pouvez imbriquer des commentaires les uns dans les autres, c'est à dire que les commentaires peuvent contenir d'autres commentaires.
Voici quelques exemples :
-- un commentaire de fin de ligne
(* utiliser les blocs de commentaires pour les commentaires devant s'étaler sur plusieurs lignes*)
copy result to Res -- stocke le résultat dans la variable Res
(* la routine suivante, findString, cherche une chaîne de caractères dans une liste de documents AppleWorks *)
(* voici un exemple de -- commentaire imbriqué (* un autre commentaire à l'intérieur d'un commentaire *) *)
L'exemple de bloc de commentaires qui suit provoque une erreur car le commentaire est inséré dans une instruction.
-- le bloc de commentaires suivant est invalide tell application "Finder" get (* name of *) file 1 of startup disk end tell
Comme les commentaires ne sont pas exécutés, vous pouvez utiliser cette particularité pour désactiver rapidement une partie de votre code le temps de faire des tests, pour réactiver ce code, il vous suffira de supprimer les balises de commentaires. Cette désactivation temporaire est particulièrement utilisée lors des phases de débuggage du code.
(* on verification() -- en construction end *)
Un identificateur est une série de caractères qui définit une valeur ou un autre élément du langage. Par exemple, les noms des variables sont des identificateurs. L'exemple suivant règle la valeur de la variable myName avec "Fred".
set myName to "Fred"
Les identificateurs sont aussi utilisés comme étiquettes dans les propriétés et les structures.
Un identificateur a toujours comme premier caractère une lettre de l'alphabet, il peut contenir des majuscules (A-Z), des minuscules (a-z), des chiffres (0-9) et le caractère de soulignement (_), les caractères accentués, comme é,è,ê, ne sont pas supportés.
Quelques identificateurs valides :
Yes Agent99 iTunes_Music_Store
Par contre, ceux qui suivent sont invalides :
C-- Back&Forth 999 why^Not
Lorsque les identificateurs sont encadrés par des barres verticales (|), ils peuvent alors contenir n'importe quels caractères. Les exemples précédents sont maintenant valides :
|C--| |Back&Forth| |999| |why^Not|
Les identificateurs encadrés par des barres verticales (|) peuvent également contenir des barres verticales supplémentaires seulement si elles sont échappées par le caractère anti-slash (\), comme dans l'exemple suivant :
|Pile \|ou\| Face|
Le caractère anti-slash permet d'échapper des caractères normalement réservés au langage AppleScript, comme les guillemets (") :
"il \"pleut\" des cordes"
Un caractère anti-slash peut également être utilisé dans un identificateur si celui-ci est encadré par des barres verticales et si ce caractère réservé est lui-même échappé comme dans cet exemple :
|/\\Haut\\/Bas|
Les identificateurs ne peuvent pas être orthographiés comme un mot réservé - c'est à dire, qu'ils ne peuvent pas s'écrire comme les termes du langage AppleScript ou du dictionnaire de l'application désignée dans l'instruction Tell. Par exemple, vous ne pouvez pas créer une variable dont l'identificateur sera file à l'intérieur d'une instruction Tell Finder, car file est déjà une classe d'objet répertorié dans le dictionnaire du Finder. Dans ce cas, AppleScript retournera une erreur de syntaxe.
AppleScript n'est pas sensible à la casse ; lorsqu'il interprète des instructions, il ne fait pas de distinctions entre les majuscules et les minuscules, cette particularité est valable pour l'ensemble des éléments du langage.
La seule exception concerne les comparaisons de chaînes de caractères. Normalement, AppleScript ne distingue pas les majuscules des minuscules lors de la comparaison des chaînes de caractères, mais vous pouvez forcer AppleScript à le faire en utilisant une instruction spéciale, une instruction Considering.
Souvent les identificateurs sont des associations de plusieurs termes du langage courant, on utilise alors des majuscules pour marquer les différents termes les composant, par exemple monNom.
set monNom to "Loulou"
Après avoir créé la variable monNom, vous pouvez vous y référer par la suite avec ces différentes orthographes :
MONNOM monnom MonnoM mOnnOm
Toutefois, lorsque vous compilerez pour la première fois un script comportant un nom de variables écrit de différentes manières, AppleScript n'utilisera que la première orthographe rencontrée tout au long du script, les orthographes suivantes sont ignorées et corrigées de manière à s'écrire comme la première orthographe rencontrée.
Si vous voulez en apprendre plus, vous trouverez dans les autres pages de ce site la traduction française de la documentation officielle sur ce langage, ainsi que sur AppleScript Studio. Vous trouverez également sur le site de <MacFr.com> un didacticiel sur AppleScript : <AppleScript de A à Z> de Didier Durandet.
Accueil | Présentation | AppleScript | AppleScript Studio | Atelier | Liens
Les marques ou logos cités appartiennent à leurs propriétaires respectifs.
Page valide XHTML 1 Strict et CSS1.
Site trad.applescript V 2.0 © nicolas Descombes 2004 - Fait par ma pomme (moi).
