JavaScript

Origem: Wikipédia, a enciclopédia livre.
Ir para: navegação, pesquisa
NoFonti.svg
Este artigo ou se(c)ção cita fontes fiáveis e independentes, mas que não cobrem todo o conteúdo (desde novembro de 2010). Por favor, adicione mais referências e insira-as corretamente no texto ou no rodapé. Material sem fontes poderá ser removido.
Encontre fontes: Google (notícias, livros e acadêmico)
JavaScript
Unofficial JavaScript logo 2.svg
Logotipo não-oficial da JSConf EU 2011.
Paradigma Multi-paradigma: com base em protótipo funcional
imperativo
scripts
Surgido em 1995
Última versão 1.8.5 (22 de março de 2011[1] )
Criado por Brendan Eich
Estilo de tipagem: Dinâmica, fraca e implícita
Dialetos: ISO/IEC C++ 1998
ISO/IEC C++ 2003
Influenciada por Self, C, Lisp, Scheme, Perl, Python, Java
Influenciou JScript, ActionScript, JScript .NET, Objective-J, TIScript

JavaScript é uma linguagem de programação interpretada[2] . Foi originalmente implementada como parte dos navegadores web para que scripts pudessem ser executados do lado do cliente e interagissem com o usuário sem a necessidade deste script passar pelo servidor, controlando o navegador, realizando comunicação assíncrona e alterando o conteúdo do documento exibido.

É atualmente a principal linguagem para programação client-side em navegadores web. Começa também a ser bastante utilizada do lado do servidor através de ambientes como o node.js. Foi concebida para ser uma linguagem script com orientação a objetos baseada em protótipos, tipagem fraca e dinâmica e funções de primeira classe. Possui suporte à programação funcional e apresenta recursos como fechamentos e funções de alta ordem comumente indisponíveis em linguagens populares como Java e C++.

É baseada em ECMAScript padronizada pela Ecma international nas especificações ECMA-262[3] e ISO/IEC 16262.

História[editar | editar código-fonte]

JavaScript foi originalmente desenvolvido por Brendan Eich da Netscape sob o nome de Mocha, posteriormente teve seu nome mudado para LiveScript e por fim JavaScript. LiveScript foi o nome oficial da linguagem quando foi lançada pela primeira vez na versão beta do navegador Netscape 2.0 em setembro de 1995, mas teve seu nome mudado em um anúncio conjunto com a Sun Microsystems em dezembro de 1995 quando foi implementado no navegador Netscape versão 2.0B3.

A mudança de nome de LiveScript para JavaScript coincidiu com a época em que a Netscape adicionou suporte à tecnologia Java em seu navegador (Applets). A escolha final do nome causou confusão dando a impressão de que a linguagem foi baseada em java, sendo que tal escolha foi caracterizada por muitos como uma estratégia de marketing da Netscape para aproveitar a popularidade do recém-lançado Java.

JavaScript rapidamente adquiriu ampla aceitação como linguagem de script client-side de páginas web. Como consequência, a Microsoft desenvolveu um dialeto compatível com a linguagem de nome JScript para evitar problemas de marca registrada. JScript adicionou novos métodos para consertar métodos do Javascript relacionados a data que apresentavam problemas[carece de fontes?]. JScript foi incluído no Internet Explorer 3.0, liberado em Agosto de 1996. Javascript e Jscript são tão similares que os dois termos são comumente usados de forma intercambiável. A Microsoft entretanto declara muitas características nas quais JScript não conforma com a especificação ECMA.

Em novembro de 1996 a Netscape anunciou que tinha submetido JavaScript para Ecma internacional como candidato a padrão industrial e o trabalho subsequente resultou na versão padronizada chamada ECMAScript.

JavaScript tem se transformado na linguagem de programação mais popular da web. Inicialmente, no entanto, muitos profissionais denegriram a linguagem pois ela tinha como alvo principal o público leigo. Com o advento do Ajax, JavaScript teve sua popularidade de volta e recebeu mais atenção profissional. O resultado foi a proliferação de frameworks e bibliotecas, práticas de programação melhoradas e o aumento no uso do JavaScript fora do ambiente de navegadores, bem como o uso de plataformas de JavaScript server-side.[4]

Em janeiro de 2009 o projeto CommonJS foi fundado com o objetivo de especificar uma biblioteca padrão para desenvolvimento JavaScript fora do navegador.

Características[editar | editar código-fonte]

As seguintes características são comuns a todas as implementações conformantes com o ECMAScript.

