Frases de leitura do núcleo JavaScript

No JavaScript, expressões são frases e declarações são a frase ou comando inteiro. Assim como uma declaração em inglês termina com um período, o JavaScript termina com um semicolon.

A expressão calcula um valor, mas a afirmação faz algo acontecer.

Uma maneira de "fazer algo acontecer" é calcular expressões com efeitos colaterais. Expressões com efeitos colaterais, como atribuições e chamadas de função, podem ser usadas como instruções separadas. Esse uso de expressões como declarações também é chamado de declarações de expressão. Declarações semelhantes incluem declarações de declaração, que são usadas para declarar novas variáveis ​​ou definir novas funções.

Um programa JavaScript é uma coleção de uma série de instruções executáveis. Por padrão, o intérprete JavaScript é executado em sequência em ordem de redação. Outra maneira de "fazer algo acontecer" é alterar a ordem de execução padrão da declaração:

1. Declaração condicional: O intérprete JavaScript pode determinar se deve executar ou pular essas instruções, como se e alternar instruções.

2. Declaração de loop: declarações que podem ser executadas repetidamente, como enquanto e para declarações

3. Declaração de salto: você pode deixar o intérprete saltar para outras partes do programa para continuar a execução, como declarações de quebra, retorno e arremesso

Em seguida, este artigo introduzirá várias declarações e sua sintaxe no JavaScript. Este capítulo resume essas frases no final. Um programa JavaScript nada mais é do que uma coleção de declarações separadas por separação; portanto, depois de dominar as instruções JavaScript, você pode escrever um programa JavaScript.

1. Declaração de expressão

As declarações de atribuição são uma declaração de expressão relativamente importante. Sua função é alterar o valor de uma variável, assim como a execução de uma declaração de atribuição: por exemplo

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

Greet = "Hello" + Name;

i *= 3;

O operador de incremento (++) e o operador decrescente (-) estão relacionados à declaração de atribuição. Sua função é alterar o valor de uma variável, assim como a execução de uma instrução de atribuição.

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

contador ++;

A função importante do operador de exclusão é excluir as propriedades de um objeto (ou elementos de uma matriz) e tudo o que geralmente é usado como declarações, não como parte de uma expressão complexa.

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

excluir boi;

As chamadas de função são outra categoria importante de declarações de expressão, por exemplo

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

alerta (saudação);

window.close ();

Embora essas funções do cliente sejam expressões, elas têm um certo impacto no navegador da web. Portanto, achamos que também é uma declaração, e não faz sentido chamar uma função sem efeitos colaterais, a menos que faça parte de uma declaração complexa de expressão ou atribuição, por exemplo. É impossível descartar um valor cosseno aleatoriamente;

Math.cos (x);

Em vez disso, para obter o valor cosseno, você deve atribuí -lo a uma variável para que esse valor possa ser usado no futuro:

var cx = math.cos (x);

Novamente, cada linha de código termina com um semicolon.

2. Declarações compostas e declarações vazias

Várias expressões podem ser concatenadas juntamente com um operador de vírgula para formar uma expressão. Da mesma forma, o JavaScript também pode dizer que várias declarações são unidas para formar uma instrução composta. Basta envolver várias declarações em aparelhos encaracolados. Portanto, as seguintes linhas de código podem ser usadas como uma instrução separada em qualquer lugar do JavaScript que você deseja usar uma instrução.

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

{

x = math.pi;

cx = math.cos (x);

console.log ("cos (π) =" + cx);

}

Existem vários pontos a serem observados sobre os blocos de declaração: Primeiro, os blocos de declaração não exigem semicolons. As instruções de elemento em blocos devem terminar com os semicolons, mas os blocos de declaração não.

Segundo, as linhas no bloco de declaração são recuadas, o que não é necessário, mas o recuo puro pode tornar o código mais legível e mais fácil de entender.

Terceiro, o JavaScript não possui escopo no nível do bloco, e as variáveis ​​declaradas no bloco de declaração não são de propriedade privada do bloco de declaração. (Consulte a primeira seção do capítulo 3, 10)

A prática de combinar muitas declarações em um grande bloco de declaração é muito comum na programação de JavaScript. Expressões semelhantes geralmente contêm subexpressões, muitos javascrescts contêm outras subestimações. Em termos de formulário, o JavaScript geralmente permite que um bloco de declaração contenha uma substituição. Por exemplo: o corpo do loop while pode conter apenas uma declaração. Usando um bloco de instrução, você pode colocar qualquer número de instruções nesse bloco e esse bloco de declaração pode ser usado como uma instrução.

No JavaScript, quando você deseja que várias instruções sejam usadas como uma declaração, use uma instrução em conformidade. Uma instrução vazia (declaração vazia) é exatamente o oposto, permite conter 0 declarações. A declaração vazia é assim:

;//ponto e vírgula

O intérprete JavaScript obviamente não executa nenhuma ação ao executar uma declaração vazia, mas a prática provou que declarações vazias às vezes são úteis ao criar um loop com um corpo de loop vazio, como o seguinte para loop

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

// inicialize uma matriz a

for (i = 0; i <A.Length; a [i ++] = 0);

Nesse loop, todas as operações são concluídas na expressão a [i ++] = 0, e nenhum corpo de loop é necessário aqui. No entanto, o JavaScript exige que o corpo do loop contenha pelo menos uma declaração; portanto, apenas um semicolon separado é usado aqui para representar uma declaração vazia.

Observe que os semicolons no lado direito do loop for, enquanto o loop ou se a declaração são discretos, o que pode causar alguns bugs fatais, difíceis de localizar. Por exemplo, o resultado da execução do código a seguir provavelmente será um efeito que o autor não deseja:

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

if ((a == 0) || (b == 0)); // Esta linha de código não faz nada ...

o = nulo; // Esta linha de código sempre será executada

Se você usar uma instrução vazia para fins especiais, é melhor adicionar comentários no código, o que pode indicar claramente que essa instrução vazia é útil.

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

