path: root/files/fr/introduction_au_shell_javascript/index.html

---
title: Introduction au shell JavaScript
slug: Introduction_au_shell_JavaScript
tags:
  - JavaScript
  - SpiderMonkey
translation_of: Mozilla/Projects/SpiderMonkey/Introduction_to_the_JavaScript_shell
---
<p>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.</p>

<p>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.</p>

<h3 id="R.C3.A9cup.C3.A9rer_et_compiler_l.27interpr.C3.A9teur_JavaScript" name="R.C3.A9cup.C3.A9rer_et_compiler_l.27interpr.C3.A9teur_JavaScript">Récupérer et compiler l'interpréteur JavaScript</h3>

<div class="note"><strong>Note :</strong> 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.</div>

<h4 id="Connexion_au_serveur_CVS" name="Connexion_au_serveur_CVS">Connexion au serveur CVS</h4>

<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 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 :</p>

<pre class="eval">cvs -d <a class="link-mailto" href="mailto::pserver:anonymous@cvs-mirror.mozilla.org" rel="freelink">:pserver:anonymous@cvs-mirror.mozilla.org</a>:/cvsroot login
</pre>

<p>Lorsqu'il vous est demandé, saisissez le mot de passe <code>anonymous</code>.</p>

<h4 id="Compilation_de_la_version_courante_.C2.AB_trunk_.C2.BB_de_JavaScript" name="Compilation_de_la_version_courante_.C2.AB_trunk_.C2.BB_de_JavaScript">Compilation de la version courante « trunk » de JavaScript</h4>

<p>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 :</p>

<pre class="eval">cvs -d <a class="link-mailto" href="mailto::pserver:anonymous@cvs-mirror.mozilla.org" rel="freelink">:pserver:anonymous@cvs-mirror.mozilla.org</a>:/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 class="eval">cd mozilla/js/src
make -f Makefile.ref
</pre>

<p>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.</p>

<p>À partir de maintenant, vous êtes prêt à <a href="#Utilisation_du_shell_JavaScript">exécuter et tester l'interpréteur</a>.</p>

<h4 id="Compilation_d.27une_version_sp.C3.A9cifique_.C2.AB_branch_.C2.BB_de_JavaScript" name="Compilation_d.27une_version_sp.C3.A9cifique_.C2.AB_branch_.C2.BB_de_JavaScript">Compilation d'une version spécifique « branch » de JavaScript</h4>

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

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

<pre class="eval">cvs -d <a class="link-mailto" href="mailto::pserver:anonymous@cvs-mirror.mozilla.org" rel="freelink">:pserver:anonymous@cvs-mirror.mozilla.org</a>:/cvsroot co -l -r<em>nom_de_la_branche</em> mozilla/js/src mozilla/js/src/config mozilla/js/src/editline mozilla/js/src/fdlibm
</pre>

<p>Remplacez<em>nom_de_la_branche</em> 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.</p>

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

<h3 id="Utilisation_de_l.27interpr.C3.A9teur_JavaScript" name="Utilisation_de_l.27interpr.C3.A9teur_JavaScript">Utilisation de l'interpréteur JavaScript</h3>

<p>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.</p>

<div class="note"><strong>Note :</strong> é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.</div>

<h4 id="Options_de_la_ligne_de_commandes" name="Options_de_la_ligne_de_commandes">Options de la ligne de commandes</h4>

<p>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.</p>

<dl>
 <dt><code>-b<em>nombre de branchements</em></code></dt>
 <dd>Définition du nombre de branchements maximum.</dd>
 <dt><code>-c<em>taille d'un bloc de la pile</em></code></dt>
 <dd>Définition de la taille d'un bloc de la pile.</dd>
 <dt><code>-C</code></dt>
 <dd>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.</dd>
 <dt><code>-e<em>script</em></code></dt>
 <dd>Exécute le <var>script</var> spécifié, qui est une chaîne de caractères littérale contant le code source à exécuter.</dd>
 <dt><code>-f<em>chemin_du_fichier</em></code></dt>
 <dd>Exécute le programme JavaScript spécifié par le <var>chemin_du_fichier</var>.</dd>
 <dt><code>-i</code></dt>
 <dd>Active le mode interactif.</dd>
 <dt><code>-P</code></dt>
 <dd><em>Je ne suis pas encore certain du fonctionnement de cette option.</em></dd>
 <dt><code>-s</code></dt>
 <dd>Active le mode d'avertissement strict.</dd>
 <dt><code>-S<em>taille de la pile</em></code></dt>
 <dd>Définition de la taille maximale de la pile.</dd>
 <dt><code>-v<em>version</em></code></dt>
 <dd>Force la version de JavaScript à la version spécifiée par <var>version</var> (ex : <code>170</code> pour JavaScript 1.7).</dd>
 <dt><code>-w</code></dt>
 <dd>Active les messages d'avertissement.</dd>
 <dt><code>-W</code></dt>
 <dd>Désactive les messages d'avertissement.</dd>
 <dt><code>-x</code></dt>
 <dd>Active le mode XML <a href="fr/E4X">E4X</a>.</dd>
</dl>

