Introduction au shell JavaScript

par 4 contributeurs :

Cet article sert d'introduction à l'obtention et à la compilation du shell JavaScript depuis le serveur CVS de Mozilla, en se concentrant particulièrement sur les versions de développement (prerelease) pour des tests ou expérimentations.

En outre, cet article fournit des informations de base sur l'utilisation du shell pour faire des expériences avec du code JavaScript et pour exécuter des programmes JavaScript.

Récupérer et compiler l'interpréteur JavaScript

Note : Vous devez récupérer entièrement le code source de l'interpréteur JavaScript même si vous avez déjà une copie de travail d'un autre projet Mozilla, car certains fichiers sont spécifiques à l'interpréteur et ne se trouvent donc pas dans l'arborescence des fichiers source Mozilla.

Connexion au serveur CVS

Comme lorsque vous souhaitez récupérer les sources d'un autre projet Mozilla depuis CVS, vous devez d'abord vous authentifier auprès du serveur CVS. Pour cela, placez vous en ligne de commande dans le répertoire où vous souhaitez que les fichiers soient récupérés, puis saisissez la commande suivante dans votre terminal :

cvs -d :pserver:anonymous@cvs-mirror.mozilla.org:/cvsroot login

Lorsqu'il vous est demandé, saisissez le mot de passe anonymous.

Compilation de la version courante « trunk » de JavaScript

Une fois authentifié auprès du serveur, il faut récupérer le code source depuis le dépôt CVS. Premièrement, vous devez aller dans le répertoire racine de votre copie de travail CVS, ensuite vous devez saisir la commande suivante :

cvs -d :pserver:anonymous@cvs-mirror.mozilla.org:/cvsroot co -l mozilla/js/src mozilla/js/src/config mozilla/js/src/editline mozilla/js/src/fdlibm

Cette commande récupèrera tous les fichiers nécessaires à la compilation de l'interpréteur JavaScript.

Maintenant vous pouvez démarrer la compilation de JavaScript en saisissant les deux commandes suivantes :

cd mozilla/js/src
make -f Makefile.ref

Une fois la compilation terminée, vous devriez avoir un exécutable nommé <tt>js</tt> dans un répertoire dont le nom est dépendant du système d'exploitation utilisé pour la compilation. Par exemple, sur mac OS X, l'exécutable se situe dans <tt>Darwin_DBG.OBJ/js</tt>.

À partir de maintenant, vous êtes prêt à exécuter et tester l'interpréteur.

Compilation d'une version spécifique « branch » de JavaScript

Si vous voulez tester une version particulière de JavaScript, vous pouvez le faire facilement en ajoutant -r nom_de_la_branche à la ligne de commande qui permet la récupération des fichiers sur le serveur CVS.

Suivez les mêmes étapes que précédemment, mais lors de la récupération des fichiers, changez la ligne <tt>cvs co...</tt> par :

cvs -d :pserver:anonymous@cvs-mirror.mozilla.org:/cvsroot co -l -r nom_de_la_branche mozilla/js/src mozilla/js/src/config mozilla/js/src/editline mozilla/js/src/fdlibm

Remplacez nom_de_la_branche par le nom de la branche que vous voulez récupérer. Par exemple, pour récupérer la branche 1.7 alpha de JavaScript, Vous devez utiliser <tt>JS_1_7_ALPHA_BRANCH</tt>.

Ensuite, vous pouvez compiler et exécuter l'interpréteur comme précédemment.

Utilisation de l'interpréteur JavaScript

L'interpréteur propose deux modes de fonctionnement. Vous pouvez l'utiliser comme un interpréteur interactif, dans lequel vous saisissez le code JavaScript dans une invite de commandes et obtenez directement le résultat. Ce qui est très pratique pour tester et expérimenter de nouvelles fonctionnalités. Vous pouvez aussi donner, avec la ligne de commande, un fichier JavaScript à exécuter. Dans ce cas, le programme sera exécuté automatiquement.

Note : étant donné que l'interpréteur JavaScript est utilisé comme environnement de test pour le moteur JavaScript, les options disponibles et les fonctions intégrées peuvent changer avec le temps.

Options de la ligne de commandes

Il y a un bon nombre d'options de ligne de commande que vous pouvez spécifier pour contrôler l'interpréteur. Elles sont résumées ci-dessous.

