= | NN 2 IE 3 ECMA 1
Cet opérateur affecte la valeur évaluée de l'opérande de droite à la variable de gauche. Après l'opération, la variable contient des données du même type que la valeur originale. Les opérations d'affectation peuvent être chaînées ; dans ce cas, l'évaluation de l'instruction entière s'effectue de droite à gauche. Ainsi, après l'expression :
    a = b = c = 25;
les trois variables sont égales à 25.
Exemple
    var myName = "Theodore Roosevelt";
    var now = new Date( );

& | NN 2 IE 3 ECMA 1
L’opérateur AND au niveau du bit exécute une opération mathématique binaire sur deux opérandes (leurs valeurs binaires). Chaque colonne de bits est soumise à l'opération booléenne AND. Si la valeur d'une colonne des deux opérandes est égale à 1, le résultat correspondant à cette position de colonne est 1. Toutes les autres combinaisons produisent le résultat zéro. La valeur d'opérateur qui en résulte est l'équivalent décimal du résultat binaire. Par exemple, les équivalents binaires des valeurs décimales 3 et 6 sont 0011 et 0110. Après une opération AND sur ces deux valeurs, le résultat binaire est 0010, ce qui équivaut à la valeur décimale 2.
Exemple
    var n = 3 & 6;

<< | NN 2 IE 3 ECMA 1
Cet opérateur décale les bits du premier opérande du nombre de colonnes spécifié par le second. Par exemple, si les bits de la valeur binaire de 3 (0011) sont décalés de deux positions vers la gauche, le résultat binaire est 1100, ce qui équivaut à la valeur décimale 12.
Exemple
    var shifted = 3 << 2;

~ | NN 2 IE 3 ECMA 1
Il s’agit de l’opérateur NOT au niveau du bit. Cet opérateur unaire inverse la valeur du signe binaire de chaque colonne d'un nombre. Par exemple, l'équivalent binaire de la valeur décimale 6 est 0110 (avec beaucoup plus de zéros à gauche). Après l'opération de négation appliquée à la valeur de chaque colonne, le résultat binaire est 1001, plus tous les zéros de gauche inversés en 1. L'équivalent décimal est une valeur négative (-5).
Exemple
    var n = ~6;

| | NN 2 IE 3 ECMA 1
L’opérateur OR au niveau du bit exécute une opération mathématique binaire sur deux opérandes (leurs valeurs binaires). Chaque colonne de bits est soumise à l'opération booléenne OR. Si la valeur d'une colonne des deux opérandes est égale à 0, le résultat correspondant à cette position de colonne est 0. Toutes les autres combinaisons produisent le résultat 1. La valeur d'opérateur qui en résulte est l'équivalent décimal du résultat binaire. Par exemple, les équivalents binaires des valeurs décimales 3 et 6 sont 0011 et 0110. Après une opération OR sur ces deux valeurs, le résultat binaire est 0111, ce qui équivaut à la valeur décimale 7.
Exemple
    var n = 3 | 6;

>> | NN 2 IE 3 ECMA 1
Cet opérateur décale les bits du premier opérande du nombre de colonnes spécifié par le second. Par exemple, si les bits de la valeur binaire de 6 (0110) sont décalés de deux positions vers la droite, le résultat binaire est 0001, ce qui équivaut à la valeur décimale 1. Tous les caractères binaires situés au-delà de l'extrémité droite du nombre sont écartés.
Exemple
    var shifted = 6 >> 2;

^ | NN 2 IE 3 ECMA 1
L’opérateur OR au niveau du bit (XOR) exécute une opération mathématique binaire sur deux opérandes (leurs valeurs binaires). Chaque colonne de bits est soumise à l'opération booléenne XOR. Si la valeur d'une colonne de l'un des deux opérandes (mais pas des deux) est égale à 1, le résultat correspondant à cette position de colonne est 1. Toutes les autres combinaisons produisent le résultat 0. La valeur d'opérateur qui en résulte est l'équivalent décimal du résultat binaire. Par exemple, les équivalents binaires des valeurs décimales 3 et 6 sont 0011 et 0110. Après une opération XOR sur ces deux valeurs, le résultat binaire est 0101, ce qui équivaut à la valeur décimale 5.
Exemple
    var n = 3 ^ 6;

>>> | NN 2 IE 3 ECMA 1
Il s’agit de l’opérateur de déplacement vers la droite au niveau du bit avec peuplement de zéros. Cet opérateur décale (vers la droite) les bits du premier opérande du nombre de colonnes spécifié par le second. Dans le cas de l'opérateur de déplacement vers la droite au niveau du bit (), les caractères binaires qui peuplent l'expression à partir du côté gauche sont des 1 ; dans le cas de l'opérateur de déplacement vers la droite avec peuplement de zéros (>>>), les caractères binaires qui peuplent l'expression à partir du côté gauche sont des zéros. Tous les caractères binaires situés au-delà de l'extrémité droite du nombre sont écartés. Microsoft désigne également cet opérateur comme opérateur de déplacement vers la droite non signé.
Exemple
    var shifted = 6 >>> 2;

, | NN 2 IE 3 ECMA 1
Cet opérateur (suivi ou non de l’espace blanc facultatif) permet de délimiter des expressions se trouvant dans la même ligne de script. Vous pouvez l'utiliser de plusieurs manières. Par exemple, pour déclarer plusieurs variables, la syntaxe est : var varName1, varName2, ... varNameN;
Il est également possible de joindre plusieurs instructions de script sur la même ligne. Ainsi, la ligne de script suivante : alert("Howdy"), alert("Doody");
présente successivement deux boîtes d'alerte (la seconde s'affiche une fois que la première a été fermée par l'utilisateur). Une autre application consiste à l'utiliser dans des boucles for dans lesquelles vous voulez inclure deux variables ou plus :
    for (var i = 0, var j = 2; i< 20; i++, j++) {
        ...
    }
Exemple
    var isCSS, isIEMac;

//, /*...*/ | NN 2 IE 3 ECMA 1
Instructions de commentaires qui vous permettent d'insérer du texte non exécutable dans un script. L'interpréteur de langage ignore tout texte suivant le symbole // dans une ligne d'instructions. Le navigateur interprète la ligne de script suivante, sauf si elle commence par un autre symbole //.
Pour les commentaires sur plusieurs lignes, vous pouvez faire précéder le bloc du symbole /*. Les blocs de commentaires peuvent contenir un nombre quelconque de lignes. Le symbole */ désigne la fermeture du bloc indiquant à l'interpréteur qu'il peut exécuter les instructions suivantes.
Exemple
    // convert temp from C to F

    /*
    many lines
    of
    comments
    */

