JavaScript

Origem: Wikipédia, a enciclopédia livre.

JavaScript , frequentemente abreviado como JS, é uma linguagem de
programação interpretada de alto nível, caracterizada também,como JavaScript
dinâmica, fracamente tipada, prototype-based e multi-paradigma.[2]
Juntamente com HTML e CSS, o JavaScript é uma das três principais
tecnologias da World Wide Web. JavaScript permite páginas da Web
interativas e, portanto, é uma parte essencial dos aplicativos da web. A
grande maioria dos sites usa, e todos os principais navegadores têm um
mecanismo JavaScript dedicado para executá-lo.

É atualmente a principal linguagem para programação client-side em

navegadores web. É também bastante utilizada do lado do servidor através
de ambientes como o node.js.

Como uma linguagem multi-paradigma, o JavaScript suporta estilos de Logotipo não-oficial da JSConf EU 2011.
programação orientados a eventos, funcionais e imperativos (incluindo Paradigma Multi-paradigma: com base
orientado a objetos e prototype-based), apresentando recursos como em protótipo funcional
imperativo
fechamentos (closures) e funções de alta ordem comumente indisponíveis scripts
em linguagens populares como Java e C++. Possuí APIs para trabalhar com
Surgido em 4 de dezembro de 1995 (23
texto, matrizes, datas, expressões regulares e o DOM, mas a linguagem em si anos)
não inclui nenhuma E/S, como instalações de rede, armazenamento ou Última ECMAScript 2018 (junho de
gráficos, contando com isso no ambiente host em que está embutido. versão 2018[1])

Criado por Brendan Eich

Foi originalmente implementada como parte dos navegadores web para que
Estilo de Dinâmica, fraca e implícita
scripts pudessem ser executados do lado do cliente e interagissem com o
tipagem:
usuário sem a necessidade deste script passar pelo servidor, controlando o
Dialetos: ISO/IEC C++ 1998
navegador, realizando comunicação assíncrona e alterando o conteúdo do ISO/IEC C++ 2003
documento exibido, porém os mecanismos JavaScript agora estão Influenciada Self, C, Lisp, Scheme, Perl,
incorporados em muitos outros tipos de software host, incluindo servidores por Python, Java
em servidores e bancos de dados da Web e em programas que não são da Influenciou JScript, ActionScript, JScript
Web, como processadores de texto e PDF, e em tempo de execução .NET, Objective-J, TIScript
ambientes que disponibilizam JavaScript para escrever aplicativos móveis e Extensão .js
do arquivo:
de desktop, incluindo widgets de área de trabalho.

Os termos Vanilla JavaScript e Vanilla JS se referem ao

JavaScript não estendido por qualquer estrutura ou biblioteca
adicional. Scripts escritos em Vanilla JS são códigos Índice
JavaScript simples.[3][4] História
Início no Netscape
Embora existam semelhanças entre JavaScript e Java, JavaScript Back-end
incluindo o nome da linguagem, a sintaxe e as respectivas Adoção pela Microsoft
bibliotecas padrão, as duas linguagens são distintas e diferem Padronização
muito no design; JavaScript foi influenciado por linguagens Desenvolvimentos posteriores
de programação comoSelf e Scheme.[5] Marca comercial
Características
É baseada em ECMAScript, padronizada pela Ecma Suporte universal
international nas especificações ECMA-262[6] e ISO/IEC Imperativa e Estruturada
16262. Dinâmica
Tipagem dinâmica
Baseada em objetos
História Avaliação em tempo de execução
Funcional
Funções de primeira classe
Início no Netscape Funções aninhadas
Fechamentos
Em 1993, o Centro Nacional de Aplicações de
Baseada em Protótipos
Supercomputação (NCSA), uma unidade da Universidade de
Protótipos
Illinois em Urbana-Champaign, lançou o NCSA Mosaic, o Funções e métodos
primeiro navegador gráfico popular da Web, que Extensões específicas do fornecedor
desempenhou um papel importante na expansão do
Uso em páginas Web
crescimento da nascente World Wide Web além do nicho Exemplo
NeXTSTEP onde a World Wide Web havia se formado três Compatibilidade
anos antes. Em 1994, uma empresa chamada Mosaic Acessibilidade
Communications foi fundada em Mountain View, na Segurança
Califórnia, e empregou muitos dos autores originais do Vulnerabilidades inter-sites
Confiança duvidosa (cliente)
NCSA Mosaic para criar o Mosaic Netscape. No entanto, não
Confiança duvidosa (servidor)
compartilhou intencionalmente nenhum código com o NCSA
Erros de codificação do navegador e do plug-in
Mosaic. O codinome interno do navegador da empresa era
Erros de implementação da Sandbox
Mozilla, uma junção de "Mosaic and Godzilla" . A primeira Vulnerabilidades de Hardware
versão do navegador da Web, Mosaic Netscape 0.9, foi
Exemplos de scripts
lançada no final de 1994. Em quatro meses, já havia
Scripts Simples
conquistado três quartos do mercado de navegadores e se Comentários
tornado o principal navegador da Web nos anos 90. Para Funções
evitar problemas de propriedade de marca registrada com o Hierarquia do objeto
NCSA, o navegador foi posteriormente renomeado para Números Perfeitos
Netscape Navigator no mesmo ano, e a empresa assumiu o Ferramentas de Desenvolvimento
nome de Netscape Communications. A Netscape Versão
Communications percebeu que a Web precisava se tornar
Bibliografia
mais dinâmica. Marc Andreessen, o fundador da empresa,
Referências
acreditava que o HTML precisava de uma "linguagem de
Ver também
cola" que fosse fácil de usar por Web designers e
Ligações externas
programadores de meio período para montar componentes
como imagens e plugins, onde o código poderia ser escrito
diretamente na Web.[7]

