Introduction au shell JavaScript

  • Raccourci de la révision : Introduction_au_shell_JavaScript
  • Titre de la révision : Introduction au shell JavaScript
  • ID de la révision : 186078
  • Créé :
  • Créateur : Emeric
  • Version actuelle ? Non
  • Commentaire /* <code>throwError()</code> */

Contenu de la révision

{{template.Traduction_en_cours("Introduction to the JavaScript shell")}}

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

Note: Vous récupérer entièrement le code source de l'interpréteur JavaScript même si vous souhaitez compiler un autre projet Mozilla, vu que certains 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 faire cela, placez vous en ligne de commandes 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

Lorsque demandé, saisissez le mot de passe, <tt>anonymous</tt>.

Compilation de la version courante "trunk" de JavaScript

Une fois authentifié auprès du serveur, c'est le moment de 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 pouvez 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 ici <tt>Darwin_DBG.OBJ/js</tt>.

A 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 branchname à la ligne de commande qui permet la récupération des fichiers sur le serveur CVS.

Suivez les même é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, you 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 fonctionnements. Vous pouvez l'utiliser comme un interprêteur interactif, dans lequel vous tapez le code JavaScript dans un prompt 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 commandes, un fichier JavaScript à exécuter. Dans ce cas, le programme sera exécuté automatiquement.

Note: Comme l'interprêteur JavaScript est utilisé comme environnement de test pour le moteur de fonctionnement de JavaScript, les options disponibles et les fonctions intégrées peuvent changer dans le temps.

Options de la ligne de commandes

Il y a bon numbre d'options de ligne de commandes 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 script spécifié, qui est une chaine de caractères litterale contant le code source à exécuter.
  • -f chemin 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.
  • -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 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 <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 JavasScript, de tester les nouvelles fonctionnalités du langage.

Fonctions intégrées

Pour proposer un interprêteur JavaScript le plus utile, 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.

Note: clear() sans paramètre nettoie vraiment tout. Cela inclue toutes les fonctions intégrées.

clone(fonction, [portée])

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

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 <tt>dis(test);</tt>, 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 montrant 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 ou en utilisant la fonction load().

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

function unTraitement(entree) {
	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])

Evalue le code JavaScript contenu dans chaine. Si objet est spécifié, le code est exécuté dans cet objet, en le considérant comme un bac à sable (sandbox).

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

If string is "lazy" and object is not specified, evalcx() returns a new object with lazy standard classes.

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

gc()

Lance le ramasse-miettes 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 lobjet spécifié en paramètre.

help([commande ...])

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

intern(chaine)

Intègre la chaine 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 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 ...])

Lets you set or get options. If you specified options on the command line, the results of calling options will indicate which options you requested. You can also pass in new options to set.

If you start the shell with the command <tt>js -x</tt>, then the options() function will return <tt>xml</tt>. If you start the shell with no options, and decide you want to enable XML mode, you can do so by issuing the command:

options('xml');

The available options are:

Option Name Description
strict Strict mode is enabled.
werror Warnings should be treated as errors.
atline When atline is enabled, comments of the form //@line num set the number of the following line to num.
xml XML mode is enabled.

pc2line(function, [pc])

Returns the line number of the JavaScript code that corresponds to the first line of the specified function. If you specify a program counter offset into the function, the line number of the line of code containing that offset is returned.

print([expression ...])

Evalue l'expression 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([string ...])

Dumps statistics. Valid options are arena, atom, and global.

Option Description
arena Outputs the arena table.
atom Outputs the atom table.
global Outputs the global name table.

An arena is a large block of memory from which the JavaScript engine allocates sub-blocks in order to optimize performance; issuing a large number of malloc() calls for each individual block is inefficient, so the engine creates arenas, then uses an internal memory management system to allocate memory from within those. The arena table is a list of all the arenas that have been allocated by the shell. stats("arena") lets you inspect the arena table so that you can see how a test case uses arenas.

An atom is a unique identifier for a string. In order to optimize comparisons between strings, each string is given an atom. These atoms are stored in a hash table, which you can display using the command stats("atom").

stats("global") displays the global name table, which contains the names and information about each object in memory.

stringsAreUtf8()

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

testUtf8(mode)