Imperativa e Estruturada[editar | editar código-fonte]

JavaScript suporta os elementos de sintaxe de programação estruturada da linguagem C (por exemplo, if, while, switch). Uma exceção é a questão do escopo: o escopo em blocos ao estilo do C não é suportado, em seu lugar JavaScript utiliza escopo a nível de função. JavaScript 1.7, entretanto, suporta escopo a nível de bloco através do comando let. Como C, JavaScript faz distinção entre expressões e comandos. Uma diferença sintática do C é que a quebra de linha termina automaticamente o comando, sendo o ponto-e-vírgula opcional ao fim do comando.

Dinâmica[editar | editar código-fonte]

Tipagem dinâmica[editar | editar código-fonte]

Como na maioria das linguagens de script, tipos são associados com valores, não com variáveis. Por exemplo, a variável x poderia ser associada a um número e mais tarde associada a uma string. JavaScript suporta várias formas de testar o tipo de um objeto, incluindo duck typing.

Baseada em objetos[editar | editar código-fonte]

JavaScript é quase inteiramente baseada em objetos. Objetos JavaScript são arrays associativos, aumentados com protótipos. Os nomes da propriedade de um objeto são strings: obj.x = 10 e obj["x"] = 10 são equivalentes, o ponto neste exemplo é apenas sintático. Propriedades e seus valores podem ser adicionadas, mudadas, ou deletadas em tempo de execução. A maioria das propriedades de um objeto (e aqueles em sua cadeia de herança via protótipo) pode ser enumerada usando-se uma estrutura de repetição for...in. Javascript possui um pequeno número de objetos padrão da linguagem como window e document.

Avaliação em tempo de execução[editar | editar código-fonte]

JavaScript inclui a função eval que consegue executar em tempo de execução comandos da linguagem que estejam escritos em uma string.

Funcional[editar | editar código-fonte]

Funções de primeira classe[editar | editar código-fonte]

No JavaScript as funções são de primeira classe, isto é, são objetos que possuem propriedades e métodos, e podem ser passados como argumentos, serem atribuídos a variáveis ou retornados como qualquer outro objeto.

Funções aninhadas[editar | editar código-fonte]

Funções 'internas' ou 'aninhadas' são funções definidas dentro de outras funções. São criadas cada vez que a função que as contém (externa) é invocada. Além disso, o escopo da função externa, incluindo constantes, variáveis locais e valores de argumento, se transforma parte do estado interno de cada objeto criado a partir da função interna, mesmo depois que a execução da função interna é concluída.

Fechamentos[editar | editar código-fonte]

JavaScript permite que funções aninhadas sejam criadas com o escopo léxico no momento de sua definição e possui o operador () para invocá-las em outro momento. Essa combinação de código que pode ser executado fora do escopo no qual foi definido, com seu próprio escopo durante a execução, é denominada, dentro da ciência da computação, fechamento.

Baseada em Protótipos[editar | editar código-fonte]

Protótipos[editar | editar código-fonte]

JavaScript usa protótipos em vez de classes para o mecanismo herança. É possível simular muitas características de orientação a objetos baseada em classes com protótipos.

Funções e métodos[editar | editar código-fonte]

Diferente de muitas linguagens orientadas a objetos, não há distinção entre a definição de uma função e a definição de um método no JavaScript. A distinção ocorre durante a chamada da função; a função pode ser chamada como um método. Quando uma função é chamada como método de um objeto, a keyword this da função é associada àquele objeto via tal invocação.

Uso em páginas Web[editar | editar código-fonte]

O uso primário de JavaScript é escrever funções que são embarcadas ou incluídas em páginas HTML e que interagem com o Modelo de Objeto de Documentos (DOM) da página. Alguns exemplos deste uso são:

  • abrir uma nova janela com controle programático sobre seu tamanho, posição e atributos;
  • validar valores de um formulário para garantir que são aceitáveis antes de serem enviados ao servidor;
  • mudar imagens à medida que o mouse se movimenta sob elas.

Pelo fato do código JavaScript rodar localmente no navegador do usuário, e não em um servidor remoto, o navegador pode responder a tais ações rapidamente, fazendo uma aplicação mais responsiva. Além disso, o código JavaScript pode detectar ações de usuário que o HTML sozinho não pode, tais como teclas pressionadas individualmente. Aplicações como Gmail tomam vantagem disso: muito da lógica da interface do usuário é escrita em JavaScript, e o JavaScript envia requisições de informação, tais como o conteúdo de um correio eletrônico, para o servidor. A tendência mais ampla de programação em Ajax explora de maneira similar este ponto forte.