Em 1995, a Netscape Communicationsrecrutou Brendan Eich com o objetivo de incorporar a linguagem de programação Scheme em
seu Netscape Navigator. [8] Antes que ele pudesse começar, a Netscape Communications colaborou com a Sun Microsystems para
incluir na linguagem de programação mais estática do Netscape Navigator Sun, Java, a fim de competir com a Microsoft pela adoção
de tecnologias e plataformas da Web. [9]A Netscape Communicationsdecidiu então que a linguagem de script que eles queriam criar
complementaria o Java e deveria ter uma sintaxe semelhante, o que excluía a adoção de outras linguagens como
Perl, Python, TCL ou
Scheme. Para defender a ideia do JavaScript contra propostas concorrentes, a empresa precisava de um protótipo. Eich escreveu um
em 10 dias, em maio de 1995.

Embora tenha sido desenvolvido sob o nome Mocha, a linguagem foi oficialmente chamada de LiveScript quando foi lançada em
versões beta do Netscape Navigator 2.0 em setembro de 1995, mas foi renomeada para JavaScript [10] quando foi lançada no
Netscape Navigator 2.0 beta 3 Dezembro. [11] A escolha final do nome causou confusão, dando a impressão de que a linguagem era
uma derivação da linguagem de programação Java, e a escolha foi caracterizada como uma manobra de marketing da Netscape para
dar ao JavaScript o status da linguagem da moda, o Java.

Há um equívoco comum de que o JavaScript foi influenciado por uma linguagem de script de página da Web desenvolvida pelo
Nombas chamada Cmm (não confundir com o C posteriormente - criado em 1997). [12] Brendan Eich, no entanto, nunca tinha
ouvido falar de Cmm antes de criar o LiveScript. [13]Os Nombas lançaram seus scripts de página da Web incorporados no Netscape,
embora o script de página da Web não fosse um conceito novo, conforme mostrado pelo navegador da Web ViolaWWW. Nombas
mais tarde passou a oferecer JavaScript em vez de Cmm em seu produto ScriptEase e fazia parte do grupo TC39 que padronizava o
ECMAScript. [14]

JavaScript Back-end
Em dezembro de 1995, logo depois de lançar o JavaScript para navegadores, a Netscape introduziu uma implementação da
linguagem para scripting server-side com o Netscape Enterprise Server. [15]

Desde 1996, o servidor da Web do IIS tem suportado a implementação do JavaScript - JScript do lado do servidor - em páginas ASP
e .NET. [16]

Desde meados da década de 2000, foram introduzidas implementações adicionais de JavaScript no lado do servidor, como o Node.js
em 2009. [17]

Adoção pela Microsoft

As tecnologias de script da Microsoft, incluindo VBScript e JScript, foram lançadas em 1996. JScript, uma implementação de
engenharia reversa do JavaScript da Netscape, fazia parte do Internet Explorer 3. O JScript também estava disponível para scripts do
servidor no Internet Information Server. O Internet Explorer 3 também incluiu o primeiro suporte da Microsoft para CSS e várias
extensões para HTML, mas em cada caso a implementação era visivelmente diferente daquela encontrada no Netscape Navigator na
época. [18] Essas diferenças tornaram difícil para os designers e programadores fazerem um único site funcionar bem em ambos os
navegadores, levando ao uso dos logotipos "melhor visualizado no Netscape" e "melhor visualizado no Internet Explorer" que
caracterizaram esses primeiros anos de guerras de navegadores. O JavaScript começou a adquirir a reputação de ser um dos
obstáculos a uma Web de plataforma cruzada e baseada em padrões. Alguns desenvolvedores assumiram a difícil tarefa de tentar
fazer com que seus sites funcionassem em ambos os principais navegadores, mas muitos não podiam arcar com o tempo [19]. Com o
lançamento do Internet Explorer 4, a Microsoft introduziu o conceito de HTML Dinâmico, mas as diferenças nas implementações de
linguagem e nos diferentes e proprietários Modelos de Objeto de Documento permaneceram e foram obstáculos à adoção
generalizada de JavaScript na Web.

Padronização
Em novembro de 1996, a Netscape submeteu o JavaScript à ECMA International para criar uma especificação padrão, que outros
fornecedores de navegador poderiam implementar com base no trabalho feito na Netscape. Isso levou ao lançamento oficial da
especificação de linguagem ECMAScript publicada na primeira edição da norma ECMA-262 em junho de 1997, sendo o JavaScript a
mais conhecida das implementações.ActionScript e JScript eram outras implementações bem conhecidas doECMAScript.

