mozilla
Vos résultats de recherche

    Expressions et opérateurs

    Ce chapitre aborde les expressions et les opérateurs en JavaScript, il inclue des notions sur les opérateurs d'affectation, de comparaison, les opérateurs arithmétiques, binaires, logiques, ceux qui s'appliquent sur les chaînes de caractères ainsi que les opérateurs spéciaux.

    Expressions

    Une expression correspond à toute unité de code valide qui se résoud pour donner une valeur.

    En termes de concepts, il y a deux types d'expressions : celles qui affectent une valeur à une variable et celles qui ont simplement une valeur.

    L'expression x = 7 correspond au premier type. Cette expression utilise l'opérateur = afin d'affecter la valeur sept à la variable x. L'expression elle-même est évaluée à sept.

    Le code 3 + 4 correspond au second type d'expression. Cette expression utilise l'opérateur  + afin d'additionner trois et quatre. Le résultat, sept, n'est pas assigné à une variable.

    JavaScript possède les catégories d'expressions suivantes:

    • Les expressions arithmétiques : évaluées comme un nombre, par exemple 3.14159 (généralement construites avec les opérateurs arithmétiques)
    • Les expressions de chaînes de caractères : évaluées comme une chaîne de caractères, comme "Fred" ou "234" (généralement construites avec les opérateurs de chaînes)
    • Les expressions logiques : évaluées à true ou false (généralement construites avec les opérateurs logiques)
    • Les expressions objet : évaluées comme un objet (généralement construites avec des opérateurs spéciaux)

    Opérateurs

    JavaScript possède différents types d'opérateurs. Cette section décrit les opérateurs et certaines informations sur les priorités entre opérateurs.

    JavaScript utilise des opérateurs binaires et unaires, ainsi qu'un opérateur ternaire spécial (l'opérateur conditionnel). Un opérateur binaire utilise deux opérandes, un précédant l'opérateur et un lui succédant :

    opérande1 opérateur opérande2
    

    Par exemple : « 3+4 » ou « x*y ».

    Un opérateur unaire ne nécessite qu'un opérande, avant ou après l'opérateur :

    opérateur opérande

    ou

    opérande opérateur

    Comme « x++ » ou « ++x ».

    Opérateurs d'affectation

    Un opérateur d'affectation assigne une valeur à son opérande gauche, valeur basée sur celle de l'opérande droit. L'opérateur d'affectation simple est le signe égal (=), il assigne la valeur de l'opérande droit à l'opérande gauche. Autrement dit, avec « x = y » on affecte la valeur y à x.

    D'autres opérateurs d'affectation sont des raccourcis correspondant à certaines opérations, ils sont énumérés dans le tableau qui suit :

    Tableau 3.1 Opérateurs d'affectation
    Opérateur de raccourci Signification
    x += y x = x + y
    x -= y x = x - y
    x *= y x = x * y
    x /= y x = x / y
    x %= y x = x % y
    x <<= y x = x << y
    x >>= y x = x >> y
    x >>>= y x = x >>> y
    x &= y x = x & y
    x ^= y x = x ^ y
    x |= y x = x | y

    Opérateurs de comparaison

    This seems to me kind of poorly explained, mostly the difference betwen "==" and "==="... Un opérateur de comparaison compare ses deux opérandes et renvoie un valeur booléene correspondant au résultat de la comparaison (vraie ou fausse). Les opérandes peuvent être des nombres, des chaînes de caractères, des booléens ou des objets. Les chaînes de caractères sont comparées selon l'ordre lexicographique usuel en utilisant les valeurs Unicode. Dans la plupart des cas, si les deux opérandes ne sont pas du même type, JavaScript tentera de les convertir vers un type approprié. Cette méthode aboutira souvent en une comparaison numérique. Les seules exceptions à cette conversion implicite sont les opérateurs === et !== , qui testent des égalités et inégalités strictes. Ces opérateurs n'effectuent pas de conversion de type. Le tableau qui suit décrit les opérateurs de comparaisons relativement à ce fragment de code :

    var var1 = 3, var2 = 4;
    
    Tableau 3.2 Opérateurs de comparaison
    Opérateur Description Exemples qui renvoient true
    Égalité (==) Renvoie true si les opérandes sont égaux. 3 == var1

    "3" == var1

    3 == '3'
    Inégalité (!=) Renvoie true si les opérandes sont différents. var1 != 4
    var2 != "3"
    Égalité stricte (===) Renvoie true si les opérandes sont égaux et de même type. Voir Object.is et égalité de type en JavaScript. 3 === var1
    Inégalité stricte (!==) Renvoie true si les opérandes ne sont pas égaux et/ou ne sont pas de même type. var1 !== "3"
    3 !== '3'
    Supériorité stricte (>) Renvoie true si l'opérande gauche est supérieur (strictement) à l'opérande droit. var2 > var1
    "12" > 2
    Supériorité ou égalité (>=) Renvoie true si l'opérande gauche est supérieur ou égal à l'opérande droit. var2 >= var1
    var1 >= 3
    Infériorité stricte (<) Renvoie true si l'opérande gauche est inférieur (strictement) à l'opérande droit. var1 < var2
    "2" < "12"
    Infériorité ou égalité (<=) Renvoie true si l'opérande gauche est inférieur ou égal à l'opérande droit. var1 <= var2
    var2 <= 5

    Opérateurs arithmétiques

    Les opérateurs arithmétiques ont pour opérandes des valeurs numériques (des littéraux ou des variables) et renvoient une valeur numérique. Les opérateurs arithmétiques standards sont l'addition (+), la soustraction (-), la multiplication (*), et la division (/). Ces opérateurs fonctionnent comme pour la plupart des langages de programmation lorsqu'ils sont utilisés avec des nombres décimaux (on notera que la division par zéro a pour résultat Infinity). Ainsi :

    console.log(1 / 2); /* affiche 0.5 */
    console.log(1 / 2 == 1.0 / 2.0); /* renvoie true */
    

    JavaScript fournit également d'autres opérateurs arithmétiques, listés dans le tableau qui suit :

    Tableau 3.3 Opérateurs arithmétiques
    Opérateur Description Exemple
    %
    (Modulo)
    Opérateur binaire. Renvoie le reste entier de la division entre les deux opérandes. 12 % 5 renvoie 2.
    ++
    (Incrément)
    Opérateur unaire. Ajoute un à son opérande. S'il est utilisé en préfixe (++x), il renvoie la valeur de l'opérande après avoir ajouté un, s'il est utilisé comme opérateur de suffixe (x++), il renvoie la valeur de l'opérande avant d'ajouter un. Si x vaut 3, ++x incrémente x à 4 et renvoie 4, x++ renvoie 3 et seulement ensuite ajoute un à x.
    --
    (Décrément)
    Opérateur unaire. Il soustrait un à son opérande. Il fonctionne de manière analogue à l'opérateur d'incrément. Si x vaut 3, --x décrémente x à 2 puis renvoie2, x-- renvoie 3 puis décrémente la valeur de x.
    -
    (Négation unaire)
    Opérateur unaire. Renvoie la valeur opposée de l'opérande. Si x vaut 3, alors -x renvoie -3.

    Opérateurs binaires

    Les opérateurs binaires voient leurs opérandes comme des ensembles de 32 bits (des zéros et des uns), et non pas comme des nombres décimaux, octaux ou hexadécimaux. Ainsi, le nombre décimal neuf aura une représentation binaire de 1001. Les opérateurs binaires effectuent des opérations sur des représentations binaires mais renvoies des valeurs numériques JavaScript standards.

    Le tableau qui suit résume les opérateurs binaires JavaScript :

    Tableau 3.4 Opérateurs binaires
    Opérateur Utilisation Description
    AND (ET) binaire a & b Renvoie un 1 à chaque position binaire pour laquelle les bits des deux opérandes sont à 1.
    OR (OU) binaire a | b Renvoie un 1 à chaque position binaire pour laquelle au moins un des bits des deux opérandes est à 1.
    XOR (OU exclusif) binaire a ^ b Renvoie un 1 à chaque position binaire pour laquelle au plus un des bits des deux opérandes est à 1.
    NOT (NON) binaire ~ a Inverse les bits de l'opérande.
    Décalage binaire à gauche a << b Décale la représentation binaire de b bits sur la gauche et complète avec des zéros à droite.
    Décalage binaire à droite a >> b Décale la représentation binaire de b bits sur la droite en ignorant les bits perdus.
    Décalage binaire à droite en complétant avec des zéros a >>> b Décale la représentation binaire de b bits sur la droite en ignorant les bits perdus et ajoute des zéros sur la gauche.

    Opérateurs binaires logiques

    Les opérateurs binaires logiques fonctionnent de cette façon :

    • Les opérandes sont convertis en entiers sur 32 bits et exprimés comme une série de bits (des 1 et des 0).
    • Chaque bit du premier opérande est associé avec le bit correspondant du second opérande (le premier bit du premier opérande avec le premier bit du second opérande, le second avec le second et ainsi de suite)
    • L'opérateur est appliqué pour chaque paire de bits ainsi constituée et le résultat est reconstruit sous forme binaire.

    Le chiffre neuf est par exemple représenté comme 1001, et le nombre quinze comme 1111. Ainsi, quand les opérateurs binaires sont appliqués sur ces valeurs, on a les résultats qui suivent :

    Tableau 3.5 Exemples utilisant les opérateurs binaires
    Expression Résultat Description binaire
    15 & 9 9 1111 & 1001 = 1001
    15 | 9 15 1111 | 1001 = 1111
    15 ^ 9 6 1111 ^ 1001 = 0110
    ~15 -16 ~00000000...00001111 = 11111111...11110000
    ~9 -10 ~00000000...00001001 = 11111111...11110110

    Il faut remarquer que tous les bits sont échangés lorsque l'opérateur binaire NOT est utilisé. Il est donc utile de savoir que les valeurs dont le bit le plus fort (le plus à gauche) vaut 1 sont des nombres négatifs (représentation en complément à deux).

    Opérateurs binaires de décalage

    Les opérateurs binaires de décalage utilisent deux opérandes : le premier indiquant la quantité à décaler et le second indiquant de combien de bits on décale le premier opérande. La direction du décalage est spécifiée grâce à l'opérateur.

    Les opérateurs binaires de décalage convertissent leurs opérandes en entiers sur 32 bits et renvoient un résultat dont le type est le même que l'opérande gauche.

    Les opérateurs de décalage sont énumérés dans le tableau qui suit.

    Tableau 3.6 Opérateurs binaires de décalage
    Opérateur Description Exemple
    <<
    (Décalage à gauche)
    Cet opérateur décale le premier opérande d'un certain nombre de bits sur la gauche. Les bits en trop sont ignorés et des bits à zéro sont introduits à droite. 9<<2 renvoie 36, car 1001, décalé de 2 bits à gauche, devient  100100, dont la représentation en base 10 est  36.
    >>
    (Décalage à droite avec propagation du signe)
    Cet opérateur décale le premier opérande d'un certain nombre de bits sur la droite. Les bits en trop sont ignorés et des bits correspondant au bit de signe sont introduits à gauche. 9>>2 renvoie 2, car 1001, décalé de 2 bits à droite, devient 10 représentant 2. De même  -9>>2 renvoie -3, car le signe est préservé.
    >>>
    (Décalage à droite avec zéros)
    Cet opérateur décale le premier opérande d'un certain nombre de bits sur la droite.  Les bits en trop sont ignorés et des bits à 0 sont introduits à gauche. 19>>>2 renvoie 4, car 10011, décalé de 2 bits, devient 100 qui représente 4. Pour les nombres positifs, cet opérateur et l'opérateur précédent renvoient les mêmes résultats.

    Opérateurs logiques

    Les opérateurs logiques sont généralement utilisés avec des valeurs booléennes. Dans ce cas, il renvoient une valeur booléenne. Les opérateurs && et || renvoient en fait une valeurs d'un des opérandes et si ces opérateurs sont utilisés avec des valeurs non-booléennées, ils pourront renvoyer une valeur non-booléenne. Les opérateurs logiques sont décrits dans le tableau qui suit.

    Tableau 3.6 Opérateurs logiques
    Opérateur Usage Description
    && expr1 && expr2 (ET logique) renvoie expr1 s'il peut être converti à false, sinon renvoie expr2. Dans le cas où on utilise des opérandes booléens, && renvoie true si les deux opérandes valent true, false sinon.
    || expr1 || expr2 (OU logique) renvoie expr1 s'il peut être converti à true, sinon renvoie expr2. Dans le cas où on utilise des opérandes booléens, || renvoie true si l'un des opérandes vaut true, si les deux valent false, il renvoie false.
    ! !expr (NON logique) renvoie false si son seul opérande peut être converti en true, sinon il renvoie true.

    Les exemples d'expressions qui peuvent être converties à false sont celles qui sont évaluer à null, 0, NaN, la chaîne de caractères vide (""), ou undefined.

    Le code qui suit montre des exemples de l'utilisation de l'opérateur logique ET (&&).

    var a1 = true && true;       // t && t renvoie true
    var a2 = true && false;      // t && f renvoie false
    var a3 = false && true;      // f && t renvoie false
    var a4 = false && (3 == 4);  // f && f renvoie false
    var a5 = "Chat" && "Chien";  // t && t renvoie Chien
    var a6 = false && "Chat";    // f && t renvoie false
    var a7 = "Chat" && false;    // t && f renvoie false
    

    Les exemples suivants montrent l'utilisation de l'opérateur logique OU (||).

    var o1 =   true || true;     // t || t renvoie true
    var o2 =  false || true;     // f || t renvoie true
    var o3 =   true || false;    // t || f renvoie true
    var o4 =  false || (3 == 4); // f || f renvoie false
    var o5 = "Chat" || "Chien";  // t || t renvoie Chat
    var o6 =  false || "Chat";   // f || t renvoie Chat
    var o7 = "Chat" || false;    // t || f renvoie Chat
    

    Les exemples suivants montrent l'utilisation de l'opérateur logique NON (!).

    var n1 = !true;   // !t renvoie false
    var n2 = !false;  // !f renvoie true
    var n3 = !"Chat"; // !t renvoie false
    

    Evaluation rapide

    Les expressions logiques sont évaluées de gauche à droite. Cette évaluation utilise des tests pour savoir s'il est possible d'utiliser des « raccourcis » correspondant aux règles suivantes :

    • false && n'importe quoi sera évalué à false.
    • true || n'importe quoi sera évalué à true.

    Les règles logiques garantissent la validité de ces évaluations, il faut noter que le second opérande n'est pas du tout évalué, empêchant ainsi les conséquences cachées de cette évaluation.

    Opérateurs de chaînes de caractères

    En plus des opérateurs de comparaisons qui peuvent être utilisés sur des chaînes de caractères, il existe l'opérateur de concaténation (+) permettant de concaténer deux chaînes de caractères. Le résultat de cette opération est la fusion des deux opérandes en une même chaîne de caractères : "ma " + "chaîne" renverra ainsi la chaîne de caractères "ma chaîne".

    L'opérateur court += peut également être utilisé pour concaténer des chaînes. Si on a une variable maChaine qui vaut "alpha", l'expression maChaîne += "bet" vaudra "alphabet" et la variable maChaîne prendra cette valeur.

    Opérateurs spéciaux

    JavaScript fournit un ensemble d'opérateurs spéciaux :

    Opérateur conditionnel ternaire

    L'opérateur conditionnel est le seul opérateur JavaScript qui utilise trois opérandes. L'expression utilisant l'opérateur peut prendre une valeur parmi deux selon une condition donnée. Cet opérateur s'utilise avec la syntaxe suivante :

    condition ? val1 : val2
    

    Si condition vaut true, l'opérateur vaudra val1. Sinon il vaudra val2. Il est possible d'utiliser l'opérateur conditionnel aux mêmes endroits qu'un opérateur standard.

    On peut par exemple avoir :

    var statut = (âge >= 18) ? "adulte" : "mineur";
    

    Cette instruction assigne la valeur "adulte" à la variable status si la variable âge est supérieure ou égale à 18. Sinon, on lui affecte la valeur "mineur".

    Note : Voir la page sur l'opérateur conditionnel pour plus de détails.

    La virgule comme opérateur

    L'opérateurvirgule (,) évalue ses deux opérandes et renvoie la valeur du second opérande. Cet opérateur est principalement utilisé dans les boucles for pour permettre à plusieurs variables d'être modifiées à chaque itération de la boucle.

    Ainsi, si on a un tableau à 2 dimensions avec 10 lignes et colonnes, on peut utiliser la virgule comme opérateur pour incrémenter deux variables à la fois. Le code qui suit imprime les valeurs contenues sur la diagonale du tableau :

    for (var i = 0, j = 9; i <= 9; i++, j--)
      document.writeln("a[" + i + "][" + j + "]= " + a[i][j]);
    

    Note : Voir la page sur la virgule comme opérateur pour plus de détails.

    delete

    L'opérateur delete supprime un objet, une propriété d'un objet ou un élément d'un tableau à partir de sa position dans le tableau. La syntaxe de cet opérateur est la suivante :

    delete monObjet;
    delete monObjet.propriété;
    delete monObjet[index];
    delete propriété; // uniquement valide au sein d'une instruction with
    

    où on a monObjet qui est le nom de l'objet, propriété qui est une propriété existante et index un entier indiquant la position d'un élément dans un tableau.

    La quatrième instruction n'est valide qu'au sein d'une instruction with et permet de supprimer une propriété d'un objet.

    Il est possible d'utiliser l'opérateur delete pour supprimer les variables déclarées implicitement. Si l'opérateur fonctionne correctement, il change la propriété ou l'élément vers la valeur  undefined. L'opérateur delete renvoie true si l'opération de suppression est possible, false sinon.

    x = 42;
    var y = 43;
    monobj = new Number();
    monobj.h = 4;    // création de la propriété h
    delete x;        // renvoie true (suppression possible si déclaration implicite)
    delete y;        // renvoie var (suppression impossible si déclaration avec var si la variable n'est pas une propriété)
    delete Math.PI;  // renvoie false (suppression impossible pour les propriétés pré-définies)
    delete monobj.h; // renvoie true (suppression possible des propriétés définies par l'utilisateur)
    delete monobj;   // renvoie true (suppression possible si déclaration implicite)
    
    Suppression d'éléments d'un tableau

    Lorsqu'on supprime un élément d'un tableau, la longueur du tableau n'est pas modifiée. Ainsi, si on supprime a[3], a[4] restera a[4] (même position et valeur) alors que a[3] sera undefined.

    Lorsque l'opérateur delete supprime un élément d'un tableau, cet élément n'appartient plus au tableau. Dans l'exemple qui suit, arbres[3] est supprimé mais il est toujours accessible et renvoie undefined.

    var arbres = new Array("sequoia", "laurier", "cèdre", "chêne", "érable");
    delete arbres[3];
    if (3 in arbres) {
      // Ceci ne sera pas exécuté
    }
    

    Pour qu'un élément continue à exister mais qu'il vaille undefined, on utilisera le mot-clé undefined plutôt que l'opérateur delete. Dans l'exemple qui suit, arbres[3] est modifié pour valoir undefined et l'élément du tableau continue à exister :

    var arbres = new Array("sequoia", "laurier", "cèdre", "chêne", "érable");
    arbres[3] = undefined;
    if (3 in arbres) {
      // Ceci sera exécuté
    }
    

    Note : Voir la page sur l'opérateur delete pour plus de détails.

    in

    L'opérateur in renvoie true si la propriété indiquée fait partie de l'objet donné. Cet opérateur s'utilise avec la syntaxe suivante :

    nomOuNumeroPropriete in monObjet
    

    avec nomOuNumeroPropriete qui est une chaîne de caractères ou une expression numérique correspondant au nom d'une propriété ou un indice de tableau, monObjet est le nom d'un objet.

    Les exemples qui suivent utilisent cet opérateur in.

    // Tableaux
    var arbres = new Array("sequoia", "laurier", "cèdre", "chêne", "érable");
    0 in arbres;        // renvoie true
    3 in arbres;        // renvoie true
    6 in arbres;        // renvoie false
    "laurier" in arbres;    // renvoie false (l'opérateur se base sur l'indice et pas
                       // sur la valeur)
    "length" in arbres; // renvoie true (length est une propriété d'un objet Array)
    
    // Objets pré-définis
    "PI" in Math;          // renvoie true
    var myString = new String("coral");
    "length" in myString;  // renvoie true
    
    // Objets définis par l'utilisateur
    var maVoiture = {fabricant: "Honda", modèle: "Accord", year: 1998};
    "fabricant" in maVoiture;  // renvoie true
    "modèle" in maVoiture; // renvoie true
    

    Note : Voir la page sur l'opérateur in pour plus de détails.

    instanceof

    L'opérateur instanceof renvoie true si l'objet donné est du type spécifié. Cet opérateur s'utilise avec la syntaxe suivante :

    nomObjet instanceof typeObjet
    

    avec nomObjet qui est le nom de l'objet dont on souhaite comparer le type à typeObjet, typeObjet étant un type d'objet tel que Date ou Array.

    instanceof peut être utilisé pour confirmer le type d'un objet pendant l'exécution. Ainsi on peut gérer les exceptions en prévoyant différents cas pour différents types d'exception éventuellement jetée.

    Dans l'exemple qui suit, le code utilise l'opérateur instanceof afin de déterminer si jour est un objet Date. C'est le cas et les instructions contenues dans le bloc après l'instruction if sont donc exécutées.

    var jour = new Date(2007, 01, 22);
    if (jour instanceof Date) {
      // instructions à exécuter
    }
    

    Note : Voir la page sur l'opérateur instanceof pour plus de détails.

    new

    L'opérateur new permet de créer une instance d'un objet défini par l'utilisateur ou d'un objet dont le type est Array, Boolean, Date, Function, Image, Number, Object, Option, RegExp, ou String. Côté serveur, on pourra également utiliser les types d'objet suivants DbPool, Lock, File, ou SendMail. Cet opérateur utilise la syntaxe suivante :

    var nomObjet = new typeObjet([param1, param2, ..., paramN]);
    

    Il également possible de créer des objets en utilisant des initialiseurs d'objets.

    Voir la page sur l'opérateur new de la Référence JavaScript pour plus d'informations.

    this

    Le mot-clé this permet de faire référence à l'objet courant. En général, on l'utilise au sein d'une méthode pour faire référence à l'objet qui a utilisé la méthode. Il s'utilise de cette façon :

    this["nomPropriete"]
    
    this.nomPropriete

    Premier exemple
    Soit une fonction qui valide un objet si sa propriété value est comprise entre deux valeurs :

    function valide(obj, valMin, valMax){
      if ((obj.value < valMin) || (obj.value > valMax))
        alert("Valeur incorrecte !");
    }
    

    Il est possible d'appeler valide pour chaque gestionnaire d'événement onChange des éléments du formulaire, et d'utiliser le mot-clé this pour passer l'élément même en argument :

    <B>Entrez un nombre entre 18 et 99:</B>
    <INPUT TYPE="text" NAME="age" SIZE=3
       onChange="valide(this, 18, 99);">
    

    Second exemple
    Lorsqu'il est combiné avec la propriété form, le mot-clé this permet de faire référence l'objet formulaire parent. Dans l'exemple ci-après, le formulaire monFormulaire contient un objet  Text et un bouton. Lorsque l'utilisateur clique sur le bouton, la valeur de l'objet Text prend pour valeur le nom du formulaire. Le gestionnaire d'événement du bouton onClick utilise this.form en référence à monFormulaire.

    <FORM NAME="monFormulaire">
    Form name:<INPUT TYPE="text" NAME="texte1" VALUE="Licorne"/>
    <INPUT NAME="bouton1" TYPE="button" VALUE="Le nom du formulaire"
       onClick="this.form.text1.value = this.form.name;"/>
    </FORM>
    

    Note : Voir la page sur l'opérateur this pour plus de détails.

    typeof

    L'opérateur typeof peut être utilisé de deux façons distinctes :

    1. typeof opérande
    2. typeof (opérande)
      

    L'opérateur typeof renvoie une chaîne de caractères indiquant le type de l'opérande (qui n'est pas évalué). opérande correspond à la chaîne de caractère, la variable, le mot-clé ou l'objet dont on souhaite renvoyer le type. L'utilisation des parenthèses est facultative.

    Soient les définitions de variables suivantes :

    var maFonction = new Function("5 + 2");
    var forme = "round";
    var taille = 1;
    var jour = new Date();
    

    L'opérateur typeof renverra les résultats suivants :

    typeof maFonction; // renvoie "function"
    typeof forme;      // renvoie "string"
    typeof taille;     // renvoie "number"
    typeof jour;       // renvoie "object"
    typeof inexistant; // renvoie "undefined"
    

    En ce qui concerne les mots-clés true et null, l'opérateur typeof renvoie les résultats suivants :

    typeof true; // renvoie "boolean"
    typeof null; // renvoie "object"
    

    Pour une chaîne de caractères ou un nombre, typeof renvoie les résultats suivants :

    typeof 62;            // renvoie "number"
    typeof 'Hello world'; // renvoie "string"
    

    L'opérateur typeof, lorsqu'il est utilisé avec des propriétés, renvoie le type de valeur contenue dans la propriété :

    typeof document.lastModified; // renvoie "string"
    typeof window.length;         // renvoie "number"
    typeof Math.LN2;              // renvoie "number"
    

    Pour les méthodes et les fonctions, l'opérateur typeof renvoie les résultats suivants :

    typeof blur;        // renvoie "function"
    typeof eval;        // renvoie "function"
    typeof parseInt;    // renvoie "function"
    typeof shape.split; // renvoie "function"
    

    Pour les objets pré-définis, l'opérateur typeof fonctionne ainsi :

    typeof Date;     // renvoie "function"
    typeof Function; // renvoie "function"
    typeof Math;     // renvoie "object"
    typeof Option;   // renvoie "function"
    typeof String;   // renvoie "function"
    

    Note : Voir la page sur l'opérateur typeof pour plus de détails.

    void

    L'opérateur void peut être utilisé de deux façons :

    1. void (expression)
      
    2. void expression
      

    L'opérateur void indique qu'une expression doit être évaluée sans retourner de valeur. expression étant une expression JavaScript à évaluer. Les parenthèses sont facultatives mais les utiliser permet d'avoir une meilleur lisibilité du code.

    L'opérateur void peut être utilisé pour spécifier une expression comme un lien hypertexte, l'expression est évaluée mais n'est pas chargée à la place du document actuel.

    Le fragment de code  qui suit crée un lien hypertexte qui ne fait rien lorsque l'utilisateur clique dessus. Lorsqu'on clique sur le lien, void(0) est évalué à undefined, n'ayant aucun effet.

    <A HREF="javascript:void(0)">Cliquer ici pour ne rien faire</A>
    

    Le code suivant crée un lien hypertexte qui envoie un formulaire lorsque l'utilisateur clique dessus.

    <A HREF="javascript:void(document.form.submit())">
    Cliquer ici pour envoyer</A>

    Note : Voir la page sur l'opérateur void pour plus de détails.

    Précédence des opérateurs

    La précédence des opérateurs indique l'ordre dans lequel ils sont appliqués lors de l'évaluation d'une expression. L'utilisation de parenthèses permet de surcharger la relation de précédence.

    Le tableau qui suit décrit les précédences des opérateurs, dans l'ordre décroissant.

    Tableau 3.7 Précédence des opérateurs
    Type d'opérateur Opérateurs individuels
    membre . []
    appel/création d'instance () new
    négation/incrémentation ! ~ - + ++ -- typeof void delete
    multiplication/division * / %
    addition/soustraction + -
    décalage binaire << >> >>>
    relationnel < <= > >= in instanceof
    égalité == != === !==
    ET binaire &
    OU exclusif binaire ^
    OU binaire |
    ET logique &&
    OU logique ||
    conditionnel ?:
    assignation = += -= *= /= %= <<= >>= >>>= &= ^= |=
    virgule ,

    Une version plus détaillée de cette table peut être trouvée dans la Référence JavaScript.

    Étiquettes et contributeurs liés au document

    Étiquettes : 
    Contributors to this page: s3dm, teoli, SphinxKnight
    Dernière mise à jour par : SphinxKnight,
    Masquer la barre latérale