Uma JavaScript engine (também conhecida como interpretador JavaScript ou uma implementação JavaScript) interpreta código fonte JavaScript e o executa de forma adequada. A primeira implementação JavaScript foi criada por Brendan Eich na Netscape Communications Corporation, para o Navegador Netscape. A implementação, nomeada SpiderMonkey, é implementada em C e vem sendo atualizada para conformar com a edição 3 do ECMA-262. A implementação Rhino, criada primariamente por Norris Boyd (ex-empregado da Netscape; agora no Google) é uma implementação de JavaScript em Java. Rhino, como SpiderMonkey, é conformante com a terceira edição do ECMA-262.

Por ser o JavaScript a única linguagem que a maioria dos navegadores populares suportam, tem se tornado uma linguagem alvo para muitos frameworks em outras linguagens, a despeito do fato de não ter sido planejado para tal. Não obstante as limitações de desempenho inerente à sua natureza dinâmica, a crescente velocidade das implementações JavaScript tem feito da mesma uma prática linguagem intermediária.

Exemplo[editar | editar código-fonte]

Um exemplo minimalista de uma página conforme os padrões web (utilizando a sintaxe HTML5) que contém JavaScript pode ser representado pelo seguinte código:

<!DOCTYPE html>
<html lang="pt-BR">
    <head>
        <meta charset="UTF-8" />
        <title>Wikipédia</title>
        <script>
            window.onload = function () {
                document.getElementById("hello").addEventListener("click", function () {
                    alert("Bem-vindo à Wikipédia!");
                }, false);
            };
        </script>
    </head>
    <body>
        <noscript>Seu navegador não suporta JavaScript ou ele está desabilitado.</noscript>
        <button id="hello">Dizer "Olá"</button>
    </body>
</html>

No script acima, vimos que existe uma tag chamada <noscript>, ela está neste código HTML porque é um meio de acessibilidade com o cliente, fazendo com que seu texto seja renderizado pelo navegador quando o JavaScript estiver desativado.

Compatibilidade[editar | editar código-fonte]

Já que JavaScript roda em ambientes variáveis, uma parte importante do teste e depuração de seu código consiste na verificação de compatibilidade entre navegadores.

As interfaces DOM para a manipulação de páginas web não são parte do padrão ECMA, ou do próprio JavaScript. Oficialmente, são definidas por um esforço de padronização da W3C; na prática, implementações de navegadores diferem do padrão de uma para as outras, e nem todos navegadores executam JavaScript.

Para lidar com essas diferenças, programadores JavaSCript com frequência tentam escrever códigos que conformam com o padrão comum a maioria dos navegadores; não sendo possível isso, tentam escrever de maneira ad-hoc um código que verifique a presença de certos recursos e que se comporte de maneira adequada caso tais recursos não estejam disponíveis. Em alguns casos, dois navegadores podem ambos implementarem uma funcionalidade com comportamentos diferentes, e programadores podem achar prático detectar qual navegador está rodando e mudar o comportamento de seus scripts para se adequar a isso. Programadores podem também usar bibliotecas ou ferramentas que abstraem tais diferenças entre navegadores.

Além disso, scripts podem não funcionar para alguns usuários. Por exemplo, um usuário pode:

  • Usar um navegador antigo ou raro com suporte DOM incompleto ou incomum.
  • Usar um navegador de um PDA ou telefone móvel que não está apto a executar JavaScript.
  • Ter a execução do JavaScript desabilitada por normas de segurança.

Para suportar tais usuários, programadores web tentam criar páginas que sejam robustas a agentes que não suportem o JavaScript da página. Em particular, uma página deve funcionar a despeito das funcionalidades extras que um JavaScript provê. Uma abordagem alternativa que muitos acham preferível é a página se desenvolvida por primeiro a partir de tecnologias básicas que funcionem em todos os navegadores, e então aprimorá-la para os usuários que possuam JavaScript.

Acessibilidade[editar | editar código-fonte]

Assumindo que o usuário não tenha desabilitado sua execução, pode-se utilizar JavaScript do lado cliente para melhorar a experiência de um usuário com deficiência física ou visual.