O lançamento do ECMAScript 2 em junho de 1998 deu continuidade ao ciclo de processo de padrões, conforme algumas
modificações do padrão internacional ISO / IEC 16262. ECMAScript 3 foi lançado em dezembro de 1999 e é a linha de base
moderna para JavaScript. O trabalho original do ECMAScript 4 liderado por W
aldemar Horwat (então na Netscape, agora no Google)
começou em 2000. A Microsoft inicialmente participou e implementou algumas propostas em sua linguagem
JScript .NET.

Com o tempo, ficou claro que a Microsoft não tinha intenção de cooperar ou implementar o JavaScript adequado no Internet
Explorer, mesmo que eles não tivessem uma proposta concorrente e tivessem uma implementação parcial (e divergente neste ponto)
no lado do servidor .NET. Então, em 2003, o trabalho original do ECMAScript 4 foi desativado.
O próximo grande evento foi em 2005, com dois grandes acontecimentos na história do JavaScript. Primeiro, Brendan Eich e Mozilla
juntaram-se novamente à Ecma International como um membro sem fins lucrativos e começaram a trabalhar no ECMAScript para
XML (E4X), o padrão ECMA-357, que veio de ex-funcionários da Microsoft na BEA Systems (originalmente adquirida como
Crossgain) . Isso levou a trabalhar em conjunto com a Macromedia (posteriormente adquirida pela Adobe Systems), que estava
implementando o E4X no ActionScript 3 (o ActionScript 3 era um fork do ECMAScript 4 original).

Assim, juntamente com a Macromedia, o trabalho foi reiniciado no ECMAScript 4 com o objetivo de padronizar o que estava no
ActionScript 3. Para isso, aAdobe Systems lançou a ActionScript Virtual Machine 2, codinome Tamarin, como um projeto de código
aberto. Mas Tamarin e ActionScript 3 eram muito diferentes do JavaScript da web para convergir, como foi realizado pelas partes em
2007 e 2008.

Infelizmente, ainda havia turbulência entre os vários jogadores; Douglas Crockford - então no Yahoo! - juntou forças com a
Microsoft em 2007 para se opor ao ECMAScript 4, o que levou ao esforço do ECMAScript 3.1. O desenvolvimento do ECMAScript
4 nunca foi concluído, mas esse trabalho influenciou versões subsequentes.

Enquanto tudo isso acontecia, as comunidades de código aberto e de desenvolvedores começaram a trabalhar para revolucionar o que
poderia ser feito com JavaScript. Esse esforço da comunidade surgiu em 2005, quando Jesse James Garrett lançou um white paper no
qual cunhou o termo Ajax e descreveu um conjunto de tecnologias, das quais o JavaScript era o backbone, usado para criar
aplicativos da Web onde os dados podem ser carregados em segundo plano, evitando a necessidade de recargas de páginas completas
e levando a aplicativos mais dinâmicos. Isso resultou em um período de renascimento do uso do JavaScript liderado pelas bibliotecas
de código aberto e pelas comunidades que se formaram em torno delas, com bibliotecas como Prototype, jQuery, Dojo Toolkit,
MooTools e outras.

Em julho de 2008, os diferentes partidos de ambos os lados se reuniram em Oslo. Isso levou ao eventual acordo no início de 2009
para renomear o ECMAScript 3.1 para o ECMAScript 5 e impulsionar o idioma usando uma agenda que é conhecida como
Harmonia. O ECMAScript 5 foi finalmente lançado em dezembro de 2009.

Em junho de 2011, o ECMAScript 5.1 foi lançado para se alinhar totalmente com a terceira edição do padrão internacional ISO / IEC
16262. O ECMAScript 2015 foi lançado em junho de 2015. O ECMAScript 2016 foi lançado em junho de 2016. A versão atual é o
ECMAScript 2017, lançado em junho de 2017.

Desenvolvimentos posteriores
JavaScript tornou-se uma das linguagens de programação mais populares da web. No entanto, muitos programadores profissionais
inicialmente denegriram a linguagem devido ao público-alvo percebido de autores da Web e outros "amadores". [20] O advento do
Ajax devolveu o JavaScript aos holofotes e atraiu mais atenção da programação profissional. O resultado foi a proliferação de
estruturas e bibliotecas abrangentes, práticas de programação JavaScript aprimoradas e aumento do uso de JavaScript fora dos
navegadores da Web, conforme observado pela proliferação de plataformas JavaScript dolado do servidor.

Em janeiro de 2009, o projeto CommonJS foi fundado com o objetivo de especificar uma biblioteca padrão comum principalmente
. [21]
para o desenvolvimento de JavaScript fora do navegador

Com o surgimento de aplicativos de página única e sites pesados em JavaScript, ele está sendo cada vez mais usado como um alvo de
compilação para compiladores de origem para origem de linguagens dinâmicas e estáticas.

Marca comercial
"JavaScript" é uma marca comercial da Oracle Corporation nos Estados Unidos. [22] Ele é usado sob licença para tecnologia
inventada e implementada pelaNetscape Communicationse entidades atuais, como aFundação Mozilla. [23]

Características
As seguintes características são comuns a todas as implementações em conformidade com o ECMAScript, a menos que esteja
explicitamente especificado ao contrário.

Suporte universal
Todos os navegadores da Web modernos e populares suportam JavaScript com interpretadores inte
grados.

