Minicurso de JavaScript (Portuguese)

Mini-curso de JavaScript

Bruno Grangê
www.grange.com.br


Agenda prevista

 Dia 1:
• Episódio 1 - Começando com JavaScript
• Episódio 2 - Sintaxe e estrutura
 Dia 2:
• Episódio 3 - Funções e objetos
 Dia 3:
• Episódio 4 - Objetos nativos embutidos
 Dia 4:
• Episódio 5 - As janelas do browser
 Dia 5:
• Episódio 6 - Debugando o DOM

2


Episódio 1 - Começando com JavaScript

 O que é JavaScript
 Diferenças de JS e Java
 O que podemos fazer com JS?
 Como programar JS?
 Formas de usar o JS
• Blocos <SCRIPT> embutidos na página
• Arquivos importados
 Tratamento de eventos
 Principais eventos JS

3


O que é JavaScript?

 JavaScript (chamaremos JS) é uma linguagem de programação
interpretada criada em 1995 como uma extensão do HTML.

 O JS oferece recursos que faltam no HTML, permitindo a criação
de páginas interativas e dinâmicas, que são interpretadas
localmente, sem precisar recorrer a execução remota de
programas no servidor.

 O JS é hoje executado na maioria os browsers, e está sendo
amplamente disseminado para outras plataformas, como PDAs,
terminais inteligentes e aplicações em geral (e.g. Notes).

4


FSQ – Frequently Smart Questions

 Eu consigo executar funções no
servidor com o JS?

 SIM! O JS no servidor (server-side JS) é
uma linguagem que possui o mesmo núcleo
que o client-side JS, mas acrescenta
estruturas exclusivas para interação com o
servidor. Porém, este curso tratará apenas
do client-side JS, que roda no browser.

5


FDQ – Frequently Dumb Questions

 JavaScript é Java?

 NÃO! JS freqüentemente é confundida
com a linguagem Java, provavelmente
devido à semelhança do nome. Apesar de
possuir sintaxe parecida, JS não tem nada
a ver com Java!

 O nome "script", que quer dizer roteiro, já
indica que se trata de uma linguagem
interpretada. Além do nome, podemos
apontar diversas outras diferenças:

6


Diferenças de JS e Java

 Interpretada. Programas em Java são compilados para um código de
máquina, e depois executados. O JS é interpretados na página.

 Simples. Programas em Java são bem mais poderosos e complexos que
programas JS, e não estão limitados à página.

 Pequena. JS (1.5) consiste de cerca de 400 estruturas. A API do Java (2)
possui mais de 20000 estruturas.

 Extensão do HTML. Pode-se incluir uma applet em uma página, porém
não podemos incluir Java diretamente em uma página Web. O código JS
vem embutido dentro da página. Não existe JS sem uma página.

7


O que podemos fazer com JS?

 Realizar operações matemáticas e de computação.

 Gerar documentos com aparência definida na hora da
visualização, com base em informações do cliente.

 Abrir janelas, trocar e manipular informações como o histórico,
barra de estado, plug-ins, etc.

 Interagir com o conteúdo do documento, alterando propriedades
da página.

 Interagir com o usuário através de eventos.

8


Como programar JS?

 O ideal é ter a sua disposição:

 Um bom editor de textos para editar o HTML
• (Scite, UltraEdit, Adobe Dreamweaver, etc).

 Alguns browsers comumente utilizados na web para testar
• (Microsoft Internet Explorer, Mozilla Firefox, Opera, etc).

 Um bom debugger para depurar o código
• (Microsoft Script Debugger, Firebug, Granjuxx Debugger, etc).

9


Formas de usar o JS

 Dentro de blocos HTML <SCRIPT> ... </SCRIPT> em várias
partes da página.
• Para definir funções usadas pela página, gerar HTML em novas páginas ou
alterar o procedimento de interpretação do HTML.

 Em um arquivo externo, importado pela página.
• Para definir funções que serão usadas por várias páginas em um site.

 Dentro de descritores HTML sensíveis a eventos.
• Para tratar eventos do usuário em elementos da página durante a exibição.

10


Blocos <SCRIPT> embutidos na página

 A forma mais prática de usar JS é embutindo o código na página
dentro de um bloco delimitado pelas tags <SCRIPT> e
</SCRIPT>. Pode haver vários blocos <SCRIPT> na página.

<script>
... instrucoes JS ...
</script>

11


Blocos <SCRIPT> embutidos na página (cont.)

 O descritor <SCRIPT> possui um atributo LANGUAGE que
informa o tipo e versão da linguagem utilizada. O atributo
LANGUAGE é necessário para incluir blocos em outras
linguagens como VBScript. É opcional para JS.
<SCRIPT LANGUAGE="VBScript">
... codigo em VBScript ...
</SCRIPT>

<SCRIPT LANGUAGE="JavaScript1.5">
... codigo JavaScript ...
</SCRIPT>

<SCRIPT> ... codigo JavaScript ... </SCRIPT>

12

 Observe o código abaixo:
<BODY> <p>Ultima modificacao:
<script language="JavaScript1.5">  </script></p>
</BODY>

13

 Tudo o que está em vermelho no código mostrado é JS.

 O código JS que foi colocado entre comentários HTML .
Isto é usado para os browsers antigos, que não suportam JS, e
exibem o código na página em vez de executá-lo.

 No código acima, autor é uma variável que recebe por atribuição
o texto “Bruno Grange"; document é um objeto JS que
representa a página da janela atual do browser. lastModified é
uma propriedade da página (texto contendo a data de última
modificação do arquivo) e write() é um método que escreve o
texto passado como parâmetro na página representada por
document.

14



 O ponto (.) é usado para que se possa ter acesso a propriedades
