Manual JavaScript

A Verso Nova de uma Velha Histria A Verso Nova de uma Velha Histria
Este manual foi escrito lanado pela ltima vez no incio 2004 e tenta explicar JavaScript
enquanto linguagem de programao.
Fez parte da Enciclopdia Omega e, com o fato de a Enciclopdia Omega estar parada e,
acrescida a isso a instabilidade na ferramenta ento utilizada pela EO, resolvi desvincular
este manual da EO e lan-lo em separado. Aproveito para acrescentar um padro de
codificao que eu havia criado h tempos tambm, e que at hoje se encontrava esquecido.
A partir desta verso, este manual se encontrar em meu site pessoal, podendo evoluir para
tratar de AJAX, XUL e outros assuntos, a depender da sua aceitao e do meu tempo
disponvel.
Espero que apreciem.
-- Crlisson Galdino
"No sou nem ateniense, nem grego, mas sim um
cidado do mundo." Scrates
Manual JavaScript
Verso atual: 2006.04
Data de Publicao: 21 de abril de 2006
Classificao: Manual de Programao
Autor: Crlisson Galdino
Contato: bardo@swissinfo.org
#2
Manual JavaScript
ndice
ndice
Introduo......................................................................................................................................................5
Histria............................................................................................................................................................................5
Altos e Baixos.................................................................................................................................................................5
O Que Ela ....................................................................................................................................................................5
Sobre Este Manual..........................................................................................................................................................5
Conhecimento Prvio......................................................................................................................................................6
Software Necessrio........................................................................................................................................................6
Programando Estruturadamente.....................................................................................................................7
Tipos de Variveis...........................................................................................................................................................7
Operadores......................................................................................................................................................................7
Listas...............................................................................................................................................................................8
Estrutura Bsica...............................................................................................................................................................8
Estruturas de Repetio...................................................................................................................................................8
while.....................................................................................................................................................................................8
do-while................................................................................................................................................................................9
for..........................................................................................................................................................................................9
Estruturas de Deciso......................................................................................................................................................9
if............................................................................................................................................................................................9
switch..................................................................................................................................................................................10
if condensado......................................................................................................................................................................10
Modularizao...............................................................................................................................................................10
Sobre Parmetros...........................................................................................................................................................11
Programando com Orientao a Objetos......................................................................................................12
Antes de Comear.........................................................................................................................................................12
Orientao a Objetos.....................................................................................................................................................12
Composio........................................................................................................................................................................12
Classes................................................................................................................................................................................12
Herana...............................................................................................................................................................................12
Usando Objetos.............................................................................................................................................................12
Estrutura with................................................................................................................................................................13
A Criao de Classes.....................................................................................................................................................13
Classe Data....................................................................................................................................................................13
Composio...................................................................................................................................................................14
Herana.........................................................................................................................................................................14
Iara JavaScript Code Standards....................................................................................................................15
Indentao.....................................................................................................................................................................15
Expresses.....................................................................................................................................................................15
#3
Manual JavaScript
Comentrios..................................................................................................................................................................15
Nomenclatura................................................................................................................................................................16
Variveis........................................................................................................................................................................16
Classes...........................................................................................................................................................................16
#4
Manual JavaScript
Introduo
Introduo
Histria
No ano de 1994, a empresa Netscape, fabricante do programa
de mesmo nome para navegao na Internet, sentiu necessidade de
implementar uma tecnologia de processamento modo cliente. Para
programas simples que fossem executados no computador do usurio
mesmo, sem que fosse preciso enviar informaes para o computador
servidor.
Eram coisas como a validao de um formulrio, por exemplo.
Na mesma poca era adicionado suporte a applets Java (aplicativos
pequenos e que so executados embutidos, no nosso caso em pginas
HTML. Possuem uma rea formalmente delimitada para eles) ao
navegador, mas... Em se tratando de programas complexos ou visuais
era timo, s que o tempo necessrio para copiar e executar o
programa em bytecode simplesmente no compensava certas
pequenas tarefas. Alm de que os applets no esto to ligados assim
aos elementos da pgina HTML afinal de contas. Foi a que nasceu a
soluo.
A Netscape criou LiveScript, uma linguagem embutvel na
pgina HTML, interpretada pelo navegador, tomando bem menos
tempo que Java e estando mais unida aos elementos da pgina.
Assim como aconteceu com Java - que se chamava Oak -, a
linguagem da Netscape terminou mudando de nome com a
paritipao da Sun Microsystems no projeto e assim a verso Beta 2
do Netscape, em 1995, j trazia estampada para a linguagem o novo
nome: JavaScript. No que tenha tanta ligao com Java, mas por
pura questo de marketing. E assim nascia uma linguagem que se
tornaria um padro e sinnimo de processamento cliente em pginas
web.
A linguagem JavaScript to poderosa e simples para
manipular objetos (foi sua motivao principal manipular os
elementos de uma pgina HTML) que se criou, a partir dela, um
padro: o ECMAScript. Vrios outros setores utilizam uma
linguagem nesse padro, entre eles o VRML. O aplicativo
proprietrio Flash utilizava um, que depois evolui para o que eles
hoje chamam de ActionScript, mas que mantm ainda certa
compatibilidade.
Altos e Baixos
Criada inicialmente para pequenos processamentos, JavaScript
foi muito utilizada para acrescentar recursos simples pgina, s
vezes banais. Esse uso o que a faz ser lembrada como uma extenso
do HTML e no como uma linguagem de fato.
Entretanto, JavaScript uma linguagem de programao. Uma
linguagem completa e poderosa, com as limitaes que o meio
exigia.
uma linguagem que foi criada para:
alterar valores de elementos HTML;
criar elementos HTML;
validar formulrio e controlar interao entre molduras.
Atravs de JavaScript voc poder ter acesso a qualquer
elemento da pgina.
JavaScript rene o que h de melhor em dois grupos
consagrados de linguagem: listas associativas, tipagem dinmica e
expresses regulares de Perl (linguagem para criao de relatrios); a
sintaxe bsica, a biblioteca matemtica e a de data de C/C++/Java (C
uma linguagem de grande peso no mundo Unix, e at nos outros;
C++ uma verso de C utilizando a tcnica de Orientao a Objetos;
Java a linguagem preferida do meio acadmico, mas que pouco a
pouco atinge outras reas). Se estou falando grego, desculpe-me:
essas coisas sero tratadas adiante.
Esta linguagem pode ser utilizada de uma forma bem bsica ao
simplesmente associarmos aes simples a eventos de elementos da
pgina (por exemplo, fazendo uma janela abrir ao clicarmos um
boto de formulrio HTML); de forma estruturada; ou, o que mais
interessante, orientada a objetos, de uma forma que lembra bastante a
linguagem Perl.
Como tudo que rosa tem que ter espinho, JavaScript tem suas
limitaes: s roda em um navegador web, depende do navegador do
internauta e no lida com arquivos de maneira alguma. Mas como
isso tudo era esperado de uma linguagem assim, podemos dizer que
JavaScript o que h de melhor nessa rea.
Mas no o fim para quem quer usar tantos recursos quantos
seja necessrio para a criao de uma aplicao local. O projeto
Mozilla tambm apresenta um framework para a criao de
programas grficos normais (como usando Java/AWT ou GTK+),
multiplataforma, usando-se JavaScript e XML, podendo inclusive ser
executados por rede.
O Que Ela
Atualmente, como j foi dito, uma linguagem de
programao que possui muitas qualidades e limitaes do gnero ao
qual pertence. Entretanto, JavaScript vinha sendo bastante
subestimada pela comunidade de desenvolvedores em geral (pelo
menos antes da do AJAX e da Web 2.0). Geralmente ser utilizada
para coisas banais e amadoras.
uma linguagem que lembra bastante C++ e Java.
Principalmente Java. Mas traz apenas semelhanas. Ela possui
tipagem dinmica, o que significa que voc no precisa dizer qual o
tipo da varivel, podendo armazenar nela ora inteiro, ora string. Ela
tem o tipo booleano tambm. Na verdade, quando se trata de
variveis, elas nem mesmo precisam ser criadas, mas cri-las
aconselhvel para que o cdigo se torne mais compreensvel.
Por sua forte ligao aos elementos HTML, ela muito
utilizvel para efeitos visuais curiosos, pena que a "Guerra dos
Navegadores" terminou por complicar a vida do programador
DHTML (JavaScript manipulando diretamente partes de um
documento HTML como objetos). Mas quem tem pacincia e investe
nisso corre o risco de se surpreender com o resultado.
Apesar da sintaxe parecer com Java, por incrvel que parea ela
me lembra bem mais linguagens como Perl, mesmo que no tenha
"$" antes de varivel e coisas do gnero... Isso talvez seja pela
tipagem dinmica, pela lista - inclusive a associativa - ou talvez seja
pelo modo como feita a criao de classes.
No final, JavaScript parece um Perl com sintaxe de Java, com a
difcil peculiaridade de no poder armazenar dados.
Sobre Este Manual
Como os volumes de Omega destinados a cobrir linguagens de
programao, este livro tenta levar conhecimento bastante amplo da
linguagem em si, mas mostrando alguns dos recursos disponveis.
Tenta tambm, como parte de Omega, traar uma imagem - ainda que
Introduo #5
Manual JavaScript
embaada - da linguagem na comunidade, seu papel e uso perante os
desenvolvedores, alm de tentar defin-la como realmente .
Aqui voc aprender no apenas a programar em JavaScript
como tambm a utilizar suas caractersticas para Orientao a
Objetos. Isso sem contar com o uso de recursos estruturados bastante
teis herdados, em sua maioria, de Perl.
No ser tratado aqui nada referente a HTML ou DHTML, o
nosso foco ser JavaScript. Caso o leitor se interesse por qualquer
dessas duas tecnologias (a primeira, inclusive, de primordial
importncia para o prprio JavaScript), sugiro que procure leitura
especializada. Omega.javaScript tende a servir como um
aprimoramento para quem j conhece um pouco de HTML e
programao, e deseje conhecer melhor esta linguagem mal-
compreendida.
Conhecimento Prvio
Este livro assume que o leitor conhece j programao e, neste
campo, tenha algum domnio sobre expresses lgicas e aritmticas,
estruturas de repetio e de deciso, e programao Orientada a
Objetos. Tambm assume-se que o leitor j domina, muito ou pouco,
a linguagem de hipertexto HTML. De qualquer forma, aqui vai um
resumo de cada um desses elementos, para recordar.
Programao estruturada utiliza uma mxima: qualquer
programa pode ser feito a partir de estruturas de deciso, de repetio
e dos conceitos: mdulos - ou funes - e seqncias. A grande
vantagem, qual todos os programadores at hoje agradecem, a
abolio dos "GOTOs", que eram os principais responsveis por
cdigos incompreensveis. Na programao estruturada, fala-se em
funes e variveis: o programador estruturado tem o poder do
verbo.
Expresses lgicas so seqncias de variveis do tipo valor-
verdade e expresses comparativas que retornam valores-verdade.
Valores-verdade a que me refiro so os conhecidos booleanos, que
podem assumir valor "verdadeiro" ou "falso" (true ou false).
Variveis e expresses comparativas que retornavam este tipo so
ligadas em cadeias por operadores lgicos e parnteses. Os
operadores lgicos so: "E", "OU", "OU EXCLUSIVO", "E
EXCLUSIVO" e "NO". Para um bom uso de expresses lgicas
recomendado o estudo de "lgica aplicada computao" ou "lgica
clssica proposicional".
Expresses aritmticas retornam nmeros. So expresses
matemticas e envolvem variveis de nmeros, nmeros constantes e
chamadas de funes que retornam nmeros, separados por
parnteses e operadores matemticos. So operadores matemticos:
"MAIS", "MENOS", "VEZES", "DIVIDIDO", "DIVIDIDO-S-
RESTO", "DIVIDIDO-SEM-FRACIONAR" e "ELEVADO--
POTNCIA". Quanto a expresses aritmticas, so mais fceis de
serem compreendidas pelo fato de serem um pouco estudadas nos
ensinos fundamental e mdio.
Estruturas de repetio so blocos de cdigo que so repetidos
um determinado nmero de vezes ou at que certa condio seja
atingida. A condio o resultado de uma expresso lgica.
Estruturas de deciso so blocos de cdigo que so executados
apenas se dada condio for verdadeira. Algumas vezes,
acompanhados de blocos que so executados somente se a mesma
condio avaliada for falsa. A condio tambm o resultado da
avaliao de uma expresso lgica.
Programao Orientada a Objetos revolucionou a programao
ao criar elementos complexos, que renem comportamento (mtodos,
parecidos com as funes da Programao Estruturada), estado
(atributos, parecidos com as variveis da P.E.) e identidade (como as
variveis, algo que os distingue uns dos outros). H o conceito de
classes, que so "moldes" para esses elementos complexos, chamados
de objetos. Entre classes h associaes. Entre estas, algumas so
especialmente interessantes, como a herana - que quando uma
classe , a princpio, igual a outra: claro que apenas a princpio, a
acrescentamos ou retiramos algo. Programao Orientada a Objetos
algo realmente interessante e til. Se o leitor no conhece esta forma
de programar, talvez sinta dificuldade na seo que trata a Orientao
a Objetos em JavaScript. Recomendo fortemente que busque, caso
seja este seu caso, informaes sobre este que um dos conceitos
mais utilizados na programao atual - apesar de no ser coisa to
nova assim... Voc pode recorrer a livros, mas h de encontrar
alguma coisa se fizer pesquisas na Internet sobre o assunto.
HTML uma linguagem de hipertexto, utilizada para a criao
de pginas na Internet. Ela serve, na verdade, para o que poderamos
chamar de "diagramao da web". Atualmente est comeando a ser
substituda por XML, sendo XHTML a linguagem transitria.
Acontece que isto est acontecendo ainda em nvel muito superficial
e certamente levar um tempo at que seja mesmo substituda. Como
uma linguagem de marcao de hipertexto, HTML oferece TAGs,
que utilizamos para determinar locais onde objetos aparecero e
inserir os objetos. Quando se fala de "aplicao para web", isso no
descarta HTML, muito pelo contrrio: todo o processamento de um
aplicativo que roda em um servidor precisa mostrar alguma coisa ao
usurio e para isso no h como evitar o uso de uma linguagem de
marcao, geralmente HTML mesmo.
No fundamentalmente necessrio que voc conhea
Orientao a Objetos, HTML ou expresses lgicas, mas tal
desconhecimento poder acarretar na dificuldade de compreender
alguns trechos deste manual.
Software Necessrio
Para trabalhar com JavaScript voc vai precisar de um
computador com um Sistema Operacional, um software navegador
com suporte a JavaScript e um editor de textos ASCII qualquer.
Texto puro mesmo. Claro que editores especiais para programao
que ofeream destaque sinttico da linguagem JavaScript e outra
facilidades so bem mais interessantes e confortveis de se usar.
H infinitas combinaes possveis para se trabalhar JavaScript
mas, por ser este um volume de Omega, uma enciclopdia do
software livre, mediante as vantagens j faladas no volume principal
desta categoria de software, recomendamos a seguinte combinao:
GNU/Linux (o sistema operacional), Mozilla (o navegador) e Kate (o
editor). Claro que h muitas outras opes, como o FreeBSD como
Sistema Operacional, o Galeon como navegador e o emacs como
editor, portanto sinta-se vontade para escolher sua combinao: o
S.O. certamente ser um que voc j tenha instalado e e venha
usando; o navegador voc provavelmente j tem tambm; o editor
pode ser provisoriamente o editor de texto padro/preferido-seu em
seu sistema, se voc no tiver ainda um editor com destaque
sinttico.
Mas, enfim, por incrvel que parea, s disso mesmo que
voc vai precisar.
Introduo #6
Manual JavaScript
Programando Estruturadamente
Programando Estruturadamente
Neste captulo trataremos todos os detalhes da linguagem JavaScript para programao estruturada. Pelo menos este
o objetivo, mas certamente no ser atingido assim de incio. aso o leitor no entenda muito de programao
estruturada, sugiro !ue bus!ue leitura sobre "algoritmo", pois #undamental.
Tipos de Variveis
Variveis servem para armazenar "coisas" que sero utilizadas
no decorrer de um programa ou parte dele. Eu poderia dizer que
armazenam valores ou dados, mas acredito que "coisas" uma
definio melhor: pois podem ser nmeros, cadeias de caracteres,
objetos e at, estranhamente, funes!
Em JavaScript lidamos com alguns tipos bsicos. So eles:
nmero, valor-verdade e cadeia de caracteres. Para facilitar a
abordagem, vamos esquecer que variveis podem guardar referncia a
funes ou se referir a objetos e consideremos a existncia de apenas
esses trs tipos de dados bsicos - so, afinal de contas, os nicos
citados que podem ser classificados como "tipos bsicos".
Variveis do tipo nmero guardaro nmeros que podero ser
positivos, nulos ou negativos, inteiros ou fracionrios (pois na
verdade os computadores no guardam nmeros reais. Tanto que
prefervel tratar o que os computadores guardam como pontos
flutuantes ao invs de se usar o termo "reais"). Com eles pode-se
fazer operaes matemticas em geral. Na verdade, provvel que
JavaScript separe inteiros de flutuantes, mas isso totalmente
transparente ao usurio. Outra coisa interessante sobre nmeros e
JavaScript que a linguagem tambm representa nmeros
absurdamente grandes, chamando-os de Infinity positivo e negativo.
Assim, no ocorrer necessariamente um erro ao se tentar dividir por
zero, por exemplo.
Variveis do tipo valor-verdade armazenam apenas verdadeiro
ou falso, em JavaScript, como na maioria das linguagens,
representados, respectivamente, por true e false. Algumas linguagens
no trazem este tipo, exigindo o uso de nmeros: 1 representando
verdadeiro e 0 representando falso. Felizmente JavaScript implementa
valores-verdades, conhecidos como booleanos.
Variveis do tipo cadeia de caracteres armazenam cadeias - ou
seqncias - de caracteres. Um caractere pode ser uma letra, um
nmero, uma exclamao, um arroba... Qualquer smbolo grfico que
possa fazer parte de um arquivo de texto puro. Eles so representados
com uma regra prpria, que a mesma de muitas linguagens
existentes: devem ser colocados entre aspas (") ou apstofros ('). Se
voc utilizar aspas, os apstofros que aparecerem no cdigo sero
tratados como caracteres, e vice-versa. Para imprimir alguns
caracteres especiais, voc pode utilizar a contra-barra (\). Ela indica
que o que vem depois representa um caractere especial. Assim, um \n
representa uma quebra de linha (do texto, no do HTML), o \"
representa aspas mesmo e \\ se refere ao caractere (\).
Voc no precisar se preocupar tanto com tipos em JavaScript.
Isso porque, como j foi dito, ela oferece tipagem dinmica, o que
quer dizer que uma varivel tratada como varivel, no como
varivel inteira ou varivel booleana. Assim, uma varivel pode
assumir qualquer tipo no decorrer do programa.
Variveis no precisam ser declaradas, mas sua declarao
muito importante para mantermos programas bem-organizados. Para
declarar uma varivel, utilize a palavra-chave var antes do nome.
Cada varivel deve ser declarada apenas uma vez (ou nenhuma, se
no quiser faz-lo).
Operadores
H cinco grupos de operadores, basicamente falando: lgicos,
comparativos, aritmticos, de strings e de atribuio.
Operadores lgicos retornam um valor-verdade a partir de um
ou mais valores-verdades. H o E (&&), que retorna verdadeiro se, e
somente se os dois valores passados forem verdadeiros. Seu uso
como em "A &&B". O OU (||) retorna verdadeiro se pelo menos um
dos valores passados for verdadeiro. Seu uso, similar ao do E, como
em "A || B". H, para concluir, a negao (!), que retorna verdadeiro
se o valor recebido for falso. Seu uso como em "!A". Pode-se
agrupar esses operadores e variveis em expresses complexas e,
como em expreses aritmticas, utilizar-se parnteses para controlar a
ordem em que a expresso ser avaliada. Exemplo de expresso
lgica (A, B, C e D so variveis booleanas): ( A && (B || ( !(C || D) )
) ). Isso ser verdadeiro para as seguintes combinaes de A, B, C e
D: VVFF, VVFV, VVVF, VVVV e VFFF. Tente visualizar isso.
Operadores comparativos recebem dois valores e os comparam,
retornando um valor-verdade. Existem para serem utilizados em
expresses lgicas. A igualdade (==) compara duas variveis de
qualquer tipo bsico e retorna verdadeiro se: so numericamente
iguais (no caso de nmeros) ou so literalmente iguais (no caso de
strings). Seu uso como em "A==B", "A==2.3" ou "A=='Console'".
A desigualdade (!=) funciona como "!(A==B)" funcionaria para
"A==B". Ela nega a igualdade e usada como em "A!=B", "A!=7.8"
ou "A!='Terminal'". Os outros quatro operadores so exclusivamente
numricos: so o maior que (>), o menor que (<), o maior que ou
igual a (>=) e o menor que ou igual a (<=). Seu uso bastante
intuitivo: "A>B" retornaria verdadeiro para A=2 e B=-3, por
exemplo. O (A<=B) equivale expresso: ( (A < B) || (A == B) ).
Operadores aritmticos recebem nmeros e retornam nmeros.
So os j conhecidos: soma (+) - de uso como em "A+B" ; subtrao
() - de uso como em "A-B" -; multiplicao (*) - de uso como em
"A*B" -; diviso (/) - de uso como em "A/B" - e mais outros. H a
diviso em modo anel - ou o resto de uma diviso inteira, se preferir
nesses termos - (%), que usado como em "A%B" e para "16%5"
retornar "1", por exemplo. A potncia (
) como em "A
B" e para "5^2"
resultar "25".
O operador de string que existe a concatenao, representado
como "+". Assim, "E-mail " + 'enviado!' resultar na string "E-mail
enviado!".
Os operadores de atribuio servem basicamente para
atribuirmos valores a variveis. O principal o de atribuio simples
(=), que utilizado na forma "A=B", B podendo ser uma varivel,
uma expresso lgica, aritmtica, de string... Os outros operadores -
exceto os lgicos - podem ser associados ao igual, criando-se outros
operadores de atribuio. A saber: (+=) como incrementao para
valores numricos, "A+=B" incrementa "A" com "B"; (+=) como
concatenao para strings, "A+=B" adiciona o valor de "B" string
"A"; (-=) decrementao para valores numricos, decrementa "B" de
"A" e se "hora" tem valor "8", "hora-=5" dar "hora" valor "3"; (
*=@ ), (/=) e ( @%= ) funcionam da mesma forma.
Entre os operadores de atribuio, h os operadores especiais
de incremento (++) e decremento (--). O operador de incremento
aumenta o valor da varivel em 1. J o de decremento faz exatamente
Programando Estruturadamente #7
Manual JavaScript
o contrrio, decrementando o valor da varivel de 1. Esses operadores
podem ser utilizados aplicados a uma varivel como um comando ou
dentro de expresses aritmticas. Neste caso, haver diferena entre
coloc-los antes ou depois da varivel. Quando antes, primeiro feita
a alterao e depois a expresso avaliada. Quando depois, a varivel
s incrementada ou decrementada depois de a anlise expresso
ter sido concluda. Isso quer dizer, para ser mais preciso, que:
x = 2 * y++
resultar, para x, em um valor diferente de
x = 2 * ++y
Vamos supor que, antes de tudo, y tenha o valor "5". No
primeiro caso, terminaremos com x=10 e y=6. No segundo, x ser 12
e y, 6.
Listas
Um tipo mais complexo de dado, mesmo sendo j orientado a
objetos (vamos abstrair isso, por enquanto) a lista ou vetor. Uma
lista uma estrutura que permite o armazenamento de vrias variveis
com um mesmo nome, acessveis por um ndice. Este ndice pode ser
numrico comeando por zero (listas indexadas) ou uma string
qualquer (listas associativas ou hashs). Ao contrrio das variveis
bsicas, as listas precisam ser criadas como listas mas, como uma
linguagem de script, voc no precisa dizer de que tipo a lista,
podendo misturar string com booleanos e nmeros. A criao de uma
lista feita atravs do comando:
var x = new Array()
Este comando criar uma varivel "x" e determina que esta
contenha uma lista.
Cada elemento da lista pode ser acessado por [i], sendo i o
ndice do correspondente ao elemento na lista ou a chave para acess-
lo, caso seja associativo. A lista criada vazia. Podemos adicionar um
elemento indexado atravs do comando:
x.push("Ol, este pr!"e!r
ele"ent#")
Assim, quando requisitarmos x$%&, ser retornada a string
"Ol, este o primeiro elemento!". "x.length" retornar o tamanho da
lista indexada.
De forma anloga, se queremos retirar um elemento da lista
moda de pilha (ltimo a entrar o primeiro a sair, podemos utilizar o
comando seguinte:
y = x.pp()
Este cdigo retirar o ltimo elemento adicionado lista e
colocar em y. O elemento deixar de constar na lista.
Se quisermos trabalhar com lista associativa, podemos incluir o
elemento da seguinte forma:
x$"'a(!"& = ")e*r!nh +e u"a perna s,,
persna*e" + -l(lre .ras!le!r."
Assim, atravs de x["Saci"] poderemos associar o texto
colocado. Isso muito til, pois tem base no conceito de listas de
duplas strings, associando-as por chave e valor. Como o leitor j deve
ter percebido por esse exemplo, esta estrutura pode ser utilizada para
um dicionrio de verbetes (no que isso seja to til assim em
JavaScript), para associar apelidos a nomes, apelidos a e-mails e
muitas outras coisas. Mais frente voc ver como fazer acessar de
forma mais eficiente todos os elementos de uma lista.
Uma observao final : tenha cuidado ao usar o push e o pop:
alguns softwares que pretendem se passar por "navegadores com
suporte a JavaScript" no suportam ainda esse recurso to simples.
Para substitu-los, h a seguinte alternativa:
x$ x.len*th & = valr/ y = x$ x.len*th0
1 &
que equivalem a:
x.push(valr)/ y = x.pp()
com a diferena de que o pop exclui o ltimo elemento e a
linha equivalente no o faz. At onde vi, felizmente, a falta de suporte
aos mtodos push e pop ocorre em navegadores antiges.
Estrutura Bsica
A primeira coisa que se deve tem em mente sobre programao
estruturada que os comandos devero ser executados
seqncialmente. A segunda coisa que se deve saber o que so
comandos e como criar essas seqncias.
Um comando uma atribuio, uma chamada de valor ou um
bloco de cdigo (estrutura de repetio ou deciso). Um bloco de
cdigo pode conter listas de comandos, inclusive com outros blocos
de cdigo, em hierarquias de qualquer tamanho.
Os comandos podem ser colocados naturalmente, separados.
Em muitas linguagens, preciso colocar ponto-e-vrgula para separar
dois comandos distintos, mas no em JavaScript, a memos que voc
coloque comandos em uma mesma linha. Isso no quer dizer que
voc no possa utiliz-los no fim das linhas, e sim que o interpretador
JavaScript ir ignorar aquilo. Assim o identificador de fim de
comando pode ser tanto a quebra de linha como o ponto-e-vrgula.
Outra informao importante: JavaScript sensvel caixa. O
que isso significa? Uma varivel criada como "vaLOR" se chamar
exatamente "vaLOR" e no adianta tentar acess-la com "Valor",
"valor" ou "VALOR". Isso serve para tudo.
Estruturas de Repetio
Trata-se de um comando simples - ou um bloco de comandos -
que ser executado mais de uma vez dentro do cdigo maior.
JavaScript utiliza as trs estruturas de repetio bsicas do C: o while,
o do-while e o for, este ltimo, alm da forma tradicional, de uma
outra maneira bastante til para listas associativas.
while
O while (enquanto) repete um comando ou conjunto de
comandos enquanto uma determinada expresso lgica for
verdadeira. Por exemplo, o cdigo
wh!le (x 2 1%)
x++
incrementar x um determinado nmero de vezes. Quantas
vezes? Depende... Talvez nenhuma. Ele incrementar x o nmero de
vezes que for preciso para que x no seja mais menor que 10.
Programando Estruturadamente #8
Manual JavaScript
dowhile
O do-while (faa enquanto) funciona de maneira muito
parecida com o while, com a diferena de que a operao efetuada
ao menos uma vez (por isso o FAA primeiro e o ENQUANTO
depois). Assim, no exemplo, o comando:
+
senha = pr"pt("3!*!te a senha")
wh!le (senha #= "a.ra4a+a.ra")
repetir a operao de solicitao da senha at que esta seja
"abrakadabra". O cdigo diz para que ele "faa solicitao de senha
enquanto a senha for diferente de abrakadabra".
for
O for (para) faz uma operao um determinado nmero de
vezes, percorrendo dado intervalo. Seu uso convencional da
seguinte forma:
-r (! = %/ ! 2 1%/ !++)
alert(!)
Desta forma, a varivel i ser inicializada com 0 e sero
jogadas ao usurio 10 janelas de alerta, cada uma apresentando um
nmero, do 0 at o 9, pois a cada iterao o i aumentado em 1.
De um modo geral, h trs expresses. A primeira um
comando que ser executado apenas antes da primeira iteao. A
segunda uma expresso booleana que serve de condio. Toda vez
que for iniciar uma nova iterao, o JavaScript checar se a expresso
retorna verdadeiro. Caso retorne, ele pra; seno ele continua. A
terceira outro comando, mas este executado depois de toda a
iterao. Desta forma, o uso convencional do for :
-r ( !n!(!al!5a(a()/ .lean/
pera(a() )
("an+s()
E isso equivale a:
!n!(!al!5a(a()
wh!le (.lean) 6
("an+s()
pera(a()
7
Bem, este o uso convencional, mas h um outro uso, que
muito interessante, por sinal. uma forma de percorrer uma lista
associativa. Suponhamos que voc criou uma lista de links
associando nome a endereo, sendo o nome a chave, com comandos
como:
l!sta$"8-al"& = "http9//www.u-al..r"
Agora voc quer escrever os links mesmo, em sequncia. Como
fazer? Lembrar todas as chaves? Nem pensar! para situaes como
esta que o for funciona como o foreach do Perl, caso voc o conhea.
Caso contrrio, sem problemas: a idia simples.
Para todo elemento da lista, voc vai ter a chave. Ou seja,
percorre-se toda a lista, mas ao invs de a varivel que a percorre
assumir um valor numrico, como no uso tradicional do for
convencional (sim, pois o for na verdade bastante flexvel), ela
assume os valores-chaves. Isso j est ficando meio confuso, no
mesmo? Bem, ento vamos a um exemplo que melhora:
-r (! !n l!sta)
+(u"ent.wr!te("2a hre-=:" + l!sta$!&
+ ":;" + ! + "2/a;2.r;")
O que isso faz? Simples! Escreve todos os links contidos na
lista associativa (nome ->endereo) "lista". s isso mesmo.
Entretanto, h uma questo a se considerar: no estou certo de que
isso funciona corretamente no Internet Explorer, da Microsoft. Isto j
foi testado no Netscape 4, no Mozilla e no Opera, funcionando
corretamente em todos eles.
Estruturas de Deciso
As estruturas de deciso servem para executar uma dada
operao (ou, como sempre pode ser, um conjunto de operaes),
dependendo de uma determinada condio ser verdadeira. H trs
tipos bsicos de estruturas de deciso: o IF, o SWITCH e a forma
condensada do IF.
if
O if (se) pode ser utilizado de duas formas diferentes. A forma
mais simples quando queremos que um cdigo seja executado caso
uma dada expresso seja verdadeira. A forma :
!- ((n+!(a)
("an+
Por exemplo, o cdigo a seguir no permite que x assuma valor
superior a 100. Assim, aps passar por este trecho de cdigo, x
necessariamente ser menor que ou igual a 100.
!- (x ; 1%%)
x = %
A forma completa do if traz tambm a opo "else", a ser
executada caso a condio no seja verdadeira. Sua forma
!- ((n+!(a)
("an+0se0ver+a+e!r
else
("an+0se0-als
Assim podemos fazer com que o cdigo possa seguir um entre
dois caminhos distintos, dependendo de um dado valor. No exemplo
a seguir temos um trecho de cdigo que verifica se x par ou mpar.
!- ( (x % 2) == %)
status3e< = "x par"
else
status3e< = "x ="par"
Programando Estruturadamente #9
Manual JavaScript
swi!"h
O switch permite que, ao invs de optar entre apenas duas
opes, possamos optar entre vrias opes, uma para cada valor de
uma dada varivel ou expresso aritmtica. O normal que o switch
seja utilizado para nmeros, mas em JavaScript ele pode ser utilizado
para variveis do tipo string tambm! Veja o uso
sw!t(h (var!avel) 6
(ase p(a19 ("an+
(ase p(a29 ("an+
...
(ase p(an9 ("an+
7
O switch verificar se a varivel "opcao1". Se no for, ele
far a verificao com "opcao2", e assim por diante at encontrar a
igualdade. Quando encontr-la, o switch simplesmente no verificar
mais nada e executar todo o cdigo que vier at o fim do switch,
inclusive o das verificaes seguintes. Por isso, uma forma mais
utilizada do switch :
sw!t(h (var!avel) 6
(ase p(a19 ("an+/ .rea4
(ase p(a29 ("an+/ .rea4
...
(ase p(an9 ("an+/ .rea4
7
No cdigo apresentado, ao encontrar um case que seja igual
varivel, o switch executa o comando e pra. Para mais de um
comando, basta colocar o break no fim. Mais de uma opo pode ser
colocada em um case, como em todas as estruturas de repetio e
deciso. Para isso, basta que coloquemos todos os comandos entre
chaves onde colocaramos um comando apenas. Mas vejamos um
exemplo de switch: vamos fazer um trecho de cdigo que escreva na
tela a posio de alguns dos jogadores da Seleo na Copa 2002.
sw!t(h (>*a+r) 6
(ase "?ar(s" 9 +(u"ent.wr!te("@
*le!r t!tular, (a"!sa 1#")/ .rea4
(ase "Anal+"9 +(u"ent.wr!te("O
(a"!sa B est +e vlta e art!lhe!r.")/
.rea4
(ase "A!val+"9
+(u"ent.wr!te("Cer+u a (a"!sa 1% -!
:real: "elhr +a (pa.")/ .rea4
(ase "D+"!lsn"9
+(u"ent.wr!te("Ea*ue!r, "as a(h Fue
a!n+a nG -alara" pra ele.")
7
if "ondensado
O IF condensado de que falo na verdade um operador ternrio
de deciso. Por ser de deciso (algo no exatamente trivial por
envolver expresses lgicas), achou-se melhor que fosse colocado
nesta seo. Bem, voc viu o exemplo anterior do if, no? O operador
ternrio IF condensado serve quando temos uma varivel e desejamos
atribuir a ela um valor dependendo de uma expresso. Exatamente o
caso do exemplo. Veja o uso:
var!avel = (expressa) H
valr'eIer+a+e!r 9 valr'eJals
simples de usar quando a gente entende, e ajuda muito.
menos til que o if, mas um comando bastante poderoso (no sentido
de que faz muito em poucas linhas. No caso, uma). Veja como fica
aquele if em verso condensada:
status3e< = ( (x % 2) == %) H "x par" 9
"x ="par"
Modularizao
s vezes acontece de precisarmos utilizar uma determinada
seqncia de comandos em vrios cantos. A modularizao resolve
este problema, permitindo que escrevamos mdulos de cdigo-fonte,
que possam ser chamados a qualquer momento.
Os mdulos - tambm conhecidos como funes,
procedimentos ou rotinas - so suportados por JavaScript, assim
como o so por qualquer linguagem que tenha um mnimo de
estrutura. Eles so construdos atravs da palavra reservada function,
como segue:
-un(t!n -un(a() 6
("an+/
("an+/
...
7
Dentro de uma funo pode haver praticamente qualquer tipo
de comando que poderia ser executado fora dela, incluindo estruturas
de deciso, repetio e tudo o mais. Algumas vezes temos uma idia
geral aplicvel a qualquer string ou nmero. Podemos passar um
valor por parmetro para a funo para que a operao seja feita. Por
exemplo, a funo a seguir retorna um texto pr-definido envolvendo
um valor passado por parmetro:
-un(t!n ex!.e(str) 6
alert("Ol# Olha s,9 " + str + " )G
!n(r=velH")
7
Uma chamada como "exibe('essa funo exibe mesmo.')"
mostrar uma janela de aviso com a seguinte string: "Ol! Olha s:
essa funo exibe mesmo. No incrvel?". Claro que esta funo no
vai ser de grande utilidade: apenas ilustrativa. Voc pode fazer com
um valor passado por parmetro qualquer operao que voc poderia
fazer se ele fosse uma varivel normal.
Uma funo tambm pode retornar um valor e isso feito com
uso da palavra reservada return. O exemplo a seguir mostra uma
funo que retorna um nmero inteiro unitrio por extenso.
-un(t!n u"KrDxtens(n) 6
sw!t(h (n) 6
Programando Estruturadamente #10
Manual JavaScript
(ase %9 str = "5er"/ .rea4
(ase 19 str = "u""/ .rea4
(ase 29 str = "+!s"/ .rea4
(ase L9 str = "trMs"9 .rea4
(ase N9 str = "Fuatr"/ .rea4
(ase O9 str = "(!n("9 .rea4
(ase P9 str = "se!s"/ .rea4
(ase Q9 str = "sete"/ .rea4
(ase R9 str = "!t"/ .rea4
(ase B9 str = "nve"
7
return str
7
Assim, podemos escrever "alert(umPorExtenso(5))" e ver na
tela o nome "cinco". Ao trabalharmos com valores numricos,
podemos fazer funes JavaScript que funcionem exatamente como
funes matemticas especficas.
As ltimas coisas que resta dizer sobre funes: o nome de uma
funo pode ser passado como parmetro para outra funo. O cdigo
a seguir chama dez janelas, cada um com um nmero, de 0 a 9. Teste.
-un(t!n -a53e5Ie5es(-un() 6
-r (var ! = %/ ! 2 1%/ !++) 6
-un((!)
7
7
-a53e5Ie5es(alert)
Outra que uma funo pode ser declarada de uma forma
diferente:
var -a53e5Ie5es = -un(t!n (-un() 6 -r
(var ! = %/ ! 2 1%/ !++)6-un((!)77
E tambm podemos atribuir uma funo a uma varivel, como
segue:
var ?es" = -a53e5Ie5es
Sobre Parmetros
Os parmetros passados para uma funo podem ser o nmero
que ela suporta, ou menos. Por isso, s vezes se utiliza de uma
estranha estrutura, como segue:
-un(t!n ."3!a(usr) 6
aux = (usr) H usr 9 "usur! anSn!""
alert("T" 3!a, " + usr + "##")
7
Isso significa que se a funo for chamada como bomDia(), a
frase que aparecer ser Bom Dia, usurio annimo!!. Isso muito
til em alguns casos, especialmente nos construtores de classes, como
voc ver na prxima seo.
Programando Estruturadamente #11
Manual JavaScript
Programando com Orientao a Objetos
Programando com Orientao a Objetos
Antes de Comear
A forma de programar em que simplesmente se ordena que
coisas sejam executadas em seqncia - forma conhecida como
Programao Estruturada ou Imperativa - no a nica forma de se
criar um programa. H algumas outras e, nos ltimos anos, tem se
destacado cada vez mais uma dessas formas, mas uma forma
especfica, a Orientao a Objetos.
Chamadas de Paradigmas, formas de programar tm muita
diferena entre si e sair de uma para outra exige uma mudana de
viso. preciso ver as coisas de outro modo. No caso especfico de
Programao Orientada a Objetos, temos um paradigma que derivou
de dois outros: a Programao Estruturada e a Funcional. Este
paradigma realmente mostra as coisas funcionando de outra forma
mas, por trazer muita semelhana com a Programao Estruturada,
possvel que se aprenda sua tcnica e no seu esprito. Como
resultado disso, teramos algum que programa utilizando uma
linguagem orientada a objetos, mas no o paradigma, fazendo as
coisas quase que da mesma forma que faria em uma linguagem
estruturada.
JavaScript implementa, at certo ponto, as vantagens da
Programao Orientada a Objetos, permitindo seu uso. Est fora do
escopo deste livro tratar a programao orientada a objetos
diretamente, como paradigma, por isso no espere muito da sesso
seguinte, que prentende apenas orientar o leitor, se me permite o
trocadilho. Para um estudo mais aprofundado da Programao
Orientada a Objetos, sugiro que recorra literatura apropriada.
Orientao a Objetos
Na Programao Orientada a Objetos, temos trechos de cdigo
que representam objetos. Objetos digitais esto jogados em um
ambiente montando um inteiro.
Com#osio
Um objeto pode ser composto por valores
(computacionalmente falando, inteiros, strings, booleanos...) e outros
objetos.
Considere como coisas simples uma barra de ferro ou madeira,
um pedao de vidro ou qualquer elemento feito apenas com um
material. Assim sendo, uma automvel no uma coisa simples, mas
um objeto. Poderamos falar diretamente do volante (e at compr-lo
separadamente), da temos que o volante outra coisa. Faz parte do
carro, mas existe completamente, mesmo sem carro (se vai ser til ou
no sem o carro uma outra questo). Mas o volante simples? No,
um outro objeto. E assim temos objetos e mais objetos se
compondo, uns formados por outros, at um momento em que no
h mais objetos, apenas coisas simples.
Classes
Classes representam uma categoria de objetos e aqui que a
coisa comea a complicar para quem no est muito acostumado. Ao
invs de explicar de cara, vou comear com um exemplo. Vamos
imaginar um Ford Ka. No gosto de fazer propaganda de A ou de B,
mas os detalhes so fundamentais neste ponto. Imagine um azul,
placa ABC-1234, com um adesivo Jota Papelaria no vidro de trs e
um arranho pequeno na porta do motorista. Claro que um carro tem
muito mais detalhes do que isso, mas vamos parar por aqui. Este
carro um objeto, certo?
Agora vamos ver um outro Ka, mas este branco, novo, com
os pneus gastos, com um adesivo em cada porta de um escudo do
Vasco (no sou vascaino). A placa ZXC-8765, e uma imagem de
Nossa Senhora no canto inferior esquerdo do vidro da frente.
Esses dois carros no tem nada a ver um com o outro, no
verdade? Mas tem... O que tm a ver? Tm a ver que os dois so
Fords Ka e, portanto, muito parecidos apesar de tudo. Os dois tm
uma mesma composio (se forem do mesmo ano) de portas, bancos,
volantes, motor... Mas o motor de um pode estar mais gasto que o do
outro, assim como os pneus estavam. Mas mesmo assim, esses
componentes tambm tm uma coisa em comum: so do mesmo tipo.
Em Orientao a Ojetos, da mesma classe.
$erana
Pode-se dizer que o ZXC-8765 do exemplo anterior era um
carro, certo? Mas pode-se dizer tambm que ele era um Ford Ka.
Como pode ser duas coisas se era apenas um objeto? Na verdade,
isso ocorre porque o Ford Ka um carro.
Esse papo parece meio bvio e confuso, no? O que preciso
ver exatamente que o ZXC-8765 no simplesmente um carro e
que nenhum carro simplesmente carro. Todos tm um modelo de
alguma indstria que os define melhor.
O que se deve entender tambm que o Ford Ka um carro. O
que isso significa? Significa que a idia do Ford Ka tem todas as
caractersticas referentes idia de carro, por herana.
Quais so as caractersticas de carro? Possuem pneus, andam
no cho deslizando os pneus. Possuem motor e lugar para algum
que o conduza, dito motorista. Quais as de um Ford Ka? Todas as de
um carro, mais: so exatamente 4 os pneus e muitas outras.
Quando dizemos que uma classe A herda de outra classe B,
queremos dizer que todo objeto x que seja feito segundo as normas
de A, sendo considerado um A, ser tambm considervel como um
B.
Usando Objetos
Um objeto uma coisa que agrupa variveis (aqui chamadas
de atributos) e funes (aqui chamadas de mtodos). A grande
vantagem ao usar objeto que, alm de agruparmos coisas que tm a
ver entre si, elas passam a ser mais integradas.
Um atributo acessado com um ponto depois do nome do
objeto, seguido do prprio atributo. como se fosse uma varivel e
pode ser utilizado da mesma forma.
Um mtodo tambm acessado dessa forma, mas com
parnteses depois. Enfim, tudo quase igual. Assim, os comandos a
seguir so vlidos.
5x(.(r = "wh!te"
Programando com Orientao a Objetos #12
Manual JavaScript
5x(.an+ar()
"ensa*e" = (5x(.arUn+!(!na+) H "Ve"
ar (n+!(!na+" 9 ")G te" ar
(n+!(!na+"
Um objeto funciona como um vetor associativo. Assim, voc
pode acessar a cor, por exemplo, tambm com:
5x($"(r"& = "wh!te"
Estrutura with
Se voc pretende tratar um s objeto, pode utilizar o comando
with, utilizado assim:
w!th (5x() 6
(r = "wh!te"
an+ar()
7
Isso colabora para que voc poupe tempo e caracteres, o que
pode ser muito importante em JavaScript, j que tudo vai ser
transferido pela rede antes de ser interpretado.
A Criao de Classes
O esquisito de O. O. em JavaScript justamente aqui, na
criao de classes. Uma classe, em JavaScript, apenas uma funo.
A nica coisa que difere que nesta funo voc utilizar o this para
agregar atributos e mtodos. O this referencia no somente a prpria
classe, mas o objeto especfico durante sua execuo. Este.
Para adicionar um atributo, basta escrever
this.nomeDoAtributo. Se for um objeto, voc deve instanci-lo:
this.lista = new Array(). Para adicionar um mtodo, voc deve
utilizar aquela forma estranha de definio de funo: this.escreve =
function() { document.write( this.texto ) define um mtodo escreve
que escrever o contedo do atributo texto deste objeto.
Classe Data
Vamos ver se as coisas clareiam um pouco mais com um
exemplo: trata-se de uma clssica classe de Data que escreve a data
por extenso e na forma simples.
-un(t!n 3ata(++, "", aa) 6
th!s.+!a = ++
th!s."es = ""
th!s.an = aa
th!s.extens = -alse
th!s..te"Dxtens = -un(t!n() 6
sw!t(h (th!s."es) 6
(ase 19 """ = ">ane!r"/
.rea4
(ase 29 """ = "-evere!r"/
.rea4
(ase L9 """ = ""arW"/ .rea4
(ase N9 """ = "a.r!l/ .rea4
(ase O9 """ = ""a!"/ .rea4
(ase P/ """ = ">unh"/ .rea4
(ase Q9 """ = ">ulh"/ .rea4
(ase R9 """ = "a*st"/
.rea4
(ase B9 """ = "sete".r"/
.rea4
(ase 1%9 """ = "utu.r"/
.rea4
(ase 119 """ = "nve".r"/
.rea4
(ase 129 """ = "+e5e".r"/
.rea4
7
return th!s.+!a + " +e " + """ +
" +e " + th!s.an
7
th!s..te"'!"ples = -un(t!n() 6
return th!s.+!a + "/" + th!s."es
+ "/" + th!s.an
7
th!s.es(reve = -un(t!n() 6
!- (th!s.extens) 6
+(u"ent.wr!te(
th!s..te"Dxtens() )
7 else 6
+(u"ent.wr!te(
th!s..te"'!"ples() )
7
7
7
Esta classe, apesar de simples, j mostra algo interessante:
permite que voc escolha a forma na qual a data ser escrita. Assim,
devemos criar um objeto do tipo data como segue:
var + = new 3ata(1%, %Q, 2%%2)
Uma vez feito isso, se escrevemos:
+.extens = true
Ao digitarmos d.escreve(), a data ser escrita por extenso. Sem
isso, ela ser escrita na forma normal.
Programando com Orientao a Objetos #13
Manual JavaScript
Composio
muito simples o conceito. To simples que no h muito o
que falar. Um objeto uma varivel. Uma classe pode definir
atributos, que so variveis. Por conseqncia, um atributo pode
tambm ser um objeto e esse o ponto chave. s colocar
this.atributo = new Classe(params) e pronto.
Herana
A herana, como j foi explicado no tpico paradigma,
quando queremos dizer que uma classe A , de certa forma, uma
especializao da classe B.
Um dos exemplos mais clssicos disso o de Pessoa. Vamos
supor uma classe Pessoa. Ela teria como atributos nome, endereo,
telefone, e-mail... Agora queremos uma Pessoa Fsica. Basta
acrescentarmos o CPF e outras coisas mais. No interessante re-
escrever tudo. Uma Pessoa Jurdica teria o CNPJ. No final, a classe
Pessoa deveria ter o que h em comum entre Pessoas Fsicas e
Jurdicas. Usando herana, ns no precisaremos re-escrever tudo,
basta dizermos que PessoaFisica, apesar de ter CPF e outras coisas,
uma Pessoa. O mesmo com Pessoa Jurdica.
JavaScript possui um jeito muito esquisito de se definir isso:
com o prottipo da funo ( o construtor da classe, mas para o
JavaScript ainda uma funo). O acesso na forma
constructorDaClasse.prototype = new construtorDaClasseMae.
Apenas isso. Sem parnteses mesmo! Lembre que em JavaScript o
construtor da classe o prprio nome da classe.
Vamos a um exemplo. Vamos supor que j existe uma classe
Pessoa, inclusive com um mtodo escrever() que escreve na tela
todos os seus dados na forma Campo: Valor
-un(t!n KessaJ!s!(a() 6
th!s.(p-
th!s.setUKJ(n) 6
th!s.(p- = n
7
th!s.es(rever() 6
parent.es(rever()
+(u"ent.wr!te("UKJ9 " +
th!s.(p- + "X2TAX;")
7
7
Este cdigo est muito simples e falta alguma coisa, no? Falta
dizermos que uma pessoa fsica tambm uma pessoa. Para isso,
devemos escrever (depois de escrita toda a classe) a linha j
apresentada:
KessaJ!s!(a.prttype = new Kessa
Com isso temos que uma pessoa fsica tambm uma pessoa.
Outra coisa interessante que ainda no foi dita o parent. a
forma de acessar mtodos da classe-me. A chamada que est na
classe PessoaFisica significa Classe-me.escrever()
.
Programando com Orientao a Objetos #14
Manual JavaScript
Iara JavaScript Code Standards
Iara JavaScript Code Standards
Este padro est sendo proposto para tornar possvel:
1. O cdigo JavaScript escrito por qualquer pessoa que siga
este padro seja compreendido e modificado por qualquer
outra pessoa que tambm conhea este padro sem qualquer
problema;
2. A escrita de cdigos JavaScript pequenos, que possam ser
transferidos pela Internet gerando to pouco trfego quanto
for possvel;
3. Reunir boas prticas de codificao.
Como se pode notar facilmente, o tem 2 parece conflitar com
o tem 3. Por isso, procuramos criar um meio termo entre os dois: um
cdigo bem-escrito e enxuto ao mesmo tempo. neste ponto que
reside o maior trabalho na elaborao deste padro.
Indentao
1. No se deve utilizar o demarcador de fim-de-cdigo
(ponto-e-vrgula) - como em Python -, exceto em dois casos
especiais: o for quando usado em estilo C (dois comandos +
uma expresso lgica) e o case quando tiver apenas um
comando (pode-se usar ponto-e-vrgula para separar o
comando do break). Como conseqncia, exceto nos casos
explicitados, cada linha de cdigo dever apresentar no
mximo um comando.
2. O delimitador de incio de bloco (abre chaves) deve ser
colocado ao final da estrutura que anuncia o bloco.
3. O delimitador de fim de bloco (fecha chaves) deve aparecer
sozinho na linha e no mesmo nvel de indentao da linha
de cdigo que abriu o bloco.
4. No se deve utilizar espaos para indentao, apenas o
caractere de tabulao (TAB).
5. O cdigo comea alinhado esquerda, no sendo
necessrio usar uma tabulao para o nvel inicial do
arquivo js.
6. Deve-se evitar o uso de linhas em branco no cdigo.
Quando necessrias para organizao, certifique-se de no
haver caracteres brancos (tabulaes e espaos) na linha.
7. Blocos formados por uma s linha de cdigo no precisaro
de delimitadores de incio e fim, somente da indentao.
-un(t!n exe"pl()6
-r(! =%/ ! 21%/ !++)
alert(:(: +! +:) Dste
exe"pl +a !+entaWG:)
alert(:O exe"pl +a !+entaWG -!
r+a+ : +! +: ve5es.:)
7
Expresses
1. Qualquer operador (matemtico, lgico, de atribuio) deve
ser escrito com um espao antes (entre o operador e o
primeiro operando) e nenhum depois (deve estar unido ao
segundo operando).
2. Variveis incrementadas/decrementadas devem aparecer
com o operador prximo a elas e separadas das demais da
expresso (e demais operadores) por espaos (antes e
depois, mas nunca acumulados com outros espaos que a
expresso j traga prximo ao [in|de]cremento).
3. Expresses que demandem parnteses e chaves (tais como
o if, o while ou mesmo o function) no apresentaro
espaos na concatenao com parnteses e com chaves.
4. Encadeamentos de comandos separados por ponto-e-
vrgula devem ter um espao aps cada ponto-e-vrgula.
5. Listas separadas por vrgula no devem apresentar espaos
entre seus tens e as vrgulas.
Esta a forma proposta pelo padro:
x =y *2 +L /5
Aqui temos um caso se atribuio seletiva (lgica de circuitos):
aux =x YYy YY2%
Outro exemplo maior:
-un(t!n s"aZnte!rs(a,.)6
s =:A s"a +e : +a +: (" : +. +:
retrnu :
wh!le(. ;%)6
a++
.00
7
wh!le(. 2%)6
a00
.++
7
return s +a +:.:
7
Note que o nico espao na primeira linha o que se encontra
depois de function.
Concatenao de strings (a e b so convertidos em strings
automaticamente): colocar um espao antes de cada sinal de
concatenao.
Comentrios
Evite colocar comentrios no cdigo. Tente fazer o cdigo da
maneira mais clara e auto-explicativa possvel, colocando apenas
comentrio essenciais (como, por exemplo, o cabealho do arquivo,
onde deve haver uma nota da licena de distribuio).
Iara JavaScript Code Standards #15
Manual JavaScript
Nomenclatura
1. Nomes devem ser escritos em ingls, hbito considerado
boa prtica de programao. Um software no est preso a
nenhuma cultura especfica, no sendo cultural, mas uma
forma internacional de resolver problemas. Por isso,
escrever cdigo com nomes em ingls no falta de
patriotismo;
2. Nomes so essencialmente em caracteres minsculos,
exceto nos casos tratados nos prximos tens;
3. Nomes de classes comeam sempre com a primeira letra em
maisculo, a menos que seja uma classe de uma API. Neste
caso, a API deve fornecer uma sub-string padro, que
dever estar no incio dos nomes de todas as classes da
API. Esta sub-string pode ter letras maisculas e
minsculas livremente;
4. Sempre que o nome tiver mais que uma palavra o
formando, cada palavra depois da primeira (que segue as
regras apresentadas acima) deve ser unida ao restante,
mudando-se apenas a primeira letra para maiscula. Nunca
utilizar sublinhados para essas unies.
5. Nomes de atributos e mtodos privados devero ter um
caractere _ no incio. Isso no os torna praticamente
privados, mas conceitualmente, entre ns programadores.
Uma soluo similar utilizada em Perl 5, que tambm no
traz o conceito de mtodo privado.
6. Deve-se evitar abreviaes.
Exemplificando...
("pleteVa.le =new A3'Va.le()
O exemplo acima mostra um objeto completeTable sendo
criado a partir da classe ADSTable.
O objeto formado pelo nome Complete Table. Comeando
com minscula por ser objeto, temos complete Table. Como dito,
cada palavra alm da primeira deve ser unida ao resto, com a
primeira letra em maiscula. Por isso, Table se une ao complete,
mantendo o T maisculo: completeTable.
A classe apresentada a implementao de tabela de uma
suposta API que adotou a sub-string "ADS" para definir suas classes.
Por isso a classe tem esse nome: ADS + Table.
Variveis
1. Constitui-se uma boa prtica de programao a declarao
de variveis. Entretanto, no havemos de declarar uma
varivel por questes de tamanho do arquivo gerado (var).
Outras linguagens amplamente conhecidas no oferecem
forma de se declarar variveis (PHP 4) ou a oferecem como
opcional (Perl 5 em modo normal). Portanto,
consideraremos a declarao de uma varivel como um
hbito no-primordial para a boa apresentao do cdigo,
abolindo-a.
2. Uma varivel deve ser sempre inicializada com um valor
explcito, de uma outra varivel ou retorno de uma funo.
No se deve utilizar qualquer operador que aja sobre a
varivel sem que esta tenha recebido um valor inicial. Tal
deve ser feito, preferencial mas no necessariamente, no
incio do bloco de cdigo.
3. Vetores devem ser declarados com [] e no com new
Array().
4. Valores booleanos devem ser expressos como true ou false
sempre que houver risco de valores numricos causarem
confuses. O ideal, entretanto, que se utilize sempre 0 e 1,
como em C.
Classes
1. Mtodos devem ser declarados dentro da prpria classe.
2. Herana deve ser feita atravs do processo de refazer o
construtor a partir do construtor da classe me: cria-se um
mtodo make pela atribuio do construtor da classe me e
invoca-se tal mtodo logo em seguida.
3. No caso de herana mltipla, o mtodo ter o mesmo nome,
mas os dois passos sero seguidos mais de uma vez, sempre
em par.
Vejamos, por exemplo, a classe ADSCode.
-un(t!n A3'U+e(s)6
th!s.(ntent =s YY::
th!s.a++ =-un(t!n(s)6
th!s.(ntent +=s
7
th!s..ta!n =-un(t!n()6
return th!s.(ntent
7
th!s.wr!te =-un(t!n()6
+(u"ent.wr!te(th!s..ta!
n())
7
7
desta forma que todos os mtodos so definidos dentro da
classe. Veja add, obtain e write.
Agora suponha uma classe ADSParagraph, apenas para
exemplificar (usando [p] para a tag de pargrafo, apenas para
simplificar a edio aqui, na web).
-un(t!n A3'Kara*raph(s)6
th!s."a4e =A3'U+e
th!s."a4e(s)
th!s..ta!n =-un(t!n()6
return :$p&:
+th!s.(ntent+ :$/p&:
7
7
As duas linhas que comeam com th!s."a4e fazem com
que o ADSParagraph herde todo o comportamento e estado inicial de
ADSCode.
No exemplo, sobrescrevemos o mtodo obtain, perdendo o
herdado de ADSCode.
Iara JavaScript Code Standards #16