Expressões e operadores de leitura do núcleo JavaScript

Uma expressão é uma frase em JavaScript e o intérprete JavaScript calculará um resultado. Quantidades comumente usadas nos programas são o tipo mais simples de expressões que são variáveis. Nomes variáveis ​​também são uma expressão simples e seu valor é o valor atribuído à variável.

Expressões complexas são compostas de expressões simples. Por exemplo, uma expressão de acesso à matriz é composta por uma expressão que representa uma matriz, suportes quadrados e uma expressão inteira. A nova operação de expressão que eles formam é o valor do elemento em uma posição específica na matriz. Mesma letra

Uma expressão de chamada numérica consiste em uma expressão que representa um objeto de função e 0 mais de 0 expressões de parâmetros. O método mais comum de combinar expressões simples em expressões complexas são os operadores.

Este capítulo (este artigo) explicará todos os operadores JavaScript. Ele também explica expressões que não envolvem operadores (como acessar elementos da matriz e chamadas de função), e sua sintaxe e estilo de programação são muito semelhantes aos da linguagem C.

1. Expressão do elemento

A expressão mais simples é "expressão original", que é a menor unidade de uma expressão - eles não contêm outras expressões. Expressões originais em JavaScript contêm constantes ou quantidades diretas. Palavras -chave e variáveis.

Uma quantidade direta é um valor constante que aparece diretamente no programa. Eles parecem:

A cópia do código é a seguinte:

1.23 // Quantidade direta

"Hello" // Stand Direct Quantity

/ padrão/ // Expressão regular Quantidade direta

Algumas palavras reservadas em JavaScript formam a expressão original

A cópia do código é a seguinte:

True // Valor booleano: Verdadeiro

falso // falso

nulo // retorna um valor: vazio

Isso // retorna o objeto "atual"

Através do aprendizado do capítulo 3, diferentemente de outras palavras -chave, isso não é uma constante, e os valores que retorna em diferentes partes do programa também são diferentes. Essa palavra-chave geralmente aparece na programação orientada a objetos. Isso retorna o objeto do método quadrado.

Finalmente, a terceira expressão original é uma variável

A cópia do código é a seguinte:

eu // retorna o valor da variável i

soma // retorna o valor da soma

indefinido // é uma variável global, diferentemente do NULL, não é uma palavra -chave

2. Expressões de inicialização de objetos e matrizes.

A inicialização do objeto e da matriz é na verdade objetos e matrizes recém -criados. Essas expressões inicializadas às vezes são chamadas de "quantidade direta de objeto" e "quantidade direta de matriz". No entanto, diferentemente das quantidades diretas booleanas, elas não são expressões originais porque os membros ou elementos que eles contêm são subexpressões.

A sintaxe da expressão de inicialização de uma matriz é muito simples, vamos começar abaixo

A expressão de inicialização de uma matriz é composta por um par de colchetes e uma lista separada por vírgula. O resultado da inicialização é uma matriz recém -criada. Os elementos de uma matriz são valores de expressões separados por vírgula.

[] // Uma matriz vazia; [] Deixar vazio significa que a matriz não tem elementos

[1+2,3+4] // Matriz com dois elementos, o primeiro é 3, o segundo é 7

A expressão de inicialização do elemento em uma expressão de inicialização da matriz pode ser uma expressão de inicialização da matriz. Ou seja, expressões podem ser aninhadas

A cópia do código é a seguinte:

var mat = [[1,2,3], [4,5,6], [7,8,9]];

Os elementos entre as listas da matriz podem ser omitidos e o espaço será preenchido com indefinição. Por exemplo:

A cópia do código é a seguinte:

var a = [1 ,,, 5]

Quatro dos elementos são indefinidos. Uma vírgula é deixada no final da quantidade direta da matriz, e um novo elemento com um valor indefinido não será criado.

As expressões de inicialização do objeto são muito semelhantes às expressões de inicialização da matriz, exceto que os colchetes são substituídos por colchetes encaracolados. E cada expressão da palavra contém um nome de atributo e um não-coro como prefixo.

A cópia do código é a seguinte:

var p = {x: 2.1, y: -3} // um objeto com dois membros do atributo

var q = {}; // objeto vazio

qx = 2,1; qy = -3; // Os membros do atributo de Q são os mesmos que os de P

O objeto também pode ser aninhado diretamente, por exemplo

A cópia do código é a seguinte:

var anh = {esquerda: {x: 2, y: 3},

à direita: {x: 4, y: 5}}

Quando o JavaScript calcula o valor de uma expressão de inicialização do objeto, as expressões de objeto são calculadas a cada vez e não precisam incluir valores constantes: eles podem ser qualquer expressão de JavaScript. Da mesma forma, o nome da propriedade na quantidade direta do objeto pode ser uma string em vez de um identificador. (É muito útil quando apenas palavras reservadas ou alguns identificadores ilegais são usados ​​como nomes de atributos nessa linha)

A cópia do código é a seguinte:

var lado = 1;

var square = {"esquerda": {x: px, y: py},

'Right': {x: p.x+lado, y: p.y+lado}}

O capítulo 67 também discutirá as expressões de inicialização de objetos e matrizes novamente.

3. Expressões de função

A expressão da definição da função define uma função JavaScript. O valor da expressão é essa função recém -definida. Em certo sentido, as expressões de definição de função podem se tornar quantidades de função direta, e as expressões de função podem ser chamadas de "quantidades de função direta", depois que todas as expressões de inicialização do objeto também são chamadas de "quantidades diretas de objetos". Uma expressão de definição de função típica contém a função da palavra-chave, seguida por um par de parênteses, uma lista separada por vírgula e a lista contém 0 ou mais identificadores (nomes de parâmetros). Em seguida, siga o segmento de código JavaScript (corpo de função) embrulhado em aparelhos encaracolados.

var square = function (x) {return x*x};

Expressões de definição de função também podem conter o nome da função. As funções também podem ser definidas por instruções de função, em vez de expressões de função. Mais conteúdo será descrito no capítulo 8.