Performs UTF-8 tests. The mode parameter may be an integer from 1 to 4.

This is a debugging command that simply runs some checks on UTF-8 string handling, and isn't of general use, unless you're working on the JavaScript engine itself.

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])

Enables or disables tracing mode. Pass true to enable tracing or false to turn it off. If you don't specify a parameter, tracing() returns the current setting.

Tip: This only works if you build JavaScript with JS_THREADED_INTERP turned off in the file <tt>jsinterp.c</tt>.

trap([function, [pc,]] expression)

Sets a trap at the specific point in the JavaScript code. When the bytecode at the offset specified by pc in the function function is about to be executed, the expression is evaluated.

This is a powerful debugging mechanism when used in concert with line2pc(). For example, if you want to display a message when line 6 of a function, doSomething() is executed, you can enter the following:

trap(doSomething, line2pc(test, 6), "print('line 6!\n')");
Note: When a trap is set, the corresponding bytecode in the program is replaced with a trap bytecode until you use untrap() to remove the trap.

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 sur le 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([number])

The version() function lets you get or set the JavaScript version number. This may be useful for gaining access to syntax only available in certain versions of JavaScript (for example, see Using JavaScript 1.7).

{{ wiki.languages( { "en": "en/Introduction_to_the_JavaScript_shell", "ja": "ja/Introduction_to_the_JavaScript_shell" } ) }}

Source de la révision

