Opérateurs spéciaux

  • Raccourci de la révision : JavaScript//Guide/Opérateurs/Opérateurs_spéciaux
  • Titre de la révision : Opérateurs spéciaux
  • ID de la révision : 261171
  • Créé :
  • Créateur : Mgjbot
  • Version actuelle ? Non
  • Commentaire robot Ajoute: [[ko:Core JavaScript 1.5 Guide:Operators:Special Operators]]

Contenu de la révision

Opérateurs spéciaux

JavaScript offre les opérateurs spéciaux suivants :

  • {{template.Anch("L\'opérateur conditionnel")}}
  • {{template.Anch("La virgule")}}
  • {{template.Anch("delete")}}
  • {{template.Anch("in")}}
  • {{template.Anch("instanceof")}}
  • {{template.Anch("new")}}
  • {{template.Anch("this")}}
  • {{template.Anch("typeof")}}
  • {{template.Anch("void")}}

L'opérateur conditionnel

L'opérateur conditionnel est le seul opérateur JavaScript pouvant accepter trois opérandes. Cet opérateur renvoie une des deux valeurs proposées en fonction d'une condition. Sa syntaxe est la suivante :

condition ? val1 : val2

Si condition est true, l'opérateur renvoie la valeur val1. Sinon il renvoie la valeur val2. L'opérateur conditionnel peut être utilisé à tout endroit où l'on pourrait utiliser un opérateur classique.

Par exemple, examinez le code suivant :

situation = (age >= 18) ? "adulte" : "mineur"

Cette instruction affecte la valeur "adulte" à la variable situation si age vaut dix-huit ou plus. Sinon, elle affecte "mineur" à situation.

La virgule

L'opérateur virgule (,) évalue simplement ses deux opérandes et renvoie la valeur de la deuxième. Cet opérateur est employé principalement à l'intérieur des boucles for, pour pouvoir mettre à jour plusieurs variables à chaque itération de la boucle.

À titre d'exemple, si a est un tableau à 2 dimensions avec 10 éléments par côté, le code suivant utilise l'opérateur virgule pour incrémenter deux variables à la fois. Ainsi, le code peut afficher les valeurs des éléments présents sur la diagonale du tableau :

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

delete

L'opérateur delete supprime un objet, une propriété d'un objet ou un élément d'un tableau présent à un indice donné. Sa syntaxe est la suivante :

delete nomObjet;
delete nomObjet.propriete;
delete nomObjet[indice];
delete propriete; // valide uniquement à l'intérieur d'une instruction with

nomObjet est le nom d'un objet, propriete une propriété existante et indice un entier représentant l'emplacement d'un élément d'un tableau.

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

Vous pouvez utiliser l'opérateur delete pour supprimer des variables déclarées implicitement mais pas celles déclarées avec le mot-clé var.

Si la suppression réussit, la propriété ou l'élément se voit affecter la valeur undefined. L'opérateur delete renvoie true si l'opération est possible, et false si l'opération est impossible.

x = 42;
var y = 43;
monobj = new Number();
monobj.h = 4;      // on crée la propriété h
delete x;        // renvoie true (on peut supprimer une variable si celle-ci est déclarée implicitement)
delete y;        // renvoie false (on ne peut pas supprimer une variable si celle-ci est déclarée avec var)
delete Math.PI;  // renvoie false (on ne peut pas supprimer les propriétés prédéfinies)
delete monobj.h; // renvoie true (on peut supprimer les propriétés définies par l'utilisateur)
delete monobj;   // renvoie true (on peut supprimer les objets déclarés implicitement)

Suppression des éléments d'un tableau
Lorsque vous supprimez un élément d'un tableau, la longueur du tableau n'est pas affectée. À titre d'exemple, si vous supprimez a{{mediawiki.external(3)}}, a{{mediawiki.external(4)}} reste a{{mediawiki.external(4)}} et a{{mediawiki.external(3)}} n'est pas défini (devient undefined).

Lorsque l'opérateur delete supprime un élément d'un tableau, cet élément n'est plus dans le tableau. Dans l'exemple suivant, arbres{{mediawiki.external(3)}} est supprimé avec delete :