4. Expressão de acesso ao atributo

A operação de expressão de acesso ao atributo obtém o valor de um objeto ou um elemento de matriz. O JavaScript define dois métodos para acesso à propriedade.

A cópia do código é a seguinte:

expressão. Indentificador

expressão [expressão]

A primeira maneira é escrever uma expressão seguida por um período e um identificador. A expressão especifica o objeto e o identificador especifica o atributo mingchuan para acessar.

O capítulo 2 é escrito usando colchetes quadrados, que é uma expressão (esse método é adequado para objetos e matrizes). A segunda expressão especifica a propriedade Mingchuan a ser acessada ou o índice que representa o elemento da matriz a ser acessado. Aqui estão alguns exemplos específicos

A cópia do código é a seguinte:

ox // => 1x atributo de expressão o

oyz // => 3 z atributo da expressão oy

o. ["x"] // => 1 objeto o do atributo x

a [1] // => 4 elemento com o índice de expressão A é 1

a [2] ["1"] // => 6 elemento com índice 1 na expressão a [2]

a [0] .x // => 1: x atributo da expressão a [0]

Independentemente da forma de expressões de acesso a atributos usadas, as expressões antes "". e "[" são sempre avaliados primeiro. Se o resultado da avaliação for nulo ou indefinido, a expressão lançará uma exceção de erro de tipo, pois nenhum desses valores pode conter qualquer atributo. Se o resultado da operação não for um objeto ou uma matriz, o JavaScript o converterá em um objeto (Capítulo 3, Seção 6)

Embora o .Identifier seja escrito de maneira mais simples, deve -se notar que esse método se aplica apenas ao nome do atributo a ser acessado e é um identificador legal. E você precisa saber o nome do atributo ao acesso. Se o nome da propriedade for uma palavra reservada ou contiver espaços e marcas de pontuação e for um número (para uma matriz), os suportes quadrados devem ser gravados. Quando o nome do atributo é um valor derivado de um operador em vez de um valor fixo, os suportes quadrados devem ser gravados. (Capítulo 6, 2, 1 bar)

5. Expressão de transporte

Uma expressão de invocação no JavaScript é uma representação de sintaxe de chamar (ou executar) uma função ou método. Começa com uma expressão de função que se refere à função a ser chamada. A expressão da função é seguida por um par de parênteses, com uma lista de parâmetros separada por vírgula. Pode haver 0 parâmetros ou vários parâmetros.

f (0) // f é uma expressão de função: 0 é uma expressão de parâmetro.

Math.max (x, y, z) //math.max é uma função; x, y e z são parâmetros

a.sort () //a.sort () é uma função que não possui parâmetros.

Quando uma expressão é chamada de avaliação, calcule primeiro a expressão da função e calcule a expressão do parâmetro para obter um conjunto de valores de parâmetros. Se o valor da expressão da função não for um objeto chamável, uma exceção de erro de tipo será lançada. Os valores dos parâmetros são então atribuídos aos parâmetros formais, que são definidos ao definir a função. Em seguida, execute o corpo da função. Se a função usar a instrução RETURN para fornecer um valor de retorno, esse valor de retorno será o valor de toda a expressão de chamada. Caso contrário, o valor da expressão de chamada é indefinido. Os detalhes da chamada da função - incluindo o número de expressões formais de parâmetros e o número de parâmetros reais na definição da função - serão explicados em detalhes no Capítulo 8.

Qualquer expressão de chamada contém um par de parênteses e expressões antes dos parênteses esquerdos. Se essa expressão for uma expressão de acesso à propriedade, essa chamada será chamada de "convite do método". Ao executar um corpo de função em uma chamada de método, o objeto e a matriz que são acessados ​​como atributos são o ponteiro disso no método de chamada. Esse recurso possibilita que as funções (cujo nome OO seja "Método") chamem seu objeto host (mais no capítulo 9).

6. Expressão de criação de objetos

A expressão de criação de objetos cria um objeto e chama uma função (construtor) para inicializar as propriedades do objeto. As expressões de criação de objetos são muito semelhantes às expressões de chamada de função, exceto que existe uma palavra -chave adicional antes das expressões de criação de objetos:

novo objeto ()

Novo ponto (2,3)

Se a expressão de criação de objetos não exigir que nenhum parâmetros seja passado para o construtor, esse par de colchetes poderá ser omitido. Mais detalhes do construtor serão explicados no capítulo 9

novo objeto

novo ponto

7. Visão geral dos operadores

Os operadores do JavaScript são usados ​​para calcular expressões de tabela, expressões de comparação, expressões lógicas, expressões de atribuição etc.

Deve -se notar que a maioria dos operadores é representada por marcas de pontuação, como excluir e instanceof. Sejam operadores de palavras -chave ou operadores simbólicos, os operadores representados são operadores regulares e sua sintaxe é muito concisa.

A prioridade do operador subscrito é classificada e a prioridade do operador anterior é maior que a prioridade do operador subsequente. Os operadores separados por Huafeng horizontal têm prioridades diferentes.

A representa a natureza de ligação do operador.

L da esquerda para a direita ou r (da direita para a esquerda)

A lista do título N representa o número de operações.

Tipo representa o tipo de operando esperado e o tipo de resultado do operador (após o símbolo "→")

eu. Número de operandos

Os operadores podem ser classificados pelo número de operandos.

A maioria dos operadores em JavaScript são operadores binários que combinam duas expressões em uma expressão um pouco mais complexa.

O JavaScript também suporta alguns operadores unários que convertem uma expressão em outra expressão um pouco mais complexa. O operador " -" na expressão -x é um operador unário. É encontrar um valor negativo para x.

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

ii. Tipo de operando e tipo de resultado

Alguns operadores podem ser usados ​​para qualquer tipo de dados, mas ainda desejam que eles operem nos dados do tipo especificado.

iii.lValue