//, /*...*/ | NN 2 IE 3 ECMA 1
Instructions de commentaires qui vous permettent d'insérer du texte non exécutable dans un script. L'interpréteur de langage ignore tout texte suivant le symbole // dans une ligne d'instructions. Le navigateur interprète la ligne de script suivante, sauf si elle commence par un autre symbole //.
Pour les commentaires sur plusieurs lignes, vous pouvez faire précéder le bloc du symbole /*. Les blocs de commentaires peuvent contenir un nombre quelconque de lignes. Le symbole */ désigne la fermeture du bloc indiquant à l'interpréteur qu'il peut exécuter les instructions suivantes.
Exemple
    // convert temp from C to F

    /*
    many lines
    of
    comments
    */

@cc_on, @if, @end, @set | NN s.o. IE 4(Win) ECMA s.o.
IE pour Windows comprend une fonctionnalité de scripts appelée compilation conditionnelle. Il s’agit d’un mode qui, une fois qu’il est activé par le biais de l’instruction @cc_on, permet aux instructions JScript de s’exé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’exécutent que sur IE 4 et versions ultérieures pour Windows, sans entrer en conflit avec les autres navigateurs.
Cette partie « conditionnelle » provient de nombreuses propriétés globales (toutes précédées du symbole @) qui révèlent des propriétés d’environnement, telles que la version du moteur de script, le système d’exploitation et le type de processeur. Toutes ces informations sont disponibles à partir des propriétés de l’objet navigator sur une vaste gamme de navigateurs, il ne s’agit donc pas d’informations uniques disponibles seulement pour cet environnement conditionnel.
Pour activer la compilation conditionnelle, incluez l’instruction suivante dans votre script :
    /*@cc_on @*/
Il s’agit d’un commutateur à sens unique : une fois que le mode est activé, il ne peut plus être désactivé dans la page considérée.
Le fragment suivant montre comment l’instruction @if et les instructions connexes affichent des informations d’environnement dans la barre de statut de la fenêtre si le navigateur exécute JScript version 5.6 ou ultérieure (IE 6 ou version plus récente) :
    /*@cc_on @*/
    /*@if (@_jscript_version>= 5.6 && @_x86)
        status = "Now running JScript version " + @_jscript_version +
        " with Intel inside.";
       @else @*/
        status = "Have a nice day.";
    /*@end @*/
L’instruction @set vous permet d’affecter une valeur numérique ou booléenne (pas de chaînes) à une variable (une variable avec un préfixe @) au sein d’une section de compilation conditionnelle :
    @set @isOK = @_win32
Une fois initialisée, cette variable (y compris son identifiant autrement inacceptable) peut être utilisée dans les instructions de scripts sur toute la page. Remarque : La syntaxe inspirée de Visual Basic des instructions @ dans les instructions de compilation conditionnelle n’autorise pas les points-virgules à la fin des instructions.
D’un côté, la compilation conditionnelle pourrait être utile pour le déploiement sur IE uniquement, pour le tri des anciennes versions de Microsoft Internet Explorer et des nouvelles fonctionnalités de langue qui généreraient des erreurs de compilation (comme les constructions try-catch). De telles instructions ne se compilent que dans des situations de versions très contrôlables. Cependant, dans un contexte de développement pour des navigateurs de différentes marques, vous trouverez au mieux des applications conçues à des fins de débogage pour IE uniquement, mais probablement pas pour le déploiement réel d’applications.
Exemple
Reportez-vous à la section ci-dessus.

@cc_on, @if, @end, @set | NN s.o. IE 4(Win) ECMA s.o.
IE pour Windows comprend une fonctionnalité de scripts appelée compilation conditionnelle. Il s’agit d’un mode qui, une fois qu’il est activé par le biais de l’instruction @cc_on, permet aux instructions JScript de s’exé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’exécutent que sur IE 4 et versions ultérieures pour Windows, sans entrer en conflit avec les autres navigateurs.
Cette partie « conditionnelle » provient de nombreuses propriétés globales (toutes précédées du symbole @) qui révèlent des propriétés d’environnement, telles que la version du moteur de script, le système d’exploitation et le type de processeur. Toutes ces informations sont disponibles à partir des propriétés de l’objet navigator sur une vaste gamme de navigateurs, il ne s’agit donc pas d’informations uniques disponibles seulement pour cet environnement conditionnel.
Pour activer la compilation conditionnelle, incluez l’instruction suivante dans votre script :
    /*@cc_on @*/
Il s’agit d’un commutateur à sens unique : une fois que le mode est activé, il ne peut plus être désactivé dans la page considérée.
Le fragment suivant montre comment l’instruction @if et les instructions connexes affichent des informations d’environnement dans la barre de statut de la fenêtre si le navigateur exécute JScript version 5.6 ou ultérieure (IE 6 ou version plus récente) :
    /*@cc_on @*/
    /*@if (@_jscript_version>= 5.6 && @_x86)
        status = "Now running JScript version " + @_jscript_version +
        " with Intel inside.";
       @else @*/
        status = "Have a nice day.";
    /*@end @*/
L’instruction @set vous permet d’affecter une valeur numérique ou booléenne (pas de chaînes) à une variable (une variable avec un préfixe @) au sein d’une section de compilation conditionnelle :
    @set @isOK = @_win32
Une fois initialisée, cette variable (y compris son identifiant autrement inacceptable) peut être utilisée dans les instructions de scripts sur toute la page. Remarque : La syntaxe inspirée de Visual Basic des instructions @ dans les instructions de compilation conditionnelle n’autorise pas les points-virgules à la fin des instructions.
D’un côté, la compilation conditionnelle pourrait être utile pour le déploiement sur IE uniquement, pour le tri des anciennes versions de Microsoft Internet Explorer et des nouvelles fonctionnalités de langue qui généreraient des erreurs de compilation (comme les constructions try-catch). De telles instructions ne se compilent que dans des situations de versions très contrôlables. Cependant, dans un contexte de développement pour des navigateurs de différentes marques, vous trouverez au mieux des applications conçues à des fins de débogage pour IE uniquement, mais probablement pas pour le déploiement réel d’applications.
Exemple
Reportez-vous à la section ci-dessus.

