Javascript Core Reading Experience Tipos, valores e variáveis

A operação de um programa de computador requer valores operacionais, como o número 3.14 ou o texto "Hello World". Nas linguagens de programação, o tipo de valor que pode ser representado e operado é chamado de tipo de dados. O recurso mais básico das linguagens de programação é hospedar vários tipos de dados. Quando o programa precisa manter o valor para uso futuro, ele é atribuído a ("salvar" o valor para) uma variável. Uma variável é um nome simbólico de um valor e uma referência a um valor pode ser obtida pelo nome. O mecanismo de trabalho das variáveis ​​é uma característica básica das linguagens de programação. Este capítulo se referirá à seção anterior para ajudar a entender o conteúdo deste capítulo e será explicada em mais profundidade mais tarde.

Os dados JavaScript são divididos em duas categorias: tipo primitivo e tipo de objeto

As classes originais em JavaScript incluem números, strings e valores booleanos. Este capítulo terá um capítulo separado discutindo especificamente os números, strings e valores booleanos de JavaScript. O JavaScript também possui dois valores brutos especiais, nulos (vazios) e indefinidos (indefinidos), eles não são números, cordas ou valores booleanos. Eles representam os únicos membros de seus respectivos tipos especiais.

JavaScript é um objeto além de números, cordas, valores booleanos, nulos e indefinidos. Um objeto é uma coleção de propriedades. Cada atributo consiste em um "par de nome/valor" (o valor pode ser um valor primitivo, como um número, uma string ou um objeto). Um dos objetos mais especiais (o objeto global será introduzido na Miss Fifth, e a sexta seção será descrita em mais detalhes)

Objetos JavaScript normais são coleções sem nelecssy de "valores nomeados". O JavaScript também define um objeto especial - uma matriz, representando um conjunto ordenado de valores numerados. O JavaScript define uma sintaxe dedicada para matrizes. Faça as matrizes têm algumas propriedades de comportamento exclusivas diferentes dos objetos comuns.

O JavaScript também define uma função de objeto especial. Uma função é um objeto com código executável com o qual deseja se associar. Ele executa o código chamando a função e retorna o resultado da operação. Como matrizes, as características do comportamento da função são diferentes de outros objetos. O JavaScript define uma sintaxe especial para usar funções. Para funções JavaScript. Mais importante ainda, todos são valores verdadeiros, e o JavaScript pode ser usado para tratá -los como objetos comuns.

Se uma função inicializar (usando o novo operador) um novo objeto, chamamos de construtor. Cada construtor define um objeto de classe-uma coleção composta por objetos de inicialização do construtor. As classes podem ser consideradas como subtipos de tipos de objetos. Além das classes e classes de matrizes, o JavaScript também define três outras classes usadas. Uma data define um objeto que representa uma data. Regexp define o objeto de expressões regulares. A classe de erro define a linha que representa o erro de tempo de execução e o objeto de erro de sintaxe em um programa JavaScript. Você pode definir a classe necessária definindo seu próprio construtor.

O intérprete JavaScript possui seu próprio mecanismo de gerenciamento de memória, que pode automaticamente lixo de coleta de memória. Isso significa que o programa pode criar objetos sob demanda, e os programadores não precisam se preocupar com a destruição desses objetos e com a reciclagem de memória. Quando nenhuma referência aponta para um objeto, o intérprete sabe que o objeto é inútil e reciclará automaticamente os recursos de memória que ocupa.

JavaScript é uma linguagem orientada a objetos. Não falando estritamente, isso significa que não usamos funções de definição global para operar diferentes tipos de valores. O próprio tipo de dados pode definir métodos para usar valores. Por exemplo, para classificar os elementos na matriz A, não há necessidade de passar uma função de classificação (), mas transferir uma classificação de método ()

a.sort (); // classificar (a) Versão orientada a objetos

Tecnicamente, apenas objetos JavaScript podem ter métodos. No entanto, números, cordas e valores booleanos também têm seus próprios métodos. No JavaScript, apenas nulos e indefinidos são valores que não podem ter métodos.

Os tipos de JavaScript podem ser divididos em tipos primitivos e tipos de objetos e podem ser divididos em tipos que podem ter métodos e tipos que não podem ter métodos. Também pode ser dividido em tipos mutáveis ​​e imutáveis. Os valores dos tipos mutáveis ​​podem ser modificados e objetos e matrizes pertencem a tipos mutáveis: os programas JavaScript podem alterar o valor do valor de atributo de um objeto e o valor dos elementos da matriz.

Números, booleanos, nulos e indefinidos são tipos imutáveis. Por exemplo, modificar o conteúdo de uma matriz em si não faz sentido. Uma string pode ser considerada uma variedade de caracteres e você pode pensar que pode ser alterada. No entanto, no JavaScript, as cordas são imutáveis. Você pode acessar o texto em qualquer posição de uma string, mas o JavaScript não fornece uma maneira de modificar o conteúdo de texto da string o tempo todo.

O JavaScript pode executar a conversão do tipo de dados livremente. Por exemplo, se um número for usado em que o programa espera usar uma string, o JavaScript converterá automaticamente o número em uma string. Se você espera usar um valor não-booleano em que o valor booleano é usado, o JavaScript também se converterá de acordo. Em JavaScript, as regras da "igualdade de julgamento" são usadas para "julgamento igualdade" (igualdade)

As variáveis ​​de JavaScript não são criadas. As variáveis ​​podem ser atribuídas a pessoas e tipos. As variáveis ​​podem ser declaradas usando a palavra -chave var. O JavaScript adota o escopo da sintaxe. As variáveis ​​não declaradas em nenhuma função são chamadas de variáveis ​​globais. Eles são visíveis em qualquer lugar do programa de JavaScript.

1. Números

Ao contrário de outras linguagens de programação, o JavaScript não distingue entre valores inteiros e valores de ponto flutuante. Todos os valores no JavaScript são expressos pelos valores de ponto flutuante. Quando um número aparece diretamente em um programa JavaScript, somos um literal numérico, e o JavaScript suporta quantidades diretas numéricas em vários formatos. (Nota: adicionar um sinal negativo (-) diretamente antes que qualquer número possa obter seus valores negativos), mas o sinal negativo é um operador inverso unidirecional. , não um componente da gramática de quantidades numéricas diretas. )

I Inteiro Tipo de quantidade direta

Um número inteiro decimal é representado por uma sequência de matriz em JavaScript