e métodos de um objeto. O sinal "+" é usado para concatenar
caracteres e strings. As duas barras (//) representam um
comentário de linha em JS.

 Essa página traria como resultado:

15



 No Domino Designer (chamaremos Designer), fazemos:

 Texto (formatado ou não) com pass-thru HTML.

 Podemos usar <Computed Value> e

16



 No Designer, podemos colocar o código JS no “JS Header”,
permitindo assim que ele possa ser usado por toda página.

17


Arquivos importados

 Muitas vezes é necessário usar um mesmo código várias vezes.

 Para isso o JS permite que se crie funções que são chamadas de
outras partes da página várias vezes.

 As funções geralmente ficam em um bloco <SCRIPT> separado,
antes de todos os outros blocos, para que sejam carregadas
antes que a página seja exibida.

18


Arquivos importados (cont.)

 Se várias páginas usam as mesmas funções JS, uma boa opção
é colocá-las em um arquivo e importá-lo nas páginas que
precisarem delas.

 Este arquivo deve ter a extensão ".js" e conter apenas código JS
(não deve ter descritores HTML, como <SCRIPT>).

 No Designer, este arquivo pode ser uma página, o resultado de
um agente, uma biblioteca, etc., ou qualquer recurso disponível
através de uma URL.
• No Designer 6 é possível criar JS Libraries e importa-las no código.

19



 Por exemplo, suponha que o arquivo biblio.js possua o seguinte
código:

20



 Para carregar esta função, usa-se a tag <SCRIPT> com SRC:

<script LANGUAGE=JavaScript SRC="biblio.js"></script>
(...)
<script>
resultado = soma(5, 6);
document.write("<P>A soma de 5 e 6 é " + resultado);
</script>

21



 No Designer, temos várias opções, porém as melhores são:

Criar uma JS library Criar uma página content type HTML

22



 Depois, para usar as suas funções, basta invocar as páginas.
 Abaixo temos um exemplo usando o HTML Head content.

23


Tratamento de eventos

 JS dá suporte a captura de vários eventos do usuário, que vão do
arrasto do mouse ao apertar de uma tecla.
 Os eventos geralmente vem inseridos em elementos HTML, e são
precedidos pelo prefixo “on”.

<FORM>
<INPUT TYPE="button"
onClick="alert('Oh não,
você acionou o sistema de
autodestruição!')"
VALUE="Não aperte este
botão">
</FORM>

24


Tratamento de eventos (cont.)

 Para usar eventos no designer, você pode usar código em pass-
thru HTML, ou usar alguns eventos JS dos elementos Designer.

25


Tratamento de eventos (cont.)

 JS também pode ser acionado
através de eventos nativos do
HTML, como links e botões de
submissão de formulários
usando uma URL "javascript:“
(assim como no “http://”)

<a
href="javascript:
alert('Tem certeza que
deseja levantar da
cadeira?')“
>link </a>

26


Principais eventos JS
Atributo Quando o procedimento é executado Descritores HTML onde é permitido
onclick Quando um objeto é clicado pelo mouse <a>, <input>
onselect Quando um objeto é selecionado <input type=text>, <textarea>
Quando uma seleção ou campo de texto tem seu
onchange conteúdo modificado <input type=text>, <textarea>, <select>
Quando um componente de formulário ou janela se <textarea>, <body>, <form>, <input>, <select>,
onfocus torna ativa <option>
Quando um componente de formulário ou janela se <textarea>, <body>, <form>, <input>, <select>,
onblur torna inativa <option>
onmouseover Quando o mouse está sobre um link <a>, <area>
onmouseout Quando o mouse deixa um link <a>, <area>
onsubmit Antes de enviar um formulário <form>
onreset Antes de limpar um formulário <form>
onload Após carregar uma página, janela ou frame <body>
onunload Ao deixar uma página, janela ou frame <body>
Quando um erro ocorre durante a carga de uma
onerror imagem ou página <img>, <body>

onabort Quando a carga de uma imagem é abortada <img>

27


Episódio 2 - Sintaxe e estrutura

 Sintaxe básica
 Variáveis
 Escopo das variáveis
 Tipos de dados e literais
 Caracteres especiais
 Identificadores e palavras reservadas
 Operadores e expressões
 Estruturas de controle de fluxo
• if... else
• for
• while
• break e continue
• for ... in e with

28


Sintaxe básica

 O JS, como a maioria das linguagens, é formada por um bloco de
instruções e comentários.

 Uma instrução JS pode terminar com um ponto-e-vírgula [ ; ] ou
uma nova linha.

 Instruções compostas são agrupadas em blocos delimitados por
chaves ({ e }), por exemplo, uma função:

function media(a, b) {
return (a + b) / 2;
}

29


Sintaxe básica (cont.)

 JS é case-sensitive. Logo, function, Function e FUNCTION são
três nomes distintos e tratados de forma diferente.

 Há duas formas de comentar JS:

// em uma linha com duas barras

/*
ou em várias linhas, com os caracteres barra
asterísco, e depois asterísco – barra
*/

30


Variáveis

 Para definir uma variável, basta escolher um nome que não seja
uma palavra reservada e atribuir um valor:
preco = 10;
produto = ‘Caneta para concurso’;

 Uma variável também pode ser declarada sem um valor. Para isto
é necessário usar a palavra-chave var (valor undefined):
var ladrao;

31


Escopo das variáveis

 Uma variável declarada pela primeira vez dentro de um bloco de
função tem escopo local e não existe fora dele.
 Variáveis declaradas ou definidas fora do bloco são globais e são
visíveis em toda a página:
global = 3; // escopo: toda a pagina
function x() {
local = 5; // escopo: somente o bloco da função
global = 10;
}
x();
// local nao existe aqui – so em x().
// global tem valor 10 para toda a pagina

32


Escopo das variáveis (cont.)

 O uso de var é opcional na definição de variáveis globais.
Variáveis locais devem ser definidas com var para garantir que
são locais mesmo havendo uma variável global com o mesmo
nome, por exemplo:
g = 3; // variável global
function x() {
var g = 10; // esta variável g é local!
}
x();
// g (global) tem o valor 3!

33


Tipos de dados e literais

 O JS possui apenas 6 tipos de
dados fundamentais:

 String
 Number
 Boolean
 undefined
 null
 Object

34


Tipos de dados e literais (cont.)
T ip o s e o b je t o s o b je c t O b je t o s n a t iv o s
G lo b a l
n a t iv o s T ip o d e d a d o s
e m b u t id o s

E C M A S c r ip t n a t iv o q u e
r e p r e se n t a O b je c t B o o le a n F u n c t io n
c o le ç õ e s d e
fu n c t io n p r o p r ie d a d e s
A rra y D ate
c o n t e n d o v a lo r e s d e
N um ber
T ip o d e o b je t o q u e
r e p r e se n t a fu n ç õ e s, t ip o s p r im it iv o s ,
m é to d o s e fu n c t io n o u o b je c t S t r in g M ath
c o n str u to r e s
T ip o s d e d a d o s p r im it ivo s ( q u e r e p r e s e n t a m v a lo r e s )
u n d e f in e d num ber M in : ± 4 .9 4 0 6 5 e - 3 2 4
r e p r e s e n t a v a lo r e s undefined r e p r e se n ta n ú m e r o s M a x : ± 1 .7 9 7 6 9 e + 3 0 8
a in d a n ã o d e f in id o s d e p o n t o - f lu t u a n t e
IE E E 7 5 4 c o m p r e c is ã o NaN
d e 1 5 c a s a s d e c im a is Infinity
n u ll (6 4 b it s ) -Infinity
r e p r e se n t a o v a lo r null
n u lo
st rin g " u0000 - uFFFF"
r e p r e s e n t a c a d e ia s ' u0000 - uFFFF'
b o o le a n o r d e n ad as (e ' '
true
r e p r e s e n t a v a lo r e s in d e x á v e is) d e " "
false
b o o le a n o s c a r a c t e r e s U n ic o d e . " abcde012+$_@..."

35



 JS é uma mãe!
 Não é preciso declarar as
variáveis.
 Uma variável só muda de um tipo
se durante o script for associado
um novo valor de um tipo
diferente ao que ela armazenava
antes.
 Os tipos primitivos number, string
e boolean são representados
pelos objetos nativos Number,
String e Boolean, facilitando o uso
de suas propriedades e métodos.

36



s = "texto";
// s é string

y = 123;
// y é number

s = true;
// s agora é boolean!

/* VARIAVEIS CAMALEAO -
SE ADAPTAM AO CONTEXTO*/

37



 Variáveis do tipo number são representados internamente como
ponto-flutuante de dupla-precisão.

 Números iniciados em "0" são considerados octais e os iniciados
em "0x" são hexadecimais.

 O tipo number também representa alguns valores especiais, que
são infinito positivo (Infinity), infinito negativo (-Infinity) e
indeterminação (NaN - Not a Number).

38



 Exemplos de number
hx= 0xffac;
// hexa: 0123456789abcdef

float= 1.78e-45;
// ponto-flutuante: .0123456789e-

oct= 0677;
// octal: 01234567

soma = h + 12.3 + oct - 10;
// conversão automática

39



 Booleans representam os estados de ligado e desligado através
dos literais true e false.
 Geralmente são obtidos como resultados de expressões
condicionais e lógicas.

if(valorNota==3)
alert(“FALSE!”)

40



 Strings são identificados por literais contidos entre aspas duplas
("...") ou simples ('...').
 O texto entre aspas pode ser qualquer caractere Unicode. Tanto
faz usar aspas simples como aspas duplas.
 Geralmente usamos aspas simples quando um trecho de código
JS que requer aspas é embutido em um atributo HTML, que já
utiliza aspas duplas:
<INPUT TYPE="button"
ONCLICK="alert('Oh não!')"
VALUE="Não aperte!">

41



 A concatenação de strings é realizada através do operador “+”.
 O operador “+=” (atribuição composta com concatenação)
acrescenta texto a um string existente.
 Qualquer número ou valor booleano que fizer parte de uma
operação de concatenação será automaticamente transformado
em string.
str1 = "Eu sou uma string";
str2 = str1 + ' também!';
str3 = str2 + 1 + 2 + 3;
// str3 contém:
// Eu sou uma string também!123
str1 += "!";
// mesmo que str1 = str1 + "!".

42



 Para converter um número ou booleano em string basta utilizá-lo
em uma operação de concatenação com uma string vazia:
a = 10;
b = "" + a; // b contém a string “10”

 A conversão de strings em números já não é tão simples. É
preciso identificar a representação utilizada, se é ponto-flutuante,
hexadecimal.
 Para isto, JS fornece duas funções nativas: parseInt(string) e
parseFloat(string) que convertem strings em representações de
número inteiro e ponto-flutuante respectivamente.

43



a = "10"; b = prompt("Digite um número");
// lê string

document.write(a + b);
// imprime “105”

c = parseInt(a) + parseInt(b);
// converte strings em inteiros decimais

document.write(c);
// imprime ”15”

44


Caracteres especiais

 Quando é necessário imprimir aspas
dentro de aspas é preciso usar um
caractere especial de escape.

 O caractere usado para este fim dentro
de strings é a contra-barra ().
 Use ' para produzir uma aspa simples
e " para produzir aspas duplas.
 A própria contra-barra pode ser impressa
usando “”.
 Outros caracteres também podem ser
impressos dessa forma.

45


Caracteres especiais (cont.)

Caractere Função
especial
" Aspas duplas ( " )
' Aspas simples( ' )
Contra-barra ( )
n Nova linha (line feed)
r Retorno de carro (carriage return)
f Avança página (form feed)
t Tabulação horizontal (horizontal tab)
b Retrocesso (backspace)

46


Caracteres especiais (cont.)

 IMPORTANTE!

 O HTML ignora completamente espaços em branco extras, novas-
linhas, etc. que não sejam provocadas por descritores HTML
(como <BR>, <P>, etc.).

 Portanto os escapes acima que provocam espaços em branco
não aparecerão na página a menos que o texto esteja dentro de
um bloco <PRE>.

47


Identificadores e palavras reservadas

 Identificadores JS são os nomes que escolhemos para variáveis e
funções. Esses nomes podem ter qualquer tamanho e só podem
conter caracteres que sejam:
• números (0-9)
• letras (A-Z e a-z)
• caractere de sublinhado ( _ )

 Além disso, embora identificadores JS possam conter números,
não podem começar com número ou conter caracteres especiais.
Por exemplo, os identificadores abaixo são ilegais:
• ping-pong, 5abc, Me&You, m@il()

48


Identificadores e palavras reservadas (cont.)

 As palavras listadas abaixo são utilizadas pelo JS e por isto são
consideradas reservadas, não sendo permitido usá-las para
definir identificadores para métodos, variáveis ou funções:

 break – sai de um loop sem completá-lo
 continue – pula uma iteração de um loop
 delete – operador que apaga um objeto false – literal booleano
 for – estrutura de repetição for
 function – declara uma função JS
 if, else – estrutura de controle condicional if-else
 in – usado em um loop for para iterar pelas propriedades de um
objeto

49


Identificadores e palavras reservadas (cont.)

 new – cria uma nova cópia de um objeto a partir de um protótipo
 null – literal do tipo null
 return – retorna de uma função (pode retornar um valor)
 this – ponteiro para o objeto atual (ou elemento HTML atual)
 true – literal booleano
 typeof – operador que identifica o tipo de uma variável
 undefined – literal do tipo undefined
 var – declara uma variável
 void – operador que executa funções sem retornar valor
 while – estrutura de repetição while
 with – estabelece o objeto como default dentro de um bloco
 e outros...

50


Operadores e expressões

 JS possui várias classes de operadores:

 De atribuição
 Aritméticas
 Booleanas
 Comparativas
 Binárias

51


Operadores e expressões (cont.)
Operadores aritméticos Operadores lógicos Operadores de bits
- n negação != diferente de & and
++n, n++ incremento == igual a | or
--n, n-- decremento > maior que ^ xor
* multiplicação < menor que ~ not
/ divisão >= maior ou igual a << desloc. à esquerda
% resto <= menor ou igual a >> desloc. à direita
+ adição e conc. || or >>> desloc. à dir. s/ sinal
- subtração && and Operadores de objetos
Operadores de atribuição ! not new criação
= atribuição ?: condicional delete remoção
op= atribuição com , vírgula typeof tipo do objeto
operação void descarta o tipo

52



x = 1;
// atribuição simples

y += 1;
// atribuicao com soma. Equivale: y = y + 1 ou y++

z /= 5;
// atribuicao com divisao. Equivale: z = z / 5

texto = 4 + 5 + ":" + 4 + 5;
// texto contém 9:45

53



Associatividade Tipo de Operador Operador

Dir a Esq separadores [] . ()

Esq a Dir unários e de objetos e++ e-- ++e –-e +e -e ~ ! new delete void typeof

EaD multiplicação/divisão */%
EaD adição/sub./concat. +-+

EaD deslocamento << >> >>>
EaD relacional < > >= <=
EaD igualdade == !=
EaD AND &
EaD XOR ^
EaD OR |
EaD E lógico &&
EaD OU lógico ||
DaE condicional ?:
DaE atribuição = += -= *= /= %= >>= <<= >>>= &= ^=

54



 Os “++” e “––“ (incremento e decremento) acrescentam ou
subtraem 1 da variável antes ou depois do uso, respectivamente.

x = 5;

z = ++x;
// z = 6, x = 6;
//Incrementa x primeiro, depois atribui a z

z = x++;
// z = 6, x = 7; Atribui x a z, depois incrementa

55


Estruturas de controle de fluxo

 As estruturas de controle de fluxo
são praticamente as mesmas
utilizadas em outras linguagens
estruturadas populares.

 A sintaxe das principais estruturas
em JS é idêntica à sintaxe usada
em C, C++ e Java.

56


if... else

 A estrutura if... else é utilizada para realizar controle de fluxo
baseado em expressões condicionais:
if (condição) {
// instruções caso condição == true

} else if (condição 2) {
// instruções caso condição 2 == true

} else {
// instruções caso ambas as condições sejam false

}

57


if... else (cont.)

 Exemplo:
if (ano < 0) {
alert("Digite um ano D.C.");

} else if ( ((ano % 4 == 0) && (ano % 100 != 0)) || (ano
% 400 == 0)) {
alert(ano + " é bissexto!");

} else {
alert(ano + " não é bissexto!");
}

58


if... else (cont.)

 A operação do if...else pode ser realizada também de uma forma
mais compacta (e geralmente menos legível) através do operador
condicional. A sua sintaxe é:
• expressão ? instruções se expressão=true : instruções se expressão=false

strValor= document.forms[0].sabeJogar.value;
boolIsJogador= strValor==‘SIM’ ? true : false;
/* e o mesmo que:
if (strValue==‘Sim’) {
boolIsJogador= true;
} else {
boolIsJogador= false;
}
*/

59


for

 As estruturas for são usadas para repetições baseadas em
condições.
 O bloco for contém de três parâmetros opcionais: uma
inicialização, uma condição e um incremento.
 A sintaxe é a seguinte:

for(inicialização; condição; incremento) {
// instruções a serem realizadas enquanto
condição for true
}

60


for (cont.)

 Exemplo:
for (i = 0; i < 10; i = i + 1) {
document.write("<p>Linha " + i);
}

 Neste exemplo, a variável i é local ao bloco for (ela não é
conhecida fora do bloco).
 Para que ela seja visível fora do bloco é preciso que ela seja
declarada fora dele.

61


for (cont.)

 O mesmo for pode ser escrito desta forma:
i = 0;
for ( ; i < 10; ) {
i++;
}

 A única diferença entre esta forma e a anterior é que a variável i
agora é visível fora do bloco for.

62


for (cont.)

 Uma instrução do tipo, no entanto:
for ( ; ; ) {
document.write("<p>Linha");
}

 Isto gera um loop infinito!
 Isso trava o browser!

63


while

 A estrutura while é executada enquanto uma condição for true:
inicialização;
while(condição) {
// instruções a serem realizadas enquanto
condição for true
incremento;
}

 O incremento acima é apenas um exemplo de aplicação do while,
visto que ele não precisa necessariamente ser usado em
computações com contadores.

64


while (cont.)

 Exemplos:
i = 0
while (i < 10) {
i++;
}

i = 0
while (i != 1) {
Math.floor(Math.random()*10)
}

65


break e continue

 Para sair a força de loops existem as instruções break e continue.
 A instrução break sai da estrutura de loops e prossegue com a
instrução seguinte.
 A instrução continue deixa a execução atual do loop e reinicia
com a passagem seguinte.

 Vejamos o exemplo no próximo slide...

66


break e continue (cont.)

function leiaRevista() {
while (!terminado) {
passePagina();
if (alguemChamou) {
break;
// caia fora deste loop (pare de ler)
}
if (paginaDePropaganda) {
continue;
// pule esta iteração (pule a pagina e nao leia)
}
leia();
}
...

67


for... in e with

 As estruturas for...in e with são exclusivas do JS e servem para
manipulação de propriedades de objetos.

 Visto que mais a frente faremos uma melhor apresentação do
modelo de objetos do JS, veremos estas instruções com mais
calma em breve.

68


Episódio 3 - Funções e Objetos

 Funções nativas
 Funções definidas pelo usuário
 Objetos
• Construtores e o operador “new”
• Propriedades
• Métodos
 Criação de novos tipos de objetos
• for... in
• Referências e propriedades de propriedades
 Modelo de objetos do HTML
 Acesso a objetos do browser e da página
• Estruturas e operadores utilizados com objetos
– this
– typeof
– constructor
– void
– delete

69


Funções nativas

 O JS possui 6 funções nativas.
 Essas funções permitem realizar tarefas úteis e podem ou não
retornar algum valor, recebendo como parâmetros com os dados
sobre os quais devem operar. Por exemplo, o código abaixo:
ano = parseInt("1997");

 Chama parseInt() passando o string "1997" como argumento.
 A função parseInt() retorna um valor (tipo number) que atribuímos
à variável ano.
 Se o valor passado não for conversível em número, parseInt()
retorna o valor NaN (não é um número).

70


Funções nativas (cont.)

 Se uma função não retorna valor ou se não interessa guardar o
valor de retorno, pode-se simplesmente chamá-la sem atribuí-la a
qualquer variável.
 A função abaixo, simplesmente executa o código JS que recebe
como argumento:
eval("alert('Meeengoool!')");

71



 Além das 6 funções nativas, há
muitos outros procedimentos na
linguagem.
 A grande maioria, porém, não
são rigorosamente funções,
mas métodos - tipo especial de
função associada a um objeto
específico.

72



Função O que faz
parseInt(string) Converte uma representação String de um número na sua representação Number.
ou Ignora qualquer coisa depois do ponto decimal ou depois de um caractere que não
parseInt(string, base) é número. Se primeiro caractere não for número, retorna NaN (Not a Number).
A base é a representação do String (2, 8, 10, 16)
parseFloat(string) Converte uma representação String de um número na sua representação Number,
levando em consideração o ponto decimal.
Ignora qualquer coisa depois do segundo ponto decimal ou depois de um caractere
que não é número.
Se primeiro caractere não for número ou ponto decimal, retorna NaN
isNaN(valor) Retorna true se o valor passado não é um número.
eval(string) Interpreta o string passado como parâmetro como código JavaScript e tenta
interpretá-lo.
eval() é uma função que oferece acesso direto ao interpretador JavaScript.
Exemplo: resultado = eval("5 + 6 / 19");
escape(string) Converte caracteres de 8 bits em uma representação de 7 bits compatível com o
formato url-encoding. Útil na criação de cookies.
Exemplo: nome = escape("João"); // nome contém Jo%E3o
unescape(string) Faz a operação inversão de escape(string).
Exemplo: nome = unescape("Jo%E3o"); // nome contém João

73


Funções definidas pelo usuário

 Como já vimos, JS permite ao usuário criar suas próprias funções.
 O identificador da função deve vir seguido de um par de
parênteses e, entre eles, opcionalmente, uma lista de parâmetros,
separados por vírgulas.
 A implementação (seqüência de instruções) da função deve vir
dentro de um bloco entre chaves “{“ e “}”.
function nomeDaFunção (param1, ..., paramN) {
... implementação ...
}

74


Funções definidas pelo usuário (cont.)

 Para retornar um valor, é preciso usar uma instrução return:
function soma (a, b) {
return a + b;
//soma e retorna os argumentos a e b
}

 Funções não precisam ter argumentos ou retornar valores,
podendo apenas executar procedimentos úteis para a página.
function oi () { alert(‘oi!’); }

75



 Os parâmetros têm um escopo local ao bloco da função e não são
visíveis fora dele.
 Variáveis utilizadas dentro da função podem ser locais ou não.
 Para garantir que o escopo de uma variável seja local a uma
função, é necessário declará-las locais usando var
x = 60; // este x é global
function soma(a, b) {
// a e b são locais (porque são argumentos)
var x = a; // este x é uma variável local
var y = b;
return x + y;
}

76



 Identificadores utilizados para nomes de função são propriedades
do contexto onde foram definidos.
 Não pode haver uma variável global com o mesmo nome que uma
função. O uso do identificador de uma função (sem os parênteses
ou argumentos) como argumento de uma atribuição, copia a
definição da função para outra variável. Por exemplo:
sum = soma;

 ...copia a definição da função soma() para a variável sum, que
agora é uma função. sum pode então ser usada como função:
resultado = sum(25, 40);

77



 Função para descontrair...

function starWars() {
/* the */ return “of Jedi”;
}

78


Objetos

 A maior parte da programação em
JS é realizada através de objetos.
 Um objeto é uma estrutura mais
elaborada que uma simples
variável que representa tipos
primitivos.
 Variáveis podem conter apenas
um valor de cada vez. Objetos
podem conter vários valores, de
tipos diferentes, ao mesmo
tempo.
 Um objeto é, portanto, uma
coleção de valores.

79


Objetos (cont.)

 Suponha que usemos as variáveis abaixo para uma data:
dia= 27; mes= “Fevereiro”; ano= 2006;

 Suponha agora que temos que realizar operações com 101 datas!

BALAIO DE GATO!

80


Objetos (cont.)

 Para fazer isto, teríamos que criar
nomes significativos para cada
grupo de dia, mês, ano e evitar
que seus valores se misturassem.
 A solução para isso é usar um
objeto, que trate cada coleção de
dia, mês e ano como um grupo.

dtaCarnaval.dia = 27;
dtaCarnaval.mes = “Fevereiro”;
dtaCarnaval.ano = 2006;

81


Objetos (cont.)

 As variáveis que armazenam objetos são do tipo object.
 Se uma propriedade tem o tipo object, ela também pode ter suas
próprias propriedades e assim formar uma hierarquia de objetos
interligados pelas propriedades:
dataHoje.agora.minuto = 59;
// agora: objeto que representa uma hora

82


Objetos (cont.)

 Os tipos primitivos em JS assumem um papel duplo, se
comportando ora como tipo primitivo - com apenas um valor, ora
como objeto - tendo o seu valor armazenado em uma
propriedade.
 O programador não precisa se preocupar com os detalhes dessa
crise de identidade das variáveis JS, pois a conversão objeto -
tipo primitivo e vice-versa é totalmente transparente.
var nome= “Bruno Grange”;
tamanhoNome= nome.length
primeiroNome= nome.substr(0, 5)

83


Construtores e o operador “new”

 Para criar novos objetos é preciso usar um construtor.
 O construtor é uma função especial associada ao tipo do objeto
que define todas as características que os objetos criados terão.
 O construtor cria um novo objeto quando chamado através do
operador new.

Variável do tipo object que armazena um objeto Date Chama a função
Date()
(construtor) que
dataViagem = new Date(2006, 02, 27); retorna as
informações
necessárias
para criar o
Utiliza as informações retornadas por Date() para criar o objeto. objeto.

84


Construtores e o operador “new” (cont.)

 Os tipos de objetos nativos Object, Number, String, Boolean,
Function, Date e Array possuem os construtores definidos em JS.
 Os construtores são funções globais e devem ser chamadas
através do operador new para que um objeto seja retornado.
 A tabela abaixo relaciona os construtores nativos do JS.

Construtor Tipo de objeto construído
Object() Constrói objeto genérico do tipo Object. Dependendo do
Object(valor) tipo do valor primitivo passado, o resultado pode ainda
ser um objeto String, Number ou Boolean.
Number() Constrói um objeto do tipo Number com valor inicial zero,
Number(valor) se for chamada sem argumentos ou com o valor
especificado.
Boolean() Constrói um objeto do tipo Boolean com valor inicial false,
Boolean(valor) se for chamada sem argumentos ou com o valor
especificado.

85



Construtor Tipo de objeto construído
String() Constrói um objeto do tipo String com valor inicial "", se
String(valor) for chamada sem argumentos ou com o valor
especificado.
Array() Constrói um objeto do tipo Array, que representa uma
Array(tamanho) coleção ordenada (vetor) de tamanho inicial zero ou
Array(elem1, elem2, ..., elemn) definido através de parâmetro.
Function() Constrói um objeto do tipo Function com corpo da função
Function(corpo) vazio, com uma string contendo o código JavaScript
Function(arg1, arg2, ..., corpo) que compõe o corpo da função, e com argumentos.
Date() Constrói um objeto do tipo Date. O primeiro construtor
Date(ano, mes, dia) constrói um objeto que representa a data e hora
Date(ano, mes, dia, atuais. Os outros são formas diferentes de construir
hora, min, seg) datas no futuro ou no passado.
Date(string) Date(milissegundos)

86



 Tipos primitivos podem assumir o papel de objetos.
 A conversão é feita automaticamente, contudo, também pode ser
feita explicitamente através de um construtor.

 Exemplo:
//tipo primitivo
n = 13;

//objeto
m = new Number(13);

87


Propriedades

 Cada objeto possui uma coleção propriedades.
 Essas propriedades podem ser acessadas através do nome do
objeto seguido por um ponto ( . ), ou por um índice ou nomes
dentro de colchetes. ( [ ] ).

z = "Zebra";
// variável zebra é do tipo primitivo string ...
z [0] = true;
// ... Agora vira um objeto do tipo String
z [1] = "brancas";
// para que possa ter propriedades.
z [2] = 6;

88


Propriedades (cont.)

//pelo nome da propriedade entre colchetes
z ["domesticada"] = true;
z ["listras"] = "brancas";
z ["idade"] = 6;

//forma mais comum
//nome da propriedade precedida de um ponto
z.domesticada = true;
z.listras = "brancas";
z.idade = 6;

//acessando os valores
idadeDaZebra = z.idade;

89


Métodos

 As propriedades de um objeto podem conter tipos primitivos,
objetos ou funções.
 As funções são objetos do tipo Function.
 Funções que são associadas a objetos são chamadas de
métodos.
 Todos os objetos nativos do JS possuem métodos.
 Pode-se ter acesso aos métodos da mesma maneira que se tem
acesso às propriedades:
letra = z.charAt(0);
//método charAt(0) retorna "Z" (String)

90


Métodos (cont.)

 Para acrescentar um método ao objeto z, basta criar uma função
e atribuir o identificador da função a uma propriedade do objeto:
function falar() {
alert("Rinch, rinch!");
}
z.rinchar = falar;

 A instrução acima copia a definição de falar() para a propriedade
rinchar, de z.
 A propriedade rinchar agora é método de z, como vemos:
z.rinchar();

91


Criação de novos tipos de objetos

 A especificação de um novo tipo de objeto é útil quando
precisamos representar tipos de dados abstratos não disponíveis.
 Um novo tipo de objeto pode ser especificado simplesmente
definindo um construtor.
function Conta() { }

 A função Conta, acima, nada mais é que uma função comum.
 O que a transforma em construtor é como esta é chamada,
usando new.
 Tendo-se a função, é possível criar objetos com o novo tipo e
atribuir-lhes propriedades:

92


Criação de novos tipos de objetos (cont.)

 Exemplo:
cc1 = new Conta(); // cc1 é do tipo object
cc1.correntista = "Granjuxx";
cc1.saldo = 100.0;

 As propriedades correntista e saldo acima existem apenas no
objeto cc1, e não em outros objetos Conta. Isto porque foram
definidas como propriedades do objeto (como as propriedades
que definimos para z), e não do tipo de objeto.
 Se ela for definida dentro da definição do construtor Conta(),
valerá para todos os objetos criados com o construtor:

93



 Exemplo:
function Conta() {
this.correntista = "Não identificado";
this.saldo = 0.0;
}

 Agora todo objeto Conta terá propriedades iniciais definidas.
 A palavra-chave this é um ponteiro para o próprio objeto.
 Dentro do construtor, o objeto não tem nome. Quando o
construtor é invocado, this, que significa “este”, se aplica ao objeto
que está sendo criado .
 Contudo, desta forma, ainda não é muito simples inicializar os
valores para as propriedades dos objetos criados desta forma.

94



 Podemos usar this para criar um outro construtor, mais útil, que
receba argumentos:
function Conta(corr, saldo) {
this.correntista = corr;
this.saldo = saldo;
}

 Não há conflito entre a variável local saldo e a propriedade saldo
do objeto Conta pois elas existem em contextos diferentes. Com o
novo construtor, é possível criar contas da forma:
cc2 = new Conta("Granjuxx", 326.50);
cc1 = new Conta("Google", 100.0);

95



 Para definir métodos para o novo tipo, basta criar uma função e
copiá-la para uma propriedade do construtor, por exemplo:
function metodo1() {
document.write("Saldo: " + this.saldo");
}
function Conta(corr, saldo) {
this.correntista = corr;
this.saldo = saldo;
this.imprimeSaldo = metodo1;
}

96



 Agora qualquer objeto criado com o construtor Conta() possui um
método que imprime na página o valor da propriedade saldo:
cc3 = new Conta("", 566.99);
cc3.imprimeSaldo();

// imprime na página: “Saldo: 566.99”

97


for... in

 A estrutura for...in. pode ser usada para ler todas as propriedades
de um objeto, e extrair os seus valores. A sua sintaxe é:
for (variavel in nome_do_objeto) {
// declarações usando variavel
}

 ...onde variavel é o nome da variável que será usada para indexar
as propriedades do objeto. O bloco será repetido até não haver
mais propriedades.
 Em cada iteração, uma propriedade estará disponível em variavel
e seu valor poderá ser extraído usando vetores associativos, da
forma objeto[variavel].

98


for... in (cont.)

 Veja como exemplo a função abaixo, que retorna todas as
propriedades de um objeto:
function mostraProps(objeto) {
props = "";
for (idx in objeto) {
props += idx + " = " + objeto[idx] + "n";
}
return props;
}

99


Referências e propriedades de propriedades

 Propriedades podem ser definidas também como objetos, que por
sua vez podem conter outras propriedades.
 Os dois objetos abaixo possuem uma relação hierárquica: Um
Alvo contém um Circulo. É possível, através de um Alvo, ter
acesso e propriedades do Circulo que ele contém:
function Circulo(x, y, r) {
this.x = x; this.y = y; this.r = r;
}
function Alvo(circ) {
this.circ = circ;
}
c1 = new Circulo(3, 3, 6);
a1 = new Alvo(c1);

100


Referências e propriedades de propriedades (cont.)

 Os dois objetos acima possuem uma relação hierárquica: Um Alvo
contém um Circulo. É possível, através de um Alvo, ter acesso e
propriedades do Circulo que ele contém:
a1.circ.x = 20;
a1.circ.y = 10;

 As instruções acima alteram os valores do círculo do objeto a1, e
também os valores do círculo c1, que são o mesmo objeto!
 Isto acontece porque o Alvo foi criado usando um círculo já
existente, passado por referência e não por valor.

101


Modelo de objetos do HTML - DOM

 Dentro de um documento, a hierarquia de objetos e propriedades
JS reflete a hierarquia do HTML, através de um modelo de objetos
do documento (Document Object Model - DOM).
 O DOM relaciona cada elemento HTML, respeitando sua
hierarquia, a um objeto JS.

 Por exemplo, em HTML um bloco <INPUT TYPE="text"> está
relacionado a um objeto do tipo Text. Contudo, o elemento deve
estar dentro de um bloco <FORM>, representado por um objeto
do tipo Form, que por sua vez, deve estar dentro de um bloco
<BODY>, representado por um objeto do tipo Document.

102


Modelo de objetos do HTML - DOM (cont.)

103



 Ao lado vemos exemplos de
instâncias de um campo e um
botão no DOM, seguindo a
hierarquia do HTML.

 OBS: DOM signinifica Document
Object Model, e não tem nada a
ver com Domino Object Model.

104



 O objeto Window é o mais importante da hierarquia do browser.
 O tipo Window possui uma propriedade document que representa
a página HTML que está sendo exibida na janela.
 Todas as variáveis globais criadas em um programa JS em HTML
são propriedades temporárias do objeto Global.
<script>
var nome;
</script>
/* nome é propriedade de window, e pode ser utilizada na
página de duas formas: */
nome = "Sam";
window.nome = "Sam";

105


Acesso a objetos do browser e da página

 Cada componente de uma página define um objeto que poderá
ser manipulado em JS e agir como referência ao componente.
 Digamos que temos uma página com a imagem:
<IMG SRC="zebra.gif" name="figura3">

x = window;
// x é uma referência ‘Window’
y = x.document;
// window.document é ref. ‘Document’
z = y.figura3
// window.document.figura3 é ref. do tipo Image
z.src = "jegue.gif";
// src é propriedade (tipo String) de Image

106


Acesso a objetos do browser e da página (cont.)

 A expressão acima mostra como a hierarquia de elementos do
HTML se reflete em JS através de propriedades.
 Para ler propriedades ou invocar métodos de um objeto é
necessário citar toda a hierarquia de objetos acima dele.
 A única exceção à regra é a referência window, que sempre pode
ser omitida. As instruções abaixo fazem a mesma coisa:
window.document.write("Tigres");
document.write("Tigres");

107


Acesso a objetos do browser e da página (cont.)

 Quando criamos uma nova janela e queremos operar sobre ela,
podemos batizá-la com um nome qualquer que servirá de
referência para operações.
 Essa referência é um objeto do tipo Window:
janela2 = window.open("pagina2.html");
/* método open retorna referência do tipo Window que é
propriedade da janela atual (window) */
janela2.document.open();
janela2.document.write("Eu escrevo na Janela 2");

108


Manipulação de objetos

 Todos os objetos criados em HTML estão automaticamente
disponíveis em JS, mesmo que um nome não seja atribuído a
eles.
 Por exemplo, se há três blocos <FORM>...</FORM> em uma
página, há três objetos do tipo Form no JS.
 Se eles não tem nome, pode-se ter acesso a eles através da
propriedade ‘forms’ definida em Document, que fica armazenada
em um vetor, que sempre se inicia em 0 no JS.
frm1 = document.forms[0];
/* mesma coisa que window.document.forms[0], ou
document.meuForm, caso forms[0] seja meuForm */
frm2 = document.forms[1];

109


Manipulação de objetos (cont.)

 Os vetores são necessários apenas quando um objeto não tem
nome.
 Se tiver um nome, o ideal é usá-lo já que independe da ordem dos
componentes, e pode fornecer mais informações como por
exemplo, o tipo do objeto (é um botão, um campo de textos?):
texto = document.forms[0].elements[1];
// qual será o componente? O que será o componente?

110


Manipulação de objetos (cont.)

 Exemplo:
<form name="f1">
<input type=button name="botao1" value="Botão 1">
<input type=text name="campoTexto" value="Texto Muito
Velho">
</form>
texto = document.f1.campoTexto;
textoVelho = texto.value;
texto.value = "Novo Texto";
//ou
textoAntigo = document.f1.campoTexto.value;
document.f1.campoTexto.value = "Novo Texto";

111


Estruturas e operadores utilizados com objetos

 JS possui várias estruturas e operadores criados especificamente
para manipulação de objetos.
 Já vimos o uso do operador new, da estrutura for... in e da
referência this.
 Nesta seção conheceremos aplicações de this em HTML, a
estrutura with e os operadores typeof, constructor, void e delete.

112


this

 this é usada como referência ao objeto no qual se está operando.
 A palavra-chave this pode ser usada apenas quando se está
dentro de um objeto.
 Só usamos this dentro de funções construtoras e métodos.
 No caso dos objetos HTML, this só faz sentido quando é usada
dentro de um dos atributos de eventos (ONCLICK,
ONMOUSEOVER, HREF, etc.):
<input type=text onclick="alert(this.value)">

113


with

 with é uma estrutura especial eu permite agrupar propriedades de
objetos, dispensando a necessidade de chamá-las pelo nome
completo. Por exemplo, em vez de usar:
objeto.propriedade1 = 12;
objeto.propriedade2 = true;
objeto.propriedade3 = "informação";

 Usamos:
with(objeto) {
propriedade1 = 12;
propriedade2 = true;
propriedade3 = "informação"; }

114


typeof

 Uma das maneiras de identificar o tipo de um objeto, é através do
operator typeof.
 Este operador retorna um String que indica o tipo de dados
primitivo (object, number, string, boolean ou undefined) do
operando ou se é um objeto do tipo Function.
 A sintaxe é:
typeof operando
// ou typeof (operando)

115


typeof (cont.)

var coisa;
// typeof coisa: undefined
var outraCoisa = new Object();
// typeof outraCoisa: object
var texto = "Era uma vez...";
// typeof texto: string
var numero = 13;
// typeof numero: number
var hoje = new Date();
// typeof hoje: object
var c = new Circulo(3, 4, 5);
// typeof c: object
var boo = true;
// typeof boo: boolean

116


typeof (cont.)

 O operador typeof também retorna o tipo function para qualquer
tipo de procedimento, seja método, construtor ou função.
typeof Circulo // function
typeof eval // function
typeof document.write // function
typeof Document // function
typeof Window
// undefined (nao ha construtor p/ o tipo Window)
typeof window // object
typeof Math
// object (Math nao é tipo... é objeto)

117


constructor

 Uma forma mais precisa para identificar o tipo do objeto, é
identificar seu construtor.
 Toda a definição do construtor pode ser obtida através da
propriedade constructor, que todos os objetos possuem.
document.write(c.constructor.name);
// imprime Circulo
document.write(hoje.constructor.name);
// imprime Date
if (hoje.constructor == “Date") { ...

118


void

 O operador void é usado para executar uma expressão JS, mas
jogar fora o seu valor.
 É útil em situações onde o valor de uma expressão não deve ser
utilizado pelo programa.
 A sintaxe está mostrada abaixo (os parênteses são opcionais):
void (expressão);

119


void (cont.)

 Considere o exemplo abaixo. Suponha que a função que submete
o formulário enviaFormulario() retorne o texto “enviado”.
 Este valor poderia fazer com que a janela tentasse carregar uma
suposta página chamada “enviado”:
<a href="javascript: enviaFormulario()">
Enviar formulário</a>

 Para evitar que o valor retorno interfira no código, e ainda assim
executarmos a função, usamos void que descarta o retorno:
<a href="javascript: void(enviaFormulario())">
Enviar formulário</a>

120


delete

 O operador delete pode ser usado para remover objetos,
elementos de um vetor ou propriedades de um objeto.
 Não é possível remover variáveis declaradas com var ou
propriedades e objetos pré-definidos.
 A sintaxe é a seguinte:
delete objeto;
delete objeto.propriedade;
delete objeto[índice];

 Se a operação delete obtém sucesso, ela muda o valor da
propriedade para undefined.
 A operação retorna false se a remoção não for possível.

121


Episódio 4 - Objetos nativos embutidos

 O Objeto Global
 Object
 Number
 Boolean
 Function
 Prototype
 String
 Array
 Math
 Date

122


Resumo

 Os objetos nativos embutidos no JS fazem parte do núcleo da
linguagem.
 Eles não são fornecidos pelo browser, e, com exceção dos
objetos Global e Math, é necessário criá-los explicitamente para
poder usá-los.

G lo b a l

A r r a y O b j e c t B o o le a n N u m b e r S t r in g F u n c t io n D ate M ath
A rray() O b je c t () B o o le a n ( ) N u m b e r() S t r in g ( ) F u n c t io n ( ) D ate ()

123


O Objeto Global

 O objeto Global representa o contexto global de execução.
 Ele define a propriedade window, cujo valor é o próprio objeto
Global.

 Objetos de todos os tipos nativos embutidos podem ser criados
usando o operador new.

 A exceção é Math, que funciona apenas como repositório para
agrupar funções e constantes matemáticas utilitárias.

124


Global (cont.)

 Exemplo de Math - utilizamos da forma:
a = Math.random()*256;
// função que retorna valor aleatório
b = Number.MAX_VALUE;
// constante com maior número representável
c = Date.parse(34532343);
// converte milissegundos em uma data

125


Object

 Trata-se de um tipo de objeto genérico usado para representar
qualquer objeto criado com new.
 Seu construtor raramente é utilizado pelo programador JS.
 Existe basicamente para dar suporte a operações internas.

 Para criar um Object, pode-se fazer:
obj = new Object();

126


Object (cont.)

Método Ação

toString() Transforma qualquer objeto em uma representação
string. É usado automaticamente nas conversões
de números em strings, por exemplo, durante a
concatenação.

valueOf() Converte um objeto em seu valor primitivo, se houver.

assign(valor) Implementa o operador de atribuição (=).

127


Number

 É um tipo de objeto usado para representar números (tipo
primitivo number) como objetos.
 O número será transformado em objeto automaticamente quando
for necessário.
 Um objeto Number pode ser criado explicitamente usando new e
o construtor Number():
n = new Number(12);

128


Number (cont.)

Constante Significado

MAX_value Maior valor numérico representável: 4,94065e-324

MIN_value Menor valor numérico representável: 1,79769e+308

NaN Não é um número: NaN

NEGATIVE_INFINITY Infinito positivo: +Infinity

POSITIVE_INFINITY Infinito negativo: -Infinity

129


Boolean

 É um tipo de objeto usado para representar os literais true e false
como objetos.
 Um valor booleano é criado sempre que há uma expressão de
teste ou comparação sendo realizada, assim, todas as formas
abaixo criam objetos Boolean ou valores boolean:
boo = new Boolean("");
// 0, números < 0, null e "": false
boo = new Object(true);
boo = true;
boo = 5 > 4;

130


Function

 Um objeto Function representa uma operação JS, que pode ser
uma função, método ou construtor.
 Para criar um objeto deste tipo, basta definir uma nova função
com a palavra-chave function:
func = new Function("corpo_da_função"); // ou, ...
func = new Function(arg1, arg2, ..., argn,
"corpo_da_função");

 Considere a função a seguir:

131


Function (cont.)

function soma(calc) {
a=calc.v1.value;
b=calc.v2.value;
calc.v3.value=a+b;
}

 O código abaixo obtem o mesmo resultado, desta vez definindo
uma variável que representa o objeto:
soma = new Function(calc, "a=calc.v1.value;
b=calc.v2.value; calc.v3.value=a+b;");

132


Function (cont.)

 O resultado do uso de Function() acima é um código mais
complicado e difícil de entender que a forma usada anteriormente
com function.
 Também é menos eficiente, visto que as funções declaradas com
function são interpretadas toda vez que são chamadas.

 O objeto Function tem quatro propriedades que podem ser usadas
por qualquer função (tenha sido definida com function ou com new
Function()). São elas:

133


Function (cont.)

Propriedade Significado (tipo da propriedade em itálico)
arguments[] Array. O vetor de argumentos da função
arguments.length Number. O comprimento do vetor de argumentos (retorna o
número de argumentos que a função tem)
length Number. Mesma coisa que arguments.length
caller Function. Uma referência para o objeto Function que chamou
esta função, ou null se o objeto que a invocou não é uma
função. Só tem sentido quando uma função chama a outra. É
uma forma da função atual se referir àquela que a chamou.

prototype Object. Através desta propriedade, é possível definir novos
métodos e propriedades para funções construtoras, que
estarão disponíveis nos objetos criados com ela.

134


Prototype

 Já vimos como acrescentar propriedades temporárias a objetos.
 As propriedades podem ser permanentes se forem definidas
dentro do construtor do objeto, mas nem sempre temos acesso ao
construtor.
 Podemos criar novos métodos e propriedades e associá-las a um
construtor qualquer usando a sua propriedade prototype. Assim a
propriedade passa a ser permanente, e estará presente em todos
os objetos.

135


Prototype (cont.)

 Para acrescentar uma propriedade ao tipo Date, por exemplo,
podemos fazer:
Date.prototype.ano = d.getYear() + 1900;

 Agora todos os objetos criados com o construtor Date terão a
propriedade ano:
d = new Date();
document.write("Estamos no ano de: " + d.ano);

136


Prototype (cont.)

 Considere a função que iremos prototipar:
function bissexto(umAno) {
if (((umAno % 4 == 0) && (umAno % 100 != 0)) ||
(umAno % 400 == 0))
return true;
else
return false; }

 Podemos transformá-la em método. O primeiro passo é fazê-la
operar sobre os dados do próprio objeto.

137


Prototype (cont.)

function bissexto() { // método!
if(((this.ano % 4 == 0) && (this.ano % 100 != 0)) ||
(this.ano % 400 == 0))
return true;
else
return false;
}

 Agora basta atribuir a função a uma nova propriedade do protótipo
do objeto, que chamamos de isLeapYear:
Date.prototype.isLeapYear = bissexto;

138


Prototype (cont.)

 Chamando...
hoje = new Date();
if (hoje.isLeapYear())
document.write("O ano " + hoje.ano + " é
bissexto");
else
document.write("O ano " + hoje.ano + " não é
bissexto");

139


String

 O tipo String existe para dar suporte e permitir a invocação de
métodos sobre cadeias de caracteres, representadas pelo tipo
primitivo string.
 Pode-se criar um novo objeto String fazendo:
s = new String("string");

 ou simplesmente:
s = "string";

140


String (cont.)

 Objetos String possuem apenas uma propriedade: length, que
pode ser obtida a partir de qualquer objeto string e contém o
comprimento da cadeia de caracteres:
cinco = "zebra".length;
seis = s.length;

 Além dessas propriedades, ainda existem os seguintes métodos:

141


String (cont.)

Método Chamado Retorna
anchor("âncora") <a name="âncora">Texto</a><>
link("http://a.com") <a href="http://a.com">Texto</a>

small() <small>Texto</small>
big() <big>Texto</big>
blink() <blink>Texto</blink>
strike() <strike>Texto</strike>
sub() <sub>Texto</sub>
sup() <sup>Texto</sup>
italics() <i>Texto</i>
bold() <b>Texto</b>
fixed() <tt>Texto</tt>
fontcolor("cor") <font color="cor">Texto</font> (cor pode ser um valor rrggbb hexadecimal ou
nome de cor)
fontsize(7) <font size="7">Texto</font> (o número representa o tamanho e pode ser um
número de 1 a 7)

142


String (cont.)

 Os dois métodos a seguir realizam transformações no formato dos
caracteres. São extremamente úteis em comparações e rotinas de
validação. Retornam String.

Método Chamado Retorna

toLowerCase() texto (converte para caixa-baixa)

toUpperCase() TEXTO (converte para caixa-alta)

143


String (cont.)

 Os métodos seguintes realizam operações baseados nos
caracteres individuais de uma string.
 Permitem, por exemplo, localizar caracteres e separar tokens com
base em delimitadores.
 Não afetam os strings originais.
Método Chamado Ação (tipo de retorno em itálico)
charAt(n) String. Retorna o caractere na posição n. A string s inicia na
posição 0 e termina em s.length–1. Se for passado um
valor de n maior que s.length-1, o método retorna uma
string vazia.
indexOf("substring") Number. Retorna um índice n referente à posição da
primeira ocorrência de "substring" na string s.
indexOf("substring", Number. Retorna um índice n referente à posição da
inicio) primeira ocorrência de "substring" em s após o índice
inicio. inicio é um valor entre 0 e s.length-1

144


String (cont.)

Método Chamado Ação (tipo de retorno em itálico)
lastIndexOf("substring") Number. Retorna um índice n referente à posição da última
ocorrência de "substring" na string s.
lastIndexOf("substring", fim) Number. Retorna um índice n referente à posição da última
ocorrência de "substring" em s antes do índice fim. fim é
um valor entre 0 e s.length-1
split("delimitador") Array. Converte o string em um vetor de strings separando-
os pelo "delimitador" especificado. O método join() de
Array faz o oposto.
substring(inicio, fim) String. Extrai uma substring de uma string s.
• inicio é um valor entre 0 e s.length-1.
• fim é um valor entre 1 e s.length.
O caractere na posição inicio é incluído na string e o
caractere na posição fim não é incluído. A string
resultante contém caracteres de inicio a fim -1.

145


String (cont.)

 O método split(), que retorna um objeto do tipo Array, é uma
forma prática de separar um texto em tokens, para posterior
manipulação. Por exemplo, considere o string:
data = "Sexta-feira, 13 de Agosto de 2006";

 Fazendo:
sexta = data.split(","); // separa pela vírgula

 Obtemos:
sexta[0] = "Sexta-feira" e sexta[1] = "13 de Agosto de 2006".

146


String (cont.)

 Separamos agora o string sexta[1], pelo substring " de " :
diad = sexta[1].split(" de "); // separa por |de|

 obtendo diad[0] = 13, diad[1] = Agosto, diad[2] = 2006. Podemos
agora imprimir uma frase:
[1] = diad[1].substring(0,3); // diad[1] é “Ago”
document.write("Válido até " + diad[0] + "/" + diad[1] +
"/" + diad[2]);

Válido até 13/Ago/1999

147


Array

 O tipo Array representa coleções de qualquer tipo, na forma de
vetores ordenados e indexados.
 Para criar um novo vetor, é preciso usar o operador new e o
construtor Array():
direcao = new Array(4);

148


Array (cont.)

 Vetores começam em 0 e terminam em length–1.
 length é a única propriedade do tipo Array, e contém um número
com o comprimento do vetor.
 Os elementos do vetor são acessíveis através de índices
passados entre colchetes ([ e ]).
x = direcao[2];
/* copia o conteúdo do terceiro elemento do vetor
direcao para a variavel x */

149


Array (cont.)

 O vetor pode ser povoado de mais de várias maneiras.
 Uma das formas é definir seus termos um a um:
direcao[0] = "Norte"; direcao[1] = "Sul";
direcao[2] = "Leste"; direcao[3] = "Oeste";

 Ou:
direcao = new Array("Norte","Sul","Leste","Oeste");

 Ou:
direcao = “Norte,Sul,Leste,Oeste”.split(“,”);

150


Array (cont.)

 Para recuperar o tamanho do vetor, usa-se a propriedade length
que também pode ser redefinida com valores maiores ou menores
para expandir ou reduzir o vetor:
tamanho = direcao.length;
// direcao possui 4 elementos

direcao.length--;
// agora só possui 3

direcao.length++;
// possui 4 de novo, mas o último é undefined

151


Array (cont.)

 Não é possível ter índices avulsos.
 Se uma propriedade de índice 6 for definida:
direcao[6] = "Centro";

 o novo vetor direcao será atualizado e passará a ter 7 elementos,
que terão os valores:

("Norte","Sul","Leste","Oeste",undefined,
undefined,"Centro")

152


Array (cont.)

Método Ação
join() ou join("separador") Retorna String. Converte os elementos de um vetor em uma
string e os concatena. Se um string for passado como
argumento, o utiliza para separar os elementos concatenados.

reverse() Array. Inverte a ordem dos elementos de um vetor. Tanto o vetor
retornado, quanto o vetor no qual o método é chamado são
afetados.
sort() Array. Ordena os elementos do vetor com base no código do
caractere. Tanto o vetor retornado, quanto o vetor no qual o
método é chamado são afetados.
sort(função_de_ordenação()) Array. Ordena os elementos do vetor com base em uma função
de ordenação. A função deve tomar dois valores a e b e deve
retornar:
• Menor que zero se a < b
• Igual a zero se a = b
• Maior que zero se a > b

153


Array (cont.)

 O método join() tem várias aplicações, principalmente quando
usado em conjunto com o método split(), de String.
 Uma aplicação é a conversão de valores separados por
delimitadores em tabelas HTML:
dados = "Norte; Sul; Leste; Oeste"; // String
vetor = dados.split("; ");
s = "<tr><td>";
s += vetor.join("</td><td>");
s += "</td></tr>";
document.write("<table border>" + s + "</table>");

154


Array (cont.)

 Qualquer tipo de dados pode ser contido em vetores.
 Vetores multidimensionais podem ser definidos como vetores de
vetores. Veja um exemplo:
uf = new Array(
new Array("São Paulo", "SP"), new Array("Paraíba", "PB"));
// uf[0] é o Array ("São Paulo", "SP")
// uf[1][1] é o String "PB"

155


Math

 O objeto Math não é um tipo de objeto, e sim uma propriedade
global read-only, servindo apenas de repositório de constantes e
funções matemáticas.
 Para ter acesso a suas funções e constantes, deve-se usar a
sintaxe:
Math.função();
Math.constante;

156


Math (cont.)

Funções Constantes
acos(x) cosseno-1 abs(x) absoluto E e
asin(x) seno-1 max(a, b) máximo LN10 ln 10
atan(x) tangente-1 min(a, b) mínimo LN2 ln 2
atan2(x, y) retorna o pow(x, y) xy LOG10E log10 e
ângulo q de um ponto (x,y)
sin(x) seno LOG2E log2 e
ceil(x) arredonda para round(x) arredonda PI p
cima (3.2 e 3.8  4) (3.49  3 e 3.5  4)
SQRT1_2 1/sqrt(2)
cos(x) cosseno tan(x) tangente SQRT2 sqrt(2)
exp(x) ex sqrt(x) raiz quadrada
floor(x) arredonda para log(x) logarítmo
baixo (3.2 e 3.8  3) natural
random() retorna um número pseudo-aleatório
entre 0 e 1.

157


Math (cont.)

 Exemplo:
function cos() {
a = parseInt(document.f1.val1.value) * (Math.PI /
180);
document.f1.val1.value = Math.cos(a);
}

158


Date

 O tipo Date é um tipo de objeto usado para representar datas.
 Para criar data que represente a data e hora atuais, chame-o
usando new, da forma:
aquiAgora = new Date();

159


Date (cont.)

 Além da data e hora atuais, Date é usado para representar datas
arbitrárias. Para representar uma data e hora específica, pode-se
usar funções ou um de seus construtores:
new Date(ano, mes, dia);
// Ex: aDia = new Date(06, 07, 29);

new Date(ano, mes, dia, hora, minuto, segundo);
// Ex: bDia = new Date(06, 02, 27, 23, 59, 59);

new Date(Data em string: "Mes dd, aa hh:mm:ss");
// Ex: cDia = new Date("February 27, 06 23:59:15");

new Date(milissegundos desde 0:0 de 01/01/1970);
// Ex: dDia = new Date(86730923892832);

160


Date (cont.)

Método Ação
getDate() Retorna Number. Recupera o dia do mês (1 a 31)
getDay() Number. Recupera o dia da semana (0 a 6)
getHours() Number. Recupera a hora (0 a 23)
getMinutes() Number. Recupera o minuto (0 a 59)
getMonth() Number. Recupera o mês (0 a 11)
getSeconds() Number. Recupera o segundo (0 a 59)
getTime() Number. Recupera a representação em milissegundos
desde 1-1-1970 0:0:0 GMT
getTimezoneOffset() Number. Recupera a diferença em minutos entre a data
no fuso horário local e GMT (não afeta o objeto no qual
atua)

161


Date (cont.)

Método Ação
getYear() Number. Recupera ano menos 1900 (1997  97)
setDate(dia_do_mês) Acerta o dia do mês (1 a 31)
setHours(hora) Acerta a hora (0 a 23)
setMinutes(minuto) Acerta o minuto (0-59)
setMonth(mês) Acerta o mês (0-11)
setSeconds() Acerta o segundo (0-59)
setTime() Acerta a hora em milissegundos desde 1-1-1970 0:0:0
GMT
setYear() Acerta o ano (ano – 1900)
toGMTString() String. Converte uma data em uma representação GMT
toLocaleString() String. Converte a data na representação local do sistema

162


Date (cont.)

Função Ação
parse(string) Retorna Date. Converte uma data do sistema no formato
IETF (usado por servidores de email, servidores HTTP,
etc.) em milisegundos desde 1/1/1970 0:0:0 GMT
(UTC). O valor de retorno pode ser usado para criar
uma nova data no formato JavaScript. Exemplo:
DataIETF = "Wed, 8 May 1996 22:44:53 –0200";
umaData = new Date(Date.parse(DataIETF));

UTC() Retorna Number. Converte uma data no formato UTC
separado por vírgulas para a representação em
milisegundos:
Date.UTC(ano, mês, dia [, horas[, minutos[, segundos]]]);
Exemplo:
millis = Date.UTC(75, 11, 13, 23, 30);

163


Episódio 5 - As janelas do browser

 O tipo Window
 Janelas de diálogo
 Métodos para manipular janelas
 Janelas com aparência personalizada
 Eventos
 Comunicação entre janelas
 Frames HTML
 Frames em JS

164


O tipo Window

 O tipo Window representa janelas.
 A propriedade global window representa a janela do browser onde
roda o script. Através de window, têm-se acesso a outras
propriedades que referenciam possíveis sub-janelas, a janela que
a criou (se existir) ou frames.
 As propriedades e métodos de Window, quando referentes à
janela atual (objeto window), podem omitir o nome do objeto:
window.status = "oye!";
// ou status = "oye!";
window.open("documento.html");
// ou open("documento.html");

165


O tipo Window (cont.)

Propriedade Acesso Função

defaultStatus r/w Contém String. Texto que aparece por default na barra de status da
janela.

status r/w Contém String. Define texto que aparecerá na barra de status.

name r/w Contém String. Contém nome da janela. Este nome é utilizável em
HTML no atributo TARGET em <A TARGET="nome"> e em
<BASE TARGET="nome">. Em frames, retorna uma referência
Window.

document r Contém Document. Referência à página contida na janela.

history r Contém History. Referência ao histórico da janela.
location r Contém Location. Referência à URL exibida na janela.

166


O tipo Window (cont.)

Propriedade Acesso Função
opener r Contém Window. Refere-se a janela que abriu esta janela
self r Contém Window. Referência à própria janela. Mesmo que window
window r Contém Window. Sinônimo de self.
frames r Contém Array de Window. Vetor dos frames contidos na janela.
length r Contém Number. Número de elementos Window no vetor frames
(mesma coisa que window.frames.length)
parent r Contém Window. Referência à janela que contém esta janela (só
existe quando a janela atual é um frame)
top r Contém Window. Referência à janela que não é frame que contém a
janela atual (só existe quando a janela atual é um frame)

167

Minicurso de JavaScript (Portuguese)

Minicurso de JavaScript (Portuguese)

Mais conteúdo relacionado

Minicurso de JavaScript (Portuguese)