@cc_on, @if, @end, @set | NN s.o. IE 4(Win) ECMA s.o.
IE pour Windows comprend une fonctionnalité de scripts appelée compilation conditionnelle. Il s’agit d’un mode qui, une fois qu’il est activé par le biais de l’instruction @cc_on, permet aux instructions JScript de s’exé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’exécutent que sur IE 4 et versions ultérieures pour Windows, sans entrer en conflit avec les autres navigateurs.
Cette partie « conditionnelle » provient de nombreuses propriétés globales (toutes précédées du symbole @) qui révèlent des propriétés d’environnement, telles que la version du moteur de script, le système d’exploitation et le type de processeur. Toutes ces informations sont disponibles à partir des propriétés de l’objet navigator sur une vaste gamme de navigateurs, il ne s’agit donc pas d’informations uniques disponibles seulement pour cet environnement conditionnel.
Pour activer la compilation conditionnelle, incluez l’instruction suivante dans votre script :
    /*@cc_on @*/
Il s’agit d’un commutateur à sens unique : une fois que le mode est activé, il ne peut plus être désactivé dans la page considérée.
Le fragment suivant montre comment l’instruction @if et les instructions connexes affichent des informations d’environnement dans la barre de statut de la fenêtre si le navigateur exécute JScript version 5.6 ou ultérieure (IE 6 ou version plus récente) :
    /*@cc_on @*/
    /*@if (@_jscript_version>= 5.6 && @_x86)
        status = "Now running JScript version " + @_jscript_version +
        " with Intel inside.";
       @else @*/
        status = "Have a nice day.";
    /*@end @*/
L’instruction @set vous permet d’affecter une valeur numérique ou booléenne (pas de chaînes) à une variable (une variable avec un préfixe @) au sein d’une section de compilation conditionnelle :
    @set @isOK = @_win32
Une fois initialisée, cette variable (y compris son identifiant autrement inacceptable) peut être utilisée dans les instructions de scripts sur toute la page. Remarque : La syntaxe inspirée de Visual Basic des instructions @ dans les instructions de compilation conditionnelle n’autorise pas les points-virgules à la fin des instructions.
D’un côté, la compilation conditionnelle pourrait être utile pour le déploiement sur IE uniquement, pour le tri des anciennes versions de Microsoft Internet Explorer et des nouvelles fonctionnalités de langue qui généreraient des erreurs de compilation (comme les constructions try-catch). De telles instructions ne se compilent que dans des situations de versions très contrôlables. Cependant, dans un contexte de développement pour des navigateurs de différentes marques, vous trouverez au mieux des applications conçues à des fins de débogage pour IE uniquement, mais probablement pas pour le déploiement réel d’applications.
Exemple
Reportez-vous à la section ci-dessus.

@cc_on, @if, @end, @set | NN s.o. IE 4(Win) ECMA s.o.
IE pour Windows comprend une fonctionnalité de scripts appelée compilation conditionnelle. Il s’agit d’un mode qui, une fois qu’il est activé par le biais de l’instruction @cc_on, permet aux instructions JScript de s’exé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’exécutent que sur IE 4 et versions ultérieures pour Windows, sans entrer en conflit avec les autres navigateurs.
Cette partie « conditionnelle » provient de nombreuses propriétés globales (toutes précédées du symbole @) qui révèlent des propriétés d’environnement, telles que la version du moteur de script, le système d’exploitation et le type de processeur. Toutes ces informations sont disponibles à partir des propriétés de l’objet navigator sur une vaste gamme de navigateurs, il ne s’agit donc pas d’informations uniques disponibles seulement pour cet environnement conditionnel.
Pour activer la compilation conditionnelle, incluez l’instruction suivante dans votre script :
    /*@cc_on @*/
Il s’agit d’un commutateur à sens unique : une fois que le mode est activé, il ne peut plus être désactivé dans la page considérée.
Le fragment suivant montre comment l’instruction @if et les instructions connexes affichent des informations d’environnement dans la barre de statut de la fenêtre si le navigateur exécute JScript version 5.6 ou ultérieure (IE 6 ou version plus récente) :
    /*@cc_on @*/
    /*@if (@_jscript_version>= 5.6 && @_x86)
        status = "Now running JScript version " + @_jscript_version +
        " with Intel inside.";
       @else @*/
        status = "Have a nice day.";
    /*@end @*/
L’instruction @set vous permet d’affecter une valeur numérique ou booléenne (pas de chaînes) à une variable (une variable avec un préfixe @) au sein d’une section de compilation conditionnelle :
    @set @isOK = @_win32
Une fois initialisée, cette variable (y compris son identifiant autrement inacceptable) peut être utilisée dans les instructions de scripts sur toute la page. Remarque : La syntaxe inspirée de Visual Basic des instructions @ dans les instructions de compilation conditionnelle n’autorise pas les points-virgules à la fin des instructions.
D’un côté, la compilation conditionnelle pourrait être utile pour le déploiement sur IE uniquement, pour le tri des anciennes versions de Microsoft Internet Explorer et des nouvelles fonctionnalités de langue qui généreraient des erreurs de compilation (comme les constructions try-catch). De telles instructions ne se compilent que dans des situations de versions très contrôlables. Cependant, dans un contexte de développement pour des navigateurs de différentes marques, vous trouverez au mieux des applications conçues à des fins de débogage pour IE uniquement, mais probablement pas pour le déploiement réel d’applications.
Exemple
Reportez-vous à la section ci-dessus.

?: | NN 2 IE 3 ECMA 1
Cet opérateur fournit une syntaxe abrégée pour une structure de contrôle if/else. Le déploiement de cet opérateur implique trois composants : une condition et deux instructions. Si la condition est évaluée comme true, la première instruction est exécutée ; dans le cas contraire, c'est la seconde. La syntaxe se présente comme suit :
    condition ? statement1 : statement2
Vous pouvez imbriquer ces opérateurs afin d’ajouter des chemins de décision supplémentaires au sein d’une même instruction. Dans la syntaxe suivante, si conditionA est évaluée à false, conditionB est évaluée et l’expression entière renvoie la valeur de statement2 ou statement3 selon les résultats de conditionB.
Cet opérateur n'est abrégé qu'en apparence. Il appelle le même traitement interne qu'une construction if...else.
Exemple
    var newColor = (temp > 100) ? "red" : "blue";