-b nombre de branchements
Définition du nombre de branchements maximum.
-c taille d'un bloc de la pile
Définition de la taille d'un bloc de la pile.
-C
Demande à l'interpréteur de compiler le programme mais de ne pas l'exécuter. C'est une méthode pratique pour vérifier rapidement la présence d'erreurs de syntaxe dans votre programme sans avoir besoin de l'exécuter.
-e script
Exécute le <var>script</var> spécifié, qui est une chaîne de caractères littérale contant le code source à exécuter.
-f chemin_du_fichier
Exécute le programme JavaScript spécifié par le <var>chemin_du_fichier</var>.
-i
Active le mode interactif.
-P
Je ne suis pas encore certain du fonctionnement de cette option.
-s
Active le mode d'avertissement strict.
-S taille de la pile
Définition de la taille maximale de la pile.
-v version
Force la version de JavaScript à la version spécifiée par <var>version</var> (ex : 170 pour JavaScript 1.7).
-w
Active les messages d'avertissement.
-W
Désactive les messages d'avertissement.
-x
Active le mode XML E4X.

Utilisation de l'interpréteur

Si vous voulez exécuter l'interpréteur en mode interactif, vous pouvez utiliser simplement la commande:

js

Si vous voulez exécuter le code JavaScript contenu dans le fichier <tt>foo.js</tt>, vous pouvez utiliser cette commande :

js -f foo.js

Pour exécuter <tt>foo.js</tt> puis passer l'interpréteur en mode interactif, faites ceci :

js -f foo.js -f -
Utilisation de l'interpréteur en mode interactif

En mode interactif, vous pouvez saisir du code JavaScript à la main pour créer des objets et des fonctions, mais aussi des tests conditionnels. Cet un moyen pratique pour tester vos idées et, plus important pour les développeurs du moteur JavaScript, de tester les nouvelles fonctionnalités du langage.

Fonctions intégrées

Pour proposer un interpréteur JavaScript le plus utile possible, il y a des fonctions intégrées qui vous sont proposées et que vous pouvez utiliser à partir de vos programmes JavaScript ou en mode interactif.

build()

Renvoie la date et l'heure de compilation de l'interpréteur JavaScript.

clear([object])

Efface les propriétés de l'<var>objet</var> spécifié. Appeler clear() sans paramètres efface tout, ainsi vous pouvez démarrer dans un état connu.

Note : clear() sans paramètre nettoie vraiment tout. Cela inclut toutes les fonctions intégrées.
clone(fonction, [portée])

Duplique l'objet <var>fonction</var> spécifié. Si la variable <var>portée</var> n'est pas spécifiée, le parent du nouvel objet est le même que l'objet original. Autrement, le nouvel objet est placé dans la même portée que l'objet spécifié par <var>portée</var>.

dis([fonction])

Désassemble le code binaire JavaScript pour le programme entier, ou pour la <var>fonction</var> spécifiée.

Par exemple, si vous saisissez la fonction JavaScript suivante :

function test() {
  var i = 3;
  print(i+2);
}

Puis exécutez la commande dis(test);, vous aurez la sortie suivante :

main:
00000:  uint16 3
00003:  setvar 0
00006:  pop
00007:  name "print"
00010:  pushobj
00011:  getvar 0
00014:  uint16 2
00017:  add
00018:  call 1
00021:  pop
00022:  stop

Source notes:
  0:     0 [   0] newline 
  1:     3 [   3] decl     offset 0
  2:     7 [   4] newline 
  3:    18 [  11] xdelta  
  4:    18 [   0] pcbase   offset 11
dissrc([fonction])

Désassemble le code binaire JavaScript du programme complet, ou de la <var>fonction</var> spécifiée, en affichant le code source. Cette fonction fonctionne seulement avec des programmes exécutés à partir de fichiers, aussi bien en utilisant le commutateur -t au lancement de l'interpréteur qu'en utilisant la fonction load().

Si votre programme contient une fonction, unTraitement(), comme ceci :

function unTraitement(entrée) {
	print("Entrez un nombre : ");
	var n1 = readline();
	print("Entrez en autre : ");
	var n2 = readline();
	
	print("Vous avez entré " + n1 + " et " + n2 + "\n");
}

l'appel suivant dissrc(unTraitement) devrait donner le résultat suivant :

