Ce chapitre décrit les expressions et les opérateurs JavaScript tels que les opérateurs d'affectation, de comparaison, arithmétiques, binaires, logiques, de chaîne et divers opérateurs spéciaux.

Une liste complète et détaillée des opérateurs et des expressions est également disponible dans ce manuel.

Les opérateurs

JavaScript a les types d'opérateurs suivants. Cette sous-section décrit chaque type et contient des informations sur leur priorité les uns par rapport aux autres.

JavaScript prend en charge les opérateurs binaires et unaires, ainsi qu'un autre opérateur ternaire spécial, l'opérateur conditionnel. Une opération binaire utilise deux opérandes, un avant l'opérateur et un après :

opérande1 opérateur opérande2

Par exemple : 3+4 ou x*y .

À son tour, l'opérateur unaire utilise un opérande, avant ou après l'opérateur :

opérateur opérande opérande opérateur

Par exemple : x++ ou ++x .

Opérateurs d'affectation

À la suite de l'opération d'affectation, l'opérande à gauche de l'opérateur d'affectation (le signe "=") est défini sur la valeur extraite de l'opérande de droite. L'opérateur d'affectation de base est =, qui affecte la valeur de l'opérande de droite à l'opérande de gauche. Ainsi, l'expression x = y signifie que x reçoit la valeur de y.

Il existe également des opérateurs d'affectation composés qui sont utilisés pour raccourcir les opérations décrites dans le tableau suivant :

Liste des opérateurs d'affectation Nom Opérateur abrégé Signification

Mission	x=y	x=y
Affectation avec complément	x += y	x = x + y
Affectation avec soustraction	x -= y	x = x - y
Affectation avec multiplication	x *= y	x=x*y
Affectation avec division	x /= y	x=x/y
Affectation modulo	x %= y	x = x % y
Affectation de décalage à gauche	x > y
Affectation avec décalage à droite non signé	x >>>= y	x = x >>> y
Affectation avec ET au niveau du bit	x &= y	x=x&y
Affectation avec bitwise XOR	x ^= y	x=x^y
Affectation avec OR au niveau du bit	x |= y	x = x | y

Déstructuration

Pour une affectation plus complexe, JavaScript a une syntaxe de déstructuration, qui est une expression qui vous permet d'extraire des données de tableaux ou d'objets à l'aide d'une syntaxe qui reflète les constructeurs de tableaux et les littéraux d'objet.

var foo = ["un", "deux", "trois"] ; // pas de déstructuration var one = foo; vartwo = foo ; var trois = foo ; // avec déstructuration var = foo;

Opérateurs de comparaison

Vous pouvez utiliser l'opérateur delete pour supprimer des variables implicitement déclarées, mais vous ne pouvez pas l'utiliser pour supprimer des variables déclarées avec var .

Après l'application de l'opérateur de suppression, la propriété de l'élément est remplacée par undefined . L'opérateur de suppression renvoie vrai si l'opération est possible ; L'opérateur renvoie faux si l'opération ne peut pas être effectuée.

X = 42 ; varier = 43 ; monobj = nouveau nombre(); monobj.h = 4 ; // crée la propriété h supprime x ; // renvoie true (une variable déclarée implicitement peut être supprimée) delete y ; // retourne false (impossible de supprimer une variable déclarée avec var) delete Math.PI; // renvoie false (impossible de supprimer les propriétés intégrées) delete myobj.h ; // renvoie true (les propriétés personnalisées peuvent être supprimées) delete myobj ; // renvoie true (vous pouvez supprimer l'objet déclaré implicitement)

Suppression d'éléments de tableau

La suppression d'un élément de tableau n'affecte pas la longueur du tableau. Par exemple, si vous supprimez a , l'élément a reste a et a devient indéfini.

Lorsqu'un élément de tableau est supprimé à l'aide de l'opérateur de suppression, la valeur de cet élément est supprimée du tableau. Dans l'exemple suivant, les arborescences d'éléments sont supprimées à l'aide de l'opérateur de suppression. Cependant, l'élément trees reste adressable et renvoie undefined .