Além da quantidade direta inteira decimal, o JavaScript também reconhece os valores do mecanismo de dezesseis (16) como cardinalidade. O chamado sistema hexadecimal é uma quantidade direta prefixada com "0x" ou "0x", seguida por uma sequência de números hexadecimais. O valor hexadecimal é composto de letras entre 0-9 e a (a) -f (f). As letras da FA são expressas nos números 10-15 abaixo. Aqui estão exemplos de quantidades diretas de números inteiros hexadecimais

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

0xff // 15*16+15 = 255

0xcafe911

Embora o ECMAScript não suporta quantidades diretas octal, algumas implementações do JavaScript podem permitir a representação de números inteiros em octal (base 8). A quantidade direta octal começa com o número 0, seguido por uma sequência de números entre 0 e 7.

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

0377 // 3*64 +7*8 +7 = 255 (decimal)

Como algumas implementações do JavaScript suportam o octal entre o número, enquanto alguns não o fazem, é melhor não usar o número inteiro interfixado com 0. Afinal, não podemos saber se a implementação atual do JavaScript suporta a análise octal. No modo rigoroso do ECMAScript6, a quantidade octal direta é explicitamente proibida.

ii. Quantidade direta de ponto flutuante

As quantidades diretas de ponto flutuante podem conter pontos decimais e usam o método tradicional de redação de números reais. Um número real consiste em uma parte inteira, um ponto decimal e uma parte decimal.

Além disso, o método de contagem exponencial também pode ser usado para representar quantidades diretas de ponto flutuante. Ou seja, o número real é seguido pela letra E ou E, seguida pelo sinal positivo e negativo e, em seguida, um expoente inteiro é adicionado. O valor numérico representado por esse método de contagem é uma potência exponencial do número real anterior multiplicado por 10.

Pode ser expresso em uma sintaxe mais concisa

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

[dígitos] [. dígitos] [(e | e) [(+|-)] dígitos]

3.14

2345.455

.333333333333333333333333333333333333

6.02E23 //6.02*10 para a 23ª potência

1.255454e-23 //1.255454*10 para a 23ª potência

Operação aritmética em iii.javascript

Os programas JavaScript usam operadores aritméticos fornecidos pela província de idiomas para executar operações numéricas. Esses operadores contêm + - * / e o restante (restante dividido) % operador %

Além dos operadores básicos, o JavaScript também suporta operações aritméticas mais complexas. Essa operação com complicação de linha é implementada por funções e constantes definidas como propriedades dos objetos de matemática.

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

Math.pow (2, 53) // => 9007199254740992 Document.Write (Math.pow (2,53))

Math.Round (.6) //=>1.0 Rodada

MATH.CEIL (.6) //=>1.0 Pesquisa ascendente

Math.floor (.6) //=>0.0 para baixo

Math.abs (-5) // => 5 Encontre o valor absoluto

Math.max (x, y, z) // retorna o valor máximo

Math.min (x, y, z) // retorna o valor mínimo

Math.random () // gerar um número pseudo-random maior que 0 e menor que 1

Math.pi // pi

Math.e // e: a base do logaritmo natural

Math.sqrt (3) // raiz quadrada

Math.pow (3, 1/3) // Raiz de cubo de 3 de 3

Math.sin (0) // Funções trigonométricas, bem como Math.Cos, Math.atan, etc.

Math.log (10) //=>2.302585092994046 Logaritmo natural com a base 10

Math.log (512) /math.ln2 // log de 512 com base 2

Math.log (100) /Math.ln10 // log de 100 com base 10

Math.Exp (3) // Power de três

As operações aritméticas no JavaScript não relatarão erros ao transbordar, subir ou divisíveis por zero. No entanto, o resultado da operação numérica excede o número que pode ser representado no JavaScript (Overflow), e o resultado é um valor especial de valor infinito (Infinty), que é expresso como infinir em JavaScript. Da mesma forma, quando o valor do número negativo excede o intervalo de números negativos que o JavaScript pode expressar, o resultado é o infinito negativo, que é expresso como -infinty no JavaScript. As propriedades comportamentais dos valores do infinito são consistentes com o que esperamos: o resultado de adição, subtração, multiplicação e divisão com base nelas é o infinito (preservando os sinais)

O subfluxo é uma situação que ocorre quando o resultado do cálculo está sem fio próximo a zero e é menor que o valor mínimo que o JavaScript pode representar. Quando um número negativo é submetido a fluxos, o JavaScript retorna um valor especial, "Zero negativo", que (zero negativo) é quase exatamente o mesmo que o zero normal. Os programadores JavaScript raramente usam zeros negativos.

JavaScript Predefinido Variáveis ​​Globais Infinaty e NAN para expressar valores não numéricos. No ECMASCIPT3, esses dois valores podem ser lidos e escritos. O ECMAScript5 corrigiu esse problema definindo-os como somente leitura. O valor do atributo definido pelo objeto Number no ECMASCIPT3 também é somente leitura, aqui estão alguns exemplos:

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

Infinito // inicialize uma variável legível/gravação para o infinito

Número.positive_infinity // mesmo valor, somente leitura

1/0 // Este é o mesmo valor

Número.max_value + 1 // O resultado do cálculo ainda é infinito

Número.negative_infinity // denota infinito negativo

-Infinidade

-1/0

-Number.max_value -1

Nan // Inicialize uma variável legível/gravação para NAN

Número.nan // mesmo valor, mas leitura apenas

0/0 // O resultado do cálculo ainda é NAN

Número.Min_Value/2 // Ocorreu o fluxo. O resultado calculado é 0

-Number.min_value/2 // Zero negativo

-1/infinito // zero negativo

-0 // zero negativo

Há um pouco de especial sobre valores não numéricos em JavaScript, que não são iguais a seres humanos e valores, incluindo eles mesmos. Em outras palavras, é impossível julgar se x é nan por x == nan. Em vez disso, x deve ser usado! = x para julgar que se e somente quando x for nan, o resultado da expressão é verdadeiro. A função ISNAN () é semelhante a isso. Se o parâmetro for nan ou um valor não numérico (como uma string e um objeto), ele retornará true. Existe uma função semelhante no JavaScript que isfinite (), que retorna verdadeiro quando os parâmetros não são NAN, Infinty ou -infinity.

O valor zero negativo também é um pouco especial. É igual a zero positivo e negativo (mesmo julgado usando o rigoroso teste de igualdade de JavaScript), o que significa que esses dois valores são quase exatamente os mesmos, exceto que excluir:

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

var zero = 0;

var negz = -0;

zero === negz // => valores zero positivos e negativos verdadeiros são iguais

1/zero === 1/negz // infinito falso positivo e infinito negativo são diferentes

