Implementação do JavaScript
- Página Anterior História do JavaScript
- Próxima Página Sintaxe do ECMAScript
O ECMAScript, núcleo do JavaScript, descreve a sintaxe e os objetos básicos da linguagem;
O DOM descreve métodos e interfaces para lidar com o conteúdo da página web;
O BOM descreve métodos e interfaces para interagir com o navegador.
ECMAScript, DOM e BOM
Embora o ECMAScript seja um padrão importante, ele não é a única parte do JavaScript, claro, nem é a única parte padronizada. Na verdade, uma implementação completa do JavaScript é composta por 3 partes diferentes:
ECMAScript
O ECMAScript não está vinculado a nenhum navegador específico, na verdade, ele também não menciona métodos para entrada e saída de usuários (o que difere de linguagens como C, que dependem de bibliotecas externas para tais tarefas). Então, o que é o ECMAScript? A descrição do padrão ECMA-262 (2º parágrafo) é a seguinte:
O ECMAScript pode fornecer capacidades de programação de scripts para diferentes tipos de ambientes hospedeiros, portanto, o linguagem de script central está separada de qualquer ambiente hospedeiro específico ... ...
O navegador da Web para o ECMAScript é um ambiente hospedeiro, mas não é o único. De fato, há inúmeras outras variações de ambientes (por exemplo, o ScriptEase do Nombas e o ActionScript da Macromedia, usado ao mesmo tempo em Flash e Director MX) que podem conter implementações do ECMAScript. Então, o que determina o ECMAScript fora do navegador?
O navegador da Web é um ambiente hospedeiro para o ECMAScript, mas não é o único. De fato, há inúmeras outras variações de ambientes (como o ScriptEase do Nombas e o ActionScript da Macromedia, usado ao mesmo tempo em Flash e Director MX) que podem conter implementações do ECMAScript. Então, o que determina o ECMAScript fora do navegador?
- Simplificando, o ECMAScript descreve o seguinte:
- Tipos
- Sentenças
- Palavras-chave
- Palavras-chave reservadas
- Operadores
- Objetos
O ECMAScript é apenas uma descrição, que define todas as propriedades, métodos e objetos do linguagem de script. Outros idiomas podem implementar o ECMAScript como um padrão de funcionalidade, assim como o JavaScript:
Cada navegador tem sua própria implementação do interface ECMAScript, que é então estendida, incluindo DOM e BOM (serão discutidos em seções posteriores). Claro, há outras implementações e extensões do ECMAScript que não são navegadores, como o Windows Scripting Host (WSH), o ActionScript da Macromedia em Flash e Director MX, e o Nombas ScriptEase.
1. Versões do ECMAScript
O ECMAScript é dividido em várias versões diferentes e é definido em um padrão chamado ECMA-262. Como outros padrões, o ECMA-262 é editado e atualizado. Quando há atualizações principais, é lançada uma nova versão do padrão. A versão mais recente do ECMA-262 é a 5.1, lançada em junho de 2011.
A primeira versão do ECMA-262 é essencialmente a mesma que o Netscape JavaScript 1.1, exceto que todas as partes relacionadas ao navegador foram removidas, além de algumas pequenas ajustes. Primeiro, o ECMA-262 requer suporte ao padrão Unicode (para suporte a múltiplas linguagens). Segundo, ele requer que os objetos sejam independentes da plataforma (o JavaScript 1.1 do Netscape, na verdade, tem diferentes implementações de objetos, como o objeto Date, que depende da plataforma). Essa é a principal razão pela qual o JavaScript 1.1 e 1.2 não se conformam ao padrão ECMA-262 da primeira versão.
A maioria das atualizações da segunda edição do ECMA-262 foram essencialmente editoriais. Esta atualização do padrão foi para garantir a rigorosa conformidade com o ISO/IEC-16262, e não houve adição, alteração ou exclusão de conteúdo específico. O ECMAScript geralmente não observa a segunda edição.
A terceira edição do ECMA-262 foi a primeira atualização real do padrão. Ele forneceu atualizações para o processamento de strings, definição de erros e saída numérica. Além disso, ele adicionou suporte para expressões regulares, novos comandos de controle, tratamento de exceções try...catch e algumas pequenas mudanças para tornar o padrão mais internacional. Geralmente, ele marcou o ECMAScript como uma verdadeira linguagem de programação.
2. O que é conformidade ECMAScript
No ECMA-262, a conformidade do ECMAScript tem uma definição clara. Um linguagem de script deve atender aos seguintes quatro princípios básicos:
- As implementações que atendem devem seguir as descrições de suporte a todos os “tipos, valores, objetos, propriedades, funções e linguagem de programas e semântica” descritas no ECMA-262 (ECMA-262, primeira página)
- As implementações que atendem devem suportar o padrão de caracteres Unicode (UCS)
- As implementações que atendem podem adicionar “tipos, valores, objetos, propriedades e funções” não especificados no ECMA-262. O ECMA-262 descreve essas adições como novos objetos ou novas propriedades de objetos no padrão
- As implementações que atendem podem suportar a “sintaxe de programas e expressões regulares” não definidas no ECMA-262 (o que significa que podem substituir ou expandir o suporte embutido para expressões regulares)
Todas as implementações do ECMAScript devem atender aos padrões acima.
3. Suporte ao ECMAScript nos navegadores da web
O Navigator 3.0 com JavaScript 1.1 foi lançado em 1996. Em seguida, o padrão JavaScript 1.1 foi apresentado como um rascunho de novo padrão para a EMCA. Com a popularidade espetacular do JavaScript, a Netscape começou felizmente a desenvolver a versão 1.2. Mas havia um problema, a ECMA não aceitou o rascunho da Netscape. Pouco tempo após o lançamento do Navigator 3.0, a Microsoft lançou o IE 3.0. Esta versão do IE continha JScript 1.0 (o nome da implementação do JavaScript própria da Microsoft), que originalmente planejada para ser comparável ao JavaScript 1.1. No entanto, devido à falta de documentação e algumas características repetidas incorretas, o JScript 1.0 ficou longe do nível do JavaScript 1.1.
Antes da finalização da primeira edição da ECMA-262, o Netscape Navigator 4.0, que continha o JavaScript 1.2, foi lançado em 1997. No final daquele ano, o padrão ECMA-262 foi aceito e padronizado. Portanto, o JavaScript 1.2 não é compatível com a primeira edição do ECMAScript, embora o ECMAScript devia ser baseado no JavaScript 1.1.
O próximo passo para o JScript foi a inclusão do JScript 3.0 no IE 4.0 (a versão 2.0 foi lançada junto com o IIS 3.0, mas não foi incluída no navegador). A Microsoft promoveu o JScript 3.0 como a primeira linguagem de script no mundo a atender plenamente aos padrões ECMA. Naquela época, a ECMA-262 ainda não estava finalizada, então o JScript 3.0 sofreu o mesmo destino do JavaScript 1.2 - ele também não conseguiu atender aos padrões finais do ECMAScript.
A Netscape escolheu atualizar sua implementação do JavaScript no Netscape Navigator 4.06. O JavaScript 1.3 finalmente fez o Netscape conformar-se completamente ao primeiro padrão ECMAScript. A Netscape adotou o suporte ao padrão Unicode e manteve todas as novas características introduzidas no JavaScript 1.2, implementando também a independência de plataforma.
Quando a Netscape publicou seu código-fonte como projeto Mozilla, o JavaScript 1.4 estava programado para ser integrado ao Netscape Navigator 5.0. No entanto, uma decisão audaciosa - redesenhar completamente o código da Netscape, destruiu esse trabalho. O JavaScript 1.4 foi lançado apenas como linguagem de script do lado do servidor para o Netscape Enterprise Server e nunca foi incluído nos navegadores.
Hoje em dia, todos os navegadores web populares seguem a terceira edição da ECMA-262.
A tabela a seguir lista o suporte ao ECMAScript em muitos dos navegadores web mais populares:
| Navegadores | Compatibilidade DOM |
|---|---|
| Netscape Navigator 2.0 | - |
| Netscape Navigator 3.0 | - |
| Netscape Navigator 4.0 - 4.05 | - |
| Netscape Navigator 4.06 - 4.79 | Edição 1 |
| Netscape 6.0+ (Mozilla 0.6.0+) | Edição 3 |
| Internet Explorer 3.0 | - |
| Internet Explorer 4.0 | - |
| Internet Explorer 5.0 | Edição 1 |
| Internet Explorer 5.5+ | Edição 3 |
| Opera 6.0 - 7.1 | Edição 2 |
| Opera 7.2+ | Edição 3 |
| Safari 1.0+/Konqueror ~ 2.0+ | Edição 3 |
DOM
DOM (Modelo de Objetos de Documento) é uma interface de aplicativo (API) para HTML e XML. O DOM organiza toda a página em um documento composto por uma hierarquia de nós. Cada parte de uma página HTML ou XML é um derivado de um nó. Considere a seguinte página HTML:
<html>
<head>
<title>Página de Exemplo</title>
</head>
<body>
<p>hello world!</p>
</body>
</html>
Este código pode ser desenhado como um gráfico de hierarquia de nós usando DOM:
O DOM representa o documento através da criação de uma árvore, permitindo que os desenvolvedores tenham controle sem precedentes sobre o conteúdo e a estrutura do documento. Com a API DOM, é fácil deletar, adicionar e substituir nós.
1. Por que o DOM é indispensável
Desde que o IE 4.0 e o Netscape Navigator 4.0 começaram a suportar diferentes formas de HTML dinâmico (DHTML), os desenvolvedores pela primeira vez puderam modificar a aparência e o conteúdo do documento sem recarregar a página. Isso foi um grande salto na tecnologia da Web, mas também trouxe enormes problemas. A Netscape e a Microsoft desenvolveram seus próprios DHTML, encerrando a era em que os desenvolvedores podiam escrever uma única página HTML que funcionasse em todos os navegadores.
A indústria decidiu que é necessário fazer algo para manter a característica de plataforma cruzada da Web, eles se preocupam que, se deixarem a Netscape e a Microsoft fazerem isso, a Web inevitavelmente se dividirá em duas partes independentes, cada uma adequada apenas para um navegador específico. Portanto, o grupo responsável por especificar os padrões de comunicação da Web, W3C (World Wide Web Consortium), começou a desenvolver o DOM.
2. Níveis do DOM
O DOM Level 1 foi proposto pela W3C em outubro de 1998. Ele consiste em dois módulos, DOM Core e DOM HTML. O primeiro fornece uma estrutura de documento baseada em XML para acessar e operar qualquer parte do documento; o segundo adiciona objetos e métodos específicos do HTML, expandindo o DOM Core.
Atenção, o DOM não é exclusivo do JavaScript, na verdade, muitos outros idiomas implementaram ele. No entanto, o DOM no navegador da Web já foi implementado com ECMAScript, e agora é uma grande parte da linguagem JavaScript.
O DOM Level 1 é um objetivo, ou seja, planejar a estrutura do documento, enquanto o objetivo do DOM Level 2 é muito mais amplo. A expansão do DOM original adiciona suporte para eventos de mouse e interface do usuário (DHTML tem suporte rico para isso), escopo, navegação (métodos repetidos no DOM do documento) e suporte para CSS (folhas de estilo em cascata) através de interfaces de objetos. O DOM Core original introduzido no Level 1 também adiciona suporte para namespaces XML.
O DOM Level 2 introduziu vários novos módulos DOM, usados para lidar com novos tipos de interfaces DOM:
- Visão DOM - Descreve a rastreamento de várias visões do documento (isto é, o documento antes e após a estiloização CSS)
- Eventos DOM - Descreve as interfaces para eventos
- Estilo DOM - Descreve as interfaces para lidar com estilos baseados em CSS
- Navegação e Escopo DOM - Descreve as interfaces para navegação e operação da árvore de documentos
O DOM Level 3 introduziu métodos para carregar e manter documentos de maneira uniforme (inclusos no módulo DOM Load and Save) e métodos para validar documentos (DOM Validation), expandindo ainda mais o DOM. No Level 3, o DOM Core é expandido para suportar todas as características do XML 1.0, incluindo XML Infoset, XPath e XML Base.
Ao estudar DOM, pode-se encontrar alguém citando o DOM Level 0. Note que não há padrão DOM Level 0, ele é apenas um ponto de referência histórico do DOM (DOM Level 0 se refere ao DHTML original suportado no IE 4.0 e Netscape Navigator 4.0).
3. Outros DOM
Além do DOM Core e DOM HTML, outras várias linguagens publicaram seus próprios padrões DOM. Essas linguagens são baseadas em XML, e cada DOM adiciona métodos e interfaces específicos para a linguagem correspondente:
- Linguagem vetorial escalável (SVG) 1.0
- Linguagem de marcação digital (MathML) 1.0
- Linguagem de integração de mídia síncrona (SMIL)
Notas:Se desejar aprender mais sobre o conteúdo relacionado, acesse o CodeW3C's Tutorial de SMIL e Tutorial de SVG.
Além disso, outras linguagens também desenvolveram suas próprias implementações do DOM, como a linguagem de interface de XML do Mozilla (XUL). No entanto, apenas as linguagens listadas acima são padrões recomendados pelo W3C.
Suporte DOM em navegadores da Web
O DOM já era um padrão antes de ser implementado pelos navegadores da Web. A primeira tentativa do IE de implementar o DOM foi na versão 5.0, mas na verdade, foi a partir da versão 5.5 que ele começou a ter suporte real ao DOM, implementando o Nível 1 do DOM. Desde então, o IE não introduziu novas funcionalidades do DOM.
O Netscape só introduziu suporte ao DOM até a versão 6 (Mozilla 0.6.0). Atualmente, o Mozilla possui o melhor suporte ao DOM, implementando o Nível 1 completo, quase todo o Nível 2 e parte do Nível 3. (O objetivo do grupo de desenvolvimento do Mozilla é construir um navegador 100% compatível com os padrões, e seu trabalho foi recompensado.)
O Opera só começou a suportar DOM a partir da versão 7.0, e o Safari também implementou a maioria do Nível 1 do DOM. Eles estão praticamente no mesmo nível que o IE 5.5, e em alguns casos, até superam o IE 5.5. No entanto, em termos de suporte ao DOM, todos os navegadores estão muito atrás do Mozilla. A tabela a seguir lista o suporte ao DOM dos navegadores mais comuns.
| Navegadores | Compatibilidade DOM |
|---|---|
| Netscape Navigator 1.0 - 4.x | - |
| Netscape 6.0+ (Mozilla 0.6.0+) | Nível 1, Nível 2, Nível 3 (parte) |
| IE 2.0 - 4.x | - |
| IE 5.0 | Nível 1 (mínimo) |
| IE 5.5+ | Nível 1 (quase todo) |
| Opera 1.0 - 6.0 | - |
| Opera 7.0+ | Nível 1 (quase todo), Nível 2 (parte) |
| Safari 1.0+/Konqueror ~ 2.0+ | Nível 1 |
Notas:Se desejar aprender mais sobre o conhecimento do DOM, acesse o CodeW3C's Tutorial de HTML DOM e Tutorial de XML DOM.
BOM
O IE 3.0 e o Netscape Navigator 3.0 forneceram uma característica - BOM (Modelo de Objeto Navegador), que permite o acesso e a operação de janelas de navegador. Com o BOM, os desenvolvedores podem mover janelas, mudar o texto na barra de estado e executar outras ações não diretamente relacionadas ao conteúdo da página. O que torna o BOM único e frequentemente suspeito é que ele é apenas uma parte do JavaScript, sem qualquer padrão relacionado.
O BOM principal lida com janelas de navegador e frames, mas geralmente, as extensões JavaScript específicas do navegador são consideradas parte do BOM. Essas extensões incluem:
- Abrir uma nova janela do navegador
- Mover, fechar a janela do navegador e ajustar o tamanho da janela
- Objeto que fornece detalhes sobre o navegador da Web
- Objeto que fornece detalhes sobre a resolução da tela do usuário
- Suporte a cookies
- O IE expandiu o BOM, adicionando a classe ActiveXObject, que pode instanciar objetos ActiveX via JavaScript
Devido à falta de padrões BOM relacionados, cada navegador tem sua própria implementação BOM. Existem alguns padrões de fato, como um objeto janela e um objeto navegação, mas cada navegador pode definir suas próprias propriedades e métodos para esses objetos ou outros objetos.
Ver:
- Página Anterior História do JavaScript
- Próxima Página Sintaxe do ECMAScript