Imperativa e Estruturada
JavaScript suporta os elementos de sintaxe de programação estruturada da linguagem C como, 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 de uma ni strução.

Dinâmica

Tipagem dinâmica
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

JavaScript é quase inteiramente baseada em objetos[carece de fontes ?]. 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

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

Funcional

Funções de primeira classe

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 ouretornados como qualquer outro objeto.

Funções aninhadas
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
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 daciência da computação, fechamento.

Baseada em Protótipos

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

Funções e métodos
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 keywordthis da função é associada àquele objeto via tal invocação.

Extensões específicas do fornecedor

JavaScript é oficialmente gerenciado pela Mozilla Foundation, e novos recursos de idioma são adicionados periodicamente. No
entanto, apenas alguns mecanismos JavaScript suportam esses novos recursos:

Funções de propriedade getter e setter (suportadas peloWebKit, Gecko, Opera[24], ActionScript e Rhino).[25]
Cláusulas de captura condicional.
Protocolo iterador (adotado doPython).
Compreensões de array e gerador de expressões (adotado doPython)
Escopo de bloco adequado através da palavra-chavelet
Desestruturação de matriz e objeto (forma limitada de pattern matching)
Expressões de função concisas f( unction (args) expr)
ECMAScript para XML (E4X), uma extensão que adiciona suporte XML nativo ao ECMAScript (não suportado no
Firefox desde a versão 21 [26])

Uso em páginas Web

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 (dialog) 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.
Um recurso de interface útil baseada em janela, é um tipo de janela secundária da tela principal, ou janela principal, para solicitar ou
exibir ao usuário determinadas informações complementares, semelhante a “caixa de diálogo” (dialog).

Existem dois tipos de associação entre uma janela de diálogo e a janela principal à qual está associada: "forma modal"
(showModalDialog), quando a abertura da janela de diálogo flexível sobreposta a janela principal sem a necessidade de recarregar a
página principal após o uso do modal, chamada de Lightbox, bloqueando a interação com janela principal a esmaecendo/escurecendo
à fundo até que o diálogo seja encerrado; ou "forma não modal", em que pode haver interação concomitante nas duas janelas
[27][28]
(principal e diálogo) sem bloqueio da principal, O caso mais comum é do diálogo modal.
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 porNorris 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
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
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 umPDA 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
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
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
website 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
Um problema comum relacionado à segurança é a escrita de scripts inter
-sites, ou XSS, uma violação da regra da mesma origem. T
ais
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 porcausa 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. eVrificar 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 umwrapping de um JSON em um comentário JavaScript).

Confiança duvidosa (cliente)

Desenvolvedores de aplicativos cliente-servidor devem reconhecer que clientes não confiáveis podem estar sob o controle de
invasores. O autor do aplicativo não pode presumir que seu código JavaScript será executado como pretendido (ou de todo) porque
qualquer segredo incorporado no código pode ser extraído por um determinado adversário. Algumas implicações são:

Os desenvolvedores de sites não podem ocultar perfeitamente como o JavaScript do site funciona porquecódigo-
o
fonte bruto deve ser enviado ao cliente. O código pode ser ofuscado, mas a ofuscação pode ser projetada por
engenharia reversa.
A validação de formulário JavaScript fornece apenas conveniência para usuários, não segurança. Se um site
verificar que o usuário concordou com seus termos de serviço ou filtra caracteres inválidos em campos que devem
conter apenas números, ele deve fazê-lo no servidor, não apenas no cliente.
Os scripts podem ser desativados seletivamente, portanto, não se pode confiar em JavaScript para impedir
operações, como clicar com o botão direito do mouse em uma imagem para salvá-la.
É uma prática extremamente ruim incorporar informações confidenciais, como senhas, em JavaScript, porque elas
podem ser extraídas por um invasor.

Confiança duvidosa (servidor)

Sistemas de gerenciamento de pacotes, como npm e Bower, são populares entre os desenvolvedores de JavaScript. Tais sistemas
permitem que um desenvolvedor gerencie facilmente as dependências de seus programas sobre as bibliotecas de programas de outros
desenvolvedores. Os desenvolvedores confiam que os mantenedores das bibliotecas os manterão seguros e atualizados, mas nem
sempre é esse o caso. Uma vulnerabilidade surgiu por causa dessa confiança cega. Bibliotecas confiáveis podem ter novas versões
que causam bugs ou vulnerabilidades em todos os programas que dependem das bibliotecas. Inversamente, uma biblioteca pode ficar
sem correção com vulnerabilidades conhecidas na natureza. Em um estudo feito olhando uma amostra de 133 sites, os pesquisadores
descobriram que 37% dos sites incluíam uma biblioteca com pelo menos uma vulnerabilidade conhecida. O atraso mediano entre a
versão da biblioteca mais antiga usada em cada site e a mais nova versão disponível dessa biblioteca é de 1.177 dias na ALEXA, e o
desenvolvimento de algumas bibliotecas ainda em uso ativo cessou anos atrás. Outra possibilidade é que o mantenedor de uma
biblioteca pode remover a biblioteca completamente. Isso ocorreu em março de 2016, quando o Azer Koçulu removeu seu repositório
do npm. Isso fez com que todas as dezenas de milhares de programas e sites, dependendo de suas bibliotecas, quebrassem.