for (i = 0; i <a.Length; a [i ++] = 0) /*vazio* /;

3. Declaração de declaração

VAR e função são declarações de declaração que declaram ou definem variáveis ​​ou funções. Essas instruções definem e atribuem identificadores (nomes de variáveis ​​e nomes de funções) a eles, que podem ser usados ​​em qualquer lugar do programa. As declarações de declaração não fazem nada sozinho, mas tem um significado importante: criando variáveis ​​e funções, a semântica do código pode ser melhor organizada.

As seções a seguir falarão sobre declarações e instruções VAR, mas não contêm todo o conteúdo de variáveis ​​e funções.

I.Var

A instrução VAR é usada para declarar uma ou mais variáveis. Sua sintaxe é a seguinte:

var name_1 [= value_1] [, ..., name_n [= value_n]]

A palavra -chave VAR é seguida por uma lista de variáveis ​​a serem declaradas. Cada variável na lista pode ter uma expressão de inicialização que pode ser usada para especificar seu valor inicial. Por exemplo:

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

var i; // Uma variável simples

var j = 0; // Uma variável com valor inicial

var p, q; // duas variáveis

var greet = "hello" + nome; // expressão de inicialização mais complexa

var x = 2,34, y = math.cos (0,75), r, teta; // muitas variáveis

var x = 2, y = x * x; // a segunda variável usa a primeira variável

var x = 2,

f = function (x) {return x * x}, // Cada variável possui uma linha exclusiva

y = f (x)

Se a instrução VAR aparecer no corpo da função, ela define uma variável local e seu escopo é essa função. Se você usar uma instrução VAR no código de nível superior, ela declara uma variável global, que é visível em todo o JavaScript. No capítulo 3, seção 10, é mencionado que as variáveis ​​globais são propriedades dos objetos globais. Então, diferentemente de outras propriedades globais de objetos, as variáveis ​​declaradas pelo VAR não podem ser excluídas por meio de exclusão.

Se a variável na instrução VAR não especificar uma expressão de inicialização, o valor dessa variável será inicialmente indefinido. Portanto, o valor da variável antes da declaração de declaração é indefinida.

Deve -se notar que a instrução VAR também pode ser usada como um componente do loop for ou for/in loop. (O mesmo que as declarações variáveis ​​declaradas antes dos loops, as variáveis ​​declaradas aqui também serão "avançadas"), por exemplo:

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

for (var i = 0; i <10; i ++) console.log (i);

for (var i = 0, j = 10; i <10; i ++, j--) console.log (i * j);

para (var i em o) console.log (i);

Observe que não importa se você declarar a mesma variável várias vezes.

II.FUNCIONAL

A função de palavra -chave é usada para declarar funções. Aprendemos expressões de função (4.3). As definições de função podem ser gravadas em uma forma de declaração. Por exemplo: duas definições são escritas no código de exemplo seguinte:

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

var f = função f (x) {return x + 1;} // atribui a expressão a uma variável

função f (x) {return x + 1;} // frase contendo nomes de variáveis

A sintaxe da declaração da função é a seguinte:

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

function funcname ([arg1 [, arg2 [..., argn]]]) {

declarações

}

funcname é o identificador de nome da função a ser declarado. O nome da função é seguido pela lista de parâmetros, separados por vírgulas. Ao chamar uma função, esses identificadores se referem aos parâmetros reais passados ​​para a função.

O corpo da função é composto por declarações de JavaScript, sem limite para o número de declarações e é fechado em aparelhos encaracolados. Ao definir uma função, as instruções no corpo da função não são executadas, mas estão associadas ao novo objeto de função a ser executado ao chamar a função. Observe que os aparelhos encaracolados nas instruções da função são necessários, o que é diferente dos blocos de instrução usados ​​por loops e outros bloqueios de instrução. Mesmo que o corpo da função tenha apenas uma declaração, ainda são necessários aparelhos encaracolados para embrulhá -la.

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

função hyteus (x, y) {

retornar math.sqrt (x * x + y * y);

}

Hyteus (1, 2) //=>2.23606797749979

função facial (n) {// uma função recursiva

if (n <= 1) retornar 1;

retornar n * facial (n - 1);

}

Facial (11) // => 39916800

As declarações de função geralmente aparecem na parte superior do código JavaScript e também podem ser aninhadas em outras funções. Mas, quando aninhados, as declarações de função só podem aparecer no topo da função aninhada. Ou seja: a definição da função não pode aparecer se, enquanto ou outras instruções.

Como a instrução VAR, as variáveis ​​criadas por declarações de declaração de função não podem ser excluídas. No entanto, essas variáveis ​​não são somente leitura e os valores variáveis ​​podem ser reescritos.

4. Declarações condicionais

Uma declaração condicional é executar ou pular certas declarações, determinando se o valor da expressão especificado deve ser avaliado. Essas declarações são "pontos de decisão" do código, às vezes chamados de "ramificações". Se o intérprete JavaScript for executado seguindo o "caminho" do código. A declaração condicional é o ponto do garfo nesse caminho. Quando o programa atingir esse ponto, você deve selecionar um caminho para continuar a execução.

I. Se a declaração

Se a instrução for uma declaração de controle básico. Para ser preciso, permite que o programa seja executado condicionalmente. Existem duas formas desta afirmação: a primeira é

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

se (expressão)

declaração

Nesse formulário, se o valor da expressão for verdadeiro, execute a instrução Declaração e, se for falsa, não execute a instrução. Por exemplo,

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

se (nome de usuário == null) // se o nome de usuário for nulo ou indefinido

nome de usuário = "Jack Wong"; // Defina

Deve -se notar que é necessário envolver os suportes do jardim da expressão se declaração.

A sintaxe JavaScript estipula que, se as palavras -chave e expressões com suportes de jardim deverão ser seguidas por uma declaração. No entanto, várias instruções podem ser combinadas em uma usando blocos de instrução. Portanto, a forma da declaração IF se parece com a seguinte:

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

if (! endereço) {

endereço = "";

mensagem = "Por favor, enviando endereço"

}

A segunda forma da instrução IF introduz a cláusula else e executa a lógica de else quando o valor da expressão é falso.

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

se (expressão)

Declaração1

outro

Declaração2

Por exemplo, o seguinte código

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

if (n == 1)

console.log ("1 nova mensagem");

outro

console.log ("você tem" + n + "nova mensagem");

Ao usar as instruções IF/else no uso aninhado das instruções IF, você deve ter cuidado para garantir que a instrução ELS corresponda à instrução IF correta. Considere o seguinte código:

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

i = j = 1;

k = 2;

if (i == j)

if (j == k)

console.log ("eu igual a k");

outro

console.log ("i doent igual j"); //Erro! !

Neste exemplo, a instrução IF interna constitui as cláusulas exigidas pela instrução IF externa. No entanto, a relação correspondente entre se e mais não é clara (apenas o indentação dá um pouco de dica) e, neste exemplo, a dica dada pelo indentação está errada, porque o intérprete JavaScript o entende.

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

if (i == j) {

if (j == k)

console.log ("eu igual a k");

outro

console.log ("i doent igual j");

}

Como a maioria das linguagens de programação, as regras se e senões correspondem ao JavaScript são que mais sempre correspondem à instrução IF próxima. Para tornar o exemplo legível, mais fácil de entender e mais conveniente para manutenção e depuração, os aparelhos encaracolados devem ser usados.

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

if (i == j) {

if (j == k) {

console.log ("eu igual a k");

} else {// Brace Crape torna o resultado do código mais claro

console.log ("i doent igual j");

}

}

Muitos programadores têm o hábito de envolver o corpo de IF e outras declarações em aparelhos encaracolados (assim como em uma declaração correspondente como um loop de tempo). Mesmo se houver apenas uma declaração por filial, isso pode evitar o problema ambíguo do programa agora.

ii.Else if

A instrução if/else seleciona uma das duas filiais julgando o resultado do cálculo de uma expressão. O que devo fazer quando houver muitas filiais no código? Uma solução é usar a instrução else if. caso contrário, se não for uma instrução JavaScript real, é apenas uma maneira de escrever declarações se/else juntas.

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

if (n == 1) {

// Execute o bloco 1

} else if (n == 2) {

// Execute o bloco de código 2

} else if (n == 3) {

// Execute o Bloco 3

} outro {

// As condições anteriores são falsas, então o bloco de código 4 é executado

}

Não há nada de especial nesse tipo de código. Consiste em declarações múltiplas se, e cada cláusula de declaração if contém outra instrução IF. O código equivalente da sintaxe pode ser concluído usando as instruções IF aninhadas, mas em comparação com isso, é óbvio que a redação de mais se for mais clara e preferível.

iii.switch

Durante a execução do programa, uma instrução IF cria uma ramificação e pode usar outra pessoa para lidar com várias ramificações. Então, quando todos os ramos dependem do valor da mesma expressão, caso contrário, se não for a melhor solução. Nesse caso, é uma prática muito desnecessária calcular repetidamente expressões em múltiplas declarações se.

A declaração do Switch é adequada para lidar com essa situação. A chave de palavra -chave é seguida por uma expressão envolvida em suportes de jardim. Depois, existem blocos de código fechados em aparelhos encaracolados.

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

switch (expressão) {

declarações

}

No entanto, a sintaxe completa da instrução Switch é mais complicada do que isso. O caso é seguido por uma expressão e um cólon. O caso é muito semelhante a um idioma de marcação, exceto que esse idioma de marcação não tem um nome.

Está associado apenas às expressões que o seguem. Ao executar essa instrução Switch, ele calcula primeiro o valor da expressão e depois descobre se a expressão da cláusula de caso é a mesma que o valor da expressão. (O mesmo é comparado com o operador "==="). Se o caso for correspondido, ele executará o código correspondente. Se um caso correspondente não puder ser encontrado, ele executará o bloco de código na tag "padrão:". Se não houver tag "padrão:", o Switch pulará todos os blocos de código.

A instrução Switch é muito fácil de confundir, e a introdução com exemplos será mais clara. A instrução Switch a seguir é equivalente à instrução if/else agora.

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

Switch (n) {

Caso 1: // se n === 1 começar a partir daqui

// Execute o bloco 1

quebrar;

Caso 2:

// Execute o bloco de código 2

quebrar;

Caso 3:

// Execute o Bloco 3

quebrar;

padrão:

// Executar o bloco de código 4

quebrar;

}

Deve -se notar que a quebra de palavras -chave é usada no final de cada instrução de caso. Apresentaremos a declaração de quebra mais tarde. A declaração de quebra pode fazer o intérprete saltar da instrução SWITCH ou da declaração de loop. No Switch, o caso indica apenas o ponto de partida do código a ser executado, mas não especifica o ponto final. Se não houver instrução Break, a instrução Switch começará a executar do código na tag de caixa correspondente do valor da expressão e executa instruções subsequentes por sua vez até o final de todo o bloco de código da chave. Obviamente, se você usar uma instrução Switch em uma função, poderá usar o retorno para substituir a interrupção. Retorno e quebra são usados ​​para encerrar a instrução SWITCH, que também impedirá que uma declaração de caso continue a executar o próximo bloco de declaração de caso.

A declaração a seguir está próxima do combate real e converte o valor em uma string de acordo com o tipo do valor.

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

função convert (x) {

Switch (tipo de x) {

caso 'número': // converte números em hexadecimal

retornar x.toString (16);

case 'string':

return '"' + x + '"'; // retorna duas cordas com citações duplas.

padrão: // Use métodos comuns para converter outros tipos

retornar string (x);

}

}

console.log (convert (100255114)) // => 5f9c58a

Observe que, nos dois exemplos acima, a palavra -chave de caso é seguida por um número e string direto, que é o uso mais comum da Switch na prática, mas o padrão ECMAScript permite que cada palavra -chave siga expressões arbitrárias.

A instrução Switch calcula primeiro a expressão após a palavra -chave do comutador e calcula a expressão após cada caso em ordem de cima para baixo, sabendo que o valor da expressão executada no caso e o valor da expressão do comutador são iguais. Como a operação correspondente para cada caso é na verdade uma comparação do operador de identidade "===", não "==", a correspondência de expressão e caso não faz nenhuma conversão de tipo.

Toda vez que uma instrução Switch é executada, nem todas as expressões de caso podem ser executadas. Portanto, as expressões de casos com efeitos colaterais devem ser evitadas, como expressões de chamadas de função e expressões de atribuição. A maneira mais segura é usar expressões constantes nas expressões.

Como mencionado anteriormente, se a expressão do Switch não corresponder a todas as expressões de caso, o bloco de declaração marcou "o padrão:" será executado. Se não houver tag "padrão:", toda a instrução Switch será ignorada. No exemplo anterior, a tag "padrão:" aparece no final do comutador e está atrás de todas as tags de caixa. Obviamente, essa é a maneira mais razoável e mais usada de escrever. De fato, a tag "Padrão:" pode ser colocada em qualquer lugar dentro da instrução Switch.

5. Loop.

Para entender as declarações condicionais, você pode pensar no código em JavaScript como caminhos de ramificação. As declarações de loop estão em loops que permitem que algum código seja executado repetidamente. Existem quatro declarações de loop no JavaScript: enquanto, enquanto, enquanto, para e para/in. As seções a seguir as explicarão de uma vez. O loop mais usado é a travessia dos elementos da matriz. (7.6 discutirão esse loop e métodos de loop especial definidos pelas classes de matriz em detalhes.)

I. Enquanto

Se a instrução for uma instrução BASIC Control usada para selecionar declarações de ramificação que executem o programa. Como se, a declaração do tempo também seja uma declaração básica de loop, e sua sintaxe é a seguinte:

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

Enquanto (expressão)

declaração

Antes de executar uma declaração de tempo, o intérprete JavaScript calcula primeiro o valor da expressão. Se seu valor for um valor falso, o programa pulará a instrução lógica no corpo do loop e executará a próxima instrução no programa. Se seu valor for verdadeiro, a lógica na declaração do corpo do loop será executada e o valor da expressão da expressão será calculado. O loop continuará até que o valor da expressão seja falso. Em outras palavras, quando a expressão é verdadeira, a declaração será executada em um loop. Observe que o uso while (true) criará um loop morto.

De um modo geral, não queremos que o JavaScript execute a mesma operação repetidamente. Em quase todos os loops, uma ou mais variáveis ​​mudarão iterativamente com o loop. É precisamente porque essas variáveis ​​são alteradas que as operações de instrução realizadas em cada loop são diferentes. Além disso, se a alteração da variável é usada na expressão, o valor da expressão de cada loop também é diferente. Isso é muito importante. A expressão responsável pelo valor inicial do valor verdadeiro é sempre o valor verdadeiro, e o loop não terminará. O exemplo abaixo mostra que, enquanto o loop produz valores 0-9.

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

var count = 0;

while (contagem <10) {

console.log (contagem);

contagem ++;

}

Pode -se descobrir que, neste exemplo, o valor inicial da contagem da variável é 0 e, durante o loop, seu valor é incrementado em 1 de cada vez, quando o loop é executado dez vezes. O valor da expressão é programado false e, enquanto terminará, e o intérprete JavaScript executará a próxima declaração do programa. A maioria dos loops tem uma variável contra a contagem. Embora os contadores geralmente usem nomes de variáveis ​​como o IJK, se você deseja tornar o código mais legível, use nomes de sintaxe mais específicos.

ii.do/whwile

O loop DO/enquanto é muito semelhante ao loop while, exceto que detecta a expressão do loop na cauda do loop e não na parte superior, o que significa que o corpo do loop é executado pelo menos uma vez. A sintaxe do loop DO/While é a seguinte:

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

fazer

declaração

enquanto (expressão);

Faça/enquanto os loops não são tão comumente usados ​​quanto os loops. Isso ocorre porque não é comum na prática querer executar loops pelo menos uma vez. Aqui está um exemplo de um loop de fazer/enquanto

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

função printArray (a) {

var len = A.Length,

i = 0;

if (len == 0)

console.log ("Array vazio");

outro

fazer {

console.log (a [i]);

} while (++ i <len);

}

PrintArray ([1,5,2,6])

Existem duas diferenças de sintaxe entre DO/enquanto loops e normais durante os loops. Primeiro, o loop DO exige que a palavra -chave faça deve ser usada para identificar o início do loop, use enquanto a variável para identificar o final do loop e entrar na condição do loop para julgar; Em segundo lugar, ao contrário do loop while, o loop do DO usa um final de ponto de vírgula. Se o corpo do laço estiver encerrado em aparelhos encaracolados, o loop while não termina com um semicolon.

iii. para

A instrução for fornece uma estrutura de controle de declaração de loop mais conveniente do que enquanto. A instrução for simplifica o modo de loop comumente usado. A maioria dos loops possui variáveis ​​de contador específicas. Essa variável é inicializada antes do início do loop e verifique seu valor antes de cada loop. Finalmente, a variável do contador é auto-incrementada, caso contrário, será modificada após o término do ciclo e antes do próximo julgamento. Nesse tipo de loop, as três operações principais do contador são inicialização, detecção e atualização. A declaração for declara explicitamente essas três operações como parte da sintaxe do loop, cada uma usando uma expressão para representá -la. A sintaxe da declaração for a seguinte:

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

para (inicializar; teste; incremento)

declaração

As três expressões de inicialização, teste e incremento são separadas por semicolons. Eles são responsáveis ​​por inicializar operações, julgamento da condição cíclica e atualizar variáveis ​​contra o contador. Colocá -los na primeira linha do loop facilita a compreensão do que o loop está fazendo e também impede que o esquecimento de inicializar ou incrementar a variável contador.

A maneira mais fácil de explicar como funciona um loop é listar um equivalente enquanto o loop

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

inicializar

while (teste) {

declaração

incremento;

}

Em outras palavras, a expressão inicializa é executada apenas uma vez antes do início do loop. A expressão de inicialização deve ter efeitos colaterais (geralmente uma declaração de atribuição). O JavaScript também permite expressões de inicialização com declarações de declaração variável VAR, para que uma variável possa ser declarada e inicializada. Antes de cada loop, a expressão do teste será executada e o resultado da expressão será julgado para determinar se deve executar o corpo do loop. Antes de cada loop, a expressão do teste será executada e o resultado será determinado se o corpo do loop será executado. Se o resultado do teste for o valor verdadeiro, a instrução no corpo do loop será executada. Finalmente, execute a expressão de incremento. Também por uma questão de utilidade, a expressão de incremento aqui também deve ter efeitos colaterais. De um modo geral, é uma expressão de atribuição ou uma expressão composta por operadores "++" e "--".

O acima, enquanto o loop pode ser escrito usando um loop para

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

for (var count = 0; contagem <10; contagem ++)

console.log (contagem)

Obviamente, alguns loops são mais complexos e múltiplas variáveis ​​são iteradas em um momento no loop. No JavaScript, este caso deve ser usado com um operador de vírgula, que combina a expressão de inicialização e a expressão de increment automaticamente em uma expressão para uso em um loop for.

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

var i, j;

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

console.log (i * j);

Até agora, as variáveis ​​de loop no código de amostra são todos números. Obviamente, os números são os mais usados, mas não são necessários. O código a seguir usa um loop for para atravessar os resultados dos dados da tabela e retornar o último objeto na lista vinculada (ou seja, o primeiro objeto que não contém o próximo atributo)

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

Função Tail (O) {// retorna o último objeto do nó da lista vinculada

para (; o.next; o = o.next) /*vazio* /// Execute a travessia com base no fato de O.Next ser o valor verdadeiro

retornar o;

}

Deve -se notar que esse código não contém expressões de inicialização, e as pessoas e uma das três expressões no loop for podem ser ignoradas, mas dois semicolons são indispensáveis. Se a expressão do teste for omitida, será um loop morto. Também com o tipo de tempo (Ture), uma maneira de escrever um loop morto é para (;;).

iiii.for/in

A instrução for/in usa a palavra -chave for, mas é um tipo diferente de loop que o regular para loop. A sintaxe do loop for/in é a seguinte

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

para (variável no objeto)

declaração

Uma variável é geralmente um nome variável ou uma expressão que pode produzir lvalues ​​ou uma variável declarada através de uma instrução VAR. De qualquer forma, é um valor que se aplica ao lado esquerdo da expressão de atribuição. O objeto é uma expressão e o resultado dessa expressão é um objeto. Da mesma forma, uma declaração é uma declaração ou bloco de declarações que formam o corpo do loop.

Usar um loop for para iterar por meio de elementos de matriz é muito simples

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

var a = [1, 3, 5, "44"];

for (var i = 0; i <A.Length; i ++) // i representa o índice de elementos de matriz

console.log (a [i]) // Elementos de saída de cada matriz

O loop for/in é usado para atravessar convenientemente as propriedades do membro do objeto

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

para (var p in o) // atribui o nome do atributo à variável p

console.log (O [P]); // emitir o valor de cada atributo

No processo de execução da instrução for/in, o intérprete JavaScript calcula primeiro a expressão do objeto. Se a expressão for nula ou indefinida, o intérprete JavaScript pulará o loop e executará o código subsequente. Se a expressão for igual a um valor primitivo, esse valor primitivo será convertido no objeto Wrapper (Seção 3.6). Caso contrário, a expressão em si já é um objeto. O JavaScript enumera as propriedades do objeto, por sua vez, para executar o loop. No entanto, antes de cada loop, o JavaScript calcula o valor da expressão da variável e atribui o nome do atributo (uma string) a ele.

Deve -se notar que, enquanto o loop for/in, o valor do Varibale pode ser considerado como o LValue da expressão de atribuição e pode ser qualquer expressão. Essa expressão é calculada a cada loop, o que significa que o valor que ele calcula pode ser diferente a cada vez que os loops. Por exemplo, você pode usar o seguinte código para copiar todas as propriedades do objeto em uma matriz:

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

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

var a = [], i = 0;

para (a [i ++] em O) /*vazio* /;

document.write (a) // => x, y, z

As matrizes JavaScript são apenas um objeto especial, portanto, o loop for/in pode enumerar índices de dados como enumerar as propriedades do objeto. Por exemplo, adicionar este código após o código acima pode enumerar o índice de dados 0, 1, 2:

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

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

var a = [], i = 0;

para (a [i ++] em O) /*vazio* /;

document.write (a) // => x, y, z cópia Propriedades do objeto em uma matriz

para (i em a)

document.write (i) // => Índice de dados da enum 0 1 2

De fato, o loop for/in não atravessa todas as propriedades do objeto. Somente os atributos "enumeráveis" serão percorridos (consulte 6.7). Como os métodos internos definidos pelo núcleo da linguagem JavaScript não são "enumeráveis". Por exemplo, todos os objetos têm tostring (), mas o loop for/in não enumeram a propriedade ToString (). Além dos métodos internos, existem muitos objetos internos que não são enumeráveis. Todos os atributos e métodos definidos no código são enumeráveis ​​(a Seção 6.7 será mencionada, mas existem meios especiais no ECMAScript5 que podem tornar os atributos não enumeráveis).

Os objetos podem herdar as propriedades de outros objetos, e a linha herda as propriedades personalizadas (6.2.ii) também podem ser enumeradas usando/in.

Se o corpo for/in loop excluir uma propriedade não inumerada, essa propriedade não será enumerada novamente. Se o corpo do loop definir novas propriedades do objeto, essas propriedades geralmente não são enumeradas (mas algumas implementações de JavaScript podem enumerar as propriedades adicionadas no corpo do loop).

A ordem da enumeração de atributo

A especificação do ECMAScript não especifica em qual ordem o for/in loop enumera as propriedades do objeto. Mas, de fato, o fabricante de navegador JavaScript implementa as propriedades dos objetos simples na ordem das definições de atributo, e as propriedades definidas primeiro são enumeradas primeiro. Se um objeto for criado na forma de uma quantidade direta, ele será enumerado na ordem em que as propriedades na quantidade direta aparecerão. (Algumas bibliotecas de rede e JavaScript dependem dessa ordem de enumeração, enquanto os fabricantes de navegadores principalmente não modificam essa ordem). Nos casos seguintes, a ordem de enumeração depende da implementação específica (não da interação)

1. Objetos herdam atributos enumeráveis

2. Objeto tem propriedades do índice de matriz inteira

3. Use Excluir para excluir as propriedades existentes do objeto

4. Use Object.DefineProperty () ou métodos similares para alterar as propriedades do objeto

6. Jump

Em JavaScript, um tipo de declaração é uma declaração de salto. Do entendimento da declaração, ele pode fazer com que a execução do JavaScript salte de uma posição para uma posição.

A declaração de quebra é pular para o final de um loop ou outra declaração. A declaração continua encerra a execução desse loop e inicia a execução do próximo loop. As declarações no JavaScript podem ser nomeadas ou rotuladas, quebrar e continuar podem identificar loops de destino ou outras tags de instrução.

A declaração de retorno permite que o intérprete salte da execução do corpo da função. E forneça o valor de retorno desta chamada. A declaração de arremesso aciona ou lança uma exceção, que é usada com a instrução Try/Catch/Finalmente, que especifica a lógica de código de manuseio de exceção. Esta é uma declaração de salto complexa. Quando uma exceção é lançada, o programa saltará para a estrela de exceção fechada mais próxima. Este programa de exceção pode estar na mesma função ou na pilha de chamadas em um nível mais alto.

Em seguida, descreva cada declaração de salto

eu. Instrução de tag

Uma declaração pode ser rotulada e o rótulo é composto pelo identificador e cólon antes da declaração:

Identificador: declaração

Ao definir uma tag para uma instrução, você pode consultar esta declaração por seu nome de tag em qualquer lugar do programa. Você pode definir rótulos para várias declarações, embora seja apenas mais útil ao definir rótulos para blocos de declaração, como declarações de loop ou declarações de julgamento condicional. Ao definir um nome de tag para o loop, você pode usar o intervalo e continuar dentro do corpo do loop para sair do loop ou desafiar diretamente o início do próximo loop. break and continue are the only statements in JavaScript that can use statement tags (this chapter will be discussed next). The following example, where the while loop defines a tag, and the continue statement uses this tag:

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

mainloop: while (token != null) {

//忽略这里代码...

continue mainloop; //跳转到下一次循环

//忽略这里的代码...

}

这里做标签的indentifier必须是一个合法的javascript标识符，而不能是一个保留字。标签的命名空间和变量或函数的命名空间是不同的，因此可以使用同一个标识符作为语句标签和作为变量名或函数名。语句标签只在它所起作用的语句（当然可以在它的子句）内是有定义的。一个语句标签不能和它内部的语句标签重名，但在两个代码不相互嵌套的情况下是可以出现同名语句标签的。带有标签的语句还可以带有标签，也就是说，任何语句可以有很多个标签。

ii.break

单独使用break语句的作用是立即退出最内存的循环或switch语句。它的语法如下：

quebrar;

由于它能够使循环和switch语句退出，因此这种形式的break只能出现在这类语句中才是合法的。

我们在switch语句的例子中已经见到果break语句。在循环中，无论出于什么原因，只要不想继续执行整个循环，就可以用break提前退出。当循环终止条件非常复杂时，要函数体内使用break语句实现这样些条件判断的做法要比直接在循环表达式中写出这个复杂的终止条件做法简单的多。

下面的例子中循环遍历整个数组元素来查找某个特定的值，当整个数组遍历完成后正常退出循环，如果找到了需要查找的数组元素，则使用break语句退出循环：

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

for (var i = 0; i < a.length; i++) {

if (a[i] == target) break;

}

javascript中同样允许break关键字后跟随一个语句标签，（只有标识符，没有冒号）

Break LabelName;

当break和标签一块使用时，程序将跳转到这个标签所识别的语句块的结束，或者直接终止这个闭合语句块的执行。当没有任何闭合语句块指定break所用的标签，这时会产生一个语法错误。当使用这种形式的break语句时，带标签的语句不应该是循环或者switch语句，因为break语句可以“跳出”任何闭合的语句块。这里的语句可以是由花括号组起来的一组语句，使用同一个标签来识别一组语句。

break关键字和labelname之间不能换行。因为javascript可以给语句自动补全省略掉的分号，如果break关键字和标签之间有换行，javascript解释器会认为你在使用break不带标签的最简形式，因此会在break后补充分号.

当你希望通过break来跳出非就近的循环体或者switch语句时，就会用到带标签的break语句。下面是示例代码：

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

var matrix = getData(); //从某处获得一个二维数组

//将矩阵中所有元素进行求和

var sum = 0,

success = false;

//从签名处开始，以便在报错时推出程序。

compure_sum: if (matrix) {

for (var x = 0; x < matrix.length; x++) {

var row = matrix[x];

if (!row) break compure_sum;

for (var y = 0; y < row.length; y++) {

var cell = row[y];

if (isNaN(cell)) break compure_sum;

sum += cell;

}

}

success = true;

}

//break语句跳转至此

//如果success =false条件到达这里，说明我们给出的矩阵中有错误

//否则对矩阵中所有的元素进行求和

最后，需要注意的是，不管break语句带不带标签，它的控制权都无法越过函数的边界。比如：对于一条带标签的函数定义语句来说，不能通过函数内部通过这个标签来跳转到函数外部.

iii.continue语句

continue语句和break语句非常类似，但它不退出循环，而是转而执行下一次循环。continue语句的语法和break的语句语法一样简单

continuar;

continue语句会也会带有标签

continue lebname;

不管continue语句带不带标签，它只能在循环体使用，在其它地方使用将会报语法错误。

当执行到continue语句的时候，当前的循环逻辑就终止了，随即执行下一次循环，在不同类型的循环中，continue的行为也有区别

1.在while循环中，在循环开始处指定expression会重复检测，如果检测结果为true，循环体会从头执行。

2.在do/while循环中，程序的执行至今跳转到循环的结尾处，这时会重新判断循环条件，之后才会继续下一次循环。

3.在for循环中，首先会计算自增表达式，然后再检测test表达式，用以判断是否执行循环体。

4.在for/in循环中，循环开始遍历下一个属性名，这个属性名赋给了指定的变量。

需要注意continue语句在while和for循环中的区别，while循环直接进入下一轮的循环条件判断，但for循环首先计算器increment表达式，然后判断循环条件。之前的章节讨论了和while循环“等价”的for循环行为。但由于continue在这两种循环中行为表现不同，因此使用while循环不可能完美的模拟等价的for循环。

下面这段代码展示了不带标签的continue语句，产生一个错误的时候跳过当前循环的后续逻辑

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

for (i = 0; i < data.length; i++) {

if (!data[i]) continue; //不能处理undefined数据

total += data[i];

}

和break语句类似，带标签的continue语句可以用在嵌套的循环中，用以跳出层次嵌套的循环体逻辑。同样和break语句类似，在continue语句和labname之间不能有换行。

iiii.return

回想一下，函数调用的一种表达式，而且所有的表达式都有值。函数中的return语句即是指函数调用后的返回值。这里是return语句的语法：

return expression;

The return statement can only appear in the function body. If not, it will report a syntax error. When the return statement is executed, the function terminates the execution and returns the value of the expression to the calling program. Por exemplo:

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

function square(x) {return x * x} //一个包含return的语句函数

square(4) //执行为16

如果没有return语句，则函数调用仅依次执行函数体内的每一条语句直到函数结束，最后返回调用程序。这种情况下，调用表达式的结果是undefined。return语句经常作为函数内最后的一条语句出现，但并不是说一定一定要放在函数的最后，即使在执行return语句的时候还有很多代码没有执行到，这时候函数也还返回调用程序。

The return statement can be used alone without having expression, so the function will also want to call the program to return undefined. Por exemplo:

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

//如果参数是null或者undefined则立即返回

if (!o) return;

//其它逻辑

由于javascript可以自动插入分号，因此，return关键字和它后面的表达式之间不能有换行。

iiiii.throw语句

所谓异常（excepion）是当发生了某种异常情况或错误时产生的一个信号。抛出异常，就是用信号通知发生了错误或异常状况。捕获异常是指处理这个信号，抛出异常，就是用信号通知发生了错误或异常状况。捕获异常是指处理这个信号，即采取必要的手段从异常中汇丰。在javascript中，当产生运行时错误或者程序使用throw语句时就会显式的抛出异常。使用try/catch/finally语句可以捕获异常，下一节会对它作详细介绍。

throw语句的语法如下：

throw expression

expression的值可以是任意类型的。可以抛出一个代表错误码的数组，或者包含可错误消息的字符串。当javascript解释器抛出异常的时候，通常采用Eeeor类型或其子类型，当然也可以使用它们。一个error对象有一个那么熟悉表示错误类型，一个message属性用来传递构造函数的字符串（参照第三部分的Error类），在下面的例子中，当使用非法参数调用函数时就抛出一个Error对象：

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

function fa(x) {

//如果输入的参数是非法的，则抛出一个异常

if (x < 0) throw new Error("x不能是负数。");

//否则计算出一个值，正常地返回它

for (var f = 1; x > 1; f *= x, x--) /*empty*/;

