<html>
<link rel="stylesheet" href="josh.css">

<!-- Inserted by TRADOS: --><META HTTP-EQUIV="content-type" CONTENT="text/html; charset=windows-1252">
<body bgcolor="#FFFFFF">
<div id="=">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">=</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">2</span> IE <span class="emphasis">3</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
Cet op&eacute;rateur affecte la valeur &eacute;valu&eacute;e de l'op&eacute;rande de droite &agrave; la variable de gauche. Apr&egrave;s l'op&eacute;ration, la variable contient des donn&eacute;es du m&ecirc;me type que la valeur originale. Les op&eacute;rations d'affectation peuvent &ecirc;tre cha&icirc;n&eacute;es; dans ce cas, l'&eacute;valuation de l'instruction enti&egrave;re s'effectue de droite &agrave; gauche. Ainsi, apr&egrave;s l'expression:
</p>
<span class="PROGRAMLISTING"><pre>a = b = c = 25;</pre></span>
</td>
</tr>
<tr>
<td colspan="2"><p>
les trois variables sont &eacute;gales &agrave; 25.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>var myName = &quot;Theodore Roosevelt&quot;;
var now = new Date( );</pre>
</span></td>
</tr>
</table>
</div>
<div id="&">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">&amp;</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">2</span> IE <span class="emphasis">3</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
L&rsquo;op&eacute;rateur AND au niveau du bit ex&eacute;cute une op&eacute;ration math&eacute;matique binaire sur deux op&eacute;randes (leurs valeurs binaires). Chaque colonne de bits est soumise &agrave; l'op&eacute;ration bool&eacute;enne AND. Si la valeur d'une colonne des deux op&eacute;randes est &eacute;gale &agrave; 1, le r&eacute;sultat correspondant &agrave; cette position de colonne est 1. Toutes les autres combinaisons produisent le r&eacute;sultat z&eacute;ro. La valeur d'op&eacute;rateur qui en r&eacute;sulte est l'&eacute;quivalent d&eacute;cimal du r&eacute;sultat binaire. Par exemple, les &eacute;quivalents binaires des valeurs d&eacute;cimales 3 et 6 sont 0011 et 0110. Apr&egrave;s une op&eacute;ration AND sur ces deux valeurs, le r&eacute;sultat binaire est 0010, ce qui &eacute;quivaut &agrave; la valeur d&eacute;cimale 2.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>var n = 3 &amp; 6;</pre>
</span></td>
</tr>
</table>
</div>
<div id="<<">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">&lt;&lt;</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">2</span> IE <span class="emphasis">3</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
Cet op&eacute;rateur d&eacute;cale les bits du premier op&eacute;rande du nombre de colonnes sp&eacute;cifi&eacute; par le second. Par exemple, si les bits de la valeur binaire de 3 (0011) sont d&eacute;cal&eacute;s de deux positions vers la gauche, le r&eacute;sultat binaire est 1100, ce qui &eacute;quivaut &agrave; la valeur d&eacute;cimale 12.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>var shifted = 3 &lt;&lt; 2;</pre>
</span></td>
</tr>
</table>
</div>
<div id="~">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">~</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">2</span> IE <span class="emphasis">3</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
Il s&rsquo;agit de l&rsquo;op&eacute;rateur NOT au niveau du bit. Cet op&eacute;rateur unaire inverse la valeur du signe binaire de chaque colonne d'un nombre. Par exemple, l'&eacute;quivalent binaire de la valeur d&eacute;cimale 6 est 0110 (avec beaucoup plus de z&eacute;ros &agrave; gauche). Apr&egrave;s l'op&eacute;ration de n&eacute;gation appliqu&eacute;e &agrave; la valeur de chaque colonne, le r&eacute;sultat binaire est 1001, plus tous les z&eacute;ros de gauche invers&eacute;s en 1. L'&eacute;quivalent d&eacute;cimal est une valeur n&eacute;gative (-5).
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>var n = ~6;</pre>
</span></td>
</tr>
</table>
</div>
<div id="|">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">|</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">2</span> IE <span class="emphasis">3</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
L&rsquo;op&eacute;rateur OR au niveau du bit ex&eacute;cute une op&eacute;ration math&eacute;matique binaire sur deux op&eacute;randes (leurs valeurs binaires). Chaque colonne de bits est soumise &agrave; l'op&eacute;ration bool&eacute;enne OR. Si la valeur d'une colonne des deux op&eacute;randes est &eacute;gale &agrave; 0, le r&eacute;sultat correspondant &agrave; cette position de colonne est 0. Toutes les autres combinaisons produisent le r&eacute;sultat 1. La valeur d'op&eacute;rateur qui en r&eacute;sulte est l'&eacute;quivalent d&eacute;cimal du r&eacute;sultat binaire. Par exemple, les &eacute;quivalents binaires des valeurs d&eacute;cimales 3 et 6 sont 0011 et 0110. Apr&egrave;s une op&eacute;ration OR sur ces deux valeurs, le r&eacute;sultat binaire est 0111, ce qui &eacute;quivaut &agrave; la valeur d&eacute;cimale 7.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>var n = 3 | 6;</pre>
</span></td>
</tr>
</table>
</div>
<div id=">>">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">&gt;&gt;</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">2</span> IE <span class="emphasis">3</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
Cet op&eacute;rateur d&eacute;cale les bits du premier op&eacute;rande du nombre de colonnes sp&eacute;cifi&eacute; par le second. Par exemple, si les bits de la valeur binaire de 6 (0110) sont d&eacute;cal&eacute;s de deux positions vers la droite, le r&eacute;sultat binaire est 0001, ce qui &eacute;quivaut &agrave; la valeur d&eacute;cimale 1. Tous les caract&egrave;res binaires situ&eacute;s au-del&agrave; de l'extr&eacute;mit&eacute; droite du nombre sont &eacute;cart&eacute;s.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>var shifted = 6 &gt;&gt; 2;</pre>
</span></td>
</tr>
</table>
</div>
<div id="^">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">^</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">2</span> IE <span class="emphasis">3</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
L&rsquo;op&eacute;rateur OR au niveau du bit (XOR) ex&eacute;cute une op&eacute;ration math&eacute;matique binaire sur deux op&eacute;randes (leurs valeurs binaires). Chaque colonne de bits est soumise &agrave; l'op&eacute;ration bool&eacute;enne XOR. Si la valeur d'une colonne de l'un des deux op&eacute;randes (mais pas des deux) est &eacute;gale &agrave; 1, le r&eacute;sultat correspondant &agrave; cette position de colonne est 1. Toutes les autres combinaisons produisent le r&eacute;sultat 0. La valeur d'op&eacute;rateur qui en r&eacute;sulte est l'&eacute;quivalent d&eacute;cimal du r&eacute;sultat binaire. Par exemple, les &eacute;quivalents binaires des valeurs d&eacute;cimales 3 et 6 sont 0011 et 0110. Apr&egrave;s une op&eacute;ration XOR sur ces deux valeurs, le r&eacute;sultat binaire est 0101, ce qui &eacute;quivaut &agrave; la valeur d&eacute;cimale 5.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>var n = 3 ^ 6;</pre>
</span></td>
</tr>
</table>
</div>
<div id=">>>">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">&gt;&gt;&gt;</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">2</span> IE <span class="emphasis">3</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
Il s&rsquo;agit de l&rsquo;op&eacute;rateur de d&eacute;placement vers la droite au niveau du bit avec peuplement de z&eacute;ros. Cet op&eacute;rateur d&eacute;cale (vers la droite) les bits du premier op&eacute;rande du nombre de colonnes sp&eacute;cifi&eacute; par le second. Dans le cas de l'op&eacute;rateur de d&eacute;placement vers la droite au niveau du bit (<span class="literal">), les caract&egrave;res binaires qui peuplent l'expression &agrave; partir du c&ocirc;t&eacute; gauche sont des 1; dans le cas de l'op&eacute;rateur de d&eacute;placement vers la droite avec peuplement de z&eacute;ros (<literal>&gt;&gt;&gt;</literal>), les caract&egrave;res binaires qui peuplent l'expression &agrave; partir du c&ocirc;t&eacute; gauche sont des z&eacute;ros. Tous les caract&egrave;res binaires situ&eacute;s au-del&agrave; de l'extr&eacute;mit&eacute; droite du nombre sont &eacute;cart&eacute;s. Microsoft d&eacute;signe &eacute;galement cet op&eacute;rateur comme op&eacute;rateur de d&eacute;placement vers la droite non sign&eacute;.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>var shifted = 6 &gt;&gt;&gt; 2;</pre>
</span></td>
</tr>
</table>
</div>
<div id=",">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">,</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">2</span> IE <span class="emphasis">3</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
Cet op&eacute;rateur (suivi ou non de l&rsquo;espace blanc facultatif) permet de d&eacute;limiter des expressions se trouvant dans la m&ecirc;me ligne de script. Vous pouvez l'utiliser de plusieurs mani&egrave;res. Par exemple, pour d&eacute;clarer plusieurs variables, la syntaxe est:
</p>
<programlisting>var varName1, varName2, ... varNameN;</programlisting>
</td>
</tr>
<tr>
<td colspan="2"><p>
Il est &eacute;galement possible de joindre plusieurs instructions de script sur la m&ecirc;me ligne. Ainsi, la ligne de script suivante:
</p>
<programlisting>alert(&quot;Howdy&quot;), alert(&quot;Doody&quot;);</programlisting>
</td>
</tr>
<tr>
<td colspan="2"><p>
pr&eacute;sente successivement deux bo&icirc;tes d'alerte (la seconde s'affiche une fois que la premi&egrave;re a &eacute;t&eacute; ferm&eacute;e par l'utilisateur). Une autre application consiste &agrave; l'utiliser dans des boucles <span class="literal">for</span> dans lesquelles vous voulez inclure deux variables ou plus:
</p>
<span class="PROGRAMLISTING"><pre>for (var i = 0, var j = 2; i&lt; 20; i++, j++) {
    ...
} </pre></span>
</td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>var isCSS, isIEMac;</pre>
</span></td>
</tr>
</table>
</div>
<div id="/*...*/">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">//, /*...*/</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">2</span> IE <span class="emphasis">3</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
Instructions de commentaires qui vous permettent d'ins&eacute;rer du texte non ex&eacute;cutable dans un script. L'interpr&eacute;teur de langage ignore tout texte suivant le symbole <span class="literal">//</span> dans une ligne d'instructions. Le navigateur interpr&egrave;te la ligne de script suivante, sauf si elle commence par un autre symbole <span class="literal">//</span>.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
Pour les commentaires sur plusieurs lignes, vous pouvez faire pr&eacute;c&eacute;der le bloc du symbole <span class="literal">/*</span>. Les blocs de commentaires peuvent contenir un nombre quelconque de lignes. Le symbole <span class="literal">*/</span> d&eacute;signe la fermeture du bloc indiquant &agrave; l'interpr&eacute;teur qu'il peut ex&eacute;cuter les instructions suivantes.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>// convert temp from C to F

/*
many lines
of
comments
*/</pre>
</span></td>
</tr>
</table>
</div>
<div id="//">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">//, /*...*/</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">2</span> IE <span class="emphasis">3</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
Instructions de commentaires qui vous permettent d'ins&eacute;rer du texte non ex&eacute;cutable dans un script. L'interpr&eacute;teur de langage ignore tout texte suivant le symbole <span class="literal">//</span> dans une ligne d'instructions. Le navigateur interpr&egrave;te la ligne de script suivante, sauf si elle commence par un autre symbole <span class="literal">//</span>.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
Pour les commentaires sur plusieurs lignes, vous pouvez faire pr&eacute;c&eacute;der le bloc du symbole <span class="literal">/*</span>. Les blocs de commentaires peuvent contenir un nombre quelconque de lignes. Le symbole <span class="literal">*/</span> d&eacute;signe la fermeture du bloc indiquant &agrave; l'interpr&eacute;teur qu'il peut ex&eacute;cuter les instructions suivantes.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>// convert temp from C to F

