Guide JavaScript 1.5:Expressions et opérateurs

Un article de MDC.

[modifier] Expressions

Une expression indique tout ensemble valide de constantes littérales, de variables, d'opérateurs et d'expressions, qui lorsqu'évalué, renvoie une seule valeur. Cette valeur peut être un nombre, une chaîne ou une valeur logique.

Conceptuellement, il y a deux types d'expressions : celles qui affectent une valeur à une variable et celles qui se résument simplement à une valeur. Par exemple, l'expression x = 7 est une expression qui affecte à x la valeur sept. Cette expression renvoie elle-même sept lorsqu'elle est évaluée. De telles expressions utilisent des opérateurs d'affectation. Maintenant, l'expression 3 + 4 renvoie simplement sept lorsqu'elle est évaluée ; aucune affectation n'est réalisée. Les opérateurs employés dans de telles expressions sont simplement appelés opérateurs.

JavaScript possède les types d'expressions suivants :

• Expressions arithmétiques : renvoient un nombre lorsqu'elles sont évaluées, par exemple 3.14159. Ces expressions utilisent généralement les opérateurs arithmétiques.
• Expressions de type chaînes : renvoient une chaîne de caractères lorsqu'elles sont évaluées, par exemple "Fred" ou "234". Ces expressions utilisent généralement les opérateurs liés aux chaînes.
• Expressions logiques : renvoient true ou false lorsqu'elles sont évaluées. Ces expressions impliquent souvent des opérateurs logiques.
• Expressions-objets : renvoient un objet lorsqu'elles sont évaluées. Consultez les opérateurs spéciaux pour la liste des différents opérateurs qui renvoient des objets lorsqu'ils sont évalués.

[modifier] Opérateurs

JavaScript possède les types d'opérateurs suivants. Cette section décrit chacun d'entre-eux et contient des informations concernant la précédence des opérateurs.

• Opérateurs d'affectation
• Opérateurs de comparaison
• Opérateurs arithmétiques
• Opérateurs bit-à-bit
• Opérateurs logiques
• Opérateurs liés aux chaînes
• Opérateurs spéciaux

JavaScript dispose à la fois d'opérateurs unaires et binaires. Un opérateur binaire nécessite deux opérandes, un avant l'opérateur et un après :

opérande1 opérateur opérande2

À titre d'exemple, 3+4 ou x*y.

Un opérateur unaire nécessite un seul opérande, soit avant soit après l'opérateur :

opérateur opérande

ou

opérande opérateur

À titre d'exemple, x++ ou ++x.

De plus, JavaScript possède un opérateur ternaire, l'opérateur conditionnel. Un opérateur ternaire nécessite trois opérandes.

[modifier] Précédence des opérateurs

Après discussion, il a été décidé de trier la liste des opérateurs dans ce tableau dans un ordre décroissant de priorité.

Type d'opérateur	Opérateurs de ce type
membre	.  []
appel/création d'instance	()  new
négation/incrémentation	!  ~  -  +  ++  --  typeof  void  delete
multiplication/division	*  /  %
addition/soustraction	+  -
décalage bit-à-bit	<<  >>  >>>
comparaison	<  <=  >  >=  in  instanceof
égalité	==  !=  ===  !==
et bit-à-bit	&
ou exclusif bit-à-bit	^
ou bit-à-bit	|
et logique	&&
ou logique	||
condition	?:
affectation	=  +=  -=  *=  /=  %=  <<=  >>=  >>>=  &=  ^=  |=
virgule	,

Tableau : Précédence des opérateurs

Une version plus complète de ce tableau, avec des liens vers des détails complémentaires à propos de chaque opérateur, pourra être trouvée dans la section Référence.

[modifier] Opérateurs d'affectation

Un opérateur d'affectation affecte une valeur à son opérande de gauche en fonction de la valeur de son opérande de droite. L'opérateur d'affectation de base est le signe égal (=) ; il affecte la valeur de son opérande de droite à son opérande de gauche. C'est-à-dire que x = y affecte la valeur de y à x.

Les autres opérateurs d'affectation sont des formes raccourcies d'opérations courantes, comme le montre le tableau suivant.

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

Tableau : Opérateurs d'affectation