Operadores de atribuição e outros poucos operadores da tabela esperam que seu tipo LVAL do operando, o LValue é um termo antigo. Isso significa que "as expressões só podem aparecer no lado esquerdo do operador de atribuição". Em JavaScript, variáveis, propriedades de objeto e elementos de matriz são todos os Lvalues. A especificação do ECMAScript permite que uma função interna de intervalo retorne um LValue, mas as funções definidas não podem retornar um LValue.

iiii. prioridade do operador

Na tabela acima, os operadores mostrados são classificados de alta a baixa por prioridade, com um conjunto de operadores dentro de cada separador horizontal com a mesma prioridade. A prioridade do operador controla a ordem na qual os operadores são executados. Os operadores com alta (parte superior da tabela) são sempre executados mais altos que os operadores com baixa prioridade (parte inferior da tabela).

Veja a seguinte expressão

w = x+y*z;

O operador de multiplicação "*" tem uma prioridade mais alta que a adição "+", portanto a multiplicação é executada primeiro. Então, como o operador de atribuição "=" tem a menor prioridade. Portanto, a operação de atribuição é realizada após a expressão à direita calcula o resultado.

A prioridade do operador pode ser escrita usando suportes de jardim. A expressão acima pode ser escrita assim.

w = (x + y) * z;

Deve -se notar que a prioridade das expressões de acesso à propriedade e expressões de chamada é maior que a de todos os operadores da tabela.

tipo de my.função [x] (y)

Embora o TypeOF seja um dos operadores de maior prioridade, o tipoof também é executado após dois acessos de propriedade e chamadas de função.

De fato, se você realmente não tiver certeza da prioridade do operador que está usando, a maneira mais fácil é usar suportes de jardim para forçar a ordem das operações. Algumas regras importantes devem ser memorizadas: a multiplicação e a divisão são mais altas que a adição e a subtração, e a prioridade das operações de atribuição é muito baixa e geralmente são executadas por último.

iiiiiiii.operationality

Nesta seção, a coluna intitulada A ilustra a nodulenidade do operador. L refere -se à combinação da esquerda para a direita e R refere -se à combinação da direita para a esquerda. A tuberculose especifica a ordem das operações em múltiplas expressões operadoras com a mesma prioridade.

Por exemplo, a operação de subtração é realizada em uma combinação da esquerda para a direita.

A cópia do código é a seguinte:

W = x - y - z

Como este código:

A cópia do código é a seguinte:

W = ((x - y) - z)

Por outro lado, a seguinte expressão:

A cópia do código é a seguinte:

x = ~ -y;

w = x = y = z;

P = a? B: C? D: E? F: G;

Exatamente o mesmo que este código

A cópia do código é a seguinte:

x = ~ (-y);

w = (x = (y = z));

P = a? B: (C? D: (E? F: G))

Porque operadores unários, tarefas e operadores de condição ternária têm uma combinação da direita para a esquerda.

IIIIIIIIII. Ordem de operação

A prioridade e a ligação dos operadores definem sua ordem de operações na equação de atribuição, mas não especifica a ordem das operações no processo de cálculo das expressões de palavras. O JavaScript sempre calcula expressões estritamente em ordem da esquerda para a direita, por exemplo:

Na expressão w = x+y*z, a expressão w será calculada primeiro, depois x, y e z serão calculados e, em seguida, os valores de y serão multiplicados por z, adicionando o valor de x. Finalmente, a variável ou atributo mencionado por sua expressão w é referido. A adição de um suporte de círculo a uma expressão alterará a relação entre multiplicação, adição e operações de atribuição. Mas a ordem da esquerda para a direita não mudará.

8. Expressões aritméticas

Esta seção abrange esses operadores de cálculo aritmético, bem como operações aritméticas nos operandos. Os operadores de multiplicação, divisão e subtração são muito simples. A operação de adição é uma seção separada porque o operador de adição pode operar concatenação de string e sua conversão de tipo é um pouco especial.

Os operadores aritméticos básicos são *, /, %, +, -. Além de +adição, outros operadores são particularmente simples. Eles são apenas convertidos em números quando necessário e, em seguida, podem encontrar o produto, quociente, residual (módulo) e diferença. Todas as operações que não podem ser convertidas em números serão convertidas em valores de NAN. Se o operando (ou resultado de conversão) for um valor nan, o resultado da operação aritmética também é NAN

O operador "/" divide o segundo operando pelo primeiro operando, se você usou linguagens de programação que distinguem o número inteiro e o ponto flutuante. Então, quando você divide um número inteiro por um número inteiro, o resultado desejado também é um número inteiro. No JavaScript, todos os números são números de ponto flutuante e o resultado de operações de divisão também são tipos de ponto flutuante. Por exemplo, o resultado de 5/2 é 2,5, não 2. O resultado da operação com o divisor 0 é o infinito positivo ou o infinito negativo. E o resultado de 0/0 é NAN. Todas essas operações não relatarão erros.

O operador "%" calcula o módulo do primeiro operando para o segundo operando; em outras palavras, o primeiro operando é dividido pelo restante do segundo operando. O símbolo de resultado é consistente com o símbolo da primeira operação mouse (dividido). Por exemplo, o resultado de 5%2 é 1 e -5%2 é -1.

Os operandos do operador remanescente são geralmente inteiros, mas também são adequados para números de ponto flutuante. 6,5%2,1 O resultado é 0,2. (0,199999999999999999973)

eu. Operador "+"

O operador de adição binário "+" pode adicionar dois números ou operações de concatenar de string:

A cópia do código é a seguinte:

1+2 // => 3

"Olá" + "" + "lá" // => "Olá"

"1"+"2" // => "12"

Quando ambos os operandos são números ou strings, os resultados do cálculo são óbvios. No entanto, para outros casos, é necessária alguma conversão de tipo necessária. E o comportamento do operador depende do resultado da conversão do tipo. Tecnicamente falando, o comportamento do operador de adição é:

Se um operando for um objeto, o objeto seguirá a regra de conversão do objeto para o valor original do valor da classe original (consulte o Capítulo 3, Seção 8, 3). A data executa a conversão no método ToString () Object ToString (), enquanto outros objetos executam a conversão através do método ValueOf () (se o método valueof () retornar um valor primitivo). Como a maioria dos objetos não possui o método ValueOf () disponível, eles usarão o método ToString () para executar o rastreamento