retornar f;

}

当抛出异常时，javascript解释器会立即停止当前正在执行的逻辑，并跳转至就近的异常处理程序。异常处理程序用try/catch/finally语句的catch从句编写的。如果抛出的异常没有一条关联catch从句，解释器会检测更高层的闭合代码块，看它是否关联相关的异常处理程序。以此类推，直到扎到一个异常处理的程序为止。

如果抛出的异常函数没有处理它的try/catch/finally语句，异常将向上传播到调用该函数的代码。这样的话，异常就会沿着javascript方法的词法结构和调用栈向上传播。如果没有找到任何异常处理的程序，javascript将吧异常当成程序错误来处理，并报告给用户。

iiiiii.try/catch/finally语句

try/catch/finally语句是javascript的异常处理机制。其中try从句定义了需要处理的异常所在代码块。catch语句跟随在try从句之后，当try块从某处发送了异常时，调用了catch内的代码逻辑。catch从句跟随finnlly块，后者防置了清理代码，不管try块中是否产生了异常，finnally块内的逻辑总会执行。尽管catch和finally都是可选的，但try从句只杀二者之一与组成完整的语句。try、catch和finally语句块都需要花括号括起来，这里的花括号是必须的。即使从句中只有一条语句也不能省略花括号。

下面的代码说明了try/catch/finlly的语法和使用目的：

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

