1. Operador de multiplicación
1. Multiplicación: *
Algunas reglas especiales para operadores de multiplicación:
Si los operandos son valores numéricos, de acuerdo con la multiplicación convencional, si el producto excede el rango de representación del valor de ECMAScript, return Infinity o -infinity
Si un operando es NAN, el resultado de retorno es NAN
Si el infinito se multiplica por 0, return nan
Si el infinito se multiplica por un número no 0, return Infinity o -infinity
Multiplicar infinito con infinito y retorno infinito
Si hay un operando que no es un valor numérico, el fondo primero llamará al número () para convertirlo en un valor numérico y luego aplicar las reglas anteriores
La copia del código es la siguiente:
<script type = "text/javaScript">
alerta (5 * 6); // 30
alerta (5 * nan); //Yaya
alerta (infinito * 0); //Yaya
alerta (infinito * 2); //Infinidad
alerta ("5" * 5); // 25
alerta (verdadero * 10); // 10
alerta (falso * 10); // 0
</script>
2. División:/
Algunas reglas especiales para los operadores de división:
Si los operandos son todos valores numéricos, de acuerdo con el cálculo de la división convencional, si el cociente excede el rango de representación del valor de ECMAScript, el retorno infinito o la infinidad
Si un operando es NAN, el resultado de retorno es NAN
Si el infinito es expulsado por Infinity, regrese a Nan
Si 0 se divide por 0, devuelve nan
Si el número finito de no 0 se divide por 0, devuelve infinito o infinidad
Si el infinito se divide por un número finito que no es cero, devuelve infinito o infinidad
Si hay un operando que no es un valor numérico, el fondo primero llamará al número () para convertirlo en un valor numérico y luego aplicar las reglas anteriores
La copia del código es la siguiente:
<script type = "text/javaScript">
alerta (5/5); // 1
alerta (5 / nan); //Yaya
alerta (infinito / infinito); //Yaya
alerta (infinito / 2); //Infinidad
alerta (5/0); //Infinidad
alerta (10 / verdadero); // 10
alerta (10 / falso); //Infinidad
</script>
3. Encuentre el módulo (restante): %
Algunas reglas especiales para encontrar operadores modulares:
Si los operandos son todos valores numéricos, calcule de acuerdo con el método de división convencional y devuelva el número restante obtenido dividiendo
Si el dividendo es infinito y el dividendo es un número finito, el resultado de retorno es nan
Si el dividendo es finito y el dividendo es 0, return nan
Si el infinito es expulsado por Infinity, regrese a Nan
Si el dividendo es finito y el dividendo es infinito, devuelva el dividendo
Si el dividendo es 0, regresa 0
Si hay un operando que no es un valor numérico, el fondo primero llamará al número () para convertirlo en un valor numérico y luego aplicar las reglas anteriores
La copia del código es la siguiente:
<script type = "text/javaScript">
alerta (26 % 5); // 1
alerta (infinito % 3); //Yaya
alerta (3 % 0); //Yaya
alerta (5 % infinito); // 5
alerta (0 % 10); // 0
alerta (verdadero % 25); // 1
alerta (3 % falso); //Yaya
</script>
2. Operadores aditivos
1. Operador de adición: +
Si uno de los operandos es una cadena:
Si ambos operandos son cadenas, entonces emplome el segundo operando después del primer operando.
Si solo un operando es una cadena, luego convierta otro operando en una cadena y luego ejecute las reglas anteriores
La copia del código es la siguiente:
<script type = "text/javaScript">
Resultado var1 = 5 + 5; // Agregar números a los números
alerta (resultado1); // 10
VAR result2 = 5 + "5"; // Agregar una cadena con un número
alerta (resultado2); // "55"
</script>
2. Operador de sustracción:-
Si un operando es una cadena, booleana, nula o indefinida, entonces llame al número () en segundo plano para convertirlo en un valor numérico y luego realizar una resta.
3. Operadores relacionales
Mayor que:>
Menos que: <
Mayor o igual a:> =
Menos o igual a: <=
Reglas especiales del operador relacional:
Si el operando es una cadena, compare la codificación de caracteres correspondiente de las dos cadenas
Si un operando es un valor numérico, luego convierta el otro operando en un valor numérico y luego compare
Cualquier número se compara con NAN y el resultado es falso
IV. Operador igual
1. Igual y desigual: == y! =
Ambos operadores convertirán el operando al mismo tipo antes de comparar
Al convertir, la igualdad y los operadores desiguales siguen las siguientes reglas:
Si uno de los operandos tiene un tipo booleano, primero conviértelo a un tipo numérico, falso a 0, verdadero para convertirlo a 1.
Si uno de los operandos tiene un tipo de cadena y la otra es un tipo numérico, luego convierta la cadena en un número para comparar.
Si uno de los operandos es un objeto y el otro no lo es, primero llame al método valuef () del operando, obtenga el valor de tipo básico y luego compárelo
Reglas especiales para la comparación:
NULL e indefinidos son iguales.
NULL e indefinido no se convertirá en ningún otro tipo
Si el resultado de alguna operación es NAN, entonces la comparación igual devuelve falso y la comparación desigual devuelve verdadero. Tenga en cuenta que incluso si ambos operandos son nan, el resultado de retorno es falso, es decir, Nan no es igual a Nan.
Si ambos operandos son objetos, compare los valores a los que se refieren, si se hace referencia al mismo objeto, entonces devuelva verdadero, de lo contrario, devuelva falso.
2. Congruencia e incompletitud: == y ===
== El operando se convertirá al mismo tipo para la comparación;
=== El tipo no se convertirá, compare directamente
Por ejemplo:
La copia del código es la siguiente:
VAR result1 = ("55" == 55);
VAR result2 = ("55" === 55);
alerta (resultado1); // Verdadero
alerta (resultado2); // falso "55" es una cadena, 55 es un número y los tipos son diferentes
V. Operador condicional
Variable = expresión condicional? Valor verdadero: valor falso
Primero, se evaluará la expresión condicional. Si el resultado es verdadero, el valor verdadero se asignará a la variable. If False, el valor falso se asignará a la variable.
La copia del código es la siguiente:
<script type = "text/javaScript">
var num1 = 10;
var num2 = 25;
var num3 = (num2> num1)? num2: num1;
alerta (num3); // 25
</script>
6. Operador de asignación
1. Operador de asignación simple: =
var num1 = 10;
num = num1+10;
2. Operadores de asignación de compuestos: +=, -=, *=, /=, %=, >> =, << =, >>> =
La copia del código es la siguiente:
<script type = "text/javaScript">
var num = 5;
alerta (num); // 5
num += 5;
alerta (num); // 10
num *= 2;
alerta (num); // 20
num /= 10;
alerta (num); // 2
num -= 2;
alerta (num); // 0
</script>
7. Operador de coma
El operador de coma puede realizar múltiples operaciones en una sola declaración
Propósito: 1. Declarar múltiples variables
var num1 = 1, num2 = 2, num3 = 3;
2. Asignación
var num = (0,1,2,3) // num = 3
Cuando se usa para operaciones de asignación, el operador de coma siempre devuelve el valor de la última expresión.
Área de práctica:
La copia del código es la siguiente:
<script type = "text/javaScript">
var num1 = 5;
var num2 = 10;
Var Message = "La suma de 5 y 10 es" + num1 + num2;
alerta (mensaje);
</script>
La copia del código es la siguiente:
<script type = "text/javaScript">
alerta (nulo == Undefined);
alerta (nulo === Undefined);
alerta ("nan" == nan);
alerta ("nan" === nan);
alerta (nan == nan);
alerta (nan === nan);
alerta (nan! = nan);
alerta (nan! == nan);
alerta (falso == 0);
alerta (falso === 0);
alerta (true == 1);
alerta (true === 1);
alerta (nulo == 0);
alerta (indefinido == 0);
alerta (5 == "5");
alerta (5 === "5");
</script>
Lo anterior se trata de este artículo, y la explicación de los operadores de JavaScript termina aquí. En el próximo artículo, explicaremos las declaraciones de JavaScript.