Opérateur de notes d'apprentissage JavaScript (suite)

Auteur：Eve Cole Date de mise à jour：2025-05-18 20:32:02

1. Opérateur de multiplication

1. Multiplication: *

Quelques règles spéciales pour les opérateurs de multiplication:

Si les opérandes sont des valeurs numériques, selon la multiplication conventionnelle, si le produit dépasse la plage de représentation de la valeur ECMascript, renvoyez Infinity ou -Ifinity

Si un opérande est nan, le résultat de retour est nan

Si l'infini est multiplié par 0, retournez nan

Si l'infini est multiplié par un nombre non 0, retournez Infinity ou -Infinity

Multiplier l'infini avec l'infini et retourner l'infini

S'il y a un opérande qui n'est pas une valeur numérique, l'arrière-plan s'appellera d'abord le numéro () pour le convertir en valeur numérique, puis appliquer les règles ci-dessus

La copie de code est la suivante:

alerte (5 * 6); // 30

alerte (5 * nan); // nan

alerte (infinité * 0); // nan

alerte (infinité * 2); //Infini

alerte ("5" * 5); // 25

alerte (true * 10); // 10

alerte (false * 10); // 0

</cript>

2. Division: /

Quelques règles spéciales pour les opérateurs de division:

Si les opérandes sont toutes des valeurs numériques, selon le calcul de la division conventionnelle, si le quotient dépasse la plage de représentation de la valeur ECMAScript, renvoyez l'infini ou -finity

Si un opérande est nan, le résultat de retour est nan

Si l'infini est expulsé par l'infini, retournez à Nan

Si 0 est divisé par 0, retourne nan

Si le nombre fini de non 0 est divisé par 0, retournez Infinity ou -Ifinity

Si l'infini est divisé par un nombre fini qui n'est pas nul, retournez Infinity ou -Infinity

S'il y a un opérande qui n'est pas une valeur numérique, l'arrière-plan s'appellera d'abord le numéro () pour le convertir en valeur numérique, puis appliquer les règles ci-dessus

La copie de code est la suivante:

alerte (5/5); // 1

alerte (5 / nan); // nan

alerte (infinité / infinité); // nan

alerte (Infinity / 2); //Infini

alerte (5/0); //Infini

alerte (10 / true); // 10

alerte (10 / false); //Infini

</cript>

3. Trouvez le module (restant):%

Quelques règles spéciales pour trouver des opérateurs modulaires:

Si les opérandes sont toutes des valeurs numériques, calculez selon la méthode de division conventionnelle et renvoyez le numéro restant obtenu en divisant

Si le dividende est infini et que le dividende est un nombre fini, le résultat de retour est nan

Si le dividende est fini et que le dividende est 0, retourne nan

Si l'infini est expulsé par l'infini, retournez à Nan

Si le dividende est fini et que le dividende est infini, retournez le dividende

Si le dividende est 0, retournez 0

S'il y a un opérande qui n'est pas une valeur numérique, l'arrière-plan s'appellera d'abord le numéro () pour le convertir en valeur numérique, puis appliquer les règles ci-dessus

La copie de code est la suivante:

alerte (26% 5); // 1

alerte (infinité% 3); // nan

alerte (3% 0); // nan