continue | NN 2 IE 3 ECMA 1
Interrompt l'itération considérée de la boucle et retourne au début de celle-ci pour recommencer (en exécutant l'expression mise à jour éventuellement spécifiée dans une boucle for). Si vous utilisez des constructions de boucle imbriquée, affectez des étiquettes à chaque calque imbriqué, puis utilisez l'étiquette de votre choix comme paramètre de l'instruction continue. Voir l'instruction label (uniquement disponible depuis Navigator 4 et Internet Explorer 4).
Exemple
    outerLoop:
    for (var i = 0; i <= maxValue1; i++) {
        for (var j = 0; j <= maxValue2; j++) {
            if (j*i == magic2) {
                continue outerLoop;
            }
        }
    }

char | NN 2 IE 3 ECMA 1
JavaScript fournit un mécanisme permettant d’inclure des caractères d’espace blanc considérés (parfois appelés codes de contrôle) dans les chaînes, ainsi que des symboles qui entrent autrement en conflit avec la représentation de chaînes. La clé est la barre oblique inverse (\\), suivie immédiatement d’un seul caractère ayant une signification particulière. Le tableau suivant montre les caractères d’échappement reconnus et leur signification.
Ces caractères sont pratiques pour le texte des boîtes de dialogue d’alerte, de confirmation et d’invite. Par exemple, si vous vouliez afficher plusieurs paragraphes avec une ligne blanche entre eux dans une boîte d’alerte, vous inséreriez des caractères de changement de ligne :
    alert("First paragraph.\n\nSecond paragraph.")
Remarque : Ces caractères s’appliquent aux chaînes et n’influencent pas le formatage du contenu HTML pour les retours chariot.
Séquence d’échappement | Description
--- | ---
\\b | Retour arrière
\\t | Tabulation horizontale
\\n | Changement de ligne (nouvelle ligne)
\\v | Tabulation verticale
\\f | Changement de formulaire
\\r | Retour chariot
\" | Guillemet double "
\' | Guillemet simple '
\\ | Barre oblique inverse

— | NN 2 IE 3 ECMA 1
Cet opérateur unaire soustrait 1 de la valeur considérée d'une expression variable. Vous pouvez placer l'opérateur devant ou derrière la variable, en fonction de l'effet souhaité. Lorsque l'opérateur se trouve devant la variable, cette dernière est décrémentée avant son évaluation dans l'instruction considérée. Par exemple, dans la séquence suivante :
    var a, b;
    a = 5;
    b = --a;
un est soustrait de a avant d’être affecté à b. Ainsi, b et a sont tous deux 4 à la fin de ces instructions. En revanche, dans la séquence suivante :
    var a, b;
    a = 5;
    b = a--;
la soustraction s’effectue après l’affectation de a à b. Une fois les instructions terminées, b est 5 et a est 4.
Ce comportement influence le mode de définition et d'utilisation des variables de comptage de boucle for. Généralement, un compteur de boucle, qui décompte à partir d'une valeur maximale, commence à décrémenter une fois les instructions de la boucle exécutées. La plupart des compteurs de boucle placent donc l'opérateur derrière la variable du compteur :
    for (var i = 10; i>=0; i--) {...}
Exemple
    --n
    n--

delete | NN 4 IE 4 ECMA 1
L’opérateur delete supprime une propriété d'un objet (par exemple, une propriété prototype qui a été précédemment ajoutée à une instance d'objet statique) ou un élément d'un tableau généré par script. La suppression d’une entrée de tableau ne modifie pas la longueur du tableau ou les index numériques des éléments existants. Au lieu de cela, la valeur de l’élément supprimé est simplement undefined. L’opérateur delete n’est pas un outil de gestion de la mémoire.
Exemple
    delete myString.author;

/ | NN 2 IE 3 ECMA 1
Cet opérateur divise le nombre sur sa gauche par le nombre sur sa droite. Les deux opérandes doivent être des nombres. Une expression contenant cet opérateur produit un nombre.
Exemple
    var myQuotient = number1 / number2;

do/while | NN 4 IE 4 ECMA 3
Exécute des instructions en boucle lorsqu'une condition est vraie. La condition étant testée à la fin de la boucle, les instructions qu'elle contient sont toujours exécutées au moins une fois. Il est impératif que la valeur de l'expression constituant la condition soit potentiellement modifiée dans les instructions. Dans le cas contraire, la boucle est infinie.
Exemple
    var i = 1;
    do
        window.status = "Loop number " + i++;
    } while (i <= 10)
    window.status = "";

== | NN 2 IE 3 ECMA 1
Cet opérateur compare les valeurs de deux opérandes et renvoie un résultat booléen. Le comportement de cet opérateur varie en fonction de la version de JavaScript spécifiée pour l'élément script. Si l'attribut language est paramétré sur JavaScript ou JavaScript1.1, certains opérandes sont automatiquement convertis de la manière indiquée dans le tableau ci-dessous.
Opérande de gauche | Opérande de droite | Description
--- | --- | ---
Référence d'objet | Référence d'objet | Compare l'évaluation de références d'objet.
N’importe quel type de données | Boolean | Convertissent un opérande booléen en nombre (1 pour true ; 0 pour false) et comparent à un autre opérande.
Référence d'objet | String | Convertit un objet en chaîne (<i>via</i> toString()), puis compare les chaînes.
String | Nombre | Convertit une chaîne en nombre, puis compare les valeurs numériques.
Navigator 4 et les versions ultérieures utilisent des conversions de valeurs légèrement différentes pour déterminer l’égalité lorsque vous définissez l’élément script sur language="JavaScript1.2". Le navigateur est plus “ littéral ” en matière d'égalité, ce qui signifie qu'il ne convertit pas automatiquement les données. Ainsi, alors que l'expression
    123 == "123"
est presque toujours évaluée comme true en raison de la conversion automatique du type de données, Navigator 4 et les versions ultérieures l'évaluent comme false dans les instructions de scripts explicitement écrits en JavaScript 1.2. Comme les normes du DOM et XHTML plus récentes ne fournissent pas d’endroit où spécifier les versions du langage de script, évitez ces situations particulières. Si vos scripts nécessitent des tests pour l’égalité absolue des opérandes, utilisez plutôt l’opérateur d’identité le plus récent ===. Pour les tests d’égalité des valeurs typiques, les opérateurs d’égalité standards fonctionnent parfaitement.
Quelle que soit la version, si vous voulez comparer les valeurs d'objets (par exemple, de chaînes explicitement générées avec le constructeur d'objet new String( )), vous devez comparer les valeurs dérivées de méthodes telles que toString( ) ou valueOf( ).
Exemple
    if (n == m) {
        ...
    }