<p>{{template.Traduction_en_cours("Introduction to the JavaScript shell")}}
</p>
<h2 name="R.C3.A9cup.C3.A9rer_et_compiler_l.27interpr.C3.A9teur_JavaScript">Récupérer et compiler l'interpréteur JavaScript</h2>
<div class="note"><b>Note:</b> Vous récupérer entièrement le code source de l'interpréteur JavaScript même si vous souhaitez compiler un autre projet Mozilla, vu que certains sont spécifiques à l'interprêteur et ne se trouvent donc pas dans l'arborescence des fichiers source Mozilla.</div>
<h3 name="Connexion_au_serveur_CVS">Connexion au serveur CVS</h3>
<p>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 faire cela, placez vous en ligne de commandes dans le répertoire où vous souhaitez que les fichiers soient récupérés, puis saisissez la commande suivante dans votre terminal:
</p>
<pre class="eval">cvs -d :pserver:anonymous@cvs-mirror.mozilla.org:/cvsroot login
</pre>
<p>Lorsque demandé, saisissez le mot de passe, <tt>anonymous</tt>.
</p>
<h3 name="Compilation_de_la_version_courante_.22trunk.22_de_JavaScript">Compilation de la version courante "trunk" de JavaScript</h3>
<p>Une fois authentifié auprès du serveur, c'est le moment de 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 pouvez saisir la commande suivante: 
</p>
<pre>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
</pre>
<p>Cette commande récupèrera tous les fichiers nécessaires à la compilation de l'interpréteur JavaScript.
</p><p>Maintenant vous pouvez démarrer la compilation de JavaScript en saisissant les deux commandes suivantes:
</p>
<pre>cd mozilla/js/src
make -f Makefile.ref
</pre>
<p>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 ici <tt>Darwin_DBG.OBJ/js</tt>.
</p><p>A partir de maintenant, vous êtes prêt à <a href="#Using_the_JavaScript_shell">exécuter et tester l'interprêteur</a>.
</p>
<h3 name="Compilation_d.27une_version_sp.C3.A9cifique_.22branch.22_de_JavaScript">Compilation d'une version spécifique "branch" de JavaScript</h3>
<p>Si vous voulez tester une version particulière de JavaScript,  vous pouvez le faire facilement en ajoutant <code>-r <i>branchname</i></code> à la ligne de commande qui permet la récupération des fichiers sur le serveur CVS.
</p><p>Suivez les même étapes que précédemment, mais lors de la récupération des fichiers, changez la ligne <tt>cvs co...</tt> par:
</p>
<pre class="eval">cvs -d :pserver:anonymous@cvs-mirror.mozilla.org:/cvsroot co -l -r <i>nom_de_la_branche</i> mozilla/js/src mozilla/js/src/config mozilla/js/src/editline mozilla/js/src/fdlibm
</pre>
<p>Remplacez <i>nom_de_la_branche</i> 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, you devez utiliser <tt>JS_1_7_ALPHA_BRANCH</tt>.
</p><p>Ensuite, vous pouvez compiler et exécuter l'interprêteur comme précédemment.
</p>
<h2 name="Utilisation_de_l.27interpr.C3.AAteur_JavaScript">Utilisation de l'interprêteur JavaScript</h2>
<p>L'interprêteur propose deux modes de fonctionnements.  Vous pouvez l'utiliser comme un interprêteur interactif, dans lequel vous tapez le code JavaScript dans un prompt 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 commandes, un fichier JavaScript à exécuter. Dans ce cas, le programme sera exécuté automatiquement.
</p>
<div class="note"><b>Note:</b> Comme l'interprêteur JavaScript est utilisé comme environnement de test pour le moteur de fonctionnement de JavaScript, les options disponibles et les fonctions intégrées peuvent changer dans le temps.</div>
<h3 name="Options_de_la_ligne_de_commandes">Options de la ligne de commandes</h3>
<p>Il y a bon numbre d'options de ligne de commandes que vous pouvez spécifier pour contrôler l'interprêteur.  Elles sont résumées ci dessous.
</p>
<ul><li> <code>-b <i>nombre de branchements</i></code>
<ul><li> Définition du nombre de branchements maximum.
</li></ul>
</li><li> <code>-c <i>taille d'un bloc de la pile</i></code>
<ul><li> Définition de la taille d'un bloc de la pile.
</li></ul>
</li><li> <code>-C</code>
<ul><li> 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.
</li></ul>
</li><li> <code>-e <i>script</i></code>
<ul><li> Exécute le <i>script</i> spécifié, qui est une chaine de caractères litterale contant le code source à exécuter.
</li></ul>
</li><li> <code>-f <i>chemin du fichier</i></code>
<ul><li> Exécute le programme JavaScript spécifié par le <i>chemin du fichier</i>.
</li></ul>
</li><li> <code>-i</code>
<ul><li> Active le mode interactif.
</li></ul>
</li><li> <code>-P</code>
<ul><li> <i>Je ne suis pas encore certain du fonctionnement de cette option.</i>
</li></ul>
</li><li> <code>-s</code>
<ul><li> Active le mode d'avertissement strict.
</li></ul>
</li><li> <code>-S <i>taille de la pile</i></code>
<ul><li> Définition de la taille maximale de la pile.
</li></ul>
</li><li> <code>-v <i>version</i></code>
<ul><li> Force la version de JavaScript à la version spécifiée par <i>version</i> (ex: <code>170</code> pour JavaScript 1.7).
</li></ul>
</li><li><code> -w</code>
<ul><li> Active les messages d'avertissement.
</li></ul>
</li><li> <code>-W</code>
<ul><li> Désactive les messages d'avertissement.
</li></ul>
</li><li> <code>-x</code>
<ul><li> Active  le mode XML <a href="fr/E4X">E4X</a>.
</li></ul>
</li></ul>
<h3 name="Utilisation_de_l.27interpr.C3.AAteur">Utilisation de l'interprêteur</h3>
<p>Si vous voulez exécuter l'interprêteur en mode interactif, vous pouvez utiliser simplement la commande:
</p>
<pre class="eval">js
</pre>
<p>Si vous voulez exécuter le code JavaScript contenu dans le fichier <tt>foo.js</tt>, vous pouvez utiliser cette commande:
</p>
<pre class="eval">js -f foo.js
</pre>
<p>Pour exécuter <tt>foo.js</tt> puis passer l'interprêteur en mode interactif, faites ceci:
</p>
<pre class="eval">js -f foo.js -f -
</pre>
<h4 name="Utilisation_de_l.27interpr.C3.AAteur_en_mode_interactif">Utilisation de l'interprêteur en mode interactif</h4>
<p>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 JavasScript, de tester les nouvelles fonctionnalités du langage.
</p>
<h3 name="Fonctions_int.C3.A9gr.C3.A9es">Fonctions intégrées</h3>
<p>Pour proposer un interprêteur JavaScript le plus utile, 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.
</p>
<h4 name="build.28.29"><code>build()</code></h4>
<p>Renvoie la date et l'heure de compilation de l'interprêteur JavaScript.
</p>
<h4 name="clear.28.5Bobject.5D.29"><code>clear(<i>[object]</i>)</code></h4>
<p>Efface les propriétés de l'<var>objet</var> spécifié.  Appeler <code>clear()</code> sans paramètres efface tout, ainsi vous pouvez démarrer dans un état connu.
</p>
<div class="note"><b>Note:</b> <code>clear()</code> sans paramètre nettoie vraiment tout. Cela inclue toutes les fonctions intégrées.</div>
<h4 name="clone.28fonction.2C_.5Bport.C3.A9e.5D.29"><code>clone(<i>fonction, [portée]</i>)</code></h4>
<p>Duplique l'objet <var>fonction</var> spécifié.  Si la variable <var>portée&lt;/scope&gt; 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 &lt;var&gt;portée</var>.
</p>
<h4 name="dis.28.5Bfonction.5D.29"><code>dis(<i>[fonction]</i>)</code></h4>
<p>Désassemble le code binaire JavaScript pour le programme entier, ou pour la <i>fonction</i> spécifiée.
</p><p>Par exemple, si vous saisissez la fonction JavaScript suivante:
</p>
<pre>function test() {
  var i = 3;
  print(i+2);
}
</pre> 
<p>Puis exécutez la commande <tt>dis(test);</tt>, vous aurez la sortie suivante:
</p>
<pre>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
</pre>
<h4 name="dissrc.28.5Bfonction.5D.29"><code>dissrc(<i>[fonction]</i>)</code></h4>
<p>Désassemble le code binaire JavaScript du programme complet, ou de la <i>fonction</i> spécifiée, en montrant le code source.  Cette fonction fonctionne seulement avec des programmes exécutés à partir de fichiers, aussi bien en utilisant le commutateur <code>-t</code> au lancement de l'interprêteur ou en utilisant la fonction <code>load()</code>.
</p><p>Si votre programme contient une fonction, <code>unTraitement()</code>, comme ceci:
</p>
<pre>function unTraitement(entree) {
	print("Entrez un nombre: ");
	var n1 = readline();
	print("Entrez en autre: ");
	var n2 = readline();
	
	print("Vous avez entré " + n1 + " et " + n2 + "\n");
}
</pre>
<p>L'appel suivant <code>dissrc(unTraitement)</code> devrait donner le résultat suivant:
</p>
<pre>;-------------------------  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
</pre>
<h4 name="evalcx.28chaine.5B.2C_objet.5D.29"><code>evalcx(<i>chaine[, objet]</i>)</code></h4>
<p>Evalue le code JavaScript contenu dans <i>chaine</i>.  Si <i>objet</i> est spécifié, le code est exécuté dans cet objet, en le considérant comme un bac à sable (sandbox).
</p><p>Si <i>chaine</i> est vide et que <i>objet</i> n'est pas spécifié, <code>evalcx()</code> renvoie un nouvel object contenant les classes standard.
</p><p>If <i>string</i> is "lazy" and <i>object</i> is not specified, <code>evalcx()</code> returns a new object with lazy standard classes.
</p>
<div class="note"><b>Note:</b> <code>evalcx()</code> est utile seulement pour les personnes réalisant un travail en profondeur dans le moteur JavaScript, pour tester des environnements du genre <code>evalInSandbox</code> dans l'interprêteur.</div>
<h4 name="gc.28.29"><code>gc()</code></h4>
<p>Lance le ramasse-miettes pour nettoyer la mémoire des objets inutiles.
</p>
<h4 name="getpda.28objet.29"><code>getpda(<i>objet</i>)</code></h4>
<p>Renvoie les descripteurs de propriétés pour l'<i>objet</i> spécifié.
</p>
<h4 name="getslx.28objet.29"><code>getslx(<i>objet</i>)</code></h4>
<p>Renvoie l'étendue de l'<i>objet</i> en nombre de lignes de script, qui correspond au nombre de lignes de code source où l'on peut trouver l<i>objet</i> spécifié en paramètre.
</p>
<h4 name="help.28.5Bcommande_....5D.29"><code>help(<i>[commande ...]</i>)</code></h4>
<p>Affiche une information conscise à propos de la commande spécifiée, ou à propos de toutes les fonctions disponibles si aucune n'est spécifiée.
</p>
<h4 name="intern.28chaine.29"><code>intern(<i>chaine</i>)</code></h4>
<p>Intègre la <var>chaine</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.
</p>
<div class="note"><b>Note:</b> Cette fonction est prévue pour être utilisée seulement lors des tests du moteur JavaScript.</div>
<h4 name="line2pc.28.5Bfonction.2C_.5D_ligne.29"><code>line2pc(<i>[fonction, ] ligne</i>)</code></h4>
<p>Renvoie la valeur du pointeur d'instruction pour la <i>ligne</i> de code spécifiée.  Si <i>fonction</i> est spécifiée, <i>ligne</i> est un offset dans la fonction spécifiée.
</p>
<h4 name="load.28chemin_.5Bchemin.5D.29"><code>load(<i>chemin</i> <i>[chemin]</i>)</code></h4>
<p>Charge les fichiers spécifiés en paramètre.
</p>
<h4 name="notes.28.5Bfonction.5D.29"><code>notes(<i>[fonction]</i>)</code></h4>
<p>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 <code>dissrc()</code> est utilisée.
</p>
<h4 name="options.28.5Boption_....5D.29"><code>options(<i>[option ...]</i>)</code></h4>
<p>Lets you set or get options.  If you specified options on the command line, the results of calling <code>options</code> will indicate which options you requested.  You can also pass in new options to set.
</p><p>If you start the shell with the command <tt>js -x</tt>, then the <code>options()</code> function will return <tt>xml</tt>.  If you start the shell with no options, and decide you want to enable XML mode, you can do so by issuing the command:
</p>
<pre class="eval">options('xml');
</pre>
<p>The available options are:
</p>
<table class="standard-table">