tentar{

//通常来讲，这里的代码会从头执行到尾而不会产生任何问题，

//但有时会抛出一个异常，要么是由throw语句直接抛出异常

//要么通过调用一个方法间接抛出异常

}

catch(e){

//当且仅当try抛出了异常，才会执行这里的代码

//这里可以通过局部变量e来获得对Error对象或者抛出的其它值的引用

//这里的代码可以基于某种原因处理这个异常，也可以忽略这个异常。

//还可以通过throw语句重新抛出异常

}

Finalmente{

//不管try语句块是否抛出看异常，这里的逻辑总会执行，终止try的语句块方式有：

//1）正常终止，执行完语句块的最后一条语句

//2）通过break，continue或return语句终止

//3）抛出一个异常，异常被catch从句捕获

//4）抛出一个异常，异常未被捕获，继续向上传播

}

我们注意到，关键字catch后跟随了一对圆括号，圆括号内是一个标识符。这个标识符和函数参很像。当捕获一个异常时，把这个异常相关的值（比如Error对象）赋值给这个参数。和普通的变量不同，这条catch子句中的标识符具有块级作用域，它只在catch语句块内有定义。

这里有一个关于try/catch语句更实际的例子，这里使用了前面章节中提到factorial()方法，并使用客户端javascript方法prompt()和alert()来输入和输出

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