>= | NN 2 IE 3 ECMA 1
Cet opérateur compare les valeurs des opérandes situés de part et d'autre. Si la valeur numérique de l'opérande de gauche est supérieure ou égale à celle de l'opérande de droite, l'expression est évaluée comme true. Pour comparer ces valeurs numériques, les chaînes de caractères sont converties en valeurs Unicode.
Exemple
    if (a >= b) {
        ...
    }

> | NN 2 IE 3 ECMA 1
Cet opérateur compare les valeurs des opérandes situés de part et d'autre. Si la valeur numérique de l'opérande de gauche est supérieure à celle de l'opérande de droite, l'expression est évaluée comme true. Pour comparer les valeurs, les chaînes de caractères sont converties en valeurs Unicode.
Exemple
    if (a > b) {
        ...
    }

if | NN 2 IE 3 ECMA 1
Instruction conditionnelle simple qui prévoit un chemin d'exécution alternatif.
Exemple
    if (myDateObj.getMonth( ) == 1) {
        calcMonthLength( );
    }

if/else | NN 2 IE 3 ECMA 1
Instruction conditionnelle qui prévoit deux chemins d'exécution, en fonction du résultat de la condition. Vous pouvez imbriquer une autre instruction if ou if/else dans chaque chemin de l'instruction if/else.
Exemple
    var theMonth = myDateObj.getMonth( );
    if (theMonth == 1) {
        monLength = calcLeapMonthLength( );
    else
        monLength = calcMonthLength(theMonth);
    }

in | NN 6 IE 5.5(Win) ECMA s.o.
L’opérateur in permet aux scripts de découvrir rapidement si une propriété ou une méthode particulière est implémentée pour un objet. L’opérande gauche est une chaîne contenant le nom de la propriété ou méthode (nom de méthode sans parenthèses), alors que l’opérande droit est une référence à l’objet. Si votre exploration nécessite des références DOM avec des points, placez-les dans le côté référence objet de l’expression. In other words, instead of trying "style.filter" in document.body, use "filter" in document.body.style. Si plus de navigateurs implémentaient cet opérateur ECMA à venir, il s’agirait d’un outil utile pour la détection d’objets.
Exemple
    if ("createDocument" in document.implementation) {
        // go ahead and use document.implementation.createDocument( )
    }

++ | NN 2 IE 3 ECMA 1
Cet opérateur unaire ajoute 1 à la valeur considérée d'une expression variable. Vous pouvez placer l'opérateur devant ou derrière la variable, en fonction de l'effet souhaité. Lorsque l'opérateur se trouve devant la variable, cette dernière est incrémentée avant son évaluation dans l'instruction en question. Par exemple, dans la séquence suivante :
    var a, b;
    a = 5;
    b = ++a;
1 est ajouté à a avant d’être affecté à b. Ainsi, b et a sont tous deux 6 à la fin de ces instructions. En revanche, dans la séquence suivante :
    var a, b;
    a = 5;
    b = a++;
l’addition s’effectue après l’affectation de a à b. Une fois les instructions terminées, b est 5 et a est 6.
Ce comportement influence le mode de définition et d'utilisation des variables de comptage de boucle for. Généralement, un compteur de boucle qui commence à partir d'une valeur minimale, incrémente le compteur une fois les instructions de la boucle exécutées. La plupart des compteurs de boucle placent donc l'opérateur derrière la variable du compteur : for (var i = 10; i>=0; i++) {...}
Exemple
    ++n
    		n++

!= | NN 2 IE 3 ECMA 1
Cet opérateur compare les valeurs de deux opérandes et renvoie un résultat booléen. Le comportement de cet opérateur varie en fonction de la version de JavaScript spécifiée pour l'élément script. Si l'attribut language est JavaScript ou JavaScript1.1, certains opérandes sont automatiquement convertis, comme pour l'opérateur d'égalité (==). La situation diffère légèrement dans Navigator 4 et versions ultérieures lorsque l'élément script est paramétré sur language="JavaScript1.2". Le navigateur est plus “ littéral ” en matière d'inégalité, ce qui signifie qu'il ne convertit pas automatiquement les données. Ainsi, alors que l'expression
    123 != "123"
est presque toujours évaluée comme false en raison de la conversion automatique du type de données, Navigator 4 et les versions ultérieures l'évaluent comme true dans les instructions de script explicitement écrites en JavaScript 1.2. Comme les normes du DOM et XHTML plus récentes ne fournissent pas d’endroit où spécifier les versions du langage de script, évitez ces situations particulières. Si vos scripts nécessitent des tests pour l’inégalité absolue des opérandes, utilisez plutôt l’opérateur d’identité !== le plus récent. Pour les tests d’inégalité des valeurs typiques, les opérateurs d’inégalité standards fonctionnent parfaitement.
Quelle que soit la version, si vous voulez comparer les valeurs d'objets (par exemple, de chaînes explicitement générées avec le constructeur d'objet new String( )), vous devez comparer les valeurs dérivées de méthodes telles que toString( ) ou valueOf( ).
Exemple
    if (n != m) {
        ...
    }

instanceof | NN 6 IE 5(Win) ECMA s.o.
L’opérateur instanceof permet aux scripts de déterminer si un objet (opérande gauche) est une instance d’un objet connu (ou héritée de l’objet connu). Par certains côtés, cet opérateur est similaire à l’opérateur typeof, mais au lieu de renvoyer un type d’objet global, une expression avec l’opérateur instanceof renvoie une valeur booléenne spécifiant un type d’objet plus spécifique. En fait, vous pouvez tester un objet par rapport à des objets personnalisés, dans les prototypes d’objets Netscape 6 et de l’arborescence du DOM. Alors que l’opérateur typeof d’un tableau renvoie object, vous pouvez découvrir si un objet a été instancié spécifiquement comme tableau :
    myVar instanceof Array
Remarquez cependant que si l’expression ci-dessus est évaluée comme true, c’est aussi le cas de :
    myVar instanceof Object
Un tableau est un descendant de l’objet Object racine et est donc aussi une instance de cet objet racine.
Dans Netscape 6, un ou les deux opérandes peuvent aussi être des références aux objets du prototype du DOM. Ainsi, l’expression suivante est légale et opérationnelle dans Netscape 6 :
    document.getElementById("widget") instanceof HTMLDivElement
Exemple
    if (theVal instanceof Array) {
        // go ahead and treat theVal as an array
    }

<= | NN 2 IE 3 ECMA 1
Cet opérateur compare les valeurs des opérandes situés de part et d'autre. Si la valeur numérique de l'opérande de gauche est inférieure ou égale à celle de l'opérande de droite, l'expression est évaluée comme true. Pour comparer ces valeurs numériques, les chaînes de caractères sont converties en valeurs Unicode.
Exemple
    if (a <= b) {
        ...
    }