iiii. Número do ponto flutuante binário e erro de arredondamento

Existem inúmeros números reais, mas o JavaScript pode representar apenas números finitos através da forma de números de ponto flutuante (para ser preciso, existem 18 437 736 874 454 810 627), ou seja, quando números reais são usados ​​no JavaScript, geralmente é apenas uma representação aproximada do valor real.

O JavaScript adota a notação do número de ponto flutuante IEEE-754 (usado por quase todas as linguagens de programação modernas). Esta é uma representação binária que pode representar com precisão frações, como 1/2 1/8 e 1/1024. Infelizmente, as frações que costumamos usar, especialmente em cálculos financeiros, são todos baseados em frações decimais 1/10, 1/100, etc. A notação binária não pode representar um número simples como 0,1.

Os números em JavaScript têm precisão suficiente. E pode estar perto de 0,1. Mas, de fato, a incapacidade de expressar com precisão os números traz alguns problemas.

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

var x = 0,3 - .2;

var y = .2 - .1;

alerta (x == y) // => false Os dois valores não são iguais

x == .1 // => false .3-.2 não é igual a .1

y == .1 // => true .2-.1 é igual a 1

Devido ao erro de arredondamento, a diferença aproximada entre 0,3 e 0,2 não é igual à diferença aproximada entre 0,2 e 0,1 (em ambientes reais de simulação, 0,3-0,2 = 0,099 999 999 999 999 999 999 98). Esse problema não está apenas presente no JavaScript, é muito importante entender o seguinte: esse problema ocorrerá em qualquer linguagem de programação que use números de ponto flutuante binário. Também é importante observar que os valores de x e y no código acima estão muito próximos um do outro e os valores corretos finais. Esse resultado de cálculo pode ser competente para a maioria das tarefas de cálculo. Esse problema ocorre apenas ao comparar se os dois valores são iguais.

As versões futuras do JavaScript podem suportar tipos numéricos decimais para evitar esse problema, antes que você prefira usar grandes números inteiros para cálculos financeiros importantes. Por exemplo, use "segmentos" inteiros em vez de "elementos" decimais para unidades monetárias.

iiiii.date e tempo

O núcleo do idioma JavaScript inclui o construtor date (), que originalmente criou objetos de data e hora. Os métodos desses objetos de data fornecem uma API simples para o cálculo da data. Os objetos de data não podem ser um tipo de dados básico, como números.

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

var zhen = nova data (2011, 0, 1); // 1 de janeiro de 2011

var mais tarde = nova data (2011, 0, 1, 17, 10, 30); // no mesmo dia

var agora = new Date (); // a data e hora atuais

var decised = agora - zhen; // Data Subtração. Calcule o número de milissegundos do intervalo de tempo

mais tarde.getlyear (); // => 2011

mais tarde.getmonth (); // => 0 meses contados de 0

mais tarde.getDate (); // => 1 O número de dias contado de 1

mais tarde.getday (); // => 5 Obtenha o dia da semana. 0 representa domingo, 5 representa domingo

mais tarde.gethours () // => horário local

mais tarde.getutchours () // use UTC para representar a hora da hora, com base no fuso horário.

2. Texto

Uma string é uma sequência imutável e ordenada de valores de 16 bits, cada caractere geralmente vem de um conjunto de caracteres Unicode. JavaScript representa o texto através de tipos de string. O comprimento de uma string é o número de valores de 16 bits que ele contém. O índice de uma string javascript (e sua matriz) começa em 0. O comprimento da sequência vazia é 0 e não existe "tipo de caractere" representando um único caractere no JavaScript. Para representar um valor de 16 bits, basta atribuí-lo a uma variável de sequência. O comprimento desta string é 1.

Conjunto de caracteres, código interno e string javascript

O JavaScript usa um conjunto de caracteres unicode codificado por UTF-16, e uma sequência JavaScript é uma sequência composta por um conjunto de valores não ordenados de 16 bits. Os caracteres Unicode mais usados ​​são representados por códigos internos de 16 bits e representam um único caractere na sequência. Os caracteres Unicode que não podem ser representados como 16 bits são seguidos pelas regras de codificação UTF-16-usando dois valores de 16 bits para formar uma sequência (também conhecida como "pares de proxy"). Isso significa que uma sequência JavaScript de comprimento 2 (dois valores de 16 bits) pode representar um caractere unicode.

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

var p = "π"; // π é representado por código interno de 16 bits 0x03c0

var e = "e"; // e é representado pelo código interno de 17 bits 0x1d452

p.length // => 1 p contém um valor de 16 bits

E.Length // => 2 E codificado por UTF-16 contém dois valores: "/ud835/udc52"

Todos os métodos de operação de string definidos pelo JavaScript agem em valores de 16 bits, não caracteres, e não processam o item de proxy separadamente. Da mesma forma, o JavaScript não padronizará o processamento de string. Não há garantia de que as strings sejam o formato Legal UTF-16

I String Quantidade direta

Uma quantidade direta de strings em um programa JavaScript é uma sequência de caracteres cercados por citações únicas ou cotações duplas. Uma string delimitada por citações únicas pode conter cotações duplas, e uma string delimitada por citações duplas também pode conter citações únicas. Aqui estão alguns exemplos de quantificação direta de cordas.

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

"" // string vazia, 0 caracteres

'Teste'

"3.14"

'nome = "myform"'

"Você não prefere o livro de O'Reily?"

No ECMAScript3, a quantidade direta da string deve ser gravada em uma linha, enquanto no ECMAScript5, a quantidade direta da string pode ser dividida em várias linhas e cada linha deve terminar com uma barra de barragem (/). Nem a barragem nem o caractere final da linha são o conteúdo da quantidade direta da string. Se você quiser estar juntos, pode usar /n para escapar dos caracteres.

Deve -se notar que, ao usar citações únicas para delimitar strings, você precisa ter cuidado com as abreviações e todos os formatos em inglês. Apostróficos ingleses e citações únicas são o mesmo personagem, portanto, as barris (/) devem ser usadas para escapar.

ii caracteres de escape

Nas cordas JavaScript, as barras (/) têm um objetivo especial. Adicionar um personagem às barras -barras não representará mais seu significado literal. Por exemplo, /n é um caractere de fuga, que representa uma nova linha.

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

/o // NUL caracteres

/b // caractere backspace

/T // Personagem da guia horizontal

/n // personagem de linha de linha

/v // caractere vertical da guia

/f // Renovação da página

/r // Caractere de retorno de carruagem

/"// Citações duplas

// barra de barriga

/xxx Latin-1 caractere especificado por hexadecimal de dois bits