Depois que o objeto para o valor original é convertido, se uma das operações for uma string, o outro operando também será convertido em uma string. Em seguida, faça concatenação de string.

Caso contrário, ambos os operando serão convertidos em números (ou NAN) e depois adicionados.

Aqui estão alguns exemplos

A cópia do código é a seguinte:

1 + 2 // => 3 Adição

"1" + "2" // => "12" conexão de string

"1" + 2 // => "12" Os números são convertidos em strings e concatenados

1 + {} // => "1 [objeto objeto]": o objeto é convertido em uma string e, em seguida, a concatenação da string é executada.

true + true // => 2 valor booleano é convertido em um número e adicionado

2 + nulo // => 2 nulo convertido para 0 e faça adição

2 + indefinido // => nan indefinido convertidos em nan para adição

Finalmente, é importante observar. Quando a operação de sinal de mais é usada de acordo com as cadeias, o efeito da adição na ordem das operações deve ser considerado. Isto é, o resultado da operação depende da ordem de operação do operador, por exemplo

A cópia do código é a seguinte:

1 + 2 + "bmice" // => "3 bmice"

1 + (2 + "bmice") => "12bmice"

ii. operador unário

O operador unário atua em um operando separado. e gerar um novo valor. No JavaScript, os operadores unários têm alta prioridade e são todos combinados com o direito. Esta seção descreve os operadores unários (+,-, ++ e-) e, quando necessário, eles convertem operações em números. Deve -se notar que + - é um operador unário e também é um operador binário.

Adição de um yuan+

O operador de adição unário converte o número do operando em um número (ou NAN) e retorna o número convertido. Se o próprio operando for um número, o número será retornado diretamente.

Subtração de um yuan-

Quando o sinal é um operador unário, ele converterá o operando em um número, conforme necessário, e alterará o símbolo do resultado da operação.

Incremento ++

Incrementar o operador "++" para incrementar (+1) o operando, e o operando é uma LValue (variável, elemento da matriz ou atributo de objeto). O operador converte operando em números. Em seguida, adicione 1 ao número e reatribua o valor após adicionar 1 à variável, elemento da matriz ou atributo de objeto.

Operação Increment ++ Retorna o valor dependente de sua posição no operando.

Quando o operador está antes do número do operando, ele é chamado de operador de "pré-incremento", que calcula incrementalmente o operando e retorna o valor calculado.

Quando o operador está atrás do operando, ele é chamado de operador de "pós-incremento". Ele realiza cálculos incrementais no operando, mas retorna o valor não conferido que é usado para cálculos incrementais. como

var i = 1, j = ++ i // os valores de i e j são 2

var i = 1, j = i ++; // eu é 2, j é 1

Deve -se notar que a soma de ++ x = x+1 é exatamente a mesma. O operador "++" nunca executa operações de concatenação de string. Ele sempre converterá o operando em um número e o aumentará em 1. Se x for a string "1", o resultado de ++ x é o número 2 e x+1 é a string "11"

As operações decrescentes e incrementadoras são as mesmas, o que converte operando em uma matriz e depois subtrai em 1.

iii. operador de bits

O operador de bits pode executar operações de bit de nível inferior em dados binários representados por números. Embora não sejam operações matemáticas puras tradicionais, eles também são classificados aqui como operadores aritméticos porque agem nas operações de tipos numéricos e números de retorno. Esses operadores não são comuns em JavaScript. (Não descrito aqui, use o Baidu para obter detalhes ~-~)

9. Expressões relacionais

Esta seção descreve os operadores de relacionamento do JavaScript. Os operadores relacionais são usados ​​para testar a relação entre dois valores (igualdade, menor de ou "atributos") e retornar verdadeiro e falso de acordo com o existe o relacionamento. As expressões relacionais sempre retornam um valor booleano e geralmente usam expressões relacionais em IF While ou para declarações (capítulo 5) para controlar o processo de execução do programa.

As próximas seções falarão sobre igualdade e operações desiguais, operadores de comparação e os outros dois personagens de relacionamento em JavaScript em e na instância

I igualdade e operadores desiguais

Os operadores "==" e "===" são usados ​​para comparar se dois valores são iguais e os dois operadores permitem que os operadores de qualquer tipo. Retorne true se for igual, caso contrário, retorne falsos. "===" também é chamado de operador estrito de igualdade (às vezes chamado de operador de identidade), que é usado para detectar se dois operandos são estritamente iguais. O operador "==" é chamado de operador de igualdade. É usado para detectar se dois operandos são iguais. A definição de igualdade aqui está solta e permite a conversão do tipo.

O JavaScript suporta os operadores "=", "==", "===", você deve entender as diferenças entre os operadores (atribuição, igualdade, identidade). E tenha cuidado ao programar. Para reduzir a confusão, "=" "deve ser chamado de" get ou atribuir "," == "" deve ser chamado de "igual" e "===" deve ser chamado de "estritamente igual".

As regras dos operadores "! =" E "! ==" são "==", o inverso do operador "===" e "!" é um não operador booleano. Chamamos "! =", "! ==" Desigual e não estritamente igual.

A comparação dos objetos JavaScript é uma comparação de referências, não uma comparação de valores. Objetos e eles mesmos são iguais, mas não são iguais às pessoas e objetos. Se dois objetos tiverem o mesmo número de atributos, os mesmos nomes e valores de atributos, eles ainda são desiguais. Os elementos da matriz na posição correspondente são iguais e duas matrizes também são desiguais.

O estrito operador de igualdade "===" calcula primeiro o valor do operando e, em seguida, compare esses dois valores. Não há conversão no processo de comparação.

Se os dois tipos de valor não quiserem ser os mesmos, eles não são iguais

Se ambos os valores forem nulos ou indefinidos, eles não são iguais

Se ambos os valores forem booleanos verdadeiros ou falsos, eles são iguais

