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:
<script type = "text / javascript">
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:
<script type = "text / javascript">
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:
<script type = "text / javascript">
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:
<script type = "text / javascript">
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:
<script type = "text / javascript">
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:
<script type = "text / javascript">
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:
<script type = "text / javascript">
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:
<script type = "text / javascript">
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.