Tabla de contenido

1 operador unario
2 operadores booleanos
3 operador multiplicativo
4 Operador exponencial
5 Operador aditivo
6 operadores relacionales
7 Operador de igualdad
8 Marca de operación condicional
9 Operador de asignación
10 operador de coma

1 operador unario

Los operadores que solo operan en un valor se denominan operadores unarios.
(1) Operadores de incremento y decremento
Ya sea que se utilicen operadores de incremento o decremento de prefijo, el valor de la variable cambiará antes de que se evalúe la declaración.

let age = 29;
let another = --age+2;

console.log(age); //28
console.log(another); //30

La principal diferencia entre la versión del sufijo y la versión del prefijo es que el incremento y la disminución de la versión del sufijo solo ocurre después de que se evalúa la declaración.

        let num1 = 2;
        let num2 = 20;
        let num3 = num1-- + num2; //22
        let num4 = num1 + num2; //21

Los operadores de incremento y decremento se pueden usar para cualquier valor, lo que significa que no se limitan a enteros, cadenas, valores booleanos, valores de punto flotante e incluso objetos. Los operadores de incremento y decremento siguen las siguientes reglas:

Para una cadena, si es una forma numérica válida, conviértala en un valor numérico y aplique el cambio. El tipo de variable cambia de cadena a valor numérico.
Para una cadena, si no es una forma numérica válida, el valor de la variable se establece en NaN. El tipo de variable cambia de cadena a valor numérico.
Para un valor booleano, si es falso, se convierte a 0 antes de aplicar el cambio. El tipo de variable cambia de booleano a numérico.
Para valores booleanos, si es verdadero, convierta a 1 y aplique el cambio. El tipo de variable cambia de booleano a numérico.
Para valores de coma flotante, sume 1 y reste 1.
Si es un objeto, llame a su método valueOf () para obtener un valor operable. Aplicar las reglas anteriores al valor obtenido. Si es NaN, llame a toString () y aplique otras reglas nuevamente, el tipo de variable cambia de objeto a valor.

(2) Unario más y unario menos
Si unario más se aplica a valores no numéricos, se realizará la misma conversión de tipo que con la función de conversión Número (): los valores booleanos falso y verdadero se convierten en 0 y 1, y Las cadenas se analizan de acuerdo con reglas especiales. El objeto llamará a sus métodos valueOf () y / o toString () para obtener valores convertibles.

        let s1 = "01";
        let s2 = "1.1";
        let s3 = "z";
        let b = false;
        let o = {
    
    
            valueOf() {
    
    
                return -1;
            }
        };

        s1 = +s1; //值变成数值1
        s2 = +s2; //值变成数值1.1
        s3 = +s3; //值变成NaN
        b = +b; //值变成数值0
        f = +f; //不变
        o = +o; //值变成-1

2 operadores booleanos

Hay 3 operadores booleanos: negación lógica, AND lógico y OR lógico.
(1) Negación lógica El
operador de negación lógica está representado por un signo de exclamación (!) Y se puede aplicar a cualquier valor en ECMAScript. Este operador siempre devuelve un valor booleano, independientemente del tipo de datos que se aplique. El operador de negación lógica primero convierte el operando en un valor booleano y luego lo niega. El operador de negación lógica seguirá las siguientes reglas:

Si el operando es un objeto, devuelve falso
Si el operando es una cadena vacía, devuelve verdadero
Si el operando es una cadena no vacía, devuelve falso
Si el operando es el valor 0, devuelve verdadero
Si el operando es un valor distinto de cero, devuelve falso
Si el operando es nulo, devuelve verdadero
Si el operando es NaN, devuelve verdadero
Si el operando no está definido, devuelve verdadero

El operador de negación lógica también se puede utilizar para convertir cualquier valor en un valor booleano. Usar dos signos de exclamación (!!) al mismo tiempo es equivalente a llamar a la función de transformación Boolean ().
(2) Y
lógico El operador Y lógico está representado por dos símbolos de unión (&&) y se aplica a dos valores.

Primer operando	Segundo operando	resultado
cierto	cierto	cierto
cierto	falso	falso
falso	cierto	falso
falso	falso	falso