tentar {

//要求用户输入一个数字

var n = Number(prompt("请输入一个正整数", ""));

//假设输入是合法的，计算这个阶乘

var f = factorial(n);

//显示结果

alert(n + "!=" + f);

} catch (ex) {

//如果输入不合法，将执行这里的逻辑

document.write(ex); //告诉用户发送了什么。

}

这里的try/catch语句并不包含finally从句。尽管finally不像catch那样经常使用，但有时候它还是非常有用。然而，我们需要更详尽的解释它的行为。不管try语句块中的代码执行完成了多少，只要try语句中有一部分代码执行了，finally从句就会执行。它通常在try从句的代码后用于清理工作。

关注下面这个例子

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

tentar {

print("Outer try running..");

tentar {

print("Nested try running...");

throw "an error";

} catch (e) {

print("Nested catch caught " + e);

throw e + " re-thrown";

} finalmente {

print("Nested finally is running...");

}

} catch (e) {

print("Outer catch caught " + e);

} finalmente {

print("Outer finally running");

}

// Windows Script Host 作出该修改从而得出WScript.Echo(s)

function print(s) {

document.write(s);

}

Saída:

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

Outer try running..

Nested try running...

Nested catch caught an error

Nested finally is running...

Outer catch caught an error re-thrown

Outer finally running