<tbody><tr>
<td class="header">Option Name
</td><td class="header">Description
</td></tr>

<tr>
<td><code>strict</code>
</td><td> Strict mode is enabled.
</td></tr>
<tr>
<td><code>werror</code>
</td><td> Warnings should be treated as errors.
</td></tr>
<tr>
<td><code>atline</code>
</td><td> When <code>atline</code> is enabled, comments of the form <code>//@line <i>num</i></code> set the number of the following line to <code><i>num</i></code>.
</td></tr>
<tr>
<td><code>xml</code>
</td><td> XML mode is enabled.
</td></tr>
</tbody></table>
<h4 name="pc2line.28function.2C_.5Bpc.5D.29"><code>pc2line(<i>function, [pc]</i>)</code></h4>
<p>Returns the line number of the JavaScript code that corresponds to the first line of the specified <i>function</i>.  If you specify a program counter offset into the function, the line number of the line of code containing that offset is returned.
</p>
<h4 name="print.28.5Bexpression_....5D.29"><code>print(<i>[expression ...]</i>)</code></h4>
<p>Evalue l'<i>expression</i> et affiche le résultat sur la sortie standard <tt>stdout</tt>.
</p>
<h4 name="quit.28.29"><code>quit()</code></h4>
<p>Quitte l'interprêteur.
</p>
<h4 name="readline.28.29"><code>readline()</code></h4>
<p>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.
</p>
<h4 name="seal.28objet.5B.2C_profond.5D.29"><code>seal(<i>objet[, profond]</i>)</code></h4>
<p>Scelle l'<i>objet</i> spécifié, ou une arborescence d'objets si <i>profond</i> est à <code>true</code>.  EN scellant un objet ou arborescence d'objet, vous désactivez la modification de ces objets.
</p>
<h4 name="stats.28.5Bstring_....5D.29"><code>stats(<i>[string ...]</i>)</code></h4>
<p>Dumps statistics.  Valid options are <i>arena</i>, <i>atom</i>, and <i>global</i>.
</p>
<table class="standard-table">