/*
many lines
of
comments
*/</pre>
</span></td>
</tr>
</table>
</div>
<div id="@cc_on">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">@cc_on, @if, @end, @set</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">s.o.</span> IE <span class="emphasis">4(Win)</span> ECMA <span class="emphasis">s.o.</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
IE pour Windows comprend une fonctionnalit&eacute; de scripts appel&eacute;e <span class="emphasis">compilation conditionnelle</span>. Il s&rsquo;agit d&rsquo;un mode qui, une fois qu&rsquo;il est activ&eacute; par le biais de l&rsquo;instruction <span class="literal">@cc_on</span>, permet aux instructions JScript de s&rsquo;ex&eacute;cuter dans des conditions testables au sein de cet environnement conditionnel. Si vous entourez les instructions de compilation conditionnelle de commentaires JavaScript, les instructions conditionnelles ne s&rsquo;ex&eacute;cutent que sur IE 4 et versions ult&eacute;rieures pour Windows, sans entrer en conflit avec les autres navigateurs.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
Cette partie &laquo;&nbsp;conditionnelle&nbsp;&raquo; provient de nombreuses propri&eacute;t&eacute;s globales (toutes pr&eacute;c&eacute;d&eacute;es du symbole <span class="literal">@</span>) qui r&eacute;v&egrave;lent des propri&eacute;t&eacute;s d&rsquo;environnement, telles que la version du moteur de script, le syst&egrave;me d&rsquo;exploitation et le type de processeur. Toutes ces informations sont disponibles &agrave; partir des propri&eacute;t&eacute;s de l&rsquo;objet <span class="literal">navigator</span> sur une vaste gamme de navigateurs, il ne s&rsquo;agit donc pas d&rsquo;informations uniques disponibles seulement pour cet environnement conditionnel.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
Pour activer la compilation conditionnelle, incluez l&rsquo;instruction suivante dans votre script&nbsp;:
</p>
<span class="PROGRAMLISTING"><pre>/*@cc_on @*/</pre></span>
</td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
Il s&rsquo;agit d&rsquo;un commutateur &agrave; sens unique&nbsp;: une fois que le mode est activ&eacute;, il ne peut plus &ecirc;tre d&eacute;sactiv&eacute; dans la page consid&eacute;r&eacute;e.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
Le fragment suivant montre comment l&rsquo;instruction <span class="literal">@if</span> et les instructions connexes affichent des informations d&rsquo;environnement dans la barre de statut de la fen&ecirc;tre si le navigateur ex&eacute;cute JScript version 5.6 ou ult&eacute;rieure (IE 6 ou version plus r&eacute;cente)&nbsp;:
</p>
<span class="PROGRAMLISTING"><pre>/*@cc_on @*/
/*@if (@_jscript_version&gt;= 5.6 &amp;&amp; @_x86)
    status = &quot;Now running JScript version &quot; + @_jscript_version + 
    &quot; with Intel inside.&quot;;
   @else @*/
    status = &quot;Have a nice day.&quot;;
/*@end @*/ </pre></span>
</td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
L&rsquo;instruction <span class="literal">@set</span> vous permet d&rsquo;affecter une valeur num&eacute;rique ou bool&eacute;enne (pas de cha&icirc;nes) &agrave; une variable (une variable avec un pr&eacute;fixe <span class="literal">@</span>) au sein d&rsquo;une section de compilation conditionnelle&nbsp;:
</p>
<span class="PROGRAMLISTING"><pre>@set @isOK = @_win32</pre></span>
</td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
Une fois initialis&eacute;e, cette variable (y compris son identifiant autrement inacceptable) peut &ecirc;tre utilis&eacute;e dans les instructions de scripts sur toute la page. Remarque&nbsp;: La syntaxe inspir&eacute;e de Visual Basic des instructions <span class="literal">@</span> dans les instructions de compilation conditionnelle n&rsquo;autorise pas les points-virgules &agrave; la fin des instructions.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
D&rsquo;un c&ocirc;t&eacute;, la compilation conditionnelle pourrait &ecirc;tre utile pour le d&eacute;ploiement sur IE uniquement, pour le tri des anciennes versions de Microsoft Internet Explorer et des nouvelles fonctionnalit&eacute;s de langue qui g&eacute;n&eacute;reraient des erreurs de compilation (comme les constructions <span class="literal">try-catch</span>). De telles instructions ne se compilent que dans des situations de versions tr&egrave;s contr&ocirc;lables. Cependant, dans un contexte de d&eacute;veloppement pour des navigateurs de diff&eacute;rentes marques, vous trouverez au mieux des applications con&ccedil;ues &agrave; des fins de d&eacute;bogage pour IE uniquement, mais probablement pas pour le d&eacute;ploiement r&eacute;el d&rsquo;applications.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td colspan="2"><p>
Reportez-vous &agrave; la section ci-dessus.
</p></td>
</tr>
</table>
</div>
<div id="@if">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">@cc_on, @if, @end, @set</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">s.o.</span> IE <span class="emphasis">4(Win)</span> ECMA <span class="emphasis">s.o.</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
IE pour Windows comprend une fonctionnalit&eacute; de scripts appel&eacute;e <span class="emphasis">compilation conditionnelle</span>. Il s&rsquo;agit d&rsquo;un mode qui, une fois qu&rsquo;il est activ&eacute; par le biais de l&rsquo;instruction <span class="literal">@cc_on</span>, permet aux instructions JScript de s&rsquo;ex&eacute;cuter dans des conditions testables au sein de cet environnement conditionnel. Si vous entourez les instructions de compilation conditionnelle de commentaires JavaScript, les instructions conditionnelles ne s&rsquo;ex&eacute;cutent que sur IE 4 et versions ult&eacute;rieures pour Windows, sans entrer en conflit avec les autres navigateurs.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
Cette partie &laquo;&nbsp;conditionnelle&nbsp;&raquo; provient de nombreuses propri&eacute;t&eacute;s globales (toutes pr&eacute;c&eacute;d&eacute;es du symbole <span class="literal">@</span>) qui r&eacute;v&egrave;lent des propri&eacute;t&eacute;s d&rsquo;environnement, telles que la version du moteur de script, le syst&egrave;me d&rsquo;exploitation et le type de processeur. Toutes ces informations sont disponibles &agrave; partir des propri&eacute;t&eacute;s de l&rsquo;objet <span class="literal">navigator</span> sur une vaste gamme de navigateurs, il ne s&rsquo;agit donc pas d&rsquo;informations uniques disponibles seulement pour cet environnement conditionnel.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
Pour activer la compilation conditionnelle, incluez l&rsquo;instruction suivante dans votre script&nbsp;:
</p>
<span class="PROGRAMLISTING"><pre>/*@cc_on @*/</pre></span>
</td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
Il s&rsquo;agit d&rsquo;un commutateur &agrave; sens unique&nbsp;: une fois que le mode est activ&eacute;, il ne peut plus &ecirc;tre d&eacute;sactiv&eacute; dans la page consid&eacute;r&eacute;e.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
Le fragment suivant montre comment l&rsquo;instruction <span class="literal">@if</span> et les instructions connexes affichent des informations d&rsquo;environnement dans la barre de statut de la fen&ecirc;tre si le navigateur ex&eacute;cute JScript version 5.6 ou ult&eacute;rieure (IE 6 ou version plus r&eacute;cente)&nbsp;:
</p>
<span class="PROGRAMLISTING"><pre>/*@cc_on @*/
/*@if (@_jscript_version&gt;= 5.6 &amp;&amp; @_x86)
    status = &quot;Now running JScript version &quot; + @_jscript_version + 
    &quot; with Intel inside.&quot;;
   @else @*/
    status = &quot;Have a nice day.&quot;;
/*@end @*/ </pre></span>
</td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
L&rsquo;instruction <span class="literal">@set</span> vous permet d&rsquo;affecter une valeur num&eacute;rique ou bool&eacute;enne (pas de cha&icirc;nes) &agrave; une variable (une variable avec un pr&eacute;fixe <span class="literal">@</span>) au sein d&rsquo;une section de compilation conditionnelle&nbsp;:
</p>
<span class="PROGRAMLISTING"><pre>@set @isOK = @_win32</pre></span>
</td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
Une fois initialis&eacute;e, cette variable (y compris son identifiant autrement inacceptable) peut &ecirc;tre utilis&eacute;e dans les instructions de scripts sur toute la page. Remarque&nbsp;: La syntaxe inspir&eacute;e de Visual Basic des instructions <span class="literal">@</span> dans les instructions de compilation conditionnelle n&rsquo;autorise pas les points-virgules &agrave; la fin des instructions.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
D&rsquo;un c&ocirc;t&eacute;, la compilation conditionnelle pourrait &ecirc;tre utile pour le d&eacute;ploiement sur IE uniquement, pour le tri des anciennes versions de Microsoft Internet Explorer et des nouvelles fonctionnalit&eacute;s de langue qui g&eacute;n&eacute;reraient des erreurs de compilation (comme les constructions <span class="literal">try-catch</span>). De telles instructions ne se compilent que dans des situations de versions tr&egrave;s contr&ocirc;lables. Cependant, dans un contexte de d&eacute;veloppement pour des navigateurs de diff&eacute;rentes marques, vous trouverez au mieux des applications con&ccedil;ues &agrave; des fins de d&eacute;bogage pour IE uniquement, mais probablement pas pour le d&eacute;ploiement r&eacute;el d&rsquo;applications.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td colspan="2"><p>
Reportez-vous &agrave; la section ci-dessus.
</p></td>
</tr>
</table>
</div>
<div id="@end">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">@cc_on, @if, @end, @set</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">s.o.</span> IE <span class="emphasis">4(Win)</span> ECMA <span class="emphasis">s.o.</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
IE pour Windows comprend une fonctionnalit&eacute; de scripts appel&eacute;e <span class="emphasis">compilation conditionnelle</span>. Il s&rsquo;agit d&rsquo;un mode qui, une fois qu&rsquo;il est activ&eacute; par le biais de l&rsquo;instruction <span class="literal">@cc_on</span>, permet aux instructions JScript de s&rsquo;ex&eacute;cuter dans des conditions testables au sein de cet environnement conditionnel. Si vous entourez les instructions de compilation conditionnelle de commentaires JavaScript, les instructions conditionnelles ne s&rsquo;ex&eacute;cutent que sur IE 4 et versions ult&eacute;rieures pour Windows, sans entrer en conflit avec les autres navigateurs.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
Cette partie &laquo;&nbsp;conditionnelle&nbsp;&raquo; provient de nombreuses propri&eacute;t&eacute;s globales (toutes pr&eacute;c&eacute;d&eacute;es du symbole <span class="literal">@</span>) qui r&eacute;v&egrave;lent des propri&eacute;t&eacute;s d&rsquo;environnement, telles que la version du moteur de script, le syst&egrave;me d&rsquo;exploitation et le type de processeur. Toutes ces informations sont disponibles &agrave; partir des propri&eacute;t&eacute;s de l&rsquo;objet <span class="literal">navigator</span> sur une vaste gamme de navigateurs, il ne s&rsquo;agit donc pas d&rsquo;informations uniques disponibles seulement pour cet environnement conditionnel.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
Pour activer la compilation conditionnelle, incluez l&rsquo;instruction suivante dans votre script&nbsp;:
</p>
<span class="PROGRAMLISTING"><pre>/*@cc_on @*/</pre></span>
</td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
Il s&rsquo;agit d&rsquo;un commutateur &agrave; sens unique&nbsp;: une fois que le mode est activ&eacute;, il ne peut plus &ecirc;tre d&eacute;sactiv&eacute; dans la page consid&eacute;r&eacute;e.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
Le fragment suivant montre comment l&rsquo;instruction <span class="literal">@if</span> et les instructions connexes affichent des informations d&rsquo;environnement dans la barre de statut de la fen&ecirc;tre si le navigateur ex&eacute;cute JScript version 5.6 ou ult&eacute;rieure (IE 6 ou version plus r&eacute;cente)&nbsp;:
</p>
<span class="PROGRAMLISTING"><pre>/*@cc_on @*/
/*@if (@_jscript_version&gt;= 5.6 &amp;&amp; @_x86)
    status = &quot;Now running JScript version &quot; + @_jscript_version + 
    &quot; with Intel inside.&quot;;
   @else @*/
    status = &quot;Have a nice day.&quot;;
