JavaScript PDF

David Flanagan
 JavaScript
Domine o JavaScript com o Guia de Referência
Completo e Definitivo.
Escrito por Bookey
Saiba mais sobre o resumo de JavaScript
Ouvir JavaScript Audiolivro
Sobre o livro
JavaScript, agora em sua sétima edição, é a referência
definitiva para desenvolvedores web e programadores que
desejam aproveitar todo o potencial do JavaScript. Com
atualizações substanciais que incluem novos conteúdos sobre
ECMAScript 2017 (ES8) e capítulos adicionais que exploram
recursos-chave da linguagem, este guia best-seller é perfeito
para desenvolvedores experientes que buscam aprofundar seu
entendimento da linguagem de programação da web, além
daqueles que desejam aprimorar suas habilidades existentes
em JavaScript.
Sobre o autor
David Flanagan é um autor respeitado e especialista na área de
programação de computadores, mais conhecido por suas obras
influentes sobre JavaScript e o ecossistema mais amplo do
desenvolvimento web. Com uma formação em engenharia de
software e uma paixão por ensinar, Flanagan escreveu vários
livros que servem como recursos essenciais para
programadores iniciantes e avançados. Seu estilo de escrita
claro e suas explicações detalhadas tornaram tópicos
complexos mais acessíveis, garantindo-lhe reconhecimento
como uma voz confiável na comunidade de tecnologia. Como
defensor de software e padrões de código aberto, Flanagan
continua a contribuir para o avanço das práticas de
programação, consolidando sua reputação como uma figura
fundamental no desenvolvimento das tecnologias web
modernas.
Lista de conteúdo do resumo
Capítulo 1 : Seção 1.1. Sintaxe

Capítulo 2 : Seção 1.3. Tipos de Dados

Capítulo 3 : Seção 1.4. Expressões e Operadores

Capítulo 4 : Seção 1.5. Instruções

Capítulo 5 : Seção 1.6. JavaScript Orientado a Objetos

Capítulo 6 : Seção 1.7. Expressões Regulares

Capítulo 7 : Seção 1.8. Versões do JavaScript

Capítulo 8 : Seção 2.1. JavaScript em HTML

Capítulo 9 : Seção 2.2. O Objeto Window

Capítulo 10 : Seção 2.3. O Objeto Documento

Capítulo 11 : Seção 2.4. O DOM Legado

Capítulo 12 : Seção 2.5. O W3C DOM

Capítulo 13 : Seção 2.6. DOM do IE 4

Capítulo 14 : Seção 2.7. DHTML: Programando Estilos CSS

Capítulo 15 : Seção 2.8. Eventos e Manipulação de Eventos

Capítulo 16 : Seção 2.9. Restrições de Segurança do

JavaScript

Capítulo 17 : Array

Capítulo 18 : Data

Capítulo 19 : Documento

Capítulo 20 : Elemento

Capítulo 21 : Evento

Capítulo 22 : Global

Capítulo 23 : Input

Capítulo 24 : Camada

Capítulo 25 : Link

Capítulo 26 : Math

Capítulo 27 : Navegador

Capítulo 28 : Nodo

Capítulo 29 : Número

Capítulo 30 : Objeto
Capítulo 31 : RegExp

Capítulo 32 : Select

Capítulo 33 : String

Capítulo 34 : Estilo

Capítulo 35 : Window
 Capítulo 1 Resumo : Seção 1.1. Sintaxe

Seção Descrição

1. Sintaxe A sintaxe do JavaScript é semelhante à do Java, o que ajuda programadores familiarizados com C, C++
ou Java a aprendê-la facilmente.

1.1 Sensibilidade a JavaScript diferencia maiúsculas de minúsculas, exigindo uma capitalização consistente para
Maiúsculas palavras-chave, variáveis e nomes de funções.

1.2 Espaços em Caracteres de espaço em branco são ignorados, permitindo formatação e indentação flexíveis para
Branco melhor legibilidade.

1.3 Ponto e As instruções normalmente terminam com ponto e vírgula, mas podem ser omitidas se seguidas por uma
Vírgula nova linha, com regras específicas sobre quebras de linha.

1.4 Comentários Suporta comentários no estilo C/C++: comentários de linha única com `//` e comentários de múltiplas
linhas com `/* ... */`.

1.5 Identificadores Identificadores podem incluir letras, dígitos, sublinhados (_) e cifrões ($), mas não podem começar com
um dígito.

1.6 Palavras-chave Palavras-chave reservadas incluem aquelas com significados especiais, como break, if, return, etc.
Palavras-chave para uso futuro também estão listadas.

1. Sintaxe

A sintaxe do JavaScript se assemelha bastante à de Java, que

é derivado de C e C++. Essa familiaridade facilita para
programadores com experiência em C, C++ ou Java
aprenderem JavaScript.

1.1 Sensibilidade a Maiúsculas

JavaScript é sensível a maiúsculas. Todas as palavras-chave

estão em letras minúsculas, e é essencial manter uma
capitalização consistente para variáveis, nomes de funções e
identificadores.

1.2 Espaços em Branco

Caracteres de espaço em branco, como espaços, tabulações e

quebras de linha, são ignorados pelo JavaScript, permitindo
uma formatação e indentação flexíveis no código para
melhorar a legibilidade.

1.3 Ponto e Vírgula

As instruções em JavaScript normalmente são finalizadas por

ponto e vírgula. No entanto, quando seguidas por uma quebra
de linha, os ponto e vírgula podem ser omitidos, com
restrições sobre onde as instruções podem ser divididas entre
linhas.
1.4 Comentários

O JavaScript permite comentários no estilo C e C++:

- Comentários de uma linha começam com `//`.
- Comentários de várias linhas estão entre `/*` e `*/`.

1.5 Identificadores

Identificadores em JavaScript podem incluir letras, dígitos,

sublinhados (_) e cifrões ($). O primeiro caractere não pode
ser um dígito. Exemplos de identificadores válidos incluem:
-i
- meu_nome_variavel
- v13
- $str

1.6 Palavras-Chave

O JavaScript possui um conjunto de palavras-chave

reservadas que têm significado especial e não podem ser
usadas como identificadores:
- Palavras-chave comuns: break, do, if, switch, typeof, case,
else, in, this, var, catch, false, instanceof, throw, void,
continue, finally, new, true, while, default, for, null, try, with,
delete, function, return.
- Palavras reservadas adicionais para uso futuro incluem:
abstract, enum, int, short, boolean, export, interface, static,
byte, extends, long, super, char, final, native, synchronized,
class, float, package, throws, const, goto, private, transient,
debugger, implements, protected, volatile, double, import,
public.
Os desenvolvedores também devem evitar nomear variáveis
após propriedades e funções globais e não devem usar
`arguments` como nome de uma variável local.
Exemplo
Ponto chave:Sensibilidade a Maiúsculas e
Minúsculas em JavaScript
Exemplo:Em JavaScript, nomes de variáveis como
'myVariable' e 'myvariable' são completamente
diferentes; lembre-se disso para evitar erros.
Pensamento crítico
Ponto chave:A familiaridade da sintaxe do
JavaScript com C, C++ e Java é uma simplificação
excessiva.
Interpretação crítica:Embora seja verdade que a sintaxe
do JavaScript compartilha semelhanças com essas
linguagens, insinuar que isso torna o JavaScript mais
fácil para todos os programadores ignora as
consideráveis diferenças em paradigmas, como a
herança prototipal no JavaScript em contraste com os
modelos baseados em classe no Java. Essa consideração
é crucial, pois pode levar os novatos a subestimar a
singularidade e a complexidade do JavaScript,
particularmente na programação assíncrona e em
arquiteturas orientadas a eventos. Autores como
Douglas Crockford em 'JavaScript: The Good Parts' e
Kyle Simpson em 'You Don’t Know JS' exploram mais
profundamente essas distinções intricadas,
proporcionando um contexto mais amplo que pode
equilibrar a perspectiva de Flanagan.
 Capítulo 2 Resumo : Seção 1.3. Tipos de
Dados

Seção Conteúdo

1.3 Tipos de JavaScript suporta três tipos de dados primitivos (números, booleanos, strings) e dois tipos compostos
Dados (objetos, arrays), incluindo tipos especializados como funções e datas.

1.3.1 Formato de ponto flutuante de 64 bits. Literais numéricos incluem decimal, hexadecimal e valores especiais
Números (infinito, NaN). Funções: isNaN(), constantes numéricas, métodos de Math.

1.3.2 Dois valores: verdadeiro e falso, representando verdade e falsidade.

Booleanos

1.3.3 Strings Sequências de caracteres, representadas entre aspas. Sequências de escape especiais modificam caracteres.
Strings possuem métodos e uma propriedade de comprimento, são imutáveis.

1.3.4 Objetos Tipos de dados compostos com propriedades nomeadas acessadas via operador . ou notação de colchetes.
Criados usando o operador new ou literais de objeto.

1.3.5 Arrays Objetos numerados acessados por índices, podem conter tipos mistos. Criados usando o construtor Array ou
sintaxe literal de array.

1.3.6 Funções Blocos de código reutilizáveis. Métodos são funções em objetos (palavra-chave this). Argumentos acessados
e Métodos via array de argumentos.

1.3.7 Null e Null indica ausência de valor; undefined representa variáveis não inicializadas/propriedades ausentes.
Undefined Semelhante com == mas diferente com ===.

1.3 Tipos de Dados em JavaScript

JavaScript suporta três tipos de dados primitivos: números,
booleanos e strings; e dois tipos de dados compostos: objetos
e arrays. Também define tipos de objetos especializados,
como funções, expressões regulares e datas.

1.3.1 Números

- Os números são representados no formato de ponto

flutuante de 64 bits, sem diferenciação entre inteiros e
números de ponto flutuante.
- Literais numéricos podem estar em decimal, hexadecimal
(por exemplo, 0xFF para 255) e podem representar valores
especiais: infinito positivo/negativo e NaN (não é um
número).
- A função `isNaN()` testa valores NaN.
- O objeto `Number` fornece constantes, enquanto o objeto
`Math` oferece várias funções matemáticas.

1.3.2 Booleanos

- O tipo booleano tem dois valores: `true` e `false`,

denotando verdade e falsidade.
1.3.3 Strings

- Strings são sequências de caracteres, representadas com

aspas (simples ou duplas).
- Sequências de escape especiais modificam caracteres dentro
das strings (por exemplo, `\n` para nova linha, `\'` para
apóstrofo).
- As strings têm métodos para operações, a propriedade
`length`, e são imutáveis, significando que modificações
retornam novas strings em vez de alterar a original.

1.3.4 Objetos

- Objetos são tipos de dados compostos com propriedades

nomeadas.
- Acesse propriedades com o operador `.` (por exemplo, `o.x
= 1`) ou notação de colchetes (por exemplo, `o["x"] = 1`).
- Objetos podem ser criados usando o operador `new` ou
literais de objeto (por exemplo, `var o = {x:1, y:2}`).

1.3.5 Arrays

- Arrays são objetos numerados acessados através de índices

(por exemplo, `a[0]` para o primeiro elemento).
- Arrays podem conter tipos mistos e têm uma propriedade
de comprimento.
- Use o construtor `Array` ou a sintaxe de literal de array (por
exemplo, `var a = [1,2,3]`) para criar arrays.

1.3.6 Funções e Métodos

- Funções são blocos de código reutilizáveis definidos uma

vez e chamados várias vezes (por exemplo, `function sum(x,
y) { return x + y; }`).
- Métodos são funções atribuídas a propriedades de objetos,
com `this` referindo-se ao objeto que contém.
- Use o array `arguments` para acessar todos os argumentos
passados a uma função.

1.3.7 Nulo e Indefinido

- `null` indica "sem valor" e significa uma ausência de dados