El operador lógico AND se puede utilizar para cualquier tipo de operando, sin limitarse a valores booleanos. Si el operando no es un valor booleano, el Y lógico no necesariamente devuelve un valor booleano, pero sigue las siguientes reglas:

Si el primer operando es un objeto, devuelve el segundo operando
Si el segundo operando es un objeto, el objeto solo se devolverá si el primer operando se evalúa como verdadero
Si ambos operandos son objetos, se devuelve el segundo operando.
Si uno de los operandos es nulo, devuelve nulo
Si uno de los operandos es NaN, se devuelve NaN
Si uno de los operandos no está definido, devuelve undefined

El operador lógico AND es un operador de cortocircuito, lo que significa que si el primer operando determina el resultado, el segundo operando nunca se evaluará. Para el operador lógico AND, si el primer operando es falso, no importa qué valor tenga el segundo operando, el resultado no puede ser igual a verdadero.
(3) OR
lógico El operador OR lógico está representado por dos caracteres de barra vertical (||) y sigue las siguientes reglas

Primer operando	Segundo operando	resultado
cierto	cierto	cierto
cierto	falso	cierto
falso	cierto	cierto
falso	falso	falso

Similar a lógico y, si uno de los operandos no es un valor booleano, entonces el operador lógico OR no necesariamente devuelve un valor booleano. Siga los siguientes principios:

Si el primer operando es un objeto, se devuelve el primer operando.
Si el primer operando se evalúa como falso, se devuelve el segundo operando.
Si ambos operandos son objetos, se devuelve el primer operando.
Si ambos operandos son nulos, devuelve nulos.
Si ambos operandos son NaN, se devuelve NaN.
Si ambos operandos no están definidos, devuelve undefined.

De manera similar al operador lógico Y, el operador lógico O también tiene la característica de cortocircuito. Es solo que para OR lógico, el primer operando se evalúa como verdadero y el segundo operando no se evaluará nuevamente.
Con este comportamiento, puede evitar asignar nulos o indefinidos a variables:

let myObject = preferredObject || backupObject;

En este ejemplo, a la variable myObject se le asignará uno de dos valores. Entre ellos, la variable favoriteObject contiene el valor preferido y la variable backupObject contiene el valor de la copia de seguridad.

3 operador multiplicativo

ECMAScript define tres operadores multiplicativos: multiplicación, división y módulo. Si el operador multiplicativo tiene un operando que no es un valor numérico, el operando se convertirá en un valor numérico mediante la función de transformación Number () en segundo plano.
Operador de
multiplicación El operador de multiplicación está representado por un asterisco (*) y se puede utilizar para calcular el producto de dos valores. Sin embargo, el operador de multiplicación también tiene algunos comportamientos especiales cuando se trata de valores especiales:

Si algún operando es NaN, se devuelve NaN
Si el infinito se multiplica por 0, se devuelve NaN
Si es Infinity multiplicado por un valor finito distinto de cero, devuelve Infinity o -Infinity según el signo del segundo operando
Si es Infinity multiplicado por Infinity, devuelve Infinity
Si hay un operando que no es un valor numérico, primero use Number () para convertirlo en un valor numérico en segundo plano y luego aplique las reglas anteriores.

Operador de
división El operador de división está representado por una barra (/) y se usa para calcular el cociente del primer operando dividido por el segundo operando. Al igual que el operador de multiplicación, el operador de división tiene algunos comportamientos especiales para valores especiales:

Si algún operando es NaN, se devuelve NaN
Si es 0 dividido por 0, se devuelve NaN
Si es un valor finito distinto de cero dividido por 0, devuelve Infinity o -Infinity según el signo del primer operando
Si es Infinity dividido por Infinity, se devuelve NaN
Si es Infinity dividido por cualquier valor, devuelve Infinity o -Infinity según el signo del segundo operando
Si hay un operando que no es un valor numérico, primero use la función Número () en segundo plano para convertirlo en un valor numérico y luego aplique las reglas anteriores.

Operador de
módulo El operador de módulo (resto) está representado por un signo de porcentaje (%). Como otros operadores multiplicativos, el operador de módulo tiene algunos comportamientos especiales para valores especiales:

Si el dividendo es ilimitado y el divisor es un valor finito, se devuelve NaN
Si el dividendo es un valor finito y el divisor es 0, se devuelve NaN
Si es Infinity dividido por Infinity, se devuelve NaN
Si el dividendo es un valor finito y el divisor es un valor infinito, se devuelve el dividendo.
Si el dividendo es 0 y el divisor no es 0, devuelve 0
Si hay un operando que no es un valor numérico, primero use la función Número () en segundo plano para convertirlo en un valor numérico y luego aplique las reglas anteriores.

4 Operador exponencial

ECMAScript7 agregó el operador exponente, Math.pow () ahora tiene su propio operador **, y el resultado es el mismo.

        console.log(Math.pow(3, 2)); //9
        console.log(3 ** 2); //9

5 Operador aditivo

(1) El operador aditivo (+) se utiliza para sumar dos números. Si ambos operandos son valores numéricos, el operador de suma realiza la operación de suma y devuelve el resultado de acuerdo con las siguientes reglas:

Si algún operando es NaN, se devuelve NaN
Si es Infinity más Infinity, devuelve Infinity
Si es -Infinity más -Infinity, devuelve -Infinity
Si es Infinity más -Infinity, se devuelve NaN
Si es +0 más +0, devuelve +0
Si es -0 más +0, devuelve +0
Si es -0 más -0, devuelve -0

Si uno de los operandos es una cadena, se aplican las siguientes reglas:

Si ambos operandos son cadenas, la segunda cadena se empalma después de la primera cadena
Si solo un operando es una cadena, convierta el otro operando en una cadena y luego concatenar las dos cadenas juntas.

Si algún operando es un objeto, valor numérico o booleano, llame a su método toString () para obtener una cadena y luego aplique las reglas de cadena anteriores. Para undefined y null, llame a la función String () para obtener "undefined" y "null" respectivamente.

        let result1 = 5+5;
        console.log(result1); //10

        let result2 = 5+"5";
        console.log(result2);//"55"

(2) Operador de
resta El operador de resta (-) también es un operador de uso frecuente. Al igual que el operador de suma, el operador de resta también tiene un conjunto de reglas para manejar conversiones entre diferentes tipos en ECMAScript:

Si algún operando es NaN, se devuelve NaN
Si es Infinity menos Infinity, se devuelve NaN
Si -Infinity menos -Infinity, se devuelve NaN
Si es Infinito menos -Infinito, devuelve Infinito
Si es -Infinity menos Infinity, devuelve -Infinity
Si es +0 menos +0, devuelve +0
Si es +0 menos -0, devuelve -0
Si es -0 menos -0, devuelve +0
Si algún operando es una cadena, booleano, nulo o indefinido, primero use Number () en segundo plano para convertirlo en un número y luego realice operaciones matemáticas de acuerdo con las reglas anteriores.
Si algún operando es un objeto, llame a su método valueOf () para obtener el valor que lo representa. Si el valor es NaN, se resta el resultado calculado NaN. Si el objeto no tiene un método valueOf (), se llama a su método toString () y luego la cadena resultante se convierte en un valor.

6 operadores relacionales

Los operadores relacionales realizan operaciones que comparan dos valores, incluidos menor que (<), mayor que (>), menor o igual que (<=) y mayor o igual que (> =). Todos estos operadores devuelven valores booleanos.
Al igual que otros operadores en ECMAScript, la conversión de tipos y otros comportamientos ocurren cuando se aplican a diferentes tipos de datos.

Si los operandos son todos valores numéricos, realice una comparación numérica
Si todos los operandos son cadenas, compare los códigos de los caracteres correspondientes en la cadena uno por uno
Si algún operando es un valor numérico, convierta otro operando en un valor numérico y realice una comparación numérica
Si algún operando es un objeto, llame al método valueOf () y luego realice la comparación de acuerdo con las reglas anteriores después de obtener el resultado. Si no hay valueOf (), llame al método toString () y luego realice la comparación de acuerdo con las reglas anteriores después de obtener el resultado.
Si algún operador es un valor booleano, se convierte en un valor numérico y luego se realiza la comparación.