/*@end @*/ </pre></span>
</td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
L&rsquo;instruction <span class="literal">@set</span> vous permet d&rsquo;affecter une valeur num&eacute;rique ou bool&eacute;enne (pas de cha&icirc;nes) &agrave; une variable (une variable avec un pr&eacute;fixe <span class="literal">@</span>) au sein d&rsquo;une section de compilation conditionnelle&nbsp;:
</p>
<span class="PROGRAMLISTING"><pre>@set @isOK = @_win32</pre></span>
</td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
Une fois initialis&eacute;e, cette variable (y compris son identifiant autrement inacceptable) peut &ecirc;tre utilis&eacute;e dans les instructions de scripts sur toute la page. Remarque&nbsp;: La syntaxe inspir&eacute;e de Visual Basic des instructions <span class="literal">@</span> dans les instructions de compilation conditionnelle n&rsquo;autorise pas les points-virgules &agrave; la fin des instructions.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
D&rsquo;un c&ocirc;t&eacute;, la compilation conditionnelle pourrait &ecirc;tre utile pour le d&eacute;ploiement sur IE uniquement, pour le tri des anciennes versions de Microsoft Internet Explorer et des nouvelles fonctionnalit&eacute;s de langue qui g&eacute;n&eacute;reraient des erreurs de compilation (comme les constructions <span class="literal">try-catch</span>). De telles instructions ne se compilent que dans des situations de versions tr&egrave;s contr&ocirc;lables. Cependant, dans un contexte de d&eacute;veloppement pour des navigateurs de diff&eacute;rentes marques, vous trouverez au mieux des applications con&ccedil;ues &agrave; des fins de d&eacute;bogage pour IE uniquement, mais probablement pas pour le d&eacute;ploiement r&eacute;el d&rsquo;applications.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td colspan="2"><p>
Reportez-vous &agrave; la section ci-dessus.
</p></td>
</tr>
</table>
</div>
<div id="@set">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">@cc_on, @if, @end, @set</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">s.o.</span> IE <span class="emphasis">4(Win)</span> ECMA <span class="emphasis">s.o.</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
IE pour Windows comprend une fonctionnalit&eacute; de scripts appel&eacute;e <span class="emphasis">compilation conditionnelle</span>. Il s&rsquo;agit d&rsquo;un mode qui, une fois qu&rsquo;il est activ&eacute; par le biais de l&rsquo;instruction <span class="literal">@cc_on</span>, permet aux instructions JScript de s&rsquo;ex&eacute;cuter dans des conditions testables au sein de cet environnement conditionnel. Si vous entourez les instructions de compilation conditionnelle de commentaires JavaScript, les instructions conditionnelles ne s&rsquo;ex&eacute;cutent que sur IE 4 et versions ult&eacute;rieures pour Windows, sans entrer en conflit avec les autres navigateurs.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
Cette partie &laquo;&nbsp;conditionnelle&nbsp;&raquo; provient de nombreuses propri&eacute;t&eacute;s globales (toutes pr&eacute;c&eacute;d&eacute;es du symbole <span class="literal">@</span>) qui r&eacute;v&egrave;lent des propri&eacute;t&eacute;s d&rsquo;environnement, telles que la version du moteur de script, le syst&egrave;me d&rsquo;exploitation et le type de processeur. Toutes ces informations sont disponibles &agrave; partir des propri&eacute;t&eacute;s de l&rsquo;objet <span class="literal">navigator</span> sur une vaste gamme de navigateurs, il ne s&rsquo;agit donc pas d&rsquo;informations uniques disponibles seulement pour cet environnement conditionnel.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
Pour activer la compilation conditionnelle, incluez l&rsquo;instruction suivante dans votre script&nbsp;:
</p>
<span class="PROGRAMLISTING"><pre>/*@cc_on @*/</pre></span>
</td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
Il s&rsquo;agit d&rsquo;un commutateur &agrave; sens unique&nbsp;: une fois que le mode est activ&eacute;, il ne peut plus &ecirc;tre d&eacute;sactiv&eacute; dans la page consid&eacute;r&eacute;e.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
Le fragment suivant montre comment l&rsquo;instruction <span class="literal">@if</span> et les instructions connexes affichent des informations d&rsquo;environnement dans la barre de statut de la fen&ecirc;tre si le navigateur ex&eacute;cute JScript version 5.6 ou ult&eacute;rieure (IE 6 ou version plus r&eacute;cente)&nbsp;:
</p>
<span class="PROGRAMLISTING"><pre>/*@cc_on @*/
/*@if (@_jscript_version&gt;= 5.6 &amp;&amp; @_x86)
    status = &quot;Now running JScript version &quot; + @_jscript_version + 
    &quot; with Intel inside.&quot;;
   @else @*/
    status = &quot;Have a nice day.&quot;;
