Parlons des opérateurs JavaScript

L'opérateur, également appelé opérateur, est un symbole utilisé pour implémenter des fonctions telles que l'affectation, la comparaison et l'exécution d'opérations arithmétiques.

Les opérateurs couramment utilisés en JavaScript sont :

• Opérateurs arithmétiques Opérateurs
• d'incrémentation et de décrémentation Opérateurs
• de comparaison
• Opérateurs logiques
• Opérateurs d'affectation

d'opérateur arithmétique

: Symboles utilisés dans les opérations arithmétiques, utilisés pour effectuer des opérations arithmétiques sur deux variables ou valeurs.

console.log(1 + 1); //2
    console.log(1 - 1); //0
    console.log(1 * 1); //1
    console.log(1 / 1); //1
    console.log(4 % 2); //0

les nombres à virgule flottante auront des erreurs dans les opérations arithmétiques (évitez la participation directe aux calculs) :

console.log(0.1 + 0.2); //0.30000000000000004

ne peut pas déterminer directement si deux nombres à virgule flottante sont égal.

var num = 0,1 + 0,2 ;
    console.log(num == 0.3); //false

• Priorité de l'opérateur arithmétique : multiplication et division en premier, addition et soustraction
• Vous pouvez utiliser l'opérateur % reste pour déterminer si un nombre est divisible.

Expression et valeur de retour :

composée de nombres et

opérateurs Une formule composée de , de variables, etc. est appelée une expression.

L’expression finira par nous renvoyer un résultat, appelé valeur de retour.

Opérateurs d'incrémentation et de décrémentation

Si vous devez ajouter ou soustraire 1 à plusieurs reprises à une variable numérique, vous pouvez utiliser les opérateurs d'incrémentation ( ++ ) et de décrémentation ( -- ) pour ce faire.

Écriture compliquée :

var num = 1 ;
    num = nombre + 1 ;
    num = nombre + 1 ;
    console.log(num); //3

opérateur d'incrément de préfixe :

++ est écrit devant la variable

++num l'incrément de préfixe doit augmenter de 1, similaire à num=num+1

var age = 10 ;
    ++âge ;
    console.log(age);//11 Semblable à la formule d'utilisation de age = age + 1

: ajoutez-le d'abord, puis renvoyez la valeur

console.log(age);
    var a = 10 ;
    console.log(++a + 10); //(10+1)+10=21

l'opérateur post-incrément

++ est écrit après la variable

num++ post-incrément, ce qui signifie ajouter 1 à lui-même, similaire à num=num+1

âge variable = 10 ;
    âge++;
    console.log(age);//11 est similaire à

la formule d'utilisation de age = age + 1 : renvoie d'abord la valeur d'origine, puis ajoute

var a = 10 ;
    console.log(a++ + 10); //10+10=20
    console.log(a); //11

Résumé des différences

• Les opérateurs de pré-incrémentation et de post-incrémentation peuvent simplifier l'écriture du code, rendant la valeur d'une variable +1 plus simple qu'auparavant.
• Lorsqu'il est utilisé seul, les résultats sont les mêmes.
• Lorsqu'il est utilisé conjointement avec d'autres codes, les résultats d'exécution seront différents.
• Préposition : ajoutez d'abord soi-même, puis effectuez les calculs ( d'abord soi-même avant les autres )
• Postposition : effectuez d'abord le calcul sur la valeur d'origine, puis ajoutez-vous ( d'abord, puis soi-même )
• Lors du développement, la plupart du temps, l'incrémentation/décrémentation postfixe est utilisée, et le code occupe une ligne. Exemple : num++;

Exercice :

var e = 10 ;
    var f = e++ + ++e; //1.e++=10 e=11 2.++e=12 f=10+12
    console.log(f); //22

d'opérateur de comparaison

 : L'opérateur de comparaison (opérateur relationnel) est un opérateur utilisé lors de la comparaison de deux données . Une valeur booléenne (true/false) est renvoyée après l'opération de comparaison. opération de comparaison.

console.log( 2 <= 5);
    console.log('Yue Zeyi' = 'blog personnel'); //false
    console.log(17 == '17'); //vrai type de données de conversion par défaut, le type de chaîne est converti en type numérique console.log(17 = '17'); //le faux type de données est différent, la valeur et le type de données sont requis Utilisation de symboles cohérents

d'opérateur logique

: les opérateurs logiques sont utilisés. Les opérateurs qui effectuent des opérations booléennes renvoient également une valeur booléenne. Il est souvent utilisé pour évaluer plusieurs conditions lors d’un développement ultérieur.

logical AND

Symbole : && est vrai lorsque les deux côtés de et

true true , tant qu'un côté est false , le résultat est false

.
    console.log(3 < 5 && 3 < 7); //vrai

OU logique

 : || équivaut à si

les deux côtés de ou sont false , le résultat est false , tant qu'un côté est true , le résultat est true

console.log(3 > 5 && 3 > 2); //faux
    console.log(3 < 5 && 3 < 7); //vrai

!

de négation logique

la négation logique est également appelée symbole de négation, qui est utilisé pour obtenir la valeur opposée d'une valeur booléenne.

console.log(!true); //false
    console.log(!false); //véritable

opération de court-circuit (interruption logique)

Le principe de l'opération de court-circuit : lorsqu'il y a plusieurs expressions (valeurs), lorsque la valeur de l'expression à gauche peut déterminer le résultat, l'expression à droite ne continuera plus à être exploitée. La valeur de la formule.

ET logique :

• Syntaxe :表达式1 && 表达式2
• Si la première expression est évaluée comme vraie, renvoie l'expression 2.
• Si la première expression est évaluée comme fausse, renvoie l'expression 1

console.log(123 && 456); sauf que 0 est vrai.
    console.log(123 && 456 && 789); //Retour 789, repousser dans la séquence console.log(0 && 456); //0

OU logique :

syntaxe :
• expression
• 1表达式1 || 表达式2
• Si c'est vrai, l'expression 1 est renvoyée.
• Si l'expression 1 est fausse, l'expression 2 est renvoyée

.
    console.log(123 || 456 || 123 + 456); //123);
    console.log(0 || 456 || 123 + 456); //456

Remarque : une interruption logique provoquera une opération de court-circuit, c'est-à-dire que le code suivant ne sera pas exécuté, affectant les résultats d'exécution du programmeur.

varnum = 0 ;
    console.log(123 || num++); //L'interruption logique a empêché l'exécution de num++ console.log(num); //0

de l'opérateur d'affectation

 : opérateur utilisé pour affecter des données aux variables

var num = 5;
    nombre += 10 ;
    console.log(num); //5+10=15
    num *= 3;
    console.log(num); //15*3=45

priorité de l'opérateur

• la non-priorité logique dans l'opérateur unaire est très élevée.
• Le ET logique a une priorité plus élevée que le OU logique

console.log(4 >= 6 || 'I' != 'you' && !(12 * 2 == 144) && true);
    /* 
    Les opérateurs logiques sont divisés en quatre sections 1.4 >= 6 pour obtenir faux
    2.'I' != 'tu' doit être vrai
    3.!(12 * 2 == 144) devient vrai
    4.vrai
    Jugez ensuite le ET logique : 2 et 3 sont vrais, 3 et 4 sont vrais 
    Puis jugez le logique ou : vrai
     */