Erros de codificação do navegador e do plug-in

O JavaScript fornece uma interface para uma ampla gama de recursos do navegador, alguns dos quais podem ter falhas, como estouro
de buffer. Essas falhas podem permitir que invasores escrevam scripts que executariam qualquer código que desejassem no sistema
do usuário. Este código não é de forma alguma limitado a outro aplicativo JavaScript. Por exemplo, uma exploração de buffer
overrun pode permitir que um invasor obtenha acesso àAPI do sistema operacional com privilégios de superusuário.

Essas falhas afetaram os principais navegadores, incluindoFirefox[29], Internet Explorer[30] e Safari[31].

Plugins, como players de vídeo, Adobe Flash e a ampla gama de controles ActiveX habilitados por padrão no Microsoft Internet
Explorer, também podem ter falhas exploráveisvia JavaScript (tais falhas foram exploradas no passado).[32][33]

No Windows Vista, a Microsoft tentou conter os riscos de erros, como estouro de buffer, executando o processo do Internet Explorer
com privilégios limitados[34]. O Google Chrome confina seus renderizadores de página à sua própria "sandbox".

Erros de implementação da Sandbox

Os navegadores da Web são capazes de executar o JavaScript fora do sandbox, com os privilégios necessários para, por exemplo,
criar ou excluir arquivos. Naturalmente, esses privilégios não devem ser concedidos ao código da eb.
W

A concessão incorreta de privilégios ao JavaScript da Web desempenhou um papel importante nas vulnerabilidades do Internet
Explorer[35] e do Firefox [36]. No Windows XP Service Pack 2, a Microsoft rebaixou os privilégios do JScript no Internet Explorer.
[37]

O Microsoft Windows permite que os arquivos de origem JavaScript no disco rígido de um computador sejam lançados como
programas de uso geral e sem área de segurança. Isso torna o JavaScript (como o VBScript) um vetor teoricamente viável para um
cavalo de Tróia, embora cavalos de Tróia em JavaScript sejam incomuns na prática.[38]

Vulnerabilidades de Hardware
Em 2015, uma implementação de prova de conceito baseada em JavaScript de um ataque de desajustes foi descrita em um artigo por
pesquisadores de segurança.[39] [40] [41]

Em 2017, foi demonstrado um ataque baseado em JavaScript via navegador que poderia ignorar o ASLR. É chamado de
"ASLR⊕Cache" ou AnC.[42][43]

Exemplos de scripts

Scripts Simples

// 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
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
Criando uma função simples:

function nomeDaFuncao ( /*parâmetros*/ ) {

/* código que será executado */

return /*Valor retornado*/ ;

}

Hierarquia do objeto

//Construtor
//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

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 (k === i) {
perfects .push(k);
}
}

return perfects .join(', ');

}

alert('Números perfeitos de 1 a 5000:' + perfectNumbers (5000));

Ferramentas de Desenvolvimento
Dentro do JavaScript, o acesso a um depurador se torna inestimável ao desenvolver programas grandes e não triviais. Pode haver
diferenças de implementação entre os vários navegadores (especialmente dentro do DOM), portanto, é útil ter acesso a um depurador
eb tem como destino. [44]
para cada um dos navegadores que um aplicativo W

Os depuradores de scripts são integrados em muitos navegadores comuns, como o Internet Explorer, o Firefox, o Safari, o Google
Chrome, o Opera e o Node.js. [45]
Além das Ferramentas nativas para desenvolvedores do Internet Explorer, três outros depuradores estão disponíveis para o Internet
Explorer: O Microsoft Visual Studio possui o maior número de recursos dos três, seguido de perto pelo Microsoft Script Editor (um
componente do Microsoft Office), e finalmente depurador de scripts da Microsoft gratuito. O Microsoft Visual Web Developer
Express gratuito fornece uma versão limitada da funcionalidade de depuração do JavaScript no Microsoftisual
V Studio.

Em comparação com o Internet Explorer, o Firefox tem um conjunto mais abrangente de ferramentas para desenvolvedores, que
inclui também um depurador. Versões antigas do Firefox sem essas ferramentas usavam um addon do Firefox chamado Firebug, ou o
antigo depurador do Venkman. O Web Inspector WebKit inclui um depurador JavaScript, [46] que é usado no Safari. Uma versão
modificada chamada Blink DevTools é usada no Google Chrome. O Node.js possui o Node Inspector, um depurador interativo que se
integra ao Blink DevTools. O Opera inclui um conjunto de ferramentas chamado Dragonfly
.

Além do software de computador nativo, há o ambiente de desenvolvimento integrado (IDEs) JavaScript on-line, que possui recursos
de depuração que são gravados em JavaScript e criados para serem executados na Web. Um exemplo é o programa JSLint,
desenvolvido por Douglas Crockford, que escreveu extensivamente sobre o idioma. O JSLint verifica o código JavaScript para
conformidade com um conjunto de padrões e diretrizes. Muitas bibliotecas para JavaScript, como o three.js, fornecem links para o
código de demonstração que pode ser editado pelos usuários. Os códigos de demonstração também são usados como uma ferramenta
pedagógica por instituições como aKhan Academy para permitir que os alunos experimentem escrever código em um ambiente onde
possam ver a saída de seus programas, sem precisar de configuração além do navegador da web.