/*@end @*/ </pre></span>
</td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
L&rsquo;instruction <span class="literal">@set</span> vous permet d&rsquo;affecter une valeur num&eacute;rique ou bool&eacute;enne (pas de cha&icirc;nes) &agrave; une variable (une variable avec un pr&eacute;fixe <span class="literal">@</span>) au sein d&rsquo;une section de compilation conditionnelle&nbsp;:
</p>
<span class="PROGRAMLISTING"><pre>@set @isOK = @_win32</pre></span>
</td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
Une fois initialis&eacute;e, cette variable (y compris son identifiant autrement inacceptable) peut &ecirc;tre utilis&eacute;e dans les instructions de scripts sur toute la page. Remarque&nbsp;: La syntaxe inspir&eacute;e de Visual Basic des instructions <span class="literal">@</span> dans les instructions de compilation conditionnelle n&rsquo;autorise pas les points-virgules &agrave; la fin des instructions.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
D&rsquo;un c&ocirc;t&eacute;, la compilation conditionnelle pourrait &ecirc;tre utile pour le d&eacute;ploiement sur IE uniquement, pour le tri des anciennes versions de Microsoft Internet Explorer et des nouvelles fonctionnalit&eacute;s de langue qui g&eacute;n&eacute;reraient des erreurs de compilation (comme les constructions <span class="literal">try-catch</span>). De telles instructions ne se compilent que dans des situations de versions tr&egrave;s contr&ocirc;lables. Cependant, dans un contexte de d&eacute;veloppement pour des navigateurs de diff&eacute;rentes marques, vous trouverez au mieux des applications con&ccedil;ues &agrave; des fins de d&eacute;bogage pour IE uniquement, mais probablement pas pour le d&eacute;ploiement r&eacute;el d&rsquo;applications.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td colspan="2"><p>
Reportez-vous &agrave; la section ci-dessus.
</p></td>
</tr>
</table>
</div>
<div id="?:">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">?:</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">2</span> IE <span class="emphasis">3</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
Cet op&eacute;rateur fournit une syntaxe abr&eacute;g&eacute;e pour une structure de contr&ocirc;le <span class="literal">if/else</span>. Le d&eacute;ploiement de cet op&eacute;rateur implique trois composants: une condition et deux instructions. Si la condition est &eacute;valu&eacute;e comme <span class="literal">true</span>, la premi&egrave;re instruction est ex&eacute;cut&eacute;e; dans le cas contraire, c'est la seconde. La syntaxe se pr&eacute;sente comme suit:
</p>
<span class="PROGRAMLISTING">
<pre><var class="replaceable">condition </var>?<var class="replaceable"> statement1 </var>:<var class="replaceable"> statement2</var></pre>
</span> </td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
Vous pouvez imbriquer ces op&eacute;rateurs afin d&rsquo;ajouter des chemins de d&eacute;cision suppl&eacute;mentaires au sein d&rsquo;une m&ecirc;me instruction. Dans la syntaxe suivante, si <var class="replaceable">conditionA</var> est &eacute;valu&eacute;e &agrave; <span class="literal">false</span>, <var class="replaceable">conditionB</var> est &eacute;valu&eacute;e et l&rsquo;expression enti&egrave;re renvoie la valeur de <var class="replaceable">statement2</var> ou <var class="replaceable">statement3</var> selon les r&eacute;sultats de <var class="replaceable">conditionB</var>.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
Cet op&eacute;rateur n'est abr&eacute;g&eacute; qu'en apparence. Il appelle le m&ecirc;me traitement interne qu'une construction <span class="literal">if...else</span>.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>var newColor = (temp &gt; 100) ? &quot;red&quot; : &quot;blue&quot;;</pre>
</span></td>
</tr>
</table>
</div>
<div id="continue">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">continue</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">2</span> IE <span class="emphasis">3</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
Interrompt l'it&eacute;ration consid&eacute;r&eacute;e de la boucle et retourne au d&eacute;but de celle-ci pour recommencer (en ex&eacute;cutant l'expression mise &agrave; jour &eacute;ventuellement sp&eacute;cifi&eacute;e dans une boucle <span class="literal">for</span>). Si vous utilisez des constructions de boucle imbriqu&eacute;e, affectez des &eacute;tiquettes &agrave; chaque calque imbriqu&eacute;, puis utilisez l'&eacute;tiquette de votre choix comme param&egrave;tre de l'instruction <span class="literal">continue</span>. Voir l'instruction <span class="literal">label</span> (uniquement disponible depuis Navigator4 et Internet Explorer4).
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>outerLoop:
for (var i = 0; i &lt;= maxValue1; i++) {
    for (var j = 0; j &lt;= maxValue2; j++) {
        if (j*i == magic2) {
            continue outerLoop;
        }
    }
}</pre>
</span></td>
</tr>
</table>
</div>
<div id="/char">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">char</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">2</span> IE <span class="emphasis">3</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
JavaScript fournit un m&eacute;canisme permettant d&rsquo;inclure des caract&egrave;res d&rsquo;espace blanc consid&eacute;r&eacute;s (parfois appel&eacute;s codes de contr&ocirc;le) dans les cha&icirc;nes, ainsi que des symboles qui entrent autrement en conflit avec la repr&eacute;sentation de cha&icirc;nes. La cl&eacute; est la barre oblique inverse (<span class="literal">\\</span>), suivie imm&eacute;diatement d&rsquo;un seul caract&egrave;re ayant une signification particuli&egrave;re. Le tableau suivant montre les caract&egrave;res d&rsquo;&eacute;chappement reconnus et leur signification.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
Ces caract&egrave;res sont pratiques pour le texte des bo&icirc;tes de dialogue d&rsquo;alerte, de confirmation et d&rsquo;invite. Par exemple, si vous vouliez afficher plusieurs paragraphes avec une ligne blanche entre eux dans une bo&icirc;te d&rsquo;alerte, vous ins&eacute;reriez des caract&egrave;res de changement de ligne&nbsp;:
</p>
<span class="PROGRAMLISTING"><pre>alert(&quot;First paragraph.\n\nSecond paragraph.&quot;)</pre></span>
</td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
Remarque&nbsp;: Ces caract&egrave;res s&rsquo;appliquent aux cha&icirc;nes et n&rsquo;influencent pas le formatage du contenu HTML pour les retours chariot.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><table border="1">
<tbody>
<tr>
<th>S&eacute;quence d&rsquo;&eacute;chappement</th>
<th>Description</th>
</tr>
<tr>
<td><span class="literal">\\b</span></td>
<td>Retour arri&egrave;re</td>
</tr>
<tr>
<td><span class="literal">\\t</span></td>
<td>Tabulation horizontale</td>
</tr>
<tr>
<td><span class="literal">\\n</span></td>
<td>Changement de ligne (nouvelle ligne)</td>
</tr>
<tr>
<td><span class="literal">\\v</span></td>
<td>Tabulation verticale</td>
</tr>
<tr>
<td><span class="literal">\\f</span></td>
<td>Changement de formulaire</td>
</tr>
<tr>
<td><span class="literal">\\r</span></td>
<td>Retour chariot</td>
</tr>
<tr>
<td><span class="literal">\&quot;</span></td>
<td>Guillemet double &quot;</td>
</tr>
<tr>
<td><span class="literal">\'</span></td>
<td>Guillemet simple '</td>
</tr>
<tr>
<td><span class="literal">\\</span></td>
<td>Barre oblique inverse</td>
</tr>
</tbody>
</table></td>
</tr>
</table>
</div>
<div id="-">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">&mdash;</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">2</span> IE <span class="emphasis">3</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
Cet op&eacute;rateur unaire soustrait 1 de la valeur consid&eacute;r&eacute;e d'une expression variable. Vous pouvez placer l'op&eacute;rateur devant ou derri&egrave;re la variable, en fonction de l'effet souhait&eacute;. Lorsque l'op&eacute;rateur se trouve devant la variable, cette derni&egrave;re est d&eacute;cr&eacute;ment&eacute;e avant son &eacute;valuation dans l'instruction consid&eacute;r&eacute;e. Par exemple, dans la s&eacute;quence suivante:
</p>
<span class="PROGRAMLISTING"><pre>var a, b;
a = 5;
b = --a;</pre></span>
</td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
un est soustrait de <span class="literal">a</span> avant d&rsquo;&ecirc;tre affect&eacute; &agrave; <span class="literal">b</span>. Ainsi, <span class="literal">b</span> et <span class="literal">a</span> sont tous deux 4 &agrave; la fin de ces instructions. En revanche, dans la s&eacute;quence suivante:
</p>
<span class="PROGRAMLISTING"><pre>var a, b;
a = 5;
b = a--;</pre></span>
</td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
la soustraction s&rsquo;effectue apr&egrave;s l&rsquo;affectation de <span class="literal">a</span> &agrave; <span class="literal">b</span>. Une fois les instructions termin&eacute;es, <span class="literal">b</span> est 5 et <span class="literal">a</span> est 4.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
Ce comportement influence le mode de d&eacute;finition et d'utilisation des variables de comptage de boucle <span class="literal">for</span>. G&eacute;n&eacute;ralement, un compteur de boucle, qui d&eacute;compte &agrave; partir d'une valeur maximale, commence &agrave; d&eacute;cr&eacute;menter une fois les instructions de la boucle ex&eacute;cut&eacute;es. La plupart des compteurs de boucle placent donc l'op&eacute;rateur derri&egrave;re la variable du compteur:
</p>
<span class="PROGRAMLISTING"><pre>for (var i = 10; i&gt;=0; i--) {...} </pre></span>
</td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>--n
n--</pre>
</span></td>
</tr>
</table>
</div>
<div id="delete">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">delete</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">4</span> IE <span class="emphasis">4</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
L&rsquo;op&eacute;rateur <span class="literal">delete</span> supprime une propri&eacute;t&eacute; d'un objet (par exemple, une propri&eacute;t&eacute; prototype qui a &eacute;t&eacute; pr&eacute;c&eacute;demment ajout&eacute;e &agrave; une instance d'objet statique) ou un &eacute;l&eacute;ment d'un tableau g&eacute;n&eacute;r&eacute; par script. La suppression d&rsquo;une entr&eacute;e de tableau ne modifie pas la longueur du tableau ou les index num&eacute;riques des &eacute;l&eacute;ments existants. Au lieu de cela, la valeur de l&rsquo;&eacute;l&eacute;ment supprim&eacute; est simplement <span class="literal">undefined</span>. L&rsquo;op&eacute;rateur <span class="literal">delete</span> n&rsquo;est pas un outil de gestion de la m&eacute;moire.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>delete myString.author;</pre>
</span></td>
</tr>
</table>
</div>
<div id="/">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">/</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">2</span> IE <span class="emphasis">3</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
Cet op&eacute;rateur divise le nombre sur sa gauche par le nombre sur sa droite. Les deux op&eacute;randes doivent &ecirc;tre des nombres. Une expression contenant cet op&eacute;rateur produit un nombre.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>var myQuotient = number1 / number2;</pre>
</span></td>
</tr>
</table>
</div>
<div id="do/while">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">do/while</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">4</span> IE <span class="emphasis">4</span> ECMA <span class="emphasis">3</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
Ex&eacute;cute des instructions en boucle lorsqu'une condition est vraie. La condition &eacute;tant test&eacute;e &agrave; la fin de la boucle, les instructions qu'elle contient sont toujours ex&eacute;cut&eacute;es au moins une fois. Il est imp&eacute;ratif que la valeur de l'expression constituant la condition soit potentiellement modifi&eacute;e dans les instructions. Dans le cas contraire, la boucle est infinie.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>var i = 1;
do
    window.status = &quot;Loop number &quot; + i++;
} while (i &lt;= 10)
window.status = &quot;&quot;;</pre>
</span></td>
</tr>
</table>
</div>
<div id="==">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">==</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">2</span> IE <span class="emphasis">3</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
Cet op&eacute;rateur compare les valeurs de deux op&eacute;randes et renvoie un r&eacute;sultat bool&eacute;en. Le comportement de cet op&eacute;rateur varie en fonction de la version de JavaScript sp&eacute;cifi&eacute;e pour l'&eacute;l&eacute;ment <span class="literal">script</span>. Si l'attribut <span class="literal">language</span> est param&eacute;tr&eacute; sur <span class="literal">JavaScript</span> ou <span class="literal">JavaScript1.1</span>, certains op&eacute;randes sont automatiquement convertis de la mani&egrave;re indiqu&eacute;e dans le tableau ci-dessous.
</p>
<table border="1">
<tbody>
<tr>
<th>Op&eacute;rande de gauche</th>
<th>Op&eacute;rande de droite</th>
<th>Description</th>
</tr>
<tr>
<td>R&eacute;f&eacute;rence d'objet</td>
<td>R&eacute;f&eacute;rence d'objet</td>
<td>Compare l'&eacute;valuation de r&eacute;f&eacute;rences d'objet.</td>
</tr>
<tr>
<td>N&rsquo;importe quel type de donn&eacute;es</td>
<td>Boolean</td>
<td>Convertissent un op&eacute;rande bool&eacute;en en nombre (<span class="literal">1</span> pour <span class="literal">true</literal>; <span class="literal">0</span> pour <span class="literal">false</span>) et comparent &agrave; un autre op&eacute;rande. </td>
</tr>
<tr>
<td>R&eacute;f&eacute;rence d'objet</td>
<td>String</td>
<td>Convertit un objet en cha&icirc;ne (&lt;i&gt;via&lt;/i&gt; <span class="literal">toString()</span>), puis compare les cha&icirc;nes. </td>
</tr>
<tr>
<td>String</td>
<td>Nombre</td>
<td>Convertit une cha&icirc;ne en nombre, puis compare les valeurs num&eacute;riques.</td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
Navigator 4 et les versions ult&eacute;rieures utilisent des conversions de valeurs&nbsp;l&eacute;g&egrave;rement diff&eacute;rentes pour d&eacute;terminer l&rsquo;&eacute;galit&eacute; lorsque vous d&eacute;finissez l&rsquo;&eacute;l&eacute;ment <span class="literal">script</span> sur <span class="literal">language=&quot;JavaScript1.2&quot;</span>. Le navigateur est plus &ldquo;litt&eacute;ral&rdquo; en mati&egrave;re d'&eacute;galit&eacute;, ce qui signifie qu'il ne convertit pas automatiquement les donn&eacute;es. Ainsi, alors que l'expression
</p>
<span class="PROGRAMLISTING"><pre>123 == &quot;123&quot;</pre></span>
</td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
est presque toujours &eacute;valu&eacute;e comme <span class="literal">true</span> en raison de la conversion automatique du type de donn&eacute;es, Navigator4 et les versions ult&eacute;rieures l'&eacute;valuent comme <span class="literal">false</span> dans les instructions de scripts explicitement &eacute;crits en JavaScript1.2. Comme les normes du DOM et XHTML plus r&eacute;centes ne fournissent pas d&rsquo;endroit o&ugrave; sp&eacute;cifier les versions du langage de script, &eacute;vitez ces situations particuli&egrave;res. Si vos scripts n&eacute;cessitent des tests pour l&rsquo;&eacute;galit&eacute; absolue des op&eacute;randes, utilisez plut&ocirc;t l&rsquo;op&eacute;rateur d&rsquo;identit&eacute; le plus r&eacute;cent <span class="literal">===</span>. Pour les tests d&rsquo;&eacute;galit&eacute; des valeurs typiques, les op&eacute;rateurs d&rsquo;&eacute;galit&eacute; standards fonctionnent parfaitement.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
Quelle que soit la version, si vous voulez comparer les valeurs d'objets (par exemple, de cha&icirc;nes explicitement g&eacute;n&eacute;r&eacute;es avec le constructeur d'objet <span class="literal">new</span> <span class="literal">String( )</span>), vous devez comparer les valeurs d&eacute;riv&eacute;es de m&eacute;thodes telles que <span class="literal">toString( )</span> ou <span class="literal">valueOf( )</span>.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>if (n == m) {
    ...
}</pre>
</span></td>
</tr>
</table>
</div>
<div id=">=">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">&gt;=</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">2</span> IE <span class="emphasis">3</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
Cet op&eacute;rateur compare les valeurs des op&eacute;randes situ&eacute;s de part et d'autre. Si la valeur num&eacute;rique de l'op&eacute;rande de gauche est sup&eacute;rieure ou &eacute;gale &agrave; celle de l'op&eacute;rande de droite, l'expression est &eacute;valu&eacute;e comme <span class="literal">true</span>. Pour comparer ces valeurs num&eacute;riques, les cha&icirc;nes de caract&egrave;res sont converties en valeurs Unicode.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>if (a &gt;= b) {
    ...
}</pre>
</span></td>
</tr>
</table>
</div>
<div id=">">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">&gt;</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">2</span> IE <span class="emphasis">3</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
Cet op&eacute;rateur compare les valeurs des op&eacute;randes situ&eacute;s de part et d'autre. Si la valeur num&eacute;rique de l'op&eacute;rande de gauche est sup&eacute;rieure &agrave; celle de l'op&eacute;rande de droite, l'expression est &eacute;valu&eacute;e comme <span class="literal">true</span>. Pour comparer les valeurs, les cha&icirc;nes de caract&egrave;res sont converties en valeurs Unicode.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>if (a &gt; b) {
    ...
}</pre>
</span></td>
</tr>
</table>
</div>
<div id="if">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">if</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">2</span> IE <span class="emphasis">3</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
Instruction conditionnelle simple qui pr&eacute;voit un chemin d'ex&eacute;cution alternatif.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>if (myDateObj.getMonth( ) == 1) {
    calcMonthLength( );
}</pre>
</span></td>
</tr>
</table>
</div>
<div id="if/else">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">if/else</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">2</span> IE <span class="emphasis">3</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
Instruction conditionnelle qui pr&eacute;voit deux chemins d'ex&eacute;cution, en fonction du r&eacute;sultat de la condition. Vous pouvez imbriquer une autre instruction <span class="literal">if</span> ou <span class="literal">if</span>/<span class="literal">else</span> dans chaque chemin de l'instruction <span class="literal">if</span>/<span class="literal">else</span>.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>var theMonth = myDateObj.getMonth( );
if (theMonth == 1) {
    monLength = calcLeapMonthLength( );
else
    monLength = calcMonthLength(theMonth);
}</pre>
</span></td>
</tr>
</table>
</div>
<div id="in">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">in</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">6</span> IE <span class="emphasis">5.5(Win)</span> ECMA <span class="emphasis">s.o.</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
L&rsquo;op&eacute;rateur <span class="literal">in</span> permet aux scripts de d&eacute;couvrir rapidement si une propri&eacute;t&eacute; ou une m&eacute;thode particuli&egrave;re est impl&eacute;ment&eacute;e pour un objet. L&rsquo;op&eacute;rande gauche est une cha&icirc;ne contenant le nom de la propri&eacute;t&eacute; ou m&eacute;thode (nom de m&eacute;thode sans parenth&egrave;ses), alors que l&rsquo;op&eacute;rande droit est une r&eacute;f&eacute;rence &agrave; l&rsquo;objet. Si votre exploration n&eacute;cessite des r&eacute;f&eacute;rences DOM avec des points, placez-les dans le c&ocirc;t&eacute; r&eacute;f&eacute;rence objet de l&rsquo;expression. In other words, instead of trying <span class="literal">&quot;style.filter&quot; in</span> <span class="literal">document.body</span>, use <span class="literal">&quot;filter&quot; in document.body.style</span>. Si plus de navigateurs impl&eacute;mentaient cet op&eacute;rateur ECMA &agrave; venir, il s&rsquo;agirait d&rsquo;un outil utile pour la d&eacute;tection d&rsquo;objets.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>if (&quot;createDocument&quot; in document.implementation) {
    // go ahead and use document.implementation.createDocument( )
}</pre>
</span></td>
</tr>
</table>
</div>
<div id="++">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">++</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">2</span> IE <span class="emphasis">3</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
Cet op&eacute;rateur unaire ajoute 1 &agrave; la valeur consid&eacute;r&eacute;e d'une expression variable. Vous pouvez placer l'op&eacute;rateur devant ou derri&egrave;re la variable, en fonction de l'effet souhait&eacute;. Lorsque l'op&eacute;rateur se trouve devant la variable, cette derni&egrave;re est incr&eacute;ment&eacute;e avant son &eacute;valuation dans l'instruction en question. Par exemple, dans la s&eacute;quence suivante:
</p>
<span class="PROGRAMLISTING"><pre>var a, b;
a = 5;
b = ++a;</pre></span>
</td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
1 est ajout&eacute; &agrave; <span class="literal">a</span> avant d&rsquo;&ecirc;tre affect&eacute; &agrave; <span class="literal">b</span>. Ainsi, <span class="literal">b</span> et <span class="literal">a</span> sont tous deux 6 &agrave; la fin de ces instructions. En revanche, dans la s&eacute;quence suivante:
</p>
<span class="PROGRAMLISTING"><pre>var a, b;
a = 5;
b = a++;</pre></span>
</td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
l&rsquo;addition s&rsquo;effectue apr&egrave;s l&rsquo;affectation de <span class="literal">a</span> &agrave; <span class="literal">b</span>. Une fois les instructions termin&eacute;es, <span class="literal">b</span> est 5 et <span class="literal">a</span> est 6.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
Ce comportement influence le mode de d&eacute;finition et d'utilisation des variables de comptage de boucle <span class="literal">for</span>. G&eacute;n&eacute;ralement, un compteur de boucle qui commence &agrave; partir d'une valeur minimale, incr&eacute;mente le compteur une fois les instructions de la boucle ex&eacute;cut&eacute;es. La plupart des compteurs de boucle placent donc l'op&eacute;rateur derri&egrave;re la variable du compteur&nbsp;:
</p>
<programlisting>for (var i = 10; i&gt;=0; i++) {...} </programlisting>
</td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>++n
		n++</pre>