[modifier] Opérateurs de comparaison

Un opérateur de comparaison compare ses opérandes et renvoie une valeur logique en fonction du résultat de la comparaison. Les opérandes peuvent être des nombres, des chaînes, des valeurs logiques ou des objets. La comparaison des chaînes se fait en fonction de l'ordre lexicographique classique, en se basant sur les valeurs Unicode des caractères. Si les deux opérandes ne sont pas du même type, JavaScript essaie de les convertir dans un type approprié pour la comparaison, sauf pour les opérateurs === et !==. En général, cela débouche sur une comparaison numérique. Le tableau suivant décrit les opérateurs de comparaison.

Opérateur	Description	Exemples renvoyant true1
Égal (==)	Renvoie true si les opérandes sont égaux.	3 == var1 "3" == var1 3 == '3'
Différent (!=)	Renvoie true si les opérandes ne sont pas égaux.	var1 != 4 var2 != "3"
Strictement égal (===)	Renvoie true si les opérandes sont égaux et du même type.	3 === var1
Strictement différent (!==)	Renvoie true si les opérandes ne sont pas égaux et/ou pas du même type.	var1 !== "3" 3 !== '3'
Plus grand que (>)	Renvoie true si l'opérande de gauche est plus grand que l'opérande de droite.	var2 > var1 "12" > 2
Plus grand ou égal (>=)	Renvoie true si l'opérande de gauche est plus grand ou égal à l'opérande de droite.	var2 >= var1 var1 >= 3
Plus petit que (<)	Renvoie true si l'opérande de gauche est plus petit que l'opérande de droite.	var1 < var2 "12" < var2
Plus petit ou ou égal (<=)	Renvoie true si l'opérande de gauche est plus petit ou égal à l'opérande de droite.	var1 <= var2 var2 <= 5

Tableau : Opérateurs de comparaison

¹ Ces exemples supposent que var1 s'est vu affecter la valeur 3 et var2 la valeur 4.

[modifier] Opérateurs arithmétiques

Les opérateurs arithmétiques prennent des valeurs numériques (constantes littérales ou variables) en opérandes et renvoient une valeur numérique. Les opérateurs arithmétiques classiques sont ceux de l'addition (+), la soustraction (-), la multiplication (*) et la division (/). Ces opérateurs fonctionnent de la même manière que dans la plupart des autres langages de programmation, excepté que l'opérateur / renvoie toujours un nombre à virgule flottante en JavaScript, et non pas un nombre tronqué comme c'est parfois le cas dans des langages comme C ou Java. À titre d'exemple :

1/2 // renvoie 0.5 en JavaScript
1/2 // renvoie 0 en Java

De plus, JavaScript offre les opérateurs arithmétiques présentés dans le tableau suivant :

Opérateur	Description	Exemple
% (Modulo)	Opérateur binaire. Renvoie le reste de la division entière des deux opérandes.	12 % 5 renvoie 2
++ (Incrémentation)	Opérateur unaire. Ajoute un à son opérande. Si utilisé en notation préfixe (++x), renvoie la valeur de son opérande après avoir ajouté un ; si utilisé en notation suffixe (x++), renvoie la valeur de son opérande avant d'avoir ajouté un.	Si x vaut 3, alors ++x affecte 4 à x et renvoie 4 tandis que x++ affecte 4 à x et renvoie 3.
-- (Décrémentation)	Opérateur unaire. Soustrait un à son opérande. La valeur de renvoi est analogue à celle de l'opérateur d'incrémentation.	Si x vaut 3, alors --x affecte 2 à x et renvoie 2 tandis que x-- affecte 2 à x et renvoie 3.
- (Opposé)	Opérateur unaire. Renvoie l'opposé de son opérande.	Si x vaut 3, alors -x renvoie -3.

Tableau : Opérateurs arithmétiques

Sommaire 1 Expressions 2 Opérateurs 2.1 Précédence des opérateurs 3 Opérateurs d'affectation 4 Opérateurs de comparaison 5 Opérateurs arithmétiques 6 Opérateurs bit-à-bit 6.1 Opérateurs bit-à-bit logiques 6.2 Décalage bit-à-bit 7 Opérateurs logiques 7.1 Évaluation des expressions logiques 7.2 Opérateurs liés aux chaînes 8 Opérateurs spéciaux 8.1 L'opérateur conditionnel 8.2 La virgule 8.3 delete 8.4 in 8.5 instanceof 8.6 new 8.7 this 8.8 typeof 8.9 void