< | NN 2 IE 3 ECMA 1
Cet opérateur compare les valeurs des opérandes situés de part et d'autre. Si la valeur numérique de l'opérande de gauche est inférieure à celle de l'opérande de droite, l'expression est évaluée comme true. Pour comparer les valeurs, les chaînes de caractères sont converties en valeurs Unicode.
Exemple
    if (a < b) {
        ...
    }

% | NN 2 IE 3 ECMA 1
Cet opérateur divise le nombre sur sa gauche par le nombre sur sa droite. Si la division produit un reste, l'expression est évaluée à la valeur de ce reste entier. En l'absence de reste, la valeur renvoyée est zéro. Les deux opérandes doivent être des nombres. Une expression contenant cet opérateur produit un nombre. Même si la valeur du reste (modulo) ne vous intéresse pas, cet opérateur permet de déterminer rapidement si deux valeurs sont multiples.
Exemple
    if ((dayCount % 7) > 0) {
        ...
    }

* | NN 2 IE 3 ECMA 1
Cet opérateur multiplie le nombre de gauche par le nombre de droite. Les deux opérandes doivent être des nombres. Une expression contenant cet opérateur produit un nombre.
Exemple
    var myProduct = number1 * number2;

- | NN 2 IE 3 ECMA 1
Il s’agit de l’opérateur de négation. Cet opérateur unaire inverse la valeur de l'opérande. Par exemple, dans les instructions suivantes :
    a = 5;
    b = -a;
la valeur de b devient -5. Un opérateur de négation appliqué à une valeur négative renvoie une valeur positive.
Exemple
    var myOpposite = -me;

new | NN 2 IE 3 ECMA 1
L’opérateur new crée des instances des objets statiques ECMA standards suivants : Array Boolean Date Fonction Nombre Object RegExp String
Une expression contenant cet opérateur est évaluée comme une instance de l'objet. En d’autres termes, lors de l’invocation de cet opérateur, JavaScript recherche une fonction constructeur du même nom. Ainsi, l’opérateur new fonctionne aussi avec des objets personnalisés formés par le biais de fonctions constructeurs personnalisées. Il fonctionne aussi dans IE pour Windows pour la création d’instances d’objets propriétaires, tels que les objets ActiveX et VBArray.
Les règles syntaxiques permettent de nommer l'objet statique, l'objet statique avec des parenthèses vides et l'objet statique avec des paramètres entre parenthèses :
    var myArray = new Array;
    var myArray = new Array( );
    var myArray = new Array("Larry", "Moe", "Curly");
Seuls les deux derniers exemples sont garantis comme fonctionnant dans toutes les versions de navigateur gérables par script. A l'exception de l'objet Date, si vous omettez d'affecter des paramètres durant la création de l'objet d’origine, la nouvelle instance créée n'a que les propriétés affectées au prototype de l'objet statique.
Exemple
    var now = new Date( );

! | NN 2 IE 3 ECMA 1
Il s’agit de l’opérateur NOT. Cet opérateur unaire est évalué comme la valeur négative d'un opérande booléen. Il convient d'utiliser l'opérateur NOT avec des valeurs booléennes explicites telles que le résultat d'une comparaison ou un paramétrage de propriété booléenne.
Exemple
    if (a == !b) {
        ...
    }

|| | NN 2 IE 3 ECMA 1
L’opérateur OR compare deux expressions booléennes pour vérifier si elles sont égales. Si l'une des deux expressions est évaluée comme true, le résultat produit par l'opérateur || est également évalué comme true si les deux expressions sont évaluées comme false, l'opérateur est évalué comme false. Une expression booléenne peut consister en l'expression d'une comparaison (à l'aide des nombreux opérateurs de comparaison disponibles) ou en une série d'autres valeurs. La présentation de l'opérateur AND résume les types de données et valeurs les plus fréquents, avec la valeur booléenne correspondante.
Vous pouvez créer des conditions composées à l'aide de l'opérateur ||. Par exemple, si vous voulez vérifier si l’une des deux conditions ou les deux à la fois sont vraies, vous pouvez créer une condition telle que :
    var userEntry1 = document.forms[0].entry1.value;
    var userEntry2 = document.forms[0].entry2.value;
    if (userEntry1 || userEntry2) {
        ...
    }
Dans la condition composée, l'opérateur || recherche si les opérandes sont true avant d'évaluer la condition comme true. Si l'utilisateur a saisi du texte dans le premier champ, la condition est court-circuitée du fait qu'une valeur true pour un seul opérande génère un résultat true. Si l'utilisateur n'a entré du texte que dans le second champ, le second opérande est évalué. Puisqu'elle évalue comme true une chaîne non vide, la condition est évaluée comme true. Ce n'est que lorsque les deux opérandes sont évalués comme false que la condition composée est évaluée comme false.
Exemple
    if (a <= b || b >= c) {
        ...
    }

=== | NN 4 IE 4 ECMA 2
Cet opérateur compare les valeurs de deux opérandes et renvoie un résultat booléen. Tant la valeur que le type de données des deux opérandes doivent être identiques pour que l'opérateur renvoie true (pas de conversions de types de données automatiques). Voir l'opérateur d'égalité (==) pour des comparaisons d’égalité moins strictes.
Exemple
    if (n === m) {
        ...
    }

!== | NN 3 IE 4 ECMA s.o.
Cet opérateur compare les valeurs de deux opérandes et renvoie un résultat booléen. Tant la valeur que le type de données des deux opérandes doivent être identiques pour que l'opérateur renvoie false. Pour des comparaisons moins strictes, reportez-vous à l’opérateur d’inégalité (!=).
Exemple
    if (n !== m) {
        ...
    }

for | NN 2 IE 3 ECMA 1
Construction permettant l'exécution répétée d'instructions, généralement pour un nombre de fois précis déterminé.
Exemple
    var userEntry = document.forms[0].entry.value;
    var oneChar;
    for (var i = 0; i < userEntry.length; i++) {
        oneChar = userEntry.charAt(i);
        if (oneChar < "0" || oneChar > "9") {
            alert("The entry must be numerals only.");
        }
    }