Leitores de tela utilizados por pessoas cegas ou com visão parcial podem detectar a presença de JavaScript e dessa forma acessar e ler o DOM da página depois que seus scripts foram executados. Nestes casos recomenda-se que o HTML seja o mais conciso, navegável e rico semanticamente possível, tendo a página scripts ou não. Não se recomenda que o código JavaScript de uma página seja totalmente dependente do eventos provenientes do mouse já que usuários que não conseguem ou optam por não usar o mouse não estarão aptos a colher os benefícios de tal código. Da mesma forma, embora hyperlinks e webforms possam ser navegados e operados do teclado, JavaScript voltado para acessibilidade não deve requerer um teclado para acessar tais eventos. JavaScript conta com eventos independentes do dispositivo de usuário tais como onfocus e onchange que são mais recomendados na maioria dos casos.

Não se recomenda utilizar JavaScript de um jeito que seja confuso ou desorientador para qualquer usuário da internet. Por exemplo, usar JavaScript para alterar ou desabilitar a funcionalidade normal de um navegador, tal como mudar a forma com que o botão direito ou o evento de atualização funcionam, deve ser evitado. Da mesma forma, eventos de interrupção que o usuário pode não estar ciente reduzem a sensação de controle do usuário, assim como scripts inesperados que mudam o conteúdo da página.

Frequentemente o processo de fazer páginas web complexas tão acessíveis quanto possível se transforma em um problema não trivial, onde certas decisões são assunto de debate e opinião. Entretanto, tecnologias assistivas estão constantemente evoluindo e novas recomendações e informações relevantes vem sendo continuamente publicadas na web.

Segurança[editar | editar código-fonte]

JavaScript e o DOM representam uma potencialidade para programadores maliciosos escreverem scripts para rodarem em um cliente via web. Navegadores são projetados para conter este risco de duas maneiras. A primeira é que scripts são rodados em uma sandbox na qual só podem executar ações relacionadas à internet, não tarefas de programação de propósito geral como criar arquivos. A segunda é que scripts são limitados pela regra da mesma origem: scripts de um web site não têm acesso a informações como nomes de usuário, senhas ou cookies enviados de outro site. A maioria dos bugs em JavaScript relacionados à segurança são brechas de uma das regras.

Vulnerabilidades inter-sites[editar | editar código-fonte]

Um problema comum relacionado à segurança é a escrita de scripts inter-sites, ou XSS, uma violação da regra da mesma origem. Tais vulnerabilidades ocorrem quando um atacante está apto a causar em um site alvo, como um site de banco, a inclusão de um script malicioso na página web apresentada à vítima. O script neste exemplo pode então acessar a aplicação do banco com privilégios da vítima, potencialmente revelando informações secretas ou transferindo dinheiro sem a autorização da vítima.

Alguns navegadores incluem proteção parcial contra ataques XSS refletidos, no qual o atacante fornece uma URL incluindo o script malicioso. No entanto, mesmo usuários destes sites estão vulneráveis a outros ataques XSS, como aqueles onde o código malicioso é guardado em um banco de dados. Apenas o correto desenho de aplicações web no servidor pode prevenir inteiramente ataques XSS.

Vulnerabilidades XSS também podem ocorrer por causa de erros de implementação por parte de programadores de navegadores.

Outra vulnerabilidade inter-sites é a falsificação de requisição inter-sites ou CSRF. No CSRF, o código no site de um atacante faz com que o navegador da vítima tome ações não desejadas pelo usuário em um site alvo (como transferência de dinheiro em um banco). Ela funciona porque, se o site alvo conta apenas com cookies para autenticar requisições, então requisições iniciadas pelo código no site do atacante levarão as mesmas credenciais legítimas de login que as requisições iniciadas pelo usuário. Em geral a solução para CSRF é requerer um valor de autenticação em um campo webform escondido, e não somente nos cookies, para autenticar qualquer requisição que possa ter efeitos duradouros. Verificar o cabeçalho do HTTP Referrer também pode ajudar.

"Sequestro JavaScript" é um tipo de ataque CSRF no qual uma tag <script> no site do atacante explora uma página no lado da vítima que retorna informação privada tal como JSON ou JavaScript. Soluções possíveis incluem requerer um token de autenticação nos parâmetros POST e GET para qualquer resposta que retorne um JSON privado (mesmo que não tenha efeitos colaterais); utilizar POST e nunca GET para requisições que retornem um JSON privado; e modificar a resposta de forma que não possa ser usada via uma tag <script> (através, por exemplo, de um wrapping de um JSON em um comentário JavaScript).

Exemplos de scripts[editar | editar código-fonte]

Scripts Simples[editar | editar código-fonte]