Var arbres = new Array("redwood", "bay", "cedar", "oak", "maple"); supprimer des arbres ; if (3 dans les arbres) ( // la condition échoue )

Si vous souhaitez qu'un élément reste dans le tableau mais que sa valeur soit indéfinie, utilisez le mot-clé undefined au lieu de l'opérateur de suppression. Dans l'exemple suivant, l'élément trees est défini sur undefined , mais l'élément reste dans le tableau :

Var arbres = new Array("redwood", "bay", "cedar", "oak", "maple"); arbres = indéfini ; if (3 in trees) ( // ce bloc de code est en cours d'exécution )

type d'opérateur

Utilisez l'opérateur instanceof lorsque vous devez valider le type d'un objet lors de l'exécution. Par exemple, lors de la capture d'exceptions, vous pouvez créer différents sauts de programmation de gestion des exceptions en fonction du type d'exception à gérer.

Par exemple, le code suivant utilise l'opérateur instanceof pour tester si theDay est un objet Date. Puisque theDay est bien un objet Date, le programme exécute le code contenu dans l'instruction if.

Var leJour = nouvelle Date(1995, 12, 17); if (theDay instanceof Date) ( // code exécutable )

Priorité des opérateurs

Une priorité Les opérateurs déterminent l'ordre dans lequel ils sont exécutés lorsqu'une expression est évaluée. Vous pouvez influencer la priorité des opérateurs avec des parenthèses.

Le tableau ci-dessous décrit la priorité des opérateurs du plus élevé au plus bas.

Tableau 3.7 Priorité des opérateurs Type d'opérateur Opérateurs

propriété de l'objet	.
appel, instanciation d'objet	() nouveau
négation, incrément	! ~ - +++ -- typeof void delete
multiplication, division	* / %
addition soustraction	+ -
décalage de peu	> >>>
comparaison, entrée	< >= dans l'exemple de
égalité	== != === !==
peu-et	&
bit-exclusif-ou	^
peu ou	|
logique-et	&&
ou logique	||
opérateur conditionnel (ternaire)	?:
mission	= += -= *= /= %= = >>>= &= ^= |=
virgule	,

Plus version détaillée ce tableau contenant des liens et Informations Complémentaires pour chaque opérateur, se trouve dans la référence JavaScript.

Expressions

Expression est tout bloc de code valide qui renvoie une valeur.

Conceptuellement, il existe deux types d'expressions : celles qui attribuent une valeur à une variable et celles qui évaluent une valeur sans l'attribuer.

L'expression x = 7 est un exemple du premier type d'expression. Cette expression les usages opérateur= pour affecter x à la valeur 7 . L'expression elle-même vaut également 7.

Le code 3 + 4 est un exemple du deuxième type d'expression. Cette expression utilise opérateur"+" pour additionner les nombres 3 et 4 sans affecter le résultat résultant 7 à une variable.

Toutes les expressions en JavaScript appartiennent aux catégories suivantes :

Expressions de base

Basique mots clés et des expressions de base en JavaScript.

cet opérateur

Utilisez le mot-clé this pour faire référence à l'objet courant. En général, cela pointe vers l'objet appelable auquel appartient cette méthode. Utilisez ceci comme ceci :

This["propertyName"] this.propertyName

Disons que la fonction de validation vérifie la propriété value d'un objet ; l'objet est spécifié, ainsi que les bornes supérieure et inférieure de la valeur de cette propriété :

Fonction valider(obj, lowval, hival)( if ((obj.value< lowval) || (obj.value >hival)) alert("Valeur invalide!"); )

Vous pouvez appeler la fonction validate sur le gestionnaire d'événements onChange pour chaque élément de formulaire, en l'utilisant pour pointer vers l'élément de formulaire, comme illustré dans l'exemple suivant :

Entrez un nombre de 18 à 99 :

Opérateur de regroupement

L'opérateur de regroupement "parenthèses" () contrôle la priorité d'évaluation de l'expression. Par exemple, vous pouvez redéfinir l'ordre - "multiplication et division, puis addition et soustraction", pour que, par exemple, l'addition soit effectuée avant la multiplication :

Vara = 1 ; var b = 2; var c = 3 ; // ordre normal a + b * c // 7 // exécuté comme d'habitude, donc a + (b * c) // 7 // maintenant inverser l'ordre // addition à la multiplication (a + b) * c // 9 // qui est équivalent à a * c + b * c // 9

Syntaxe simplifiée pour la création de tableaux et de générateurs

La syntaxe simplifiée est une fonctionnalité JavaScript expérimentale qui pourra être ajoutée aux futures versions d'ECMAScript. Il existe 2 versions de la syntaxe :

Syntaxe simplifiée pour les tableaux. (pour (x de y) y) Syntaxe simplifiée pour les générateurs.

Des syntaxes simplifiées existent dans de nombreux langages de programmation et permettent de construire rapidement un nouveau tableau basé sur un tableau existant. Par exemple:

) je*je ] ; // [ 1, 4, 9 ] var abc = [ "A", "B", "C" ]; ; // [ "a", "b", "c" ]

Expressions de la main gauche

Les valeurs de gauche sont affectées aux valeurs de droite.

nouveau

Vous pouvez utiliser l'opérateur new pour instancier un objet d'un type défini par l'utilisateur ou l'un des objets intégrés. Utilisez le nouvel opérateur comme ceci :

Var objectName = new objectType();

super

Le mot clé est utilisé pour appeler les fonctions de l'objet parent. Ceci est également utile avec les classes pour appeler le constructeur du parent, par exemple.

Super(); // appelle le constructeur du parent. super.functionOnParent();

Opérateur de poste

L'opérateur de propagation permet à une expression de se développer à des emplacements avec plusieurs arguments (pour les appels de fonction) ou plusieurs éléments (pour les tableaux).

Exemple : Aujourd'hui, si vous avez un tableau et souhaitez en créer un nouveau avec la partie existante du premier, alors la syntaxe du tableau littéral n'est plus suffisante et vous devez écrire du code impératif (pas de variantes) en utilisant une combinaison de push , épissure, concaté, etc. Mais avec cet opérateur, le code devient plus court :

Parties var = ["épaule", "genoux"] ; var lyrics = ["tête", ...parties, "et", "orteils"] ;

L'opérateur fonctionne de la même manière avec les appels de fonction :

Fonction f(x, y, z) ( ) var args = ; f(...args);

Les expressions en JavaScript sont des combinaisons opérandes Et les opérateurs.

Opérations Les expressions in sont exécutées séquentiellement en fonction de la valeur de priorité (plus la valeur de priorité est élevée, plus elle est élevée). Le résultat renvoyé n'est pas toujours du même type que le type de données en cours de traitement. Par exemple, les opérandes impliqués dans les opérations de comparaison sont divers types, mais le résultat renvoyé sera toujours un booléen.

Riz. 1. Structure de l'expression en JavaScript

Les opérandes sont des données traitées par le script JavaScript. Les opérandes peuvent être types simples data, et complex, ainsi que d'autres expressions.

Les opérateurs sont des symboles de langage qui effectuent diverses opérations sur les données. Les opérateurs peuvent être écrits en utilisant des caractères de ponctuation ou des mots-clés.

Selon le nombre d'opérandes, on distingue les types d'opérateurs suivants :
unaire - un opérande est impliqué dans l'opération ;
binaire - deux opérandes participent à l'opération ;
ternaire - combine trois opérandes.

La forme la plus simple d'une expression est un littéral - quelque chose qui s'évalue à lui-même, comme le nombre 100 , la chaîne "Hellow world" . Une variable peut également être une expression, puisqu'elle s'évalue à la valeur qui lui est assignée.

Expressions et opérateurs en JavaScript 1. Opérateurs arithmétiques

Les opérateurs arithmétiques sont conçus pour effectuer opérations mathématiques, ils fonctionnent sur des opérandes numériques (ou des variables qui stockent des valeurs numériques) et renvoient une valeur numérique en conséquence.

Si l'un des opérandes est une chaîne, l'interpréteur JavaScript tentera de le convertir en un type numérique, puis effectuera l'opération appropriée. Si la conversion de type échoue, le résultat sera NaN (pas un nombre).

Tableau 1. Opérateurs arithmétiques Opérateur/Opération Description Priorité

+ Ajout	Ajoute des opérandes numériques. Si l'un des opérandes est une chaîne, le résultat de l'expression est une chaîne.	12
- Soustraction	Soustrait le deuxième opérande du premier.	12
- Moins unaire	Convertit un nombre positif en un nombre négatif et vice versa.	14
* Multiplication	Multiplie deux opérandes.	13
/ division	Divise le premier opérande par le second. Le résultat de la division peut être un nombre entier ou un nombre à virgule flottante.	13
% Modulo (reste de la division)	Calcule le reste de la division entière du premier opérande par le second. S'applique à la fois aux nombres entiers et aux nombres à virgule flottante.	13

var x = 5, y = 8, z ; z = x + y // renvoie 13 z = x - y ; // renvoie -3 z = - y ; // renvoie -8 z = x * y ; // renvoie 40 z = x / y ; // renvoie 0,625 z = y % x ; // renvoie 3 2. Instructions d'affectation

Les opérateurs d'affectation sont utilisés pour affecter des valeurs aux variables. Les opérateurs combinés vous permettent de stocker la valeur initiale et la suivante dans une variable.

var a = 5 ; // attribue la valeur numérique 5 à la variable a var b = "hellow" ; // stocke la chaîne hellow dans la variable b var m = n = z = 10; // attribue aux variables m, n, z la valeur numérique 10 x += 10 ; // équivalent à x = x + 10 ; x-= 10 ; // équivalent à x = x - 10 ; x * = 10 ; // équivalent à x = x * 10 ; x/= 10 ; // équivalent à x = x / 10 ; x%= 10 ; // équivalent à x = x % 10 ; 3. Opérateurs d'incrémentation et de décrémentation

Les opérateurs d'incrémentation et de décrémentation sont unaires et incrémentent et décrémentent la valeur de l'opérande de un. L'opérande peut être une variable, un élément de tableau, une propriété d'objet. Le plus souvent, ces opérations sont utilisées pour incrémenter le compteur dans une boucle.

var X = y = m = n = 5, z, s, k, l ; z = ++x * 2 ; /* à la suite de calculs renverra la valeur z = 12, x = 6, c'est-à-dire la valeur x est d'abord incrémentée de 1, puis l'opération de multiplication est effectuée */ s = y++ * 2 ; /* à la suite de calculs renverra la valeur s = 10, y = 6, c'est-à-dire d'abord, l'opération de multiplication est effectuée, puis la valeur augmentée de 1 est stockée dans la variable y */ k = --m * 2 ; // renverra la valeur k = 8, m = 4 l = n-- * 2; // renverra la valeur l = 10, n = 4 4. Opérateurs de comparaison

Les opérateurs de comparaison sont utilisés pour faire correspondre les opérandes, le résultat d'une expression peut être l'une des deux valeurs - true ou false . Les opérandes peuvent être non seulement des nombres, mais aussi des chaînes, des booléens et des objets. Cependant, la comparaison ne peut être effectuée que sur des nombres et des chaînes, de sorte que les opérandes qui ne sont pas des nombres ou des chaînes sont convertis.

Si les deux opérandes ne peuvent pas être convertis avec succès en nombres ou en chaînes, les opérateurs renvoient toujours false .

Si les deux opérandes sont des chaînes/nombres, ou peuvent être convertis en chaînes/nombres, ils seront comparés en tant que chaînes/nombres.

Si un opérande est une chaîne/converti en chaîne et l'autre est un nombre/converti en nombre, l'opérateur tentera de convertir la chaîne en nombre et effectuera une comparaison numérique. Si la chaîne n'est pas un nombre, elle est convertie en NaN et la comparaison prend la valeur false .

Le plus souvent, les opérations de comparaison sont utilisées lors de l'organisation des branches dans les programmes.

Tableau 4. Opérateurs de comparaison Opérateur/Opération Description Priorité

== Égalité	Teste deux valeurs pour une correspondance, permettant la conversion de type. Renvoie vrai si les opérandes sont identiques et faux s'ils sont différents.	9
!= Inégalité	Renvoie vrai si les opérandes ne sont pas égaux	9
=== Identité	Teste "l'identité" de deux opérandes à l'aide d'une définition de correspondance stricte. Renvoie vrai si les opérandes sont égaux sans conversion de type.	9
!== Non identique	Effectue un contrôle d'identité. Renvoie true si les opérandes ne sont pas égaux sans conversion de type.	9
> Plus	Renvoie true si le premier opérande est supérieur au second, sinon renvoie false .	10
>= Supérieur ou égal	Renvoie true si le premier opérande n'est pas inférieur au second, sinon renvoie false .	10
	Renvoie true si le premier opérande est inférieur au second, sinon renvoie false .	10
	Renvoie true si le premier opérande n'est pas supérieur au second, sinon renvoie false .	10

5 == "5" ; // renvoie vrai 5 != -5.0; // renvoie vrai 5 === "5" ; // renvoie faux faux === faux ; // renvoie vrai 1 !== vrai; // renvoie vrai 1 != vrai; // renverra false puisque true est converti en 1 3 > -3 ; // renvoie vrai 3 >= "4" ; // renvoie faux 5. Opérateurs logiques

Les opérateurs logiques vous permettent de combiner des conditions qui renvoient des valeurs booléennes. Le plus souvent utilisé dans une instruction if.

(2 < 3) && (3===3); // вернет true, так как выражения в обеих скобках дают true (x < 10 && x >0); // retournera true si x est compris entre 0 et 10 !false; // renvoie true 6. Opérateurs au niveau du bit

Les opérateurs au niveau du bit opèrent sur leurs opérandes comme une séquence de 32 bits de zéros et de uns et renvoient une valeur numérique indiquant le résultat de l'opération, écrit en système décimal compte. Les entiers sont considérés comme des opérandes, la partie fractionnaire de l'opérande est ignorée. Les opérations au niveau du bit peuvent être utilisées, par exemple, lors du chiffrement de données, de l'utilisation d'indicateurs et de la délimitation des droits d'accès.

Tableau 6. Opérateurs au niveau du bit Opérateur/Opération Description Priorité

& ET au niveau du bit	Si les deux bits sont 1 , alors le bit résultant sera 1 . Sinon, le résultat est 0 .	8
| OU au niveau du bit	Si l'un des opérandes contient 1 à la position, le résultat contiendra également 1 à cette position, sinon le résultat à cette position sera 0 .	6
^ OU exclusif	Si une et une seule valeur contient un 1 à n'importe quelle position, alors le résultat contiendra un 1 à cette position, sinon le résultat à cette position sera 0 .	7
~ Déni	Une opération de négation au niveau du bit est effectuée sur représentation binaire valeurs d'expression. Toute position contenant 1 dans l'expression d'origine est remplacée par 0 . Toute position contenant 0 dans l'expression d'origine devient 0 . Les nombres positifs commencent à 0 , les nombres négatifs commencent à -1 , donc ~ n == -(n+1) .	14
	L'opérateur décale les bits du premier opérande vers la gauche du nombre de positions de bits établi par le deuxième opérande. Les zéros sont utilisés pour occuper les postes à droite. Renvoie un résultat du même type que l'opérande de gauche.	11
>> Décalage de bits vers la droite	L'opérateur décale les bits du premier opérande vers la droite du nombre de positions de bit défini par le deuxième opérande. Les chiffres hors limites sont supprimés. Le bit le plus significatif (32e) n'est pas modifié pour conserver le signe du résultat. Si le premier opérande est positif, les bits de poids fort du résultat sont remplis de zéros ; si le premier opérande est négatif, les bits de poids fort du résultat sont remplis par des uns. Décaler une valeur vers la droite d'une position équivaut à diviser par 2 (le reste étant ignoré), et décaler vers la droite de deux positions équivaut à diviser par 4, et ainsi de suite.	11
>>> Décalage à droite au niveau du bit sans signe	L'opérateur décale les bits du premier opérande vers la droite du nombre de positions de bit défini par le deuxième opérande. Les zéros sont ajoutés à gauche quel que soit le signe du premier opérande. Les chiffres hors limites sont supprimés.	11

var x = 9, y = 5, z = 2, s = -5, résultat ; // 9 équivaut à 1001, 5 équivaut à 0101 result = x & y; // renvoie 1 (équivalent à 0001) résultat = x | y; // renvoie 13 (équivalent à 1101) result = x ^ y; // renverra 12 (équivalent à 1100) result = ~ y; // retourne -6 (équivalent à 1100) result = x > z; // renvoie 2 (équivalent à 10) result = s >>> z; // renvoie 1073741822 (équivalent à 1111111111111111111111111110) 7. Opérateurs de chaîne

Il existe plusieurs opérateurs qui opèrent sur les chaînes d'une manière particulière.

"1" + "10" ; // retournera "110" "1" + 10 ; // renvoie "110" 2 + 5 + "crayons de couleur" ; // retourne "7 crayons de couleur" "Crayons de couleur" + 2 + 5; // renvoie "Crayons de couleur 25" "1" > "10" ; // retourne faux "10" 10 ? x*2 :x/2 ; // renvoie x * 2 si x > 10, sinon x / 2 9. Commentaires en JavaScript

Commentaire sur une seule ligne : faites précéder le texte du commentaire de // caractères.

Tout d'abord, brièvement sur les expressions en JavaScript.

Expressions JavaScript

JavaScript a des déclarations et des expressions.

Les instructions ne renvoient pas de valeurs.

Expressions Toujours retourner certaines valeurs. Lorsque l'interpréteur voit une expression, il évalue sa valeur et remplace l'expression par sa valeur.

Les expressions sont soit simples soit composées. Les expressions simples n'incluent pas d'autres expressions.

Les expressions simples incluent :

Identifiants : someVar (nom de la variable) ;

Littéraux : "chaîne" ou 675 (nombre ou littéral numérique) ;

Certains mots-clés comme celui-ci ;

Lorsque l'analyseur rencontre un identifiant, il doit d'abord calculer sa valeur, c'est-à-dire, par exemple, remplacer le nom d'une variable par sa valeur.

La valeur du littéral sera la même que celle qui est écrite dans le code du script.

Opérateurs et expressions JavaScript complexes

Les opérateurs sont utilisés pour combiner plusieurs expressions simples en une seule complexe.

Les opérateurs sont :

• Unaire (un opérande).
• Binaire (deux opérandes).
• Opérateur ternaire ? en JavaScript (trois opérandes, il n'y a qu'un seul opérateur ternaire).

Un opérande est une expression simple à laquelle un opérateur est appliqué.

Par exemple, l'opérateur d'addition arithmétique "+" est un opérateur binaire. Il additionne les opérandes gauche et droit et renvoie la somme.

vardigit = 4 + 7 ;

Au fait, l'affectation se fait à l'aide de l'opérateur d'affectation "=". Cet opérateur évalue la valeur de l'opérande droit et l'affecte à l'opérande gauche.

JavaScript a un plus unaire, il n'a qu'un seul opérande. Unaire plus n'est pas opérateur arithmétique, il convertit l'opérande en nombre.

Var maVar = "7" ; document.write(typeof(myVar) + "
"); // Affiche la chaîne myVar = +myVar; document.write(typeof(myVar) + "
"); // Affiche le numéro dans le document

Au début, myVar contenait la chaîne "7", qui est un littéral de type chaîne (chaîne), et non numérique (nombre). À l'aide de l'opérateur unaire plus, nous avons converti la chaîne littérale en une chaîne numérique.

Opérations arithmétiques

Les opérations arithmétiques sont des opérations mathématiques bien connues.

Peut-être que l'opérateur % (reste) a besoin d'être clarifié. 9 est divisible par 5 avec un reste de 4, et c'est ce reste que cet opérateur renvoie. On l'appelle aussi prise modulo. Lors de l'utilisation d'entiers, le résultat de cet opérateur sera également un entier. Lorsque vous travaillez sur des nombres à virgule flottante, le résultat sera un nombre à virgule flottante.

5.5 % 2.2 = 1.1

Lors d'opérations arithmétiques, il convient de rappeler que si elles sont effectuées de manière incorrecte, elles peuvent conduire à des résultats:

• NaN (pas un nombre) - pas un nombre.
• Infini - infini.

Voici ce que donne la division par zéro :

Var maVar = 0 / 0 ; document.write("Valeur de la variable : " + myVar + ", son type : " + typeof(myVar) + "
");

Opérations de comparaison

Les opérateurs de comparaison sont utilisés pour faire correspondre les expressions. Une expression avec un opérateur conditionnel renvoie une valeur booléenne - vrai ou faux (true / false).

Les opérations de comparaison peuvent également être effectuées avec des chaînes, cela sera abordé dans une autre leçon. La seule condition pour un résultat correct est de faire correspondre des données du même type. Sinon, JavaScript essaiera de convertir les données d'un type à un autre, ce qui n'est pas toujours possible. Pour éviter les erreurs, ne comparez que des données du même type.

Opérations d'affectation

L'exemple le plus évident d'un opérateur d'affectation est l'affectation simple (=). Cet opérateur (=) permet d'affecter une valeur à une variable.

Mais il existe un certain nombre d'opérations d'affectation qui sont abrégées.

Opérations booléennes

Les opérations booléennes sont souvent utilisées avec la construction if else dans JS. C'est sur des exemples de cette conception que leur travail sera démontré. Mais d'abord, une liste d'opérateurs logiques.

Maintenant des exemples simples :

Si (vrai && vrai) document.write("Ça marche !
"); if (true || false) document.write("Ça marche !
"); if (!false) document.write("Ça marche !
");

Jetons un coup d'œil à ces exemples :

L'opérateur logique ET (&&) renverra vrai si les deux opérandes sont vrais.

L'opérateur logique OU (||) renverra vrai si au moins un opérande est vrai.

L'opérateur logique NOT (!) prend un opérande et inverse la valeur vrai/faux.

Opérateurs unaires

Les opérateurs unaires sont des opérateurs à un opérande. Voici quelques-uns de ces opérateurs :

• ++ - augmenter de 1 (incrément). Il peut s'agir d'un préfixe et d'un suffixe, plus d'informations ci-dessous.
• -- - diminuer de 1 (décrémenter). Il peut s'agir d'un préfixe et d'un suffixe, plus d'informations ci-dessous.
• + - plus unaire.
• - - moins unaire.

moins unaire

Le moins unaire inverse le signe de l'expression. Par exemple, lorsque vous écrivez -100 dans un programme, vous appliquez simplement un moins unaire au littéral numérique 100.

Vous devez comprendre exactement comment fonctionne le moins unaire - il renvoie la valeur de l'opérande avec le signe opposé. Voici un exemple d'utilisation correcte du moins unaire :

Var maVar = -100 ; document.write(-myVar + " - le moins unaire a fonctionné, mais la variable aussi = " + myVar + ".
"); maVar = -maVar; document.write("Maintenant variable = " + maVar + ".
");

Voici un exemple sans signification d'un double moins unaire. Je pense que ce sera utile à des fins éducatives:

Var maVar = -100 ; document.write(--myVar + " est un incrément, pas un double moins unaire.
"); document.write("Maintenant variable = " + myVar + ".
"); document.write(-(-myVar) + " qui est une double utilisation du moins unaire.
");

plus unaire

Le plus unaire n'effectue aucune opération mathématique. Il convertit un littéral en un type numérique.

Var maVar = "78687" ; document.write(typeof(myVar) + ".
"); maVar = +maVar; document.write(typeof(maVar) + ".
");

incrémenter et décrémenter

En programmation, il est souvent nécessaire d'augmenter ou de diminuer la valeur d'une variable de un. Il existe des opérateurs unaires pour cela :

• ++ - augmenter de 1 (incrément).
• -- - diminuer de 1 (décrémenter).

Contrairement aux plus et moins unaires, l'incrémentation et la décrémentation modifient la valeur de la variable lorsqu'elle est appelée.

Var maVar = 10 ; document.write(++maVar + ".
"); document.write(maVar + ".
");

La décrémentation (--) fonctionne de la même manière.

Considérons maintenant les utilisations de préfixe et de suffixe de ces opérateurs.

• ++myVar - augmentation du préfixe de 1.
• myVar++ - suffixe augmenté de 1.

La différence est celle-ci :

• L'utilisation du préfixe de ces opérateurs évalue d'abord la valeur de l'opérateur unaire, puis utilise le résultat dans l'expression.
• L'utilisation de Postfix évalue d'abord l'expression, puis exécute l'opérateur unaire (++ ou -- ).

Un exemple simple vous aidera à comprendre ceci :

Var maVar = 10 ; document.write((++maVar + 5) + ".

"); var maVar = 10; document.write((maVar++ + 5) + ".
"); document.write("Variable = " + maVar + ".
");

L'incrémentation et la décrémentation ne peuvent être utilisées qu'avec des variables, elles ne peuvent pas être appliquées à des littéraux numériques. En termes simples, le code ++7 a donné une erreur dans le script.

Autres opérateurs

JavaScript a d'autres opérateurs :

• Opérateur ternaire (avec trois opérandes)

Table des matières des documents

JavaScript prend en charge un ensemble compact d'opérateurs qui peuvent être utilisés pour créer des pages Web interactives. Ce chapitre donne un aperçu de ces opérateurs.

Ce chapitre contient les sections suivantes qui fournissent bref examen chaque opérateur :

• Bloc d'instruction : ( )

• Instructions conditionnelles : if...else et switch

• Instructions de boucle : for, while, do...while, label, break et continue (label lui-même n'est pas une instruction de boucle, mais est souvent utilisé avec lesdites instructions)

• Opérateurs de manipulation d'objets : pour... dans et avec

• commentaires

• Instructions de gestion des exceptions : essayez... attrapez et lancez

Toute expression est également un opérateur. Voir le chapitre 3 dans la section "Expressions et opérations" pour plus de détails sur les opérations.

Utilisez le caractère point-virgule (;) pour séparer les instructions dans le code JavaScript.

Voir JavaScript de base. Annuaire. détails sur les opérateurs de ce chapitre.

1. Bloc d'instructions Le bloc d'instructions permet de regrouper des instructions. Le bloc est délimité par des accolades :

( instruction1 instruction2 . . . instructionn )

2. Instructions conditionnelles Une instruction conditionnelle est un ensemble de commandes qui sont exécutées si la condition spécifiée est vraie. JavaScript prend en charge deux instructions conditionnelles : if...else et switch .2.1. instruction if...else Cette instruction est utilisée pour exécuter certaines instructions si la condition booléenne est vraie ; utilisez un bloc else facultatif pour exécuter d'autres instructions si la condition est fausse. L'instruction if ressemble à ceci :

si (condition) (instructions1) [autre (instructions2)]

La condition peut être n'importe quelle expression JavaScript dont la valeur est true ou false . Les instructions à exécuter peuvent être n'importe quelle instruction JavaScript, y compris les instructions if imbriquées. Si vous devez exécuter plusieurs instructions après une instruction if ou else, vous devez placer ces instructions exécutées entre accolades ().

Vous ne devez pas utiliser d'affectations simples dans une instruction conditionnelle. Par exemple, N'UTILISEZ PAS ce code :

Si vous devez utiliser une affectation dans une instruction conditionnelle, placez des parenthèses supplémentaires autour de l'instruction d'affectation. Par exemple, if((x = y)) .

Ne confondez pas les valeurs booléennes primitives true et false avec les valeurs true et false d'un objet booléen. Tout objet dont la valeur n'est pas undefined , null , zero , **NaN** ou la chaîne vide, y compris un objet booléen avec la valeur false , est évalué à true lorsqu'il est passé à l'instruction conditionnelle. Par exemple:

varb = nouveau booléen(faux) ; if (b ) // cette condition est évaluée à true

Exemple.

Dans cet exemple, la fonction checkData renvoie true si le nombre de caractères dans l'objet Text est de trois ; sinon, affiche un avertissement et renvoie false .

function checkData () ( if (document . form1 . threeChar . value . length == 3 ) ( return true ) else ( alert (" Entrez exactement trois caractères. " + document . form1 . threeChar . value + " n'est pas valide. " ) renvoie faux ) )

2.2. Instruction switch L'instruction switch permet à un programme d'évaluer une expression et de tenter de faire correspondre la valeur de l'expression à la valeur de l'étiquette de cas. Si une correspondance est trouvée, le programme exécute l'instruction associée. L'instruction switch ressemble à ceci :

switch (expression )( case label : instruction ; break ; case label : instruction ; break ; ... default : instruction ; )

Le programme recherche d'abord une étiquette qui correspond à la valeur de l'expression, puis exécute l'instruction associée. Si aucune étiquette correspondante n'est trouvée, le programme recherche une instruction par défaut facultative et, si elle est trouvée, exécute l'instruction associée. Si l'instruction par défaut n'est pas trouvée, le programme continue d'exécuter l'instruction après la fin de l'instruction switch.

L'instruction break facultative associée à l'étiquette case garantit que le programme interrompra l'exécution de l'instruction switch dès que l'instruction match sera exécutée et continuera l'exécution à partir de l'instruction suivant l'instruction switch. Si break est absent, le programme continue d'exécuter l'instruction suivante à l'intérieur de l'instruction switch.

Exemple.

Ici, si expr prend la valeur Bananas , le programme correspond à la casse Bananas et exécute l'instruction associée. Si une interruption est rencontrée, le programme interrompt le commutateur et exécute l'instruction après le bloc d'instructions switch. Si break n'est pas présent, l'instruction au cas où Cherries sera également exécutée.

switch (expr ) ( case " Oranges " : document . write (" Les oranges coûtent 0,59 $ la livre.
" ) ; break ; case " Pommes " : document . write (" Les pommes coûtent 0,32 $ la livre.
" ) ; break ; case " Bananes " : document . write (" Les bananes coûtent 0,48 $ la livre.
" ) ; break ; case " Cerises " : document . write (" Les cerises coûtent 3,00 $ la livre.
" ) ; break ; default : document . write (" Désolé, nous n'avons plus de " + i + " .
" ) ; ) document . write (" Y a-t-il autre chose que vous aimeriez ?
" ) ;

3. Instructions de boucle Une boucle est un ensemble d'instructions exécutées plusieurs fois jusqu'à ce qu'une condition spécifiée soit remplie. JavaScript prend en charge les instructions de boucle for , do...while et while , ainsi que label (label n'est pas une instruction de boucle en soi, mais est souvent utilisé avec lesdites instructions). En outre, vous pouvez utiliser des instructions break et continue dans des instructions de boucle.

Une autre instruction de boucle, for...in , exécute également ses instructions dans une boucle, mais est utilisée pour opérer sur des objets. Voir Opérateurs de manipulation d'objets.

3.1. L'instruction for La boucle for itère tant que la valeur spécifiée est false . La boucle JavaScript for est similaire aux boucles for Java et C. L'instruction for ressemble à ceci :

for ([ expressioninitiale ] ; [ condition ] ; [ expressionincrémentale ]) ( instructions )

Lorsque la boucle for est exécutée, voici ce qui se passe :

1. L'expression initiale initialExpression , le cas échéant, est exécutée. Cette expression initialise généralement un ou plusieurs compteurs de boucle, et la syntaxe permet des expressions de n'importe quelle complexité. Cette expression peut également déclarer des variables.

2. L'expression de condition est évaluée. Si condition est true , les instructions/instructions de boucle sont exécutées. Si condition est false , la boucle for se termine. Si l'expression de la condition est complètement absente, la condition est supposée vraie.

3. Les instructions sont exécutées.

4. L'expression de mise à jour incrementExpression , le cas échéant, est exécutée et le contrôle revient à l'étape 2.

Exemple.

Cette fonction contient une instruction for qui compte le nombre d'options sélectionnées dans une liste déroulante (un objet Select qui permet plusieurs sélections). L'instruction for déclare la variable i et l'initialise à zéro. Il vérifie si i est inférieur au nombre d'options sur l'objet Select, exécute l'instruction if et incrémente i de un après chaque itération de la boucle.

function howMany(selectObject) ( var numberSelected=0; for (var i=0; i< selectObject.options.length; i++) { if (selectObject.options[i].selected==true) numberSelected++; } return numberSelected; }

Choisissez des types de musique, puis cliquez sur le bouton ci-dessous :
R&B Jazz Blues New Age Classique Opéra

3.2. Instruction do...while L'instruction do...while est répétée tant que l'expression spécifiée est fausse. L'instruction do...while ressemble à ceci :

faire (instruction) tandis que (condition)

L'instruction est exécutée une fois avant que la condition ne soit vérifiée. Si la condition est true , l'instruction est exécutée à nouveau. A la fin de chaque exécution, la condition est vérifiée. Si condition est false , l'exécution s'arrête et le contrôle est transféré à l'instruction après do...while .

Exemple.

Dans cet exemple, la boucle do itère au moins une fois et itère tant que i est inférieur à 5 .

faire ( je += 1 ; documenter . écrire (i ) ; ) tandis que (je< 5 ) ;

3.3. L'instruction while L'instruction while exécute ses instructions tant que la condition spécifiée est vraie. L'instruction while ressemble à ceci :

tandis que (condition) (instructions)

Si condition devient false , les instructions à l'intérieur de la boucle arrêtent de s'exécuter et le contrôle est transféré à l'instruction suivant la boucle.

La vérification de la condition/condition se produit avant l'exécution des instructions à l'intérieur de la boucle. Si condition renvoie true , les instructions sont exécutées et la condition est à nouveau vérifiée. Si condition renvoie false , la boucle se termine et le contrôle est transféré à l'instruction suivant l'instruction while.

Exemple 1

Cette boucle while itère tant que n est inférieur à 3 :

n = 0 x = 0 tandis que (n< 3 ) { n ++; x += n ; }

À chaque itération, la boucle incrémente n et ajoute cette valeur à x . Par conséquent, x et n prennent les valeurs suivantes :

• Après la première passe : n = 1 et x = 1

• Après la deuxième passe : n = 2 et x = 3

• Après la troisième passe : n = 3 et x = 6

Après trois itérations de la boucle, la condition n< 3 больше не true, поэтому выполнение цикла прерывается.

Exemple 2 : boucle infinie.

Assurez-vous que la condition de boucle deviendra un jour fausse ; sinon le cycle ne se brisera jamais. Les prochaines instructions de la boucle while sont exécutées indéfiniment, puisque la condition ne deviendra jamais fausse :

while (true ) ( alert (" Hello, world " ) )

3.4. instruction label L'instruction label est un identificateur qui peut être référencé n'importe où dans le programme. Par exemple, vous pouvez utiliser une étiquette pour identifier une boucle, puis utiliser des instructions break ou continue pour interrompre la boucle ou poursuivre l'exécution.

La syntaxe de l'instruction label ressemble à ceci :

étiquette : déclaration

La valeur de l'étiquette peut être n'importe quel identifiant JavaScript valide qui n'est pas un mot réservé. L'énoncé/l'énoncé identifié par l'étiquette peut être n'importe quel énoncé.

Exemple.

Dans cet exemple, l'étiquette markLoop identifie une boucle while.

markLoop : while (theMark == true ) doSomething() ; )

3.5. Instruction break Utilisez l'instruction break pour interrompre une boucle de commutation ou une instruction libellée label.

• Si vous utilisez break sans label , il casse immédiatement le contenu le plus proche while , do-while , for ou switch et transfère le contrôle à l'instruction suivante.

• Si vous utilisez break with label , cela rompt l'instruction étiquetée spécifiée.

La syntaxe de l'instruction break est :

1 . pause 2. étiquette de rupture

La première option rompt la boucle ou le commutateur contenant le plus proche ; la deuxième option interrompt l'instruction spécifiée qui a l'étiquette.

Exemple.

Cela itère sur les éléments du tableau jusqu'à ce que l'index de l'élément avec la valeur de theValue soit trouvé :

pour (i = 0 ; je< a . length ; i ++ ) { if (a [ i ] = theValue ) break ; }

3.6. Instruction continue L'instruction continue est utilisée pour redémarrer les instructions while , do-while , for et label .

• Si vous utilisez continue sans label , il interrompt l'itération actuelle de la boucle while, do-while ou for la plus proche et continue d'exécuter cette boucle avec l'itération suivante. Contrairement à l'instruction break, continue ne rompt pas complètement la boucle. Dans la boucle while, il saute à condition . Dans une boucle for sur increment-expression .

• Si vous utilisez continue avec une étiquette, elle s'applique à l'instruction de boucle identifiée par cette étiquette.

La syntaxe de l'instruction continue est :

1 . continuer 2. continuer l'étiquette

Exemple 1

Voici un exemple de boucle while avec une instruction continue qui est exécutée si la valeur de i est 3 . Donc n obtient les valeurs 1, 3, 7 et 12 .

je = 0 n = 0 alors que je< 5 ) { i ++; if (i == 3 ) continue ; n += i ; }

Exemple 2

Une instruction étiquetée checkiandj contient une instruction étiquetée checkj . Si continue est trouvé, le programme abandonne l'itération en cours de checkj et commence l'itération suivante. Chaque fois qu'un continue est rencontré, checkj recommence à itérer jusqu'à ce que sa condition renvoie false . Si false est renvoyé, le reste de l'instruction checkiandj est exécuté et checkiandj itère jusqu'à ce que sa condition renvoie false. Si false est renvoyé, le programme continue son exécution à partir de l'instruction suivant checkiandj .

Si continue a une étiquette pour checkiandj , le programme continuera depuis le début de l'instruction checkiandj.

checkiandj : tandis que (je< 4 ) { document . write (i + "
" ) ; i += 1 ; checkj : while (j > 4 ) ( document . write (j + "
" ) ; j -= 1 ; if ((j % 2 ) == 0 ) continue checkj ; document . write (j + " est impair.
" ) ; ) document.write(" je = " + je + "
" ) ;document.write(" j = " + j + "
" ) ; }

4. Opérateurs de manipulation d'objets JavaScript utilise les instructions for...in et with pour manipuler les objets.4.1. L'instruction for...in L'instruction for...in itère la variable spécifiée sur toutes les propriétés d'un objet. Pour chaque propriété atteinte, JavaScript exécute les instructions spécifiées. L'instruction for...in ressemble à ceci :

Pour (variable dans l'objet) (

Exemple.

Cette fonction prend un objet et le nom de l'objet comme argument. Il itère ensuite sur toutes les propriétés de cet objet et renvoie une chaîne - une liste de noms de propriétés et leurs valeurs.

function dump_props (obj , obj_name ) ( var result = "" ; for (var i in obj ) ( result += obj_name + " . " + i + " = " + obj [ i ] + "
" ) résultat += " " ; renvoie le résultat ; )

Pour un objet voiture avec des propriétés de marque et de modèle, le résultat serait :

voiture. marque = voiture Ford . modèle = Mustang

4.2. L'instruction with L'instruction with définit l'objet par défaut pour un ensemble de blocs d'instructions. JavaScript examine les noms non qualifiés à l'intérieur d'un bloc d'instructions et détermine si les noms sont des propriétés par défaut de l'objet. Si le nom non qualifié est une propriété, cette propriété est utilisée dans l'instruction ; sinon, une variable locale ou globale est utilisée.

L'instruction with ressemble à ceci :

avec (objet )( instructions )

Exemple.

Ici, l'instruction with spécifie que l'objet Math est l'objet par défaut. Les instructions après l'instruction with accèdent à la propriété PI et aux méthodes cos et sin sans spécifier d'objet. JavaScript accepte un objet Math comme objet pour ces appels.

var a , x , y ;; var r = 10 avec (Math ) ( a = PI * r * r ; x = r * cos (PI ) ; y = r * sin (PI / 2); )

Note :

L'utilisation de l'instruction with peut ralentir considérablement l'exécution du programme.

5. Commentaires Les commentaires expliquent généralement ce que fait le code. Les commentaires sont ignorés par l'interpréteur. JavaScript prend en charge les commentaires de style Java et C++ :

• Un commentaire sur une seule ligne avec une double barre oblique au début de la ligne (//).

• Commentaire multiligne avec /* au début et */ à la fin.

Exemple.

Voici un exemple de deux commentaires :

// Ceci est un commentaire sur une seule ligne. /* Et c'est multi-ligne. Il peut être de n'importe quelle longueur et vous pouvez mettre ce que vous voulez ici. */

6. Instructions de gestion des exceptions Vous pouvez lancer une exception avec une instruction throw et la gérer avec des instructions try...catch.

L'instruction try...catch est également utilisée pour gérer les exceptions Java. Voir "Gestion des exceptions Java dans JavaScript" et "Gestion des exceptions JavaScript dans Java".

6.1. instruction throw L'instruction throw est utilisée pour lever une exception. Si vous lancez une exception, vous spécifiez une expression contenant la valeur de l'exception :

jeter une expression

Le code suivant lève plusieurs exceptions.

lancer "Erreur2" ; // lève une exception avec une valeur de chaîne throw 42 ; // lève une exception avec la valeur 42 throw true ; // lève une exception avec la valeur true

Lors de la levée d'une exception, vous pouvez spécifier un objet. Vous pouvez ensuite accéder aux propriétés de l'objet dans le bloc catch. L'exemple suivant crée un objet myUserException de type UserException et l'utilise dans une instruction throw.

// Un objet de type UserException est créé function UserException (message ) ( this . message = message ; this . name = " UserException " ; ) // Une instance d'objet est créée et appelée myUserException = new UserException (" Value too high " ) ; lancer myUserException ;

6.2. Instruction try...catch L'instruction try...catch marque un bloc d'instructions, tente de les exécuter et spécifie une ou plusieurs réponses lorsqu'une exception se produit. Si une exception se produit, l'instruction try...catch l'intercepte.

Une instruction try...catch se compose d'un bloc try, qui contient une ou plusieurs instructions, et de zéro ou plusieurs blocs catch, qui contiennent des instructions qui spécifient ce qu'il faut faire lorsqu'une exception est levée dans le bloc try. Autrement dit, si vous voulez exécuter un bloc try et qu'il échoue, vous transférez le contrôle au bloc catch. Si une instruction dans un bloc try (ou une instruction d'une fonction appelée à partir d'un bloc try) lève une exception, le contrôle est immédiatement transféré au bloc catch. Si aucune exception n'a été levée, le bloc catch est ignoré. Le bloc finally est exécuté après l'exécution des blocs try et catch, mais avant l'exécution de l'instruction suivant le bloc d'instruction try...catch.

L'exemple suivant utilise l'instruction try...catch. Une fonction est appelée qui interroge le nom du mois à partir du tableau en fonction de la valeur transmise à la fonction. Si la valeur ne correspond pas au numéro du mois (1-12 ), une exception est levée avec la valeur "InvalidMonthNo" et les instructions du bloc catch définissent la variable dans monthName sur unknown.

function getMonthName (mo ) ( mo = mo - 1 ; // Récupère le numéro du mois par l'index du tableau (1=Jan, 12=Dec) var mois = new Array (" Jan " , " Feb " , " Mar " , " Apr " , " May " , " Jun " , " Jul " , " Aug " , " Sep " , " Oct " , " Nov " , " Dec " ) ; if (months [ mo ] != null ) ( return month [ mo ] ) else ( throw " InvalidMonthNo " ) ) try ( // tente d'exécuter ces instructions : monthName = getMonthName (myMonth ) // la fonction peut déclencher une exception ) catch (e ) ( monthName = " unknown " logMyErrors (e ) // l'objet qui a appelé l'exception est passé au gestionnaire d'exceptions)

lancer; vous pouvez utiliser cet identifiant pour obtenir des informations sur l'exception levée. JavaScript crée cet identifiant lorsqu'il entre dans le bloc catch ; l'identifiant n'existe que lors de l'exécution du bloc catch ; une fois le bloc catch terminé, l'identifiant n'est plus disponible.

Par exemple, le code suivant lève une exception. Si une exception se produit, le contrôle est transféré au bloc catch.

try ( throw "myException" // une exception est levée ) catch (e ) ( // instructions pour gérer toute exception logMyErrors (e ) // l'exception est transmise au gestionnaire d'erreurs )

Plusieurs blocs catch

Une seule instruction try peut contenir plusieurs blocs catch conditionnels, chacun gérant un type spécifique d'exception. Dans ce cas, le bloc catch conditionnel approprié est entré uniquement lorsque l'exception spécifiée pour ce bloc est levée. Vous pouvez également éventuellement inclure un bloc catch séparé pour toutes les exceptions non spécifiées en tant que bloc catch final dans l'instruction.

Par exemple, fonction suivante appelle trois autres fonctions (déclarées ailleurs) qui testent ses arguments. Si la fonction de test détermine que le composant testé n'est pas valide, elle renvoie 0, obligeant l'appelant à lever l'exception spécifiée.

function getCustInfo (name , id , email ) ( var n , i , e ; if (! validate_name (name )) throw " InvalidNameException " else n = name ; if (! validate_id (id )) throw " InvalidIdException " else i = id ; if (! validate_email (email )) throw " InvalidEmailException " else e = email ; cust = (n + " " + i + " " + e ) ; return (cust ) ; )

Les blocs catch conditionnels contrôlent l'invocation du gestionnaire d'exceptions approprié.
" ) ( // appelle bad_id_handler (e ) ) catch (e if e == " InvalidEmailException " ) ( // appelle bad_email_handler (e ) ) catch (e )( // l'exception inconnue est écrite dans le fichier journal logError (e ) )

finalement bloquer

Le bloc finally contient des instructions exécutées après l'exécution des blocs try et catch, mais avant l'exécution des instructions suivant l'instruction try...catch. Le bloc finally est exécuté, qu'une exception ait été levée ou non. Si une exception est levée, les instructions du bloc finally sont exécutées même si aucun bloc catch n'a géré l'exception.

Vous pouvez utiliser un bloc finally pour terminer proprement un script lorsqu'une exception se produit ; par exemple, vous devrez peut-être libérer une ressource associée à un script. Dans l'exemple suivant, un fichier est ouvert et les opérateurs travaillent avec lui (le JavaScript côté serveur permet l'accès aux fichiers). Si une exception est levée lorsque fichier ouvert, le bloc finally ferme le fichier avant que le script n'échoue.

ouvreMonFichier(); try ( writeMyFile (theData) ) finally ( closeMyFile () // la ressource est toujours fermée)

Imbrication des instructions try...catch

Vous pouvez imbriquer une ou plusieurs instructions try...catch les unes dans les autres. Si l'instruction try...catch interne n'a pas de bloc catch, le bloc catch de l'instruction try...catch contenante est vérifié pour une correspondance.