<h4 id="Utilisation_de_l.27interpr.C3.A9teur" name="Utilisation_de_l.27interpr.C3.A9teur">Utilisation de l'interpréteur</h4>

<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 foo.js, vous pouvez utiliser cette commande :</p>

<pre class="eval">js -f foo.js
</pre>

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

<pre class="eval">js -f foo.js -f -
</pre>

<h5 id="Utilisation_de_l.27interpr.C3.A9teur_en_mode_interactif" name="Utilisation_de_l.27interpr.C3.A9teur_en_mode_interactif">Utilisation de l'interpréteur en mode interactif</h5>

<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 JavaScript, de tester les nouvelles fonctionnalités du langage.</p>

<h4 id="Fonctions_int.C3.A9gr.C3.A9es" name="Fonctions_int.C3.A9gr.C3.A9es">Fonctions intégrées</h4>

<p>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.</p>

<h5 id="build.28.29" name="build.28.29"><code>build()</code></h5>

<p>Renvoie la date et l'heure de compilation de l'interpréteur JavaScript.</p>

<h5 id="clear.28.5Bobject.5D.29" name="clear.28.5Bobject.5D.29"><code>clear(<em>[object]</em>)</code></h5>

<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"><strong>Note :</strong> <code>clear()</code> sans paramètre nettoie vraiment tout. Cela inclut toutes les fonctions intégrées.</div>

<h5 id="clone.28fonction.2C_.5Bport.C3.A9e.5D.29" name="clone.28fonction.2C_.5Bport.C3.A9e.5D.29"><code>clone(<em>fonction, [portée]</em>)</code></h5>

<p>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>.</p>

<h5 id="dis.28.5Bfonction.5D.29" name="dis.28.5Bfonction.5D.29"><code>dis(<em>[fonction]</em>)</code></h5>

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

<p>Par exemple, si vous saisissez la fonction JavaScript suivante :</p>

<pre class="eval">function test() {
  var i = 3;
  print(i+2);
}
</pre>

<p>Puis exécutez la commande <code>dis(test);</code>, 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>

<h5 id="dissrc.28.5Bfonction.5D.29" name="dissrc.28.5Bfonction.5D.29"><code>dissrc(<em>[fonction]</em>)</code></h5>

<p>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 <code>-t</code> au lancement de l'interpréteur qu'en utilisant la fonction <code>load()</code>.</p>

<p>Si votre programme contient une fonction, <code>unTraitement()</code>, comme ceci :</p>

<pre class="eval">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");
}
</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>

<h5 id="evalcx.28chaine.5B.2C_objet.5D.29" name="evalcx.28chaine.5B.2C_objet.5D.29"><code>evalcx(<em>chaine[, objet]</em>)</code></h5>

<p>É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.</p>

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

<div class="note"><strong>Note :</strong> <code>evalcx()</code> est utile seulement pour les personnes réalisant un travail en profondeur dans le moteur JavaScript, pour tester des environnements comme <code>evalInSandbox</code> dans l'interpréteur.</div>

<h5 id="gc.28.29" name="gc.28.29"><code>gc()</code></h5>

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

<h5 id="getpda.28objet.29" name="getpda.28objet.29"><code>getpda(<em>objet</em>)</code></h5>

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

<h5 id="getslx.28objet.29" name="getslx.28objet.29"><code>getslx(<em>objet</em>)</code></h5>

<p>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.</p>

<h5 id="help.28.5Bcommande_....5D.29" name="help.28.5Bcommande_....5D.29"><code>help(<em>[commande ...]</em>)</code></h5>

<p>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.</p>

<h5 id="intern.28cha.C3.AEne.29" name="intern.28cha.C3.AEne.29"><code>intern(<em>chaîne</em>)</code></h5>

<p>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.</p>

<div class="note"><strong>Note :</strong> Cette fonction est prévue pour être utilisée seulement lors des tests du moteur JavaScript.</div>

<h5 id="line2pc.28.5Bfonction.2C_.5D_ligne.29" name="line2pc.28.5Bfonction.2C_.5D_ligne.29"><code>line2pc(<em>[fonction, ] ligne</em>)</code></h5>

<p>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.</p>

<h5 id="load.28chemin_.5Bchemin.5D.29" name="load.28chemin_.5Bchemin.5D.29"><code>load(<em>chemin</em><em>[chemin]</em>)</code></h5>

<p>Charge les fichiers spécifiés en paramètre.</p>

<h5 id="notes.28.5Bfonction.5D.29" name="notes.28.5Bfonction.5D.29"><code>notes(<em>[fonction]</em>)</code></h5>

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

<h5 id="options.28.5Boption_....5D.29" name="options.28.5Boption_....5D.29"><code>options(<em>[option ...]</em>)</code></h5>

<p>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 <code>options</code> indiquera celles que vous avez demandées. Il est également possible de passer de nouvelles options à définir.</p>

<p>Si vous lancez l'interpréteur avec la commande js -x, alors la fonction <code>options()</code> 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 :</p>

<pre class="eval">options('xml');
</pre>

<p>Les options disponibles sont :</p>