for/in | NN 2 IE 3 ECMA 1
Variante de la boucle for ordinaire, capable d'extraire les noms et valeurs de propriété d'un objet. Seules les propriétés (et dans Netscape 6, les méthodes) définies comme énumé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énérés par scripts personnalisés.
Exemple
    function showProps( ) {
        objName = "image";
        obj = document.images[0];
        var msg = "";
        for (var i in obj) {
            msg += objName + "." + i + "=" + obj[i] + "\n";
        }
        alert(msg);
    }

- | NN 2 IE 3 ECMA 1
Cet opérateur soustrait le nombre de droite du nombre de gauche. Les deux opérandes doivent être des nombres. Une expression contenant cet opérateur produit un nombre.
Exemple
    var myDifference = number1 - number2;

switch/case | NN 4 IE 4 ECMA 3
Fournit un raccourci vers des chemins d'exécution pour de nombreuses conditions d'une expression. L’instruction break facultative à la fin de chaque bloc case raccourcit l’exécution de l’instruction switch et empêche aussi l’exécution accidentelle du bloc default s’il est présent.
Exemple
    var productList = document.forms[0].prodList;
    var chosenItem = productList.options[productList.selectedIndex].value;
    switch(chosenItem) {
        case "Small Widget":
            document.forms[0].price.value = "44.95";
            break
        case "Medium Widget":
            document.forms[0].price.value = "54.95";
            break
        case "Large Widget":
            document.forms[0].price.value = "64.95";
            break
        Par défaut :
            document.forms[0].price.value = "Nothing Selected";
    }

this | NN 2 IE 3 ECMA 1
Fait référence à l’objet considéré. Par exemple, dans un gestionnaire d'événements d'objet de contrôle de formulaire, vous pouvez transmettre l'objet comme paramètre à la fonction :
    <input type="text" name="ZIP" onchange="validate(this);>"
Dans un constructeur d'objet personnalisé, le mot-clé fait référence à l'objet lui-même, vous permettant d'affecter des valeurs à ses propriétés (tout en créant les propriétés) :
    function CD(label, num, artist) {
        this.label = label;
        this.num = num;
        this.artist = artist;
    }
A l'intérieur d'une fonction, le mot-clé this désigne l'objet fonction. Cependant, si la fonction est affectée comme méthode d’un constructeur d’objets personnalisés, this fait référence à l’instance de l’objet dans le contexte duquel la fonction s’exécute.
Exemple
    <input type="text" name="phone" onchange="validate(this.value);">

throw | NN 6 IE 5 ECMA 3
Déclenche une condition d’exception, transmettant une valeur avec l’exception. Bien que la valeur que vous transmettiez puisse être une simple chaîne, idéalement, vous devriez transmettre une instance de l’objet Error JavaScript suffisamment remplie d’informations pour qu’une instruction catch puisse réagir intelligemment à l’erreur. Une instruction throw doit être incluse dans la portion try d’une construction try-catch.
Exemple
    function processNumber(inputField) {
        try
            var inpVal = parseInt(inputField.value, 10);
            if (isNaN(inpVal)) {
                var msg = "Please enter a number only.";
                var err = new Error(msg);
                if (!err.message) {
                    err.message = msg;
                }
                throw err;
            }
            // process number
        }
        catch (e) {
            alert(e.message);
            inputField.focus( );
            inputField.select( );
        }
    }

try/catch | NN 6 IE 5 ECMA 3
Cette construction fournit une façon non perturbatrice de piéger les erreurs (exceptions) et de les traiter élégamment. Les deux parties de cette construction de traitement des exceptions sont obligatoires. Si une erreur se produit dans la portion try, l’exécution passe immédiatement à la portion catch, où vos scripts peuvent afficher des boîtes de dialogue d’alerte, modifier des données ou effectuer toute autre tâche qui empêche l’interpréteur JavaScript de déclencher un message d’erreur gênant. Les exceptions qui se produisent naturellement (c’est-à-dire qui ne sont pas déclenchées par une instruction throw) transmettent une instance de l’objet Error en tant que paramètre à la section catch. Les instructions au sein de la section catch peuvent passer en revue les propriétés de l’objet d’erreur afin de déterminer comment traiter les exceptions qui arrivent à cet endroit. Ainsi, une portion catch peut traiter des erreurs de différents types.
Vous pouvez utiliser les constructions try/catch uniquement dans les navigateurs qui les prennent en charge. Pour protéger les anciens navigateurs de cette construction, placez tout le code affecté dans une balise <script> nécessitant explicitement JavaScript 1.5 ou version ultérieure (avec l’attribut language = "JavaScript1.5").
Exemple
    function insertOneNode(baseNode, newNode, position) {
        try
            baseNode.insertBefore(newNode, baseNode.childNodes[position]);
        }
        catch (e) {
            // handle W3C DOM Exception types
            switch (e.name) {
                case "HIERARCHY_REQUEST_ERR" :
                    // process bad tree hierarchy reference
                    break
                case "NOT_FOUND_ERR" :
                    // process bad refNode reference
                    break
                Par défaut :
                    // process all other exceptions
            }
        }
        return true;
    }

typeof | NN 3 IE 3 ECMA 1
L’opérateur typeof renvoie l'une des six descriptions sous forme de chaîne du type de données d'une valeur. Les types renvoyés sont : boolean function number object string undefined
Le type d'objet peut également être un tableau. Toutefois, l'opérateur ne fournit pas d'autres informations sur le type d'objet ou tableau de la valeur (reportez-vous à l’opérateur instanceof).
Exemple
    if (typeof someVar == "string") {
        ...
    }

void | NN 3 IE 4 ECMA 1
Cet opérateur unaire évalue l'expression de droite mais renvoie une valeur undefined (indéfinie), même si l'expression (comme un appel de fonction) est évaluée à une certaine valeur. Cet opérateur est généralement utilisé avec des pseudo-URL javascript: appelant des fonctions. Si la fonction renvoie une valeur, celle-ci est ignorée par l'expression qui l'a appelée.
Exemple
    <a href="javascript: void getSound( );" >...</a>

while | NN 2 IE 3 ECMA 1
Exécute des instructions en boucle tant qu'une condition est vraie. La condition étant testée en début de boucle, il est possible que, dans certains cas, les instructions de la boucle ne s'exécutent pas. Il est impératif que la valeur de l'expression constituant la condition soit potentiellement modifiée dans les instructions. Sinon, la boucle devient infinie.
Exemple
    var i = 0;
    while (!document.forms[0].radioGroup[i].checked) {
        i
    }
    alert("You selected item number " + (i+1) + ".");