;-------------------------  10:         print("Entrez un nombre : ");
00000:  10  name "print"
00003:  10  pushobj
00004:  10  string "Entrez un nombre : "
00007:  10  call 1
00010:  10  pop
;-------------------------  11:         var n1 = readline();
00011:  11  name "readline"
00014:  11  pushobj
00015:  11  call 0
00018:  11  setvar 0
00021:  11  pop
;-------------------------  12:         print("Entrez en un autre : ");
00022:  12  name "print"
00025:  12  pushobj
00026:  12  string "Entrez en un autre : "
00029:  12  call 1
00032:  12  pop
;-------------------------  13:         var n2 = readline();
00033:  13  name "readline"
00036:  13  pushobj
00037:  13  call 0
00040:  13  setvar 1
00043:  13  pop
;-------------------------  14: 
;-------------------------  15:         print("Vous avez entré " + n1 + " et " + n2 + "\n");
00044:  15  name "print"
00047:  15  pushobj
00048:  15  string "Vous avez entré "
00051:  15  getvar 0
00054:  15  add
00055:  15  string " et "
00058:  15  add
00059:  15  getvar 1
00062:  15  add
00063:  15  string "\\n"
00066:  15  add
00067:  15  call 1
00070:  15  pop
00071:  15  stop
evalcx(chaine[, objet])

Évalue le code JavaScript contenu dans <var>chaîne</var>. Si <var>objet</var> est spécifié, le code est exécuté dans cet objet, en le considérant comme un bac à sable.

Si <var>chaîne</var> est vide et que '<var>objet</var> n'est pas spécifié, evalcx() renvoie un nouvel objet contenant les classes standard.

Note : evalcx() est utile seulement pour les personnes réalisant un travail en profondeur dans le moteur JavaScript, pour tester des environnements comme evalInSandbox dans l'interpréteur.
gc()

Lance le ramasse-miettes (garbage collector) pour nettoyer la mémoire des objets inutiles.

getpda(objet)

Renvoie les descripteurs de propriétés pour l'<var>objet</var> spécifié.

getslx(objet)

Renvoie l'étendue de l'<var>objet</var> en nombre de lignes de script, qui correspond au nombre de lignes de code source où l'on peut trouver l'<var>objet</var> spécifié en paramètre.

help([commande ...])

Affiche une information concise à propos de la commande spécifiée, ou à propos de toutes les fonctions disponibles si aucune n'est spécifiée.

intern(chaîne)

Intègre la <var>chaîne</var> spécifiée dans la table des atomes. Chaque chaîne de caractères possède un identifiant unique, appelé atome. Ce système permet de faciliter la comparaison entre chaînes de caractères.

Note : Cette fonction est prévue pour être utilisée seulement lors des tests du moteur JavaScript.
line2pc([fonction, ] ligne)

Renvoie la valeur du pointeur d'instruction pour la <var>ligne</var> de code spécifiée. Si <var>fonction</var> est spécifiée, <var>ligne</var> est un offset dans la fonction spécifiée.

load(chemin [chemin])

Charge les fichiers spécifiés en paramètre.

notes([fonction])

Affiche les commentaires de code source pour la fonction spécifiée. Les commentaires contiennent des informations qui permettent de relier le code binaire avec le code source. Cette fonction est utilisée pour décompiler le code, comme lorsque la fonction dissrc() est utilisée.

options([option ...])

Permet de définir ou de récupérer des options. Si vous spécifiez des options en ligne de commandes, les résultats de l'appel des options indiquera celles que vous avez demandées. Il est également possible de passer de nouvelles options à définir.

Si vous lancez l'interpréteur avec la commande <tt>js -x</tt>, alors la fonction options() retournera <tt>xml</tt>. Si vous lancez l'interpréteur sans option et que vous voulez activer le mode XML, vous pouvez le faire en utilisant la commande :

options('xml');

Les options disponibles sont :

Nom de l'option Description
strict Mode strict activé.
werror Les avertissements seront traités comme des erreurs.
atline Lorsque atline est activée, les commentaires de la forme //@line num définissent le nombre de lignes suivantes à <var>num</var>.
xml Mode XML activé.
pc2line(function, [pc])

Renvoie le nombre de lignes du code JavaScript code qui correspondent à la première ligne de la <var>fonction</var> spécifiée. Si vous spécifiez un décalage du compteur du programme dans la fonction, le nombre de ligne de code contenant cet offset sera renvoyé.

print([expression ...])

Évalue l'<var>expression</var> et affiche le résultat sur la sortie standard <tt>stdout</tt>.