Se um dos valores é NAN, ou ambos são nan, eles não são iguais, e a NAN e outros valores não são iguais, incluindo a si mesma.

Se dois valores são números e são iguais, eles são iguais. Se um valor for 0 e um valor for -0, eles também são iguais.

Se os dois valores forem strings e os números de 16 dígitos (consulte o Capítulo 3, 2) contidos nos bits correspondentes são exatamente iguais, eles são iguais. Se seu comprimento ou conteúdo for diferente, eles não são iguais. As duas seqüências podem ter exatamente a mesma função e os caracteres exibidos são os mesmos, mas têm valores de 16 bits que não são codificados. O JavaScript não realiza conversões padrão no Unicode, portanto, essas strings não são iguais em comparação com os operadores "===" e "==". String.localecompare () na terceira parte fornece outra maneira de comparar strings.

Se dois valores de referência apontarem para o mesmo objeto, matriz ou função, eles são iguais. Se apontar para diferentes objetos, eles são desigualdades, embora os dois objetos tenham exatamente as mesmas propriedades.

O operador da igualdade "==" é semelhante ao operador de identidade, mas o operador de igualdade não é comparado estritamente. Se os dois números não forem do mesmo tipo, o operador de igualdade tentará fazer algum tipo de conversão e depois se comparar.

Se as duas operações forem as mesmas, as regras de comparação para os operadores de igualdade acima são as mesmas. Se estritamente igual, os resultados da comparação são iguais. Se eles não forem estritamente iguais, os resultados da comparação não são iguais.

Se os dois tipos de operação forem diferentes, o operador igual "==" também os considerará iguais. A detecção de igualdade seguirá as seguintes regras e conversões de tipo:

Se um tipo for nulo e deixe o outro ser indefinido, eles são iguais

Se um valor for um número e o outro for uma string, converta a string em um número primeiro e depois use o valor convertido para comparação.

Se um valor for verdadeiro, é convertido em 1 e depois comparado. Se um valor for falso, é convertido para 0 e comparado.

Se um valor for um objeto e o outro for um número ou uma string, use as regras de conversão do método no Capítulo 3, Seção 8, 3 para converter o objeto no valor original e compará -lo. O objeto é convertido para o valor original através do método ToString () ou o método ValueOf (). As classes internas no núcleo do idioma JavaScript primeiro tentam usar o valueof () e, em seguida, tentam usar o tostring (). Além da classe de data, a classe de data só pode ser convertida através do ToString (). Os objetos que não estão no núcleo da linguagem JavaScript são convertidos em valores originais por meio de métodos definidos na implementação.

As comparações entre outros tipos não são iguais

Aqui está um pequeno exemplo de julgamento igual

"1" == Verdadeiro

O resultado dessa expressão é verdadeiro, o que indica que os resultados da comparação de tipos completamente diferentes de valores são iguais. O valor booleano é verdadeiro primeiro convertido para o número 1 e, em seguida, a comparação é realizada. Em seguida, a string "1" também é convertida para o número 1, porque os valores dos dois números são iguais, portanto o resultado é verdadeiro.

ii. Operador de comparação

Menos que (<)

Se o primeiro operando for menor que o segundo operando, o resultado da operação "<" é verdadeiro, caso contrário, é falso

Menor ou igual a (<=)

Maior que (>)

Maior ou igual a (> =)

.... (sem introdução detalhada ao significado)

Os operandos do operador de comparação podem ser de qualquer tipo. No entanto, apenas números e strings podem realmente executar operadores de comparação; portanto, aqueles operando que não são números e strings serão convertidos por tipo. As regras de conversão de tipo são as seguintes:

Se o operando for um objeto, ele será convertido para o valor original de acordo com as regras de conversão descritas na Seção 3, Seção 8, 3: Se Valueof () retornar um valor primitivo, use esse valor original diretamente. Caso contrário, use o resultado da conversão do ToString () para comparação.

Depois de se converter para o valor original, se ambos os operandos forem strings, as duas seqüências serão comparadas na ordem do alfabeto. A "ordem do alfabeto" mencionada aqui é a ordem do índice dos caracteres Unicode de 16 bits que compõem as duas cordas.

Depois que o objeto é convertido para o valor original, se pelo menos um operando não for uma string, ambos os operando compararão os valores dos números. 0 e -0 são iguais. Qualquer outro número na parede infinty é grande (exceto a própria infinção), -infinty é menor que qualquer número (exceto por si mesmo). Se um operando (ou convertido) é nan, o personagem de comparação sempre retorna falsa

Para operadores numéricos e de sequência, o comportamento do operador de sinal de mais é diferente do operador de comparação. O primeiro prefere strings e executa operações de concatenação de string se um de seus operandos for uma string. Os operadores comparativos preferem números somente quando ambos os operandos são strings de cordas. Somente então a comparação de string será realizada.

A cópia do código é a seguinte:

1 + 2 // => 3 adição, o resultado é 3

"1" + "2" // Connect String, resultado é "12"

"1" + 2 // Connect String, 2 é convertido em "2", resultado é "12"

11 <3 // a comparação de números, o resultado é verdadeiro

"11" <"3" // Comparação de suporte, o resultado é verdadeiro

"11" <3 // Comparação de números, "11" é convertida em 11, e o resultado é verdadeiro

"um" <3 // comparação de números, "um" é convertido em nan, e o resultado é falso

Finalmente, deve -se notar que, ao julgar a igualdade, os operadores "<=" e "> =" não confiam no operador da igualdade e nas regras estritas de comparação de operação de igualdade. Pelo contrário, o operador Zhi, que é menor ou igual a simplesmente "não é maior que", enquanto a operação maior ou igual a "não é apenas" não menor que ". Com apenas uma exceção, quando o operando (após convertido) é NAN, todos os 4 operadores de comparação retornarão Fasle.

iii.in Operador

O operador In deseja que seu operando esquerdo seja uma string ou possa ser convertido em uma string e espera que seja um objeto para a direita. Se o objeto à direita tiver um nome de atributo chamado valor do operando esquerdo, a expressão retornará true. Por exemplo

