Vamos falar sobre operadores JavaScript

Operador, também conhecido como operador, é um símbolo usado para implementar funções como atribuição, comparação e execução de operações aritméticas.

Os operadores comumente usados ​​em JavaScript são:

• Operadores aritméticos
• Operadores de incremento e decremento Operadores
• de comparação
• Operadores lógicos
• Operadores de atribuição

de operador aritmético

: Símbolos usados ​​em operações aritméticas, usados ​​para realizar operações aritméticas em duas variáveis ​​ou valores.

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

números de ponto flutuante terão erros em operações aritméticas (evite a participação direta nos cálculos):

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

não pode determinar diretamente se dois números de ponto flutuante são igual.

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

primeiro

• , adição e subtração
• Você pode usar o operador % restante para determinar se um número é divisível

. operadores Uma fórmula composta por , variáveis, etc. é chamada de expressão.

A expressão eventualmente retornará um resultado para nós, que é chamado de valor de retorno.

Operadores de incremento e decremento

Se você precisar adicionar ou subtrair 1 repetidamente a uma variável numérica, poderá usar os operadores de incremento ( ++ ) e decremento ( -- ) para fazer isso.

Escrita complicada:

var num = 1;
    num = num + 1;
    num = num + 1;
    console.log(num); //3

operador de incremento de prefixo:

++ é escrito na frente da variável

++num incremento de prefixo deve aumentar em 1, semelhante a num=num+1

var age = 10;
    ++idade;
    console.log(age);//11 Semelhante à fórmula de uso de age = age + 1

: adicione primeiro e depois retorne o valor

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

operador pós-incremento

++ é escrito após a variável

num++ pós-incremento, o que significa adicionar 1 a si mesmo, semelhante a num=num+1

var idade = 10;
    idade++;
    console.log(age);//11 é semelhante à

fórmula de uso age = age + 1: retorne o valor original primeiro e depois adicione

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

Resumo das diferenças

• Os operadores de pré-incremento e pós-incremento podem simplificar a escrita do código, tornando o valor de uma variável +1 mais simples do que antes.
• Quando usado sozinho, os resultados são os mesmos.
• Quando usado em conjunto com outros códigos, os resultados da execução serão diferentes.
• Preposição: adicione a si mesmo primeiro e depois execute os cálculos ( primeiro a si mesmo antes dos outros )
• Pós-posição: primeiro execute o cálculo no valor original e depois adicione a si mesmo ( primeiro um primeiro, depois a si mesmo )
• Ao desenvolver, na maioria das vezes, o incremento/decremento do postfix é usado, e o código ocupa uma linha. Exemplo: num++;

Exercício:

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 comparação

: Operador de comparação (operador relacional) é um operador usado ao comparar dois dados . Após a operação de comparação, um valor booleano (verdadeiro/falso) será retornado. operação de comparação.

console.log( 2 <= 5);
    console.log('Yue Zeyi' = 'blog pessoal');
    console.log(17 == '17'); //tipo de dados de conversão padrão verdadeiro, o tipo string é convertido para o tipo numérico console.log(17 = '17'); são obrigatórios Uso de

de operador lógico

: Operadores lógicos são usados ​​Operadores que executam operações booleanas também retornam um valor booleano. É frequentemente usado para julgar múltiplas condições no desenvolvimento posterior.

&&

AND lógico

verdadeiro

false false true true

OR lógico

verdadeiro

: || é equivalente a se

ambos os lados de ou forem false , o resultado é false , desde que um lado seja true , o resultado é true

console.log(3 > 5 && 3 > 2);
    

de negação lógica

verdadeira

: ! Em relação a not,

a negação lógica também é chamada de símbolo de negação, que é usado para obter o valor oposto de um valor booleano.

console.log(!true);
    console.log(!false); //

operação de curto-circuito verdadeira (interrupção lógica)

O princípio da operação de curto-circuito: quando há múltiplas expressões (valores), quando o valor da expressão à esquerda pode determinar o resultado, a expressão à direita não continuará mais a ser operado. O valor da fórmula.

AND lógico:

• Sintaxe :表达式1 && 表达式2
• Se a primeira expressão for avaliada como verdadeira, então retornará a expressão 2.
• Se a primeira expressão for avaliada como falsa, retornará a expressão 1

console.log(123 && 456); exceto 0 são verdadeiros.
    console.log(123 && 456 && 789); //Retorna 789, empurra de volta na sequência console.log(0 && 456); //0

lógico OR:

• sintaxe :表达式1 || 表达式2
• se o resultado da expressão 1 for

a

• expressão
• 2 será retornada.

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

Nota: A interrupção lógica causará uma operação de curto-circuito, ou seja, o código subsequente não será executado, afetando os resultados de execução do programador.

varnum = 0;
    console.log(123 || num++); //A interrupção lógica fez com que num++ não fosse executado console.log(num); //0

do operador de atribuição

: operador usado para atribuir dados às variáveis

var num = 5;
    num += 10;
    console.log(num); //5+10=15
    num *= 3;
    console.log(num); //15*3=45

operador prioridade precedência

• a não prioridade lógica no operador unário é muito alta.
• O AND lógico tem prioridade mais alta que o OR lógico

console.log(4 >= 6 || 'I' != 'you' && !(12 * 2 == 144) && true);
    /* 
    Os operadores lógicos são divididos em quatro seções 1.4 >= 6 para obter falsos
    2. 'Eu'! = 'você' deve ser verdadeiro
    3.!(12 * 2 == 144) torna-se verdadeiro
    4. verdadeiro
    Então julgue o AND lógico: 2 e 3 são verdadeiros, 3 e 4 são verdadeiros 
    Então julgue o lógico ou: verdadeiro
     */