arbres = new Array("séquoia", "laurier", "cèdre", "chêne", "érable");
delete arbres[3];
if (3 in arbres) {
  // ceci n'est pas exécuté
}

Si vous voulez qu'un élément de tableau existe mais qu'il ait une valeur indéfinie, utilisez le mot-clé undefined à la place de l'opérateur delete. Dans l'exemple suivant, arbres{{mediawiki.external(3)}} se voit affecter la valeur undefined mais l'élément existe toujours :

arbres = new Array("séquoia", "laurier", "cèdre", "chêne", "érable");
arbres[3] = undefined;
if (3 in arbres) {
  // ceci est exécuté
}

in

L'opérateur in renvoie true si la propriété spécifiée se trouve dans l'objet spécifié. Sa syntaxe est la suivante :

nomPropOuNombre in nomObjet

nomPropOuNombre est une chaîne ou une expression numérique représentant respectivement le nom d'une propriété ou l'indice d'un élément, et où nomObjet est le nom d'un objet.

Les exemples suivants montrent quelques usages de l'opérateur in :

// Tableaux
arbres = new Array("séquoia", "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 (vous devez spécifier un indice,
                    // pas une valeur)
"length" in arbres  // renvoie true (length est bien une propriété du type Array)

// Objets prédéfinis
"PI" in Math         // renvoie true
maChaine = new String("corail")
"length" in maChaine // renvoie true
// Objets personnalisés
mavoiture = {marque:"Honda", modèle:"Accord", année:1998}
"marque" in mavoiture // renvoie true
"modèle" in mavoiture // renvoie true

instanceof

L'opérateur instanceof renvoie true si l'objet spécifié est du type spécifié. Sa syntaxe est la suivante :

nomObjet instanceof typeObjet

nomObjet est le nom de l'objet à comparer avec typeObjet et typeObjet un type d'objet, tel que Date ou Array.

Utilisez instanceof lorsque vous avez besoin de vous assurer du type d'un objet au moment de l'exécution. À titre d'exemple, lorsque vous interceptez des exceptions, vous pouvez définir différentes branches de gestion d'exception en fonction du type de l'exception déclenchée.

Toujours à titre d'exemple, le code suivant utilise instanceof pour déterminer si jour est un objet Date. Comme jour est bien un objet Date, les instructions de l'instruction if s'exécutent.

jour = new Date(1995, 12, 17);
if (jour instanceof Date) {
 // instructions à exécuter
}

new

Vous pouvez utiliser l'opérateur new pour créer une instance d'un type d'objet défini par l'utilisateur ou de l'un des types d'objet prédéfinis Array, Boolean, Date, Function, Image, Number, Object, Option, RegExp ou String. Du côté du serveur vous pouvez aussi l'utiliser avec DbPool, Lock, File, ou SendMail. Utilisez new de la manière suivante :

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

Vous pouvez aussi créer des objets à l'aide d'initialiseurs d'objets, comme décrit sur la page Utiliser les initialiseurs d'objets.

Voir la page consacrée à new dans la référence JavaScript 1.5 pour plus d'informations.

this

Utilisez le mot-clé this pour faire référence à l'objet actuel. En général, this fait référence à l'objet appelant au sein d'une méthode. Utilisez this de la manière suivante :

this[.nomPropriete]

Exemple 1
Supposez qu'une fonction appelée valider valide la propriété value d'un objet, l'objet et une valeur minimale et maximale étant spécifiés :

function valider(obj, valmin, valmax) {
  if ((obj.value < valmin) || (obj.value > valmax)) {
     alert("Valeur invalide!");
  }
}

Vous pourriez ensuite associer la fonction valider au gestionnaire d'évènement onChange de chaque élément d'un formulaire, en utilisant this afin de passer l'élément de formulaire à la fonction, comme le montre l'exemple suivant :

<label for="age">Entrez un nombre entre 18 et 99 :</label>
<input type="text" name="age" id="age" size="3" onChange="valider(this, 18, 99)">

Exemple 2
Lorsque combiné avec la propriété form, this peut faire référence au formulaire parent de l'objet actuel. Dans l'exemple suivant, le formulaire monFormulaire contient un objet Text et un bouton. Lorsque l'utilisateur clique sur le bouton, la valeur de l'objet Text se voit affecter le nom du formulaire. Le gestionnaire d'évènement onClick du bouton utilise this.form pour faire référence au formulaire parent, monFormulaire.

<form name="monFormulaire">
<label for="text1">Nom du formulaire : </label><input type="text" name="text1" id="text1" value="Beluga">
 
<input name="bouton1" type="button" value="Afficher le nom du formulaire"
  onClick="this.form.text1.value = this.form.name;">
</form>

typeof

L'opérateur typeof est utilisé de l'une des manières suivantes :

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

L'opérateur typeof renvoie une chaîne indiquant le type de l'opérande, qui n'est pas évalué. opérande représente la chaîne, la variable, le mot-clé ou l'objet dont on veut obtenir le type. Les parenthèses sont facultatives.

Supposez que vous avez défini les variables suivantes :

var pourLeFun = new Function("5+2");
var forme = "rond";
var taille = 1;
var aujourdhui = new Date();

L'opérateur typeof renvoie les résultats suivants pour chacune de ces variables :

typeof pourLeFun   // est function
typeof forme       // est string
typeof taille      // est number
typeof aujourdhui  // est object
typeof nExistePas  // est undefined

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

typeof true        // est boolean
typeof null        // est object

Pour un nombre ou une chaîne, l'opérateur typeof renvoie les résultats suivants :

typeof 62             // est number
typeof 'Hello world'  // est string

Pour les propriétés, l'opérateur typeof renvoie le type de la valeur que contient la propriété :

typeof document.lastModified  // est string
typeof window.length          // est number
typeof Math.LN2               // est number

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

typeof blur         // est function
typeof eval         // est function
typeof parseInt     // est function
typeof forme.split  // est function

Pour les objets prédéfinis, l'opérateur typeof renvoie les résultats suivants :

typeof Date      // est function
typeof Function  // est function
typeof Math      // est function
typeof Option    // est function
typeof String    // est function

void

L'opérateur void est utilisé de l'une des manières suivantes :

1. void (expression)
2. void expression

L'opérateur void spécifie une expression à évaluer sans renvoyer de valeur. expression constitue une expression JavaScript valide, à évaluer. Les parenthèses encadrant l'expression sont facultatives, mais il est préférable de les écrire pour des raisons de style.

Vous pouvez utiliser l'opérateur void pour spécifier une expression en tant que lien hypertexte. L'expression est évaluée mais elle n'est pas chargée à la place du document actuel.

Le code suivant crée un lien hypertexte qui ne fait rien lorsque l'utilisateur clique dessus. Lorsque l'utilisateur clique sur le lien, void(0) s'évalue à undefined ce qui n'a aucun effet en JavaScript.

<a href="javascript:void(0)">Cliquez ici pour ne rien faire</a>

Le code suivant crée un hyperlien qui envoie les données d'un formulaire lorsque l'utilisateur clique dessus.

<a href="javascript:void(document.form.submit())">Cliquez ici pour envoyer les données</a>

{{wiki.template('PrécédentSuivant', [ "Guide JavaScript 1.5:Opérateurs:Opérateurs liés aux chaînes", "Guide JavaScript 1.5:Création d\'une expression rationnelle" ])}}

{{ wiki.languages( { "en": "en/Core_JavaScript_1.5_Guide/Operators/Special_Operators", "ja": "ja/Core_JavaScript_1.5_Guide/Operators/Special_Operators", "ko": "ko/Core_JavaScript_1.5_Guide/Operators/Special_Operators", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Operatory/Operatory_specjalne" } ) }}

Source de la révision

<p>
</p>
<h3 name="Op.C3.A9rateurs_sp.C3.A9ciaux"> Opérateurs spéciaux </h3>
<p>JavaScript offre les opérateurs spéciaux suivants :
</p>
<ul><li> {{template.Anch("L\'opérateur conditionnel")}}
</li><li> {{template.Anch("La virgule")}}
</li><li> {{template.Anch("delete")}}
</li><li> {{template.Anch("in")}}
</li><li> {{template.Anch("instanceof")}}
</li><li> {{template.Anch("new")}}
</li><li> {{template.Anch("this")}}
</li><li> {{template.Anch("typeof")}}
</li><li> {{template.Anch("void")}}
</li></ul>
<h4 name="L.27op.C3.A9rateur_conditionnel"> L'opérateur conditionnel </h4>
<p>L'opérateur conditionnel est le seul opérateur JavaScript pouvant accepter trois opérandes. Cet opérateur renvoie une des deux valeurs proposées en fonction d'une condition. Sa syntaxe est la suivante :
</p>
<pre class="eval">condition ? val1 : val2
</pre>
<p>Si <code>condition</code> est <code>true</code>, l'opérateur renvoie la valeur <code>val1</code>. Sinon il renvoie la valeur <code>val2</code>. L'opérateur conditionnel peut être utilisé à tout endroit où l'on pourrait utiliser un opérateur classique.
</p><p>Par exemple, examinez le code suivant :
</p>
<pre class="eval">situation = (age &gt;= 18) ? "adulte" : "mineur"
</pre>
<p>Cette instruction affecte la valeur <code>"adulte"</code> à la variable <code>situation</code> si <code>age</code> vaut dix-huit ou plus. Sinon, elle affecte <code>"mineur"</code> à <code>situation</code>.
</p>
<h4 name="La_virgule"> La virgule </h4>
<p>L'opérateur virgule (<code>,</code>) évalue simplement ses deux opérandes et renvoie la valeur de la deuxième. Cet opérateur est employé principalement à l'intérieur des boucles <code>for</code>, pour pouvoir mettre à jour plusieurs variables à chaque itération de la boucle.
</p><p>À titre d'exemple, si <code>a</code> est un tableau à 2 dimensions avec 10 éléments par côté, le code suivant utilise l'opérateur virgule pour incrémenter deux variables à la fois. Ainsi, le code peut afficher les valeurs des éléments présents sur la diagonale du tableau :
</p>
<pre class="eval">for (var i = 0, j = 9; i &lt;= 9; i++, j--) {
  document.writeln("a[" + i + "][" + j + "]= " + a[i][j]);
}
</pre>
<h4 name="delete"> delete </h4>
<p>L'opérateur <code>delete</code> supprime un objet, une propriété d'un objet ou un élément d'un tableau présent à un indice donné. Sa syntaxe est la suivante :
</p>
<pre class="eval">delete nomObjet;
delete nomObjet.propriete;
delete nomObjet[indice];
delete propriete; // valide uniquement à l'intérieur d'une instruction with
</pre>
<p>où <code>nomObjet</code> est le nom d'un objet, <code>propriete</code> une propriété existante et <code>indice</code> un entier représentant l'emplacement d'un élément d'un tableau.
</p><p>La quatrième forme n'est légale qu'au sein d'une instruction <code>with</code>, et elle permet de supprimer une propriété d'un objet.
</p><p>Vous pouvez utiliser l'opérateur <code>delete</code> pour supprimer des variables déclarées implicitement mais pas celles déclarées avec le mot-clé <code>var</code>.
</p><p>Si la suppression réussit, la propriété ou l'élément se voit affecter la valeur <code>undefined</code>. L'opérateur <code>delete</code> renvoie <code>true</code> si l'opération est possible, et <code>false</code> si l'opération est impossible.
</p>
<pre class="eval">x = 42;
var y = 43;
monobj = new Number();
monobj.h = 4;      // on crée la propriété h
delete x;        // renvoie true (on peut supprimer une variable si celle-ci est déclarée implicitement)
delete y;        // renvoie false (on ne peut pas supprimer une variable si celle-ci est déclarée avec var)
delete Math.PI;  // renvoie false (on ne peut pas supprimer les propriétés prédéfinies)
delete monobj.h; // renvoie true (on peut supprimer les propriétés définies par l'utilisateur)
delete monobj;   // renvoie true (on peut supprimer les objets déclarés implicitement)
</pre>
<p><b>Suppression des éléments d'un tableau</b><br>
Lorsque vous supprimez un élément d'un tableau, la longueur du tableau n'est pas affectée. À titre d'exemple, si vous supprimez <code>a{{mediawiki.external(3)}}</code>, <code>a{{mediawiki.external(4)}}</code> reste <code>a{{mediawiki.external(4)}}</code> et <code>a{{mediawiki.external(3)}}</code> n'est pas défini (devient <code>undefined</code>).
</p><p>Lorsque l'opérateur <code>delete</code> supprime un élément d'un tableau, cet élément n'est plus dans le tableau. Dans l'exemple suivant, <code>arbres{{mediawiki.external(3)}}</code> est supprimé avec <code>delete</code> :
</p>
<pre class="eval">arbres = new Array("séquoia", "laurier", "cèdre", "chêne", "érable");
delete arbres[3];
if (3 in arbres) {
  // ceci n'est pas exécuté
}
</pre>
<p>Si vous voulez qu'un élément de tableau existe mais qu'il ait une valeur indéfinie, utilisez le mot-clé <code>undefined</code> à la place de l'opérateur <code>delete</code>. Dans l'exemple suivant, <code>arbres{{mediawiki.external(3)}}</code> se voit affecter la valeur <code>undefined</code> mais l'élément existe toujours :
</p>
<pre class="eval">arbres = new Array("séquoia", "laurier", "cèdre", "chêne", "érable");
arbres[3] = undefined;
if (3 in arbres) {
  // ceci est exécuté
}
</pre>
<h4 name="in"> in </h4>
<p>L'opérateur <code>in</code> renvoie <code>true</code> si la propriété spécifiée se trouve dans l'objet spécifié. Sa syntaxe est la suivante :
</p>
<pre class="eval">nomPropOuNombre in nomObjet
</pre>
<p>où <code>nomPropOuNombre</code> est une chaîne ou une expression numérique représentant respectivement le nom d'une propriété ou l'indice d'un élément, et où <code>nomObjet</code> est le nom d'un objet.
</p><p>Les exemples suivants montrent quelques usages de l'opérateur <code>in</code> :
</p>
<pre class="eval">// Tableaux
arbres = new Array("séquoia", "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 (vous devez spécifier un indice,
                    // pas une valeur)
"length" in arbres  // renvoie true (length est bien une propriété du type Array)

// Objets prédéfinis
"PI" in Math         // renvoie true
maChaine = new String("corail")
"length" in maChaine // renvoie true
</pre>
<pre class="eval">// Objets personnalisés
mavoiture = {marque:"Honda", modèle:"Accord", année:1998}
"marque" in mavoiture // renvoie true
"modèle" in mavoiture // renvoie true
</pre>
<h4 name="instanceof"> instanceof </h4>
<p>L'opérateur <code>instanceof</code> renvoie <code>true</code> si l'objet spécifié est du type spécifié. Sa syntaxe est la suivante :
</p>
<pre class="eval">nomObjet instanceof typeObjet
</pre>
<p>où <code>nomObjet</code> est le nom de l'objet à comparer avec <code>typeObjet</code> et <code>typeObjet</code> un type d'objet, tel que <code>Date</code> ou <code>Array</code>.
</p><p>Utilisez <code>instanceof</code> lorsque vous avez besoin de vous assurer du type d'un objet au moment de l'exécution. À titre d'exemple, lorsque vous interceptez des exceptions, vous pouvez définir différentes branches de gestion d'exception en fonction du type de l'exception déclenchée.
</p><p>Toujours à titre d'exemple, le code suivant utilise <code>instanceof</code> pour déterminer si <code>jour</code> est un objet <code>Date</code>. Comme <code>jour</code> est bien un objet <code>Date</code>, les instructions de l'instruction <code>if</code> s'exécutent.
</p>
<pre class="eval">jour = new Date(1995, 12, 17);
if (jour instanceof Date) {
 // instructions à exécuter
}
</pre>
<h4 name="new"> new </h4>
<p>Vous pouvez utiliser l'opérateur <code>new</code> pour créer une instance d'un type d'objet défini par l'utilisateur ou de l'un des types d'objet prédéfinis <code>Array, Boolean, Date, Function, Image, Number, Object, Option, RegExp</code> ou <code>String</code>. Du côté du serveur vous pouvez aussi l'utiliser avec <code>DbPool, Lock, File,</code> ou <code>SendMail</code>. Utilisez <code>new</code> de la manière suivante :
</p>
<pre class="eval">nomObjet = new typeObjet ( param1 [,param2] ...[,paramN] )
</pre>
<p>Vous pouvez aussi créer des objets à l'aide d'initialiseurs d'objets, comme décrit sur la page <a href="fr/Guide_JavaScript_1.5/Cr%c3%a9er_de_nouveaux_objets/Utiliser_les_initialiseurs_d'objets">Utiliser les initialiseurs d'objets</a>.
</p><p>Voir la <a href="fr/R%c3%a9f%c3%a9rence_JavaScript_1.5/Op%c3%a9rateurs/Op%c3%a9rateurs_sp%c3%a9ciaux/Op%c3%a9rateur_new">page consacrée à new</a> dans la référence JavaScript 1.5 pour plus d'informations.
</p>
<h4 name="this"> this </h4>
<p>Utilisez le mot-clé <code>this</code> pour faire référence à l'objet actuel. En général, <code>this</code> fait référence à l'objet appelant au sein d'une méthode. Utilisez <code>this</code> de la manière suivante :
</p>
<pre class="eval">this[.nomPropriete]
</pre>
<p><b>Exemple 1</b><br>
Supposez qu'une fonction appelée <code>valider</code> valide la propriété <code>value</code> d'un objet, l'objet et une valeur minimale et maximale étant spécifiés :
</p>
<pre class="eval">function valider(obj, valmin, valmax) {
  if ((obj.value &lt; valmin) || (obj.value &gt; valmax)) {
     alert("Valeur invalide!");
  }
}
</pre>
<p>Vous pourriez ensuite associer la fonction <code>valider</code> au gestionnaire d'évènement <code>onChange</code> de chaque élément d'un formulaire, en utilisant <code>this</code> afin de passer l'élément de formulaire à la fonction, comme le montre l'exemple suivant :
</p>
<pre class="eval">&lt;label for="age"&gt;Entrez un nombre entre 18 et 99 :&lt;/label&gt;
&lt;input type="text" name="age" id="age" size="3" onChange="valider(this, 18, 99)"&gt;
</pre>
<p><b>Exemple 2</b><br>
Lorsque combiné avec la propriété <code>form</code>, <code>this</code> peut faire référence au formulaire parent de l'objet actuel. Dans l'exemple suivant, le formulaire <code>monFormulaire</code> contient un objet <code>Text</code> et un bouton. Lorsque l'utilisateur clique sur le bouton, la valeur de l'objet <code>Text</code> se voit affecter le nom du formulaire. Le gestionnaire d'évènement <code>onClick</code> du bouton utilise <code>this.form</code> pour faire référence au formulaire parent, <code>monFormulaire</code>.
</p>
<pre class="eval">&lt;form name="monFormulaire"&gt;
&lt;label for="text1"&gt;Nom du formulaire : &lt;/label&gt;&lt;input type="text" name="text1" id="text1" value="Beluga"&gt;
 
&lt;input name="bouton1" type="button" value="Afficher le nom du formulaire"
  onClick="this.form.text1.value = this.form.name;"&gt;
&lt;/form&gt;
</pre>
<h4 name="typeof"> typeof </h4>
<p>L'opérateur <code>typeof</code> est utilisé de l'une des manières suivantes :
</p>
<pre class="eval">1. typeof opérande
2. typeof (opérande)
</pre>
<p>L'opérateur <code>typeof</code> renvoie une chaîne indiquant le type de l'opérande, qui n'est pas évalué. <code>opérande</code> représente la chaîne, la variable, le mot-clé ou l'objet dont on veut obtenir le type. Les parenthèses sont facultatives.
</p><p>Supposez que vous avez défini les variables suivantes :
</p>
<pre class="eval">var pourLeFun = new Function("5+2");
var forme = "rond";
var taille = 1;
var aujourdhui = new Date();
</pre>
<p>L'opérateur <code>typeof</code> renvoie les résultats suivants pour chacune de ces variables :
</p>
<pre class="eval">typeof pourLeFun   // est function
typeof forme       // est string
typeof taille      // est number
typeof aujourdhui  // est object
typeof nExistePas  // est undefined
</pre>
<p>Pour les mots-clés <code>true</code> et <code>null</code>, l'opérateur <code>typeof</code> renvoie les résultats suivants :
</p>
<pre class="eval">typeof true        // est boolean
typeof null        // est object
</pre>
<p>Pour un nombre ou une chaîne, l'opérateur <code>typeof</code> renvoie les résultats suivants :
</p>
<pre class="eval">typeof 62             // est number
typeof 'Hello world'  // est string
</pre>
<p>Pour les propriétés, l'opérateur <code>typeof</code> renvoie le type de la valeur que contient la propriété :
</p>
<pre class="eval">typeof document.lastModified  // est string
typeof window.length          // est number
typeof Math.LN2               // est number
</pre>
<p>Pour les méthodes et fonctions, l'opérateur <code>typeof</code> renvoie les résultats suivants :
</p>
<pre class="eval">typeof blur         // est function
typeof eval         // est function
typeof parseInt     // est function
typeof forme.split  // est function
</pre>
<p>Pour les objets prédéfinis, l'opérateur <code>typeof</code> renvoie les résultats suivants :
</p>
<pre class="eval">typeof Date      // est function
typeof Function  // est function
typeof Math      // est function
typeof Option    // est function
typeof String    // est function
</pre>
<h4 name="void"> void </h4>
<p>L'opérateur <code>void</code> est utilisé de l'une des manières suivantes :
</p>
<pre class="eval">1. void (expression)
2. void expression
</pre>
<p>L'opérateur <code>void</code> spécifie une expression à évaluer sans renvoyer de valeur. <code>expression</code> constitue une expression JavaScript valide, à évaluer. Les parenthèses encadrant l'expression sont facultatives, mais il est préférable de les écrire pour des raisons de style.
</p><p>Vous pouvez utiliser l'opérateur <code>void</code> pour spécifier une expression en tant que lien hypertexte. L'expression est évaluée mais elle n'est pas chargée à la place du document actuel.
</p><p>Le code suivant crée un lien hypertexte qui ne fait rien lorsque l'utilisateur clique dessus. Lorsque l'utilisateur clique sur le lien, <code>void(0)</code> s'évalue à undefined ce qui n'a aucun effet en JavaScript.
</p>
<pre class="eval">&lt;a href="javascript:void(0)"&gt;Cliquez ici pour ne rien faire&lt;/a&gt;
</pre>
<p>Le code suivant crée un hyperlien qui envoie les données d'un formulaire lorsque l'utilisateur clique dessus.
</p>
<pre class="eval">&lt;a href="javascript:void(document.form.submit())"&gt;Cliquez ici pour envoyer les données&lt;/a&gt;
</pre>
<p>{{wiki.template('PrécédentSuivant', [ "Guide JavaScript 1.5:Opérateurs:Opérateurs liés aux chaînes", "Guide JavaScript 1.5:Création d\'une expression rationnelle" ])}}
</p>{{ wiki.languages( { "en": "en/Core_JavaScript_1.5_Guide/Operators/Special_Operators", "ja": "ja/Core_JavaScript_1.5_Guide/Operators/Special_Operators", "ko": "ko/Core_JavaScript_1.5_Guide/Operators/Special_Operators", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Operatory/Operatory_specjalne" } ) }}
Revenir à cette révision