válidos.
- `undefined` representa variáveis não inicializadas ou
propriedades de objeto ausentes.
- `null` e `undefined` são tratados de maneira semelhante
com o operador `==`, mas diferem ao usar `===`.
Exemplo
Ponto chave:Entender os tipos de dados primitivos e
compostos é crucial para uma codificação eficaz em
JavaScript.
Exemplo:Imagine que você está criando uma aplicação
web simples. Você precisa armazenar a idade de um
usuário — um número, talvez, como 28. Agora, você
também quer verificar se ele é um adulto. Aqui, um
booleano (verdadeiro ou falso) vai te ajudar. E se você
precisar representar o nome do usuário? Você vai usar
strings. Ao adicionar múltiplos usuários, você agrupará
os dados deles em um array, permitindo gerenciar uma
coleção facilmente. Reconhecer como esses tipos de
dados funcionam e interagem é vital para construir
aplicações dinâmicas e responsivas em JavaScript.
Pensamento crítico
Ponto chave:Tipos de Dados Primitivos vs.
Compostos
Interpretação crítica:Um ponto chave neste capítulo é a
distinção entre tipos de dados primitivos e compostos
em JavaScript, que o autor apresenta como
conhecimento fundamental para entender a linguagem.
Enquanto Flanagan enfatiza a simplicidade dos tipos de
dados primitivos do JavaScript—números, booleanos e
strings—em comparação com as estruturas mais
complexas de objetos e arrays, é essencial criticar essa
simplificação. Por exemplo, o tratamento de números
por meio de um sistema de ponto flutuante pode levar a
erros de precisão inesperados, conforme destacado pelo
padrão de ponto flutuante da IEEE ([IEEE
754]([Link] Isso
levanta a questão de se os iniciantes podem
superestimar a clareza e a confiabilidade desses tipos
sem uma compreensão mais profunda de suas
implicações. Críticos podem argumentar que a
apresentação do autor não prepara adequadamente os
aprendizes para os desafios que podem enfrentar quando
esses tipos de dados interagem em cenários práticos.
 Capítulo 3 Resumo : Seção 1.4.
Expressões e Operadores
Categoria Descrição P A Operador Operação

Expressões e Expressões de JavaScript combinam valores

Operadores usando operadores, com parênteses para agrupar.

Precedência de Determina a ordem das operações.

Operadores

Associatividade Descreve como operadores da mesma precedência

de Operadores são agrupados (esquerda para direita ou direita
para esquerda).

Visão Geral dos 15 L . Acessar uma

Operadores propriedade de
objeto

P
A
Operador
Operação

[Link] uma propriedade de objeto

15L[ ]Acessar um elemento de array
15L( )Invocar uma função
14RnewCriar um novo objeto
14R++Incrementar (unário)
14R--Decrementar (unário)
14R-Sinal negativo unário
14R+Sinal positivo unário
14R~Complemento bit a bit
14R!Complemento lógico
14RdeleteIndefinir uma propriedade
14RtypeofRetornar tipo de dado
14RvoidRetornar indefinido
13L*, /, %Multiplicação, divisão, resto
12L+, -Somar, subtrair; Concatenar strings
11L<<, >>, >>>Deslocamentos bit a bit
10L<, <=, >, >=Operadores relacionais
9L==, !=, ===, !==Verificações de
igualdade e identidade
8L&E bit a bit
7L^Ou exclusivo bit a bit
6L|Ou bit a bit
5L&&E lógico
4L||Ou lógico
3R?:Operador condicional
2R=Atribuição
2R*=, +=, -=, [Link]ção com
operação
1L,Avaliação múltipla
Categoria Descrição P A Operador Operação

15 L . Acessar uma
propriedade de
objeto

15 L [] Acessar um
elemento de
array

15 L () Invocar uma
função

14 R new Criar um novo

objeto

14 R ++ Incrementar
(unário)

14 R -- Decrementar
(unário)

14 R - Sinal negativo
unário

14 R + Sinal positivo
unário

14 R ~ Complemento
bit a bit

14 R ! Complemento
lógico

14 R delete Indefinir uma

propriedade

14 R typeof Retornar tipo de

dado

14 R void Retornar
indefinido

13 L *, /, % Multiplicação,
divisão, resto

12 L +, - Somar, subtrair;
Concatenar
strings

11 L <<, Deslocamentos
>>, bit a bit
>>>

10 L <, <=, Operadores

>, >= relacionais

9 L ==, Verificações de
!=, igualdade e
===, identidade
Categoria Descrição P A Operador Operação

!==

8 L & E bit a bit

7 L ^ Ou exclusivo
bit a bit

6 L | Ou bit a bit

5 L && E lógico

4 L || Ou lógico

3 R ?: Operador
condicional

2 R = Atribuição

2 R *=, Atribuição com

+=, operação
-=,
etc.

1 L , Avaliação
múltipla

Expressões e Operadores em JavaScript

As expressões em JavaScript combinam vários valores

usando operadores, com parênteses usados para agrupamento
e alteração da ordem de avaliação.

Precedência e Associatividade dos Operadores

JavaScript possui uma ampla gama de operadores

semelhantes aos do C, C++ e Java. Os operadores são
categorizados por precedência e associatividade:
-
Precedência (P)
: Determina a ordem das operações.
-
Associatividade (A)
: Descreve como operadores da mesma precedência são
agrupados (da esquerda para a direita ou da direita para a
esquerda).

Visão Geral dos Operadores

| P | A | Operador | Operação realizada |

|-----|---|-----------|---------------------------------------------|
| 15 | L | . | Acessa uma propriedade de objeto |
| 15 | L | [ ] | Acessa um elemento de array |
| 15 | L | ( ) | Invoca uma função |
| 14 | R | new | Cria um novo objeto |
| 14 | R | ++ | Incremento pré ou pós (unário) |
| 14 | R | -- | Decremento pré ou pós (unário) |
| 14 | R | - | Menos unário (negação) |
| 14 | R | + | Mais unário (não-op) |
Instalar
| 14 | R | ~ o aplicativo
| ComplementoBookey para
bit a bit desbloquear
(unário) |
| 14 | R | ! | texto completo
Complemento e áudio
lógico (unário) |
| 14 | R | delete | Indefinir uma propriedade (unário) |
 Capítulo 4 Resumo : Seção 1.5.
Instruções
Seção Descrição Sintaxe

Programa Consiste em uma sequência de instruções semelhantes a N/A

JavaScript C, C++ e Java

Instruções de Cada expressão pode ser usada sozinha como uma Exemplos: s = "hello world";, x =
Expressão instrução [Link](4);, x++;

Instruções Um agrupamento de instruções dentro de chaves N/A

Compostas

Instruções Vazias Uma instrução que não faz nada ;

Instruções Instruções rotuladas para uso com break e continue label: statement;
Rotuladas

break Sai do loop mais próximo break; ou break label;

case Rotula uma condição dentro das instruções switch N/A

continue Pula para a próxima iteração de um loop continue; ou continue label;

default Funciona como uma opção de reserva nas instruções N/A

switch

do/while Executa um bloco enquanto uma condição for verdadeira do statement while (expression);

for Um loop que combina a inicialização, a condição e a for (initialize; test; update) statement;
atualização

for/in Itera sobre as propriedades de um objeto for (variable in object) statement;

function Declara uma função function funcname(args) { statements }

if/else Execução condicional de instruções if (expression) statement;else statement2;

return Sai de uma função e opcionalmente retorna um valor return; ou return expression;

switch Ramificação de múltiplos caminhos com base em uma

expressão
switch(expression) {
case constant-expression: statements
...
default: statements
}

throw Indica um erro, transferindo o controle para o throw expression;

manipulador de exceções

try/catch/finally Mecanismo de tratamento de exceções

try { statements }
catch (argument) { statements }
Seção Descrição Sintaxe

finally { statements }

var Declara e inicializa variáveis var name [= value] [, name2 [= value2] ...];

while Um loop que continua enquanto uma condição for while (expression) statement;
verdadeira

with Adiciona um objeto à cadeia de escopo; seu uso é with (object) statement;
desencorajado

Visão Geral das Instruções JavaScript

Um programa JavaScript consiste em uma sequência de

instruções, com uma sintaxe que se assemelha em grande
parte à de C, C++ e Java.

Instruções de Expressão

- Toda expressão em JavaScript pode ser uma instrução

independente.
- Exemplos incluem atribuições (por exemplo, `s = "olá
mundo"`), chamadas de métodos (por exemplo, `x =
[Link](4)`), e operações de incremento/decremento (por
exemplo, `x++`).

Instruções Compostas
- Um agrupamento de instruções entre chaves forma uma
instrução composta.
- Útil para múltiplas instruções em construções como laços
ou condicionais.

Instruções Vazias

- Uma instrução vazia é representada apenas por um ponto e

vírgula (`;`) e não faz nada.
- É útil para laços que requerem um corpo vazio.

Instruções Rotuladas

- As instruções podem receber rótulos para uso com break e

continue.
- Sintaxe: `rótulo: instrução`.

Instruções Comuns em JavaScript

-
break
: Sai do laço mais próximo.
- Sintaxe: `break;` ou `break rótulo;`
-
case
: Usado dentro de instruções switch; rotula uma condição.

-
continue
: Pula para a próxima iteração de um laço.
- Sintaxe: `continue;` ou `continue rótulo;`

-
default
: Atua como uma opção padrão em instruções switch.
-
do/while
: Executa um bloco enquanto uma condição for verdadeira.
- Sintaxe: `do instrução enquanto (expressão);`

-
for
: Um laço que combina inicialização, condição e atualização
em uma linha.
- Sintaxe: `for (inicialização; teste; atualização) instrução;`
-
for/in
: Percorre as propriedades de um objeto.
- Sintaxe: `for (variável in objeto) instrução;`
-
function
: Declara uma função.
- Sintaxe: `function nomeFuncao(argumentos) { instruções
}`
-
if/else
: Execução condicional de instruções.
- Sintaxe: `if (expressão) instrução;` e `else instrução2;`
-
return
: Sai de uma função e opcionalmente retorna um valor.
- Sintaxe: `return;` ou `return expressão;`
-
switch
: Ramificação múltipla com base em uma expressão.
- Sintaxe:
```
switch(expressão) {
case expressão-constante: instruções
...
default: instruções
 }
```
-
throw
: Sinaliza um erro, transferindo o controle para o
manipulador de exceções mais próximo.
- Sintaxe: `throw expressão;`
-
try/catch/finally
: Mecanismo de tratamento de exceções.
- Sintaxe:
```
try { instruções }
catch (argumento) { instruções }
finally { instruções }
```
-
var
: Declara e inicializa variáveis.
- Sintaxe: `var nome [= valor] [, nome2 [= valor2] ...];`
-
while
: Um laço que continua enquanto uma condição for
verdadeira.
 - Sintaxe: `while (expressão) instrução;`
-
with
: Adiciona um objeto à cadeia de escopo; seu uso é
desencorajado devido à complexidade.
- Sintaxe: `with (objeto) instrução;`
Exemplo
Ponto chave:Compreender as instruções em
JavaScript é fundamental para sequenciar sua lógica
de forma eficaz.
Exemplo:Quando você escreve um programa em
JavaScript, pense nas suas instruções como ingredientes
em uma receita; cada uma tem um papel específico a
desempenhar. Por exemplo, quando você percebe que
`let result = [Link](2, 3);` não é apenas uma
expressão, mas uma instrução autônoma que traz clareza
ao seu código, você vê como cada parte da sintaxe se
encaixa para criar uma lógica funcional. Se você
esquecer de colocar um ponto e vírgula, sua sobremesa
pode acabar estragada! Cada instrução pode afetar o
controle de fluxo, como usar um laço `for` para iterar
sobre dados, permitindo que você manipule coleções de
forma simples, reforçando que cada instrução é
essencial para a execução adequada.
Pensamento crítico
Ponto chave:A Similaridade da Sintaxe com C, C++
e Java
Interpretação crítica:Embora o autor destaque a
semelhança da sintaxe do JavaScript com C, C++ e
Java, é essencial abordar essa perspectiva de forma
crítica. O autor sugere que tais semelhanças ajudam a
facilitar a curva de aprendizado para programadores
familiarizados com essas linguagens. No entanto, esse
ponto de vista pode simplificar excessivamente as
diferenças fundamentais de paradigmas e execução—o
JavaScript é principalmente orientado a eventos e
assíncrono, o que diverge significativamente da natureza
síncrona de C/C++. Compreender essas distinções é
crucial para dominar o JavaScript, uma vez que as
linguagens de programação não podem ser entendidas
apenas pela sintaxe. Aqueles interessados em
explorações mais profundas sobre paradigmas de
linguagem devem consultar fontes como "Programming
JavaScript Applications" de Eric Elliott, que enfatiza os
aspectos únicos do JavaScript além da mera sintaxe.
 Capítulo 5 Resumo : Seção 1.6.
JavaScript Orientado a Objetos
Tópico Resumo

JavaScript Orientado a JavaScript suporta programação orientada a objetos através de objetos, herança e classes.
Objetos

Objetos em JavaScript Objetos são arrays associativos que ligam valores a propriedades nomeadas e suportam heranças.

Definindo uma Classe Uma classe é definida usando uma função construtora, inicializada com o operador `new` e a
palavra-chave `this`.

Propriedade Prototype A propriedade `prototype` de um construtor permite métodos e propriedades compartilhados

entre instâncias da classe.

Métodos de Exemplo Métodos podem ser definidos no prototype para realizar operações como calcular distâncias e
converter para strings.

Métodos e Propriedades Métodos/propriedades estáticas são anexados diretamente ao construtor, como definir um ponto
Estáticas constante.

Criando e Usando Objetos Para criar um objeto, use o construtor e chame seus métodos para realizar operações.

JavaScript Orientado a Objetos

Objetos JavaScript

Os objetos JavaScript são arrays associativos que ligam

valores a propriedades nomeadas. Eles suportam um
mecanismo simples de herança e permitem a criação de
novas classes de objetos.

Definindo uma Classe

Para definir uma nova classe, cria-se uma função construtora.
O construtor é invocado com o operador `new` e usa a
palavra-chave `this` para inicializar o objeto recém-criado.
Por exemplo, um construtor `Point` inicializa as coordenadas
x e y:
```javascript
function Point(x, y) {
this.x = x;
this.y = y;
}
```

Propriedade Prototype

Toda função construtora possui uma propriedade `prototype`

que aponta para um objeto prototype especial da classe
associada. As propriedades definidas neste prototype são
herdadas por todos os objetos criados com o construtor. Isso
é geralmente usado para definir métodos para instâncias da
classe.

Métodos de Exemplo
Definir métodos no prototype permite que as instâncias
realizem operações, como calcular a distância entre dois
pontos e convertê-los em strings:
```javascript
[Link] = function(that) {
var dx = this.x - that.x;
var dy = this.y - that.y;
return [Link](dx * dx + dy * dy);
}
[Link] = function() {
return '(' + this.x + ',' + this.y + ')';
}
```

Métodos e Propriedades Estáticas

Métodos ou propriedades estáticas são atribuídos diretamente

à função construtora. Por exemplo, uma constante
comumente usada pode ser definida da seguinte forma:
```javascript
[Link] = new Point(0, 0);
```

Criando e Usando Objetos

Para usar a classe `Point`, um novo objeto pode ser criado e
métodos chamados como mostrado:
```javascript
var p = new Point(3, 4);
var d = [Link]([Link]);
var msg = "Distância até " + p + " é " + d;
```
Exemplo
Ponto chave:Compreender a propriedade prototype
melhora sua programação orientada a objetos em
JavaScript.
Exemplo:Ao trabalhar com JavaScript, imagine criar
uma aplicação robusta onde você define uma classe
'Pessoa' para gerenciar usuários. Ao definir métodos
como 'calcularIdade' no prototype, você permite que
cada objeto pessoa calcule facilmente sua idade sem
duplicar código, ilustrando o poder dos prototypes em
fornecer funcionalidade compartilhada para todas as
instâncias.
Pensamento crítico
Ponto chave:A explicação do autor sobre os
princípios de programação orientada a objetos em
JavaScript enfatiza encapsulamento e herança
através da cadeia de protótipos.
Interpretação crítica:Embora Flanagan apresente esses
conceitos como fundamentais para o design do
JavaScript, é essencial notar que nem todos os
desenvolvedores concordam com a superioridade ou
simplicidade dessa abordagem. Alguns argumentam que
a herança baseada em protótipos do JavaScript pode
levar a complicações, especialmente para aqueles que
estão fazendo a transição de linguagens baseadas em
classes. Essa perspectiva é explorada em recursos como
'You Don’t Know JS' de Kyle Simpson, que destaca as
armadilhas potenciais de depender exclusivamente da
herança por protótipos, sugerindo que uma compreensão
mais sutil da flexibilidade e peculiaridades do
JavaScript é necessária para uma programação eficaz.
 Capítulo 6 Resumo : Seção 1.7.
Expressões Regulares
Seção Descrição

1.7 Expressões Regulares JavaScript suporta expressões regulares para correspondência de padrões, semelhante
à sintaxe Perl.

1.7.1 Caracteres Literais A maioria dos caracteres se representa, com significados especiais para certa
pontuação e sequências de escape.

Sequências de Escape Representam caracteres literais (por exemplo, `\n`, `\r`, `\t`) e pontuação (por
exemplo, `\\`, `\/`).

Caracteres Hexadecimais e Unicode Representados como `\xnn` e `\uxxxx`.

1.7.2 Classes de Caracteres Definidas usando colchetes, permitindo correspondências em conjuntos de caracteres
específicos.

Escapes de Classe de Caracteres `[...]`, `[^...]`, `.`, `\w`, `\W`, `\s`, `\S`, `\d`, `\D` para diversas correspondências de
Comuns caracteres.

1.7.3 Repetição Controla quantas vezes um padrão pode corresponder dentro de uma string.

Operadores de Repetição `?`, `+`, `*`, `{n}`, `{n,}`, `{n,m}` e correspondência não-gulosa com `?`.

1.7.4 Agrupamento e Alternância Utiliza parênteses para agrupar subexpressões e separar alternativas.

Correspondência de Grupos Referem-se a subexpressões com `$n` para texto correspondente.

1.7.5 Ancoragem da Posição da Define posições para correspondências em uma string.

Correspondência

Sintaxe de Ancoragem `^`, `$`, `\b`, `\B`, `(?=p)`, `(?!p)` para correspondência em várias posições de string e
assertivas.

1.7 Expressões Regulares

JavaScript utiliza expressões regulares para correspondência

de padrões, empregando uma sintaxe similar à do Perl.
JavaScript 1.2 suporta expressões do Perl 4, enquanto
JavaScript 1.5 melhora isso com alguns recursos do Perl 5.
Expressões regulares podem ser expressas literalmente
usando delimitadores de barra (/) ou como objetos RegExp
criados com o construtor RegExp().

1.7.1 Caracteres Literais

A maioria dos caracteres em uma expressão regular

representa a si mesma. Certas pontuações e sequências de
escape têm significados especiais, incluindo:
-
Símbolos de escape
: Representam caracteres literais (por exemplo, `\n`, `\r`, `\t`)
e pontuações (por exemplo, `\\`, `\/`).
-
Caracteres Hexadecimais e Unicode
: Representados como `\xnn` e `\uxxxx`, respectivamente.

1.7.2 Classes de Caracteres

Colchetes definem classes de caracteres, com sequências de

escape específicas para conjuntos comuns:
- Instalar o aplicativo
`[...]`: Correspondem Bookey
a qualquer paradentro
caractere desbloquear
dos
colchetes. texto completo e áudio
- `[^...]`: Correspondem a qualquer caractere que não esteja
Capítulo 7 Resumo : Seção 1.8. Versões
do JavaScript

1.8 Versões do JavaScript

A Netscape desenvolveu várias versões do JavaScript, com a

Microsoft introduzindo versões compatíveis chamadas
JScript. O órgão de normas ECMA lançou três edições do
padrão ECMAScript. A seguir, um resumo das várias versões
e suas relações:
-
JavaScript 1.0:
A versão original com bugs implementada no Netscape 2 e
agora obsoleta.
-
JavaScript 1.1:
Introduziu objetos Array verdadeiros e resolveu muitos
bugs; implementada pelo Netscape 3.
-
JavaScript 1.2:
Adicionou a declaração switch, expressões regulares e
outros recursos; quase em conformidade com o ECMA v1.
-
JavaScript 1.3:
Corrigiu incompatibilidades e atendeu ao ECMA v1;
implementada no Netscape 4.5.
-
JavaScript 1.4:
Usada apenas em produtos de servidor do Netscape.
-
JavaScript 1.5:
Introduziu tratamento de exceções e atendeu ao ECMA v3;
implementada pelo Mozilla e Netscape 6.

Versões do JScript:

-
JScript 1.0:
Equivalente ao JavaScript 1.0 para as primeiras versões do
IE 3.
-
JScript 2.0:
Equivalente ao JavaScript 1.1 para versões posteriores do IE
3.
-
JScript 3.0:
 Comparável ao JavaScript 1.3 e compatível com o ECMA
v1; implementada pelo IE 4.
-
JScript 5.0:
Suportou tratamento de exceções; parcialmente compatível
com o ECMA v3; usado no IE 5.
-
JScript 5.5:
Equivalente ao JavaScript 1.5 e totalmente compatível com
o ECMA v3; visto no IE 5.5 e IE 6.

Versões do ECMA:

-
ECMA v1:
Padronizou recursos do JavaScript 1.1, mas excluiu a
declaração switch e o suporte a expressões regulares; as
implementações conformantes são JavaScript 1.3 e JScript
3.0.
-
ECMA v2:
Uma versão de manutenção com esclarecimentos e sem
novos recursos.
-
ECMA v3:
Padronizou declarações switch, expressões regulares e
tratamento de exceções; a conformidade foi alcançada pelo
JavaScript 1.5 e JScript 5.5.

Capítulo 1: A Linguagem JavaScript

JavaScript é uma linguagem de script leve otimizada para ser

incorporada em páginas HTML, cobrindo aspectos principais
e do lado do cliente do JavaScript.

2.1 JavaScript em HTML

JavaScript pode ser incluído em HTML através de scripts,

manipuladores de eventos e URLs:
-
Tag <script>:
A maior parte do código JavaScript é inserida entre as tags
<script>. Com o JavaScript 1.1 e posteriores, scripts externos
podem ser incluídos usando o atributo `src`.
-
Manipuladores de Eventos:
O JS pode aparecer em atributos de manipuladores de
eventos de tags HTML, ativados em eventos específicos (por
exemplo, `onclick`).
-
URLs do JavaScript:
Usadas com o pseudo-protocolo `javascript:` para executar
código JS diretamente.

2.2 O Objeto Window

O objeto Window representa uma janela do navegador,

atuando como um escopo global para propriedades e
métodos. Os principais recursos incluem:
-
Diálogos Simples:
Métodos como `alert()`, `confirm()` e `prompt()` para
interações com o usuário.
-
Gerenciamento da Linha de Status:
Configuração de texto na área de status através da
propriedade `status`.
-
Temporizadores:
Usando `setTimeout()` e `setInterval()` para agendar a
execução de funções.
-
Informações do Sistema:
Acesso às propriedades `navigator` e `screen` para detalhes
do navegador e do sistema.
-
Navegação do Navegador:
Utilizando as propriedades `location` e `history` para
manipular o fluxo de navegação e navegar.
-
Controle da Janela:
Métodos para mover, redimensionar e abrir/fechar janelas do
navegador.
-
Múltiplas Janelas e Frames:
Tratando cada frame como um objeto Window separado e
acessando-os adequadamente.

2.3 O Objeto Document

O objeto Document é integral, representando o documento

HTML carregado.

DOM Legado:

Fornece acesso ao conteúdo e propriedades do documento,

mas é limitado em capacidade.

2.5 DOM W3C:

Aprimora o DOM legado, permitindo acesso a qualquer

elemento do documento com métodos como
`getElementById()` e métodos para manipular atributos e
estrutura de nós.

2.6 DOM IE 4:

Introduzido pelo Internet Explorer 4, suporta funcionalidade

semelhante ao W3C, mas carece de algumas padronizações.

2.7 DHTML: Scripting de Estilos CSS

HTML dinâmico combina HTML, CSS e JavaScript para

páginas da web visualmente dinâmicas. A propriedade `style`
permite a manipulação de atributos CSS diretamente.

2.8 Eventos e Manipulação de Eventos

O JavaScript pode lidar com eventos usando atributos padrão

prefixados com "on". Eventos podem ser associados a tags
HTML, com problemas de compatibilidade entre diferentes
navegadores afetando a manipulação avançada de eventos.

2.9 Restrições de Segurança do JavaScript

O JavaScript impõe várias restrições por questões de

segurança, incluindo:
- Limitações de política de origem cruzada.
- Prevenção da gestão de arquivos em máquinas locais.
- Confirmação do usuário necessária para ações sensíveis.
Este capítulo fornece uma base sobre a evolução, estrutura e
funcionalidade do JavaScript, destacando tanto seu poder
quanto as limitações impostas por questões de segurança.
Pensamento crítico
Ponto chave:A evolução do JavaScript por meio de
várias versões ilustra as complexidades e
inconsistências nos padrões de desenvolvimento web.
Interpretação crítica:Embora se discuta a evolução do
JavaScript e suas várias versões, os leitores podem
questionar a confiabilidade dessa rápida transformação,
que pode sugerir instabilidade em uma tecnologia web
fundamental. O fato de que múltiplas iterações e
padrões de compatibilidade variados (como JScript
versus ECMAScript) surgiram para resolver erros
anteriores indica não apenas progresso, mas também a
confusão potencial para os desenvolvedores que se
adaptam às mudanças. Isso levanta a questão de que
confiar apenas na interpretação de um único autor, como
apresentada no resumo de Flanagan, pode deixar de lado
perspectivas e críticas mais amplas sobre as questões de
padronização em linguagens de programação. Para uma
compreensão mais profunda, referências como
'JavaScript: The Good Parts' de Douglas Crockford e a
série 'You Don’t Know JS' de Kyle Simpson oferecem
visões contrastantes sobre a evolução e os desafios do
JavaScript.
 Capítulo 8 Resumo : Seção 2.1.
JavaScript em HTML
Seção Conteúdo

JavaScript em HTML Integração via scripts, manipuladores de eventos e URLs de JavaScript.

Tag <script>

Incorporado entre as tags <script> e </script>.

Arquivos externos referenciados usando o atributo src: <script src="[Link]">.
Arquivos normalmente têm a extensão .js; </script> é necessário mesmo com src.
Atributo language está obsoleto; use o atributo type definido como text/javascript.

Manipuladores de
Eventos
Executados via atributos de tags HTML que começam com 'on'.
Exemplo: <input type="button" value="Pressione-me" onclick="alert('Olá Mundo!');"> dispara
um alerta ao clicar.

URLs de JavaScript

Executados usando o pseudo-protocolo javascript:.

Use o operador void para executar JavaScript sem alterar o documento: <form
action="javascript:void validate()">.

JavaScript em HTML

O JavaScript pode ser integrado em arquivos HTML através

de scripts, manipuladores de eventos e URLs de JavaScript.

A Tag <script>
- O JavaScript é normalmente incorporado entre as tags
`<script>` e `</script>`.
- Você pode referenciar arquivos JavaScript externos usando
o atributo `src`: `<script src="[Link]"></script>`.
- Os arquivos geralmente têm a extensão `.js`, e a tag
`</script>` permaneça necessária mesmo com o atributo
`src`.
- O atributo `language` especifica a linguagem de script, mas
o padrão é JavaScript. Ele está sendo descontinuado em favor
do atributo `type`, que deve ser definido como
`text/javascript`.

Manipuladores de Eventos

- O JavaScript também pode ser executado através de

atributos de manipuladores de eventos nas tags HTML, que
começam com 'on'.
- Por exemplo: `<input type="button" value="Press Me"
onclick="alert('Hello World!');">` dispara um alerta
JavaScript ao clicar no botão.

URLs de JavaScript
- O código JavaScript também pode ser executado através de
URLs que usam o pseudo-protocolo `javascript:`.
- Para executar JavaScript sem alterar o documento atual, use
o operador `void`: `<form action="javascript:void
validate()">`.
Pensamento crítico
Ponto chave:Integração de JavaScript ao HTML
Interpretação crítica:Embora David Flanagan enfatize a
integração direta do JavaScript ao HTML, pode-se
argumentar que essa dependência de embutir scripts
diretamente no HTML pode levar a potenciais
problemas relacionados à manutenção e à separação de
preocupações. Ao acoplar scripts de forma próxima à
marcação, os desenvolvedores podem,
inadvertidamente, criar complexidades na depuração e
nas atualizações, o que contraria as práticas modernas
defendidas por frameworks como React ou Angular, que
promovem uma clara separação entre estrutura (HTML)
e comportamento (JavaScript). Vale a pena considerar
que as percepções de Flanagan são valiosas, mas devem
ser vistas através da lente das melhores práticas em
evolução no desenvolvimento web, conforme apoiado
por fontes como 'Clean Code' de Robert C. Martin. Isso
destaca a importância de avaliar as opiniões do autor em
um contexto de metodologias emergentes.
 Capítulo 9 Resumo : Seção 2.2. O Objeto
Window
Seção Detalhes

O Objeto Window O objeto Window representa uma janela de navegador web e serve como o objeto global no
JavaScript do lado do cliente.

Propriedades e Define propriedades/métodos globais no nível mais alto, acessíveis sem prefixos. Propriedade
Métodos Globais notável: document.

Caixas de Diálogo Métodos:

Simples
alert() para mensagens.
confirm() para perguntas de sim/não.
prompt() para entrada de texto do usuário.

A Linha de Status Exibe a URL e outras informações. Defina o texto de status usando status e o padrão usando
defaultStatus.

Temporizadores Execute código após intervalos:

setTimeout() para execuções únicas.

setInterval() para execuções repetidas.

Identificadores de cancelamento retornados por clearTimeout() e clearInterval().

Informações do As propriedades navigator e screen fornecem detalhes do sistema, ajudando em código específico para
Sistema navegadores.

Navegação no Gerencie a URL com location (lendo a URL atual, definindo para navegar). A propriedade history
Navegador permite a navegação pelo histórico.

Controle de Janela Métodos para manipulação de janelas incluem open() para novas janelas e close() para fechar janelas
criadas por scripts.

Múltiplas Janelas e Cada janela/frame possui um objeto Window separado. Interações exigem referências explícitas.
Frames Frames HTML são objetos Window independentes.

O Objeto Window

O objeto Window representa uma janela do navegador web e

serve como o objeto global em JavaScript do lado do cliente.

Propriedades e Métodos Globais

- O objeto Window define propriedades e métodos globais de

nível superior, acessíveis sem prefixos.
- Uma propriedade importante é `document`, que se refere ao
objeto Document exibido no navegador.

Caixas de Diálogo Simples

- Três métodos para mostrar caixas de diálogo:

- `alert()` para mensagens.
- `confirm()` para perguntas de sim/não.
- `prompt()` para entrada de texto do usuário.

A Linha de Status

- A linha de status exibe destinos de URL e outras

informações.
- Você pode definir o texto de status usando a propriedade
Instalar
`status` o aplicativo
e o padrão Bookey para desbloquear
usando `defaultStatus`.
texto completo e áudio
Temporizadores
Capítulo 10 Resumo : Seção 2.3. O
Objeto Documento

O Objeto Documento

Todo objeto Window possui uma propriedade document que

se refere a um objeto Document, que é fundamental, pois
representa o documento HTML exibido na janela do
navegador.

O Modelo de Objeto de Documento (DOM)

O DOM descreve como o conteúdo do documento é acessado

e modificado, e existem vários tipos de DOMs:

DOM Legado

O DOM legado original evoluiu com as primeiras versões do

JavaScript, permitindo o acesso a partes-chave do
documento, como formulários e imagens. Ele é bem
suportado em todos os navegadores.
DOM W3C

Este modelo fornece acesso abrangente a todo o conteúdo do

documento e é padronizado pelo World Wide Web
Consortium (W3C). Apoiado pelos navegadores modernos,
ele difere do DOM do IE 4, mas padroniza muitos recursos
legados. O livro foca nas características principais relevantes
para programadores de JavaScript.

DOM IE 4

Desenvolvido pela Microsoft, este DOM estendeu o DOM

legado, oferecendo recursos poderosos para a manipulação
do conteúdo do documento. Esses recursos não foram
padronizados, mas obtiveram algum suporte em navegadores
não-Microsoft.

Conclusão

As seções seguintes detalharão cada tipo de DOM e suas

funcionalidades para acessar e modificar o conteúdo do
documento.
Exemplo
Ponto chave:Compreender o Objeto Documento é
essencial para uma programação eficaz em
JavaScript.
Exemplo:Imagine que você está criando uma página da
web que atualiza dinamicamente o conteúdo com base
na interação do usuário. O Objeto Documento, que
representa seu documento HTML, permite que você
acesse e manipule elementos como parágrafos e botões.
Por exemplo, se você quiser mudar o texto de um
parágrafo quando um usuário clicar em um botão, você
usaria JavaScript para interagir com o Objeto
Documento. Ao entender como navegar pelo DOM,
você pode criar aplicações web responsivas e interativas
que reagem à entrada do usuário, enriquecendo
significativamente a experiência do usuário.
Pensamento crítico
Ponto chave:A importância do Modelo de Objeto de
Documento (DOM) no desenvolvimento web.
Interpretação crítica:O autor enfatiza o papel crucial do
DOM como a interface entre documentos web e
JavaScript, que permite a manipulação dinâmica de
conteúdo. No entanto, enquanto o DOM W3C é
amplamente aceito como padrão, os desenvolvedores
devem permanecer atentos à compatibilidade entre
navegadores e a modelos alternativos, como o DOM do
IE 4. A suposição de que todos os navegadores
suportarão uniformemente o modelo W3C pode levar a
descuidos em aplicações práticas, conforme evidenciado
por numerosos testemunhos de desenvolvedores que
encontram comportamentos inconsistentes em diferentes
plataformas. Recursos como Can I use ([Link])
podem oferecer insights sobre compatibilidade entre
navegadores e possíveis problemas.
Capítulo 11 Resumo : Seção 2.4. O DOM
Legado

O DOM Legado

O DOM Legado refere-se ao Modelo de Objeto de

Documento (DOM) original do JavaScript do lado do cliente,
que permite o acesso a várias propriedades e conteúdos do
documento.

Propriedades do Objeto Documento

- O objeto Documento fornece várias propriedades de leitura,

incluindo:
-
título:
Título do documento
-
URL:
URL do documento
-
últimaModificação:
 Data da última modificação do documento
- Ele também inclui arrays que referenciam tipos específicos
de conteúdo do documento:
-
forms[]:
Array de objetos Form
-
images[]:
Array de objetos Imagem
-
applets[]:
Array de objetos de applet Java incorporados
-
links[]:
Array de objetos Link
-
anchors[]:
Array de objetos Anchor

Referências Nomeadas

Referências nomeadas podem ser criadas usando o atributo

name do HTML, permitindo que scripts acessem elementos
do documento pelo nome, junto com a notação de array.
Objetos Form

O objeto Form contém:

-
elements[]:
Um array de elementos de entrada dentro do formulário que
podem ser acessados em ordem ou pelo nome.

Limitações do DOM Legado

O DOM Legado é limitado a tipos específicos de conteúdo

(formulários, imagens, etc.) e carece de métodos para
interagir diretamente com outras tags ou obter texto do
documento.

Documentos Gerados Dinamicamente

- O método `write()` do objeto Documento permite a geração

de conteúdo dinâmico durante a fase de carregamento do
documento.
- Cuidado: Usar `[Link]()` após o carregamento do
documento sobrescreverá o documento atual.
Formulários Dinâmicos

- Elementos de entrada podem ser atualizados dinamicamente

usando suas propriedades, como `value`.
- Exemplo de definição da hora local atual em um campo de
entrada de formulário dinamicamente.

Validação de Formulário

- A tag `<form>` suporta um manipulador de evento

`onsubmit` para validar envios de formulário verificando os
campos de entrada.

Imagens Rollover

- Efeitos de rolamento de imagens podem ser implementados

usando o array de imagens e alterando a propriedade `src` em
eventos de mouse (por exemplo, `onmouseover`,
`onmouseout`).

Trabalhando com Cookies

- A propriedade cookie permite definir e consultar cookies

associados ao documento.
- Cookies devem seguir um formato específico para pares
nome/valor, com datas de expiração e especificações de
caminho opcionais.
- Uma função de exemplo é fornecida para recuperar o valor
de um cookie específico.
Capítulo 12 Resumo : Seção 2.5. O W3C
DOM

O W3C DOM

O padrão W3C DOM padroniza recursos legados do DOM e

introduz novos, permitindo que scripts acessem e manipulem
vários elementos de documentos além de formulários e
imagens.

Encontrando Elementos pelo ID

- Utilize um atributo `id` único para elementos especiais.

- Acesse elementos com o método `getElementById()`.

Exemplo:
```javascript
var t = [Link]("title");
```

Encontrando Elementos pelo Nome da Tag

- Acesse elementos pelo seu nome de tag usando
`getElementsByTagName()`, que retorna um array de
elementos correspondentes.

Exemplo:
```javascript
var listas = [Link]("ul");
var item = listas[1].getElementsByTagName("li")[2];
```

Navegando em uma Árvore de Documentos

- O W3C DOM representa um documento como uma árvore

de nós (tags HTML, texto, comentários).
- Use propriedades como `parentNode`, `firstChild`,
`nextSibling` e `lastChild` para navegar pela árvore.
Exemplo:
```javascript
var p = [Link];
var c0 = [Link];
```
Instalar o aplicativo Bookey para desbloquear
Tipos de Nós texto completo e áudio
Capítulo 13 Resumo : Seção 2.6. DOM
do IE 4

Visão Geral do DOM do IE 4

O DOM do IE 4, introduzido com o Internet Explorer 4, é um

modelo de objeto de documento poderoso, mas não padrão.
Embora o IE 5 e versões posteriores suportem a maioria dos
recursos do DOM W3C, esse modelo mais antigo ainda é
relevante devido ao seu uso.

Acessando Elementos do Documento

Diferentemente do DOM W3C, o DOM do IE 4 não utiliza o

método getElementById(). Em vez disso, os elementos
podem ser acessados através do array all[] do objeto
documento, usando um ID de string ou referenciando-o
diretamente. O método tags() no array all[] é usado para
buscar elementos pelo nome da tag, necessitando que os
nomes das tags estejam em maiúsculas.

Percorrendo a Árvore do Documento

A travessia no DOM do IE 4 assemelha-se à do DOM W3C,
mas utiliza nomes de propriedade diferentes: `children[]`
substitui `childNodes[]`, e `parentElement` substitui
`parentNode`. É importante notar que comentários e texto do
documento estão excluídos da árvore, com o texto acessado
através das propriedades innerHTML e innerText.

Modificando o Conteúdo e a Estrutura do

Documento

Os objetos de elemento no DOM do IE 4 podem ter suas

propriedades configuradas e consultadas de maneira
semelhante aos elementos do DOM W3C. A propriedade
innerText altera o conteúdo textual de um elemento,
enquanto a propriedade innerHTML permite a substituição
do conteúdo de um elemento por uma string HTML, embora
de forma menos eficiente. A propriedade outerHTML e os
métodos insertAdjacentHTML() são formas adicionais,
embora menos comuns, de manipular elementos.

Compatibilidade do DOM

Para garantir a compatibilidade entre diferentes

implementações de DOM, scripts podem verificar a
existência de métodos ou propriedades. Isso permite que a
funcionalidade projetada para o DOM W3C retorne ao DOM
do IE 4, se necessário, fornecendo uma solução de script
robusta para vários navegadores.
Capítulo 14 Resumo : Seção 2.7.
DHTML: Programando Estilos CSS

DHTML: Programando Estilos CSS

Visão Geral do DHTML

HTML Dinâmico (DHTML) integra HTML, CSS e

JavaScript, permitindo a modificação dinâmica de estilos,
incluindo a posição e visibilidade dos elementos do
documento.

Propriedade de Estilo

- Cada elemento do documento possui uma propriedade de

estilo vinculada aos seus estilos inline.
- A propriedade de estilo refere-se a um objeto Estilo com
propriedades correspondentes aos atributos CSS.
- Por exemplo, para acessar o atributo de cor: `[Link]` e
para definir a cor de fundo: `[Link]`.
- Atributos CSS com hífens usam uma nomenclatura em
camelCase em JavaScript (por exemplo, `background-color`
torna-se `backgroundColor`).

Caso Especial

- O atributo `float` é uma palavra reservada em JavaScript; é

referenciado como `cssFloat`.

Propriedades CSS e Programação Dinâmica

- O padrão CSS inclui propriedades para melhorar a

aparência visual, particularmente posicionamento e
visibilidade:
-
Posição
: Valores - absoluto, relativo, fixo, estático.
-
Esquerda/Topo
: Coordenadas X/Y.
-
Largura/Altura
: Dimensões do elemento.
-
Z-Index
: Ordem de empilhamento; valores mais altos ficam na parte
superior.
-
Exibição
: Valores - bloco, inline, nenhum.
-
Visibilidade
: Pode ser definida como oculta ou visível; espaço é alocado
para elementos ocultos.
-
Overflow
: Como lidar com conteúdo que excede o tamanho do
elemento (visível, oculto, rolar, automático).
-
Cortar
: Porção do conteúdo exibido (sintaxe: `rect(top right bottom
left)`).

Exemplo de Animação DHTML

- Demonstra uma animação simples de mover um elemento.

- Código para animar um elemento movendo-o 10 pixels para
a direita a cada 50 milissegundos até que ele tenha se movido
20 vezes, momento em que se torna invisível.
```html
<h1 id='title'>Animação DHTML</h1>
<script>
var e = [Link]("title");
[Link] = "absolute";
var frame = 0;
function nextFrame() {
if (frame++ < 20) {
[Link] = (10 * frame) + "px";
setTimeout("nextFrame()", 50);
} else [Link] = "hidden";
}
nextFrame();
</script>
```
Capítulo 15 Resumo : Seção 2.8. Eventos
e Manipulação de Eventos

2.8 Eventos e Manipulação de Eventos

Esta seção discute como implementar JavaScript do lado do

cliente em documentos HTML através de atributos de
manipulador de eventos.

Atributos Padrão de Manipuladores de Eventos

Uma tabela resume os manipuladores de eventos padrão que

começam com "on" e suas respectivas tags HTML. Os
principais manipuladores incluem:
-
onabort
: Acionado quando o carregamento de uma imagem é
abortado.
-
onclick
: Executa ao pressionar e soltar o mouse.
-
onfocus
: Ativado quando um elemento ganha foco do teclado.
-
onload
: Dispara assim que um documento ou imagem é
completamente carregado.
-
onsubmit
: Relacionado ao envio de formulários, permitindo a
prevenção do envio através de uma declaração de retorno
falso.
As ações padrão de certos eventos podem ser prevenidas
retornando falso, exceto no caso de onmouseover, onde
retornar verdadeiro impede que a URL seja exibida na linha
de status.

2.8.1 Manipuladores de Eventos como Funções

JavaScript

Os manipuladores de eventos em HTML correspondem a

funções JavaScript. Por exemplo:
Instalar o aplicativo Bookey para desbloquear
```javascript
texto completo
[Link][0].onsubmit e áudio
= validate;
```
Capítulo 16 Resumo : Seção 2.9.
Restrições de Segurança do JavaScript

Restrições de Segurança do JavaScript

Visão Geral

Implementações do JavaScript do lado do cliente impõem

várias restrições de segurança para prevenir ações perigosas,
proteger a privacidade do usuário e melhorar a experiência
geral do usuário. Essas restrições não são padronizadas, mas
muitas são comuns entre diferentes navegadores.

Restrições Principais

-
Política de Mesma Origem
: Scripts só podem acessar propriedades de janelas e
documentos do mesmo servidor web, limitando a
programação entre janelas.
-
Restrições de Upload de Arquivos
: Scripts não podem manipular a propriedade de valor do
elemento de formulário FileUpload.
-
Envio de E-mails e Notícias
: Scripts são impedidos de enviar formulários para URLs
mailto: ou news: sem a confirmação do usuário.
-
Gerenciamento de Janelas
: Scripts só podem fechar janelas que criaram, a menos que a
confirmação do usuário seja obtida.
-
Acesso ao Cache
: Scripts não podem carregar URLs do tipo about:, como
about:cache.
-
Criação de Janelas
: Scripts não podem criar janelas fora da tela ou pequenas
janelas, ou janelas sem barras de título.

Restrições em Evolução

Devido ao uso indevido do JavaScript para ações

indesejadas, navegadores mais recentes permitem que os
usuários configurem as configurações de segurança para
bloquear anúncios pop-up e manipular o tamanho ou a
posição das janelas.

JavaScript do Lado do Cliente

Definição e Funcionalidade

JavaScript do lado do cliente refere-se ao código incorporado

em arquivos HTML, executado por navegadores web. Ele
fornece acesso a objetos de navegador e documento, e
geralmente é baseado em eventos, reagindo a interações do
usuário.

Implicações de Framework e Segurança

As potentes capacidades do JavaScript do lado do cliente

podem introduzir vulnerabilidades de segurança
significativas, levando os navegadores a impor restrições
sobre as ações dos scripts. Esta seção se concentra na
inclusão do JavaScript em HTML, introduzindo objetos
JavaScript, tratamento de eventos e delineando medidas de
segurança.
Pensamento crítico
Ponto chave:A ausência de padronização nas
restrições de segurança do JavaScript levanta
preocupações sobre a privacidade e a segurança dos
usuários.
Interpretação crítica:Enquanto o autor destaca a
importância de várias restrições de segurança do
JavaScript do lado do cliente, é essencial avaliar
criticamente sua eficácia e consistência entre os
navegadores. A falta de um padrão universal significa
que as medidas de segurança podem variar
significativamente, potencialmente deixando os usuários
vulneráveis, dependendo do navegador que utilizam.
Essa inconsistência compromete a confiabilidade do
JavaScript como tecnologia e sugere que o ponto de
vista do autor pode superestimar a natureza protetiva
dessas medidas. Na verdade, pesquisas de especialistas
em segurança, como Michal Zalewski, têm levantado
alarmes sobre a segurança dos navegadores, enfatizando
a necessidade de uma abordagem mais padronizada e
robusta para a segurança do JavaScript (fonte: "The
Tangled Web" de Michal Zalewski). É encorajado que
os leitores busquem fontes externas para entender
melhor as complexidades e limitações das práticas de
segurança do JavaScript.
Capítulo 17 Resumo : Array

Criação e Manipulação de Arrays em JavaScript

Métodos Construtores

-
new Array()
: Cria um array vazio.
-
new Array(n)
: Cria um array com `n` elementos indefinidos.
-
new Array(e0, e1,...)
: Inicializa um array com elementos especificados.

Sintaxe Literal

- Arrays podem ser criados usando colchetes com valores

separados por vírgulas, por exemplo, `var a = [1, true, 'abc'];`.

Propriedades do Array
-
length
: Um inteiro que pode ser lido e escrito, indicando o número
de elementos no array. Pode ser modificado para truncar ou
expandir o array.

Métodos do Array

-
concat(value, ...)
: Combina arrays e valores em um novo array.
-
join(separator)
: Converte cada elemento em string e os concatena com um
separador especificado.
-
pop()
: Remove e retorna o último elemento, alterando o
comprimento do array.
-
push(value, ...)
: Adiciona valores ao final e retorna o novo comprimento.
-
reverse()
: Inverte a ordem do array.
-
shift()
: Remove e retorna o primeiro elemento, ajustando o
comprimento.
-
slice(start, end)
: Cria um novo array com elementos do índice inicial até,
mas não incluindo, o índice final.
-
sort(orderfunc)
: Ordena os elementos no local conforme uma função de
ordenação opcional.
-
splice(start, deleteCount, value,...)
: Deleta elementos especificados e insere novos no índice
definido, retornando os elementos deletados.
-
toLocaleString()
: Retorna uma representação em string localizada do array.
-
toString()
: Converte o array em uma string.
-
unshift(value, ...)
: Adiciona novos elementos no início, deslocando os
elementos existentes e retornando o novo comprimento.
Capítulo 18 Resumo : Data

Objeto Date em JavaScript

O objeto Date em JavaScript é utilizado para trabalhar com

datas e horas, podendo ser criado em diversos formatos.

Variedades de Construtor

- `new Date();` - Cria um objeto Date para a data e hora

atuais.
- `new Date(milliseconds);` - Inicializa a partir de um
timestamp (milissegundos).
- `new Date(datestring);` - Analisa uma string de data
fornecida.
- `new Date(year, month, day, hours, minutes, seconds, ms);`
- Define campos individuais de data e hora, com os dois
primeiros argumentos (ano e mês) sendo obrigatórios.

Métodos do Objeto Date

O objeto Date funciona sem propriedades e depende de

vários métodos:
-
Métodos Get:

- `get[UTC]Date()`: Retorna o dia do mês (1-31).

- `get[UTC]Day()`: Retorna o dia da semana (0-6).
- `get[UTC]FullYear()`: Retorna o ano completo.
- `get[UTC]Hours()`: Retorna horas (0-23).
- `get[UTC]Milliseconds()`: Retorna milissegundos.
- `get[UTC]Minutes()`: Retorna minutos (0-59).
- `get[UTC]Month()`: Retorna o mês (0-11).
- `get[UTC]Seconds()`: Retorna segundos (0-59).
- `getTime()`: Retorna milissegundos desde 1º de janeiro de
1970.
- `getTimezoneOffset()`: Retorna a diferença em minutos
em relação ao UTC.
- `getYear()`: Retorna o ano menos 1900 (obsoleto).
-
Métodos Set:

- `set[UTC]Date(day_of_month)`: Define o dia do mês.

- `set[UTC]FullYear(year, month, day)`: Define o ano (e
Instalar o aplicativo
opcionalmente mês e dia). Bookey para desbloquear
texto completo
- `set[UTC]Hours(hours, e áudio
mins, secs, ms)`: Define horas,
com opções para minutos, segundos e milissegundos.
Capítulo 19 Resumo : Documento

Objeto Document no JavaScript do lado do cliente

Visão Geral

O objeto Document representa um documento HTML e é um

componente chave no JavaScript do lado do cliente,
introduzido no JavaScript 1.0, com aprimoramentos
adicionais no JavaScript 1.1. Tanto o Netscape quanto o
Internet Explorer adicionaram recursos não padronizados ao
objeto Document, enquanto o padrão W3C DOM fornece
especificações adicionais.

Propriedades Comuns

-
alinkColor
: Cor de links ativados (obsoleto).
-
anchors[]
: Array de objetos Anchor no documento.
-
applets[]
: Array de objetos Applet no documento.
-
bgColor
: Cor de fundo (obsoleto).
-
cookie
: Gerencia cookies associados ao documento.
-
domain
: Especifica o domínio da Internet do documento para
segurança.
-
embeds[]
: Objetos representando dados incorporados através da tag
`<embed>`.
-
fgColor
: Cor padrão do texto (obsoleto).
-
forms[]
: Array de objetos Form no documento.
-
images[]
: Array de objetos Image no documento.
-
lastModified
: Data da última alteração no documento.
-
linkColor
: Cor de links não visitados (obsoleto).
-
links[]
: Array de objetos Link no documento.
-
location
: URL do documento (obsoleto).
-
plugins[]
: Sinônimo para embeds[].
-
referrer
: URL do documento que fez referência ao atual.
-
title
: Conteúdo textual da tag `<title>`.
-
URL
: URL do documento.
-
vlinkColor
: Cor de links visitados (obsoleto).

Propriedades W3C DOM

-
body
: Referência à tag `<body>` do documento.
-
defaultView
: A janela na qual o documento aparece.
-
documentElement
: Referência à tag `<html>` do documento.
-
implementation
: A implementação que criou o documento.

Propriedades do Internet Explorer 4

-
activeElement
: Refere-se ao elemento de entrada atualmente ativo.
-
all[]
: Array de todos os objetos Element no documento.
-
charset
: Conjunto de caracteres do documento.
-
children[]
: Filhos diretos do documento como um array.
-
defaultCharset
: Conjunto de caracteres padrão do documento.
-
expando
: Impede a expansão de objetos do lado do cliente.
-
parentWindow
: A janela que contém o documento.
-
readyState
: Estados de carregamento do documento (não inicializado,
carregando, interativo, completo).
Propriedades do Netscape 4

-
height
: Altura do documento em pixels.
-
layers[]
: Array de objetos Layer no documento (obsoleto).
-
width
: Largura do documento em pixels.

Métodos Comuns

-
clear()
: Apaga o conteúdo do documento (obsoleto).
-
close()
: Fecha um fluxo de documento.
-
open()
: Abre um fluxo para novo conteúdo de documento.
-
write(value...)
: Insere strings no documento.
-
writeln(value...)
: Insere strings com uma nova linha no documento.

Métodos W3C DOM

-
createAttribute(name)
: Cria um nó de atributo.
-
createComment(text)
: Retorna um novo nó de Comentário.
-
createDocumentFragment()
: Retorna um nó DocumentFragment vazio.
-
createElement(tagName)
: Cria um novo nó de Elemento.
-
createTextNode(text)
: Cria um nó de Texto com o texto especificado.
-
getElementById(id)
: Recupera um Elemento pelo seu id.
-
getElementsByName(name)
: Recupera elementos pelo seu nome.
-
getElementsByTagName(tagname)
: Recupera elementos pelo nome da tag.
-
importNode(importedNode, deep)
: Copia um nó de outro documento.

Métodos do Netscape 4

-
getSelection()
: Retorna o texto selecionado do documento sem tags HTML.

Métodos do Internet Explorer 4

-
elementFromPoint(x,y)
: Recupera o Elemento localizado nas coordenadas
especificadas.

Manipuladores de Eventos

O objeto Document suporta manipuladores de eventos

genéricos, semelhantes ao objeto Element. Manipuladores de
eventos como onload e onunload são propriedades do objeto
Window.

Tópicos Relacionados

Anchor, Applet, Element, Form, Image, Layer, Link,

Window.
Exemplo
Ponto chave:Compreendendo a importância do
objeto Document em JavaScript
Exemplo:O objeto Document serve como sua principal
interface para manipular e interagir com páginas da web
através do JavaScript, permitindo que você modifique
dinamicamente elementos HTML com base em ações ou
eventos do usuário.
Capítulo 20 Resumo : Elemento

Objeto Elemento no DOM

Visão Geral

O objeto Elemento representa um elemento ou tag HTML em

um documento, herdando propriedades do objeto Node,
conforme definido no DOM Nível 1. Vários navegadores,
incluindo IE 4 e posteriores, suportam acesso a elementos do
documento, mas com diferenças em suas implementações de
DOM.

Propriedades do DOM W3C

-
Nomes de Propriedade
: Correspondem a atributos HTML; palavras reservadas
requerem nomenclatura especial (por exemplo, className
para class).
-
Propriedades Comuns
:
-
className
: Cadeia de caracteres do atributo de classe.
-
style
: Objeto representando estilos CSS inline.
-
tagName
: Nome da tag do elemento, somente leitura.

Propriedades do DOM IE

- Definidas a partir do IE 4, distintas dos padrões W3C.

-
Propriedades Chave
:
-
all[]
: Array de objetos Elemento descendentes.
-
children[]
: Array de objetos Elemento filhos diretos.
-
innerHTML
: Texto HTML dentro do elemento.
-
offsetHeight/Width
: Dimensões do elemento.
-
outerHTML
: Representação completa em HTML, incluindo tags.

Métodos do DOM W3C

- Incluem métodos para manipular atributos e elementos:

-
getAttribute(name)
: Recupera o valor do atributo.
-
setAttribute(name, value)
: Define um atributo nomeado.
-
removeAttribute(name)
: Deleta um atributo nomeado.

Métodos do DOM IE
- Métodos não padronizados presentes no IE:
-
contains(target)
: Verifica se o elemento contém outro elemento.
-
insertAdjacentHTML(where, text)
: Insere HTML em posição especificada.
-
scrollIntoView(top)
: Rola a visualização para tornar o elemento visível.

Manipuladores de Eventos

- Os elementos respondem a várias ações do usuário por

meio de manipuladores de eventos:
-
onclick
: Ao clicar no usuário.
-
ondblclick
: Ao clicar duas vezes.
-
onkeydown/onkeyup
: Em atividade do teclado.
 -
onmousemove/onmouseout
: Em movimento do mouse sobre/fora do elemento.

Conceitos Relacionados

Referências a objetos adicionais que compartilham interação

com o objeto Elemento incluem Formulário, Entrada, Nó,
Selecionar e Área de Texto.
Capítulo 21 Resumo : Evento

Visão Geral do Objeto Evento

O objeto Evento fornece detalhes sobre um evento e controla

sua propagação em diferentes ambientes de navegador.
Existem diferentes padrões e implementações entre vários
navegadores, como o DOM Nível 2, Internet Explorer (IE) e
Netscape.

Objeto Evento DOM Nível 2

-
Tipos de Evento
: O objeto Evento é utilizado nos modelos de evento do
DOM e do Netscape, sendo passado como argumento para
manipuladores de eventos. Em contraste, o modelo IE acessa
o evento através da propriedade evento do objeto Window.
-
Constantes da Fase do Evento
:
-
Event.CAPTURING_PHASE
=1
-
Event.AT_TARGET
=2
-
Event.BUBBLING_PHASE
=3

Propriedades do DOM

Todas as propriedades são apenas leitura:

-
altKey
: Indica se a tecla Alt estava pressionada durante o evento.
-
bubbles
: Indica se o evento pode borbulhar.
-
button
: Identifica qual estado do botão do mouse mudou.
-
Instalar o aplicativo Bookey para desbloquear
cancelable
: Indica se a açãotexto
padrãocompleto e áudio
do evento pode ser cancelada.
-
Capítulo 22 Resumo : Global

Visão Geral do JavaScript Global

O objeto Global no JavaScript contém um conjunto de

propriedades e funções globais que podem ser acessadas
diretamente sem a necessidade de referenciar outro objeto.
Quaisquer variáveis e funções criadas no nível superior do
seu código são tratadas como propriedades do objeto Global.
No JavaScript do lado do cliente, esse objeto Global é
representado pelo objeto Window, que também inclui
métodos e propriedades adicionais.

Propriedades Globais

-
Infinity
: Representa a infinidade positiva.
-
NaN
: Representa um valor que não é um número.

Funções Globais
-
decodeURI(uri)
: Retorna uma versão decodificada do URI fornecido,
substituindo sequências de escape hexadecimal pelos seus
caracteres correspondentes.
-
decodeURIComponent(s)
: Semelhante ao decodeURI, mas funciona especificamente
em partes componentes de um URI.
-
encodeURI(uri)
: Codifica um URI, substituindo certos caracteres por
sequências de escape hexadecimal, enquanto deixa
separadores como #, ?, e @ não codificados.
-
encodeURIComponent(s)
: Semelhante ao encodeURI, mas codifica todos os caracteres
de pontuação.
-
escape(s)
: Retorna uma cópia codificada da string com certos
caracteres substituídos (depreciado em favor de encodeURI e
encodeURIComponent).
-
eval(code)
: Avalia uma string contendo código JavaScript e retorna o
resultado.
-
isFinite(n)
: Verifica se n é um número finito, retornando verdadeiro ou
falso.
-
isNaN(x)
: Verifica se x não é um número, retornando verdadeiro ou
falso.
-
parseFloat(s)
: Converte uma string em um número e o retorna.
-
parseInt(s, radix)
: Converte uma string em um inteiro com um argumento
radix opcional especificando a base (de 2 a 36).
-
unescape(s)
: Decodifica uma string anteriormente codificada com escape
(depreciado em favor de decodeURI e
decodeURIComponent).
Veja Também

-
Window
: O objeto que representa a janela do navegador e serve como
o contexto global para o JavaScript do lado do cliente.
Capítulo 23 Resumo : Input

JavaScript Client-side 1.0

Visão Geral do Objeto Input

O objeto Input representa elementos HTML `<input>` e

fornece propriedades para seus atributos.

Propriedades

-
checked
: Indica se uma caixa de seleção ou um botão de opção está
marcado.
-
defaultChecked
: Mostra se a caixa de seleção ou botão de opção estava
marcada inicialmente.
-
defaultValue
: Texto inicial para inputs de texto/senha; não aplicável a
inputs de arquivo.
-
form
: Referência apenas para leitura ao objeto Form que contém.
-
name
: O atributo de nome do elemento de input.
-
type
: Especifica o tipo de input como uma string (por exemplo,
"text," "checkbox," etc.).

Valores Legais para Type

- Inclui valores como "button," "checkbox," "file," "hidden,"

"image," "password," "radio," "reset," "text," e "submit."
-
value
: Representa o valor em string enviado com o formulário,
varia de acordo com o tipo de input.

Métodos
-
blur()
: Remove o foco do elemento de input.
-
click()
: Simula um clique do mouse no input.
-
focus()
: Define o foco do teclado no input.
-
select()
: Seleciona texto no input (aplicável para "text," "password,"
e "file").

Manipuladores de Eventos

-
onblur
: Acionado quando o elemento perde o foco.
-
onchange
: Ativado quando o texto é alterado e o foco é deslocado.
-
onclick
: Ativado em cliques de botão; pode prevenir o envio do
formulário.
-
onfocus
: Acionado quando o elemento ganha foco.

Referências a Objetos Relacionados

Inclui associações com objetos Form, Option, Select, e

Textarea.
Capítulo 24 Resumo : Camada

Camada Cliente-side Apenas para Netscape 4

Sinopse

- Fornece uma visão geral do objeto Camada, que é um

recurso não padrão exclusivo do Netscape 4 para lidar com
objetos posicionados dinamicamente.

Construção do Objeto Camada

- `[Link][i]`, `[Link][nome-da-camada]`
e `new Layer(largura, camada_pai)` podem ser usados para
referenciar ou criar camadas.

Descrição

- As camadas são representadas por elementos HTML com

posicionamento absoluto em CSS e podem ser criadas
usando a tag `<layer>` ou o construtor Layer. Esse recurso
foi descontinuado no Netscape 6.
Propriedades

-
acima
: Referência somente leitura para a camada acima.
-
fundo
: Imagem de fundo da camada.
-
abaixo
: Referência somente leitura para a camada abaixo.
-
corFundo
: Cor de fundo da camada.
-
recortar
: Propriedades que definem os limites e dimensões da área de
recorte (base, altura, esquerda, direita, topo, largura).
-
documento
Instalar osomente
: Referência aplicativo
leituraBookey para
para o objeto desbloquear
Documento
contido. texto completo e áudio
-
Capítulo 25 Resumo : Link

Link JavaScript do lado do cliente 1.0

Herança e Visão Geral

- O objeto Link herda da classe Element. Ele representa

elementos `<a>` ou `<area>` em HTML.

Propriedades do Objeto Link

- O objeto Link inclui várias propriedades que representam

diferentes partes de uma URL. Abaixo estão descrições e
exemplos baseados em uma URL fictícia: `[Link]
.com:1234/catalog/[Link]?q=JavaScript&m=10#results`
.
-
hash
: Uma string representando a parte do âncora da URL (por
exemplo, `#result`).

-
host
: Uma string representando o nome do host e a porta (por
exemplo, `[Link]`).

-
hostname
: Uma string apenas para o nome do host (por exemplo,
`[Link]`).

-
href
: A URL completa como uma string.

-
pathname
: A parte do caminho da URL (por exemplo,
`/catalog/[Link]`).

-
port
: Uma string representando a porta (por exemplo, `1234`).

-
protocol
: Uma string para o protocolo da URL, incluindo os dois
pontos (por exemplo, `http:`).

-
search
: Uma string para a parte da consulta da URL, incluindo o
ponto de interrogação (por exemplo,
`?q=JavaScript&m=10`).

-
target
: Uma string especificando o nome do objeto Window onde o
documento vinculado será aberto. Isso inclui os atributos de
destino HTML padrão (_blank, _top, _parent e _self).

Manipuladores de Evento para o Objeto Link

-
onclick
: Acionado quando o link é clicado. Pode retornar false no
JavaScript 1.1 para evitar seguir o link.

-
onmouseout
: Acionado quando o mouse sai do link, disponível no
JavaScript 1.1.

-
onmouseover
: Acionado quando o mouse passa sobre o link. Pode
modificar a propriedade status da janela e retornar true para
suprimir a exibição da URL na linha de status.

Conceitos Relacionados

- Inclui referências aos objetos Anchor e Location para uma

melhor compreensão do comportamento e das propriedades
do link.
Capítulo 26 Resumo : Math

Objeto Math em JavaScript

O objeto Math é um recurso fundamental no JavaScript que

organiza constantes e funções matemáticas. Ao contrário de
outros objetos, como Date e String, ele não possui um
construtor e suas funções são independentes, não métodos de
um objeto.

Constantes

-
Math.E
: Base do logaritmo natural.
-
Math.LN10
: Logaritmo natural de 10.
-
Math.LN2
: Logaritmo natural de 2.
-
Math.LOG10E
: Logaritmo base 10 de e.
-
Math.LOG2E
: Logaritmo base 2 de e.
-
[Link]
: Constante À.
-
Math.SQRT1_2
: 1 dividido pela raiz quadrada de 2.
-
Math.SQRT2
: Raiz quadrada de 2.

Funções

-
[Link](x)
: Valor absoluto de x.
-
[Link](x)
: Arcoseno de x (0 a À radianos).
-
[Link](x)
: Arcoseno de x (-À/2 a À/2 radianos).
-
[Link](x)
: Arcotangente de x (-À/2 a À/2 radianos).
-
Math.atan2(y, x)
: Ângulo anti-horário entre o eixo X positivo e o ponto (x, y).
-
[Link](x)
: Inteiro mais próximo maior ou igual a x.
-
[Link](x)
: Cosseno de x.
-
[Link](x)
: e elevado à potência de x.
-
[Link](x)
: Inteiro mais próximo menor ou igual a x.
-
[Link](x)
: Logaritmo natural de x.
-
[Link](args...)
: Maior dos argumentos especificados; retorna -Infinity se
não houver argumentos ou NaN para entradas não numéricas.
-
[Link](args...)
: Menor dos argumentos especificados; retorna Infinity se
não houver argumentos ou NaN para entradas não numéricas.
-
[Link](x, y)
: x elevado à potência de y.
-
[Link]()
: Número pseudo-aleatório entre 0.0 e 1.0.
-
[Link](x)
: Inteiro mais próximo de x.
-
[Link](x)
: Seno de x.
-
[Link](x)
: Raiz quadrada de x (retorna NaN se x < 0).
-
[Link](x)
: Tangente de x.
Tópico Relacionado

-
Número
: Para mais detalhes sobre operações e comportamentos
numéricos em JavaScript.
Capítulo 27 Resumo : Navegador

Informações sobre o Navegador e JavaScript do

Lado do Cliente 1.0

Sinopse

Esta seção fornece propriedades e métodos essenciais do

objeto `navigator`, utilizado em JavaScript para obter
informações sobre o navegador em uso.

Propriedades

-
appCodeName
: Uma string que indica o apelido do navegador,
normalmente "Mozilla" para os navegadores da Netscape e
da Microsoft.
-
appName
: Uma string que especifica o nome do navegador,
"Netscape" para os navegadores da Netscape e "Microsoft
Internet Explorer" para o IE.
-
appVersion
: Uma string que indica a versão do navegador e a
plataforma. O número da versão pode ser extraído usando
`parseInt()` ou `parseFloat()`.
-
cookieEnabled
: Um valor booleano que é verdadeiro se os cookies estão
ativados no navegador.
-
language
: Uma string que especifica o idioma padrão do navegador
usando códigos padrão de duas letras.
-
platform
: Uma string que indica o sistema operacional ou a
plataforma de hardware, como "Win32" ou "Linux i586".
-
systemLanguage
: Uma string que denota o idioma padrão do sistema
Instalar o aplicativo Bookey para desbloquear
operacional.
- texto completo e áudio
userAgent
Capítulo 28 Resumo : Nodo

Nodo DOM Nível 1

Definição

Um Nodo em uma árvore de documento é uma instância de

uma das várias subclasses, incluindo Atributo, Comentário,
Documento, Fragmento de Documento, Elemento e Texto.
Cada objeto Nodo tem uma propriedade `nodeType` que
indica sua subclass específica.

Constantes de Tipo de Nodo

As seguintes constantes definem valores legais para

`nodeType`:
- `Node.ELEMENT_NODE = 1` (Elemento)
- `Node.ATTRIBUTE_NODE = 2` (Atributo)
- `Node.TEXT_NODE = 3` (Texto)
- `Node.COMMENT_NODE = 8` (Comentário)
- `Node.DOCUMENT_NODE = 9` (Documento)
- `Node.DOCUMENT_FRAGMENT_NODE = 11`
(Fragmento de Documento)

Propriedades do Nodo

- `attributes[]`: Array somente leitura de objetos Atributo

para nós Elemento.
- `childNodes[]`: Array somente leitura de objetos Nodo
filhos.
- `firstChild`: O primeiro Nodo filho ou nulo se nenhum
existir.
- `lastChild`: O último Nodo filho ou nulo se nenhum existir.
- `nextSibling`: O próximo Nodo irmão ou nulo se nenhum
existir.
- `nodeName`: O nome do nodo, varia de acordo com o tipo
de nodo.
- `nodeType`: Especifica o tipo do nodo.
- `nodeValue`: Contém o valor string, leitura/escrita para nós
Texto e Comentário.
- `ownerDocument`: O objeto Documento que contém este
Nodo ou nulo para nós Documento.
- `parentNode`: O Nodo contêiner ou nulo para nós sem um
pai.
- `previousSibling`: O Nodo irmão anterior ou nulo se
nenhum existir.
Métodos do Nodo

- `addEventListener(type, listener, useCapture)`: Registra um

ouvinte de evento.
- `appendChild(newChild)`: Adiciona um novo Nodo filho à
árvore de documento.
- `cloneNode(deep)`: Retorna uma cópia do nodo,
opcionalmente incluindo descendentes.
- `hasAttributes()`: Verifica se há atributos em um nodo
Elemento.
- `hasChildNodes()`: Verifica se o nodo tem filhos.
- `insertBefore(newChild, refChild)`: Insere um novo filho
antes de um filho de referência especificado.
- `isSupported(feature, version)`: Verifica o suporte para uma
versão de recurso.
- `normalize()`: Consolida nós Texto adjacentes e remove nós
Texto vazios.
- `removeChild(oldChild)`: Remove um Nodo filho
especificado.
- `removeEventListener(type, listener, useCapture)`: Remove
um ouvinte de evento.
- `replaceChild(newChild, oldChild)`: Substitui um Nodo
filho antigo por um novo Nodo filho.
Subclasses Relacionadas

Inclui Atributo, Comentário, Documento, Fragmento de

Documento, Elemento e Texto.
Capítulo 29 Resumo : Número

Resumo do Capítulo 29: Números em JavaScript

Construtor Number

- O construtor `Number` pode ser usado com o operador

`new` para criar um novo objeto `Number`. Sem o `new`, ele
funciona como uma função de conversão, retornando um
valor numérico.

Constantes

-
Number.MAX_VALUE
: Maior número representável (~1.79E+308).
-
Number.MIN_VALUE
: Menor número representável (~5E-324).
-
[Link]
: Representa 'Não é um número'.
-
Number.NEGATIVE_INFINITY
: Valor infinito negativo.
-
Number.POSITIVE_INFINITY
: Valor infinito positivo.

Métodos

-
toExponential(dígitos)
: Retorna uma string em notação exponencial com um
número especificado de dígitos depois do ponto decimal
(0-20).
-
toFixed(dígitos)
: Retorna uma string com exatamente o número especificado
de dígitos decimais (0-20) sem notação exponencial.
-
toLocaleString()
: Retorna uma representação de string do número,
dependente da localidade.
-
toPrecision(precisão)
: Retorna uma representação de string contendo um número
especificado de dígitos significativos (1-21).
-
toString(base)
: Converte um número em uma string em uma base
especificada (2-36); por padrão, usa a base 10 se omitida.

Referência Relacionada

- Informações adicionais podem ser encontradas na

documentação do objeto Math.
Capítulo 30 Resumo : Objeto

Objeto em JavaScript

Construtor

- O construtor `new Object();` cria um objeto vazio que pode

ter propriedades arbitrárias adicionadas.

Propriedades dos Objetos em JavaScript

-
constructor
: Uma referência à função que criou o objeto (JS 1.1; JScript
2.0; ECMA v1).

Métodos dos Objetos em JavaScript

1.
hasOwnProperty(propname)
:
- Retorna `true` se o objeto tem uma propriedade não
herdada com o nome especificado; caso contrário, retorna
`false` (JS 1.5; JScript 5.5; ECMA v3).

2.
isPrototypeOf(o)
:
- Retorna `true` se o objeto é o protótipo de `o`; caso
contrário, retorna `false` (JS 1.5; JScript 5.5; ECMA v3).

3.
propertyIsEnumerable(propname)
:
- Retorna `true` se o objeto tem uma propriedade
enumerável não herdada com o nome especificado (JS 1.5;
JScript 5.5; ECMA v3).

4.
toLocaleString()
:
- Retorna uma representação de string localizada do objeto.
Normalmente chama `toString()`, mas subclasses podem
Instalar oisso
sobrescrever aplicativo Bookey
(JS 1.5; JScript para desbloquear
5.5; ECMA v3).
texto completo e áudio
5.
Capítulo 31 Resumo : RegExp

Expressões Regulares em JavaScript

Visão Geral

Expressões regulares (RegExp) são utilizadas em JavaScript

para correspondência de padrões. Elas podem ser definidas
usando a sintaxe literal ou por meio de um construtor.

Sintaxe

-
Sintaxe Literal
: `/padrão/atributos`
-
Construtor
: `new RegExp(padrão, atributos)`

Propriedades da Instância

-
global
: Indica se a RegExp possui o atributo 'g' para
correspondência global (booleano somente leitura).
-
ignoreCase
: Indica se a RegExp possui o atributo 'i' para
correspondência sem distinção entre maiúsculas e minúsculas
(booleano somente leitura).
-
lastIndex
: Para objetos globais, esta propriedade (leitura/escrita)
mostra a posição após a última correspondência para a
próxima busca.
-
multiline
: Indica se a RegExp possui o atributo 'm' para
correspondência em várias linhas (booleano somente leitura).
-
source
: Uma string somente leitura contendo o padrão da expressão
regular sem as barras e atributos.

Métodos
-
exec(string)
: Compara uma string com a RegExp e retorna um array de
resultados da correspondência ou null se nenhuma
correspondência for encontrada. O array inclui o texto
correspondente e quaisquer correspondências de
subexpressões, juntamente com uma propriedade de índice
que indica a posição de início da correspondência.
-
test(string)
: Retorna verdadeiro se a string contém uma correspondência
para a RegExp; caso contrário, retorna falso.

Métodos Relacionados

- [Link]()
- [Link]()
- [Link]()
Capítulo 32 Resumo : Select

JavaScript 1.0: Visão Geral do Objeto Select

Herança

- Herda do objeto Element.

Sinopse

- Acessível via:
- `[Link][i]`
- `[Link][nome_do_elemento]`
- `form.nome_do_elemento`

Propriedades

-
form
: O objeto Form que contém (somente leitura).
-
length
: O número de elementos no array de opções (somente
leitura).
-
options[]
: Array de objetos Option; pode ser manipulado modificando
`[Link]` ou definindo elementos individuais como
nulos.
-
selectedIndex
: Inteiro de leitura/escrita para o índice da opção selecionada;
-1 se nenhuma estiver selecionada. Deseleciona todas se
definido como -1.
-
type
: String somente leitura que indica o tipo de seleção
("select-one" para único, "select-multiple" para múltiplo).

Métodos

-
add(novo, antigo)
: Insere um novo objeto Option antes do antigo no array de
opções; adiciona ao final se o antigo for nulo.
-
blur()
: Libera o foco do teclado.
-
focus()
: Obtém o foco do teclado.
-
remove(n)
: Remove o enésimo elemento do array de opções.

Manipuladores de Evento

-
onblur
: Acionado quando o foco é perdido.
-
onchange
: Acionado quando um item é selecionado/deselecionado.
-
onfocus
: Acionado quando o foco é adquirido.

Conceitos Relacionados

- Consulte os objetos Form, Input e Option para mais

contexto.
Capítulo 33 Resumo : String

Strings em JavaScript

Visão Geral

- A manipulação de strings é uma característica fundamental

em JavaScript, introduzida no JavaScript 1.0, JScript 1.0 e
padronizada na ECMA v1.
- O tipo `String` herda do objeto base `Object`.

Construtor

- `String(s)` - Sem o operador `new`, converte seu argumento

em uma string. Com `new`, cria um objeto String.

Propriedades

- `length` - Uma propriedade somente para leitura que

representa o número de caracteres na string.

Métodos
1.
Acesso a Caracteres

- `charAt(n)` - Retorna o caractere na posição `n`.

- `charCodeAt(n)` - Retorna a codificação Unicode do
caractere na posição `n`.
2.
Manipulação de Strings

- `concat(value...)` - Concatena strings.

- `indexOf(substring, start)` - Retorna a posição da primeira
ocorrência de `substring` após `start` ou -1 se não
encontrado.
- `lastIndexOf(substring, start)` - Retorna a posição da
última ocorrência antes de `start` ou -1 se não encontrado.
3.
Correspondência de Padrões

- `match(regexp)` - Compara a string com um padrão regex

e retorna os resultados da correspondência.
Instalar o aplicativo
- `replace(regexp, Bookey
replacement)` para desbloquear
- Substitui o texto que
corresponde a um texto
regexcompleto e áudio especificado.
por um `replacement`
- `search(regexp)` - Encontra a posição inicial da primeira
Capítulo 34 Resumo : Estilo

Estilo DOM Nível 2: Propriedades CSS Inline no IE

4

Sinopse

O objeto Style em JavaScript é utilizado para manipular as

propriedades CSS inline de um elemento. Ele compreende
propriedades correspondentes aos atributos CSS definidos
pela especificação CSS2. A nomenclatura dessas
propriedades imita de perto suas contrapartes em CSS, com
modificações para garantir a compatibilidade com JavaScript,
como a remoção de hífens e a capitalização de palavras
subsequentes.

Propriedades Principais

- Atributos compostos como `font-family` são reescritos

como `fontFamily`.
- A propriedade `float` é renomeada para `cssFloat` devido a
conflitos com palavras reservadas no JavaScript.
Notas Importantes

- Todas as propriedades são representadas como strings. Para

propriedades com valores numéricos, é essencial usar
`parseFloat()` para converter strings em números ao
consultar, e converter números de volta em strings ao definir
propriedades (tipicamente adicionando unidades como "px").
- Nem todas as propriedades são implementadas pelos
navegadores atuais, então é aconselhável consultar
referências de CSS para significados e valores válidos.

Lista de Propriedades CSS Visuais

- background, backgroundColor, backgroundImage,

backgroundPosition, backgroundRepeat
- border (várias subpropriedades), borderCollapse,
borderColor, borderStyle, borderWidth
- color, cursor, display, direction
- font (várias subpropriedades), fontSize, fontWeight,
fontStyle
- height, left, right, top, width
- margin (várias subpropriedades), padding (várias
subpropriedades)
- overflow, position, visibility, zIndex
Essas propriedades permitem uma manipulação detalhada da
apresentação de um elemento no desenvolvimento web. Para
orientações abrangentes, consulte referências específicas de
CSS.
Capítulo 35 Resumo : Window

Resumo do Capítulo 35: Objeto Window e

JavaScript do Lado do Cliente

Sinopse

Este capítulo aborda o objeto Window no JavaScript do lado

do cliente, detalhando suas propriedades, métodos,
manipulação de eventos e suas implicações na programação
dentro dos navegadores web.

Propriedades do Objeto Window

-
Propriedades Básicas:

- `closed`: Booleano que indica se a janela está fechada.

- `defaultStatus`: Mensagem de status exibida quando
nenhuma outra mensagem está visível.
- `document`: Referência ao objeto Document na janela.
- `frames[]`: Array de objetos Window representando cada
frame dentro da janela.
- `location`: Objeto location representando a URL atual da
janela.
- `navigator`: Referência ao objeto Navigator que fornece
informações do navegador.
-
Propriedades Específicas do Netscape 4:

- `innerHeight`, `innerWidth`: Dimensões da área de

exibição do documento.
- `outerHeight`, `outerWidth`: Dimensões totais da janela.
- `pageXOffset`, `pageYOffset`: Posições de rolagem.
-
Propriedades Específicas do Internet Explorer 4:

- `clientInformation`: Alias para navigator.

- `event`: Referência ao objeto de evento mais recente.

Métodos do Objeto Window

-
Métodos Comuns:

- `alert()`: Exibe uma mensagem em uma caixa de diálogo.

 - `confirm()`: Exibe um diálogo de sim/não e retorna a
escolha do usuário.
- `prompt()`: Solicita a entrada do usuário com um valor
padrão.
- `setTimeout()` e `setInterval()`: Agendam ações após
intervalos de tempo especificados.
- `open()`: Abre uma nova janela com uma URL e
características especificadas.

Manipuladores de Evento

Esses são definidos usando atributos dentro de tags HTML,

como `onload`, `onresize` e `onclick`, que acionam funções
JavaScript em eventos específicos.

Restrições de Segurança do JavaScript

Medidas de segurança limitam as capacidades dos scripts do

lado do cliente, como impedir o acesso a diferentes domínios
e controlar funcionalidades de upload de arquivos.

Conclusão

O objeto Window serve como a base para o JavaScript do

lado do cliente, permitindo interação com páginas web
através de métodos e propriedades que influenciam o
comportamento do navegador e a apresentação de conteúdo.
Exemplo
Ponto chave:Compreender o objeto Window é
essencial para o desenvolvimento eficaz de
JavaScript no lado do cliente.
Exemplo:Ao se aprofundar no JavaScript do lado do
cliente, imagine-se criando um aplicativo web dinâmico.
Você pode usar o método `alert()` para informar os
usuários sobre atualizações importantes, chamando sua
atenção. Ao manipular a propriedade `location`, imagine
que você está redirecionando os usuários para uma
experiência mais personalizada em seu site, melhorando
sua jornada. Ao definir manipuladores de eventos com
atributos como `onclick`, pense em fazer um botão que
realmente responda aos cliques dos usuários, oferecendo
feedback ou ações instantâneas. Cada interação depende
do seu entendimento do objeto Window, pois ele rege
todas essas funções essenciais, tornando seus scripts não
apenas interativos, mas também intuitivos e fáceis de
usar.
Melhores frases do JavaScript por David
Flanagan com números de página
Ver no site do Bookey e gerar imagens de citações bonitas

Capítulo 1 | Frases das páginas 14-17

[Link] é uma linguagem sensível a maiúsculas
e minúsculas.
[Link] ignora espaços em branco entre tokens.
[Link] instruções JavaScript terminam com ponto e vírgula.
[Link] de variáveis, funções e rótulos são identificadores
em JavaScript.
[Link] seguintes palavras-chave fazem parte da linguagem
JavaScript e têm significados especiais para o interpretador
JavaScript.
Capítulo 2 | Frases das páginas 20-27
[Link] números em JavaScript são representados no
formato de ponto flutuante de 64 bits.
[Link] string em JavaScript é uma sequência de letras,
dígitos e outros caracteres arbitrários do conjunto de
caracteres Unicode de 16 bits.
[Link] objeto é um tipo de dado composto que contém
qualquer número de propriedades.
4.O primeiro elemento de um array em JavaScript é o
elemento 0.
[Link] função é um pedaço de código JavaScript que é
definido uma vez e pode ser executado múltiplas vezes por
um programa.
Capítulo 3 | Frases das páginas 28-32
[Link]ões JavaScript são formadas pela
combinação de valores usando operadores
JavaScript.
[Link]ênteses podem ser usados em uma expressão para
agrupar subexpressões e alterar a ordem padrão de
avaliação.
[Link] define um conjunto completo de operadores, a
maioria dos quais deve ser familiar para programadores de
C, C++ e Java.
4.O operador de identidade, ===, é mais estrito: ele só avalia
como verdadeiro se seus operandos forem idênticos.
[Link] operadores relacionais <, <=, >, e >= comparam strings
com base na ordem alfabética.
Capítulo 4 | Frases das páginas 33-40
[Link] uma sequência de declarações em
JavaScript é cercada por chaves, conta como uma
única declaração composta.
2.A declaração return faz com que a função atualmente em
execução pare de executar e retorne ao seu chamador.
3.A declaração try/catch/finally é o mecanismo de tratamento
de exceções do JavaScript.
4.A declaração for é um loop fácil de usar que combina
expressões de inicialização e incremento com a expressão
de condição do loop.
[Link] declaração pode ser rotulada com um nome.
Capítulo 5 | Frases das páginas 41-43
[Link] JavaScript são arrays associativos que
associam valores a propriedades nomeadas.
[Link] definir uma nova classe, comece escrevendo uma
função construtora.
[Link] função JavaScript usada como construtora possui uma
propriedade chamada prototype.
[Link] um método chamado toString permite que
instâncias da sua classe sejam convertidas em strings.
[Link] você quiser definir métodos ou propriedades estáticas
(ou de classe), pode atribuí-los diretamente à função
construtora.
[Link] fragmentos de código anteriores definem uma classe
Point simples que podemos usar com código assim
Capítulo 6 | Frases das páginas 44-48
[Link] suporta expressões regulares para
correspondência de padrões com a mesma sintaxe
da linguagem de programação Perl.
[Link] expressão regular é especificada literalmente em um
programa JavaScript como uma sequência de caracteres
dentro de caracteres barra (/)
[Link] JavaScript 1.5, qualquer um dos caracteres de repetição
pode ser seguido por um ponto de interrogação para
torná-los não-guloso, o que significa que correspondem ao
menor número de repetições possível enquanto ainda
permitem que o padrão completo corresponda.
[Link] expressões regulares usam parênteses para agrupar
subexpressões, assim como fazem as expressões
matemáticas.
[Link] âncora em uma expressão regular corresponde a uma
posição em uma string sem corresponder a nenhum dos
caracteres de uma string.
Capítulo 7 | Frases das páginas 49-90
[Link] é uma linguagem de script leve e
baseada em objetos que pode ser incorporada em
páginas HTML.
2.O código JavaScript também pode aparecer como o valor
de um atributo de manipulador de eventos de uma tag
HTML.
[Link] você faz isso, no entanto, deve escrever o conteúdo
completo do novo documento e lembrar de chamar o
método [Link]() quando terminar.
4.O objeto Window representa uma janela do navegador da
web.
5.O JavaScript trata cada quadro como um objeto Window
separado, e os scripts em diferentes quadros são executados
independentemente uns dos outros.
[Link], ou HTML Dinâmico, é o resultado da
combinação de HTML, CSS e JavaScript: utiliza scripts
para modificar dinamicamente o estilo, que pode incluir a
posição e a visibilidade dos elementos do documento.
[Link] motivos de segurança, as implementações de
JavaScript do lado do cliente normalmente impõem
restrições às tarefas que os scripts podem executar.
Capítulo 8 | Frases das páginas 93-96
[Link] JavaScript 1.1 e versões posteriores, você pode
usar o atributo src da tag <script> para especificar
a URL de um script externo que deve ser
carregado e executado.
[Link] permite que scripts sejam escritos em linguagens
além do JavaScript, e alguns navegadores, como o Internet
Explorer, suportam linguagens como VBScript.
[Link] JavaScript, defina esse atributo como o tipo MIME
"text/javascript": <script src="[Link]"
language="JavaScript1.5" type="text/javascript"></script>
[Link] nomes dos atributos de manipulador de eventos sempre
começam com "on". O código especificado por um desses
atributos é executado quando o evento nomeado ocorre.
Capítulo 9 | Frases das páginas 97-105
1.O objeto Window representa uma janela do
 navegador web.
2.A propriedade mais importante do objeto Window é
document.
[Link]( ) permite que você exiba uma mensagem para o
usuário, confirm( ) permite que você pergunte ao usuário
uma questão de sim ou não, e prompt( ) permite que você
peça ao usuário para inserir uma única linha de texto.
[Link]ê também pode usar timers para especificar o código
que deve ser executado quando uma quantidade específica
de milissegundos tiver decorrido.
5.A propriedade history do objeto Window refere-se ao
objeto History da janela do navegador.
[Link] importante do que esses métodos que manipulam uma
janela existente estão o método open( ) que cria uma nova
janela do navegador e o método close( ) que fecha uma
janela criada pelo script.
[Link] trata cada frame como um objeto Window
separado, e scripts em diferentes frames são executados
independentemente uns dos outros.
Capítulo 10 | Frases das páginas 106-108
1.O objeto Document é, sem dúvida, mais
importante do que o próprio objeto Window:
enquanto o Window representa a janela do
navegador, o objeto Document representa o
documento HTML que é exibido nessa janela.
2.A forma como o conteúdo do documento é acessado e
modificado é chamada de modelo de objeto de documento,
ou DOM.
3.O DOM W3C não é completamente compatível com o
DOM do IE 4, mas ele padroniza muitos dos recursos
legados do DOM original.
Capítulo 11 | Frases das páginas 109-117
1.O DOM legado não oferece nenhuma maneira de
se referir ao conteúdo do documento, exceto
formulários, elementos de formulário, imagens,
applets, links e âncoras.
2.O método write( ) pode ser usado a partir de uma tag
<script> apenas enquanto um documento ainda está
 carregando.
[Link] o manipulador onsubmit retornar falso, o formulário não
é submetido.
[Link] mudar a imagem que é exibida, basta definir esta
propriedade para uma nova URL.
[Link] cookie com o nome e valor especificados para este
documento.
Capítulo 12 | Frases das páginas 118-124
1.O W3C DOM padroniza a maioria dos recursos do
DOM legado, mas também adiciona novos e
importantes recursos.
2.O W3C DOM representa cada documento como uma
árvore.
[Link] maneira fácil de manipular documentos HTML com o
W3C DOM é simplesmente definir as propriedades que
correspondem aos atributos HTML.
4.O W3C DOM permite alterar a estrutura da árvore do
próprio documento.
Capítulo 13 | Frases das páginas 125-129
1.O DOM do IE 4 não suporta o método
getElementById().
[Link]ê pode percorrer uma árvore de documentos do IE 4...
em vez de childNodes[], o IE 4 usa children[], e em vez de
parentNode, o IE 4 usa parentElement.
3.O DOM do IE 4 não tem métodos para criar, inserir,
remover ou substituir nós da árvore do documento.
[Link] entanto, ele suporta a propriedade very important
innerHTML, que permite substituir o conteúdo de qualquer
elemento do documento por uma string arbitrária de
HTML.
Capítulo 14 | Frases das páginas 130-134
[Link], ou HTML Dinâmico, é o resultado da
combinação de HTML, CSS e JavaScript: utiliza
scripts para modificar dinamicamente o estilo...
[Link] propriedades de posicionamento e visibilidade são
particularmente relevantes para scripting dinâmico.
[Link] que os valores de todas as propriedades de estilo são
 sempre strings, mesmo para propriedades como left e width
que representam números.
[Link] vez que é chamado, a função nextFrame( ) move um
elemento 10 pixels para a direita...
[Link]ós 20 invocações, a função usa a propriedade de
visibilidade para esconder o elemento e para de se chamar.
Capítulo 15 | Frases das páginas 135-141
[Link], se um manipulador de eventos
retorna falso, a ação padrão (como seguir um
hyperlink ou enviar um formulário) não é
realizada.
2.O mesmo é verdadeiro para os manipuladores de eventos.
Se seu documento HTML incluir uma única tag <form>
com um atributo de manipulador de eventos onsubmit, esse
manipulador de eventos estará disponível como:
[Link][0].onsubmit
[Link] manipuladores de eventos são acionados apenas para o
elemento do documento onde o evento ocorreu.
[Link] modelos avançados, os eventos podem se propagar
 para cima e/ou para baixo na hierarquia de elementos e ser
manipulados por um ou mais manipuladores de eventos.
[Link] permite que aplicações avançadas registrem mais de
um manipulador para o mesmo tipo de evento.
Capítulo 16 | Frases das páginas 142-145
1.'Scripts só podem ler propriedades de janelas e
documentos que foram carregados a partir do
mesmo servidor web.'
2.'Scripts não podem definir a propriedade de valor do
elemento de formulário FileUpload.'
3.'Um script só pode fechar janelas do navegador que ele
criou, a menos que obtenha a confirmação do usuário.'
4.'À medida que o uso de JavaScript cresceu, anunciantes e
personagens duvidosos começaram a fazer coisas irritantes
com ele.'
5.'Navegadores mais novos, como o Mozilla 1.0, permitem
restrições de segurança configuráveis pelo usuário que
podem impedir scripts de abrir novas janelas.'
Capítulo 17 | Frases das páginas 156-159
[Link] exemplo: var a = [1, true, 'abc'];
[Link] o valor dessa propriedade encurta ou estende o
array.
[Link] a string resultante da conversão de cada elemento
 de um array em uma string e depois concatenando as
strings, com a string separadora entre os elementos.
[Link] e retorna o último elemento do array, diminuindo
o tamanho do array.
[Link] os elementos de um array e retorna uma
referência ao array.
[Link] o argumento ou os argumentos como novos
elementos no início de um array, deslocando os elementos
existentes do array para cima para abrir espaço.
Capítulo 18 | Frases das páginas 171-177
[Link] argumentos, o construtor Date( ) cria um
objeto Date definido para a data e hora atuais.
[Link] chamado como uma função sem o operador new,
Date( ) ignora quaisquer argumentos passados e retorna
uma representação em string da data e hora atuais.
[Link] o número de milissegundos entre a meia-noite
(UTC) de 1º de janeiro de 1970 e a data e hora
representadas pelo objeto Date.
[Link] uma string que representa a parte da data, expressa
 no fuso horário local.
[Link] a representação interna da data em milissegundos.
Retorna o argumento em milissegundos.
Capítulo 19 | Frases das páginas 178-186
1.O objeto Document representa um documento
HTML e é um dos objetos mais importantes no
JavaScript do lado do cliente.
[Link] Comuns Todas as implementações do objeto
Document suportam as seguintes propriedades.
3.A API depende do controle específico.
[Link] propriedade pode ser particularmente útil para
programadores que estão mudando para JavaScript após se
acostumarem a linguagens sem diferenciação de
maiúsculas.
[Link] Especifica o status de carregamento de um
documento.
Capítulo 20 | Frases das páginas 189-197
1.... todos os elementos em um documento HTML
possuem propriedades que correspondem aos seus
atributos HTML...
[Link], os métodos e propriedades definidos pelo
DOM do IE 4 não são os mesmos que os métodos e
 propriedades definidos pelo padrão DOM da W3C.
[Link] esta propriedade substitui o conteúdo do elemento.
[Link] as propriedades deste objeto altera o estilo de
exibição do elemento.
[Link] HTML contido dentro do elemento, sem incluir as
tags de abertura e fechamento do próprio elemento.
Capítulo 21 | Frases das páginas 200-208
1.O objeto Event serve para fornecer tanto detalhes
sobre um evento quanto controle sobre a
propagação de um evento.
2.O DOM Level 2 define um objeto Event padrão, mas o
Internet Explorer 4, 5 e 6 usam um objeto proprietário em
vez disso.
[Link] objeto Event é passado como um argumento para o
manipulador de eventos.
4.A fase atual de propagação de eventos é representada pela
propriedade eventPhase.
[Link] ao navegador da web para não realizar a ação padrão
associada a este evento.
[Link] que o evento se propague mais adiante através das
fases de captura, alvo ou borbulhamento da propagação de
eventos.
Capítulo 22 | Frases das páginas 215-218
1.O objeto Global não tem nome, mas você pode se
referir a ele no código de nível superior (ou seja,
fora dos métodos) com a palavra-chave this.
[Link]: Um valor numérico que representa a infinidade
positiva.
[Link]: O valor não é um número.
[Link](código) Avalia uma string de código JavaScript e
retorna o resultado.
[Link](n): Retorna verdadeiro se n é (ou pode ser
convertido para) um número finito.
[Link](s, radix): Converte a string s (ou um prefixo de s)
em um inteiro e retorna esse inteiro.
Capítulo 23 | Frases das páginas 224-228
1.O objeto Input define propriedades para cada um
dos atributos da tag HTML <input>.
[Link] Um booleano de leitura/escrita que especifica se
um elemento de entrada do tipo 'checkbox' ou 'radio' está
marcado (true) ou não (false).
[Link] Uma string que especifica o texto que aparece
em um elemento de entrada do tipo 'text' ou 'password'
quando é criado pela primeira vez ou quando é redefinido
para seu estado inicial.
[Link] O valor string que é enviado quando o formulário é
submetido.
[Link]( ) Simula um clique do mouse no elemento do
formulário e não retorna nada.
[Link] Para elementos de entrada de texto do tipo 'text',
'password' e 'file', este manipulador de eventos é invocado
quando o usuário altera o texto exibido e, em seguida,
transfere o foco do teclado para fora do elemento.
[Link] Handlers onblur Invocado quando o elemento perde
o foco do teclado.
Capítulo 24 | Frases das páginas 229-233
1.O objeto Layer é suportado apenas no Netscape 4
e foi descontinuado no Netscape 6.
[Link] elemento HTML com um atributo de posição
CSS definido como absoluto é representado por um objeto
 Layer.
[Link] duas camadas se sobrepõem, aquela com o zIndex
mais alto aparece por cima e obscurece a com o zIndex
mais baixo.
[Link] essa propriedade também define o valor de
[Link].
[Link] uma camada acima de outra e não retorna nada.
Capítulo 25 | Frases das páginas 234-236
[Link] propriedade de string de leitura/gravação
que especifica a parte âncora da URL do Link,
incluindo o sinal de hash (#) à frente.
[Link] exemplo: "[Link]".
[Link] nomes especiais "_blank", "_top", "_parent" e "_self"
são permitidos.
[Link] JavaScript, este manipulador de eventos pode impedir
que o link seja seguido retornando falso.
5.A propriedade de status da janela atual pode ser definida
aqui.
Capítulo 26 | Frases das páginas 239-242
1.O objeto Math é um espaço reservado para
agrupar constantes e funções matemáticas.
[Link](x) Retorna o valor absoluto de x.
[Link](args...) Retorna o maior dos argumentos.
[Link]() Retorna um número pseudo-aleatório entre
0.0 e 1.0.
[Link](x) Retorna a raiz quadrada de x.
Capítulo 27 | Frases das páginas 243-246
[Link] Uma string somente leitura que
especifica um apelido para o navegador. Em todos
os navegadores Netscape, esse apelido é 'Mozilla'.
[Link] Um booleano somente leitura que é
verdadeiro se o navegador tiver cookies habilitados e falso
se estiver desabilitados.
[Link] Uma string somente leitura que especifica o
valor que o navegador usa para o cabeçalho user-agent nas
requisições HTTP.
Capítulo 28 | Frases das páginas 247-252
[Link] os nós em um documento HTML são
instâncias de uma das subclasses de Node listadas
acima.
[Link] objeto Node possui uma propriedade nodeType que
especifica qual das subclasses é uma instância.
[Link](newChild) Adiciona o novo nó newChild à
árvore do documento ao anexá-lo ao array childNodes[]
deste nó.
[Link](oldChild) Remove o nó oldChild da árvore
do documento.
[Link]() Normaliza todos os nós de texto descendentes
deste nó, deletando nós de texto vazios e mesclando nós de
texto adjacentes.
Capítulo 29 | Frases das páginas 253-255
[Link].MAX_VALUE O maior número
representável. Aproximadamente 1,79E+308.
[Link].MIN_VALUE O menor número representável.
Aproximadamente 5E-324.
[Link] Valor não numérico. O mesmo que o NaN
global.
[Link].NEGATIVE_INFINITY Valor negativo infinito.
[Link].POSITIVE_INFINITY Valor infinito. O mesmo
que o Infinito global.
Capítulo 30 | Frases das páginas 256-258
[Link] construtor cria um objeto vazio ao qual você
pode adicionar propriedades arbitrárias.
[Link] verdadeiro se o objeto tiver uma propriedade não
herdada com o nome especificado.
[Link] verdadeiro se este objeto for o protótipo de o.
[Link] verdadeiro se este objeto tiver uma propriedade
enumerable não herdada com o nome especificado.
[Link] uma representação de string localizada do objeto.
6.A implementação deste método fornecida pela classe
Object é bastante genérica e não fornece muitas
informações úteis.
Capítulo 31 | Frases das páginas 261-263
1./padrão/atributos
[Link] RegExp(padrão, atributos)
[Link] Um booleano somente leitura que especifica se o
RegExp tem o atributo g e, portanto, realiza
correspondência global.
[Link] Um booleano somente leitura que especifica se
o RegExp tem o atributo i e, portanto, realiza
correspondência sem distinção de maiúsculas e minúsculas.
[Link] Para objetos RegExp globais, esta propriedade de
leitura/escrita especifica a posição do caractere
imediatamente após a última correspondência; este é o
primeiro caractere examinado para a próxima
correspondência.
[Link]( string) Corresponde a string contra este RegExp e
retorna um array contendo os resultados da
correspondência, ou null se nenhuma correspondência foi
encontrada.
Capítulo 32 | Frases das páginas 266-269
1.O objeto Select define propriedades para cada um
dos atributos da tag HTML <select>, como
desativado, múltiplo, nome e tamanho.
[Link]ê pode remover opções individuais definindo um
elemento do array como nulo – isso desloca os elementos
acima dele para baixo, encurtando o array.
[Link] esta propriedade faz com que todas as outras
opções se tornem desmarcadas. Defini-la como -1 faz com
que todas as opções sejam desmarcadas.
[Link] o objeto Select permitir apenas uma única seleção (ou
seja, se o atributo múltiplo não aparecer na definição
HTML do objeto), esta propriedade é 'select-one'.
Capítulo 33 | Frases das páginas 270-274
[Link] o operador new, a função String( ) converte
seu argumento em uma string.
[Link] uma nova string que resulta da conversão de cada
um dos argumentos em uma string e da concatenação das
strings resultantes.
[Link] a posição da primeira ocorrência de uma substring
 dentro desta string que aparece na posição inicial ou após
ela, ou -1 se nenhuma ocorrência for encontrada.
[Link] uma nova string, com o texto que coincide com a
regexp substituído pela substituição.
[Link] um array de strings, criado ao dividir a string em
substrings nos limites especificados pelo delimitador.
[Link] uma cópia da string, com todas as letras
maiúsculas convertidas para suas equivalentes minúsculas.
Capítulo 34 | Frases das páginas 275-278
1.O objeto Style define um grande número de
propriedades: uma propriedade para cada
atributo CSS definido pela especificação CSS2.
[Link] de múltiplas palavras que contêm hifens, como
font-family, são escritos sem hifens em JavaScript, e cada
palavra após a primeira é capitalizada: fontFamily.
[Link] que navegadores atuais não implementam todas
essas propriedades.
[Link] as propriedades são strings, e é necessário ter
cuidado ao trabalhar com propriedades que têm valores
numéricos.
Capítulo 35 | Frases das páginas 285-366
1.O objeto Window é o objeto global para
JavaScript do lado do cliente.
[Link] é uma linguagem de script leve e baseada em
objetos que pode ser incorporada em páginas HTML.
[Link]ões em JavaScript são formadas pela combinação
de valores usando operadores do JavaScript.
[Link] suporta três tipos de dados primitivos: números,
booleanos e strings; e dois tipos de dados compostos:
objetos e arrays.
[Link] são criados com o operador new.
6.A instrução for/in itera sobre as propriedades de um objeto
especificado.
[Link] é uma linguagem sensível a maiúsculas e
minúsculas.
[Link] não possui escopo de bloco.
9.A palavra-chave this refere-se ao objeto para o qual a
função é uma propriedade.
10.O tratamento de erros em JavaScript é feito através da
instrução try/catch/finally.
JavaScript Perguntas
Ver no site do Bookey

Capítulo 1 | Seção 1.1. Sintaxe| Perguntas e respostas

[Link]
Qual é a importância da sensibilidade a maiúsculas e
minúsculas no JavaScript?
Resposta:O fato de o JavaScript ser sensível a
maiúsculas e minúsculas significa que a linguagem
trata identificadores com capitalizações diferentes
como distintos. Por exemplo, 'variavel', 'Variavel' e
'VARIAVEL' seriam considerados entidades
diferentes. Isso é importante para evitar conflitos de
nomes e melhorar a clareza do código, pois incentiva
os desenvolvedores a manterem suas convenções de
nomenclatura de forma consistente.

[Link]
Como o espaço em branco afeta o código JavaScript?
Resposta:Espaços em branco no JavaScript são ignorados
entre tokens, o que dá aos programadores a liberdade de
formatar seu código de maneira legível e organizada. Essa
flexibilidade permite uma melhor estruturação do código,
ajudando não apenas na compreensão pessoal, mas também
na colaboração com outros, já que o código se torna mais
fácil de ler e manter.

[Link]
Por que os ponto e vírgula são importantes e quando
podem ser omitidos no JavaScript?
Resposta:Os ponto e vírgula são usados para terminar
instruções no JavaScript, o que ajuda o interpretador a
entender onde uma instrução termina e outra começa. Eles
podem ser omitidos quando uma instrução termina com uma
nova linha; no entanto, isso pode levar a erros se a primeira
linha puder ser considerada uma instrução válida. Esse
recurso enfatiza a necessidade de uma formatação cuidadosa
para prevenir consequências indesejadas na execução do
código.

[Link]
Qual a finalidade dos comentários no JavaScript?
Resposta:Os comentários no JavaScript são cruciais para
documentação e melhoria da legibilidade do código. Eles
permitem que os desenvolvedores deixem anotações,
explicações ou lembretes dentro do código, o que pode
ajudar outros programadores (ou a si mesmos no futuro) a
entender a lógica e a finalidade de seções específicas do
código. Por exemplo, um comentário pode explicar a razão
pela qual uma escolha de algoritmo foi feita ou anotar um
recurso planejado para atualizações futuras.

[Link]
O que os desenvolvedores devem ter em mente ao nomear
identificadores no JavaScript?
Resposta:Os desenvolvedores devem seguir regras
específicas ao nomear identificadores no JavaScript.
Identificadores podem incluir letras, dígitos, sublinhados e
cifrões, mas não podem começar com um dígito. Além disso,
devem evitar palavras-chave reservadas e não usar os
mesmos nomes que propriedades e métodos globais para
prevenir conflitos e garantir a clareza do código.
[Link]
O que são palavras-chave reservadas no JavaScript e por
que devem ser evitadas como identificadores?
Resposta:Palavras-chave reservadas no JavaScript têm
significados e funções predefinidos dentro da linguagem,
como 'if', 'for' e 'return'. Elas não podem ser usadas como
identificadores, pois isso pode levar a complicações e
confusões no código em relação à estrutura da linguagem. É
essencial respeitar essas palavras reservadas para manter a
lógica e o fluxo dos scripts.

[Link]
Como um estilo de programação pode afetar a qualidade
do código JavaScript?
Resposta:Um estilo de programação consistente, incluindo
uso adequado de maiúsculas e minúsculas para
palavras-chave e nomes de funções, uso apropriado de
espaços em branco e comentários bem pensados, impacta
significativamente a manutenibilidade e legibilidade do
código JavaScript. Um código bem estilizado é mais fácil de
navegar, entender e depurar, especialmente em ambientes de
equipe.
Capítulo 2 | Seção 1.3. Tipos de Dados| Perguntas e
respostas
[Link]
Quais são os principais tipos de dados primitivos
suportados pelo JavaScript?
Resposta:O JavaScript suporta três tipos de dados
primitivos: números, booleanos e strings.

[Link]
Como os números são representados no JavaScript?
Resposta:Os números são representados no JavaScript
usando o formato de ponto flutuante de 64 bits, e não há
distinção entre números inteiros e de ponto flutuante.

[Link]
Quais valores especiais uma operação numérica pode
retornar quando ocorre um erro?
Resposta:Quando uma operação numérica transborda, ela
retorna infinito positivo ou negativo; quando ela subtrai
muito, retorna zero; e se uma operação resultar em um erro
(como tirar a raiz quadrada de um número negativo), retorna
NaN (não é um número).

[Link]
Você pode dar um exemplo de como definir uma string no
JavaScript?
Resposta:Uma string pode ser definida usando aspas simples
ou duplas, por exemplo: 'Olá Mundo' ou "JavaScript é
divertido!".

[Link]
O que significa que as strings em JavaScript são
imutáveis?
Resposta:Isso significa que, uma vez que uma string é criada,
seu conteúdo não pode ser alterado. Qualquer operação que
pareça modificar a string na verdade retornará uma nova
string modificada.

[Link]
Como você cria um novo objeto no JavaScript?
Resposta:Você pode criar um novo objeto usando o operador
new, assim: var o = new Object(); ou usando a sintaxe de
literais de objeto: var o = {x: 1, y: 2};.
[Link]
O que é um array no JavaScript?
Resposta:Um array é um tipo especializado de objeto que
contém valores numerados (elementos) e pode armazenar
qualquer tipo de valor, incluindo outros objetos e arrays.

[Link]
Qual é o propósito das funções no JavaScript?
Resposta:As funções são blocos de código reutilizáveis que
podem ser definidos uma vez e executados várias vezes, o
que ajuda a organizar e encapsular a lógica do código.

[Link]
Você pode explicar a diferença entre null e undefined no
JavaScript?
Resposta:Null é um valor especial que indica 'sem valor'
explicitamente, enquanto undefined é um tipo de variável que
foi declarada, mas ainda não recebeu um valor.

[Link]
Qual é a importância da palavra-chave 'this' dentro de
um método no JavaScript?
Resposta:No contexto de um método, a palavra-chave 'this'
refere-se ao objeto para o qual o método é uma propriedade,
permitindo que você acesse as propriedades desse objeto.
Capítulo 3 | Seção 1.4. Expressões e Operadores|
Perguntas e respostas
[Link]
O que são expressões em JavaScript e como são
construídas?
Resposta:Expressões em JavaScript são criadas ao
combinar valores usando operadores, que podem
incluir literais, variáveis, propriedades de objeto,
elementos de array e invocações de função.
Parênteses podem ser utilizados para agrupar
subexpressões e ajustar a ordem de avaliação
padrão.

[Link]
Qual é a função dos operadores em JavaScript e você
pode fornecer exemplos de suas categorias?
Resposta:Os operadores em JavaScript realizam uma
variedade de operações, como aritmética, comparação e
manipulação de objetos. Exemplos de categorias incluem
operadores aritméticos (como +, -, *, /), operadores de
comparação (como ==, ===, <, >) e operadores lógicos
(como &&, ||).

[Link]
Como o operador de igualdade '==' em JavaScript difere
do operador de identidade '==='?
Resposta:O operador de igualdade '==' realiza uma
comparação flexível, permitindo conversão de tipo, então 3
== '3' resulta em verdadeiro. Por outro lado, o operador de
identidade '===' verifica tanto o valor quanto o tipo,
significando que 3 === '3' resulta em falso porque são de
tipos diferentes.

[Link]
Por que o operador 'typeof' é importante em JavaScript e
o que ele retorna?
Resposta:O operador 'typeof' é crucial para determinar o tipo
de dado de um dado operando, retornando strings como
'number', 'string', 'boolean', 'object', entre outros. Isso ajuda
em uma verificação de tipo adequada e tratamento de erros
em scripts.

[Link]
O que o operador 'delete' faz em JavaScript?
Resposta:O operador 'delete' remove uma propriedade de um
objeto. Ao contrário de definir a propriedade como null, ele
realmente remove a propriedade do objeto, e retornará falso
se a propriedade não for configurável ou não puder ser
deletada.

[Link]
Como os operadores relacionais funcionam em strings em
JavaScript?
Resposta:Os operadores relacionais como <, <=, >, e >=
comparam strings com base em sua ordem alfabética,
significando que 'banana' < 'maçã' avaliaria como falso, uma
vez que 'b' vem depois de 'a' na sequência alfabética.

[Link]
Você pode explicar como os operadores de atribuição
funcionam em JavaScript?
Resposta:Os operadores de atribuição em JavaScript
atribuem valores a variáveis e também podem realizar
operações. Por exemplo, 'x += 2' adiciona 2 a x, enquanto 'y
*= 3' multiplicaria y por 3. Eles são formas abreviadas de
realizar uma operação seguida de uma atribuição.

[Link]
Qual é um exemplo de uso de parênteses em uma
expressão JavaScript?
Resposta:Considere a expressão (1 + 2) * 3. Aqui, os
parênteses são usados para garantir que a adição seja
realizada primeiro, resultando em 3 * 3, que equivale a 9.
Sem os parênteses, as operações seguiriam sua precedência
padrão, levando a um resultado diferente.

[Link]
Como o operador 'instanceof' funciona em JavaScript?
Resposta:O operador 'instanceof' verifica se um objeto foi
criado a partir de uma função construtora especificada. Por
exemplo, se obj foi criado pela construtora Date, então obj
instanceof Date avaliaria como verdadeiro. Isso é útil para
verificar o tipo de objetos.
Capítulo 4 | Seção 1.5. Instruções| Perguntas e
respostas
[Link]
Do que é composto um programa JavaScript?
Resposta:Um programa JavaScript é uma sequência
de instruções JavaScript.

[Link]
Como uma instrução de expressão funciona em
JavaScript?
Resposta:Toda expressão JavaScript pode funcionar como
uma instrução independente, como atribuições ou chamadas
de método, como 's = "hello world";' ou 'x = [Link](4);'.

[Link]
O que é uma instrução composta e quando é usada?
Resposta:Uma instrução composta consiste em múltiplas
instruções encerradas em chaves. É útil quando um loop ou
condicional precisa executar mais de uma instrução.

[Link]
Qual é o propósito da instrução vazia em JavaScript?
Resposta:A instrução vazia, representada por um único ponto
e vírgula, não faz nada, mas pode ser usada para definir
corpos de loops vazios.

[Link]
O que são instruções rotuladas e como são usadas?
Resposta:Instruções rotuladas permitem que você rotule
qualquer instrução, possibilitando o uso de 'break' ou
'continue' para controlar o fluxo em loops aninhados.

[Link]
Você pode explicar a diferença entre as instruções 'break'
e 'continue'?
Resposta:A instrução 'break' sai do loop mais interno,
enquanto 'continue' pula a iteração atual e prossegue para a
próxima.

[Link]
Qual é a importância do loop 'do/while'?
Resposta:O loop 'do/while' garante que o corpo seja
executado pelo menos uma vez, pois a condição é verificada
após o corpo do loop.

[Link]
Como funciona um loop 'for' em JavaScript?
Resposta:Um loop 'for' combina inicialização, condição de
teste e atualização em uma única linha, executando a
instrução repetidamente enquanto a condição de teste
permanecer verdadeira.

[Link]
O que faz a instrução 'for/in'?
Resposta:O loop 'for/in' itera sobre as propriedades de um
objeto, atribuindo o nome de cada propriedade a uma
variável especificada.

[Link]
Qual é o papel da instrução 'function'?
Resposta:A instrução 'function' define uma função nomeada
com parâmetros específicos e um corpo de código
executável.

[Link]
Descreva a funcionalidade da instrução 'if/else'.
Resposta:A instrução 'if' executa um bloco de código se a
condição for verdadeira; caso contrário, pode executar um
bloco alternativo de código usando 'else'.
[Link]
Como a instrução 'switch' difere das condicionais
padrão?
Resposta:A instrução 'switch' avalia uma expressão e salta
para o caso que corresponde à expressão, facilitando
ramificações múltiplas.

[Link]
Qual é o propósito do tratamento de exceções em
JavaScript?
Resposta:A estrutura 'try/catch/finally' permite que você
manipule erros de forma elegante, executando código quando
exceções ocorrem e garantindo que ações de limpeza sejam
executadas após.

[Link]
Qual é a importância da instrução 'var'?
Resposta:A instrução 'var' é usada para declarar variáveis em
JavaScript, o que é particularmente importante para declarar
variáveis locais dentro de funções.

[Link]
Por que a instrução 'with' é desencorajada?
Resposta:A instrução 'with' pode levar a efeitos colaterais
complexos e não intuitivos, tornando o código menos legível
e previsível.
Capítulo 5 | Seção 1.6. JavaScript Orientado a
Objetos| Perguntas e respostas
[Link]
Qual é o propósito de uma função construtora em
JavaScript?
Resposta:Uma função construtora é utilizada para
criar novos objetos e inicializar suas propriedades.
Ela é invocada com o operador 'new' e usa 'this'
para se referir ao novo objeto que está sendo criado.

[Link]
Como a herança funciona em objetos JavaScript?
Resposta:JavaScript utiliza um mecanismo de herança
simples onde os objetos heredam propriedades e métodos de
um objeto protótipo associado à sua função construtora.
Quaisquer propriedades ou métodos definidos no protótipo
são acessíveis a todas as instâncias do objeto.

[Link]
Você pode explicar a importância da propriedade
prototype em construtores?
Resposta:A propriedade prototype permite a definição de
métodos que são compartilhados entre todas as instâncias de
uma classe, reduzindo o uso de memória e tornando o código
mais eficiente. Por exemplo, ao definir 'distanceTo' em
[Link], todas as instâncias de Point podem usar esse
método sem que cada uma tenha sua própria cópia.

[Link]
O que é um método estático em JavaScript e como é
definido?
Resposta:Um método estático é definido diretamente em uma
função construtora, ao invés de em seu protótipo. Isso
significa que está associado à classe em si, e não a qualquer
instância dessa classe. Por exemplo, '[Link]' é uma
propriedade estática definida no construtor Point.

[Link]
Como você pode explicar o valor de retorno do método
toString na classe Point?
Resposta:O método toString é definido para converter um
objeto Point em um formato de string legível. Ele retorna
uma representação em string das coordenadas do objeto,
facilitando a inclusão em mensagens ou logs, como '(3,4)'
para um Point com x=3 e y=4.

[Link]
Dê um exemplo de como criar um novo objeto Point e
usar seus métodos.
Resposta:Você pode criar um novo objeto Point com 'var p =
new Point(3, 4);'. Em seguida, você pode calcular a distância
desse ponto até a origem com 'var d =
[Link]([Link]);'. Isso permite que você use
dinamicamente os métodos do objeto em cenários em tempo
real.

[Link]
Por que a programação orientada a objetos é benéfica em
JavaScript?
Resposta:A programação orientada a objetos (POO) em
JavaScript permite uma melhor organização do código,
promove a reutilização através da herança e modela entidades
do mundo real de forma mais eficaz. Isso resulta em um
desenvolvimento de software mais gerenciável e escalável.
Capítulo 6 | Seção 1.7. Expressões Regulares|
Perguntas e respostas
[Link]
O que são expressões regulares e como são usadas em
JavaScript?
Resposta:Expressões regulares são sequências de
caracteres que definem padrões de busca,
principalmente utilizadas para a correspondência de
strings em JavaScript. Elas empregam a mesma
sintaxe que Perl, permitindo que os desenvolvedores
realizem operações complexas de strings de forma
eficiente. Em JavaScript, podem ser escritas usando
a notação literal (enclausuradas por barras) ou com
o construtor RegExp.

[Link]
Você pode explicar o que são classes de caracteres no
contexto das expressões regulares?
Resposta:Classes de caracteres em expressões regulares
permitem que você defina um conjunto de caracteres para
corresponder. Por exemplo, [abc] corresponde a qualquer
caractere único 'a', 'b' ou 'c'. Você também pode negar uma
classe com [^abc], que corresponde a qualquer caractere que
não seja 'a', 'b' ou 'c'. Esse recurso aumenta bastante a
flexibilidade da correspondência de padrões.

[Link]
Qual é a importância da repetição nas expressões
regulares?
Resposta:A repetição permite definir quantas vezes um
padrão deve aparecer no texto. Por exemplo, o caractere '*'
indica que o elemento anterior pode aparecer zero ou mais
vezes, enquanto '+' indica uma ou mais vezes. Isso possibilita
capacidades de correspondência poderosas, como validar a
entrada do usuário ou analisar dados estruturados.

[Link]
O que significa agrupamento em expressões regulares e
por que é importante?
Resposta:O agrupamento em expressões regulares é feito
usando parênteses para combinar vários elementos em uma
única unidade. Isso é importante porque permite aplicar
quantificadores a frases inteiras em vez de caracteres
individuais. Por exemplo, (abc)+ corresponderia a 'abc',
'abcabc', etc., tratando todo o grupo como uma única
entidade.

[Link]
Como os âncoras afetam a correspondência de padrões
em expressões regulares?
Resposta:Âncoras restringem a correspondência de padrões a
um local específico dentro de uma string. Por exemplo, '^'
significa o início e '$' o fim, então /^Hello/ corresponderia
apenas a 'Hello' se ocorresse no início de uma string. Isso é
crucial para garantir que os padrões correspondam apenas em
locais prescritos, aumentando a precisão nas operações de
busca.

[Link]
O que são afirmações de look-ahead e como elas podem
ser úteis nas expressões regulares?
Resposta:Afirmações de look-ahead são recursos avançados
que permitem que você corresponda a um padrão apenas se
certas condições forem atendidas após o padrão, sem incluir
essas condições na correspondência em si. Por exemplo,
'(?=abc)' corresponderia a qualquer coisa se 'abc' o seguir,
mas não consumiria 'abc' como parte da correspondência.
Isso é útil em cenários onde a presença ou ausência de certos
padrões afeta o que você está tentando corresponder.

[Link]
Quais desafios os desenvolvedores podem enfrentar ao
usar expressões regulares em JavaScript?
Resposta:Os desenvolvedores podem encontrar dificuldades
devido à complexidade e à sintaxe sutil das expressões
regulares. Por exemplo, elaborar uma expressão regular que
interprete corretamente vários padrões ou escapar caracteres
especiais requer atenção cuidadosa aos detalhes. Além disso,
expressões excessivamente complexas podem levar a
problemas de desempenho ou correspondências não
intencionais, tornando os testes e a depuração essenciais.
Capítulo 7 | Seção 1.8. Versões do JavaScript|
Perguntas e respostas
[Link]
Qual é a importância das versões do JavaScript e como
elas se relacionam com o desenvolvimento web?
Resposta:As versões do JavaScript são cruciais para
entender a evolução da linguagem e suas
capacidades. Começando com o JavaScript 1.0, que
tinha muitos bugs e era limitado, até o JavaScript
1.5 que introduziu o tratamento de exceções em
conformidade com o ECMA v3, cada versão
acrescentou recursos essenciais que melhoraram a
robustez e a funcionalidade. Essa evolução é vital
para os desenvolvedores web, pois os informa sobre
os recursos disponíveis, garante compatibilidade
entre diferentes navegadores e orienta a escolha das
versões do JavaScript para diversos projetos.

[Link]
Como o JavaScript se integra ao HTML e por que essa
integração é importante?
Resposta:O JavaScript se integra ao HTML utilizando a tag
<script>, manipuladores de eventos e URLs de JavaScript.
Essa integração permite que os desenvolvedores criem
páginas web interativas e dinâmicas, melhorando a
experiência do usuário. Por exemplo, usar <script>
possibilita a geração de conteúdo dinâmico, enquanto os
manipuladores de eventos permitem interações em tempo
real do usuário, como cliques e envios de formulários. Essa
integração fluida é vital para o desenvolvimento web
moderno, pois transforma HTML estático em aplicações
dinâmicas.

[Link]
Explique o papel do objeto Window no JavaScript do
lado do cliente.
Resposta:O objeto Window representa a janela do navegador
no JavaScript do lado do cliente, servindo como o objeto
global para acessar e manipular documentos web. Ele define
propriedades e métodos globais, como document, que aponta
para o objeto Document representando o conteúdo exibido.
Compreender o objeto Window permite que os
desenvolvedores controlem aspectos do navegador, como
navegação e eventos de tempo, aumentando a interatividade e
gerenciando a experiência do usuário de forma eficaz.

[Link]
Quais são as principais funcionalidades fornecidas pelo
objeto Document?
Resposta:O objeto Document é essencial, pois representa o
documento HTML exibido no navegador. Ele permite o
acesso a elementos dentro do documento por meio de
propriedades como forms, images e links. Os
desenvolvedores podem manipular o conteúdo, lidar com
eventos e gerar HTML dinamicamente por meio de métodos
como getElementById() e write(). O domínio do objeto
Document facilita a criação de poderosas aplicações web que
reagem às entradas do usuário e se adaptam dinamicamente.

[Link]
Quais vantagens o W3C DOM e o IE 4 DOM oferecem
aos desenvolvedores de JavaScript?
Resposta:O W3C DOM fornece um método padronizado
para acessar e modificar todos os elementos do documento,
promovendo compatibilidade entre navegadores modernos.
Ele permite que os desenvolvedores percorram a árvore do
documento e manipulem várias estruturas HTML de forma
sistemática. Em contraste, o IE 4 DOM, embora não padrão,
oferece recursos exclusivos como innerHTML para
atualizações rápidas de conteúdo. Compreender ambos ajuda
os desenvolvedores a escrever scripts que funcionam em
diferentes navegadores e a utilizar recursos específicos de
cada um de forma eficaz.

[Link]
Como o JavaScript pode melhorar a interação do usuário
por meio de eventos, e por que essa funcionalidade é
crucial?
Resposta:O JavaScript melhora a interação do usuário por
meio do tratamento de eventos, permitindo que scripts
respondam a ações do usuário, como cliques,
pressionamentos de teclas e movimentos do mouse. Essa
interatividade é crucial para aplicações web modernas que
requerem feedback em tempo real e mudanças de conteúdo
dinâmico, melhorando o engajamento e a satisfação do
usuário. Por exemplo, a validação de formulários usando
eventos onsubmit garante a integridade dos dados ao prevenir
envios incorretos antes que eles aconteçam.

[Link]
Quais restrições de segurança são impostas ao JavaScript
do lado do cliente e por que elas são importantes?
Resposta:As restrições de segurança no JavaScript do lado do
cliente, como a política de mesma origem e limitações no
acesso a arquivos, são vitais para proteger a privacidade do
usuário e prevenir atividades maliciosas. Essas restrições
garantem que scripts só possam interagir com os documentos
servidos do mesmo domínio, mitigando ameaças como o
cross-site scripting (XSS). Compreender essas limitações
permite que os desenvolvedores escrevam aplicações seguras
que protejam os dados dos usuários e mantenham a
confiança.
Capítulo 8 | Seção 2.1. JavaScript em HTML|
Perguntas e respostas
[Link]
Qual é o principal propósito da tag <script> em HTML?
Resposta:A tag <script> é usada para incorporar
código JavaScript dentro de documentos HTML,
permitindo que você execute JavaScript diretamente
ou vinculando a um arquivo externo.

[Link]
Como os manipuladores de eventos podem melhorar a
interação do usuário em uma aplicação web?
Resposta:Os manipuladores de eventos permitem que o
código JavaScript seja executado em resposta a ações
específicas do usuário, como cliques ou eventos de teclado.
Por exemplo, usar um evento onclick para exibir 'Olá
Mundo!' quando um botão é clicado demonstra como a
programação orientada a eventos pode tornar as páginas web
interativas.

[Link]
Qual é a importância de usar o atributo type na tag
<script>?
Resposta:O atributo type especifica a linguagem de script do
código incluído. Para JavaScript, ele deve ser definido como
'text/javascript' para garantir compatibilidade, especialmente
em ambientes onde várias linguagens de script possam ser
usadas.

[Link]
Como funciona o esquema de URL javascript: em
formulários HTML?
Resposta:O esquema de URL javascript: permite que o
código JavaScript seja executado quando um formulário é
enviado sem recarregar a página. Ao usar este esquema junto
com o operador void, você pode executar funções sem alterar
o conteúdo do documento.

[Link]
Por que pode ser necessário especificar a versão do
JavaScript na tag <script>?
Resposta:Especificar a versão do JavaScript usando atributos
como language ou type garante que os navegadores
interpretem o código corretamente. Isso ajuda a manter a
compatibilidade com diferentes versões de navegador que
podem suportar apenas recursos específicos do JavaScript.

[Link]
Você pode fornecer um exemplo de uso de um
manipulador de eventos para melhorar a funcionalidade
em uma página da web?
Resposta:Certamente! Por exemplo, uma caixa de entrada
poderia usar o manipulador de eventos onfocus para mudar
sua cor de fundo, indicando aos usuários que está pronta para
entrada. Esse feedback visual melhora a experiência do
usuário, tornando a interação mais suave.

[Link]
Qual é o papel do operador void em URLs JavaScript?
Resposta:O operador void é usado em URLs JavaScript para
impedir que o navegador navegue para uma nova página ou
modifique o documento atual. Ele permite efetivamente a
execução de scripts sem qualquer efeito visível na página
web, o que é útil em ações de formulários.
[Link]
Como a tag <script> acomoda diferentes linguagens de
script?
Resposta:A tag <script> permite a inclusão de várias
linguagens de script especificando o tipo MIME apropriado
ou o atributo language. Embora o JavaScript seja o mais
comum, o HTML suporta outros scripts, como o VBScript,
tornando-se versátil para desenvolvedores que podem
trabalhar em ambientes multilíngues.
Capítulo 9 | Seção 2.2. O Objeto Window| Perguntas
e respostas
[Link]
Qual é a importância do objeto Window no JavaScript do
lado do cliente?
Resposta:O objeto Window representa o contexto
global para o JavaScript do lado do cliente e
abrange todas as propriedades e métodos de nível
superior disponíveis no navegador. Ele serve como
um espaço de nomes para funções globais e permite
que os desenvolvedores controlem aspectos do
ambiente do navegador, como exibir diálogos,
rastrear interações do usuário e navegar pelo
histórico do navegador.

[Link]
Como você cria e exibe uma caixa de diálogo usando o
objeto Window? Você pode fornecer um exemplo?
Resposta:Você pode criar caixas de diálogo usando métodos
como alert(), confirm() e prompt(). Por exemplo,
alert('Bem-vindo à minha página inicial!') irá exibir uma
simples caixa de alerta. Para solicitar ao usuário uma entrada,
use prompt('Digite seu nome'); isso abrirá uma caixa de
diálogo que permite ao usuário inserir uma única linha de
texto.

[Link]
Quais métodos permitem manipular a linha de status em
um navegador web?
Resposta:Você pode manipular a linha de status usando as
propriedades status e defaultStatus do objeto Window. Por
exemplo, definir [Link] = 'Carregando...' mudará o
texto na linha de status para 'Carregando...' até que outro
status seja configurado.

[Link]
Você pode explicar como os temporizadores funcionam no
JavaScript usando o objeto Window?
Resposta:Temporizadores no JavaScript são criados usando
setTimeout() e setInterval(). setTimeout() executa uma
função uma vez após um atraso especificado, enquanto
setInterval() executa repetidamente uma função nos
intervalos definidos. Por exemplo, var timer =
setInterval(function() { [Link]('Tick'); }, 1000) irá
registrar 'Tick' no console a cada segundo.

[Link]
Qual é a propriedade navigator do objeto Window e como
ela é usada?
Resposta:A propriedade navigator fornece informações sobre
o navegador e o sistema operacional do usuário. Ela retorna
um objeto Navigator que contém propriedades como
appName, appVersion e userAgent. Essas informações
podem ser usadas para adaptar a funcionalidade com base no
navegador, como if ([Link] == 'Netscape') { //
Código específico para Netscape }.

[Link]
Como a propriedade location afeta a navegação no
navegador?
Resposta:A propriedade location representa a URL atual
exibida na barra de endereços do navegador. Você pode lê-la
para obter a URL atual ou configurá-la para navegar para
uma página web diferente. Por exemplo, definir [Link]
= '[Link] irá navegar o navegador para a página
web especificada.

[Link]
Quais são os métodos disponíveis para controlar o
tamanho e a posição da janela do navegador?
Resposta:Os métodos para controlar a janela do navegador
incluem moveTo(), moveBy(), resizeTo() e resizeBy(). Esses
métodos permitem que os desenvolvedores mudem a posição
e o tamanho de uma janela programaticamente. Por exemplo,
resizeTo(800, 600) mudaria o tamanho da janela para uma
largura de 800 pixels e uma altura de 600 pixels.

[Link]
Qual é o propósito de usar várias janelas e frames no
JavaScript?
Resposta:Várias janelas e frames permitem que os
desenvolvedores criem aplicativos web complexos onde
diferentes conjuntos de informações podem ser exibidos
simultaneamente de forma amigável. Cada janela ou frame
opera com seu próprio contexto de execução, ou seja,
variáveis e funções podem ser escopadas às suas respectivas
janelas, promovendo um design de código modular.

[Link]
Como um script em um frame aninhado pode acessar
funções definidas na janela de nível superior?
Resposta:Um script rodando em um frame aninhado pode
acessar funções e variáveis definidas na janela de nível
superior usando a propriedade top. Por exemplo, se uma
função stop_scrolling() está definida na janela de nível
superior, um script em um frame aninhado pode chamar essa
função usando top.stop_scrolling();.
Capítulo 10 | Seção 2.3. O Objeto Documento|
Perguntas e respostas
[Link]
Qual é a importância do objeto Document em JavaScript
em comparação com o objeto Window?
Resposta:O objeto Document é mais significativo
que o objeto Window porque, enquanto o Window
representa a interface do navegador, o objeto
Document representa o documento HTML exibido
dentro dessa interface. Ele serve como um portal
para o conteúdo da página da web, permitindo que
os desenvolvedores acessem e manipulem elementos
HTML diretamente através do Modelo de Objetos
do Documento (DOM). Compreender o objeto
Document é crucial para uma programação web
eficaz.

[Link]
Quais são os diferentes tipos de DOM mencionados e
como eles diferem?
Resposta:Existem três tipos principais de DOM discutidos:
Legacy DOM, W3C DOM e IE 4 DOM. O Legacy DOM
representa um modelo mais antigo que suporta elementos
básicos como formulários e imagens, mas é limitado em
escopo. O W3C DOM é um modelo moderno e padronizado
que permite acesso e modificação completos do conteúdo do
documento e é amplamente suportado nos navegadores
atuais. O IE 4 DOM introduziu recursos proprietários para
manipulação de documentos que não eram padronizados,
mas continuam influentes. Essas diferenças refletem a
evolução dos padrões da web e a necessidade de
compatibilidade.

[Link]
Por que um programador JavaScript deve estar ciente
das variações do DOM?
Resposta:Um programador JavaScript deve estar ciente das
variações do DOM para escrever um código compatível entre
diferentes navegadores e utilizar funcionalidades específicas
de forma precisa. Compreender essas diferenças ajuda no
desenvolvimento de aplicações robustas que funcionam de
forma consistente, independentemente da escolha do
navegador pelo usuário. O conhecimento do W3C DOM é
particularmente importante para manter os padrões web
atuais, pois garante maior compatibilidade e prepara o código
para o futuro.

[Link]
O que posso fazer para explorar mais o DOM para
programação em JavaScript?
Resposta:Para explorar mais o DOM para programação em
JavaScript, você pode ler recursos abrangentes, como
'JavaScript', que cobre todos os recursos principais do DOM
padrão. Além disso, a experimentação prática através da
construção de aplicativos HTML e manipulação de
elementos usando JavaScript aprofundará sua compreensão e
melhorará suas habilidades. Engaje-se com documentação
online e tutoriais para se manter atualizado com as melhores
práticas e novos padrões da web.
Capítulo 11 | Seção 2.4. O DOM Legado| Perguntas
e respostas
[Link]
Quais são os principais componentes do Legacy DOM que
melhoram a interação com documentos em JavaScript?
Resposta:O Legacy DOM fornece propriedades
como formulários, imagens, applets, links e âncoras
que permitem o acesso a elementos específicos em
um documento. Essas propriedades são arrays que
contêm objetos correspondentes a cada um desses
elementos na ordem em que aparecem no
documento. Além disso, o objeto Form contém um
array de elementos para os elementos do formulário,
permitindo que você os referencie pelo índice ou
nome.

[Link]
Como funciona o método write() no Legacy DOM e quais
são suas limitações?
Resposta:O método write() insere texto no documento na
localização do script, permitindo a inclusão de tags HTML
no texto. No entanto, ele só pode ser utilizado enquanto o
documento ainda está sendo carregado, já que invocá-lo
depois apagará o conteúdo do documento. Ele também pode
ser usado em manipuladores de eventos para janelas
diferentes, mas requer a escrita de todo o conteúdo do
documento e a chamada de [Link]().

[Link]
Você pode explicar como a validação de formulários é
implementada no Legacy DOM usando JavaScript?
Resposta:A validação de formulários é feita através do
evento onsubmit da tag <form>. Ao retornar false do
manipulador de eventos, a submissão do formulário pode ser
evitada. Você pode percorrer os elementos do formulário,
verificar campos obrigatórios e alertar o usuário se algum
deles não estiver preenchido. Por exemplo, pode-se criar uma
função para iterar por cada campo de texto e alertar o usuário
se estiver vazio.

[Link]
Quais técnicas podem ser usadas para rollover de
imagens em páginas da web que utilizam o Legacy DOM?
Resposta:Os rollovers de imagens são realizados alterando a
propriedade src de um objeto Image com base em eventos do
mouse, como onmouseover e onmouseout. Pré-carregar
imagens na memória usando um objeto Image fora da tela
pode melhorar a experiência do usuário ao eliminar atrasos
de carregamento quando a imagem precisa ser exibida.

[Link]
Como os cookies podem ser gerenciados no Legacy
DOM?
Resposta:Os cookies podem ser configurados e recuperados
usando a propriedade cookie do objeto Document. Para criar
um cookie, você atribui uma string formatada como
'nome=valor' à propriedade cookie. Você também pode
definir uma data de expiração e um caminho para o cookie.
Para recuperar cookies, você pode dividir a string de cookies
do documento e buscar o nome do cookie desejado.

[Link]
Qual é a importância do legacy DOM, apesar de suas
limitações?
Resposta:O legacy DOM fornece funcionalidades essenciais
para a manipulação de conteúdo dinâmico em páginas da
web, incluindo alteração da estrutura do documento,
manuseio de submissões de formulários, validação de entrada
do usuário, criação de formulários dinâmicos e
gerenciamento de cookies. Embora faltem métodos
abrangentes para acessar todos os elementos do documento,
ele estabelece as bases para APIs DOM mais avançadas que
abordam essas limitações.

[Link]
Como você pode atualizar dinamicamente o conteúdo de
um elemento de formulário no Legacy DOM?
Resposta:Você pode atualizar o conteúdo de um elemento de
formulário acessando-o através do array [Link] e
definindo suas propriedades. Por exemplo, para exibir a hora
atual a cada segundo, você pode definir a propriedade value
de um elemento de entrada de texto em um objeto Form
usando a função setInterval do JavaScript.
Capítulo 12 | Seção 2.5. O W3C DOM| Perguntas e
respostas
[Link]
Quais são as vantagens de usar o W3C DOM em vez do
DOM legado em JavaScript?
Resposta:O W3C DOM padroniza a maioria das
funcionalidades do DOM legado, ao mesmo tempo
em que adiciona novas capacidades, como a
habilidade de manipular todos os elementos do
documento de forma uniforme, não apenas aqueles
de propósito especial, como formulários e imagens.
Isso facilita o acesso, a travessia e a manipulação de
qualquer parte do documento pelos scripts.

[Link]
Como podemos acessar elementos em um documento
usando seu ID?
Resposta:Você pode acessar elementos pelo seu ID usando o
método getElementById() do objeto Document. Por
exemplo, se você tiver um elemento <h1
id='title'>Título</h1>, você pode recuperá-lo com var t =
[Link]('title');.

[Link]
Qual é a estrutura de um documento no W3C DOM?
Resposta:O W3C DOM representa um documento como uma
árvore, onde cada tag HTML, string de texto e comentário
correspondem a nós dessa árvore. Cada nó é um objeto
JavaScript com propriedades que permitem a travessia e
manipulação de outros nós.

[Link]
Quais são os diferentes tipos de nós em um documento
W3C DOM?
Resposta:Os principais tipos de nós relevantes para
documentos HTML incluem: 1 para nós de Elemento (tags
HTML), 2 para nós de Texto (texto no documento), 8 para
nós de Comentário (comentários HTML) e 9 para nós de
Documento (o próprio documento). Esses tipos de nós
ajudam a organizar a estrutura do documento.

[Link]
Como você pode mudar o conteúdo de texto de um
elemento de documento?
Resposta:O conteúdo de texto de um elemento de documento
pode ser alterado definindo a propriedade nodeValue de um
nó de Texto. Alternativamente, você pode usar a propriedade
innerHTML para definir diretamente o conteúdo HTML, o
que permite estruturas mais complexas.

[Link]
Como podemos manipular a estrutura de um documento
no W3C DOM?
Resposta:Você pode manipular a estrutura do documento
usando métodos de Nó para inserir, anexar, remover ou
substituir nós filhos, bem como métodos de Documento para
criar novos nós de Elemento e Texto. Por exemplo, para
adicionar um novo item de lista a uma lista ordenada, você
poderia criar um novo elemento <li> e anexá-lo ao <ol>.

[Link]
Você pode fornecer um exemplo de como mudar o texto
de um documento?
Resposta:Certamente! Para mudar o texto da primeira tag
<h1> em um documento, você usaria o seguinte código: var
h1 = [Link]('h1')[0];
[Link] = 'Novo título'; Lembre-se de que
isso assume que o <h1> contém apenas texto simples.

[Link]
Que método pode ser usado para criar novos elementos
no documento?
Resposta:O método createElement() do objeto Document
pode ser usado para criar novos elementos. Por exemplo, var
item = [Link]('li'); cria um novo elemento
<li>.

[Link]
Como você pode remover um elemento do documento?
Resposta:Você pode remover um elemento usando o método
removeChild(). Por exemplo, se você quiser remover um
item previamente adicionado a uma lista, você chamaria
[Link](item); no pai da lista.

[Link]
Qual é o propósito da função embolden no exemplo
fornecido?
Resposta:A função embolden cria uma nova tag <b>
(negrito) e reparenta um nó de documento especificado
dentro dela, efetivamente deixando o nó original em negrito.
Isso ilustra como manipular a estrutura do documento e
aplicar formatação programaticamente.
Capítulo 13 | Seção 2.6. DOM do IE 4| Perguntas e
respostas
[Link]
Qual é a diferença fundamental entre o DOM do IE 4 e o
DOM do W3C ao acessar elementos do documento?
Resposta:O DOM do IE 4 não suporta o método
getElementById() e, em vez disso, permite o acesso a
elementos através do array all[]. Você pode acessar
um elemento pelo seu atributo id usando métodos
como [Link]['mylist'] ou [Link].

[Link]
Como o método de navegação na árvore do documento
difere entre o IE 4 e o DOM do W3C?
Resposta:No DOM do IE 4, você usa propriedades como
children[] e parentElement em vez de childNodes[] e
parentNode, como é usado no DOM do W3C. Além disso, o
DOM do IE 4 ignora comentários e texto do documento
como parte de sua estrutura de árvore.

[Link]
Quais são as implicações de modificar o conteúdo do
documento no IE 4 usando innerText e innerHTML?
Resposta:Usar innerText substitui todo o conteúdo dentro de
um elemento pelo texto especificado, limpando as tags
existentes. Em contraste, innerHTML permite que você
substitua o conteúdo de um elemento por HTML, mas requer
a invocação do parser HTML, o que pode impactar a
eficiência, mas oferece maior conveniência.

[Link]
Por que a compatibilidade é importante ao escrever
scripts para diferentes DOMs?
Resposta:A compatibilidade é crucial porque diferentes
navegadores implementam os padrões do DOM de maneiras
distintas. Usar testes de capacidade permite que você escreva
scripts que se adaptem aos recursos disponíveis no navegador
do usuário, garantindo funcionalidade em navegadores
modernos e legados.

[Link]
Quais são alguns métodos relacionados à modificação da
estrutura do documento disponíveis no DOM do IE 4?
Resposta:Os métodos desnecessários para modificar a
estrutura do documento no DOM do IE 4 incluem
innerHTML, outerHTML e insertAdjacentHTML(). No
entanto, innerHTML é o mais comumente empregado por sua
conveniência, apesar de ser não padrão.

[Link]
Como os desenvolvedores devem abordar as
características legadas do DOM, como o DOM do IE 4?
Resposta:Os desenvolvedores devem estar cientes das
características legadas e considerar abordagens alternativas
que priorizem práticas padrão, como usar o DOM do W3C
quando possível. Também é benéfico implementar estratégias
de degradação graciosa para garantir que navegadores mais
antigos ainda possam funcionar.
Capítulo 14 | Seção 2.7. DHTML: Programando
Estilos CSS| Perguntas e respostas
[Link]
Qual é o papel do DHTML no desenvolvimento web?
Resposta:DHTML, que significa HTML Dinâmico,
combina HTML, CSS e JavaScript para criar
experiências interativas e dinâmicas na web. Ele
permite que os desenvolvedores manipulem o estilo e
o comportamento dos elementos HTML em tempo
real, melhorando a experiência do usuário ao
responder a ações sem precisar recarregar a página.

[Link]
Como você pode modificar o estilo dos elementos HTML
usando JavaScript?
Resposta:Você pode modificar o estilo dos elementos HTML
acessando a propriedade 'style' de um elemento através do
JavaScript. Por exemplo, para mudar a cor de um elemento,
você usaria '[Link] = "red";'. Para definir uma
cor de fundo, você usaria '[Link] =
"blue";'.

[Link]
Qual é o primeiro passo para animar um elemento
usando DHTML?
Resposta:O primeiro passo para animar um elemento usando
DHTML é definir sua propriedade de posição como
'absolute', o que permite que você defina sua localização na
página de forma mais livre usando as propriedades top e left.

[Link]
Por que é importante converter números em strings ao
definir certas propriedades CSS?
Resposta:No JavaScript, todos os valores de propriedades
CSS são tratados como strings, mesmo aqueles que
representam valores numéricos como largura ou altura. Isso
significa que, ao definir propriedades como
'[Link]', você deve converter o valor numérico
em uma string e anexar a unidade apropriada, tipicamente
'px', para garantir que seja corretamente interpretado pelo
navegador.

[Link]
Que efeito a propriedade 'visibility' tem sobre um
elemento?
Resposta:A propriedade 'visibility' determina se um elemento
é visível na página da web. Defini-la como 'hidden' remove-o
da vista, mas o espaço que ocupa continua alocado, enquanto
defini-la como 'visible' faz com que ele reapareça.

[Link]
Como a função 'nextFrame()' demonstra a animação
DHTML?
Resposta:A função 'nextFrame()' ilustra a animação DHTML
movendo gradualmente um elemento HTML 10 pixels para a
direita a cada 50 milissegundos. Ela usa um loop controlado
por um contador de quadros para restringir o movimento a 20
quadros, após os quais esconde o elemento definindo sua
visibilidade como 'hidden'.

[Link]
O que acontece se você definir a propriedade 'position' de
um elemento como 'fixed'?
Resposta:Quando a propriedade 'position' é definida como
'fixed', o elemento é posicionado em relação ao viewport.
Isso significa que ele permanecerá no mesmo lugar na tela,
mesmo quando a página for rolada, proporcionando uma
maneira de criar barras de navegação ou avisos persistentes.

[Link]
O que a propriedade 'zIndex' controla?
Resposta:A propriedade 'zIndex' controla a ordem de
empilhamento dos elementos na página da web. Elementos
com um valor de z-index mais alto aparecerão acima
daqueles com um valor mais baixo, permitindo designs em
camadas.
Capítulo 15 | Seção 2.8. Eventos e Manipulação de
Eventos| Perguntas e respostas
[Link]
Qual é o propósito dos atributos de manipulador de
eventos em HTML e como eles funcionam em JavaScript?
Resposta:Os atributos de manipulador de eventos
em HTML, como onclick, onsubmit e onload, são
usados para especificar funções JavaScript que
devem ser executadas em resposta a ações
específicas do usuário ou eventos do navegador.
Esses atributos estão anexados a tags HTML e
começam com 'on'. Quando um evento ocorre, o
navegador executa o código JavaScript associado.
Por exemplo, se você tiver um manipulador de
evento 'onsubmit' em um formulário, ele pode ser
usado para validar a entrada do usuário antes que o
formulário seja enviado, melhorando a interação do
usuário e permitindo feedback em tempo real.

[Link]
Como os manipuladores de eventos podem ser definidos
de forma diferente em JavaScript em comparação com os
atributos HTML?
Resposta:Em JavaScript, os manipuladores de eventos podem
ser definidos como funções reais atribuídas a propriedades de
objetos de documento em vez de serem escritos como strings
de código dentro de atributos HTML. Por exemplo, você
pode criar uma função chamada validate para a submissão do
formulário e atribuí-la à propriedade onsubmit de um
formulário usando '[Link][0].onsubmit = validate;'.
Este método permite um código mais limpo e melhor
programabilidade.

[Link]
Quais são os desafios impostos por diferentes modelos de
manipulação de eventos entre navegadores?
Resposta:Existem três principais modelos de manipulação de
eventos: o modelo W3C DOM, o modelo do Internet
Explorer e o modelo do Netscape 4. Cada um desses modelos
possui maneiras únicas de gerenciar eventos, o que complica
a compatibilidade entre navegadores. Por exemplo, no
modelo W3C, o objeto Event é passado para a função
manipuladora, enquanto no IE, ele é armazenado na
propriedade de evento da janela. Devido a essas diferenças,
os desenvolvedores muitas vezes precisam escrever código
adicional ou usar bibliotecas para garantir que suas funções
de manipulação de eventos funcionem corretamente em todos
os principais navegadores.

[Link]
Como funciona a propagação de eventos em modelos
avançados de eventos?
Resposta:A propagação de eventos permite que os eventos
percorram a hierarquia de elementos do documento,
acionando quaisquer manipuladores de eventos relevantes ao
longo do caminho. Nos modelos W3C e Netscape, os eventos
começam no objeto document e se propagam até o elemento
alvo, enquanto no modelo IE, certos eventos podem subir
após serem tratados. Os desenvolvedores podem definir
manipuladores de eventos em múltiplos níveis, por exemplo,
adicionando um ouvinte onclick a um <div> que trata cliques
de qualquer um de seus elementos filhos, facilitando a gestão
de eventos.

[Link]
Qual é a importância do método addEventListener() no
modelo W3C?
Resposta:O método addEventListener() no modelo W3C
permite que os desenvolvedores anexem múltiplos
manipuladores de eventos a um único tipo de evento sem
sobrescrever manipuladores existentes. Isso é significativo
para a construção de aplicações complexas onde você pode
querer que várias funções respondam à mesma ação do
usuário, melhorando a modularidade e a manutenibilidade do
código.
Capítulo 16 | Seção 2.9. Restrições de Segurança do
JavaScript| Perguntas e respostas
[Link]
Quais são algumas razões para as restrições de segurança
no JavaScript do lado do cliente?
Resposta:As restrições de segurança no JavaScript
do lado do cliente são impostas principalmente para
proteger os dados do usuário e garantir a
privacidade. Por exemplo, impedir que scripts
excluam arquivos no disco rígido local do usuário
evita acesso não autorizado e possíveis perdas de
dados. Da mesma forma, a política de mesma
origem restringe scripts de acessar conteúdo
carregado de diferentes servidores web, o que ajuda
a prevenir ações maliciosas, como roubo de dados e
ataques de cross-site scripting. Ao limitar
capacidades como envios de e-mail e uploads de
arquivos sem o consentimento do usuário, os
navegadores protegem as interações dos usuários,
mantendo a confiança geral nas aplicações web.
[Link]
Como a política de mesma origem funciona na segurança
do JavaScript?
Resposta:A política de mesma origem é um mecanismo de
segurança crítico no JavaScript do lado do cliente que proíbe
scripts de ler propriedades de janelas ou documentos
carregados de uma origem diferente da do próprio script. Por
exemplo, se você tem um script rodando em '[Link]',
ele não pode interagir com um documento de
'[Link]'. Isso impede que scripts acessem
informações potencialmente sensíveis que o usuário possa ter
abertas em outras abas ou janelas, garantindo assim a
proteção dos dados do usuário contra acessos não
autorizados.

[Link]
Os scripts JavaScript podem fechar qualquer janela do
navegador?
Resposta:Não, os scripts só podem fechar janelas do
navegador que eles mesmos criaram. Essa restrição existe
para evitar práticas abusivas em que scripts poderiam fechar
arbitrariamente janelas que o usuário não pretendia fechar, o
que poderia ser muito frustrante ou enganoso para o usuário.

[Link]
Qual é a importância da confirmação do usuário na
segurança do JavaScript?
Resposta:A confirmação do usuário atua como um filtro
crucial para ações que poderiam interromper a experiência do
usuário ou comprometer a segurança. Por exemplo, quando
um script tenta enviar um formulário para um endereço de
e-mail ou publicar uma notícia, exigir a confirmação do
usuário garante que os usuários estejam cientes dessas ações,
evitando envios indesejados e preservando a integridade das
interações do usuário.

[Link]
Como as novas atualizações dos navegadores
influenciaram os padrões de segurança do JavaScript?
Resposta:Os navegadores mais recentes se adaptaram a
crescentes preocupações de segurança e ao uso indevido do
JavaScript, introduzindo configurações de segurança
configuráveis pelo usuário. Isso permite que os usuários
impeçam que scripts realizem ações incômodas, como abrir
anúncios em pop-up ou manipular tamanhos de janelas
atuais. Essas melhorias refletem a capacidade dos
desenvolvedores de navegadores em responder às
necessidades dos usuários por maior controle e
cibersegurança.

[Link]
Por que é importante que os navegadores web tenham
restrições de segurança para o JavaScript?
Resposta:As restrições de segurança são vitais para manter
um ambiente de navegação seguro. Elas protegem os
usuários de ações potencialmente prejudiciais que poderiam
ser executadas por meio de scripts maliciosos. Ao impor
essas regras, os navegadores reduzem o risco de
vulnerabilidades que poderiam comprometer os dados do
usuário, prevenir violações de privacidade e manter a
confiança do usuário nas aplicações web.
Capítulo 17 | Array| Perguntas e respostas
[Link]
Quais são as diferentes maneiras de criar um array em
JavaScript?
Resposta:Você pode criar um array usando o
construtor `new Array()`, que cria um array vazio,
`new Array(n)` para um array com 'n' elementos
não especificados, ou `new Array(e0, e1,...)` para
criar um array com elementos especificados. Além
disso, usando a sintaxe literal, você pode criar e
inicializar um array com uma lista separada por
vírgulas dentro de colchetes, como `var a = [1, true,
'abc'];`.

[Link]
Como funciona a propriedade `length` em arrays
JavaScript?
Resposta:A propriedade `length` representa o número de
elementos no array. Se os elementos não forem contíguos (ou
seja, se houver 'buracos' no array), a propriedade `length`
retornará um número maior que o índice mais alto com um
valor.

[Link]
Qual é o propósito do método `concat()`? Você pode dar
um exemplo?
Resposta:O método `concat()` é usado para combinar
múltiplos arrays ou valores em um novo array. Por exemplo,
se você tiver dois arrays `var a = [1, 2]` e `var b = [3, 4]`,
usando `[Link](b)` produzirá um novo array `[1, 2, 3, 4]`.

[Link]
Explique o uso do método `join()` com um exemplo.
Resposta:O método `join()` converte todos os elementos de
um array em uma string, inserindo um separador especificado
entre eles. Por exemplo, se você tiver um array `var fruits =
['maçã', 'banana', 'cereja']`, usando `[Link](', ')` retornará a
string 'maçã, banana, cereja'.

[Link]
O que acontece quando você usa o método `pop()`?
Resposta:Quando você usa o método `pop()` em um array,
ele remove o último elemento do array e retorna esse
elemento, ao mesmo tempo que decrementa o comprimento
do array em um. Por exemplo, se você tiver `var numbers =
[1, 2, 3]` e fizer `[Link]()`, ele retornará '3' e `numbers`
se tornará `[1, 2]`.

[Link]
Descreva a diferença entre os métodos `shift()` e
`unshift()`.
Resposta:O método `shift()` remove o primeiro elemento de
um array e o retorna, deslocando todos os elementos
restantes para baixo. Por exemplo, de `var arr = [1, 2, 3]`,
chamar `[Link]()` retornaria '1' e mudaria `arr` para `[2, 3]`.
Em contrapartida, `unshift()` adiciona um ou mais elementos
ao início do array, deslocando os elementos existentes para
cima. Se você chamar `[Link](0)` depois do `shift()`, `arr`
se tornará `[0, 2, 3]`.

[Link]
Qual é a função do método `splice()`? Forneça um
exemplo.
Resposta:O método `splice()` modifica um array removendo
um número de elementos em um índice especificado e
também pode adicionar novos elementos nesse índice. Por
exemplo, se você tiver `var arr = [1, 2, 3, 4, 5]` e chamar
`[Link](2, 2, 'a', 'b')`, ele removerá dois elementos
começando do índice 2 (originalmente '3' e '4') e inserirá 'a' e
'b' em seu lugar. O array resultante será `[1, 2, 'a', 'b', 5]`.

[Link]
Você pode explicar como o método `sort()` funciona?
Resposta:O método `sort()` ordena os elementos de um array
no lugar e pode aceitar uma função opcional que define a
ordem de classificação dos elementos. Por exemplo, se você
tiver `var nums = [3, 1, 2]` e usar `[Link]()`, ele ordenará
o array para `[1, 2, 3]`. Você também pode fornecer uma
função de ordenação personalizada, como ordenar números
em ordem decrescente com `[Link]((a, b) => b - a)`.

[Link]
O que faz o método `reverse()`?
Resposta:O método `reverse()` inverte a ordem dos
elementos em um array. Por exemplo, se você tiver `var arr =
[1, 2, 3]` e chamar `[Link]()`, isso mudará `arr` para `[3,
2, 1]`.

[Link]
Como os métodos `toString()` e `toLocaleString()` diferem
em uso?
Resposta:O método `toString()` converte um array em uma
string sem qualquer localização, enquanto `toLocaleString()`
respeita as configurações regionais do ambiente do usuário,
podendo formatar as strings de maneira diferente com base
nas convenções regionais. Por exemplo, chamar
`[Link]()` pode retornar '1,2,3', enquanto
`[Link]()` poderia retornar '1.0, 2.0, 3.0' em
certos locais, dependendo do formato numérico.
Capítulo 18 | Data| Perguntas e respostas
[Link]
Qual é o propósito do construtor Date em JavaScript?
Resposta:O construtor Date fornece uma maneira
de criar objetos de data, que podem representar a
data e hora atuais, interpretar strings representando
datas ou especificar componentes de data
individuais, como ano, mês, dia, horas, etc. Essa
flexibilidade permite que os desenvolvedores
manipulem datas e horários de acordo com suas
necessidades específicas.

[Link]
Como funciona o método getTime() e por que é
importante?
Resposta:O método getTime() retorna o número de
milissegundos desde a meia-noite UTC de 1º de janeiro de
1970, para o objeto Date. Essa representação numérica é
crucial para realizar cálculos e comparações de datas, pois
permite que os desenvolvedores entendam e manipulem
facilmente dados baseados no tempo.

[Link]
Quais são as diferenças entre os métodos de hora local e
UTC no objeto Date?
Resposta:Os métodos de hora local interagem com as
configurações de fuso horário local do usuário, enquanto os
métodos UTC fornecem resultados consistentes com base no
Tempo Universal Coordenado. Essa distinção é importante
para aplicações que precisam levar em conta fusos horários
ou realizar operações em datas e horários que sejam
consistentes, independentemente da localização do usuário.

[Link]
Você pode explicar a importância do método
getTimezoneOffset()?
Resposta:O método getTimezoneOffset() retorna a diferença
em minutos entre o fuso horário local e o UTC. Isso é
significativo para entender como os horários locais se
relacionam com o tempo universal e para agendar tarefas que
requerem sincronização entre diferentes fusos horários.

[Link]
Quais são as implicações do uso de métodos obsoletos
como getYear() e setYear()?
Resposta:O uso de métodos obsoletos como getYear() e
setYear() pode levar a problemas de clareza e
compatibilidade, uma vez que esses métodos podem não se
comportar como esperado em ambientes modernos de
JavaScript. Os desenvolvedores são incentivados a usar seus
equivalentes atualizados, como getFullYear() e
setUTCFullYear(), para maior precisão e consistência.

[Link]
Como métodos estáticos como [Link]() e [Link]()
aprimoram a funcionalidade do objeto Date?
Resposta:Métodos estáticos como [Link]() e [Link]()
ampliam as capacidades do objeto Date, permitindo que os
desenvolvedores convertam facilmente strings em objetos de
data e criem representações UTC de datas sem a necessidade
de instanciar um objeto Date primeiro. Isso simplifica a
manipulação de datas e melhora a eficiência geral do código.

[Link]
Por que é essencial para os desenvolvedores entenderem
tanto os métodos get quanto os métodos set para o objeto
Date?
Resposta:Entender os métodos get e set para o objeto Date é
crucial para os desenvolvedores, pois isso lhes permite
recuperar e alterar com precisão valores de data e hora em
suas aplicações. Esse conhecimento é fundamental para
tarefas como agendamento, formatação de datas e garantir
cálculos de tempo corretos.

[Link]
Qual é o benefício de usar métodos como
toLocaleDateString() e toLocaleTimeString()?
Resposta:Métodos como toLocaleDateString() e
toLocaleTimeString() formatam datas e horários de acordo
com as configurações de local do usuário, facilitando a
apresentação das informações de data de uma maneira que
seja familiar e compreensível para os usuários. Isso melhora
a experiência do usuário e garante uma melhor comunicação
das informações relacionadas a datas.

[Link]
Como o objeto Date do JavaScript pode afetar aplicações
que lidam com agendamento ou transações sensíveis ao
tempo?
Resposta:O objeto Date fornece métodos essenciais para
gerenciar e manipular dados de data e hora com precisão, o
que é crítico para aplicações que lidam com agendamento e
transações sensíveis ao tempo. Ao aproveitar o objeto Date,
os desenvolvedores podem garantir que os eventos estejam
corretamente sincronizados e apresentar informações de data
relevantes de forma clara e precisa para os usuários.

[Link]
Quais considerações os desenvolvedores devem ter em
mente em relação ao horário de verão ao usar métodos do
objeto Date?
Resposta:Os desenvolvedores devem estar cientes de que
certos métodos, como getTimezoneOffset(), retornarão
valores diferentes dependendo de estarem ou não no horário
de verão. Isso pode impactar qualquer lógica baseada em
cálculos de data e hora, enfatizando a importância de testar
esses cálculos em torno das datas de início e fim do horário
de verão.
Capítulo 19 | Documento| Perguntas e respostas
[Link]
Por que o objeto Document é considerado um dos objetos
mais importantes no JavaScript do lado do cliente?
Resposta:O objeto Document representa o
documento HTML exibido no navegador,
permitindo que os desenvolvedores interajam e
manipulem o conteúdo das páginas da web de forma
dinâmica. Ele fornece métodos e propriedades
essenciais para acessar e modificar elementos,
formulários e outros componentes da página,
criando uma ponte entre HTML e JavaScript.

[Link]
Qual é a importância de propriedades como 'cookie' no
objeto Document?
Resposta:A propriedade 'cookie' no objeto Document permite
que o JavaScript leia e escreva cookies associados ao
documento. Isso é crucial para manter o estado da sessão,
preferências do usuário e gerenciar dados no lado do cliente,
aprimorando a experiência do usuário em sites.

[Link]
Como diferentes implementações do objeto Document
(como W3C DOM, IE e Netscape) afetam o
desenvolvimento web?
Resposta:Diferentes implementações do objeto Document
podem levar a problemas de compatibilidade entre
navegadores. Por exemplo, Netscape e IE introduziram
propriedades e métodos não padronizados que podem não ser
suportados em navegadores compatíveis com W3C. Isso
exige que os desenvolvedores escrevam códigos específicos
para cada navegador ou utilizem detecção de recursos para
assegurar um comportamento consistente em diferentes
plataformas.

[Link]
Por que propriedades como 'alinkColor' e 'bgColor'
podem ser consideradas obsoletas?
Resposta:Propriedades como 'alinkColor' e 'bgColor' são
consideradas obsoletas porque dependem de práticas HTML
antigas que não são mais recomendadas no desenvolvimento
web moderno. Em vez disso, CSS (Cascading Style Sheets) é
preferido para estilizar páginas da web, proporcionando mais
flexibilidade e mantendo a separação entre conteúdo e
apresentação.

[Link]
Como o status de carregamento de um documento se
relaciona com a experiência do usuário?
Resposta:O status de carregamento, indicado pela
propriedade 'readyState', impacta diretamente a experiência
do usuário. Por exemplo, se um documento ainda estiver
'carregando', os usuários podem ver conteúdo parcial ou não
responsivo. Os desenvolvedores podem usar essa informação
para fornecer animações de carregamento ou espaços
reservados, melhorando a percepção de desempenho e
interatividade da aplicação.

[Link]
Qual é o papel da propriedade 'documentElement' no
acesso à estrutura HTML?
Resposta:A propriedade 'documentElement' dá aos
desenvolvedores acesso direto à tag <html> do documento,
servindo como um ponto de partida para navegar pela toda
estrutura DOM. Essa propriedade simplifica o acesso à
configuração geral da página da web e é essencial para
aplicar manipulações em todo o documento.

[Link]
Por que é crítico entender e diferenciar entre
propriedades e métodos suportados por várias versões do
objeto Document?
Resposta:Entender as diferenças é fundamental para
desenvolver aplicações web robustas e compatíveis. Ao
utilizar recursos específicos de certos navegadores ou versões
do JavaScript, os desenvolvedores podem evitar armadilhas,
garantir maior acessibilidade e criar um código mais
resiliente que se adapta a ambientes variados.

[Link]
Como o objeto Document evoluiu desde sua introdução no
JavaScript 1.0?
Resposta:O objeto Document evoluiu significativamente,
com propriedades e métodos adicionais sendo incluídos nas
versões subsequentes (por exemplo, JS 1.1 e DOM Level 2).
Essa evolução incorpora práticas padronizadas do W3C,
compatibilidade aprimorada com os padrões web modernos e
funcionalidades melhoradas, como a criação de nós e acesso
a conteúdo dinâmico.

[Link]
Quais são os potenciais desafios associados ao uso de
propriedades não padronizadas definidas por
navegadores como o IE?
Resposta:Usar propriedades não padronizadas pode levar a
comportamentos inconsistentes entre diferentes navegadores.
Se um desenvolvedor depender dessas propriedades, a
aplicação web pode falhar ou não ser exibida corretamente
para usuários em navegadores que não suportam esses
recursos, prejudicando a acessibilidade e a experiência do
usuário.

[Link]
Como o método 'createElement' capacita os
desenvolvedores no JavaScript?
Resposta:O método 'createElement' permite que os
desenvolvedores criem dinamicamente novos elementos no
documento, capacitando-os a construir interfaces web
interativas e responsivas em tempo real. Essa capacidade é
fundamental para aplicações web modernas que exigem
manter uma experiência do usuário fluida sem
recarregamentos constantes da página.
Capítulo 20 | Elemento| Perguntas e respostas
[Link]
Qual é a importância do objeto Element no DOM e como
ele facilita a manipulação de elementos HTML?
Resposta:O objeto Element é fundamental no
Modelo de Objeto de Documento (DOM), pois
representa cada elemento ou tag HTML dentro de
um documento. Isso permite que os desenvolvedores
interajam programaticamente com a estrutura,
conteúdo e estilo de uma página web. Por exemplo,
ao acessar propriedades como className, style, ou
métodos como setAttribute, os desenvolvedores
podem mudar dinamicamente a aparência e o
comportamento dos elementos com base na
interação do usuário ou na lógica do aplicativo. Essa
interação conecta a natureza estática do HTML com
as capacidades dinâmicas do JavaScript,
aprimorando a experiência do usuário.

[Link]
Como as especificações DOM da W3C e do IE diferem em
relação às propriedades e métodos disponíveis para
elementos HTML?
Resposta:As especificações DOM da W3C e do IE divergem
significativamente tanto nas propriedades quanto nos
métodos. Embora existam propriedades comuns como
className e tagName, o DOM da W3C adere a um padrão
que é implementado de forma uniforme em navegadores
compatíveis. Por outro lado, o DOM do IE incorpora muitas
propriedades não padronizadas—como innerHTML e
outerHTML—que não são definidas pela W3C, levando a
inconsistências de comportamento entre diferentes
navegadores. Essa variação exige que os desenvolvedores
empreguem código condicional para garantir a
compatibilidade entre navegadores.

[Link]
Qual é o papel dos manipuladores de eventos nos
elementos HTML e como eles podem aprimorar a
interação do usuário?
Resposta:Os manipuladores de eventos são essenciais para os
elementos HTML, pois definem as diversas interações que
um usuário pode realizar, como cliques, pressionamentos de
tecla e movimentos do mouse. Por exemplo, ao usar o
manipulador de evento onclick, os desenvolvedores podem
acionar funções específicas em resposta aos cliques do
usuário, permitindo atualizações dinâmicas de conteúdo ou
iniciando animações. Essa capacidade transforma uma página
web estática em uma aplicação interativa, tornando-a vital
para a criação de interfaces de usuário responsivas.

[Link]
Por que é importante entender as propriedades e métodos
específicos fornecidos por diferentes implementações do
DOM?
Resposta:Entender as propriedades e métodos específicos de
diferentes implementações do DOM é crucial para os
desenvolvedores garantirem que suas aplicações funcionem
corretamente em vários navegadores. Dado que
incompatibilidades podem surgir devido a variações na forma
como os navegadores interpretam o DOM, os
desenvolvedores devem estar cientes dessas diferenças para
escrever um código robusto e compatível entre navegadores.
Essa expertise ajuda a prever problemas que podem surgir
devido à dependência de recursos não padronizados em um
único contexto de navegador.

[Link]
Explique a importância de métodos como getAttribute e
setAttribute no contexto do objeto Element.
Resposta:Métodos como getAttribute e setAttribute fornecem
funcionalidade essencial para a interação com os atributos
HTML de um elemento. getAttribute permite que os
desenvolvedores recuperem o valor atual de um atributo
específico, facilitando a leitura e utilização de dados
definidos no HTML. Por outro lado, setAttribute permite que
os desenvolvedores modifiquem ou definam valores de
atributos programaticamente. Isso é crucial para aplicações
do lado do cliente que requerem atualizações dinâmicas com
base nas interações do usuário ou em outras lógicas,
aprimorando assim a interatividade e a funcionalidade das
aplicações web.

[Link]
Como a propriedade innerHTML difere de innerText em
termos de seu impacto na gestão de conteúdo em um
documento HTML?
Resposta:A propriedade innerHTML facilita a manipulação
do conteúdo HTML de um elemento, permitindo que os
desenvolvedores insiram ou alterem estruturas HTML
completas, incluindo tags e estilos. Isso a torna poderosa,
mas pode levar a riscos de segurança potenciais (como XSS)
se não for tratada adequadamente. Em contraste, innerText
recupera ou modifica apenas o conteúdo de texto puro,
eliminando quaisquer tags HTML. Essa diferença é vital para
os desenvolvedores, pois entender quando usar cada uma
pode garantir o resultado desejado—seja para manter a
formatação ou simplesmente exibir texto de forma estática.
Capítulo 21 | Evento| Perguntas e respostas
[Link]
Qual é o propósito do objeto Event em JavaScript?
Resposta:O objeto Event serve para fornecer
detalhes sobre um evento e controle sobre sua
propagação, permitindo o tratamento das interações
do usuário em páginas da web.

[Link]
Como os objetos Event diferem entre os diferentes
navegadores?
Resposta:Navegadores como IE 4, 5 e 6 usam objetos
proprietários que diferem do objeto Event padronizado
definido no DOM Level 2. O Netscape 4 também possui seu
próprio objeto proprietário, mostrando a falta de
uniformidade no tratamento de eventos entre diferentes
navegadores.
[Link]
O que a propriedade eventPhase indica?
Resposta:A propriedade eventPhase indica a fase atual da
propagação do evento, que pode ser de captura, no alvo ou de
bolha, ajudando os desenvolvedores a entender como os
eventos fluem pela árvore do documento.

[Link]
A ação padrão de um evento pode ser cancelada? Como?
Resposta:Sim, a ação padrão pode ser cancelada usando o
método preventDefault(), se o evento for cancelável, o que
permite aos desenvolvedores controlar como os eventos se
comportam em uma página da web.

[Link]
Quais são as diferenças nas propriedades entre o objeto
DOM Event e o modelo de evento do IE?
Resposta:Embora ambos forneçam funcionalidades
semelhantes, o modelo de evento do IE inclui propriedades
adicionais como cancelBubble, que é usada para impedir que
o evento se propague ainda mais, enquanto o modelo DOM
utiliza métodos como stopPropagation() para efeitos
semelhantes.

[Link]
O que a propriedade target representa no objeto Event?
Resposta:A propriedade target representa o nó do documento
que gerou o evento, permitindo que os manipuladores
identifiquem a origem do evento.

[Link]
Como a posição dos eventos do mouse é determinada?
Resposta:Os eventos do mouse são determinados por
propriedades como clientX e clientY, que fornecem as
coordenadas X e Y do ponteiro do mouse em relação à janela
do navegador.

[Link]
No contexto do tratamento de eventos, o que se entende
por 'bolha'?
Resposta:A bolha é uma fase na propagação de eventos onde
o evento começa do elemento alvo e se propaga para cima
através dos ancestrais na hierarquia do DOM, permitindo que
os elementos pai também respondam ao evento.

[Link]
Qual é a importância de definir constantes como
Event.CAPTURING_PHASE, Event.AT_TARGET e
Event.BUBBLING_PHASE?
Resposta:Essas constantes fornecem uma forma padronizada
de se referir a fases específicas da propagação de eventos,
ajudando os desenvolvedores a gerenciar e compreender o
fluxo de eventos mais facilmente.

[Link]
Por que o objeto Event do Netscape 4 ainda pode ser útil
apesar dos padrões do DOM Level 2?
Resposta:O objeto Event do Netscape 4 pode ser útil para
programadores interessados em eventos de teclado, já que o
DOM Level 2 não especifica eventos de teclado,
proporcionando assim uma maneira alternativa de tratar tais
situações.
Capítulo 22 | Global| Perguntas e respostas
[Link]
Qual é o significado do objeto Global em JavaScript e
como ele se relaciona com propriedades e métodos
definidos pelo usuário?
Resposta:O objeto Global em JavaScript é a espinha
dorsal fundamental da linguagem, permitindo que
quaisquer variáveis e funções definidas no nível
superior do seu código se tornem propriedades desse
objeto. Isso significa que, se você declarar uma
variável em seu script sem envolvê-la em algum
objeto, ela pertence essencialmente ao objeto Global.
Por exemplo, se você definir uma função `function
greet() { return 'Hello, World!'; }`, você pode
chamá-la em qualquer lugar como `greet()`, uma vez
que é parte inerente do objeto Global. Esse princípio
é crucial porque enfatiza como o escopo funciona em
JavaScript; compreender o objeto Global ajuda a
evitar conflitos de nome e permite que os
desenvolvedores utilizem recursos globais de forma
sábia.

[Link]
Você pode explicar a diferença entre as funções
encodeURI() e encodeURIComponent()? Por que é
importante entender suas diferenças?
Resposta:A função `encodeURI()` é usada para codificar um
URI (Identificador Uniforme de Recurso) completo, mas não
codifica caracteres que têm significados especiais em um
URI, como `#`, `?` e `&`. Por outro lado,
`encodeURIComponent()` codifica caracteres que podem
causar problemas em componentes de URI, tornando-a
adequada para codificar componentes individuais de um URI.
Por exemplo, se você quiser enviar um parâmetro de consulta
que inclua símbolos especiais, deve usar
`encodeURIComponent()` para garantir que eles sejam
transmitidos de forma segura. Compreender essas diferenças
é crucial para evitar erros ao construir URIs, garantindo que
suas aplicações interpretem e naveguem entre URLs
corretamente.

[Link]
Qual é o papel da função eval() em JavaScript e quais são
as implicações de seu uso?
Resposta:A função `eval()` avalia uma string de código
JavaScript passada como parâmetro e a executa como se
fosse um código real. Por exemplo, chamar `eval('2 + 2')`
retornaria `4`. No entanto, é importante usar `eval()` com
cautela, pois pode introduzir riscos de segurança,
especialmente ao executar strings fornecidas pelo usuário, o
que pode levar a ataques de injeção de código. Além disso,
pode dificultar a depuração e impactar o desempenho.
Portanto, confiar em `eval()` geralmente é desencorajado em
favor de práticas de codificação mais seguras e manuteníveis.

[Link]
Como funções como isNaN() e isFinite() contribuem para
o manuseio de valores numéricos em JavaScript?
Resposta:As funções `isNaN()` e `isFinite()` fornecem uma
maneira de validar valores numéricos em JavaScript.
`isNaN()` verifica se um determinado valor é o especial
Not-a-Number (NaN), o que pode ajudar a garantir que
operações destinadas a variáveis numéricas não produzam
erros. Por outro lado, `isFinite()` verifica se um valor é um
número finito, o que é crucial para gerenciar efetivamente os
limites numéricos em aplicações, evitando problemas como
overflow aritmético ou comportamentos inesperados de
valores infinitos. Essas funções capacitam os
desenvolvedores a lidar com entradas numéricas de forma
robusta, melhorando a confiabilidade de suas aplicações.

[Link]
Qual era o propósito das funções escape() e unescape(), e
por que elas devem ser desaprovadas em favor de funções
mais novas?
Resposta:As funções `escape()` e `unescape()` foram
originalmente usadas para codificar e decodificar strings,
substituindo caracteres especiais por representações
hexadecimais. No entanto, essas funções foram desaprovadas
no ECMAScript 3 devido à sua funcionalidade limitada e ao
potencial de interpretar incorretamente certos caracteres.
Alternativas modernas como `encodeURI()`,
`encodeURIComponent()`, `decodeURI()` e
`decodeURIComponent()` fornecem capacidades de
codificação e decodificação mais precisas e abrangentes,
tornando-as mais seguras e eficazes para trabalhar com URIs
e garantindo que as strings sejam devidamente formatadas
para transmissão na web.
Capítulo 23 | Input| Perguntas e respostas
[Link]
Qual é a importância da propriedade 'checked' no objeto
Input e como ela pode melhorar a experiência do usuário
em formulários?
Resposta:A propriedade 'checked' permite que os
desenvolvedores determinem se uma caixa de
seleção ou botão de opção foi marcado pelo usuário.
Isso é crucial para formulários que requerem
escolhas do usuário, como acordos ou preferências.
Configurar essa propriedade pode aprimorar a
experiência do usuário ao lembrar as escolhas feitas
em diferentes sessões ou controlar o estado dos
componentes da interface com base nas interações
do usuário. Por exemplo, se um formulário está
sendo preenchido e o usuário retorna a uma seção,
marcar previamente as opções relevantes pode
economizar tempo e reduzir frustrações.

[Link]
Como a propriedade 'defaultValue' desempenha um papel
na usabilidade do formulário e por que é importante para
uma boa experiência do usuário?
Resposta:A propriedade 'defaultValue' define qual texto
aparece nos campos de texto ou senha quando o formulário é
carregado pela primeira vez. Isso é importante, pois fornece
aos usuários exemplos de entrada esperada, orientando
visualmente suas respostas. Por exemplo, colocar um texto
de exemplo como 'Digite seu e-mail' ajuda os usuários a
entender o formato necessário. Boa usabilidade reduz taxas
de erro e aumenta a satisfação, tornando os formulários
menos intimidadantes.

[Link]
Explique a importância da propriedade 'value' em vários
tipos de entrada e como ela afeta a submissão de dados
em aplicações web.
Resposta:A propriedade 'value' contém os dados que serão
transmitidos quando um formulário é enviado. Para entradas
de texto e senha, reflete o texto inserido pelo usuário,
tornando-se essencial para coletar dados com precisão. Para
botões, exibe o rótulo, orientando os usuários sobre ações
como 'Enviar' ou 'Redefinir'. Garantir que o valor correto seja
capturado ajuda a manter a integridade dos dados e melhora a
funcionalidade geral da aplicação.

[Link]
Quais vantagens os métodos 'focus()' e 'blur()' oferecem
para elementos de formulário, especialmente em termos
de acessibilidade?
Resposta:Os métodos 'focus()' e 'blur()' são vitais para
melhorar a acessibilidade dos formulários. 'focus()' permite
que os desenvolvedores direcionem programaticamente a
atenção do usuário para campos de entrada específicos, o que
pode ajudar muito pessoas que usam navegação por teclado
ou tecnologias assistivas. Por outro lado, 'blur()' ajuda a
gerenciar o foco do teclado, contribuindo para uma
experiência de interface mais fluida. Juntos, eles ajudam a
criar uma atmosfera mais interativa e amigável, tornando os
formulários acessíveis a um público mais amplo.

[Link]
Por que entender manipuladores de eventos como
'onchange' e 'onclick' é crucial para desenvolvedores que
trabalham com JavaScript do lado do cliente?
Resposta:Entender manipuladores de eventos como
'onchange' e 'onclick' é essencial para os desenvolvedores,
pois eles permitem interatividade e responsividade nos
formulários web. 'onchange' permite que a aplicação reaja
quando os usuários terminam sua entrada, acionando
validações ou lógicas de processamento. 'onclick' possibilita
ações ao clicar em botões, sendo crucial para determinar as
intenções do usuário. O domínio desses eventos promove
uma experiência dinâmica, fazendo com que as aplicações
pareçam responsivas e intuitivas, levando a uma maior
satisfação do usuário.
Capítulo 24 | Camada| Perguntas e respostas
[Link]
Qual é a importância do objeto Layer no Netscape 4 e por
que é considerado não padrão?
Resposta:O objeto Layer era significativo porque
proporcionava um meio de trabalhar com elementos
posicionados dinamicamente usando JavaScript no
Netscape 4, que não tinha um padrão robusto para
manipulação de posicionamento na época. No
entanto, é considerado não padrão porque esse
recurso não foi adotado em versões posteriores do
Netscape, como o Netscape 6, e não está em
conformidade com as práticas modernas de
desenvolvimento web. Seu uso é, em grande parte,
histórico, exemplificando a evolução das tecnologias
web.
[Link]
Como o objeto Layer gerencia a visibilidade e o
posicionamento em uma página web?
Resposta:O objeto Layer permite que os desenvolvedores
controlem a visibilidade das camadas através de propriedades
como 'hidden' e 'visibility', permitindo mostrar ou ocultar
seções de uma página web dinamicamente. Além disso,
propriedades como 'left', 'top' e 'zIndex' definem a posição da
camada dentro do documento, permitindo um controle
preciso sobre o layout e a sobreposição. Por exemplo, definir
um 'zIndex' mais alto em uma camada garante que ela
apareça acima de outra camada, o que é crucial na criação de
apresentações web interativas.

[Link]
Você pode explicar como funcionam os métodos
moveAbove e moveBelow?
Resposta:Os métodos 'moveAbove(other_layer)' e
'moveBelow(other_layer)' são usados para modificar a ordem
de empilhamento dos objetos Layer. Quando você quer que
uma camada intercepta visualmente outra (como fazer um
pop-up aparecer sobre um fundo), você acionaria
'moveAbove' naquela camada, passando a outra camada
como argumento. Por outro lado, 'moveBelow' permite
colocar uma camada atrás de outra, controlando efetivamente
qual conteúdo é visto primeiro pelo usuário. Este é um
aspecto fundamental da sobreposição no design web,
melhorando a experiência do usuário.

[Link]
Qual é o propósito das propriedades 'clip' no objeto
Layer?
Resposta:As propriedades 'clip' definem a área visível de um
objeto Layer. Ao definir as dimensões e coordenadas da área
de recorte (como [Link], [Link], [Link] e
[Link]), os desenvolvedores podem criar efeitos onde
apenas uma parte da camada é exibida enquanto o restante é
recortado. Isso é particularmente útil em cenários onde há
conteúdo sobreposto, pois permite a personalização de quais
partes da camada são visíveis para os usuários.
[Link]
Como o objeto Layer no Netscape 4 difere dos padrões
web modernos, como HTML5 e CSS?
Resposta:O objeto Layer é específico do Netscape 4 e foi
tornado obsoleto pelos padrões modernos de CSS que
utilizam estilos como 'position: absolute;' para propósitos
semelhantes em todos os navegadores de forma consistente.
Diferentemente do objeto Layer, que era pouco confiável
devido à sua não padronização, o CSS fornece uma estrutura
bem estabelecida para posicionamento e visibilidade que é
universalmente aceita e funcional no design web
contemporâneo. Essa evolução ilustra uma mudança em
direção a práticas padronizadas no desenvolvimento web.

[Link]
O que os desenvolvedores devem considerar ao trabalhar
com recursos não padronizados como o objeto Layer?
Resposta:Os desenvolvedores devem ter cautela ao usar
recursos não padronizados como o objeto Layer, pois podem
não funcionar em todos os navegadores ou em versões
futuras. É essencial priorizar a compatibilidade e
responsividade; usar recursos padrão de HTML5 e CSS em
vez disso garante maior acessibilidade e longevidade das
aplicações web. Além disso, a dependência de tecnologias
obsoletas poderia levar a problemas de manutenção e a uma
experiência de usuário ruim.
Capítulo 25 | Link| Perguntas e respostas
[Link]
Quais são as principais propriedades de um objeto Link
em JavaScript e por que elas são importantes?
Resposta:As principais propriedades de um objeto
Link incluem hash, host, hostname, href, pathname,
port, protocol, search e target. Essas propriedades
são importantes porque permitem que os
desenvolvedores manipulem e compreendam vários
componentes de uma URL, possibilitando um
comportamento dinâmico em aplicativos web, como
navegações, pesquisas e interações dentro de
diferentes frames ou janelas. Por exemplo, ao
modificar o `href`, os desenvolvedores podem
redirecionar usuários para diferentes páginas,
melhorando a experiência do usuário.

[Link]
Como os manipuladores de eventos em JavaScript para
links podem melhorar a interação do usuário?
Resposta:Manipuladores de eventos como onclick,
onmouseover e onmouseout oferecem uma forma de
responder às ações do usuário em links, aumentando a
interatividade. Por exemplo, com o manipulador de evento
onclick, os desenvolvedores podem executar código
JavaScript adicional quando um usuário clica em um link,
como rastrear cliques para análises ou impedir a navegação
retornando falso. Isso permite experiências de usuário mais
ricas e controle sobre o comportamento dos links
dependendo do contexto.

[Link]
Por que você usaria a propriedade target de um objeto
Link?
Resposta:A propriedade target é usada para especificar como
um documento vinculado deve ser exibido em relação à
janela ou frame atual. Usando valores como '_blank' abre o
link em uma nova aba, enquanto '_self' o abre no mesmo
frame. Isso permite que os desenvolvedores criem uma
experiência de navegação controlada, facilitando uma melhor
navegação sem perder a página atual.

[Link]
Você pode explicar a importância da propriedade search
em uma URL?
Resposta:A propriedade search, que inclui a string de
consulta de uma URL, é significativa porque se relaciona a
como os dados são enviados ao servidor para processamento.
Por exemplo, em um aplicativo de busca, parâmetros como
`?q=JavaScript&m=10` ajudam a transmitir a entrada ou
preferências do usuário ao servidor, permitindo respostas e
resultados personalizados. Isso enfatiza a importância de
compreender os componentes da URL para um
desenvolvimento web eficaz.

[Link]
Como entender as propriedades do objeto Link contribui
para boas práticas de desenvolvimento web?
Resposta:Compreender as propriedades do objeto Link
permite que os desenvolvedores criem aplicativos web
robustos e dinâmicos que interagem de forma fluida com os
usuários. Por exemplo, manipulando as propriedades href ou
search, os desenvolvedores podem mudar conteúdo
dinamicamente sem precisar recarregar a página. Isso
enriquece a experiência do usuário e aumenta o engajamento,
mostrando como um entendimento profundo de JavaScript
pode levar a uma melhor funcionalidade e satisfação em
projetos web.
Capítulo 26 | Math| Perguntas e respostas
[Link]
Qual é o propósito do objeto Math em JavaScript?
Resposta:O objeto Math serve como uma coleção de
constantes e funções matemáticas. Diferente de
outros objetos como Date e String, ele não
representa uma classe de objetos e não pode ser
instanciado. Em vez disso, ele fornece métodos
estáticos que realizam várias operações
matemáticas.

[Link]
Qual é a importância da constante [Link]?
Resposta:[Link] é uma constante matemática crucial que
representa a razão entre a circunferência de um círculo e seu
diâmetro, aproximadamente 3,14159. É amplamente utilizada
em cálculos envolvendo círculos, trigonometria e geometria.

[Link]
Como a função [Link] melhora o manuseio de dados?
Resposta:A função [Link] retorna o valor absoluto de um
número dado, permitindo que os desenvolvedores ignorem
facilmente o sinal de um número. Isso é útil em cenários
onde apenas a magnitude de um número é importante, como
em cálculos de distância.

[Link]
Você pode explicar a diferença entre [Link] e
[Link]?
Resposta:[Link] retorna o maior dos argumentos
fornecidos, enquanto [Link] retorna o menor. Essa
funcionalidade é essencial para comparar valores numéricos
e determinar extremos em conjuntos de dados.

[Link]
Como a função [Link] funciona e quando pode ser
utilizada?
Resposta:[Link] gera um número flutuante
pseudo-aleatório entre 0 (inclusivo) e 1 (exclusivo). Essa
função é particularmente útil em cenários envolvendo
aleatoriedade, como na criação de elementos aleatórios em
jogos, embaralhamento de dados ou seleção de usuários
aleatórios.

[Link]
Qual é o benefício de usar [Link]?
Resposta:[Link] permite a exponenciação, ou seja, pode
calcular qualquer número elevado a qualquer potência. Essa
operação é fundamental em muitos cálculos matemáticos,
desde quadrados simples até cálculos de potências mais
complexos que surgem em campos como física e engenharia.

[Link]
Qual é o uso prático das funções [Link] e [Link]?
Resposta:[Link] arredonda um número para cima até o
inteiro mais próximo, enquanto [Link] arredonda para
baixo. Isso pode ser útil em aplicações que exigem valores
inteiros limpos, como na paginação, onde não se pode ter
páginas fracionadas.

[Link]
Como entender as funções matemáticas em JavaScript
aprimora as habilidades de programação?
Resposta:Compreender as funções matemáticas permite que
desenvolvedores JavaScript manipulem números de forma
eficaz, resolvam problemas complexos e inovem soluções
digitais, promovendo criatividade e lógica no
desenvolvimento de software.
Capítulo 27 | Navegador| Perguntas e respostas
[Link]
Qual é o propósito da propriedade `appCodeName` no
Navigator?
Resposta:A propriedade `appCodeName` fornece
um apelido para o navegador, garantindo
compatibilidade entre diferentes navegadores. Por
exemplo, é 'Mozilla' em todos os navegadores
Netscape e também nos navegadores da Microsoft
para consistência.

[Link]
Como a propriedade `appVersion` pode ser útil no
desenvolvimento em JavaScript?
Resposta:A propriedade `appVersion` fornece informações
detalhadas sobre a versão do navegador e a plataforma em
que está sendo executada. Usando funções como `parseInt()`
e `parseFloat()`, os desenvolvedores podem facilmente
extrair números de versão principal e secundária, o que pode
ajudar a adaptar o comportamento da aplicação web a
versões específicas do navegador.

[Link]
Que tipo de informação a propriedade `cookieEnabled`
fornece e por que isso é importante?
Resposta:A propriedade `cookieEnabled` indica se o
navegador tem cookies habilitados. Isso é crucial para os
desenvolvedores ao implementar recursos que dependem de
cookies para gerenciamento de sessões, preferências do
usuário, ou rastreamento.
[Link]
Em que cenários as propriedades `language` e
`userLanguage` podem ser particularmente úteis?
Resposta:A propriedade `language` pode ajudar os
desenvolvedores a personalizar o conteúdo com base no
idioma padrão do navegador do usuário, enquanto
`userLanguage` indica o idioma preferido do usuário. Isso é
especialmente benéfico para criar aplicações web localizadas
que melhoram a experiência do usuário.

[Link]
Por que é significativo que a propriedade `platform`
possa ter valores variados?
Resposta:Os valores variados da propriedade `platform`
lembram os desenvolvedores que suas aplicações web devem
acomodar uma diversidade de sistemas operacionais e
configurações de hardware. Compreender essas variações
pode influenciar decisões de design e estratégias de teste para
garantir a compatibilidade entre plataformas.

[Link]
O que o método `javaEnabled()` indica sobre um
navegador e como isso pode afetar a funcionalidade da
web?
Resposta:O método `javaEnabled()` verifica se o Java é
suportado no navegador atual. Isso é significativo porque
certas aplicações web ou applets dependem do Java; saber se
está habilitado pode determinar se esses componentes devem
ser carregados.

[Link]
Como as propriedades e métodos do Navigator
aprimoram as práticas de desenvolvimento web?
Resposta:Essas propriedades e métodos dão aos
desenvolvedores uma visão sobre o ambiente do cliente,
permitindo que construam aplicações mais robustas e
amigáveis. Eles podem otimizar o desempenho, garantir
compatibilidade e melhorar a interação do usuário com base
nas capacidades específicas do navegador.
Capítulo 28 | Nodo| Perguntas e respostas
[Link]
Quais são os diferentes tipos de nós definidos no Node
DOM Level 1, e como a propriedade nodeType os
classifica?
Resposta:Os tipos de nós no Node DOM Level 1
incluem Nó de Elemento (nodeType = 1), Nó de
Atributo (nodeType = 2), Nó de Texto (nodeType =
3), Nó de Comentário (nodeType = 8), Nó de
Documento (nodeType = 9) e Nó de Fragmento de
Documento (nodeType = 11). A propriedade
nodeType nos permite identificar a qual subclasse
uma instância de Node pertence, proporcionando
clareza sobre como interagir com ela.

[Link]
Qual é a importância da propriedade attributes em nós
Element, e como ela é tipicamente usada?
Resposta:A propriedade attributes de um nó Element é um
array somente leitura que contém os objetos Attr
representando os atributos do elemento. Embora possa ser
acessada por número ou nome de atributo, é menos comum
usar esse array, já que todos os atributos HTML também têm
propriedades correspondentes no objeto Element, tornando o
acesso direto geralmente mais simples.

[Link]
Explique o propósito do método addEventListener e seus
parâmetros. Como isso se relaciona com o tratamento de
eventos no DOM?
Resposta:O método addEventListener é usado para registrar
um ouvinte de evento para um nó. Seus parâmetros incluem
type (uma string que especifica o tipo de evento, como
'click'), listener (a função manipuladora de evento que será
acionada) e useCapture (um booleano que indica a fase da
propagação do evento). Isso é fundamental para lidar com
interações do usuário e tornar a aplicação web responsiva a
eventos.

[Link]
Como o método insertBefore funciona e qual é o seu papel
na manipulação da árvore DOM?
Resposta:O método insertBefore permite adicionar um novo
Nó filho ao tree document antes de um Nó refChild
especificado que já é um filho de seu pai. Esse método é
crucial para reorganizar a estrutura do DOM, pois pode
atualizar a representação visual do documento
dinamicamente, sem precisar recriar elementos.

[Link]
Descreva o método cloneNode e seu parâmetro deep. Por
que alguém poderia usar essa funcionalidade?
Resposta:O método cloneNode retorna uma cópia do Nó
especificado. O parâmetro deep determina se também deve
clonar os descendentes do Nó, criando assim uma cópia
completa da subárvore (se for true). Isso é útil para duplicar
elementos, especialmente em cenários onde você deseja
preservar uma estrutura complexa e seus atributos.

[Link]
Qual é a importância do método normalize no contexto
dos nós de Texto?
Resposta:O método normalize limpa um Nó ao mesclar nós
de Texto adjacentes e remover os vazios. Isso efetivamente
organiza o conteúdo, garantindo que a estrutura do
documento não fique desordenada com nós desnecessários, o
que pode melhorar o desempenho e tornar a manipulação
subsequente mais eficiente.

[Link]
Você pode descrever a relação entre parentNode e
childNodes na árvore DOM?
Resposta:A propriedade parentNode refere-se ao pai imediato
do Nó, enquanto childNodes se refere à coleção de Nós que
são filhos diretos de um Nó. Essas relações representam a
natureza hierárquica do DOM, permitindo que os
desenvolvedores naveguem e manipulem elementos com
base em seu contexto estrutural.

[Link]
Quais são alguns métodos para remover um Nó do DOM
e como eles operam?
Resposta:Os métodos removeChild e removeEventListener
servem para gerenciar Nós no DOM. removeChild recebe um
Nó oldChild como argumento e o remove de seu pai. Esta
operação ajuda a alterar dinamicamente o conteúdo de uma
página da web. removeEventListener, por outro lado,
desanexa um ouvinte de evento previamente anexado,
permitindo que você controle as interações de evento para
um elemento.
Capítulo 29 | Número| Perguntas e respostas
[Link]
Qual é o propósito do construtor Number em JavaScript?
Resposta:O construtor Number, quando chamado
com o operador 'new', cria um novo objeto Number
e converte seu argumento em um valor numérico. Se
usado sem 'new', ele serve como uma função de
conversão que converte diretamente seu argumento
em um número.

[Link]
Quais são as principais constantes definidas no objeto
Number?
Resposta:As principais constantes incluem:
Number.MAX_VALUE (o maior número representável,
~1.79E+308), Number.MIN_VALUE (o menor número
representável, ~5E-324), [Link] (valor não numérico),
Number.NEGATIVE_INFINITY (valor infinito negativo) e
Number.POSITIVE_INFINITY (valor infinito positivo).
Essas constantes fornecem limites importantes e valores
especiais para cálculos numéricos.

[Link]
Como o método toExponential funciona em JavaScript?
Resposta:O método toExponential converte um número em
uma string na notação exponencial, garantindo que haja um
dígito antes do ponto decimal e um número específico de
dígitos após ele. O parâmetro 'digits' pode variar de 0 a 20, e
ajusta o número de acordo com o arredondamento ou
preenchimento com zeros quando necessário.

[Link]
Você pode explicar a diferença entre os métodos toFixed e
toLocaleString?
Resposta:O método toFixed retorna uma representação em
string de um número com um número fixo de casas decimais,
definido pelo parâmetro 'digits'. Em contraste, toLocaleString
formata o número de acordo com as convenções locais, que
podem incluir símbolos diferentes para pontos decimais e
separadores de milhar, tornando-o mais adequado para
exibições amigáveis ao usuário.

[Link]
Qual é o significado de [Link] em JavaScript?
Resposta:[Link] representa um valor 'não é um
número', que é essencial para tratamento de erros e validação
de cálculos numéricos em JavaScript. Indica que um valor
não é um número válido, o que é importante para garantir a
integridade das operações matemáticas.

[Link]
Como você converteria um número em uma string em
uma base diferente usando JavaScript?
Resposta:Você pode usar o método toString do objeto
Number, especificando a base (ou radix). A radix pode ser
qualquer número inteiro entre 2 e 36, permitindo que você
converta o número em binário, decimal, hexadecimal ou
outros sistemas numéricos. Se nenhuma radix for fornecida,
o padrão é a base 10.

[Link]
Quais são algumas implicações de usar constantes
Number como Number.MAX_VALUE e
Number.MIN_VALUE no seu código?
Resposta:Usar constantes como Number.MAX_VALUE e
Number.MIN_VALUE ajuda os desenvolvedores a definir
limites em cálculos numéricos, evitar erros de overflow ou
underflow, e escrever um código mais robusto e resistente a
erros. Essas constantes fornecem um salvaguarda contra a
superação das capacidades numéricas do JavaScript.

[Link]
Em quais cenários alguém usaria o método toPrecision?
Resposta:O método toPrecision é particularmente útil quando
você precisa apresentar números com um número específico
de dígitos significativos, como em relatórios científicos,
demonstrações financeiras ou sempre que um controle
preciso sobre a representação de dados numéricos for
necessário.
Capítulo 30 | Objeto| Perguntas e respostas
[Link]
Qual é a importância do construtor Object em
JavaScript?
Resposta:O construtor Object é fundamental em
JavaScript, pois cria um objeto vazio ao qual
propriedades arbitrárias podem ser adicionadas.
Essa flexibilidade é crucial para a programação
dinâmica, permitindo que os desenvolvedores criem
estruturas que podem conter diversos tipos de dados
e propriedades conforme necessário.

[Link]
Como os métodos 'hasOwnProperty', 'isPrototypeOf' e
'propertyIsEnumerable' melhoram as interações com
objetos em JavaScript?
Resposta:Esses métodos fornecem ferramentas essenciais
para gerenciar propriedades de objetos e herança em
JavaScript. 'hasOwnProperty' permite verificar se uma
propriedade pertence diretamente a um objeto, garantindo a
integridade dos dados. 'isPrototypeOf' ajuda a entender
cadeias de protótipo, facilitando a herança.
'propertyIsEnumerable' oferece uma visão sobre a
visibilidade das propriedades durante a enumeração, o que é
vital para processos de iteração, como loops.

[Link]
De que forma 'toString()' difere entre os vários tipos de
objetos em JavaScript?
Resposta:Embora o método base 'toString()' na classe Object
ofereça uma representação genérica, diferentes tipos de
objetos como Number ou Boolean geralmente sobrescrevem
esse método para fornecer uma saída mais significativa. Por
exemplo, chamar 'toString()' em um Number retorna o
número como uma string, tornando-o mais útil para
desenvolvedores que buscam saídas específicas.

[Link]
Por que uma subclasse poderia sobrescrever o método
'toLocaleString()'?
Resposta:Uma subclasse poderia sobrescrever
'toLocaleString()' para fornecer uma representação de string
específica de acordo com a localidade, aprimorando a
usabilidade para a internacionalização. Por exemplo, um
objeto Date pode formatar datas de maneira diferente
dependendo das configurações de localização do usuário,
garantindo que aplicações possam atender a diversos grupos
de usuários de forma eficaz.

[Link]
Qual é o papel do método 'valueOf()' em objetos
JavaScript?
Resposta:O método 'valueOf()' é projetado para retornar o
valor primitivo associado a um objeto quando necessário,
como durante operações que requerem um tipo não objeto.
Por exemplo, quando um objeto é usado em um contexto
matemático, invocar 'valueOf()' permite que a operação o
converta para o tipo primitivo relevante de forma integrada.
Capítulo 31 | RegExp| Perguntas e respostas
[Link]
Qual é a finalidade de usar expressões regulares em
JavaScript?
Resposta:As expressões regulares são usadas para
correspondência de padrões em strings, o que
permite pesquisar, substituir e manipular texto com
base em padrões específicos. Isso pode ser
particularmente útil para tarefas como validação de
entrada do usuário, análise de arquivos de texto ou
implementação de funcionalidades de busca.

[Link]
Como a propriedade 'global' de uma RegExp influencia o
processo de correspondência?
Resposta:A propriedade 'global', quando definida como
verdadeira, indica que a expressão regular buscará todas as
correspondências na string, em vez de parar após a primeira
correspondência. Isso significa que, se você usar a flag global
(g) em sua RegExp, métodos como exec() retornarão todas as
correspondências encontradas.

[Link]
O que a propriedade 'ignoreCase' faz no contexto das
expressões regulares?
Resposta:A propriedade 'ignoreCase' permite
correspondências que não diferenciam maiúsculas de
minúsculas. Isso significa que, se uma RegExp for criada
com o atributo 'i', ela tratará letras maiúsculas e minúsculas
como equivalentes ao realizar correspondências, facilitando a
correspondência de strings independentemente do caso das
letras.

[Link]
Você pode explicar a importância da propriedade
'lastIndex' em uma RegExp global?
Resposta:A propriedade 'lastIndex' é crucial para objetos
RegExp globais porque rastreia a posição na string onde a
próxima correspondência terá início. Após chamar exec() ou
test() em uma RegExp global, essa propriedade é atualizada
para apontar para o caractere logo após a última
correspondência, permitindo a iteração correta pela string
sem perder correspondências.

[Link]
Quando você usaria a propriedade 'multiline' de uma
RegExp?
Resposta:A propriedade 'multiline' é útil ao trabalhar com
strings que contêm caracteres de nova linha. Ao definir o
atributo 'm' em sua RegExp, a correspondência de padrões
tratará cada linha como uma string separada, o que afeta o
comportamento dos ancoradores de início (^) e fim ($) para
corresponder no começo e no fim de cada linha, em vez de
apenas no início e no fim da string inteira.

[Link]
Qual é o resultado de usar o método 'exec()' em uma
string com uma RegExp, e como você pode interpretar
seus resultados?
Resposta:Quando o método 'exec()' é usado em uma string
com uma RegExp, ele retorna um array que inclui o texto
totalmente correspondido como o primeiro elemento, junto
com quaisquer grupos capturados como elementos
subsequentes. Se nenhuma correspondência for encontrada,
retorna null. Esse array também inclui uma propriedade
'index' que indica onde na string original a correspondência
foi encontrada, facilitando a localização da correspondência
dentro da string.

[Link]
Como 'test()' e 'exec()' diferem ao trabalhar com
RegExp?
Resposta:O método 'test()' retorna um booleano indicando se
a RegExp corresponde a alguma parte da string, sendo uma
maneira rápida de verificar a correspondência. Em contraste,
'exec()' fornece um array detalhado de correspondência,
incluindo grupos capturados, tornando-se mais informativo,
mas também mais complexo. Use 'test()' para verificações
simples e 'exec()' quando precisar de informações de
correspondência mais detalhadas.
Capítulo 32 | Select| Perguntas e respostas
[Link]
Qual é a importância da propriedade `selectedIndex` em
um objeto Select?
Resposta:A propriedade `selectedIndex` é
fundamental, pois permite que os desenvolvedores
acompanhem qual opção o usuário selecionou em
uma lista suspensa. Ela retorna o valor do índice da
opção atualmente selecionada, o que pode ser útil
para a lógica condicional em scripts. Por exemplo, se
um usuário selecionar 'Opção 2', `selectedIndex`
retornaria 1 (já que é baseado em zero), permitindo
que você execute um código específico ou manipule a
interface com base na escolha do usuário.

[Link]
Como adicionar opções a um elemento Select usando
JavaScript?
Resposta:Para adicionar opções a um elemento Select, você
pode usar o construtor `Option()` para criar uma nova opção
e, em seguida, adicioná-la ao array `options` do objeto Select.
Por exemplo:

```javascript
var selectElement = [Link]('mySelect');
var newOption = new Option('Texto da Nova Opção',
'valorNovaOpção');
[Link][[Link]] =
newOption;
```
Este trecho de código adiciona efetivamente uma nova opção
ao final da lista de seleção, aumentando a interação e as
escolhas do usuário.

[Link]
Em quais cenários você usaria o método `remove` em um
objeto Select?
Resposta:Você normalmente usaria o método `remove`
quando precisar atualizar dinamicamente o conteúdo de uma
lista de seleção com base nas interações do usuário ou na
lógica do aplicativo. Por exemplo, se um usuário selecionar
seu país em uma lista e você quiser filtrar países que não são
relevantes de acordo com sua escolha, você pode remover as
opções irrelevantes do elemento Select para melhorar a
experiência do usuário.

[Link]
Explique o propósito dos manipuladores de eventos como
`onchange` e `onfocus` no contexto de elementos Select.
Resposta:Manipuladores de eventos como `onchange` e
`onfocus` são cruciais para aumentar a interatividade em
aplicativos web. O manipulador de eventos `onchange` é
acionado quando o usuário seleciona ou modifica sua
seleção, permitindo feedback imediato ou atualizações na
interface com base na seleção feita. Isso pode ser usado para
carregar dinamicamente o conteúdo relacionado. O
manipulador de eventos `onfocus`, por outro lado, é invocado
quando o usuário clica ou navega até o elemento Select,
sendo frequentemente usado para destacar o elemento ou
fornecer instruções ao usuário, assim melhorando a
usabilidade.

[Link]
Quais são as propriedades somente leitura do objeto
Select e por que são importantes?
Resposta:O objeto Select contém várias propriedades
somente leitura, como `form`, `length` e `type`. Essas
propriedades fornecem informações essenciais sobre o
contexto e a funcionalidade do elemento Select. Por exemplo,
`form` permite o acesso ao objeto Form que contém o Select,
o que é útil para gerenciar múltiplos elementos de
formulário. `length` fornece a contagem de opções
disponíveis, o que pode ajudar na validação da entrada do
usuário ou na adaptação dinâmica da interface com base no
número de seleções disponíveis. A propriedade `type`
especifica se várias seleções são permitidas, orientando os
desenvolvedores sobre como lidar com a entrada do usuário
de maneira apropriada.

[Link]
Como o método `add` pode facilitar a experiência do
usuário em formulários?
Resposta:O método `add` melhora a experiência do usuário
permitindo que os desenvolvedores insiram opções em
elementos Select em posições específicas. Isso é
especialmente útil em cenários onde a ordem das opções é
importante, como garantir que um item 'mais relevante'
apareça no topo de uma lista com base na atividade ou
preferências do usuário. Ao gerenciar programaticamente as
opções disponíveis, os desenvolvedores podem criar uma
interface mais intuitiva e eficiente que responde
dinamicamente às necessidades do usuário.
Capítulo 33 | String| Perguntas e respostas
[Link]
Qual é a importância de entender como manipular strings
em JavaScript?
Resposta:Entender a manipulação de strings em
JavaScript é vital, pois permite que os
desenvolvedores lidem de maneira eficaz com dados
textuais. Isso inclui tarefas como buscar caracteres
específicos, concatenar strings e realizar conversões
de caixa, que são essenciais tanto no
desenvolvimento front-end quanto back-end.
Dominar essas técnicas ajuda na criação de
aplicações dinâmicas e garante uma melhor
experiência para o usuário.

[Link]
Como o método 'slice' aprimora a manipulação de
strings?
Resposta:O método 'slice' é particularmente útil para extrair
partes específicas de uma string sem modificar a string
original. Ele permite que os desenvolvedores obtenham
substrings ao especificar índices de início e fim, acomodando
índices negativos que contam a partir do fim da string. Por
exemplo, ao aplicar slice(6, 11) na string 'Olá Mundo!',
obteremos 'Mundo', que é instrumental em tarefas como
extração de substrings em entradas do usuário ou
processamento de dados.

[Link]
Por que o método 'indexOf' é essencial ao trabalhar com
strings?
Resposta:O método 'indexOf' é essencial, pois fornece uma
maneira de localizar a primeira ocorrência de uma substring
dentro de uma string maior, retornando sua posição. Isso é
crucial para validação de dados, funcionalidades de busca e
correspondência de padrões, capacitando os desenvolvedores
a criar aplicações mais inteligentes ao permitir buscas
direcionadas dentro do texto.

[Link]
Em quais cenários você usaria o método 'replace', e como
ele funciona?
Resposta:O método 'replace' é inestimável quando você
precisa atualizar ou modificar partes de uma string com base
em padrões ou textos específicos. Por exemplo, se você
quiser alterar todas as instâncias de 'maçã' em 'Eu amo torta
de maçã' para 'laranja', você poderia usar replace(/maçã/g,
'laranja'), que utiliza uma expressão regular para garantir que
todas as ocorrências sejam alteradas. Este método facilita
atualizações dinâmicas de conteúdo, como sanitização de
entradas do usuário ou geração de novo texto com base nas
preferências do usuário.

[Link]
Quais são as melhores práticas para criar um novo objeto
String e quando você deve usá-lo?
Resposta:Criar um novo objeto String usando 'new String(s)'
geralmente não é recomendado, pois envolve encapsular o
valor em um objeto, em vez de criar uma string primitiva, o
que pode levar a comportamentos inesperados. A melhor
prática é usar literais de string ou o construtor String sem
'new'. Use-o com moderação quando precisar de um objeto
com métodos de string, mas, na maioria dos casos,
mantenha-se a strings primitivas para melhor desempenho e
simplicidade.

[Link]
Como os métodos 'toLowerCase' e 'toUpperCase'
contribuem para a consistência dos dados?
Resposta:Os métodos 'toLowerCase' e 'toUpperCase' são
vitais para manter a consistência dos dados, especialmente
em cenários de entrada do usuário, onde a diferenciação entre
maiúsculas e minúsculas pode levar a discrepâncias. Por
exemplo, converter a entrada do usuário para minúsculas
antes do armazenamento garante que as comparações sejam
uniformes, evitando problemas como 'NomeDeUsuário'
versus 'nomedeusuario'. Essa prática não apenas melhora a
integridade dos dados, mas também aprimora a experiência
do usuário, evitando erros relacionados a maiúsculas.

[Link]
Qual é o papel das expressões regulares em métodos como
'match' e 'search'?
Resposta:As expressões regulares (regex) são ferramentas
poderosas usadas dentro dos métodos 'match' e 'search' para
realizar correspondência de padrões complexos em strings.
Esses métodos utilizam regex para identificar sequências
específicas, validar formatos ou extrair informações
significativas de textos maiores. O domínio de regex
combinado com esses métodos eleva a capacidade de um
desenvolvedor de implementar funcionalidades de busca
sofisticadas, validações de dados e tarefas de processamento
de texto.
Capítulo 34 | Estilo| Perguntas e respostas
[Link]
Qual é a relação entre as propriedades CSS e as
propriedades de estilo do DOM em JavaScript?
Resposta:As propriedades do objeto Style em
JavaScript refletem de perto as dos atributos CSS,
com certas convenções de nomenclatura adaptadas à
sintaxe do JavaScript. Por exemplo, propriedades
CSS como 'font-family' são convertidas para
'fontFamily' em JavaScript, eliminando hífens e
capitalizando as palavras seguintes. Isso permite que
os desenvolvedores manipulem estilos CSS
diretamente através do DOM do JavaScript.

[Link]
Quais são algumas considerações especiais ao trabalhar
com propriedades de estilo que possuem valores
numéricos?
Resposta:Ao lidar com propriedades CSS que possuem
valores numéricos, é crucial realizar a conversão entre strings
e números. Use parseFloat() para recuperar o valor numérico
de uma string e, ao definir uma propriedade, certifique-se de
converter o número de volta para uma string enquanto inclui
as unidades necessárias (como 'px'); por exemplo, definir a
largura de um elemento pode ser algo como
'[Link] = "100px".'

[Link]
Por que algumas propriedades CSS podem não ser
implementadas em todos os navegadores?
Resposta:Diferentes navegadores podem ter níveis variados
de suporte para as propriedades CSS, o que significa que,
embora as propriedades de estilo estejam definidas dentro do
objeto Style, seu comportamento pode diferir. É por isso que
os desenvolvedores devem sempre verificar a
compatibilidade entre os navegadores e consultar recursos
externos de CSS para obter as informações mais confiáveis.

[Link]
Como o modelo de objeto em JavaScript ajuda a estilizar
páginas da web de forma dinâmica?
Resposta:O modelo de objeto do JavaScript permite a
manipulação em tempo real dos estilos CSS, o que significa
que os desenvolvedores podem mudar a aparência dos
elementos da web dinamicamente com base nas interações do
usuário ou em outras condições. Isso é fundamental na
criação de designs responsivos e aplicações web interativas,
melhorando a experiência do usuário ao permitir um
feedback visual imediato.

[Link]
Qual é a importância da propriedade ‘cssFloat’ em
JavaScript?
Resposta:A propriedade ‘cssFloat’ é uma adaptação dentro
do objeto Style do JavaScript para lidar com atributos de
flutuação CSS, já que 'float' é uma palavra reservada em
JavaScript. Isso destaca a importância de adaptar as
propriedades CSS para a sintaxe do JavaScript e garante que
os desenvolvedores ainda possam controlar efetivamente as
propriedades de layout por meio de scripts.

[Link]
Como os desenvolvedores podem garantir que estão
fazendo referência precisa aos estilos CSS ao utilizar
JavaScript?
Resposta:Os desenvolvedores devem se referir a referências
CSS atualizadas para entender as propriedades disponíveis e
sua sintaxe. Eles também precisam considerar as regras que
governam como as propriedades CSS são convertidas em
propriedades JavaScript, garantindo que sigam as convenções
de nomenclatura adequadas para evitar erros em seu código.
Capítulo 35 | Window| Perguntas e respostas
[Link]
Qual é o propósito principal do objeto Window no
JavaScript do lado do cliente?
Resposta:O objeto Window atua como o objeto
global para todo o JavaScript do lado do cliente,
fornecendo propriedades e métodos que facilitam a
interação com o navegador e permitem que os
desenvolvedores criem conteúdo dinâmico.

[Link]
Como a função 'alert' demonstra a interatividade do
JavaScript?
Resposta:A função 'alert' exibe uma caixa de diálogo com
uma mensagem, pausando a execução do script até que o
usuário a feche. Isso exemplifica a capacidade do JavaScript
de criar experiências interativas em aplicações web.

[Link]
Quais são os comportamentos especiais associados à
propriedade 'location' do objeto Window?
Resposta:A propriedade 'location' pode tanto recuperar a
URL atual da janela do navegador quanto, ao ser atribuída
uma nova string de URL, instruir o navegador a carregar e
exibir a URL especificada, permitindo a navegação entre
diferentes páginas.

[Link]
Por que é importante entender que o JavaScript é uma
linguagem sensível a maiúsculas e minúsculas?
Resposta:Saber que o JavaScript é sensível a maiúsculas e
minúsculas ajuda a prevenir erros relacionados ao nome das
variáveis e funções, garantindo que os programadores usem
consistentemente a caixa correta para se referir a seus
identificadores.

[Link]
Qual é a importância da propriedade 'navigator' no
objeto Window?
Resposta:A propriedade 'navigator' fornece detalhes
importantes sobre o navegador web do usuário, incluindo seu
nome e versão, o que é crucial para escrever um código
compatível com diferentes navegadores.

[Link]
De que forma as funções definidas pelo usuário podem
melhorar a capacidade de um programa em JavaScript?
Resposta:Funções definidas pelo usuário permitem código
modular e reutilizável, capacitando os desenvolvedores a
encapsular lógicas e reduzir redundâncias ao chamar a
mesma função várias vezes com diferentes argumentos
conforme necessário.

[Link]
Como o conceito de 'prototype' contribui para a
programação orientada a objetos no JavaScript?
Resposta:O prototype permite que objetos herdem
propriedades e métodos de outros objetos, facilitando uma
forma de herança que promove a reutilização de código e a
gestão eficiente da memória, evitando a duplicação de
métodos para cada instância.

[Link]
Qual é o papel do tratamento de eventos no JavaScript do
lado do cliente?
Resposta:O tratamento de eventos permite que o JavaScript
responda às interações do usuário com elementos HTML
(como cliques ou pressões de tecla), possibilitando respostas
dinâmicas, como a atualização do conteúdo da página sem a
necessidade de um recarregamento completo.

[Link]
Explique o conceito de 'escopo' no JavaScript e sua
importância.
Resposta:Escopo define a visibilidade e a vida útil das
variáveis no JavaScript. Compreender o escopo é crucial para
gerenciar o acesso a variáveis e evitar conflitos em
programas maiores, especialmente com a distinção entre
variáveis globais e locais.

[Link]
Por que é essencial que os desenvolvedores compreendam
os tipos de dados do JavaScript?
Resposta:Compreender os tipos de dados é vital, uma vez
que eles ditam como os valores podem ser utilizados,
manipulados e comparados no JavaScript, influenciando o
desempenho e a correção na lógica de programação.
JavaScript Quiz e teste
Ver a resposta correta no site do Bookey

Capítulo 1 | Seção 1.1. Sintaxe| Quiz e teste

1.A sintaxe do JavaScript é semelhante à do Java,
que é derivado do C e C++.
2.O JavaScript não distingue maiúsculas de minúsculas para
palavras-chave e identificadores.
[Link] identificadores em JavaScript podem começar com um
dígito.
Capítulo 2 | Seção 1.3. Tipos de Dados| Quiz e teste
[Link] suporta três tipos de dados primitivos:
números, booleanos e strings; e dois tipos de dados
compostos: objetos e arrays.
2.O tipo booleano em JavaScript tem três valores possíveis:
true, false e null.
[Link] em JavaScript são mutáveis, o que significa que
modificações alteram a string original.
Capítulo 3 | Seção 1.4. Expressões e Operadores|
Quiz e teste
[Link] usa os mesmos operadores que C e C++
sem operadores adicionais.
2.O operador '+' em JavaScript pode ser usado tanto para
adição quanto para concatenação de strings.
[Link] JavaScript, o operador 'typeof' só pode ser usado em
números.
Capítulo 4 | Seção 1.5. Instruções| Quiz e teste
[Link] expressão em JavaScript pode ser uma
instrução independente.
[Link] instrução vazia é representada por chaves ({ }) e não
faz nada.
3.A instrução 'for/in' é usada para percorrer propriedades de
um objeto.
Capítulo 5 | Seção 1.6. JavaScript Orientado a
Objetos| Quiz e teste
[Link] em JavaScript são arrays associativos que
ligam valores a propriedades nomeadas.
[Link] função construtora é utilizada para criar uma nova
classe em JavaScript, e é invocada sem o operador 'new'.
[Link] definidas no protótipo de um construtor não
são herdadas por objetos criados com esse construtor.
Capítulo 6 | Seção 1.7. Expressões Regulares| Quiz e
teste
[Link] expressões regulares do JavaScript utilizam
uma sintaxe semelhante à do Java.
[Link] expressões regulares, o caractere '.' corresponde a
 qualquer caractere, exceto uma nova linha.
3.O quantificador '+' em expressões regulares corresponde a
zero ou uma vez.
Capítulo 7 | Seção 1.8. Versões do JavaScript| Quiz e
teste
[Link] 1.0 foi a primeira versão do JavaScript
implementada no Netscape 2 e agora está obsoleta.
[Link] 5.5 é equivalente ao JavaScript 1.4 e está em
conformidade com a ECMA v2.
[Link] pode ser incluído no HTML por meio da tag
<script>, manipuladores de eventos e URLs de JavaScript.
Capítulo 8 | Seção 2.1. JavaScript em HTML| Quiz e
teste
[Link] pode ser integrado em arquivos HTML
por meio de scripts, manipuladores de eventos e
URLs de JavaScript.
2.O atributo `language` é a maneira recomendada de
especificar a linguagem de script na tag <script>.
[Link] só pode ser executado através da tag <script> e
não pode ser acionado por manipuladores de eventos ou
URLs.
Capítulo 9 | Seção 2.2. O Objeto Window| Quiz e
teste
1.O objeto Window é o objeto global no JavaScript
do lado do cliente.
2.O método `setInterval()` é usado para executar código
apenas uma vez em um intervalo especificado.
3.A propriedade `navigator` fornece informações sobre o
sistema do usuário, incluindo o nome do navegador.
Capítulo 10 | Seção 2.3. O Objeto Documento| Quiz e
teste
[Link] objeto Window tem uma propriedade
document que se refere a um objeto Document,
que é crucial, pois representa o documento HTML
exibido na janela do navegador.
2.O DOM W3C não é padronizado e não fornece acesso
abrangente a todo o conteúdo do documento.
3.O DOM IE 4 foi desenvolvido pela Microsoft e ofereceu
recursos poderosos para manipulação do conteúdo do
documento que não eram padronizados.
Capítulo 11 | Seção 2.4. O DOM Legado| Quiz e teste
1.O Legacy DOM permite acesso a várias
propriedades e conteúdos do documento.
[Link] propriedades do objeto Document incluem um método
para interagir diretamente com todos os tipos de tags
HTML.
3.A propriedade cookie pode ser usada para definir e
recuperar cookies do documento em JavaScript.
Capítulo 12 | Seção 2.5. O W3C DOM| Quiz e teste
1.O DOM W3C permite que scripts manipulem
apenas formulários e imagens.
[Link]ê pode encontrar elementos pelo seu id único usando o
método getElementById().
3.A propriedade nodeType indica o tipo de um nó com
valores como 1 para Texto e 2 para Elemento.
Capítulo 13 | Seção 2.6. DOM do IE 4| Quiz e teste
1.O DOM do IE 4 é um modelo de objeto de
documento padrão.
[Link] elementos no DOM do IE 4 podem ser acessados
usando o array all[] do objeto documento.
3.A travessia da Árvore do Documento no DOM do IE 4 usa
a propriedade children[] em vez de childNodes[].
Capítulo 14 | Seção 2.7. DHTML: Programando
Estilos CSS| Quiz e teste
[Link] dinâmico (DHTML) combina HTML, CSS
e JavaScript para modificações de estilo
dinâmicas.
[Link] JavaScript, os atributos CSS com hífens são acessados
usando a mesma convenção de nomenclatura com hífens.
3.O atributo 'float' em CSS é referido como 'cssFloat' em
JavaScript.
Capítulo 15 | Seção 2.8. Eventos e Manipulação de
Eventos| Quiz e teste
[Link] atributos de manipuladores de eventos em
HTML começam com 'on'.
[Link] falso de um manipulador de eventos vai impedir a
ação de onmouseover em todos os casos.
3.O modelo W3C permite que múltiplos manipuladores de
eventos sejam registrados para um único tipo de evento
usando addEventListener().
Capítulo 16 | Seção 2.9. Restrições de Segurança do
JavaScript| Quiz e teste
[Link] scripts podem acessar propriedades de janelas
e documentos de qualquer servidor web devido à
Política da Mesma Origem.
[Link] não pode manipular a propriedade valor do
elemento de formulário FileUpload.
[Link] configurações do navegador podem permitir que os
usuários bloqueiem anúncios em pop-up e manipulem
tamanhos de janelas devido às restrições de segurança do
JavaScript em evolução.
Capítulo 17 | Array| Quiz e teste
1.O método construtor 'new Array()' cria um array
vazio em JavaScript.
[Link] em JavaScript só podem ser criados usando o
método construtor 'new Array()', não com a sintaxe literal.
3.O método 'pop()' remove o primeiro elemento de um array
em JavaScript.
Capítulo 18 | Data| Quiz e teste
1.O objeto Date em JavaScript pode ser criado
utilizando diferentes formatos, incluindo um
timestamp em milissegundos.
2.O método `getYear()` no objeto Date retorna o ano
completo (ex: 2023).
3.O método `[Link](...)` retorna a representação em
milissegundos para a data e hora local especificadas.
Capítulo 19 | Documento| Quiz e teste
1.O objeto Document foi introduzido em JavaScript
1.0 e foi aprimorado no JavaScript 1.1.
2.A propriedade 'alinkColor' do objeto Document é
atualmente recomendada para uso.
3.O método 'createElement(tagName)' é usado para criar um
novo node de Elemento no documento.
Capítulo 20 | Elemento| Quiz e teste
1.O objeto Element representa um elemento ou tag
HTML em um documento e herda propriedades
do objeto Node, conforme definido no DOM Level
1.
2.A propriedade 'all[]' é uma propriedade do DOM W3C
usada para acessar objetos Element descendentes.
3.O método 'getAttribute(name)' é usado para deletar um
atributo nomeado de um objeto Element.
Capítulo 21 | Evento| Quiz e teste
1.O objeto Evento fornece detalhes sobre um evento
e controla sua propagação em diferentes
 ambientes de navegadores.
[Link] as propriedades do objeto Evento são de leitura e
escrita, permitindo que sejam modificadas durante o
tratamento do evento.
[Link] modelo do IE, o evento pode ser acessado através da
propriedade evento do objeto Window.
Capítulo 22 | Global| Quiz e teste
1.O objeto Global em JavaScript é representado
pelo objeto Window na programação do lado do
cliente.
2.A função isNaN(n) verifica se n é um número.
3.A função encodeURIComponent(s) codifica todos os
caracteres em um URI.
Capítulo 23 | Input| Quiz e teste
1.O objeto Input em JavaScript representa
elementos HTML `<input>` e fornece
propriedades para seus atributos.
2.A propriedade 'defaultChecked' indica se um campo de
entrada de texto foi marcado inicialmente.
3.O manipulador de evento 'onchange' é ativado quando o
foco se afasta após a alteração do texto.
Capítulo 24 | Camada| Quiz e teste
1.O objeto Layer é um recurso padrão usado em
todos os navegadores.
[Link]ê pode referenciar um objeto Layer usando
 [Link][i] ou [Link][nome-do-layer].
3.O método load(src, width) é usado apenas para
redimensionar a camada para dimensões específicas.
Capítulo 25 | Link| Quiz e teste
1.O objeto Link em JavaScript herda da classe
Element.
2.A propriedade 'search' do objeto Link não inclui o ponto de
interrogação em seu valor.
3.O manipulador de evento 'onclick' pode ser usado para
impedir seguir um link se ele retornar falso em JavaScript
1.1.
Capítulo 26 | Math| Quiz e teste
1.O objeto Math em JavaScript não possui um
construtor e suas funções são independentes.
[Link] é uma constante que representa o valor de À em
JavaScript.
[Link]() retornará -Infinity se nenhum argumento for
fornecido.
Capítulo 27 | Navegador| Quiz e teste
1.A propriedade appCodeName no objeto navigator
normalmente retorna 'Mozilla' para navegadores
tanto da Netscape quanto da Microsoft.
2.A propriedade userLanguage especifica a língua padrão do
usuário como um valor numérico.
3.O método javaEnabled() retorna verdadeiro se o Java não
for suportado no navegador atual.
Capítulo 28 | Nodo| Quiz e teste
[Link] Nó em uma árvore de documentos pode ser de
tipos como Attr, Comment, Document,
DocumentFragment, Element ou Text.
2.A propriedade nodeType de um objeto Node especifica o
valor para seu tipo de nó, mas não é somente leitura.
3.O método `addEventListener(type, listener, useCapture)` é
usado para remover um listener de evento de um Nó.
Capítulo 29 | Número| Quiz e teste
1.O construtor Number pode criar um novo objeto
Number apenas quando usado com o operador
new.
[Link].MAX_VALUE representa o menor número
representável em JavaScript.
3.O método toFixed retorna uma representação em string de
um número com um número especificado de casas
decimais.
Capítulo 30 | Objeto| Quiz e teste
1.O construtor `new Object();` cria um objeto vazio
 que pode ter propriedades arbitrárias adicionadas.
2.O método `valueOf()` para o tipo Object retorna seu valor
primitivo, se disponível. Para Object, ele retorna um objeto
diferente em vez do próprio objeto.
3.O método `toLocaleString()` fornece uma representação
genérica em string do objeto, sem permitir que subclasses
substituam seu comportamento.
Capítulo 31 | RegExp| Quiz e teste
[Link] expressões regulares (RegExp) só podem ser
definidas usando um construtor em JavaScript.
2.O método 'test' de RegExp retorna verdadeiro se houver
uma correspondência, caso contrário, retorna falso.
3.A propriedade de instância 'global' indica se a RegExp é
usada para correspondência sem diferenciação de
maiúsculas e minúsculas.
Capítulo 32 | Select| Quiz e teste
1.A propriedade 'selectedIndex' retorna -1 se
nenhuma opção estiver selecionada.
2.O método 'remove(n)' remove o primeiro elemento do array
de opções quando n é 0.
3.O método 'blur()' é usado para ganhar foco no teclado em
um objeto Select.
Capítulo 33 | String| Quiz e teste
1.A manipulação de strings foi introduzida no
JavaScript 1.0.
2.O método `substring(from, to)` extrai caracteres entre `to` e
 `from`.
3.A propriedade `length` de uma string em JavaScript é uma
propriedade de somente leitura que representa o número de
caracteres na string.
Capítulo 34 | Estilo| Quiz e teste
1.O objeto Style em JavaScript permite a
manipulação direta das propriedades CSS
definidas pela especificação CSS2.
2.A propriedade float é mantida como 'float' no objeto Style
para garantir consistência com os padrões CSS.
[Link] as propriedades CSS suportadas pelo objeto Style
são garantidas de serem implementadas por todos os
navegadores atuais.
Capítulo 35 | Window| Quiz e teste
1.O método `alert()` é usado para exibir uma
mensagem em uma caixa de diálogo no JavaScript
do lado do cliente.
2.A propriedade `navigator` fornece informações específicas
sobre o sistema operacional do usuário.
[Link] manipuladores de eventos em JavaScript são definidos
usando atributos dentro das tags HTML.