</span></td>
</tr>
</table>
</div>
<div id="!=">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name"><span class="emphasis">!</span>=</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">2</span> IE <span class="emphasis">3</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
Cet op&eacute;rateur compare les valeurs de deux op&eacute;randes et renvoie un r&eacute;sultat bool&eacute;en. Le comportement de cet op&eacute;rateur varie en fonction de la version de JavaScript sp&eacute;cifi&eacute;e pour l'&eacute;l&eacute;ment <span class="literal">script</span>. Si l'attribut <span class="literal">language</span> est <span class="literal">JavaScript</span> ou <span class="literal">JavaScript1.1</span>, certains op&eacute;randes sont automatiquement convertis, comme pour l'op&eacute;rateur d'&eacute;galit&eacute; (<span class="literal">==</span>). La situation diff&egrave;re l&eacute;g&egrave;rement dans Navigator 4 et versions ult&eacute;rieures lorsque l'&eacute;l&eacute;ment <span class="literal">script</span> est param&eacute;tr&eacute; sur <span class="literal">language=&quot;JavaScript1.2&quot;</span>. Le navigateur est plus &ldquo;litt&eacute;ral&rdquo; en mati&egrave;re d'in&eacute;galit&eacute;, ce qui signifie qu'il ne convertit pas automatiquement les donn&eacute;es. Ainsi, alors que l'expression
</p>
<span class="PROGRAMLISTING"><pre>123 != &quot;123&quot;</pre></span>
</td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
est presque toujours &eacute;valu&eacute;e comme <span class="literal">false</span> en raison de la conversion automatique du type de donn&eacute;es, Navigator4 et les versions ult&eacute;rieures l'&eacute;valuent comme <span class="literal">true</span> dans les instructions de script explicitement &eacute;crites en JavaScript1.2. Comme les normes du DOM et XHTML plus r&eacute;centes ne fournissent pas d&rsquo;endroit o&ugrave; sp&eacute;cifier les versions du langage de script, &eacute;vitez ces situations particuli&egrave;res. Si vos scripts n&eacute;cessitent des tests pour l&rsquo;in&eacute;galit&eacute; absolue des op&eacute;randes, utilisez plut&ocirc;t l&rsquo;op&eacute;rateur d&rsquo;identit&eacute; <span class="literal">!==</literal> le plus r&eacute;cent. Pour les tests d&rsquo;in&eacute;galit&eacute; des valeurs typiques, les op&eacute;rateurs d&rsquo;in&eacute;galit&eacute; standards fonctionnent parfaitement.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
Quelle que soit la version, si vous voulez comparer les valeurs d'objets (par exemple, de cha&icirc;nes explicitement g&eacute;n&eacute;r&eacute;es avec le constructeur d'objet <span class="literal">new</span> <span class="literal">String( )</span>), vous devez comparer les valeurs d&eacute;riv&eacute;es de m&eacute;thodes telles que <span class="literal">toString( )</span> ou <span class="literal">valueOf( )</span>.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>if (n != m) {
    ...
}</pre>
</span></td>
</tr>
</table>
</div>
<div id="instanceof">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">instanceof</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">6</span> IE <span class="emphasis">5(Win)</span> ECMA <span class="emphasis">s.o.</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
L&rsquo;op&eacute;rateur <span class="literal">instanceof</span> permet aux scripts de d&eacute;terminer si un objet (op&eacute;rande gauche) est une instance d&rsquo;un objet connu (ou h&eacute;rit&eacute;e de l&rsquo;objet connu). Par certains c&ocirc;t&eacute;s, cet op&eacute;rateur est similaire &agrave; l&rsquo;op&eacute;rateur <span class="literal">typeof</span>, mais au lieu de renvoyer un type d&rsquo;objet global, une expression avec l&rsquo;op&eacute;rateur <span class="literal">instanceof</span> renvoie une valeur bool&eacute;enne sp&eacute;cifiant un type d&rsquo;objet plus sp&eacute;cifique. En fait, vous pouvez tester un objet par rapport &agrave; des objets personnalis&eacute;s, dans les prototypes d&rsquo;objets Netscape 6 et de l&rsquo;arborescence du DOM. Alors que l&rsquo;op&eacute;rateur <span class="literal">typeof</span> d&rsquo;un tableau renvoie <span class="literal">object</span>, vous pouvez d&eacute;couvrir si un objet a &eacute;t&eacute; instanci&eacute; sp&eacute;cifiquement comme tableau&nbsp;:
</p>
<span class="PROGRAMLISTING"><pre>myVar instanceof Array</pre></span>
</td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
Remarquez cependant que si l&rsquo;expression ci-dessus est &eacute;valu&eacute;e comme <span class="literal">true</span>, c&rsquo;est aussi le cas de&nbsp;:
</p>
<span class="PROGRAMLISTING"><pre>myVar instanceof Object</pre></span>
</td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
Un tableau est un descendant de l&rsquo;objet <span class="literal">Object</span> racine et est donc aussi une instance de cet objet racine.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
Dans Netscape 6, un ou les deux op&eacute;randes peuvent aussi &ecirc;tre des r&eacute;f&eacute;rences aux objets du prototype du DOM. Ainsi, l&rsquo;expression suivante est l&eacute;gale et op&eacute;rationnelle dans Netscape 6&nbsp;:
</p>
<span class="PROGRAMLISTING"><pre>document.getElementById(&quot;widget&quot;) instanceof HTMLDivElement </pre></span>
</td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>if (theVal instanceof Array) {
    // go ahead and treat theVal as an array
}</pre>
</span></td>
</tr>
</table>
</div>
<div id="<=">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">&lt;=</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">2</span> IE <span class="emphasis">3</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
Cet op&eacute;rateur compare les valeurs des op&eacute;randes situ&eacute;s de part et d'autre. Si la valeur num&eacute;rique de l'op&eacute;rande de gauche est inf&eacute;rieure ou &eacute;gale &agrave; celle de l'op&eacute;rande de droite, l'expression est &eacute;valu&eacute;e comme <span class="literal">true</span>. Pour comparer ces valeurs num&eacute;riques, les cha&icirc;nes de caract&egrave;res sont converties en valeurs Unicode.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>if (a &lt;= b) {
    ...
}</pre>
</span></td>
</tr>
</table>
</div>
<div id="<">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">&lt;</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">2</span> IE <span class="emphasis">3</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
Cet op&eacute;rateur compare les valeurs des op&eacute;randes situ&eacute;s de part et d'autre. Si la valeur num&eacute;rique de l'op&eacute;rande de gauche est inf&eacute;rieure &agrave; celle de l'op&eacute;rande de droite, l'expression est &eacute;valu&eacute;e comme <span class="literal">true</span>. Pour comparer les valeurs, les cha&icirc;nes de caract&egrave;res sont converties en valeurs Unicode.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>if (a &lt; b) {
    ...
}</pre>
</span></td>
</tr>
</table>
</div>
<div id="%">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">%</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">2</span> IE <span class="emphasis">3</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
Cet op&eacute;rateur divise le nombre sur sa gauche par le nombre sur sa droite. Si la division produit un reste, l'expression est &eacute;valu&eacute;e &agrave; la valeur de ce reste entier. En l'absence de reste, la valeur renvoy&eacute;e est z&eacute;ro. Les deux op&eacute;randes doivent &ecirc;tre des nombres. Une expression contenant cet op&eacute;rateur produit un nombre. M&ecirc;me si la valeur du reste (modulo) ne vous int&eacute;resse pas, cet op&eacute;rateur permet de d&eacute;terminer rapidement si deux valeurs sont multiples.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>if ((dayCount % 7) &gt; 0) {
    ...
}</pre>
</span></td>
</tr>
</table>
</div>
<div id="*">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">*</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">2</span> IE <span class="emphasis">3</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
Cet op&eacute;rateur multiplie le nombre de gauche par le nombre de droite. Les deux op&eacute;randes doivent &ecirc;tre des nombres. Une expression contenant cet op&eacute;rateur produit un nombre.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>var myProduct = <var class="replaceable">number1</var> * <var class="replaceable">number2</var>;</pre>
</span></td>
</tr>
</table>
</div>
<div id="-">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">-</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">2</span> IE <span class="emphasis">3</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
Il s&rsquo;agit de l&rsquo;op&eacute;rateur de n&eacute;gation. Cet op&eacute;rateur unaire inverse la valeur de l'op&eacute;rande. Par exemple, dans les instructions suivantes:
</p>
<span class="PROGRAMLISTING"><pre>a = 5;
b = -a;</pre></span>
</td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
la valeur de <span class="literal">b</span> devient -5. Un op&eacute;rateur de n&eacute;gation appliqu&eacute; &agrave; une valeur n&eacute;gative renvoie une valeur positive.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>var myOpposite = -me;</pre>
</span></td>
</tr>
</table>
</div>
<div id="new">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">new</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">2</span> IE <span class="emphasis">3</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
L&rsquo;op&eacute;rateur <span class="literal">new</span> cr&eacute;e des instances des objets statiques ECMA standards suivants :
</p>
<ul>
<li><span class="LITERAL">Array</span></li>