alerte (5% d'infini); // 5

alerte (0% 10); // 0

alerte (vrai% 25); // 1

alerte (3% faux); // nan

</cript>

2. Opérateurs additifs

1. Opérateur d'addition: +

Si l'un des opérandes est une chaîne:

Si les deux opérandes sont des chaînes, épissez le deuxième opérande après le premier opérande.

Si un seul opérande est une chaîne, convertissez-vous un autre opérande en une chaîne, puis exécutez les règles ci-dessus

La copie de code est la suivante:

Var Result1 = 5 + 5; // ajouter des nombres aux nombres

alerte (résultat1); // 10

var result2 = 5 + "5"; // ajoute une chaîne avec un numéro

alerte (résultat2); // "55"

</cript>

2. Opérateur de soustraction: -

Si un opérande est une chaîne, booléen, nul ou indéfini, alors appelez numéro () en arrière-plan pour le convertir en valeur numérique, puis effectuer une soustraction.

3. Opérateurs relationnels

Supérieur à:>

Moins que: <

Supérieur ou égal à:> =

Moins que ou égal à: <=

Opérateur relationnel Règles spéciales:

Si l'opérande est une chaîne, comparez le codage de caractères correspondant des deux chaînes

Si un opérande est une valeur numérique, convertissez l'autre opérande en une valeur numérique, puis comparez

N'importe quel nombre est comparé à NAN et le résultat est faux

Iv. Opérateur égal

1. Égalité et inégale: == et! =

Les deux opérateurs convertiront l'opérande au même type avant de comparer

Lors de la conversion, l'égalité et les opérateurs inégaux suivent les règles suivantes:

Si l'un des opérandes a un type booléen, alors convertissez-le d'abord en un type numérique, faux à 0, vrai pour le convertir en 1.

Si l'un des opérandes a un type de chaîne et l'autre est un type numérique, convertissez la chaîne en un nombre pour comparaison.

Si l'un des opérandes est un objet et l'autre ne l'est pas, appelez d'abord la valeur de la valeur () de l'opérande, obtenez la valeur de type de base, puis comparez-la

Règles spéciales de comparaison:

Null et non défini sont égaux.

Null et non défini ne seront convertis en aucun autre type

Si le résultat d'une opération est NAN, la comparaison égale renvoie false et une comparaison inégale renvoie vrai. Notez que même si les deux opérandes sont NAN, le résultat de retour est faux, c'est-à-dire Nan ne soit pas égal à NAN.

Si les deux opérandes sont des objets, comparez les valeurs auxquelles ils se réfèrent, si le même objet est référencé, renvoyez-vous vrai, sinon renvoyez false.

2. CONGURANCE ET INCOMPRÈS: == et ===

== L'opérande sera converti au même type de comparaison;

=== Le type ne sera pas converti, comparez directement

Par exemple:

La copie de code est la suivante:

var result1 = ("55" == 55);

var result2 = ("55" === 55);

alerte (result1); // vrai

alerte (résultat2); // faux "55" est une chaîne, 55 est un nombre, et les types sont différents

V. Opérateur conditionnel

Variable = expression conditionnelle? Vrai Value: Faux Valeur

Premièrement, l'expression conditionnelle sera évaluée. Si le résultat est vrai, la vraie valeur sera attribuée à la variable. Si faux, la fausse valeur sera attribuée à la variable.

La copie de code est la suivante:

var num1 = 10;

var num2 = 25;

var num3 = (num2> num1)? num2: num1;

alerte (num3); // 25

</cript>

6. Opérateur d'affectation

1. Opérateur d'affectation simple: =

var num1 = 10;

num = num1 + 10;

2. Opérateurs d'affectation composés: + =, - =, * =, / =,% =, >> =, << =, >>> =

La copie de code est la suivante:

var num = 5;

alerte (num); // 5

num + = 5;

alerte (num); // 10

num * = 2;

alerte (num); // 20

num / = 10;

alerte (num); // 2

num - = 2;

alerte (num); // 0

</cript>

7. Opérateur de virgule

L'opérateur de virgule peut effectuer plusieurs opérations dans une seule déclaration

Objectif: 1. Déclarer plusieurs variables

var num1 = 1, num2 = 2, num3 = 3;

2. Affectation

var num = (0,1,2,3) // num = 3

Lorsqu'il est utilisé pour les opérations d'attribution, l'opérateur de virgule renvoie toujours la valeur de la dernière expression.

Zone de pratique:

La copie de code est la suivante:

var num1 = 5;

var num2 = 10;

var message = "La somme de 5 et 10 est" + num1 + num2;

alerte (message);

</cript>

La copie de code est la suivante:

alerte (null == non défini);

alerte (null === Undefined);

alert ("nan" == nan);

alert ("nan" === nan);

alerte (nan == nan);

alerte (nan === nan);

alerte (nan! = nan);

alerte (nan! == Nan);

alert (false == 0);

alert (false === 0);

alerte (true == 1);

alerte (true === 1);

alerte (null == 0);

alerte (undefined == 0);

alerte (5 == "5");

alerte (5 === "5");

</cript>

Ce qui précède concerne cet article, et l'explication des opérateurs JavaScript se termine ici. Dans le prochain article, nous expliquerons les déclarations JavaScript.