/xxxxxxx UNICODE caractere especificado por quatro bits hexadecimal xxxxx

Uso de string iii

Um dos recursos internos do JavaScript é a concatenação de string. Use o operador + para strings para representar a concatenação da string. Por exemplo

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

var msg = "Hello" + "World"; // Gere a string Hello World

Para determinar o comprimento de uma string - o número de valores de 16 bits que ele contém, você pode usar o atributo de comprimento, como o comprimento da string s.

S. Length

Além do atributo de comprimento, as cadeias também fornecem muitos métodos que podem ser chamados.

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

var s = "Olá, mundo";

S.Charat (0); // "h" primeiro personagem

S.Charat (S.Length - 1) // "d" Último caractere

S.Substring (1, 4) // "ell" 2-4 caracteres

s.slice (1, 4) // ell o mesmo que acima

s.slice (-3) // os últimos 3 caracteres aparecem

S.IndexOF (L ") // 2 caracteres l A primeira posição de ocorrência

S.LastIndexOf ("l") // 10 A última vez que o personagem l aparece

S.IndexOF ("L", 3) // Após a posição 3, a primeira posição onde o personagem L aparece

S.Split (",") // => ["Hello", "World"] é separado em substringas

S.Replace ("H", "H") // => "Hllo, World" TEXTO DE TEXTO SUBLICIPAÇÃO

S.ToupPercase () // => "Olá, mundo"

No JavaScript, as cordas são fixas e inalteradas. Métodos como substituir () e touppercase () retornam novas strings, e os próprios caracteres originais não mudaram.

No ECMAScript, os caracteres podem ser tratados como matrizes somente leitura. Além de usar o método Charat (), os suportes quadrados também podem ser usados ​​para acessar caracteres individuais em uma string. (Valor de 16 bits)

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

s = "Olá, mundo"

s [0] // => "h"

s [s.Length-1] // => "D"

A Foxfire suportou a indexação de string para esse método há muito tempo, e a maioria dos navegadores modernos (exceto o IE) seguiu os passos de Mozailla e concluiu esse recurso antes que o ECMAScript fosse formado.

IIII MATISTRO DE PADRÃO

JavaScript define o construtor regexp (), usado para criar objetos que representam correspondência de padrões de texto. Esses padrões são chamados de "expressões regulares", sintaxe de expressão regular no JavaScript Perl. Os objetos String e Regexp definem funções que usam expressões regulares para corresponder aos padrões, encontre e substitua.

O objeto regexp não é um tipo de dados básico no idioma. Como data, é apenas um objeto especial com uma API prática. Expressões regulares têm sintaxe complexa e APIs ricas. Ele será introduzido em detalhes no Capítulo 10. O REGEXP é uma ferramenta de processamento de texto poderosa e comumente usada, e aqui está apenas uma visão geral.

Embora o regexp não seja um tipo de dados básico no idioma, eles ainda têm quantidades diretas e podem ser usadas diretamente no JavaScript. O texto entre duas barras forma uma quantidade direta de uma expressão regular. A segunda barra também pode seguir uma ou mais letras. Usado para modificar o significado do padrão de correspondência. Por exemplo:

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

/^Html/// corresponde a strings começando com html

/[1-9] [0-9]*/// corresponde a um número diferente de zero, seguido por qualquer número

// bjavascript/b/i/// corresponde à palavra JavaScript e ignore a caixa superior e inferior

O objeto Regexp define muitos métodos úteis e as seqüências de caracteres também possuem métodos que podem aceitar parâmetros REGEXP. Por exemplo:

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

var text = "Teste: 1,2,3"; // Exemplo de texto

var padrão = // d+/g // corresponde a todas as instâncias que contêm um ou mais números

Pattern.test (texto) // => true: a correspondência é bem -sucedida

text.search (padrão) // => 9: a posição em que a primeira partida foi bem -sucedida

text.match (padrão) // => ["1", "2", "3"] Todos os correspondências formam uma matriz

text.Repeat (Pattern, "#"); // => "Teste:#,#,#"

text.split (// d+/); // => ["", "1", "2", "3"]: use caracteres não numéricos para interceptar strings

3. Valor booleano

Os valores booleanos se referem a verdadeiro ou falso, ligado ou desligado. Esse tipo tem apenas dois valores e a palavra verdadeira ou falsa é reservada.

Os resultados das declarações de comparação em JavaScript são geralmente valores booleanos. Por exemplo

a == 4

Este código é usado para detectar se o valor de uma da variável é igual a 4. Se for igual, o valor será verdadeiro, se o valor não for igual

Os valores booleanos são geralmente usados ​​nas instruções de controle de JavaScript, como as instruções IF/else em JavaScript. Se o valor booleano for verdadeiro, execute a primeira peça de lógica e se outro pedaço de código for falso, p.

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

se (a == 4)

b = b + 1;

outro

a = a + 1;

Qualquer valor de JavaScript pode ser convertido em valores booleanos, e os seguintes valores são convertidos para falsos

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

indefinido

nulo

0

-0

Nan

"" // string vazia

Todos os outros valores, incluindo todos os objetos (matrizes), serão convertidos em verdadeiros, falsos e os 6 valores acima que podem ser convertidos em falsos são chamados de "valores falsos". O JavaScript espera que, ao usar um valor booleano, o valor falso seja tratado como falso e o valor verdadeiro será tratado como verdadeiro.

Vamos dar uma olhada em um exemplo. Adicionando a variável O é um objeto ou nulo, você pode usar uma instrução IF para detectar se O é um valor não nulo.

if (o! == NULL) ...

O operador desigual "! ==" compara o e nulo e fornece o resultado verdadeiro ou falso. Você pode primeiro ignorar a declaração de comparação aqui. NULL é um valor falso e o objeto é um valor verdadeiro.

se (o) ...

Para o primeiro caso, o código após se for executado somente quando O não for nulo, e as limitações do segundo caso não são tão rigorosas. Isso se for executado apenas se O não for falso ou qualquer valor falso (como nulo ou sem ser coberto).

O booleano contém o método tostring (), para que você possa usar esse método para converter uma sequência para "verdadeiro" ou "false", mas não contém outros métodos úteis e, além dessa API sem importância, existem três operadores booleanos importantes.

Operador && || operador e operador unário "!" Realize uma operação booleana não (não). Se o verdadeiro valor retornar false, o valor falso retornará verdadeiro, por exemplo

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

if ((x == 0 && y == 0) ||! (z == 0)) {

// x e y são zero ou z são diferentes de zero

}

4.nula e indefinida

Null é uma palavra -chave no idioma JavaScript. Representa um valor especial "valor nulo". Para NULL, ele executa a operação typeof () e retorna objeto. Ou seja, o NULL pode ser considerado um valor de objeto especial, que significa "não-objeto". Mas, de fato, o NULL é geralmente considerado o único membro de seu tipo livre. Pode representar que números, cordas e objetos são "sem valor". A maioria das linguagens de programação contém nulo como JavaScript, e você pode estar familiarizado com o NULL ou NIL.

O JavaScript também possui um segundo valor indicando a vaga do valor. Usado para representar "valores nulos" mais profundos. É um valor de uma variável. Indica que a variável não foi inicializada. Se você deseja consultar o valor de um atributo de objeto ou elemento da matriz, ele retorna indefinido, significa que o atributo ou elemento não existe. Indefinido é uma variável global predefinida (é diferente de NULL, não é uma palavra -chave) e seu valor é indefinido. Se você usar o tipoof para testar o tipo indefinido, "indefinido" será retornado, indicando que o valor é o único membro do tipo.

Embora nulos e indefinidos sejam diferentes, ambos representam "vagas de valores" e os dois são frequentemente intercambiáveis. O operador que julga a igualdade "==" pensa que os dois são iguais (use o operador estrito da igualdade "===" para distingui -los). Onde o valor deve ser do tipo booleano, seus valores são todos falsos. Semelhante ao falso. Nulos e indefinidos não contêm propriedades e métodos. De fato, usando "". e "[]" para acessar membros ou métodos desses dois valores produzirão um erro de tipo.

Você pode pensar que indefinidas representa vagas de valores incorretos no nível do sistema, no nível do sistema, enquanto Null representa vagas de valores em nível de programa, normais ou esperadas. Se você deseja copiá -los para variáveis ​​ou propriedades ou passá -las como parâmetros em uma função, o NULL é a melhor opção.

5. Objetos globais

As seções anteriores discutem os tipos de elementos e os valores originais do JavaScript. Tipos de objetos - objetos, matrizes e funções / Mas há uma classe muito importante de objetos que não devem ficar claros agora: objetos globais

Objeto global tem usos importantes no JavaScript. As propriedades de um objeto global são símbolos definidos globalmente. Os programas JavaScript podem ser usados ​​diretamente. Quando o intérprete JavaScript inicia, ele cria um novo objeto global e fornece um conjunto de propriedades iniciais definidas.

Propriedades globais, como Infinided Infinty e Nan

Funções globais como isnan (), parseint () e avaliar ()

Construtores como Date (), Regexp (), String (), Object () e Array ()

Objetos globais, como matemática e json

O atributo inicial de um objeto global não é uma palavra reservada, mas eles devem ser tratados como uma palavra reservada.

No nível superior do código - código JavaScript não dentro de nenhuma função, você pode consultar o objeto global através da palavra -chave JavaScript.

var global = this; // Defina uma variável global que referencia um objeto global.

No JavaScript do cliente, o objeto da janela atua como um objeto global. Este objeto de janela global tem uma referência familiar de janela. Ele pode substituir isso para se referir ao objeto global. O Windows define atributos globais do núcleo. No entanto, alguns outros atributos globais são definidos para navegadores da Web e JavaScript interativo.

Quando criado pela primeira vez, o objeto global define todos os valores globais predefinidos no JavaScript, e esse objeto especial também contém os valores globais definidos para o programa. Se o código declarar uma variável global. Essa variável global é um atributo do objeto global.

6. Objeto de embalagem

Um objeto JavaScript é um valor composto: é uma coleção de atributos ou valores nomeados. O valor do atributo é referenciado através de "". Quando o valor do atributo é uma função, é um método e usa Om () para transferir os métodos no objeto o.

Vemos que as cordas também têm propriedades e métodos.

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

var s = "Hello World";

var word = s.substring (s.indexOF ("")+1, s.length); // use os atributos da string.

Document.Write (Word) // "Ello World"

Como uma string não é um objeto, por que possui propriedades? Enquanto o atributo da String S for referenciado, o JavaScript converterá o valor da string em um objeto chamando a nova (s) string (s), que herda o método da string. e é usado para processar referências de atributo. Uma vez que o novo atributo seja referenciado. Depois que a referência terminar, o objeto recém -criado será destruído. (Este objeto temporário não é necessariamente necessariamente cria ou destrua, mas esse processo se parece com esse.)

Como strings, números e valores booleanos também têm seus próprios métodos, criando um objeto temporário através dos construtores Número () e Boolean (). Todos esses métodos são chamados deste objeto temporário. (NULL e indefinido não foram embrulhados, o acesso às suas propriedades terá um erro de tipo)

Veja o código a seguir e pense sobre o processo de execução deles

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

var s = "teste";

s.len = 4; // Defina uma propriedade para isso

var t = s.len // encontre esta propriedade

Ao executar esse código, o valor de t é indefinido. A segunda linha de código cria um objeto de string temporário e fornece um valor de 4. O objeto é então destruído. A terceira linha usa a string original (não modificada) para criar um novo objeto String e tenta ler os atributos de Len.

Esta propriedade não existe naturalmente, indicando que o resultado é indefinido. Este código mostra que, ao ler os valores (ou métodos) da propriedade de strings, matrizes e valores booleanos, ele se comporta como um objeto, mas se você tentar atribuir um valor à sua propriedade. Esta operação será ignorada; A modificação acontece apenas com objetos temporários. Este objeto temporário não foi retido.

Deve -se notar que a criação de objetos de invólucro pode ser exibida através dos construtores String (), número () e boolean ():

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

var s = "teste",

n = 1,

b = true;

var s = nova (s) string (s);

var n = novo número (n);

var b = novo booleano (b);

O JavaScript converte o invólucro no valor original quando necessário; portanto, o objeto SNB no código anterior com frequência - mas nem sempre - representa o mesmo valor que Snb, "==" igual ao operador trata o valor original e seu objeto de wrapper como igual.

Mas o operador completo "===" os trata como desigualdade e a diferença entre o valor original e o objeto que ele envolve pode ser visto através do operador TIPEOF.

7. Valores originais imutáveis ​​e referências de objetos mutáveis.

O valor original do JavaScript (números e strings nulos indefinidos) é fundamentalmente diferente dos objetos (incluindo matrizes e funções). O valor original é imutável; Nenhum método pode (ou mutar) um valor primitivo. Obviamente, é verdade para números e booleanos - alterar o valor de um número não faz sentido em si, mas não é tão óbvio para as cordas, porque as cordas parecem ser uma variedade de caracteres. Esperamos que os caracteres na string possam ser modificados pelo índice especificado. De fato, o JavaScript proíbe fazer isso. Todos os métodos na sequência parecem retornar uma string modificada, que é na verdade uma nova string.

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

var s = "Hello World";

S.ToupPercase (); // retorna "Hello World" e não muda o valor de s

s // => "Hello World" String original não mudou

原始值的比较是值的比较，只有在他们的值相当时它们在才相等。这对数字、布尔值、null和undefined来说听起来有点难，并没有其他办法来比较他们。同样，对于字符串来说则不那么明显；如果比较两个单独的字符串，当且仅当他们的长度相等且每个索引的字符都相等时，javascript的才认为相等。

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

var o = {x:1} //定义一个对象

ox = 2 //通过修改对象的属性来改变对象

oy = 3 //再次更改这个对象，给它增加一个新属性

var a =[1,2,3] //数组也是可以修改的

a[0]=0; //更改数组中的一个元素

a[3]=4; 给数组增加一个新元素

对象的比较并非值的比较：即使两个对象包含同样的属性及相同的值，他们也是不相等的，各个索引元素完全相等的两个数组也不相等

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

var o ={x:1}, p={x:1}//两个具有相同属性的两个对象

o === p ;//=>false 两个单独的对象永不相等( o == p ; =>false)

var a =[],b=[]; //两个单独的空数组

a === b ; //=>false两个单独的数组永不相等

我们通常将对象称为引用类型(reference type),以此来和javascript的基本类型区分开来。依照术语的叫法，对象都是引用(reference),对象的比较均是引用的比较；当且当它们应用同一个基对象时，它们才相等。

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

var a = []; //定义一个引用空数组的变量a

var b = a; //变量b引用同一个数组

b[0] = 1;

a[0] //=>1 变量a也会修改

a === b //=>true a和b引用同一个数组，因此他们相等。

就像你刚才看到的如上代码，将对象（或数组）赋值给一个变量，仅仅是赋值的引用值：对象本身并没有复制一次。

如果你想得到一个对象或数组的副本，则必须显式复制对象的每个属性或数组的每个元素。下面的这个例子则是通过循环来完成对数组的复制。

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

var a = ['a', 'b', 'c']; //待复制的数组

var b = []; //复制到目标的空数组

for (var i = 0; i < a.length; i++) { //遍历a[]中的每个元素

b[i] = a[i]; //将元素复制到b中。

}

同样的，如果我们想比较两个单独或者数组，则必须比较他们的属性或元素。下面这段代码定义了一个比较练个数组的函数。

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

function equalArrays(a, b) {

if (a.length != b.length) return false; //两个长度不相同的数组不相等

for (var i = 0; i < a.length; i++) //循环遍历所有元素

if (a[i] !== b[i]) return false; //如果有任意元素不等，则数组不相等

retornar true; // Otherwise they are equal

}

8.类型转化

javascript中的取值型非常灵活，我们已经从布尔值看到了这一点：当javascript期望使用一个布尔值时候，你可以提供任意类型值。javascript将根据需要自行转换类型。一些值（真值）为true，其它值（假值）转化为false.这在其它类型中同样适用。如果javascript期望使用一个字符串，它把给定的值转换为字符串。如果javascript期望使用一个数组，它把给定的值转换为数字（如果转化结果无意义的话将返回NaN）,一些例子如下：

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

10 + "object" //=> "10object";

"7" * "4" // =>28 两个字符串均转化为数字

var n = 1 - "x" // =>NaN字符串x无法转换为数字

n + " objects" // =>"NaN objects":NaN转换为字符串"NaN"

下表说明了在javascript中如何进行类型转化。粗体突出了那些让你倍感意外的类型转化。空单元格表示不必要也没有执行的转换。

上表提到的原始值到原始值的转换行对简单，我们已经在第本文第三小节讨论过转换为布尔值的情况了。所有原始值转换为字符串的情形也已经明确定义。转换为数字的情形比较微妙。那些以数字表示的字符串可以直接转化为数字，也允许在开始和结尾处带有空格。但在开始和结尾处的任意非空字符都不会被当成数字量的一部分，进而造成字符串为数字的结果为NaN。有一些数字转换看起来让人奇怪：true转换为1，false、空字符串""转换为0.

原始值到对象的转换也非常简单，原始值通过调用String()，Number()或Boolean()构造函数，转化为它们各自的包装对象。见本文第6节。

null和undefined属于例外，当将它们用在期望是一个对象的地方都会造成一个类型错误(TypeError)异常。而不会执行正常的转换。

对象到原始值的转换多少有些复杂，本小节第三小节有专门描述。

eu. Conversion and Equality

由于javascript可以做灵活的类型转换，因此其“==”相等运算符也随相等的含义灵活多变。例如：如下这些比较结果均是true；

null == undefined //这两值被认为相等

"0" == 0 //在比较之前，字符串转换成数字。

0 = false //在这之前布尔值转换成数字。

"0" ==false //在比较之前字符串和布尔值都转换成数字

在第四章9节第一小节相信讲解了“==”等于运算符在判断两个值是否相等时做了那些类型转换，并同样介绍了“===”恒等运算符在判断相等时并未做任何的类型转换。

需要特别注意的是：一个值转换为另一个值并不意味着两个值相等。比如在期望使用布尔值的地方使用了undefined，将会转换为false，但这不表明undefined==false。javascript运算符和语句期望使用多样化的数据类型，并可以互相转换。if语句将undefined转化为false,但“==”运算符从不试图将其转化为布尔值。

ii.显式类型转化

尽管javascript可以做做很多类型转换，但有时仍需要做显式转换，或者为了使代码变得清晰易读而做显式转换。

做显式转换最重简单的方法就是使用Boolean()、Number()、String()或Object函数。我们在本文第6节已经介绍过了. 当不通过new运算符调运这些函数时，他们会作为类型转换函数并按照上边表格所描述的规则做类型转换。

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

Number("3") //=>3

String(false) //=>"false"或使用false.toString()

Boolean([]) //=>true

Object(3) // =>new Number(3)

需要注意的是，除了null或undefined之外的任何值都具有toString()方法，在这个方法的执行结果通常和String()方法返回的结果一致。同样需要注意的话，如果试图把null或undefined转化为对象。则会抛出一个类型错误typeerro。Object()函数在这种情况下不会抛出异常：它仅简单返回一个新创建的空对象。

javascript中的某些运算符会做隐式的类型转换，有时用于类型转换。如果“+”运算符的一个操作数是字符串，它将会把令一个操作数转换为字符串。一元“+”运算符将其操作数转换为数字。同样，一元“！”运算符将其操作数转换为布尔值取反，在代码中常会看到这种类型转换的惯用法。

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

x + "" // 等于字符串String(x)

+x //等价于Number(x),也可以写成x-0

!!x //等价于Boolean(x)

在计算机中数字的解析和格式化代码是非常普通的工作。javascript中提供了专门的函数和方法用来更加精确的数字到字符串（number-to-string）和字符串到数字(string-to-number)的抓换。

Nmuber类定义的toString()方法可以接收表示基数（二进制，八进制，十六进制等）的可选参数，如果不指定该参数，转化规则将是十进制。同样也可以将数字转换为其它进制数。（范围在2-36之间）

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

var n = 17;

b_string = n.toString(2); //转化为10001

o_string = "0" + n.toString(8); //转化为八进制021

hex_string = "0x" + n.toString(16); //转化为16进制0x11

javascript为控制输出中小数点位置和有效数字位数，或者决定是否需要指定指数计数法。Number类为这种数字到字符串定义了三个方法。

toFixed()根据小数点后指定位数，将数字转换为字符串，它从不使用指数计数法。toExponential()使用指数计数法，将数字转换为指数形式的字符串，其中小数点前只有一位，小数点后的位置则由参数指定（也就是说有效数字位数要比指定的位数多一位）。toPrecision()根据指定的有效数字位数，将数字转换为字符串。如果有效数字的位数小于数字整数部分的位数，则转换成指数形式。我们注意到，三个方法都会适当的进行四舍五入或填充0,

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

var n = 123456.789;

n.toFixed(0); //"123457"

n.toFixed(2); //"123456.79"

n.toFixed(5); //"123456.78900"

n.toExponential(1); //"1.2e+5"

n.toExponential(3); //"1.235e+5"

n.toPrecision(4); // "1.235e+5"

n.toPrecision(7); //"123456.8"

n.toPrecision(10); //"123456.7890"

如果通过Number()转换函数传入一个字符串，它会试图将其转化为一个整数或浮点数直接量，这个方法只能基于十进制进行转换，并且不能出现非法的尾随字符。parseInt()和parseFloat()函数（它们是全局函数，不属于人和类的方法），更加灵活。parseInt()只解析整数。而parseFloat()则可以解析整数和浮点数。如果字符串前边是0x或0X,parseInt()将其解析为16进制数。两个方法都会跳过任意量的前导空格，尽可能解析更多数值字符。并忽略后边的内容。如果第一个是非法的数字直接量，则返回NaN

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

parseInt("3many nice") //=>3;

parseFloat("3.14meters") //=>3.14

parseInt("-12.34") //=>-12

parseInt("0xff") //=>255

parseInt("-0XFF") //=>-255

parseFloat(".1") // =>0.1

parseInt("0.1") //=> 0

parseInt(".1") //=>NaN 不能以.开始

parseInt("$112") //=>NaN 不能以$开头

parseInt()可以接收第二个可选参数。这个参数指定数字转换的基数。合法的取值范围是2-36

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

parseInt("11", 2) //=>3(1*2+1)

parseInt("ff", 16) //=> 255(15*16 +15)

parseInt("zz", 36) //=>1295(35*36+35)

parseInt("077", 8) // 63(7*8 +7)

parseInt("077", 10) //77(7*10+7)

iii.对象转化为原始值。

对象到布尔值的转换非常简单：所有的对象（包括数组和函数）都转换为true。对于包装对象亦是如此，new Boolean(false)是一个对象而不是原始值，它将转换为true。 对象到字符串（object-to-String）和对象到数字(object-to-number)的转换是通过调用带转换对象的一个方法来完成的。一个麻烦的事实是，javascript对象有两个不同的方法来执行转换，并且接下来要讨论并且接下来要讨论的场景更加复杂。值得注意的是，这里提到的字符串和数字的转换规则只适用于本地对象（native fangf object）.宿主对象(例如：由web浏览器定义的对象)，根据各自的算法可以转换成字符串和数字。

所有的对象继承了两个转换方法。第一个是toString(), 它的作用是返回一个反映这个对象的字符串。默认的toString()方法并不会返回一个有趣的值。

({x:1,y:2}).toString() //=>"[object object]"

很多类定义了更多特定版本的toString()方法.

例如：数组类(Array class)的toString()方法将每个数组元素转换为一个字符串，并在元素之间添加逗号后并合成结果字符串。

函数类(Function class)的toString()方法返回这个函数的实现定义的表示方式。实际上，这里的实现方式是通常是将用户定义函数转换为javascript源代码字符串。

日期类(Date class)定义toString()方法返回一个可读的（可被javascript-parsable解析的）日期和事件字符串

RegExp class定义的toString()方法将RegExp对象转换为正则表达式直接量字符串。

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

[1, 2, 3].toString(); //=> "1,2,3"

(function(x) {f(x);}).toString(); // =>"function(x){/nf(x); /n}"

//d+/g.toString(); //=> ///d+/g

new Date(2015, 0, 1).toString() //=>Thu Jan 01 2015 00:00:00 GMT+0800 (中国标准时间)

另外一个函数是valueOf(),这个方法的任务并未详细定义：如果存在任意原始值，它就默认将对象转换为表示它的原始值。对象是复合值，而且大多数对象无法真正表示一个原始值，数组、函数和正则表达式简单地继承了这个默认方法，调用这些类型的实例的的valueOf()方法简单地返回对象本身。日期类定义的valueOf()方法返回它的一个内部表示：1970年1月1日以来的毫秒数。

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

var d = new Date(2015, 0, 1); //=>Thu Jan 01 2015 00:00:00 GMT+0800 (中国标准时间)

d.valueOf() //=>1420041600000

通过是用我们刚才讲解过的toString()和valueOf()方法，就可以做到对象到字符串和对象到数字的转换了。但在某些场景中，javascript执行了完全不同的对象到原始值的转换。这些特殊的场景在本节的最后会讲到。

javascript对象到字符串的转换经过了如下这些步奏

如果对象具有toString()方法，则调用这个方法。如果它返回一个原始值，javascript将这个值转换为字符串（如果本身不是字符串的话），并返回这个字符串结果。

如果对象没toString()方法，或者这个方法并不返回一个原始值，那么javascript会调用valueOf()方法。如果存在这个方法，则javascript调用它。如果返回值是原始值，javascript将责怪值转换为字符串。

9.变量声明。

在javascript程序中，使用一个变量之前应该先声明，变量是通过var来声明的，如下所示：

var i;

var sum;

也可以通过一个var关键字声明多个变量

var i,sun;

而且还可以将变量的初始值和变量声明和写在一起；

var message = "hello";

var i=0 ,j=0,k=0;

If the variable is specified in the var declaration statement, even though the variable is declared, its initial value is undefined before storing it a value. We noticed that the var statement can also be used in the for and fo/in loops, which can more concisely declare the loop variables used in the loop body syntax. Por exemplo:

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

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

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

for (var p in o) console.log(p);

If the variable is specified in the var declaration statement, even though the variable is declared, its initial value is undefined before storing it a value. We noticed that the var statement can also be used in the for and fo/in loops, which can more concisely declare the loop variables used in the loop body syntax. Por exemplo:

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

var i=10;

i="ten";

10.变量作用域

一个变量的左右域（scope）是程序源代码中定义这个变量的区域，全局变量拥有全局作用域，在javascript代码中的任何地方都是定义。然而在函数内部声明变量只在函数体内有定义。他们是局部变量，作用是局部性的。函数参数也是局部变量，它们只在函数体内有定义。

在函数体内，局部变量的优先级高于同名的全局变量。如果在函数内声明一个局部变量或者函数参数中带有的变量和全局变量重名，那么全局变量就被局部变量所遮盖。

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

var scope = "global"; //声明一个全局变量

function checkscope() {

var scope = "local"; //声明一个同名的局部变量

return scope;

}

checkscope(); //=>"local"

尽管在全局作用域编写代码时可以不写var语句，但声明局部变量时则必须使用var语句。

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

scope = "global"; //声明一个全局变量,甚至不使用var来声明

function checkscope2() {

scope = "local"; //修改了全局变量

myscope = "local"; //这里显示式得声明了一个新的全局变量

return [scope, myscope]; //

}

checkscope2(); //=> ["local","local"]:产生了副作用

scope // =>"local"全局变量修改了

myscope //=> "local"全局命名空间搞乱了。

函数定义是可以嵌套的。由于每个函数都有它直接的作用域，因此会出现几个局部作用域嵌套的情况。

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

var scope = "global scope"; //全局变量

function checkscope() {

var scope = "local scope"; //局部变量

function nested() {

var scope = "sested scope"; //嵌套作用域内的局部变量

return scope;

}

return nested();

}

checkscope() //=>"嵌套作用域" sested scope

eu. Function scope and declaration in advance

在一些类似c语言的编程语言中，花括号内的每一段代码都具有各自的左右域，而且变量在声明他们的代码之外是不可见的我们称之为块级作用域(block scope),而javascript中没有块级作用域，javascript取而代之的使用了函数作用域(function scope);变量在声明它们的函数体以及这个函数体嵌套的任意函数体内都是有意义的。

如下代码，在不同的位置定义了ijk，他们都在同一个作用域内，这三个变量在函数体内均有定义的。

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

function test(o) {

var i = 0; //i在整个函数体内均是定义的

if (typeif o == "object") {

var j = 0; //j在函数体内是有定义的，不仅仅是在这个代码段内

for (var k = 0; k < 10; k++) { //k在函数体内是有定义的，不仅仅是在循环内

console.log(k); //输出数字0-9

}

console.log(k); //k已经定义，输出10

}

console.log(j); //j已经定义了，但可能没有初始化。

}

javascript的函数作用域是指在函数内声明的所有变量在函数体内始终是可见的。有意思的是，这意味这变量在声明之前甚至已经可用。javascript的这个特性被非正式的称为声明提前（hoisting），即javascript函数里声明的所有变量(但不涉及赋值)都被提前至函数整体的顶部。如下代码：

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

var scope = "global";

function f() {

console.log (escopo); //Output "undefined", not "global"

var scope = "local"; //变量在这里赋初始值，但变量本身在函数体内任何地方都是有定义的

console.log (escopo); //Output "local"

你可能误以为函数的第一行会输出"global",因为代码还没有执行到var语句声明局部变量的地方。其实不然，由于函数作用域的特性模具部变量在整个函数体内始终有定义的，也就是说，在函数体内局部变量覆盖了同名全局变量。尽管如此，只有在程序执行到var语句的时候，局部变量才能正真的被赋值。

因此，上述的过程等价于：将函数内的变量声明"提前"至函数顶部，同时变量初始化留在原来的位置：

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

function f() {

var scope; //在函数的顶部声明了局部变量

console.log (escopo); //The variable exists, but its value is "undefined"

scope = "local"; //在这里将其初始化，并赋值

console.log (escopo); //Here it has the value we expect

}

在具有块级作用域的编程语言中，在狭小的作用域里让变量声明和使用变量的代码尽可能靠近彼此，通常来说，这是一个非常不错的编程习惯。由于在javascript中没有块级作用域，因此一些程序员特意将变量声明放在函数体顶部，而不是将声明放在靠近使用变量之处。这种做法使得他们的源代码非常清晰地反映了真实的变量作用域。

ii作为属性的变量

当声明一个javascript全局变量时面试及上是定义了全局对象的一个属性。见本文第三节。

当使用var声明一个变量时，创建的这个属性是不可配置的。见第六章第7节。也就是说这个变量无法通过delete运算符删除。可能你已经注意到了，如果你没有使用严格模式并给一个未声明的变量赋值的话。javascript会自动创建一个全局变量。以这种方式创建变量是全局对象正常的可配置属性。可以删除它们。

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

var truevar = 1; //声明一耳光不可删除的全局变量

fakevar = 2; //创建全局对象的一个可删除的属性

this.fakevar2 = 3; //同上

delete truevar // =>false 变量并没有删除

delete fakevar //=>true 变量被删除

delete this.fakevar2 //=>true 变量被删除

javascript全局变量是全局对象的属性，这是在ECMAScript规范中强制规定的。对于局部变量则没有此规定，但我们可以想象得到，局部变量当做跟函数调用相关的某个对象的属性。ECMAScript3规范称对象为“调用对象”（call object）,ECMAScript5规定范称为“声明上下文对象”（declarative environment record）。javascript可以允许使用this关键字引用全局对象，却没有方法可以引用局部变量中存放的对象。这种存放局部变量的对象的特有性质，是一种对我们不可见的内部实现。然而，这些局部变量对象存在的观念是非常重要的。

iii作用域链

javascript是基于词法作用域的语言：通过阅读包含变量定义在内的舒航源码就能知道变量的作用域。

全局变量在程序中始终是都是有定义的。局部变量在声明它的函数体内以及其所嵌套的函数内始终是有定义的。