Introduction au shell JavaScript

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

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:[email protected]:/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:[email protected]:/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é js 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 Darwin_DBG.OBJ/js.

À 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 cvs co... par :

cvs -d :pserver:[email protected]:/cvsroot co -l -rnom_de_la_branche mozilla/js/src mozilla/js/src/config mozilla/js/src/editline mozilla/js/src/fdlibm

Remplaceznom_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 JS_1_7_ALPHA_BRANCH.

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.

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.

-bnombre de branchements

Définition du nombre de branchements maximum.

-ctaille 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.

-escript

Exécute le script spécifié, qui est une chaîne de caractères littérale contant le code source à exécuter.

-fchemin_du_fichier

Exécute le programme JavaScript spécifié par le chemin_du_fichier.

-i

Active le mode interactif.

-P

Je ne suis pas encore certain du fonctionnement de cette option.

-s

Active le mode d'avertissement strict.

-Staille de la pile

Définition de la taille maximale de la pile.

-vversion

Force la version de JavaScript à la version spécifiée par version (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 foo.js, vous pouvez utiliser cette commande :

js -f foo.js

Pour exécuter foo.js 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'objet spécifié. Appeler clear() sans paramètres efface tout, ainsi vous pouvez démarrer dans un état connu.

clone(fonction, [portée])

Duplique l'objet fonction spécifié. Si la variable portée 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 portée.

dis([fonction])

Désassemble le code binaire JavaScript pour le programme entier, ou pour la fonction 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 fonction 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 chaîne. Si objet est spécifié, le code est exécuté dans cet objet, en le considérant comme un bac à sable.

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

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'objet spécifié.

getslx(objet)

Renvoie l'étendue de l'objet en nombre de lignes de script, qui correspond au nombre de lignes de code source où l'on peut trouver l'objet 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 chaîne 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.

line2pc([fonction, ] ligne)

Renvoie la valeur du pointeur d'instruction pour la ligne de code spécifiée. Si fonction est spécifiée, ligne 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 js -x, alors la fonction options() retournera xml. 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 :

pc2line(function, [pc])

Renvoie le nombre de lignes du code JavaScript code qui correspondent à la première ligne de la fonction 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'expression et affiche le résultat sur la sortie standard stdout.

quit()

Quitte l'interpréteur.

readline()

Lit une ligne de texte à partir de l'entrée standard stdin, 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 siprofond 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 arena, atom et global.

Un arena 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 arenas, puis utilise un système de gestion interne de la mémoire pour allouer la mémoire dans chacun des arenas. La table des arena est une liste de tous les arenas alloués par l'interpréteur. stats("arena") vous permet d'inspecter la table pour que vous puissiez comprendre l'utilisation des arenas par un test.

Un atom 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 mode 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().

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.

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 pc dans la fonction fonction est exécuté, l'expression 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')");

untrap(fonction [, pc])

Supprime une trappe dans la fonction spécifiée à l'offset pc. Si pc 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