Versão
JavaScript foi inicialmente desenvolvido em 1996 para uso no navegador da Web Netscape Navigator. No mesmo ano, a Microsoft
lançou uma implementação para o Internet Explorer. Essa implementação foi chamada de JScript devido a problemas de marca
registrada. Em 1997, a primeira versão padronizada da linguagem foi lançada sob o nome ECMAScript na primeira edição da norma
ECMA-262.

A versão explícita e o opt-in dos recursos de linguagem eram específicos do Mozilla e foram removidos em versões posteriores do
Firefox (pelo menos no Firefox 59). O Firefox 4 foi a última versão que se referiu a uma versão explícita de JavaScript (1.8.5). Com
as novas edições do padrão ECMA-262, os recursos de linguagem JavaScript são agora mencionados com sua definição inicial nas
edições do ECMA-262.

[47][48][49]
A tabela a seguir de versões JavaScript com versão explícita é baseada em informações de várias fontes confiáveis.
 Data da Netscape Mozilla Internet Google
Versão[50] Equivalente para Opera Safari
publicação Navigator Firefox Explorer Chrome
Março de
1.0 2.0 3.0
1996
Agosto de
1.1 3.0
1996
Junho de
1.2 4.0-4.05 3
1997

ECMA-262 1st
Outubro de
1.3 edition / ECMA- 4.06-4.7x 4.0 5
1998
262 2nd edition
Netscape
1.4 6
Server
5.5
(JScript
5.5),
6
(JScript
1.5
Novembro ECMA-262 3rd 6.0 1.0
5.6),
7.0 3.0-5 1.0-10.0.666
de 2000 edition 7
(JScript
5.7),
8
(JScript
5.8)
1.5 + Array extras
Novembro
1.6 + Array e string]s 1.5
de 2005
genéricas. + E4X
1.6 + Geradores
Outubro de
1.7 Pythonic + 2.0 28.0.1500.95
2006
Iteradores + let
1.7 + Expressões
Junho de geradoras +
1.8 3.0 11.50
2008 Expressões de
clausura.
1.8 + Native
1.8.1 JSON support + 3.5
Minor Updates
Junho de 1.8.1 + Minor
1.8.2 3.6
2009 updates
1.8.2 + novas
características
para ECMA-262
Julho de 5th edition
1.8.5 4.0
2010 compilance
(última versão
explícita do
JavaScript)