7.其它语句类型。

本节讨论剩余的三种javascript语句：width，debugger和use strict

i.with语句

3.10讨论了作用域链（scope chain），一个可以按序检索的对象列表，通过它可以进行变量名的解析。width语句可以用来临时扩展作用域链：它具体有如下语法：

with (object)

declaração

这条语句将object添加到作用域链头部，然后执行statement，最后把作用域链恢复到原始状态。

在严格模式下（5.7.iii）是禁止使用width的，在非严格模式下也是不推荐使用width语句的，尽可能的避免使用width语句。那些使用width语句的javascript非常难优化，而且比没有使用width的语句，它运行速度更慢。

在对象嵌套层次很深的时候，常会使用with语句来简化代码的编写。例如客户端javascript中，可能使用下面的这种表达式来访问表单的一个html元素

document.forms[0].address.value

如果这段代码多次出现，则可以使用with将form对象添加至作用域链的顶层。

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

with(document.forms[0]){

//直接访问表单元素

name.value="";

address.value="";

email.value ="";

}

这种方法简化了大量的输入，不用再为每个变量添加document.forms[0]前缀。这个临时对象挂载在作用域链上，当javascript需要解析诸如address标识符时，就会在这个对象中查找。当然，不使用with的语句代码可以写成这样。

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

