Hablemos de operadores de JavaScript

Operador, también conocido como operador, es un símbolo que se utiliza para implementar funciones como asignación, comparación y realización de operaciones aritméticas.

Los operadores comúnmente utilizados en JavaScript son:

• Operadores aritméticos
• Operadores de incremento y decremento
Operadores
• de comparación
• Operadores lógicos
• Operadores de asignación

de operador aritmético

: Símbolos utilizados en operaciones aritméticas, utilizados para realizar operaciones aritméticas sobre dos variables o valores.

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

los números de punto flotante tendrán errores en las operaciones aritméticas (evite la participación directa en los cálculos):

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

no puede determinar directamente si dos números de punto flotante son igual.

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

primero

• , suma y resta.
• Puede utilizar el operador % restante para determinar si un número es divisible

. operadores Una fórmula compuesta de variables, etc. se llama expresión.

La expresión eventualmente nos devolverá un resultado, que se denomina valor de retorno.

Operadores de incremento y decremento

Si necesita sumar o restar 1 repetidamente a una variable numérica, puede usar los operadores de incremento ( ++ ) y decremento ( -- ) para lograrlo.

Escritura complicada:

var num = 1;
    número = número + 1;
    número = número + 1;
    console.log(num); //

Operador de incremento de 3 prefijos:

++ se escribe delante de la variable

++num debe aumentar en 1, similar a num=num+1

var age = 10;
    ++edad;
    console.log(age);//11 Similar a la fórmula de uso de edad = edad + 1

: agrégala primero y luego devuelve el valor

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

operador post-incremento

++ se escribe después de la variable

num++ post-incremento, lo que significa sumar 1 a sí mismo, similar a num=num+1

var edad = 10;
    edad++;
    console.log(age);//11 es similar a

la fórmula de uso de edad = edad + 1: primero devuelve el valor original, luego agrega

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

Resumen de diferencias

• Los operadores de preincremento y postincremento pueden simplificar la escritura de código, haciendo que el valor de una variable +1 sea más simple que antes.
• Cuando se usa solo, los resultados son los mismos.
• Cuando se usa junto con otros códigos, los resultados de la ejecución serán diferentes.
• Preposición: agregarse a sí mismo primero, luego realizar los cálculos ( primero uno mismo antes que los demás )
• Postposición: primero realizar el cálculo sobre el valor original, luego agregarse uno mismo ( primero uno primero, luego uno mismo )
• Al desarrollar, la mayoría de las veces, se utiliza el incremento/decremento del sufijo, y el código ocupa una línea. Ejemplo: num++;

Ejercicio:

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

de operador de comparación

: el operador de comparación (operador relacional) es un operador que se utiliza al comparar dos datos . Después de la operación de comparación, se devolverá un valor booleano (verdadero/falso). operación de comparación.

console.log( 2 <= 5);
    console.log('Yue Zeyi' = 'blog personal'); //falso
    console.log(17 == '17'); //tipo de datos de conversión predeterminado verdadero, el tipo de cadena se convierte a tipo numérico console.log(17 = '17'); //el tipo de datos falso es diferente, el valor y el tipo de datos son obligatorios Uso de

de operador lógico

: se utilizan operadores lógicos. Los operadores que realizan operaciones booleanas también devuelven un valor booleano. A menudo se utiliza para juzgar múltiples condiciones en el desarrollo posterior.

&&

AND lógico

true true , siempre que un lado sea false , el resultado es false

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

||

OR lógico

ambos lados de o son false , el resultado es false , siempre que un lado sea true , el resultado es true

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

de negación lógica

! En relación con no,

la negación lógica también se denomina símbolo de negación, que se utiliza para obtener el valor opuesto de un valor booleano.

console.log(!verdadero); //falso
    console.log(!false); // verdadera

operación de cortocircuito (interrupción lógica)

El principio de operación de cortocircuito: cuando hay múltiples expresiones (valores), cuando el valor de la expresión de la izquierda puede determinar el resultado, la expresión a la derecha ya no se seguirá operando el valor de la fórmula.

AND lógico:

• Sintaxis :表达式1 && 表达式2
• Si la primera expresión se evalúa como verdadera, devuelve la expresión 2.
• Si la primera expresión se evalúa como falsa, devuelve la expresión 1

console.log(123 && 456); //Devuelve 456, todos los números; excepto 0 son verdaderos.
    console.log(123 && 456 && 789); //Devuelve 789, retrocede en secuencia console.log(0 && 456); //0

lógico OR:

sintaxis:
• expresión
• 1表达式1 || 表达式2
• Si es verdadero, se devuelve la expresión 1.
• Si la expresión 1 es falsa, se devuelve la expresión 2

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

Nota: La interrupción lógica provocará una operación de cortocircuito, es decir, el código posterior no se ejecutará, lo que afectará los resultados de ejecución del programador.

varnum = 0;
    console.log(123 || num++); //La interrupción lógica provocó que num++ no se ejecutara console.log(num); //0

de operador de asignación

: operador utilizado para asignar datos a variables

var número = 5;
    número += 10;
    consola.log(núm); //5+10=15
    número *= 3;
    console.log(num); //15*3=45

de prioridad de operador

• la no prioridad lógica en el operador unario es muy alta.
• El AND lógico tiene mayor prioridad que el OR lógico

console.log(4 >= 6 || 'I' != 'you' && !(12 * 2 == 144) && true);
    /* 
    Los operadores lógicos se dividen en cuatro secciones 1.4 >= 6 para obtener falso
    2.'Yo' != 'tú' debe ser cierto
    3.!(12 * 2 == 144) se vuelve verdadero
    4.verdadero
    Luego juzga el AND lógico: 2 y 3 son verdaderos, 3 y 4 son verdaderos. 
    Luego juzga lo lógico o: verdadero
     */