Bibliografia
Tom Negrino, Dori Smith, JavaScript Para World Wide Web, Tradução 3a. Edição, Visual QuickStart Guide, ano
1999, Editora Campus,ISBN 85-352-0622-1
Arman Danesh, Teach Yourself JavaScript in a Week, ano 1996, Editora: Sams Net,ISBN 1-57521-073-8
David Flanagan, Javascript O Guia Definitivo, 6a. edição, ano 2013, Editora O´Reilly
, ISBN 978-85-65837-19-4
Referências
1. «Standard ECMA-262»(https://www.ecma-international.org/publications/standards/Ecma-262.htm). ecma-
international.org. Consultado em 13 de fevereiro de 2019
2. Flanagan, David; Ferguson, Paula (2002).JavaScript: The Definitive Guide4th ed. [S.l.]: O'Reilly & Associates.
ISBN 0-596-00048-0
3. «javascript - What is VanillaJS?» (https://stackoverflow.com/questions/20435653/what-is-vanillajs). Stack Overflow.
Consultado em 16 de março de 2019
4. «Vanilla JS» (http://vanilla-js.com/). vanilla-js.com. Consultado em 16 de março de 2019
5. «WebCite query result» (https://www.webcitation.org/5rBiWD4P6?url=http://www.ecmascript.org/es4/spec/overview.p
df) (PDF). www.webcitation.org. Consultado em 16 de março de 2019
6. «ECMAScript Language Specification»(https://web.archive.org/web/20150412040502/http://www .ecma-international.
org/publications/files/ECMA-ST/Ecma-262.pdf#)(PDF). Consultado em 10 de fevereiro de 2011. Arquivado do original
(http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-262.pdf)(PDF) em 12 de abril de 2015
7. «TimelineJS Embed» (https://cdn.knightlab.com/libs/timeline3/latest/embed/index.html?source=1Hqom0ylqRgVGmO
y3xFnEjIPtu1jNUT6PDpDGBgULYQU/edit?usp=sharing&font=Default&lang=en&initial_zoom=2&height=650) .
cdn.knightlab.com. Consultado em 17 de março de 2019
8. «Chapter 4. How JavaScript Was Created» (http://speakingjs.com/es5/ch04.html). speakingjs.com. Consultado em
17 de março de 2019
9. Severance, C. (2012-2).«JavaScript: Designing a Language in 10 Days»(https://ieeexplore.ieee.org/document/6155
645/). Computer. 45 (2): 7–8. ISSN 0018-9162 (https://www.worldcat.org/issn/0018-9162). doi:10.1109/MC.2012.57
(https://dx.doi.org/10.1109%2FMC.2012.57)Verifique data em: |data= (ajuda)
10. «Press Release» (https://web.archive.org/web/20070916144913/http://wp.netscape.com/newsref/pr/newsrelease67.h
tml). web.archive.org. 16 de setembro de 2007. Consultado em 17 de março de 2019
11. «TechVision: Innovators of the Net: Brendan Eich and JavaScript»(https://web.archive.org/web/20080208124612/htt
p://wp.netscape.com/comprod/columns/techvision/innovators_be.html) . web.archive.org. 8 de fevereiro de 2008.
Consultado em 17 de março de 2019
12. «The History of Programming Languages - O'Reilly Media»(https://web.archive.org/web/20160712042618/http://arch
ive.oreilly.com/pub/a/oreilly/news/languageposter_0504.html). web.archive.org. 12 de julho de 2016. Consultado em
17 de março de 2019
13. «History of Nombas» (http://www.brent-noorda.com/nombas/history/HistoryOfNombas.html#h.yal3k216ii2r).
www.brent-noorda.com. Consultado em 17 de março de 2019
14. «New JavaScript Engine Module Owner – Brendan Eich»(https://brendaneich.com/2011/06/new-javascript-engine-m
odule-owner/). brendaneich.com. Consultado em 17 de março de 2019
15. «Server-Side JavaScript Guide»(https://docs.oracle.com/cd/E19957-01/816-6411-10/contents.htm) .
docs.oracle.com. Consultado em 17 de março de 2019
16. LLC), Tara Meyer (Aquent. «Introducing JScript .NET»(https://docs.microsoft.com/en-us/previous-versions/windows/i
nternet-explorer/ie-developer/scripting-articles/ms974588(v%3dmsdn.10)) . docs.microsoft.com (em inglês).
Consultado em 17 de março de 2019
17. «Server-Side Javascript: Back With a Vengeance» (https://readwrite.com/2009/12/17/server-side_javascript_back_wi
th_a_vengeance/). ReadWrite (em inglês). 17 de dezembro de 2009. Consultado em 17 de março de 2019
18. «JavaScript: How Did We Get Here? - O'Reilly Media» (https://web.archive.org/web/20160719020828/http://archive.o
reilly.com/pub/a/javascript/2001/04/06/js_history.html). web.archive.org. 19 de julho de 2016. Consultado em 17 de
março de 2019
19. «JavaScript: How Did We Get Here? - O'Reilly Media» (https://web.archive.org/web/20160719020828/http://archive.o
reilly.com/pub/a/javascript/2001/04/06/js_history.html). web.archive.org. 19 de julho de 2016. Consultado em 17 de
março de 2019
20. «JavaScript: The World's Most Misunderstood Programming Language»(http://www.crockford.com/javascript/javascr
ipt.html). www.crockford.com. Consultado em 17 de março de 2019
21. Kowal, Kris (1 de dezembro de 2009).«CommonJS effort sets JavaScript on path for world domination» (https://arste
chnica.com/web/news/2009/12/commonjs-ef fort-sets-javascript-on-path-for-world-domination.ars) . Ars Technica (em
inglês). Consultado em 17 de março de 2019
22. «Trademark Status & Document Retrieval»(http://tsdr.uspto.gov/#caseNumber=75026640&caseType=SERIAL_NO&
searchType=statusSearch). tsdr.uspto.gov. Consultado em 17 de março de 2019
23. «Sun Trademarks» (https://web.archive.org/web/20100528154600/http://www .sun.com/suntrademarks/).
web.archive.org. 28 de maio de 2010. Consultado em 17 de março de 2019
24. «Getters and setters with JavaScript – code samples and demos - Robert's talk» (https://robertnyman.com/2009/05/2
8/getters-and-setters-with-javascript-code-samples-and-demos/) . robertnyman.com. Consultado em 17 de março de
2019
25. «John Resig - JavaScript Getters and Setters»(https://johnresig.com/blog/javascript-getters-and-setters/)(em
inglês). Consultado em 17 de março de 2019
26. «E4X» (https://developer.mozilla.org/en-US/docs/Archive/Web/E4X). MDN Web Docs (em inglês). Consultado em 17
de março de 2019
27. Márcio d'Ávila (8 de dezembro de 2006).«Janela modal na web»(http://www.mhavila.com.br/topicos/web/window_m
odal.html). mhavila. Consultado em 2 de fevereiro de 2017
28. Alexandre Magno. (8 de dezembro de 2006).«Javascript para o Bootstrap»(http://globocom.github.io/bootstrap/java
script.html#modals). Github. Consultado em 2 de fevereiro de 2017
29. «Buffer overflow in crypto.signText()» (https://www.mozilla.org/en-US/security/advisories/mfsa2006-38/). Mozilla (em
inglês). Consultado em 17 de março de 2019
30. «Buffer-overflow bug in IE - Tech News - CNET.com» (https://web.archive.org/web/20021225190522/http://news.co
m.com/2100-1001-214620.html). web.archive.org. 25 de dezembro de 2002. Consultado em 17 de março de 2019
31. «Apple Safari JavaScript Buffer Overflow Lets Remote Users Execute Arbitrary Code and HTTP Redirect Bug Lets
Remote Users Access Files - SecurityTracker» (https://securitytracker.com/id/1015713). securitytracker.com.
Consultado em 17 de março de 2019
32. «Microsoft WebViewFolderIcon ActiveX Control Buffer Overflow Vulnerability» (https://www.securityfocus.com/bid/19
030/info). www.securityfocus.com. Consultado em 17 de março de 2019
33. «WebCite query result» (https://www.webcitation.org/618GwPiuw?url=http://www.fusionauthority.com/security/3234-
macromedia-flash-activex-buffer-overflow.htm). www.webcitation.org. Consultado em 17 de março de 2019
34. «Protected Mode in Vista IE7 – IEBlog» (https://blogs.msdn.microsoft.com/ie/2006/02/09/protected-mode-in-vista-ie
7/). blogs.msdn.microsoft.com. Consultado em 17 de março de 2019
35. www.kb.cert.org https://www.kb.cert.org/vuls/id/713878/(https://www.kb.cert.org/vuls/id/713878/). Consultado em 17
de março de 2019 Em falta ou vazio |título= (ajuda)
36. «Privilege escalation via DOM property overrides»(https://www.mozilla.org/en-US/security/advisories/mfsa2005-41/).
Mozilla (em inglês). Consultado em 17 de março de 2019
37. LLC), Tara Meyer (Aquent. «Part 5: Enhanced Browsing Security»(https://docs.microsoft.com/en-us/previous-version
s/windows/it-pro/windows-xp/bb457150(v%3dtechnet.10)) . docs.microsoft.com (em inglês). Consultado em 17 de
março de 2019
38. «JS.Seeker.K | Symantec» (https://www.symantec.com/security-center/writeup/2003-100111-0931-99).
www.symantec.com. Consultado em 17 de março de 2019
39. «Computer Science» (https://arxiv.org/archive/cs.CR). arxiv.org. Consultado em 17 de março de 2019
40. Jean-Pharuns, Alix (30 de julho de 2015).«Rowhammer.js Is the Most Ingenious HackI've Ever Seen» (https://moth
erboard.vice.com/en_us/article/9akpwz/rowhammerjs-is-the-most-ingenious-hack-ive-ever-seen) . Motherboard (em
inglês). Consultado em 17 de março de 2019
41. Goodin, Dan (4 de agosto de 2015).«DRAM "Bitflipping" exploit for attacking PCs: Just add JavaScript»(https://arste
chnica.com/information-technology/2015/08/dram-bitflipping-exploit-for-attacking-pcs-just-add-javascript/) . Ars
Technica (em inglês). Consultado em 17 de março de 2019
42. «AnC» (https://www.vusec.net/projects/anc/). VUSec (em inglês). Consultado em 17 de março de 2019
43. Goodin, Dan (15 de fevereiro de 2017).«New ASLR-busting JavaScript is about to make drive-by exploits much
nastier» (https://arstechnica.com/information-technology/2017/02/new-aslr-busting-javascript-is-about-to-make-drive-
by-exploits-much-nastier/). Ars Technica (em inglês). Consultado em 17 de março de 2019
44. Steen, Chris Mills, Hallvord R. M.«Advanced Debugging With JavaScript»(http://alistapart.com/article/advanced-deb
ugging-with-javascript). alistapart.com (em inglês). Consultado em 17 de março de 2019
45. programmer, Scott Orgera Scott Orgera hasbeen a tech journalist since 2007 He has 25+ years' experience as a;
leader, Q. A.; certifications, several Microsoft. «Activate the Debugging Console or Web Inspector in Safari for
iPhone» (https://www.lifewire.com/activate-the-debug-console-in-safari-445798). Lifewire (em inglês). Consultado em
17 de março de 2019
46. «Introducing Drosera» (https://webkit.org/blog/61/introducing-drosera/) . WebKit. 28 de junho de 2006. Consultado
em 17 de março de 2019
47. «New in JavaScript» (https://developer.mozilla.org/en-US/docs/Web/JavaScript/New_in_JavaScript). MDN Web Docs
(em inglês). Consultado em 17 de março de 2019
48. «John Resig - Versions of JavaScript» (https://johnresig.com/blog/versions-of-javascript/)(em inglês). Consultado em
17 de março de 2019
49. «What Version of Javascript» (https://web.archive.org/web/20170109084234/http://javascript.about.com/library/bljver .
htm). web.archive.org. 9 de janeiro de 2017. Consultado em 17 de março de 2019
50. John Resig. «Versions of JavaScript» (http://ejohn.org/blog/versions-of-javascript). Ejohn.org. Consultado em 19 de
maio de 2009

Ver também
ECMAScript
JScript
NoScript
 Lista de linguagens de programação

Ligações externas
Página do MDN (em inglês)
Standard ECMA-262 (em inglês)
Introdução ao JavaScript(em inglês)

Obtida de "https://pt.wikipedia.org/w/index.php?title=JavaScript&oldid=54753367
"

Esta página foi editada pela última vez às 19h17min de 8 de abril de 2019.

Este texto é disponibilizado nos termos da licençaAtribuição-CompartilhaIgual 3.0 Não Adaptada (CC BY
-SA 3.0) da
Creative Commons; pode estar sujeito a condições adicionais. Para mais detalhes, consulte ascondições de utilização.