var f = document.forms[0];

f.name.value = "";

f.adress.value = "";

f.email.value = "";

不要忘记，只有在查找标识符的时候才能用到作用域链，创建新的变量时候不使用它，看一下下面的代码：

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

with(o) x = 1;

如果对象o有一个属性x，那么这行代码给这个属性赋值1。如果o没有定义属性x，这段代码和不使用with的代码x=1是一模一样的。它给一个局部变量或者全局变量x赋值，或者创建全局对象的一个新属性。with语句提供了一种读取o属性的快捷方法，但并不会创建o的属性。

ii.debugger语句

debugger语句通常什么也不做。然而，在调试程序可用并运行的时候，javascript解释器将会（非必须）以调试模式运行。实际上，这条语句产生一个断点（breakpoint），javascript代码执行会停止在断点的位置，这时可用使用调速器输出变量的值，检查调用栈等。

例如加上调用函数f()的时候使用了未定义的参数，因此f()抛出一个异常，但无法定位到到底哪里出了异常。为了有助于调试这个问题，需要修改f()：

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

function f(o){

if (o === undefined) debugger; //这段代码用来临时调试

console.log(1) //函数的其它部分

}

f();

这时候，当调用f()没有传入参数，程序将停止执行，这时候通过调用调速器检测调用栈并找出错误的原因。

