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 erroTabela 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.