A cópia do código é a seguinte:

var point = {

x: 1,

y: 1

} // Defina um objeto

"X" no ponto // => true O objeto tem uma propriedade chamada x

"Z" no ponto // => false, o objeto não tem o nome do atributo z

"ToString" no ponto // => objeto true herda o método da tostragem

Dados var = [7, 8, 8]

"0" em dados // => true a matriz contém 0

1 em dados // => Número de conversão true para string

3 em dados // => fase nenhum elemento com índice de 3

iiii.instanceOf Operator

A instância do operador deseja que o operador esquerdo seja um objeto e o operando correto indica a classe do objeto. Se o objeto à esquerda for uma instância da classe à direita, a expressão retornará true; É responsável por retornar falsa. O capítulo 9 falará sobre isso. As classes de objetos JavaScript são definidas pela inicialização de seus construtores. Dessa forma, o operando correto da instância deve ser uma função. por exemplo:

A cópia do código é a seguinte:

var d = new Date (); // Construa um novo objeto

D Instância de data; // O resultado do cálculo é verdadeiro, D é criado por Date ()

d instanceof Object //计算结果为true ,所有的对象都是Object的实例

d instanceof Number //计算结果为false，d不是一个Number对象

var a = [1,2,3] //数组直接量创建数组

a instanceof Array //计算结果true a为数组

a instanceof Object //true 所有的数组都是对象

a instanceof RegExp //fasle 数组不是正则表达式

需要注意的是，所有对象都是Object的实例。当通过instanceof盘对一个对象是否为一个类的实例的时候，这个判断也叫“父类”(superclass)的检测，如果instanceof的左侧操作对象不是对象的话，instanceof返回false。如果右侧操作不是函数，则抛出类型错误的异常。

为了理解instanceof运算符是如何工作的，必须首先理解“原型类”（prototype chain），原型链作为javascript的继承机制，将在6章2节2小节详细描述。

为了计算表达式o instanceof f ,javascript笔仙首先计算f.prototyoe,然后在原型链中查询o,如果找到，那么o是f（或者f的父类）的一个实例，那么返回true。反之false

10.逻辑表达式

逻辑运算符"&&"、“||”、“!”是对操作进行布尔算术运算，经常和关系运算符一起配合使用，逻辑运算符将多个关系表达式组合起来组成一个更复杂的表达式。

eu. Logic and

"&&"运算符可以从三个不同的层次进行理解。最简单一层理解是，当操作数都是布尔值是，“&&”对两个布尔值执行布尔与（AND）操作，只有在第一个操作数和第二个操作数都是true的时候，它才返回true.如果其中有一个操作数为false.则它返回false.

"&&"长用来连接两个关系表达式

x == 0 && y == 0; //只有在x和y都是0时，才返回true

关系表达式总是返回true或false,因此当这样使用的时候，“&&”本身也返回true或false。关系运算符的优先级要比"&&"（和“||”）要高，因此类似这种表达式可以放心地书写，而不用补充园括号。

"&&"操作数并不一定是布尔值，回想一下，有些值是可以当做“真值”和“假值”的。（如3章3节，假值是:false null undefined 0 -0 NaN和""，所有和其它的值包括所有的对象都是真值）。对“&&”第二层理解是，“&&”是可以对真值和假值进行布尔与（AND）操作。如果两个操作数都是真值的，则那么返回一个真值；否则，至少一个操作数是假值的。javascript中在任何使用布尔值的地方的时候，表达式语句都会将其当做真值或假值来对待，因此实际上“&&”并不总是返回true和false.但也并无大碍。

需要注意的是，上文提到了运算符返回“真值”和“假值”，但并没说说明这个“真值”或者“假值”到底是什么值，为此我们深入讨论对“&&”第三层的理解。运算符首先计算左操作数的值，即首先计算“&&”左侧的表达式，如果计算结果是假值，那么整个表达式的结果一定是假值，因此“&&”这时简单的返回左操作的值，而并不会对右边的操作数进行计算。

A cópia do código é a seguinte:

var o = {

x: 1

};

var p = null;

o && ox; //=>1 : 1:0是真值，因此返回值是ox

p && px //= null :p是假值，因此将其返回，而并不计算px

这对于理解“&&”可能不计算右操作数的情况至关重要，在上述代码中，变量P的值是null，而如果计算px的话则会抛出一个异常错误，因此，只有p为真值（不能是null或undefined）的情况下才计算px

"&&"的行为有时候被称为“短路”（short circuiting）,我们经常能看到很多代码利用了这一也行来有条件的执行代码。例如下面的两条代码是等价的

A cópia do código é a seguinte:

if (a == b) stop(); //只有a==b时才能调运stop()

(a == b) && stop(); //同上

一般来讲，当“&&”右侧的表达式具有副作用的时候（赋值，递增，递减和函数调用表达式）要格外小心。因为这些带有副作用的表达式的执行时候，依赖于左操作鼠的计算结果。

尽管“&&”可以按照第二层和第三层的理解进行一些复杂的表达式运算，但大多数的情况下，“&&”仅用来对真值和假值的做布尔计算。

ii. Logical or (||)

"||"运算符对两个操作数做布尔或（OR）运算。如果其中一个为真值，则返回真值，两个操作数都为假值，返回假值。

尽管“||”运算符大多情况下只是做简单的布尔或（OR）运算，和“&&”一样，也具备一些更复杂的行为，它首先计算第一个操作数的值，也就是说回首先计算左侧的表达式，如果计算结果为真，则返回真值，否则，再计算第二个值。

和“&&”一样，用于应该避免右操作数包含一些具有副作用的表达式，除非你目地明确在右侧使用带副作用的表达式，而有可能不会计算右侧的表达式。

这个运算符最常用的方式是用来从一组备选的表达中选取第一个真值的表达式。

A cópia do código é a seguinte:

//如果max_width已经定义了，则直接使用它。赋值在preferences对象中查找max_width