在ECMAScirpt5中，debugger语句已经正式加入到专门语言里，但在很长的一段时间里，主浏览器的厂商已经将其实现了。注意，可用的调速器是远远不够的，debugger语句不会启动调试器。但如果调试器已经在运行，这条语句才会正在产生断点。例如，使用Firefox插件firebug，首先启动firebug，这样debugger语句才能工作。

iii.“use strict”

“use strict”是ECMASCript5引入的一条指令。指令不是语句（但非常接近于语句），“use strict”和普通语句之前有两个重要区别：

1.它不包含任何语言的关键字，指令仅仅是一个包含一个特殊字符串直接量的表达式（可以是使用单引号也可以是双引号）。

2.它只能出现在脚本代码的开始或者函数体的开始、任何实体语句之前。但它不必一定出现在脚本的首行或者函数体内的首行。因为“use strict”指令之前之后或之前都可能有其它字符串直接量的表达式语句，并且javascript的具体实现可能将它们解析为解释器自有的指令。在脚本或者函数体内第一条常规语句之后，字符串直接量表达式语句只当做普通的表达式语句对待，它们不做指令解析，它们也没有任何副作用。

使用“use strict”指令的目的是说明（脚本或函数中）后续代码解析为严格代码(strict code)。如果顶层（不在任何函数内）代码使用了“use strict”指令，那么它们就是严格代码。如果函数体定义处的代码是严格代码或者函数体使用了“use strict”指令，那么函数体的代码也是严格代码。如果eval()调用所处的代码是严格代码或者eval()要执行的字符串使用了“scrict code”指令，则eval()内的代码是严格代码。

严格代码以严格模式执行。ECMAScript5中的严格模式是该语言的一个受限的子集。它修正了语言的重要缺陷，并提供健壮的差错功能和增强安全机制。严格模式和非严格模式区别如下（前三条尤其重要）

•严格模式中禁止使用with语句

•严格模式中，所有的变量要先声明，如果给一个未声明的变量、函数、函数参数、catch从句参数或全局的对象的属性赋值。就会抛出一个引用错误异常（在非严格模式中，这种隐式声明全局变量的方法是给全局变量新添加一个新属性）

•严格模式中，调用的函数（不是方法）中的一个this值是undefined。（在非严格模式中，调用的函数中的this值总是全局变量）。可以利用这种特性来判断javascript实现是否支持严格模式。

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

var hasStrictMode = (function() {

"use strict";

return this === undefined

}());

•同样，在严格模式中，当通过call()和apply()来调用函数时，其中的this值就是通过call()或apply()传第一个参数（在非严格模式中，null和undefined值被全局对象转换为对象的非对象值锁代替）

•在严格模式中，给只读属性赋值和给不可扩展的对象创建成员都将抛出一个类型错误异常（在非严格模式中，这些操作只是简单的操作失败，不会报错）。

•在严格模式中，传入eval()代码不能再调用辰星所在的上下文中声明变量或定义函数，在非严格模式中是可以这样做的。相反，变量和函数的定义是在eval()创建的作用域中，这个作用域在eval()返回时就弃用了。

•在严格模式中，函数里的arguments对象拥有传入函数值的静态副本。在非严格模式中，agreements对象具有“魔术般”的行为，arguments里的数组元素和函数都指向同一个值的引用。

•在严格模式中，当delete运算符后面跟随非法的标识符（比如变量、函数、函数参数时）将会抛出一个语法错误，（在非严格模式下，这种delete什么也没做，并返回false）

•在严格模式中，在一对象直接量中定义两个或多个同名属性将产生一个语法错误（非严格模式下不会报错）

•在严格模式下，不允许八进制整数直接量。（以0为前缀，而不是0x为前缀）在非严格模式中是允许直接八进制直接量的

•在严格模式下，标识符eval和arguments当做关键字，他们的值是不能更改的。不能给这些标识符赋值，也不能把它们声望为变量，用做函数名，用做函数参数或用做catch块的标识符。

•在严格模式中限制了对调用栈的检测能力，在严格的模式的函数中，arguments，caller和arguments.callee都会抛出一个类型错误异常。严格模式的函数同样具有caller和arguments属性，当访问这两个属性时抛出类型错误异常。

8.javascript语句小结：

javascript语句语法：