<table class="standard-table">
 <tbody>
  <tr>
   <td class="header">Nom de l'option</td>
   <td class="header">Description</td>
  </tr>
  <tr>
   <td><code>strict</code></td>
   <td>Mode strict activé.</td>
  </tr>
  <tr>
   <td><code>werror</code></td>
   <td>Les avertissements seront traités comme des erreurs.</td>
  </tr>
  <tr>
   <td><code>atline</code></td>
   <td>Lorsque <code>atline</code> est activée, les commentaires de la forme <code>//@line<em>num</em></code> définissent le nombre de lignes suivantes à <code><var>num</var></code>.</td>
  </tr>
  <tr>
   <td><code>xml</code></td>
   <td>Mode XML activé.</td>
  </tr>
 </tbody>
</table>

<h5 id="pc2line.28function.2C_.5Bpc.5D.29" name="pc2line.28function.2C_.5Bpc.5D.29"><code>pc2line(<em>function, [pc]</em>)</code></h5>

<p>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é.</p>

<h5 id="print.28.5Bexpression_....5D.29" name="print.28.5Bexpression_....5D.29"><code>print(<em>[expression ...]</em>)</code></h5>

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

<h5 id="quit.28.29" name="quit.28.29"><code>quit()</code></h5>

<p>Quitte l'interpréteur.</p>

<h5 id="readline.28.29" name="readline.28.29"><code>readline()</code></h5>

<p>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.</p>

<h5 id="seal.28objet.5B.2C_profond.5D.29" name="seal.28objet.5B.2C_profond.5D.29"><code>seal(<em>objet[, profond]</em>)</code></h5>

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

<h5 id="stats.28.5Bcha.C3.AEne_....5D.29" name="stats.28.5Bcha.C3.AEne_....5D.29"><code>stats(<em>[chaîne ...]</em>)</code></h5>

<p>Vide les statistiques. Les options valide sont <var>arena</var>, <var>atom</var> et <var>global</var>.</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>Affiche la table <var>arena</var>.</td>
  </tr>
  <tr>
   <td><code>atom</code></td>
   <td>Affiche la table <var>atom</var>.</td>
  </tr>
  <tr>
   <td><code>global</code></td>
   <td>Affiche la table <var>global</var>.</td>
  </tr>
 </tbody>
</table>

<p>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 <code>malloc()</code> 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. <code>stats("arena")</code> vous permet d'inspecter la table pour que vous puissiez comprendre l'utilisation des <var>arenas</var> par un test.</p>

<p>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 <code>stats("atom")</code>.</p>

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

<h5 id="stringsAreUtf8.28.29" name="stringsAreUtf8.28.29"><code>stringsAreUtf8()</code></h5>

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

<h5 id="testUtf8.28mode.29" name="testUtf8.28mode.29"><code>testUtf8(<em>mode</em>)</code></h5>

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

<p>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.</p>

<h5 id="throwError.28.29" name="throwError.28.29"><code>throwError()</code></h5>

<p>Lance une erreur depuis la fonction <code>JS_ReportError()</code>.</p>

<div class="note"><strong>Note :</strong> Cette fonction est prévue pour n'être utilisée que lors de tests du moteur JavaScript.</div>

<h5 id="tracing.28.5Btoggle.5D.29" name="tracing.28.5Btoggle.5D.29"><code>tracing(<em>[toggle]</em>)</code></h5>

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

<div class="note"><strong>Astuce :</strong> Ceci ne fonctionne qui si vous compilez JavaScript avec <code>JS_THREADED_INTERP</code> désactivé dans le fichier jsinterp.c.</div>

<h5 id="trap.28.5Bfonction.2C_.5Bpc.2C.5D.5D_expression.29" name="trap.28.5Bfonction.2C_.5Bpc.2C.5D.5D_expression.29"><code>trap(<em>[fonction, [pc,]] expression</em>)</code></h5>

<p>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.</p>

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

<pre class="eval">trap(doSomething, line2pc(test, 6), "print('line 6!\n')");
</pre>

<div class="note"><strong>Note :</strong> Lorsqu'une trappe est définie, le code correspondant dans le programme est remplacé par un code <code>trap</code> jusqu'à l'utilisation de <code>untrap()</code> qui supprimera la trappe.</div>

<h5 id="untrap.28fonction_.5B.2C_pc.5D.29" name="untrap.28fonction_.5B.2C_pc.5D.29"><code>untrap(<em>fonction [, pc]</em>)</code></h5>

<p>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.</p>

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

<h5 id="version.28.5Bnombre.5D.29" name="version.28.5Bnombre.5D.29"><code>version(<em>[nombre]</em>)</code></h5>

<p>La fonction <code>version()</code> 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 <a href="fr/Nouveaut%c3%a9s_dans_JavaScript_1.7#_Utilisation_de_JavaScript_1.7"> Utilisation de JavaScript 1.7</a>).</p>

<p><span class="comment">Interwiki Language Links</span></p>

<p>{{ languages( { "en": "en/Introduction_to_the_JavaScript_shell", "ja": "ja/Introduction_to_the_JavaScript_shell" } ) }}</p>