[modifier] Opérateurs bit-à-bit

Les opérateurs bit-à-bit traitent leurs opérandes comme des séries de 32 bits (un bit = zéro ou un) plutôt que comme des nombres décimaux, hexadécimaux ou octaux. À titre d'exemple, le nombre décimal neuf a une réprésentation binaire de 1001. Les opérateurs bit-à-bit effectuent toutes leurs opérations sur de telles représentations binaires, mais elles renvoient des valeurs numériques JavaScript classiques.

Le tableau suivant résume les opérateurs bit-à-bit de JavaScript.

Opérateur	Emploi	Description
ET bit-à-bit (AND)	a & b	Place un 1 à chaque position où les bits correspondants des deux opérandes sont des 1, et renvoie la valeur ainsi obtenue.
OU bit-à-bit (OR)	a | b	Place un 1 à chaque position où au moins un des bits correspondants des deux opérandes est un 1 (les deux bits correspondants peuvent être égaux à 1), et renvoie la valeur ainsi obtenue.
OU EXCLUSIF bit-à-bit (XOR)	a ^ b	Place un 1 à chaque position où un seul des bits correspondants des deux opérandes est un 1 (les deux bits correspondants ne peuvent être égaux à 1), et renvoie la valeur ainsi obtenue.
OPPOSÉ bit-à-bit (NOT)	~ a	Inverse les bits de son opérande.
Décalage vers la gauche	a << b	Décale la représentation binaire de a de b bits vers la gauche, en ajoutant des zéros à droite.
Décalage vers la droite (préservation du signe)	a >> b	Décale la représentation binaire de a de b bits vers la droite, les bits décalés étant éliminés.
Décalage vers la droite avec zéros	a >>> b	Décale la représentation binaire de a de b bits vers la droite, en ajoutant des zéros à gauche, les bits décalés étant éliminés.

Tableau : Opérateurs bit-à-bit

[modifier] Opérateurs bit-à-bit logiques

Conceptuellement, les opérateurs bit-à-bit logiques fonctionnent de la manière suivante :

• Les opérandes sont convertis en entiers codés sur trente-deux bits et interprétées comme des séries de bits (un bit = zéro ou un).
• Chaque bit du premier opérande est associé au bit correspondant du deuxième opérande : le premier bit avec le premier bit, le deuxième bit avec le deuxième, etc.
• L'opérateur est appliqué à chaque paire de bits, et le résultat est construit en regroupant le tout.

À titre d'exemple, la représentation binaire de neuf est 1001 et la représentation binaire de quinze est 1111. Voici les résultats de l'application des opérateurs bit-à-bit à ces valeurs :

• 15 & 9 renvoie 9 (1111 & 1001 == 1001)
• 15 | 9 renvoie 15 (1111 | 1001 == 1111)
• 15 ^ 9 renvoie 6 (1111 ^ 1001 == 0110)

[modifier] Décalage bit-à-bit

Les opérateurs de décalage bit-à-bit acceptent deux opérandes : le premier représente l'entité devant être décalée, le deuxième spécifie le nombre de bits de la première opérande à décaler. La direction de l'opération de décalage dépend de l'opérateur utilisé.

Les opérateurs de décalage convertissent leurs opérandes en entiers codés sur trente-deux bits et renvoient un résultat du même type que l'opérande de gauche.

Voici la liste des opérateurs de décalage :