<li><span class="LITERAL">Boolean</span></li>

<li><span class="LITERAL">Date</span></li>

<li><span class="LITERAL">Fonction</span></li>

<li><span class="LITERAL">Nombre</span></li>

<li><span class="LITERAL">Object</span></li>

<li><span class="LITERAL">RegExp</span></li>

<li><span class="LITERAL">String</span></li>
</ul></td>
</tr>
<tr>
<td colspan="2"><p>
Une expression contenant cet op&eacute;rateur est &eacute;valu&eacute;e comme une instance de l'objet. En d&rsquo;autres termes, lors de l&rsquo;invocation de cet op&eacute;rateur, JavaScript recherche une fonction constructeur du m&ecirc;me nom. Ainsi, l&rsquo;op&eacute;rateur <span class="literal">new</span> fonctionne aussi avec des objets personnalis&eacute;s form&eacute;s par le biais de fonctions constructeurs personnalis&eacute;es. Il fonctionne aussi dans IE pour Windows pour la cr&eacute;ation d&rsquo;instances d&rsquo;objets propri&eacute;taires, tels que les objets ActiveX et VBArray.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
Les r&egrave;gles syntaxiques permettent de nommer l'objet statique, l'objet statique avec des parenth&egrave;ses vides et l'objet statique avec des param&egrave;tres entre parenth&egrave;ses:
</p>
<span class="PROGRAMLISTING"><pre>var myArray = new Array;
var myArray = new Array( );
var myArray = new Array(&quot;Larry&quot;, &quot;Moe&quot;, &quot;Curly&quot;);</pre></span>
</td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
Seuls les deux derniers exemples sont garantis comme fonctionnant dans toutes les versions de navigateur g&eacute;rables par script. A l'exception de l'objet <span class="literal">Date</span>, si vous omettez d'affecter des param&egrave;tres durant la cr&eacute;ation de l'objet d&rsquo;origine, la nouvelle instance cr&eacute;&eacute;e n'a que les propri&eacute;t&eacute;s affect&eacute;es au prototype de l'objet statique.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>var now = new Date( );</pre>
</span></td>
</tr>
</table>
</div>
<div id="!">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name"><span class="emphasis">!</span></td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">2</span> IE <span class="emphasis">3</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
Il s&rsquo;agit de l&rsquo;op&eacute;rateur NOT. Cet op&eacute;rateur unaire est &eacute;valu&eacute; comme la valeur n&eacute;gative d'un op&eacute;rande bool&eacute;en. Il convient d'utiliser l'op&eacute;rateur NOT avec des valeurs bool&eacute;ennes explicites telles que le r&eacute;sultat d'une comparaison ou un param&eacute;trage de propri&eacute;t&eacute; bool&eacute;enne.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>if (a == !b) {
    ...
}</pre>
</span></td>
</tr>
</table>
</div>
<div id="||">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">||</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">2</span> IE <span class="emphasis">3</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
L&rsquo;op&eacute;rateur OR compare deux expressions bool&eacute;ennes pour v&eacute;rifier si elles sont &eacute;gales. Si l'une des deux expressions est &eacute;valu&eacute;e comme <span class="literal">true</span>, le r&eacute;sultat produit par l'op&eacute;rateur <span class="literal">||</span> est &eacute;galement &eacute;valu&eacute; comme <span class="literal">true</literal> si les deux expressions sont &eacute;valu&eacute;es comme <span class="literal">false</span>, l'op&eacute;rateur est &eacute;valu&eacute; comme <span class="literal">false</span>. Une expression bool&eacute;enne peut consister en l'expression d'une comparaison (&agrave; l'aide des nombreux op&eacute;rateurs de comparaison disponibles) ou en une s&eacute;rie d'autres valeurs. La pr&eacute;sentation de l'op&eacute;rateur AND r&eacute;sume les types de donn&eacute;es et valeurs les plus fr&eacute;quents, avec la valeur bool&eacute;enne correspondante.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
Vous pouvez cr&eacute;er des conditions compos&eacute;es &agrave; l'aide de l'op&eacute;rateur <span class="literal">||</span>. Par exemple, si vous voulez v&eacute;rifier si l&rsquo;une des deux conditions ou les deux &agrave; la fois sont vraies, vous pouvez cr&eacute;er une condition telle que: <span class="PROGRAMLISTING"><pre>var userEntry1 = document.forms[0].entry1.value;
var userEntry2 = document.forms[0].entry2.value;
if (userEntry1 || userEntry2) {
    ...
}</pre></span>
</p>
</td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
Dans la condition compos&eacute;e, l'op&eacute;rateur <span class="literal">||</span> recherche si les op&eacute;randes sont <span class="literal">true</span> avant d'&eacute;valuer la condition comme <span class="literal">true</span>. Si l'utilisateur a saisi du texte dans le premier champ, la condition est court-circuit&eacute;e du fait qu'une valeur <span class="literal">true</span> pour un seul op&eacute;rande g&eacute;n&egrave;re un r&eacute;sultat <span class="literal">true</span>. Si l'utilisateur n'a entr&eacute; du texte que dans le second champ, le second op&eacute;rande est &eacute;valu&eacute;. Puisqu'elle &eacute;value comme <span class="literal">true</span> une cha&icirc;ne non vide, la condition est &eacute;valu&eacute;e comme <span class="literal">true</span>. Ce n'est que lorsque les deux op&eacute;randes sont &eacute;valu&eacute;s comme <span class="literal">false</span> que la condition compos&eacute;e est &eacute;valu&eacute;e comme <span class="literal">false</span>.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>if (a &lt;= b || b &gt;= c) {
    ...
}</pre>
</span></td>
</tr>
</table>
</div>
<div id="===">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">===</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">4</span> IE <span class="emphasis">4</span> ECMA <span class="emphasis">2</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
Cet op&eacute;rateur compare les valeurs de deux op&eacute;randes et renvoie un r&eacute;sultat bool&eacute;en. Tant la valeur que le type de donn&eacute;es des deux op&eacute;randes doivent &ecirc;tre identiques pour que l'op&eacute;rateur renvoie <span class="literal">true</span> (pas de conversions de types de donn&eacute;es automatiques). Voir l'op&eacute;rateur d'&eacute;galit&eacute; (<span class="literal">==</span>) pour des comparaisons d&rsquo;&eacute;galit&eacute; moins strictes.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>if (n === m) {
    ...
}</pre>
</span></td>
</tr>
</table>
</div>
<div id="!==">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name"><span class="emphasis">!</span>==</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">3</span> IE <span class="emphasis">4</span> ECMA <span class="emphasis">s.o.</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
Cet op&eacute;rateur compare les valeurs de deux op&eacute;randes et renvoie un r&eacute;sultat bool&eacute;en. Tant la valeur que le type de donn&eacute;es des deux op&eacute;randes doivent &ecirc;tre identiques pour que l'op&eacute;rateur renvoie <span class="literal">false</span>. Pour des comparaisons moins strictes, reportez-vous &agrave; l&rsquo;op&eacute;rateur d&rsquo;in&eacute;galit&eacute; (<span class="literal">!=</span>).
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>if (n !== m) {
    ...
}</pre>
</span></td>
</tr>
</table>
</div>
<div id="for">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">for</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">2</span> IE <span class="emphasis">3</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
Construction permettant l'ex&eacute;cution r&eacute;p&eacute;t&eacute;e d'instructions, g&eacute;n&eacute;ralement pour un nombre de fois pr&eacute;cis d&eacute;termin&eacute;.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>var userEntry = document.forms[0].entry.value;
var oneChar;
for (var i = 0; i &lt; userEntry.length; i++) {
    oneChar = userEntry.charAt(i);
    if (oneChar &lt; &quot;0&quot; || oneChar &gt; &quot;9&quot;) {
        alert(&quot;The entry must be numerals only.&quot;);
    }
}</pre>
</span></td>
</tr>
</table>
</div>
<div id="for/in">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">for/in</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">2</span> IE <span class="emphasis">3</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
Variante de la boucle <span class="literal">for</span> ordinaire, capable d'extraire les noms et valeurs de propri&eacute;t&eacute; d'un objet. Seules les propri&eacute;t&eacute;s (et dans Netscape 6, les m&eacute;thodes) d&eacute;finies comme &eacute;num&eacute;rables par les fonctions internes du navigateur apparaissent dans la sortie de cette construction. Opera 6 prend cette construction en charge uniquement pour les objets g&eacute;n&eacute;r&eacute;s par scripts personnalis&eacute;s.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>function showProps( ) {
    objName = &quot;image&quot;;
    obj = document.images[0];
    var msg = &quot;&quot;;
    for (var i in obj) {
        msg += objName + &quot;.&quot; + i + &quot;=&quot; + obj[i] + &quot;\n&quot;;
    }
    alert(msg);
}</pre>
</span></td>
</tr>
</table>
</div>
<div id="-">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">-</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">2</span> IE <span class="emphasis">3</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
Cet op&eacute;rateur soustrait le nombre de droite du nombre de gauche. Les deux op&eacute;randes doivent &ecirc;tre des nombres. Une expression contenant cet op&eacute;rateur produit un nombre.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>var myDifference = <var class="replaceable">number1</var> - <var class="replaceable">number2</var>;</pre>
</span></td>
</tr>
</table>
</div>
<div id="switch/case">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">switch/case</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">4</span> IE <span class="emphasis">4</span> ECMA <span class="emphasis">3</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
Fournit un raccourci vers des chemins d'ex&eacute;cution pour de nombreuses conditions d'une expression. L&rsquo;instruction <span class="literal">break</span> facultative &agrave; la fin de chaque bloc <span class="literal">case</span> raccourcit l&rsquo;ex&eacute;cution de l&rsquo;instruction <span class="literal">switch</span> et emp&ecirc;che aussi l&rsquo;ex&eacute;cution accidentelle du bloc <span class="literal">default</span> s&rsquo;il est pr&eacute;sent.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>var productList = document.forms[0].prodList;
var chosenItem = productList.options[productList.selectedIndex].value;
switch(chosenItem) {
    case &quot;Small Widget&quot;:
        document.forms[0].price.value = &quot;44.95&quot;;
        break
    case &quot;Medium Widget&quot;:
        document.forms[0].price.value = &quot;54.95&quot;;
        break
    case &quot;Large Widget&quot;:
        document.forms[0].price.value = &quot;64.95&quot;;
        break
    Par d&eacute;faut&nbsp;:
        document.forms[0].price.value = &quot;Nothing Selected&quot;;
}</pre>
</span></td>
</tr>
</table>
</div>
<div id="this">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">this</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">2</span> IE <span class="emphasis">3</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
Fait r&eacute;f&eacute;rence &agrave; l&rsquo;objet consid&eacute;r&eacute;. Par exemple, dans un gestionnaire d'&eacute;v&eacute;nements d'objet de contr&ocirc;le de formulaire, vous pouvez transmettre l'objet comme param&egrave;tre &agrave; la fonction :
</p>
<span class="PROGRAMLISTING"><pre>&lt;input type=&quot;text&quot; name=&quot;ZIP&quot; onchange=&quot;validate(this);&gt;&quot;</pre></span>
</td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
Dans un constructeur d'objet personnalis&eacute;, le mot-cl&eacute; fait r&eacute;f&eacute;rence &agrave; l'objet lui-m&ecirc;me, vous permettant d'affecter des valeurs &agrave; ses propri&eacute;t&eacute;s (tout en cr&eacute;ant les propri&eacute;t&eacute;s) :
</p>
<span class="PROGRAMLISTING"><pre>function CD(label, num, artist) {
    this.label = label;
    this.num = num;
    this.artist = artist;
}</pre></span>
</td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
A l'int&eacute;rieur d'une fonction, le mot-cl&eacute; <span class="literal">this</span> d&eacute;signe l'objet fonction. Cependant, si la fonction est affect&eacute;e comme m&eacute;thode d&rsquo;un constructeur d&rsquo;objets personnalis&eacute;s, <span class="literal">this</span> fait r&eacute;f&eacute;rence &agrave; l&rsquo;instance de l&rsquo;objet dans le contexte duquel la fonction s&rsquo;ex&eacute;cute.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>&lt;input type=&quot;text&quot; name=&quot;phone&quot; onchange=&quot;validate(this.value);&quot;&gt;</pre>
</span></td>
</tr>
</table>
</div>
<div id="throw">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">throw</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">6</span> IE <span class="emphasis">5</span> ECMA <span class="emphasis">3</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
D&eacute;clenche une condition d&rsquo;exception, transmettant une valeur avec l&rsquo;exception. Bien que la valeur que vous transmettiez puisse &ecirc;tre une simple cha&icirc;ne, id&eacute;alement, vous devriez transmettre une instance de l&rsquo;objet <span class="literal">Error</span> JavaScript suffisamment remplie d&rsquo;informations pour qu&rsquo;une instruction catch puisse r&eacute;agir intelligemment &agrave; l&rsquo;erreur. Une instruction <span class="literal">throw</span> doit &ecirc;tre incluse dans la portion <span class="literal">try</span> d&rsquo;une construction <span class="literal">try-catch</span>.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>function processNumber(inputField) {
    try
        var inpVal = parseInt(inputField.value, 10);
        if (isNaN(inpVal)) {
            var msg = &quot;Please enter a number only.&quot;;
            var err = new Error(msg);
            if (!err.message) {
                err.message = msg;
            }
            throw err;
        }
        // process number
    }
    catch (e) {
        alert(e.message);
        inputField.focus( );
        inputField.select( );
    }
}</pre>
</span></td>
</tr>
</table>
</div>
<div id="try/catch">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">try/catch</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">6</span> IE <span class="emphasis">5</span> ECMA <span class="emphasis">3</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
Cette construction fournit une fa&ccedil;on non perturbatrice de pi&eacute;ger les erreurs (exceptions) et de les traiter &eacute;l&eacute;gamment. Les deux parties de cette construction de traitement des exceptions sont obligatoires. Si une erreur se produit dans la portion <span class="literal">try</span>, l&rsquo;ex&eacute;cution passe imm&eacute;diatement &agrave; la portion <span class="literal">catch</span>, o&ugrave; vos scripts peuvent afficher des bo&icirc;tes de dialogue d&rsquo;alerte, modifier des donn&eacute;es ou effectuer toute autre t&acirc;che qui emp&ecirc;che l&rsquo;interpr&eacute;teur JavaScript de d&eacute;clencher un message d&rsquo;erreur g&ecirc;nant. Les exceptions qui se produisent naturellement (c&rsquo;est-&agrave;-dire qui ne sont pas d&eacute;clench&eacute;es par une instruction <span class="literal">throw</span>) transmettent une instance de l&rsquo;objet <span class="literal">Error</span> en tant que param&egrave;tre &agrave; la section <span class="literal">catch</span>. Les instructions au sein de la section <span class="literal">catch</span> peuvent passer en revue les propri&eacute;t&eacute;s de l&rsquo;objet d&rsquo;erreur afin de d&eacute;terminer comment traiter les exceptions qui arrivent &agrave; cet endroit. Ainsi, une portion <span class="literal">catch</span> peut traiter des erreurs de diff&eacute;rents types.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
Vous pouvez utiliser les constructions <span class="literal">try</span>/<span class="literal">catch</span> uniquement dans les navigateurs qui les prennent en charge. Pour prot&eacute;ger les anciens navigateurs de cette construction, placez tout le code affect&eacute; dans une balise &lt;script&gt; n&eacute;cessitant explicitement JavaScript 1.5 ou version ult&eacute;rieure (avec l&rsquo;attribut <span class="literal">language = &quot;JavaScript1.5&quot;</span>).
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>function insertOneNode(baseNode, newNode, position) {
    try
        baseNode.insertBefore(newNode, baseNode.childNodes[position]);
    }
    catch (e) {
        // handle W3C DOM Exception types
        switch (e.name) {
            case &quot;HIERARCHY_REQUEST_ERR&quot; :
                // process bad tree hierarchy reference
                break
            case &quot;NOT_FOUND_ERR&quot; :
                // process bad refNode reference
                break
            Par d&eacute;faut&nbsp;:
                // process all other exceptions
        }
    }
    return true;
}</pre>
</span></td>
</tr>
</table>
</div>
<div id="typeof">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">typeof</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">3</span> IE <span class="emphasis">3</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
L&rsquo;op&eacute;rateur <span class="literal">typeof</span> renvoie l'une des six descriptions sous forme de cha&icirc;ne du type de donn&eacute;es d'une valeur. Les types renvoy&eacute;s sont:
</p>
<ul>
<li><span class="LITERAL">boolean</span></li>