//如果没有定义它，则使用一个写死的常量。

var max =max_width || preferences.max_windth || 500;

这种贯用法通常在函数体内，用来给参数提供默认值。

A cópia do código é a seguinte:

//将o成功的属性复制到p中，并返回p

function copy(o, p) {

p = p || {}; //如果向参数p没有传入任何对象，则使用一个新创建对象。

//函数体内的主逻辑

iii.逻辑非(!)

O "!" operator is a unary operator that is placed before a separate operand. Its purpose is to invert the boolean value of the operand.

Unlike the "&&" and "||" operators, the "!" operator first converts its operands into a Boolean value (see the Rules in Chapter 3), and then inverses the Boolean value. Aquilo é, "!" always returns true and false. Furthermore, the Boolean value of a value can be obtained by using two logical non-operations: (!!x, refer to Section 8, Section 2, Chapter 3)

"!" has a high priority and is closely tied to the operand. If you want to use p && q, you need to bracket! (p && q). The following code:

A cópia do código é a seguinte:

!(p && q) === !p || !q

!(p || q) === !p && !q

对于p和q取任何值，这两个表达式永远成立。

11.赋值表达式

javascript使用"="运算符给变量或者属性来赋值，例如：

A cópia do código é a seguinte:

i = 0 //将变量i设置为0

ox = 1 //将对象o的属性x 设置为1

“=”运算符希望它的左操作数为一个左值：一个变量或者对象属性（或数组元素），它的右操作鼠可以是任意的类型的任意值。赋值表达式的值就是右操作数的值。赋值表达式的副作用是，右操作数的值赋值给左侧的变量或对象属性。这样的话，后续对这个变量和对象的属性的引用都将得到这个值。

尽管赋值表达式的值非常简单，但有时候会看到一些复杂表达式包含赋值表达式的情况。例如：将赋值和检测操作放在一个表达式中：

A cópia do código é a seguinte:

(a = b) == 0

如果这样的话，应该清楚地知道"="和"=="区别！，需要注意的是，“=”有非常低的优先级，通常在一个较长的表达式中用到一条赋值语句时，需要补充园括号以保障正确的运算顺序。

赋值操作符的结合性是从右至左，也就是说，一个表达式中出现了多个赋值运算符，运算顺序也从右至左，因此，可以通过以下方式对多个变量赋值。

A cópia do código é a seguinte:

i=j=k=0; //把三个变量初始化为0

带操作的赋值运算：

除了常规的赋值运算外，javascript还支持需要其他的赋值运算符，这些运算符将赋值运算符合其他的运算符连接起来。提供一种更为快捷的运算方式。例如+=运算符执行的是加法运算符和赋值操作，下面的表达式：

total += salaes_tax;

和下面的表达式等价的

total = total + salaes_tax

运算符“+=”可以作用于数字或字符串，如果其操作是数字，它将执行加法运算和赋值操作；如果是字符串，他就执行字符串的连接和赋值操作。

此类型的运算符还包括，"-=","*=","&="等，如下表赋值运算符

运算符示例等价于

+=a+=ba=a+b

-=a-=ba=ab

*=a*=ba=a*b

/=a/=ba=a/b

%=a%=ba=a%b

<<=a<<=ba=a<<b

>>=a>>=ba=a>>b

>>>=a>>>=ba=a>>>b

&=a&=ba=a&b

|=a|=ba=a|b

^=a^=ba=a^b

大多数情况下，表达式为

a op =b

这里的op代表一个运算符，这个表达式等价于

a =a op b

在第一行中，表达式a计算了一次，在第二行中，表达式a计算了两次。

只有a包含具有副作用的表达式（比如函数调用和赋值操作）的时候，两者才不等价。如下两个表达式不等价

A cópia do código é a seguinte:

data[i++] *= 2;

data[i++] = data[i++] * 2

12.表达式计算

和很多解释性语言一样，javascript同样可以解释运行由javascript源代码组成的字符串，并产生一个值。javascript通过全局函数eval()来完成这个工作。

eval("3+2") //=>5

动态判断源代码中的字符串是一种强大语言的特性，几乎没有必要在实际中应用。如果你使用了eval()，你应该仔细考虑真的需要它。

下面降价eval()基础用法，并介绍两种严格使用它的方法，从代码优化的角度来讲，这两种方法对原有的代码影响是最小的。

i.eval （eval()是一个函数，但由于它已经被当做运算符来对待了。）

eval()只有一个参数，如果传入的参数不是字符串，它直接返回这个参数。如果参数是字符串，它会把字符串当成javascript进行编译(parse)，如果编译失败则抛出一个语法错误(SyntaxError)。如果编译成功，则开始执行这段代码，并返回字符串中最后一个表达式或语句的值，如果最后一个表达式没有语句或者值，则最终返回undefined。如果字符串抛出一个异常，这个异常把该调用的传给eval()

关于eveal()最重要的是，它使用了调用它的变量作用域环境，也就是说，它查找变量的值和定义新变量和函数的操作和局部的代码作用域中的代码一样。如果一个函数定义了一个局部变量x,然后调用了eval("x"),它会返回局部变量的值。如果它调用eval("x=1"),它会改变局部变量的值。如果函数调用了eval("var y=3;")它声明一个新的局部变量y。同样的，一个函数可以通过如下代码声明一个局部函数：

eval("function f(){return x+1;}");

如果最顶层的代码中调用了eval()。当然它会作用于全局变量和全局函数。

ii. Global eval()

eval()具有改变局部变量的能力，这对javascript优化器来说，是一个很大的问题，然而作为一种权宜之计，javascript征对那行调用了eval()函数所做的优化并不多。但当脚本定义了一个别名，并且用令一个名称来调用它，javascript解释器又如何工作呢，为了javascript解释器更加简化。ECMAScipt3标准规定了任何解释器都不允许对eval()赋予别名。如果eval()使用别的别名来调用的话，则会抛出EvalError异常。

实际上，大多数的实现并不是这样做的。当通过别名调用时，eval()会将其字符串当成顶层的全局代码来执行。执行代码可能会定义新的全局变量和全局函数。执行的代码可能会定义新的全局变量和全局函数，或者给全局变量赋值。但却不能修改或修改主调函数中的局部变量，因此这不会影响到函数内的代码优化。

ECMAScript5是反对使用EvalError的，并且规范了eval()的行为。“直接的eval”，当直接使用非限定的“eval”名称，来调用eval()函数时，它总共是在它的上下文作用域内支线。其它间接调用则使用全局函数为其上下文作用域。并且无法读、写、定义局部变量和函数。下面有一段代码实例：

A cópia do código é a seguinte:

var geval = eval; //使用别名调用eval将是全局eval

var x = "global",

y = "global"; //两个全局变量

function f() { //函数内执行的局部eval

var x = "local" //定于局部变量

eval("x += 'changed';"); //直接eval更改了局部变量的

retornar x; //Return the changed local variable

}

function g() { //这个函数执行了全局eval

var y = "local" //定义了局部变量

geval("y += 'changed';"); //间接改变了局部变量的值

return y; //返回未更改的局部变量

}

console.log(f(), x); //更改了局部变量，输出local changed global

console.log(g(), y); //更改了全局变量，输出local globalchanged

13.其它运算符。

javascript支持很多其它各种各样的运算符。

eu. Conditional operator (?:)

The conditional operator is the only ternary operator in javascript. Usually this operator is written as "?:". This operator has the third operand, the first operand is before "?", and the second operand is between "?" e ":". The third operand is long after ":", e.g.

x > 0 ? x : -x; //求x的绝对值

条件运算符的操作数可以是任意类型。第一个操作数当成布尔值，如果它是真值，那么将计算第二个操作数，并返回计算结果。赋值如果第一个值操作数是假值，那么将计算第三个操作数。并返回计算结果。第二个和第三个操作数总会计算其中之一。不可能两者同时进行。其实使用if语句也达到同样的效果(5.4.1),“?:”运算符只是提供了一种简写形式。这里是一个"?:"的典型使用场景，判断一个变量是否有定义，如果有定义则使用它，如果无定义，则使用一个默认值。

A cópia do código é a seguinte:

grett = "hello" + (username ? username : "three");

和以下的代码是等价的，但上面的更加简洁

A cópia do código é a seguinte:

grett = "hello";

if (username)

grett += username;

outro

grett + "three"

ii.typeof()运算符

typeof是一元运算符，放在单个操作数前面，操作数可以是任何类型，返回值表示操作类型的一个字符串。

A cópia do código é a seguinte:

x __ typeof x

undefined __ "undefined"

null __ "object"

ture或false __"boolean"

任意数字或NaN __ "Number"

任意字符串__ "String"

任意函数__ "function"

任意内容对象（非函数）__ "object"

任意宿主对象__ 由编译器各自实现的字符串，但不是"undefined" "boolean" "number" "string"

typeof最常用的用法写在表达式中们就像这样

(typeof value == "string") ? "" + value + "":value;

typeof运算符同样在swith语句中（5.4.3）非常有用，需要注意的是，typeof运算可以带上园括号。这样让typeof看起来像一个函数名，而非关键字

typeof(i)

iii.delete运算符

delete是一元操作符，它用来删除对象的属性或者数组的元素。就像赋值、递增、递减运算符一样。delete也是具有副作用的。它是用来做删除操作的。不是用来返回一个值的。

A cópia do código é a seguinte:

var o = {

x: 1,

y: 2

}

delete ox;

"x" in o; //=>false

var a = [1, 2, 3];

delete a[2]; // 删除数组中最后一个元素

2 in a; //=> false 元素2已经在数组中不存在了

a.length; //=>3,注意，数组长度并没有改变，尽管上一行删除了这个元素，但删除操作留下了一个洞。实际上并没有修改数组的长度，因此a的长度仍然为3

需要注意的是，删除属性或删除数组元素不仅仅设置了一个undefined值，当删除一个属性时，这个属性不复存在。读取一个不存在的值将会返回undefined.关于delete删除还有严格模式下的一些情况，需要学习的人自己试验，这里给一些例子。

A cópia do código é a seguinte:

var o = {x: 1,y: 2};

delete ox; //删除一个对象属性，返回true

typeof ox; //属性不存在，返回"undefined"

delete ox; //删除不存在的属性，返回true;

delete o; //不能删除通过var关键字声明的变量，返回false

delete 1; //参数不是一个左值。

this.x = 1;// 给全局定义一个属性，这里没有使用var

delete x ; //试图删除它，在非严格模式下返回true

//在严格模式下回抛出异常，这时使用"delete this.x"来代替

x; // An error occurred during runtime, no x is defined

6章第三节还有关于delete的讨论。

iii.void运算符。

void是一元运算符，在出现操作数之前，操作数可以是任何类型。这个运算符并不是经常使用：操作数会照常计算，但会忽略计算结果并返回undefined。由于void会忽略操作数的值，因此在操作数具有副作用时使用void来程序更有意义。

这个最常用的带客户端url.在url写带有副作用的表达式，而void则让浏览器不显示在这个表达式的运算结果。

A cópia do código é a seguinte:

<a href="javascript:void window.open();">new</a>

iiii.逗号运算符。(,)

逗号运算符是二元运算符，它的操作数可以是任意类型。它首先计算左操作数，然后计算右操作数。

A cópia do código é a seguinte:

i = 0, j = 1, k = 2;

它和下面的代码基本上等价的

i = 0; j = 1; k = 2;

总是会计算左侧的表达式，但计算结果忽略掉，也就是说，只有左侧表达式具有副作用，才会使用逗号运算让代码变得更通畅。逗号运算符最常用的场景是for循环中，这个for循环通常有多个循环变量。

A cópia do código é a seguinte:

//for循环中的第一个逗号是var语句的一部分

//第二个逗号是逗号运算符

//它将两个表达式(i++和j++)放在一条(for循环中)语句中

for (var i = 0, j = 10; i < j; i++, j--);

console.log(i + j);