Opérateur	Description	Exemple
<< (Décalage vers la gauche)	Cet opérateur décale le premier opérande du nombre spécifié de bits vers la gauche. Les bits décalés sont éliminés. Des zéros sont ajoutés à droite.	9<<2 renvoie 36, car 1001 décalé de 2 bits vers la gauche devient 100100, c'est-à-dire 36.
>> (Décalage vers la droite avec préservation du signe)	Cet opérateur décale le premier opérande du nombre spécifié de bits vers la droite. Les bits décalés sont éliminés. Des copies du bit le plus à gauche sont ajoutées à gauche.	9>>2 renvoie 2 car 1001 décalé de 2 bits vers la droite devient 10, c'est-à-dire 2. De même, -9>>2 renvoie -3 car il y a préservation du signe.
>>> (Décalage vers la droite avec zéros)	Cet opérateur décale le premier opérande du nombre spécifié de bits vers la droite. Les bits décalés sont éliminés. Des zéros sont ajoutés à gauche.	19>>>2 renvoie 4, car 10011 décalé de 2 bits vers la droite devient 100, c'est-à-dire 4. Pour les nombres positifs, le décalage vers la droite avec zéros et le décalage vers la droite avec préservation du signe renvoient le même résultat.

Tableau : Opérateurs de décalage bit-à-bit

[modifier] Opérateurs logiques

Les opérateurs logiques sont généralement employés avec des valeurs booléennes (ou logiques) ; lorsque c'est le cas, ils renvoient une valeur booléenne. Toutefois, les opérateurs && et || renvoient en fait la valeur de l'une des opérandes spécifiées, ce qui signifie que si ces opérateurs sont employés avec des valeurs non-booléennes, ils peuvent renvoyer une valeur non-booléenne. Les opérateurs logiques sont décrits dans le tableau suivant.

Opérateur	Emploi	Description
&&	expr1 && expr2	(ET logique) Renvoie expr1 si celle-ci peut être convertie en la valeur false ; sinon, renvoie expr2. Ainsi, lorsqu'utilisé avec des valeurs booléennes, && renvoie true si les deux opérandes sont true ; sinon, il renvoie false.
||	expr1 || expr2	(OU logique) Renvoie expr1 si celle-ci peut être convertie en la valeur true ; sinon, renvoie expr2. Ainsi, lorsqu'utilisé avec des valeurs booléennes, || renvoie true si l'un des deux opérandes est true ; si les deux opérandes sont false, il renvoie false.
!	!expr	(NON logique) Renvoie false si son opérande unique peut être converti en la valeur true ; sinon, renvoie true.

Tableau : Opérateurs logiques

Les expressions qui renvoient null, 0, la chaîne vide "" ou l'objet undefined lorsqu'évaluées sont des exemples d'expression pouvant être converties en la valeur false.

Le code suivant illustre l'opérateur && (ET logique).

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

Le code suivant illustre l'opérateur || (OU logique).

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

Le code suivant illustre l'opérateur ! (NON logique).

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

[modifier] Évaluation des expressions logiques

Comme les expressions logiques sont évaluées de gauche à droite, un « court-circuit » au cours de l'évaluation est possible grâce aux règles suivantes :

• L'expression false && quelque chose est évaluée directement comme étant false.
• L'expression true || quelque chose est évaluée directement comme étant true.

Les règles de logique garantissent l'exactitude de ces évaluations raccourcies. Notez que la partie quelque chose dans les expressions ci-dessus n'est jamais évaluée, et donc tout effet secondaire qui serait lié à cette évaluation n'aura pas lieu.

[modifier] Opérateurs liés aux chaînes

En plus des opérateurs de comparaison, qui peuvent être utilisés avec des chaînes, l'opérateur de concaténation (+) permet de concaténer deux chaînes, c'est-à-dire qu'il renvoie une autre chaîne formée par l'union des deux chaînes spécifiées en opérandes. À titre d'exemple,
"ma " + "chaîne" renvoie la chaîne "ma chaîne".

L'opérateur d'affectation += peut aussi servir à concaténer des chaînes. À titre d'exemple, si la variable machaine contient la valeur "alpha", alors l'expression machaine += "bet" renvoie "alphabet" lorsqu'évaluée et affecte cette valeur à machaine.

[modifier] Opérateurs spéciaux

JavaScript offre les opérateurs spéciaux suivants :

• L'opérateur conditionnel
• La virgule
• delete
• in
• instanceof
• new
• this
• typeof
• void

[modifier] 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.

[modifier] 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]);
}

[modifier] 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

où 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[3], a[4] reste a[4] et a[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[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[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é
}

[modifier] 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

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

[modifier] 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

où 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
}

[modifier] 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.

[modifier] 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>

[modifier] 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

[modifier] 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>