with | NN 2 IE 3 ECMA 1
L'instruction with ajoute un objet à l'étendue de chaque instruction imbriquée. Ceci permet de raccourcir le code de certains groupes d'instructions basés sur une référence à un objet particulier. Remarque: Les constructions with sont généralement très inefficaces. Vous pouvez obtenir de meilleures performances en affectant la référence de l’objet à une variable locale et en utilisant cette variable dans votre fonction.
Exemple
    with (document.forms[0]) {
        name1 = firstName.value;
        name2 = lastName.value;
        mail = eMail.value;
    }

return | NN 2 IE 3 ECMA 1
Interrompt l'exécution de la fonction considérée. Il est possible de placer une instruction return à un endroit quelconque de la fonction, y compris dans les structures de contrôle. Vous pouvez éventuellement spécifier une valeur à renvoyer à l'instruction initiale. Cette valeur peut être n’importe quel type de données JavaScript. Lorsqu'une instruction return appelée à renvoyer une valeur se trouve dans une boucle ou une autre structure de contrôle, il faut prévoir une instruction return pour chaque branche de l'arbre d'exécution, notamment une instruction return par défaut, pour le cas où l'exécution atteindrait la portée de l'exécution principale, à la fin ou près de la fin de la fonction.
Exemple
    function validateNumber(form) {
        var oneChar;
        for (var i = 0; i < userEntry.length; i++) {
            oneChar = form.entry.value.charAt(i);
            if (oneChar < "0" || oneChar > "9") {
                return false
            }
        }
        return true;
    }

+= | NN 2 IE 3 ECMA 1
Il s’agit de l’opérateur d’ajout par valeur. Cette classe d'opérateur combine un opérateur d'affectation ordinaire (=) avec l'un des nombreux autres opérateurs, afin de produire l'affectation en effectuant l'opération définie par l'opérande de gauche avec la valeur de l'opérande de droite. Par exemple, si une variable nommée a contient une chaîne, vous pouvez ajouter une chaîne à la fin de a à l'aide de l'opérateur += :
    a += " and some more.";
Sans cet opérateur d’addition d’une valeur, l'opération devrait être structurée comme suit :
    a = a + " and some more";
Le tableau suivant montre tous les opérateurs d'affectation qui fonctionnent de cette manière :
Opérateur | Exemple | Equivalent
--- | --- | ---
+= | a += b | a = a + b
-= | a -= b | a = a - b
*= | a *= b | a = a * b
/= | a /= b | a = a / b
%= | a %= b | a = a % b
<<= | a <<= b | a = a << b
>>= | a >>= b | a = a >> b
>>>= | a >>>= b | a = a >>> b
&= | a &= b | a = a & b
|= | a |= b | a = a | b
^= | a ^= b | a = a ^ b
Exemple
    output += "<H1>Section 2</H1>";
    		total *= .95;

+ | NN 2 IE 3 ECMA 1
L’opérateur d’addition fonctionne avec les chiffres et les chaînes, mais ses résultats varient en fonction des types de données de ses opérandes. Lorsque les deux opérandes sont des nombres, le résultat est la somme des nombres ; lorsque les deux opérandes sont des chaînes, le résultat est une concaténation des chaînes (dans l'ordre de l'addition) ; lorsqu'un opérande est un nombre et l'autre une chaîne, les données de type nombre sont converties en données de type chaîne, puis les deux chaînes sont concaténées. Pour convertir un opérande de type chaîne en opérande de type nombre, utilisez l'une des fonctions parseInt() ou parseFloat().
Exemple
    var mySum = number1 + number2;
    var newString = "string1" + "string2";

&& | NN 2 IE 3 ECMA 1
L’opérateur AND compare deux expressions booléennes pour vérifier si elles sont égales. Si l'une des deux expressions est évaluée comme true, le résultat produit par l'opérateur || est également évalué comme true si les deux expressions sont évaluées comme false, l'opérateur est évalué comme false.
Une expression booléenne peut consister en l'expression d'une comparaison (à l'aide des nombreux opérateurs de comparaison disponibles) ou en une série d'autres valeurs. Voici les types de données et valeurs les plus fréquents, avec la valeur booléenne correspondante.
Type de données | Equivalent booléen
--- | ---
Nombre autre que zéro | true
Zéro | false
Toute chaîne de texte non vide | true
Chaîne vide | false
Tout objet | true
null | false
undefined | false
Ces informations permettent de créer des conditions composées à l'aide de l'opérateur 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érieur à 100, la condition ressemblera à ceci :
    var userEntry = document.forms[0].entry.value ;
    if (userEntry&& parseInt(userEntry) >= 100) {
        ...
    }
Si l'utilisateur n'a saisi aucune valeur, la chaîne est vide. Dans la condition composée, si le premier opérande est évalué comme false, les règles de l'opérateur signifient que l'expression entière renvoie la valeur false (du fait que les deux opérandes doivent être true pour que l'opérateur renvoie true). Comme l'évaluation d'expressions telles qu'une condition composée s'effectue de gauche à droite, la valeur false du premier opérande court-circuite la condition pour renvoyer false, de sorte que le second opérande n'est pas évalué.
Exemple
    if (a <= b && b >= c) {
        ...
    }

break | NN 2 IE 3 ECMA 1
Interrompt l'exécution de la boucle considérée et renvoie le contrôle à l'instruction de script qui suit la boucle en question. A défaut de paramètre d'étiquette défini, sachez que l'instruction break porte sur sa propre boucle. Pour sortir d'une boucle imbriquée, affectez des étiquettes à chaque calque imbriqué et utilisez l'étiquette de votre choix comme paramètre de l'instruction break. Voir l'instruction label (uniquement disponible depuis Navigator 4 et Internet Explorer 4).
Exemple
Reportez-vous à l’instruction label.

continue | NN 2 IE 3 ECMA 1
Interrompt l'itération considérée de la boucle et retourne au début de celle-ci pour recommencer (en exécutant l'expression mise à jour éventuellement spécifiée dans une boucle for). Si vous utilisez des constructions de boucle imbriquée, affectez des étiquettes à chaque calque imbriqué, puis utilisez l'étiquette de votre choix comme paramètre de l'instruction continue. Voir l'instruction label (uniquement disponible depuis Navigator 4 et Internet Explorer 4).
Exemple
    outerLoop:
    for (var i = 0; i <= maxValue1; i++) {
        for (var j = 0; j <= maxValue2; j++) {
            if (j*i == magic2) {
                continue outerLoop;
            }
        }
    }

catch | NN 2 IE 3 ECMA 1
Voir try.