Para las cadenas, los operadores relacionales comparan los códigos de los caracteres correspondientes en la cadena, y estos códigos son valores numéricos. Una vez completada la comparación, se devuelve un valor booleano. La codificación de letras mayúsculas es menor que la codificación de letras minúsculas, por lo que sucederá la siguiente situación:

let result = "Brick"<"alphabet"; //true

Aquí la cadena "Ladrillo" se considera más pequeña que la cadena "alfabeto", porque el código de la letra B es 66 y el código de la letra a es 97. Para obtener los resultados de la comparación en orden alfabético, debe convertir ambos al mismo caso (todo en mayúsculas o todo en minúsculas) y luego comparar:

let result = "Brick".toLowerCase<"alphabet".toLowerCase; //false

Otro fenómeno extraño es al comparar dos cadenas numéricas, como:

let result = "23"<"3"; //true

Esto devuelve verdadero al comparar las cadenas "23" y "3". Debido a que ambos operandos son cadenas, sus códigos de caracteres se comparan uno por uno (el código del carácter "2" es 50 y el código del carácter "3" es 51). Sin embargo, si uno de los operandos es numérico, el resultado de la comparación es correcto:

let result = "23"<3; //false

Siempre que el valor numérico se compare con la cadena, la cadena se convertirá primero en un valor numérico y luego se comparará el valor numérico. Para las cadenas numéricas, esto puede garantizar el resultado correcto, pero ¿qué pasa si la cadena no puede ser convertido en un valor numérico?

let result = "a"<3;

Debido a que "a" no se puede convertir a ningún valor significativo, solo se puede convertir a NaN. Existe una regla según la cual cualquier operador relacional devolverá falso cuando se trate de comparar NaN:

        let result1 = NaN<3; //false
        let result2 = NaN>=3; //false

7 Operador de igualdad

(1) Igual y desigual a
ECMAScript. El operador igual en ECMAScript está representado por dos signos iguales (==). Si los operandos son iguales, devolverá verdadero. El operador de desigualdad está representado por un signo de exclamación igual a (! =). Si los operandos no son iguales, devolverá verdadero. Ambos operadores realizarán primero la conversión de tipos y luego determinarán si los operandos son iguales:

Si algún operando es un valor booleano, conviértalo en un valor numérico y compare la igualdad. False se convierte en 0 y true se convierte en 1.
Si un operando es una cadena y el otro operando es un valor numérico, intente convertir la cadena en un valor numérico y compare si es igual.
Si un operando es un objeto y el otro operando no lo es, llame al método del objeto valueOf () para obtener su valor original y luego compare de acuerdo con las reglas anteriores.

Al comparar, estos dos operadores seguirán las siguientes reglas:

nulo e indefinido son iguales
Nulo e indefinido no se pueden convertir a otros tipos de valores y luego comparar.
Si algún operando es NaN, el operador de igualdad devuelve falso y el operador de desigualdad devuelve verdadero.
Si ambos operandos son objetos, compare si son el mismo objeto. Si ambos operandos apuntan al mismo objeto, el operador de igualdad devuelve verdadero. De lo contrario, los dos no son iguales.

(2) Congruencia y desigualdad Los
operadores de congruencia y desigualdad son similares a los operadores de igualdad y desigualdad, excepto que no convierten los operandos al comparar la igualdad. El operador congruente está representado por 3 signos iguales (===), y solo si los dos operandos son iguales sin conversión, devolverá verdadero:

let result1 = ("55"==55); //true
let result2 = ("55"===55); //false

El operador de desigualdad está representado por un signo de exclamación y dos signos iguales (! ==), y solo si los dos operandos no son iguales sin conversión, devolverá verdadero.

8 Marca de operación condicional

variable = boolean_expression?true_value:false_value;

El código anterior realiza una operación de asignación condicional, es decir, de acuerdo con el valor de la expresión condicional boolean_expression para determinar qué valor se asigna a la variable variable. Si boolean_expression es verdadero, se asigna true_value; si boolean_expression es falso, se asigna false_value.

9 Operador de asignación

10 operador de coma

El operador de coma se puede utilizar para realizar varias operaciones en una declaración:

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

Notas de estudio 4: operadores de JavaScript