<tbody><tr>
<td class="header">Option
</td><td class="header">Description
</td></tr>

<tr>
<td><code>arena</code>
</td><td> Outputs the arena table.
</td></tr>
<tr>
<td><code>atom</code>
</td><td> Outputs the atom table.
</td></tr>
<tr>
<td><code>global</code>
</td><td> Outputs the global name table.
</td></tr>
</tbody></table>
<p>An <i>arena</i> is a large block of memory from which the  JavaScript engine allocates sub-blocks in order to optimize performance; issuing a large number of <code>malloc()</code> calls for each individual block is inefficient, so the engine creates arenas, then uses an internal memory management system to allocate memory from within those.  The arena table is a list of all the arenas that have been allocated by the shell.  <code>stats("arena")</code> lets you inspect the arena table so that you can see how a test case uses arenas.
</p><p>An <i>atom</i> is a unique identifier for a string. In order to optimize comparisons between strings, each string is given an atom.  These atoms are stored in a hash table, which you can display using the command <code>stats("atom")</code>.
</p><p><code>stats("global")</code> displays the global name table, which contains the names and information about each object in memory.
</p>
<h4 name="stringsAreUtf8.28.29"><code>stringsAreUtf8()</code></h4>
<p>Renvoie <code>true</code> si les chaînes de caractères sont codées au formati UTF8;  dans le cas contraire <code>false</code> est renvoyé.
</p>
<h4 name="testUtf8.28mode.29"><code>testUtf8(<i>mode</i>)</code></h4>
<p>Performs UTF-8 tests.  The mode parameter may be an integer from 1 to 4.
</p><p>This is a debugging command that simply runs some checks on UTF-8 string handling, and isn't of general use, unless you're working on the JavaScript engine itself.
</p>
<h4 name="throwError.28.29"><code>throwError()</code></h4>
<p>Lance une erreur depuis la fonction <code>JS_ReportError()</code>.
</p>
<div class="note"><b>Note:</b> Cette fonction est prévue pour n'être utilisée que lors de tests du moteur JavaScript.</div>
<h4 name="tracing.28.5Btoggle.5D.29"><code>tracing(<i>[toggle]</i>)</code></h4>
<p>Enables or disables tracing mode.  Pass <code>true</code> to enable tracing or <code>false</code> to turn it off.  If you don't specify a parameter, <code>tracing()</code> returns the current setting.
</p>
<div class="tip"><b>Tip:</b> This only works if you build JavaScript with <code> JS_THREADED_INTERP</code> turned off in the file <tt>jsinterp.c</tt>.</div>
<h4 name="trap.28.5Bfunction.2C_.5Bpc.2C.5D.5D_expression.29"><code>trap(<i>[function, [pc,]] expression</i>)</code></h4>
<p>Sets a trap at the specific point in the JavaScript code.  When the bytecode at the offset specified by <i>pc</i> in the function <i>function</i> is about to be executed, the <i>expression</i> is evaluated.
</p><p>This is a powerful debugging mechanism when used in concert with <code>line2pc()</code>.  For example, if you want to display a message when line 6 of a function, <code>doSomething()</code> is executed, you can enter the following:
</p>
<pre>trap(doSomething, line2pc(test, 6), "print('line 6!\n')");
</pre>
<div class="note"><b>Note:</b> When a trap is set, the corresponding bytecode in the program is replaced with a <code>trap</code> bytecode until you use <code>untrap()</code> to remove the trap.</div>
<h4 name="untrap.28fonction_.5B.2C_pc.5D.29"><code>untrap(<i>fonction [, pc]</i>)</code></h4>
<p>Supprime une trappe dans la <i>fonction</i> spécifiée à l'offset <i>pc</i>.  Si <i>pc</i> n'est pas spécifié, la trappe est enlevée sur le point d'entrée de la fonction.
</p><p>Cette fonction n'a aucun effet si aucune trappe n'est définie à la position spécifiée.
</p>
<h4 name="version.28.5Bnumber.5D.29"><code>version(<i>[number]</i>)</code></h4>
<p>The <code>version()</code> function lets you get or set the JavaScript version number.  This may be useful for gaining access to syntax only available in certain versions of JavaScript (for example, see <a href="fr/New_in_JavaScript_1.7#Using_JavaScript_1.7">Using JavaScript 1.7</a>).
</p>
<div class="noinclude">
</div>
{{ wiki.languages( { "en": "en/Introduction_to_the_JavaScript_shell", "ja": "ja/Introduction_to_the_JavaScript_shell" } ) }}
Revenir à cette révision