Operador de notas de aprendizaje de JavaScript (continuación)

Autor：Eve Cole Fecha de actualización：2025-05-18 20:32:02

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:

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:

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:

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:

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:

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:

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:

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:

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.