Uma visão abrangente da sintaxe do operador JavaScript

As palavras anteriores

A maioria dos operadores do JavaScript é representada por marcas de pontuação e alguns são representados por palavras -chave. A sintaxe deles é concisa, mas o número deles é bastante grande. Os operadores sempre seguem uma sintaxe fixa. Somente pela compreensão e domina que esses conteúdos podem ser usados ​​corretamente. Este artigo apresentará principalmente a visão geral da sintaxe dos operadores JavaScript

Número de operandos

Existem 46 operadores em JavaScript. Se você os classificar de acordo com o número de operandos, a maioria deles são operadores binários. Seus operandos são dois e combinam as duas expressões em expressões complexas.

 1 + 2; verdadeiro || falso;

O operador unário em JavaScript converte uma expressão em outra expressão ligeiramente complexa, incluindo principalmente os seguintes 9:

 ++ - - + ~! excluir tipo de voida ++; tipoof true;

JavaScript tem apenas um operador ternário, que é um operador de julgamento condicional?:, Que combina três expressões em uma expressão

 2> 1? 2: 1;

Prioridade

O operador controla a ordem de execução dos operadores e a execução de operadores com alta prioridade sempre precede os operadores com operadores de baixa prioridade.

Os 46 operadores são divididos em 14 níveis de prioridade, da alta a baixa:

 ++ - - + ~! Exclua o tipo de void * / % + - << >> >>> <<=>> = instanceof in ==! = ===! == & ^ | && ||?: = * = / = % = + = - = & = ^ = | = << = >> = >>> =,,

A partir desses níveis de prioridade do operador de 14 níveis, podemos ver:

Operador unário> Operador aritmético> Operador de comparação> Operador lógico> Operador tripartido> Operador de atribuição> Operador de vírgula

[Nota] O operador de inversão lógica pertence ao operador unário e tem a maior prioridade

exemplo

 ! 2 <1 && 4*3+1;

A situação acima é mais complicada, decompõe gradualmente a ordem de operação

Primeiro calcule o operador unário!,! 2; // false

 // então a expressão se torna falsa <1 && 4*3 + 1;

Calcule o operador aritmético 4*3+1; // 13

 // então a expressão se torna falsa <1 && 13;

Calcule o operador de comparação <, falso <1; // true

 // então a expressão se torna: true && 13; // 13

Parênteses podem ser usados ​​para especificar com força a ordem das operações

 2+3*5; // 17 (2+3)*5; // 25;

Ligação

Os operadores têm dois tipos de propriedades de ligação, um está vinculado da esquerda para a direita, com a marca L, e a outra está ligada da direita para a esquerda, com a Mark R. A ligação especifica a ordem das operações em múltiplas expressões de operador com a mesma prioridade.

A maioria dos operadores tem uma combinação da esquerda para a direita, apenas operadores unários, operadores condicionais e operadores de atribuição têm uma combinação da direita para a esquerda.

 w = x + y + z; // equivalente a: w = ((x + y) + z);

 w = x = y = z; // equivalente a: w = (x = (y = z));

 Q = A? B: C? D: E? f: g; // equivalente a: q = a? B: (C? D: (E? F: G));

A prioridade e a ligação dos operadores determinam sua ordem de operações em expressões complexas, mas quando as subexpressões têm influência mútua, a ordem mudará.

exemplo

 a = 1; b = a +++a-- * a ++;

Primeiro analise a expressão e, de acordo com a ordem de prioridade, o operador de incremento, o operador de multiplicação, o operador de adição e o operador de atribuição são respectivamente calculados.

Primeiro calcule o primeiro a ++; // o resultado é 1, a é 2

 // A expressão se torna b = 1+a-- * a ++;

Calcular a-; // o resultado é 2, a é 1

 // A expressão se torna b = 1+2 * a ++;

Calcule o segundo a ++; // o resultado é 1, a é 2

 // A expressão se torna b = 1 + 2 * 1;

Então, finalmente a = 2; b = 3;

 a = 1; b = a +++a-- * a ++; console.log (a, b); // 2 3

 // Da mesma forma a = 1; b = a-- * a +++a ++; console.log (a, b); // 2,1

tipo

Alguns operadores podem atuar em qualquer tipo de dados, mas ainda desejam que seus operandos sejam dados do tipo especificado, e a maioria dos operadores retorna um valor de um tipo específico. Na tabela de regra do operador abaixo, a seta é o tipo de operando do operador e a seta é o tipo de resultado da operação após a seta ser o tipo do resultado da operação.

【LValue】

LValue é um termo antigo que significa que as expressões só podem aparecer no lado esquerdo do operador.

Em JavaScript, variáveis, propriedades de objeto e elementos de matriz são todos lvalues

O tipo de operando do operador de incremento ++, diminuição do operador- e operadores de atribuição são lvalue

 var a = 3; a ++; // 33-; // Relate um erro ({}). a+= '1'; // 'undefined1''test'-= 'teste'; // Relate um erro

Tabela de regra do operador

 Tipo de operação do operador ++ incremento lVal-> num-decremento lVal-> num- Número inverso-> num+ converta em número num-> num ~ Inverso Int-> int! Lógico não-bool-> booldElete Excluir atributo lval-> booltypeof detecção tipo qualquer-> strvoid Retorno indefinido num-> num ***************************************** turno certo Int, int-> int ********************************************************* str, obj-> bool *********************************************** any-> bool ***************************************** int-> int ******************************************* Lógica ou qualquer um, qualquer um ******************************************************* BOOL, qualquer um, qualquer-> qualquer ********************************************* ********************* ********************* ********************* ********************* ********************* ********************* *****************

A visão geral abrangente acima da gramática dos operadores JavaScript é todo o conteúdo que compartilho com você. Espero que você possa lhe dar uma referência e espero que você possa apoiar mais o wulin.com.