<li><span class="LITERAL">function</span></li>

<li><span class="LITERAL">number</span></li>

<li><span class="LITERAL">object</span></li>

<li><span class="LITERAL">string</span></li>

<li><span class="LITERAL">undefined</span></li>
</ul>
</td>
</tr>
<tr>
<td colspan="2"><p>
Le type d'objet peut &eacute;galement &ecirc;tre un tableau. Toutefois, l'op&eacute;rateur ne fournit pas d'autres informations sur le type d'objet ou tableau de la valeur (reportez-vous &agrave; l&rsquo;op&eacute;rateur <span class="literal">instanceof</span>).
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>if (typeof someVar == &quot;string&quot;) {
    ...
}</pre>
</span></td>
</tr>
</table>
</div>
<div id="void">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">void</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">3</span> IE <span class="emphasis">4</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
Cet op&eacute;rateur unaire &eacute;value l'expression de droite mais renvoie une valeur <span class="literal">undefined</literal> (ind&eacute;finie), m&ecirc;me si l'expression (comme un appel de fonction) est &eacute;valu&eacute;e &agrave; une certaine valeur. Cet op&eacute;rateur est g&eacute;n&eacute;ralement utilis&eacute; avec des pseudo-URL <span class="literal">javascript:</span> appelant des fonctions. Si la fonction renvoie une valeur, celle-ci est ignor&eacute;e par l'expression qui l'a appel&eacute;e.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>&lt;a href=&quot;javascript: void getSound( );&quot; &gt;...&lt;/a&gt;</pre>
</span></td>
</tr>
</table>
</div>
<div id="while">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">while</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">2</span> IE <span class="emphasis">3</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
Ex&eacute;cute des instructions en boucle tant qu'une condition est vraie. La condition &eacute;tant test&eacute;e en d&eacute;but de boucle, il est possible que, dans certains cas, les instructions de la boucle ne s'ex&eacute;cutent pas. Il est imp&eacute;ratif que la valeur de l'expression constituant la condition soit potentiellement modifi&eacute;e dans les instructions. Sinon, la boucle devient infinie.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>var i = 0;
while (!document.forms[0].radioGroup[i].checked) {
    i
}
alert(&quot;You selected item number &quot; + (i+1) + &quot;.&quot;);</pre>
</span></td>
</tr>
</table>
</div>
<div id="with">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">with</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">2</span> IE <span class="emphasis">3</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
L'instruction <span class="literal">with</span> ajoute un objet &agrave; l'&eacute;tendue de chaque instruction imbriqu&eacute;e. Ceci permet de raccourcir le code de certains groupes d'instructions bas&eacute;s sur une r&eacute;f&eacute;rence &agrave; un objet particulier. Remarque: Les constructions <span class="literal">with</span> sont g&eacute;n&eacute;ralement tr&egrave;s inefficaces. Vous pouvez obtenir de meilleures performances en affectant la r&eacute;f&eacute;rence de l&rsquo;objet &agrave; une variable locale et en utilisant cette variable dans votre fonction.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>with (document.forms[0]) {
    name1 = firstName.value;
    name2 = lastName.value;
    mail = eMail.value;
}</pre>
</span></td>
</tr>
</table>
</div>
<div id="return">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">return</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">2</span> IE <span class="emphasis">3</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
Interrompt l'ex&eacute;cution de la fonction consid&eacute;r&eacute;e. Il est possible de placer une instruction <span class="literal">return</span> &agrave; un endroit quelconque de la fonction, y compris dans les structures de contr&ocirc;le. Vous pouvez &eacute;ventuellement sp&eacute;cifier une valeur &agrave; renvoyer &agrave; l'instruction initiale. Cette valeur peut &ecirc;tre n&rsquo;importe quel type de donn&eacute;es JavaScript. Lorsqu'une instruction <span class="literal">return</span> appel&eacute;e &agrave; renvoyer une valeur se trouve dans une boucle ou une autre structure de contr&ocirc;le, il faut pr&eacute;voir une instruction <span class="literal">return</span> pour chaque branche de l'arbre d'ex&eacute;cution, notamment une instruction <span class="literal">return</span> par d&eacute;faut, pour le cas o&ugrave; l'ex&eacute;cution atteindrait la port&eacute;e de l'ex&eacute;cution principale, &agrave; la fin ou pr&egrave;s de la fin de la fonction.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>function validateNumber(form) {
    var oneChar;
    for (var i = 0; i &lt; userEntry.length; i++) {
        oneChar = form.entry.value.charAt(i);
        if (oneChar &lt; &quot;0&quot; || oneChar &gt; &quot;9&quot;) {
            return false
        }
    }
    return true;
}</pre>
</span></td>
</tr>
</table>
</div>
<div id="+=">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">+=</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">2</span> IE <span class="emphasis">3</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
Il s&rsquo;agit de l&rsquo;op&eacute;rateur d&rsquo;ajout par valeur. Cette classe d'op&eacute;rateur combine un op&eacute;rateur d'affectation ordinaire (<span class="literal">=</span>) avec l'un des nombreux autres op&eacute;rateurs, afin de produire l'affectation en effectuant l'op&eacute;ration d&eacute;finie par l'op&eacute;rande de gauche avec la valeur de l'op&eacute;rande de droite. Par exemple, si une variable nomm&eacute;e <span class="literal">a</span> contient une cha&icirc;ne, vous pouvez ajouter une cha&icirc;ne &agrave; la fin de <span class="literal">a</span> &agrave; l'aide de l'op&eacute;rateur <span class="literal">+=</literal>:
</p>
<span class="PROGRAMLISTING"><pre>a += &quot; and some more.&quot;;</pre></span>
</td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
Sans cet op&eacute;rateur d&rsquo;addition d&rsquo;une valeur, l'op&eacute;ration devrait &ecirc;tre structur&eacute;e comme suit:
</p>
<span class="PROGRAMLISTING">
<pre>a = a + &quot; and some more&quot;;</pre>
</span> </td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
Le tableau suivant montre tous les op&eacute;rateurs d'affectation qui fonctionnent de cette mani&egrave;re&nbsp;:
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><table border="1">
<tbody>
<tr>
<th>Op&eacute;rateur</th>
<th>Exemple</th>
<th>Equivalent</th>
</tr>
<tr>
<td> +=</td>
<td> a += b</td>
<td> a = a + b</td>
</tr>
<tr>
<td> -=</td>
<td> a -= b</td>
<td> a = a - b</td>
</tr>
<tr>
<td> *=</td>
<td> a *= b</td>
<td> a = a * b</td>
</tr>
<tr>
<td> /=</td>
<td> a /= b</td>
<td> a = a / b</td>
</tr>
<tr>
<td> %=</td>
<td> a %= b</td>
<td> a = a % b</td>
</tr>
<tr>
<td>&lt;&lt;=</td>
<td> a &lt;&lt;= b</td>
<td> a = a &lt;&lt; b</td>
</tr>
<tr>
<td>&gt;&gt;=</td>
<td> a &gt;&gt;= b</td>
<td> a = a &gt;&gt; b</td>
</tr>
<tr>
<td>&gt;&gt;&gt;=</td>
<td> a &gt;&gt;&gt;= b</td>
<td> a = a &gt;&gt;&gt; b</td>
</tr>
<tr>
<td>&amp;=</td>
<td> a &amp;= b</td>
<td> a = a &amp; b</td>
</tr>
<tr>
<td> |=</td>
<td> a |= b</td>
<td> a = a | b</td>
</tr>
<tr>
<td> ^=</td>
<td> a ^= b</td>
<td> a = a ^ b</td>
</tr>
</tbody>
</table></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>output += &quot;&lt;H1&gt;Section 2&lt;/H1&gt;&quot;;
		total *= .95;</pre>