// Mostra um alerta de Confirmar e Cancelar.
if ( confirm( 'Escolha "Ok" ou "Cancelar" para ver a mensagem correspondente.' ) ) {
	alert( 'Você apertou o botão "OK"' ); // mostra um alerta para resposta "OK"
} else {
	alert( 'Você apertou o botão "Cancelar"' ); // mostra um alerta para resposta "Cancelar"
}

Comentários[editar | editar código-fonte]

Javascript permite utilizar comentários de duas formas:

  • Comentários de única linha;
  • Comentários de múltiplas linhas.

Exemplos de comentários:

// Este comentário ocupa uma única linha
 
/* Já este comentário
é mais longo e utiliza
várias linhas */

Funções[editar | editar código-fonte]

Criando uma função simples:

function nomeDaFuncao( /*parâmetros*/ ) {
	/* código que será executado */
 
	return/*Valor retornado*/;
}

Hierarquia do objeto[editar | editar código-fonte]

//Construtor
function Exemplo() {
        this.propriedade = 'Isso é uma propriedade.',
        this.metodo = function() {
              return 'Isso é um metódo';
        }
}
 
var objeto = new Exemplo(); //Instância do construtor "Exemplo"
 
//Alerta os respectivos textos na tela
alert( objeto.propriedade ),
alert( objeto.metodo() );

Números Perfeitos[editar | editar código-fonte]

function perfectNumbers( max ) {
	var i, j, k,
		perfects = [];
 
	for ( i = 0; i++ < max; ) {
		for ( j = k = 0; ++j < i; ) {
			if ( i % j === 0 ) {
				k += j;
			}
 
			if ( ( j + 1 ) === i && k === i ) {
				perfects.push( k );
			}
		}
	}
 
	return perfects.join( ', ' );
}	
 
alert( 'Números perfeitos entre 0 e 5000: ' + perfectNumbers( 5000 ) );

Versão[editar | editar código-fonte]

Versão[5] Data da publicação Equivalente para Netscape
Navigator
Mozilla
Firefox
Internet
Explorer
Opera Safari Google
Chrome
1.0 Março de 1996 2.0 3.0
1.1 Agosto de 1996 3.0
1.2 Junho de 1997 4.0-4.05
1.3 Outubro de 1998 ECMA-262 1st edition / ECMA-262 2nd edition 4.06-4.7x 4.0
1.4 Netscape
Server
1.5 Novembro de 2000 ECMA-262 3rd edition 6.0 1.0 5.5 (JScript 5.5),
6 (JScript 5.6),
7 (JScript 5.7),
8 (JScript 5.8)
6.0,
7.0,
8.0,
9.0,
10.0
3.0,
3.1,
3.2,
4.0
1.0
1.6 Novembro de 2005 1.5 + Array extras + Array e string]s genéricas. + E4X 1.5
1.7 Outubro de 2006 1.6 + Geradores Pythonic + Iteradores + let 2.0
1.8 Junho de 2008 1.7 + Expressões geradoras + Expressões de clausura. 3.0
1.8.1 1.8 + Native JSON support + Minor Updates 3.5
1.8.2 1.8.1 + Minor updates 3.6
1.8.5 1.8.1 + ECMAScript 5 Compliance 4

Bibliografia[editar | editar código-fonte]

  • JavaScript Para World Wide Web, Tradução 3a. Edição, Visual QuickStart Guide, Autor: Tom Negrino/Dori Smith, 1999, Editora Campus, ISBN 85-352-0622-1
  • Teach Yourself JavaScript in a Week, Autor: Arman Danesh, 1996, Editora: Sams Net, ISBN 1-57521-073-8

Referências

  1. New in JavaScript 1.8.5 mozilla.org. Visitado em August 10, 2010.
  2. Flanagan, David; Ferguson, Paula. JavaScript: The Definitive Guide. 4th. ed. [S.l.]: O'Reilly & Associates, 2002. ISBN 0-596-00048-0.
  3. ECMAScript Language Specification.
  4. 10 Programming Languages You Should Learn Right Now - IT Management - News & Reviews - eWeek.com www.eweek.com. Visitado em 14 de abril de 2012.
  5. John Resig. Versions of JavaScript Ejohn.org. Visitado em 2009-05-19.

Ver também[editar | editar código-fonte]

Ligações externas[editar | editar código-fonte]

Wikilivros
O Wikilivros tem um livro chamado Javascript
Wikilivros
O wikilivro Aplicativos em PHP tem uma página sobre Javascript