Opérateurs
Opérateurs arithmétiques
Les nombres supportent plusieurs opérations, comme la multiplication *, la division /, l'addition + et la soustraction -, souvent utilisées avec des opérateurs arithmétiques. Ces opérateurs incluent l'addition, la soustraction, la multiplication, la divsiion et le modulo.
+: somme-: différence*: produit/: quotient%: modulo, c'est-à-dire le reste (souvent utilisé pour vérifier la divisibilité)
Priorité des opérateurs arithmétiques : Lorsque plusieurs opérateurs sont combinés, ils sont exécutés selon un ordre de priorité. En JavaScript, une priorité plus élevée signifie une exécution antérieure ; en cas d'égalité de priorité, l'exécution se fait de gauche à droite.
* / %ont la même priorité+ -ont la même priorité* / %ont une priorité supérieure à+ -- L'utilisation de
()peut augmenter la priorité
Opérateurs d'affectation
Opérateurs utilisés pour attribuer des valeurs aux variables. = : opérateur d'affectation le plus courant, il attribue la valeur à droite à la variable à gauche, qui doit être un conteneur valide. Autres opérateurs d'affectation : += -= *= /= %=.
Opérateurs unaires
Les opérateurs JavaScript peuvent être classés selon le nombre d'expressions qu'ils nécessitent : unaires, binaires ou ternaires. Les opérateurs unaires typiques sont ++ --.
++incrémentation : augmente la valeur de la variable de 1--décrémentation : diminue la valeur de la variable de 1
Utilisation de l'incrémentation :
- Pré-incrémentation : la valeur est d'abord augmentée, puis utilisée
- Post-incrémentation : la valeur est d'abord utilisée, puis augmentée
- Lorsqu'elles sont utilisées seules, pré-incrémentation et post-incrémentation sont identiques.
Scénario d'utilisation : fréquemment pour le comptage.
let compteur = 1;
console.log(compteur++ + ++compteur + compteur); // 7
Opérateurs de comparaison
Utilisés pour comparer la grandeur de deux données.
>: supérieur<: inférieur>=: supérieur ou égal<=: inférieur ou égal==: égalité de valeur===: égalité de valeur et de type (généralement recommandé)!==: non égalité totale (généralement recommandé)
Règles de comparaison :
- La comparaison de chaînes se base sur les valeurs ASCII, de gauche à droite ; si le premier caractère est égal, le suivant est comparé, etc.
- NaN n'est égal à aucune valeur, y compris lui-même, et toute comparaison impliquant NaN donne false.
- Évitez de comparer des nombres décimaux en raison des problèmes de précision.
- Lors de comparaisons entre types différents, une conversion implicite en nombre se produit ; pour des comparaisons précises, préférez === ou !==.
- Les booléens sont convertis en nombres (0 ou 1) lors des comparaisons.
- Pour les nombres, seul 0 est faux, les autres sont vrais.
- Pour les chaînes, seule la chaîne vide '' est fausse, les autres sont vraies.
Opérateurs logiques
Scénario d'utilisation : les opérateurs logiques servent à gérer des conditions multiples.
Priorité des opérateurs
- L'opérateur non logique (!) a une priorité très élevée dans les opérateurs unaires.
- L'opérateur logique ET (&&) a une priorité supérieure à OU (||).
Opérateur ternaire
Format : condition ? code si vraie : code si fausse
Généralement utilisé pour récupérer des valeurs.
<html lang="fr">
<head>
<meta charset="UTF-8">
<title>Exemple</title>
</head>
<body>
<script>
let nombre = +prompt('Entrez un nombre');
nombre < 10 ? document.write('0' + nombre) : document.write(nombre);
</script>
</body>
</html>
Instructions
Différence entre expression et instruction :
Une expression peut être évaluée et peut donc être placée à droite d'une instruction d'affectation, par exemple : nombre = 3 + 4.
Une instruction n'a pas nécessairement de valeur ; des instructions comme alert(), for ou break ne peuvent pas être utilisées pour l'affectation.
Les programmes utilisent trois structures de contrôle :
- Structure séquentielle
- Structure conditionnelle
- Structure itérative
Instruction conditionnelle if
Les instructions conditionnelles permettent d'exécuter sélectivement du code.
// Condition simple
if (condition) {
code exécuté si la condition est vraie
}
- Si la condition entre parenthèses est vraie, le code dans les accolades est exécuté.
- Si le résultat entre parenthèses n'est pas un booléen, une conversion implicite en booléen se produit.
- Si les accolades contiennent une seule instruction, elles peuvent être omises, mais cette pratique est découragée.
// Double condition
if (condition) {
code si vraie
} else {
code si fausse
}
// Conditions multiples
if (condition1) {
code1
} else if (condition2) {
code2
} else {
code3
}
- Évaluation de condition1 ; si vraie, code1 est exécuté, sinon passage à condition2.
- Si condition2 est vraie, code2 est exécuté, sinon passage à condition suivante.
- Si aucune condition n'est vraie, code3 est exécuté.
- Il est possible d'ajouter N conditions.
Instruction conditionnelle switch
L'instruction switch est généralement utilisée pour des comparaisons de valeurs, pas pour des intervalles. Elle est souvent associée au mot-clé break ; sans break, un phénomène de percée se produit.
switch (donnee) {
case valeur1:
code1
break;
case valeur2:
code2
break;
default:
code3
break;
}
- Recherche d'une valeur correspondant exactement (===) à la donnée entre parenthèses, exécution du code correspondant.
- Aucune correspondance : exécution du code dans default.
Boucle while
Pour exécuter des opérations répétitives. while : pendant que, donc la boucle while répète du code tant que la condition est vraie.
while (condition de boucle) {
code à répéter (corps de la boucle)
}
- Similaire à if : exécution du corps uniquement si la condition est vraie.
- Après exécution du corps, retour à la vérification de la condition ; si vraie, le corps est réexécuté, jusqu'à ce que la condition soit fausse.
Éléments essentiels de la boucle while : La boucle commence par une valeur initiale, évolue progressivement et s'arrête à une condition de fin.
- Valeur initiale de la variable
- Condition d'arrêt (sans elle, la boucle devient infinie)
- Variation de la variable (incrémnetation ou décrémentation)
let index = 1;
while (index <= 3) {
document.write('Cette boucle s\'exécute trois fois <br>');
index++;
}
Sortie de boucle
break: sort de la boucle entière, utilisé lorsque le résultat est obtenu et les itérations restantes sont inutiles.continue: passe à l'itération suivante, utilisé pour exclure ou sauter une option.
Boucle for
Avantage : regroupe la déclaration initiale, la condition et la variation en un seul endroit, pour une meilleure lisibilité ; c'est la forme de boucle la plus courante.
for (variable initiale; condition; variation) {
// corps de la boucle
}
À noter :
- while(true) permet de créer une boucle "infinie", nécessitant break pour en sortir.
- for( ; ; ) peut également créer une boucle "infinie", avec break pour en sortir.
Différence entre boucle for et boucle while :
Utilisez for lorsque le nombre d'itérations est connu ; utilisez while lorsqu'il est inconnu.
Boucles imbriquées : Une boucle à l'intérieur d'une autre, généralement dans des boucles for.
for (variable externe; condition externe; variation externe) {
for (variable interne; condition interne; variation interne) {
// corps de la boucle
}
}