</span></td>
</tr>
</table>
</div>
<div id="+">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">+</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">2</span> IE <span class="emphasis">3</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
L&rsquo;op&eacute;rateur d&rsquo;addition fonctionne avec les chiffres et les cha&icirc;nes, mais ses r&eacute;sultats varient en fonction des types de donn&eacute;es de ses op&eacute;randes. Lorsque les deux op&eacute;randes sont des nombres, le r&eacute;sultat est la somme des nombres; lorsque les deux op&eacute;randes sont des cha&icirc;nes, le r&eacute;sultat est une concat&eacute;nation des cha&icirc;nes (dans l'ordre de l'addition); lorsqu'un op&eacute;rande est un nombre et l'autre une cha&icirc;ne, les donn&eacute;es de type nombre sont converties en donn&eacute;es de type cha&icirc;ne, puis les deux cha&icirc;nes sont concat&eacute;n&eacute;es. Pour convertir un op&eacute;rande de type cha&icirc;ne en op&eacute;rande de type nombre, utilisez l'une des fonctions <span class="literal">parseInt()</span> ou <span class="literal">parseFloat()</span>.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>var mySum = number1 + number2;
var newString = &quot;string1&quot; + &quot;string2&quot;;</pre>
</span></td>
</tr>
</table>
</div>
<div id="&&">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">&amp;&amp;</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">2</span> IE <span class="emphasis">3</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
L&rsquo;op&eacute;rateur AND compare deux expressions bool&eacute;ennes pour v&eacute;rifier si elles sont &eacute;gales. Si l'une des deux expressions est &eacute;valu&eacute;e comme <span class="literal">true</span>, le r&eacute;sultat produit par l'op&eacute;rateur <span class="literal">||</span> est &eacute;galement &eacute;valu&eacute; comme <span class="literal">true</literal> si les deux expressions sont &eacute;valu&eacute;es comme <span class="literal">false</span>, l'op&eacute;rateur est &eacute;valu&eacute; comme <span class="literal">false</span>.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
Une expression bool&eacute;enne peut consister en l'expression d'une comparaison (&agrave; l'aide des nombreux op&eacute;rateurs de comparaison disponibles) ou en une s&eacute;rie d'autres valeurs. Voici les types de donn&eacute;es et valeurs les plus fr&eacute;quents, avec la valeur bool&eacute;enne correspondante.
</p>
<table border="1">
<tbody>
<tr>
<th>Type de donn&eacute;es</th>
<th>Equivalent bool&eacute;en</th>
</tr>
<tr>
<td>Nombre autre que z&eacute;ro</td>
<td> true</td>
</tr>
<tr>
<td>Z&eacute;ro</td>
<td> false</td>
</tr>
<tr>
<td>Toute cha&icirc;ne de texte non vide</td>
<td> true</td>
</tr>
<tr>
<td>Cha&icirc;ne vide</td>
<td> false</td>
</tr>
<tr>
<td>Tout objet</td>
<td> true</td>
</tr>
<tr>
<td><span class="literal">null</span></td>
<td> false</td>
</tr>
<tr>
<td><span class="literal">undefined</span></td>
<td> false</td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
Ces informations permettent de cr&eacute;er des conditions compos&eacute;es &agrave; l'aide de l'op&eacute;rateur <span class="literal"> Par exemple, si vous voulez voir si quelqu'un a saisi une valeur dans un champ de formulaire et s'il s'agit d'un nombre sup&eacute;rieur &agrave; 100, la condition ressemblera &agrave; ceci:
</p>
<span class="PROGRAMLISTING"><pre>var userEntry = document.forms[0].entry.value ;
if (userEntry&amp;&amp; parseInt(userEntry) &gt;= 100) {
    ...
} </pre></span>
</td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td colspan="2"><p>
Si l'utilisateur n'a saisi aucune valeur, la cha&icirc;ne est vide. Dans la condition compos&eacute;e, si le premier op&eacute;rande est &eacute;valu&eacute; comme <span class="literal">false</span>, les r&egrave;gles de l'op&eacute;rateur signifient que l'expression enti&egrave;re renvoie la valeur <literal>false</literal> (du fait que les deux op&eacute;randes doivent &ecirc;tre <literal>true</literal> pour que l'op&eacute;rateur renvoie <literal>true</literal>). Comme l'&eacute;valuation d'expressions telles qu'une condition compos&eacute;e s'effectue de gauche &agrave; droite, la valeur <span class="literal">false</span> du premier op&eacute;rande court-circuite la condition pour renvoyer <span class="literal">false</span>, de sorte que le second op&eacute;rande n'est pas &eacute;valu&eacute;.
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>if (a &lt;= b &amp;&amp; b &gt;= c) {
    ...
}</pre>
</span></td>
</tr>
</table>
</div>
<div id="break">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">break</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">2</span> IE <span class="emphasis">3</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
Interrompt l'ex&eacute;cution de la boucle consid&eacute;r&eacute;e et renvoie le contr&ocirc;le &agrave; l'instruction de script qui suit la boucle en question. A d&eacute;faut de param&egrave;tre d'&eacute;tiquette d&eacute;fini, sachez que l'instruction <span class="literal">break</span> porte sur sa propre boucle. Pour sortir d'une boucle imbriqu&eacute;e, affectez des &eacute;tiquettes &agrave; chaque calque imbriqu&eacute; et utilisez l'&eacute;tiquette de votre choix comme param&egrave;tre de l'instruction <span class="literal">break</span>. Voir l'instruction <span class="literal">label</span> (uniquement disponible depuis Navigator4 et Internet Explorer4).
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td colspan="2"><p>
Reportez-vous &agrave; l&rsquo;instruction <span class="literal">label</span>.
</p></td>
</tr>
</table>
</div>
<div id="continue">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">continue</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">2</span> IE <span class="emphasis">3</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
Interrompt l'it&eacute;ration consid&eacute;r&eacute;e de la boucle et retourne au d&eacute;but de celle-ci pour recommencer (en ex&eacute;cutant l'expression mise &agrave; jour &eacute;ventuellement sp&eacute;cifi&eacute;e dans une boucle <span class="literal">for</span>). Si vous utilisez des constructions de boucle imbriqu&eacute;e, affectez des &eacute;tiquettes &agrave; chaque calque imbriqu&eacute;, puis utilisez l'&eacute;tiquette de votre choix comme param&egrave;tre de l'instruction <span class="literal">continue</span>. Voir l'instruction <span class="literal">label</span> (uniquement disponible depuis Navigator4 et Internet Explorer4).
</p></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="example"><span class="title">Exemple</span></td>
</tr>
<tr>
<td valign="top" colspan="2" class="CLEARSEPARATION">&nbsp;</td>
</tr>
<tr>
<td><span class="programlisting">
<pre>outerLoop:
for (var i = 0; i &lt;= maxValue1; i++) {
    for (var j = 0; j &lt;= maxValue2; j++) {
        if (j*i == magic2) {
            continue outerLoop;
        }
    }
}</pre>
</span></td>
</tr>
</table>
</div>
<div id="catch">
<table cellpadding="0" cellspacing="0" border="0" width="100%" class="main">
<tr>
<td valign="top" class="name">catch</td>
<td valign="top" nowrap class="compatibility">NN <span class="emphasis">2</span> IE <span class="emphasis">3</span> ECMA <span class="emphasis">1</span></td>
</tr>
<tr>
<td valign="top" nowrap class="usage"><p class="literal">
</p></td>
<td valign="top" nowrap class="requirements">&nbsp;&nbsp;</td>
</tr>
<tr>
<td valign="top" colspan="2" class="description"><p>
Voir try.
</p></td>
</tr>
</table>
</div>
</body>
</html>