quit()

Quitte l'interpréteur.

readline()

Lit une ligne de texte à partir de l'entrée standard <tt>stdin</tt>, et la renvoie à l'appelant. Vous pouvez utiliser cette fonction pour créer des programmes interactifs en JavaScript.

seal(objet[, profond])

Scelle l'objet spécifié, ou une arborescence d'objets si profond est à true. En scellant un objet ou arborescence d'objet, vous désactivez la modification de ces objets.

stats([chaîne ...])

Vide les statistiques. Les options valide sont <var>arena</var>, <var>atom</var> et <var>global</var>.

Option Description
arena Affiche la table <var>arena</var>.
atom Affiche la table <var>atom</var>.
global Affiche la table <var>global</var>.

Un <var>arena</var> est un large bloc mémoire depuis lequel le moteur JavaScript alloue des sous-blocs afin d'optimiser les performances ; l'émission d'un grand nombre d'appels malloc() pour chaque bloc individuel est inefficace, aussi le moteur crée des <var>arenas</var>, puis utilise un système de gestion interne de la mémoire pour allouer la mémoire dans chacun des <var>arenas</var>. La table des <var>arena</var> est une liste de tous les <var>arenas</var> alloués par l'interpréteur. stats("arena") vous permet d'inspecter la table pour que vous puissiez comprendre l'utilisation des <var>arenas</var> par un test.

Un <var>atom</var> est un identifieur unique pour une chaîne. Afin d'optimiser les comparaisons entre chaînes, un atome est attribué à chacune d'entre elles. Ces atomes sont stockés dans la table de hachage, qui peut être affichée par la commande stats("atom").

stats("global") affiche la table globale de noms, qui contient les noms et les informations concernant chaque objet en mémoire.

stringsAreUtf8()

Renvoie true si les chaînes de caractères sont codées au format UTF8 ; dans le cas contraire false est renvoyé.

testUtf8(mode)

Exécute des tests UTF-8. Le paramètre <var>mode</var> peut être un nombre entier de 1 à 4.

C'est une commande de déboguage qui lance simplement certaines vérifications sur les chaînes UTF-8, et qui n'est pas d'utilisation courante, à moins de travailler sur le moteur JavaScript lui-même.

throwError()

Lance une erreur depuis la fonction JS_ReportError().

Note : Cette fonction est prévue pour n'être utilisée que lors de tests du moteur JavaScript.
tracing([toggle])

Active ou désactive le mode de traçage. Passez true pour activer le traçage ou false pour le désactiver. Si aucun paramètre n'est spécifié, tracing() renvoie le paramétrage courant.

Astuce : Ceci ne fonctionne qui si vous compilez JavaScript avec JS_THREADED_INTERP désactivé dans le fichier <tt>jsinterp.c</tt>.
trap([fonction, [pc,]] expression)

Définit une trappe à une endroit spécifique du code JavaScript. Lorsque le code qui se trouve à l'offset spécifié par <var>pc</var> dans la fonction <var>fonction</var> est exécuté, l'<var>expression</var> est évaluée.

C'est un puissant mécanisme de débogage lorsqu'il est utilisé de concert avec line2pc(). Par exemple, si vous voulez afficher un message lorsque la ligne 6 d'une fonction doSomething() est exécutée, vous pouvez utiliser le code suivant :

trap(doSomething, line2pc(test, 6), "print('line 6!\n')");
Note : Lorsqu'une trappe est définie, le code correspondant dans le programme est remplacé par un code trap jusqu'à l'utilisation de untrap() qui supprimera la trappe.
untrap(fonction [, pc])

Supprime une trappe dans la <var>fonction</var> spécifiée à l'offset <var>pc</var>. Si <var>pc</var> n'est pas spécifié, la trappe est enlevée du point d'entrée de la fonction.

Cette fonction n'a aucun effet si aucune trappe n'est définie à la position spécifiée.

version([nombre])

La fonction version() vous permet de récupérer ou de spécifier le numéro de version de JavaScript. Cela peut être utile pour avoir accès à des syntaxes spécifiquement disponibles pour certaines versions de JavaScript (par exemple, voir Utilisation de JavaScript 1.7).

Interwiki Language Links

Étiquettes et contributeurs liés au document

Étiquettes : 
Contributeurs à cette page : BenoitL, Fredchat, Emeric, Mgjbot
Dernière mise à jour par : BenoitL,