Asp3 PDF

Sumário
CRIANDO SITES
DINÂMICOS COM
ASP 3.0
Júlio Battisti
I
Criando Sites Dinâmicos com ASP 3.0
Copyright © 2000 by Júlio Battisti

Copyright © 2000 by Axcel Books do Brasil Editora Ltda.
Nenhuma parte desta publicação poderá ser reproduzida sem autorização

prévia e escrita de Axcel Books do Brasil Editora.
Editora de Produção: Gisella Narcisi

Editor Responsável: Ricardo Reinprecht

Júlio Battisti
ISBN: 85-7323-141-6
Suporte Técnico ao Leitor

Limite de garantia: Nosso suporte técnico limita-se ao conteúdo específico do livro,
e não a questões gerais referentes ao(s) software(s) descrito(s), cessando caso esta
publicação tenha sido esgotada. Para obter esse suporte técnico específico,
o leitor deve informar título, autor e página, somente via e-mail.
Todos os originais de livros enviados para avaliação pela Editora serão destruídos,
caso não sejam aprovados. Não será feita sua devolução em nenhuma hipótese.
Os conceitos emitidos nesta obra são de inteira responsabilidade do Autor.
E-mail:
editora@axcel.com.br
Visite nossa Home Page
http://www.axcel.com.br
Axcel Books do Brasil Editora

Av. Paris, 571 – Bonsucesso
21041-020 – Rio de Janeiro – RJ
Tel. (21) 2564-0085
II
Sumário
Créditos
Produção
Alexandre Ramires
Carlos Alberto Sá Ferreira
Revisão
Vanessa Garcia
Arte e Diagramação
Ingo Bertelli
Supervisor de Produção
Carlos Alberto Sá Ferreira
Capa
Ingo Bertelli
Editora de Produção
Gisella Narcisi
Editor Responsável
Ricardo Reinprecht
III
Agradecimentos
Embora este seja o meu segundo livro, a emoção e a satisfação de concluir mais esse trabalho
é talvez até maior do que no lançamento do primeiro. Foram meses de trabalho árduo,
escrevendo capítulos entre uma viagem e outra. Felizmente conseguimos concluir esse livro
no tempo estimado. E o principal é que saiu conforme o planejado. Penso que esse livro pode
ajudar bastante aqueles que querem aprender a tecnologia ASP, e até mesmo programadores
mais experientes.
No entanto, um trabalho como este não pode ser realizado sem que várias pessoas contribuam,
formando uma verdadeira equipe. Devo citar e agradecer, mais uma vez, a paciência, o amor, a
dedicação e o apoio de minha esposa Lu, diante de mais este desafio. Sei que não foi fácil ficar ao
meu lado, um final de semana após o outro, apenas escutando o barulho das teclas do computador.
Sem o seu apoio e compreensão, tudo seria muito mais difícil, para não dizer impossível. Prometo
que o próximo trabalho terá somente umas 200 páginas.
Gostaria também de agradecer o amor e apoio da minha mãe – Dona Lucy. Pessoa que sempre
me incentivou, apoiou, acreditou no meu trabalho e fez despertar em mim o amor pelos
livros. Mãe, mais uma vez agradeço por tudo o que fizestes e continuas fazendo por mim.
Agradeço mais do que tudo, o amor que sempre me deste, fazendo com que eu crescesse com
a certeza de estar sendo amado e querido.
Também quero agradecer a equipe da Axcel Books, pela sua paciência em corrigir e revisar
mais este trabalho, sempre com sugestões para a melhoria do mesmo, de tal forma que o
amigo leitor possa obter uma obra de qualidade.
Devo citar ainda minhas irmãs: Rose, Lacy e Sandra que sempre renovam minhas forças com
seus elogios sinceros e verdadeiros. Os momentos que passamos juntos, embora poucos, são
verdadeiros e profundos. Uma simples conversa, um almoço, um passeio; são momentos de
parada e reflexão. Momentos que nos mostram o quanto a vida vale a pena. Espero podermos
passar mais tempo juntos.
IV
Sumário
Sobre o Autor
Júlio Battisti é profissional certificado da Microsoft, tendo sido aprovado em 16 Exames da
Microsoft, com os quais obteve certificações como: MCP, MCP+I, MCSE, MCSE+I e MCDBA.
É Gerente de rede na Secretaria da Receita Federal, e conhece a tecnologia ASP desde sua
primeira versão. Também é autor de artigos de informática e trabalha com o desenvolvimento
e administração de Web sites. Autor do livro: “Série Curso Básico & Rápido Microsoft Windows
2000 Server”, publicado pela Editora Axcel Books. Atua como instrutor de cursos de
informática na Secretaria da Receita Federal, em outros cursos particulares e também para
turmas em Universidades.
V
VI
Sumário
Sumário
Introdução ........................................................................................................................................ 1
Sites Dinâmicos com ASP 3.0 ......................................................................................................... 1
Equipamento e Software Necessário ............................................................................................... 3
Instalando e Testando o IIS 5.0 ........................................................................................................ 4
Novidades e Melhorias do IIS 5.0 .................................................................................................. 10
Administração e Serviços .............................................................................................................. 11
Desenvolvimento de Aplicações Internet/Intranet ................................................................. 12
É Hora de Começar ......................................................................................................................... 13
Visão Geral dos Capítulos do Livro ........................................................................................ 13
Então, “Mãos à obra” ............................................................................................................... 14
Capítulo 1 – Uma Introdução à Tecnologia ASP ......................................................................... 15
Era uma Vez uma Internet com Conteúdo Estático ....................................................................... 16
Um Começo Quase sem Querer .............................................................................................. 16
Uma Visão Geral da Internet e de Seus Elementos ................................................................ 17
Conteúdo Dinâmico na Internet .................................................................................................... 19
A Era do Comércio Eletrônico ....................................................................................................... 23
Aplicações Para a Web ................................................................................................................... 29
A Complexidade de Gerenciamento do Modelo
Cliente/Servidor e Aplicações em Duas Camadas .................................................................. 29
Aplicações em Duas Camadas ................................................................................................ 30
Aplicações em Três Camadas ................................................................................................. 31
Aplicações em Quatro Camadas ............................................................................................. 33
Questões a Considerarmos nos Modelos em Três ou Mais Camadas .................................... 34
O que é ASP? .................................................................................................................................. 35
Preparando o Servidor Para Acompanhar os Exemplos ................................................................ 37
Criando a Estrutura de Pastas e Subpastas ............................................................................. 37
Tornando a Pasta Livro Parte dos Servidor IIS ....................................................................... 38
Alguns Exemplos Práticos ...................................................................................................... 44
O Tradicional “Hello World” ................................................................................................... 44
Um Exemplo de Página Dinâmica .......................................................................................... 48
Capítulo 2 – Uma Introdução ao VBScript .................................................................................. 53
Introdução ...................................................................................................................................... 54
O que é VBScript ............................................................................................................................ 54
Uma Revisão Rápida de HTML...................................................................................................... 56
Estrutura Básica de uma Página HTML .................................................................................. 56
Tags Para a Criação de Formulários HTML ............................................................................. 60
Criando o Formulário – a tag <FORM> </FORM> ....................................................... 60
Criando uma Caixa de Texto – a Tag <INPUT TYPE=“TEXT”> ................................... 62
Criando uma Caixa de Texto Para a Digitação
de Senhas – a tag <INPUT TYPE=“PASSWORD”> ....................................................... 64
Criando um “Check Box” – a tag <INPUT TYPE=“CHECKBOX”> ............................... 66
VII
Criando um Conjunto de “Radio Buttons” – a tag <INPUT TYPE=“RADIO”> ............ 68

Criando um Campo Para Digitação de Comentários
e Textos Maiores – a tag <TEXTAREA> </TEXTAREA> .............................................. 70
Criando uma Lista de Opções (Caixa de Combinação) – a tag
<SELECT></SELECT> em Combinação com <OPTION></OPTION> .................... 72
Finalizando o Formulário com os Botões Enviar Dados e Limpar Dados
– as Tags <INPUT TYPE=“SUBMIT”> e <INPUT TYPE=“CLEAR”> ......................... 75
Declaração e Utilização de Variáveis no VBScript ........................................................................ 78
O que é uma Variável ? ........................................................................................................... 78
Inserindo Código VBScript ..................................................................................................... 78
Declaração e “Tipo” de Variável .............................................................................................. 79
Fazendo Cálculos e Comparações com o VBScript – Operadores ................................................ 83
Fazendo Cálculos com os Operadores Aritméticos ................................................................ 83
Comparando Valores com os Operadores de Comparação .................................................... 87
O Escopo das Variáveis, no VBScript ............................................................................................ 91
Estruturas Para Controle de Fluxo em VBScript ........................................................................... 95
Estruturas de Decisão .............................................................................................................. 95
A Estrutura If...Then ........................................................................................................ 96
A Estrutura If...Then...Else ............................................................................................... 96
A Estrutura If...Then...ElseIf...Else ................................................................................... 97
A Estrutura Select...Case .................................................................................................. 99
Estruturas de Repetição ........................................................................................................ 100
A Estrutura For...Next ..................................................................................................... 100
A Estrutura Do...Loop ..................................................................................................... 102
A Estrutura Do While Condição...Loop ......................................................................... 102
A Estrutura Do... Loop While Condição ........................................................................ 103
A Estrutura Do Until Condição...Loop .......................................................................... 106
A Estrutura Do... Loop Until Condição ......................................................................... 107
Conclusão ..................................................................................................................................... 110
Capítulo 3 – Funções, Procedimentos e Eventos com VBScript ................................................ 111
Tipos de Dados e Funções Para Conversão de Tipos ................................................................... 112
Determinando o Tipo de Dados Contido em uma Variável .................................................. 112
A Função IsArray ............................................................................................................ 113
A Função VarType ........................................................................................................... 115
A Função IsDate .............................................................................................................. 118
A Função IsEmpty .......................................................................................................... 121
A Função IsNull .............................................................................................................. 122
A Função IsNumeric ....................................................................................................... 124
A Função IsObject .......................................................................................................... 125
Funções Para Conversão de Tipos ......................................................................................... 127
Função Cbool .................................................................................................................. 127
Função CByte .................................................................................................................. 128
Função CCur ................................................................................................................... 129
Função CDate .................................................................................................................. 130
Função CDbl ................................................................................................................... 131
Função CInt .................................................................................................................... 132
Função CLng ................................................................................................................... 133
VIII
Sumário
Função CSng ................................................................................................................... 134

Função CStr .................................................................................................................... 135
Funções Int e Fix ............................................................................................................ 135
Outras Funções do VBScript – Tratamento
de String, Datas e Funções Matemáticas ..................................................................................... 136
Funções Para Tratamento de String ...................................................................................... 136
Função Asc ..................................................................................................................... 136
Função Chr ..................................................................................................................... 136
Função Len ..................................................................................................................... 137
Função LCase .................................................................................................................. 137
Função UCase ................................................................................................................. 138
Função Left ..................................................................................................................... 138
Função Right ................................................................................................................... 138
Função Mid ..................................................................................................................... 139
Função String .................................................................................................................. 140
Funções Para Tratamento de Data e Hora ............................................................................. 140
Função Date .................................................................................................................... 140
Função Time ................................................................................................................... 141
Função Day ..................................................................................................................... 141
Função Month ................................................................................................................. 142
Função Now .................................................................................................................... 142
Função MonthName ....................................................................................................... 143
Função Hour ................................................................................................................... 143
A função DateDiff ........................................................................................................... 144
A Função DateAdd ......................................................................................................... 145
Função Year ..................................................................................................................... 147
Função WeekDay ............................................................................................................ 147
Função WeekDayName ................................................................................................... 148
Funções Para Cálculos Matemáticos ..................................................................................... 149
Criando Suas Próprias Funções e Procedimentos ....................................................................... 151
Criando e Utilizando Sub-rotinas ......................................................................................... 151
Criando e Utilizando Funções ............................................................................................... 154
Trabalhando com Eventos no VBScript ...................................................................................... 157
Principais Eventos dos Objetos do Internet Explorer .......................................................... 159
Conclusão ..................................................................................................................................... 167
Capítulo 4 – A Tecnologia ASP e o Modelo de Objetos do ASP 3.0 .......................................... 169
Introdução .................................................................................................................................... 170
Entendendo e Utilizando ASP ..................................................................................................... 170
Como e Onde uma Página ASP é Processada? ..................................................................... 171
O que uma Página ASP Retorna Para o Navegador do Cliente? ........................................... 172
O que é Preciso Para Criar e Acessar Páginas ASP? ............................................................. 175
Objetos do ASP 3.0 ....................................................................................................................... 176
Uma Visão Geral do Modelo de Objetos do ASP 3.0 ............................................................ 177
O Objeto Request.......................................................................................................................... 179
Coleções do Objeto Request .................................................................................................. 179
A Coleção Form do Objeto Request .............................................................................. 179
A Coleção QueryString do Objeto Request.................................................................... 186
IX
Alguns Campos que Merecem Considerações Especiais .............................................. 189

A Coleção ServerVariables do Objeto Request .............................................................. 193
A Coleção Cookies do Objeto Request ........................................................................... 199
A Coleção ClientCertificate do Objeto Request ............................................................. 203
Propriedade do Objeto Request ............................................................................................ 203
Método do Objeto Request .................................................................................................... 204
O Objeto Response ....................................................................................................................... 206
Coleção do Objeto Response ................................................................................................. 206
Propriedades do Objeto Response ........................................................................................ 211
A Propriedade Buffer do Objeto Response .................................................................... 211
A Propriedade CacheControl do Objeto Response ........................................................ 212
A Propriedade CharSet do Objeto Response ................................................................. 213
A Propriedade ContentType do Objeto Response ......................................................... 214
A Propriedade Expires do Objeto Response .................................................................. 215
A Propriedade ExpiresAbsolute do Objeto Response ................................................... 216
A Propriedade IsClientConnected do Objeto Response ................................................ 217
A Propriedade PICS do Objeto Response ...................................................................... 218
A Propriedade Status do Objeto Response .................................................................... 219
Métodos do Objeto Response ................................................................................................ 219
O Método AddHeader do Objeto Response ................................................................... 220
O Método AppendToLog do Objeto Response ............................................................... 220
O Método BinaryWrite do Objeto Response .................................................................. 221
O Método Clear do Objeto Response ............................................................................. 222
O método End do Objeto Response ............................................................................... 223
Comentários ................................................................................................................... 223
O Método Flush do Objeto Response ............................................................................ 224
O Método Redirect do Objeto Response ........................................................................ 225
O Método Write do Objeto Response ............................................................................. 226
Alguns Exemplos Práticos de Aplicação ..................................................................................... 227
Exemplo 1: Validação dos Dados de um Formulário ............................................................ 227
Exemplo 2: Formulário Para Cálculo de Imposto ................................................................. 239
Conclusão ..................................................................................................................................... 248
Capítulo 5 – Conectando Páginas ASP com Bancos de Dados .................................................. 249
Uma Revisão dos Conceitos Básicos de Banco de Dados ........................................................... 251
Entidades e Atributos ............................................................................................................ 251
Chave Primária ...................................................................................................................... 252
Relacionamentos Entre Tabelas ............................................................................................ 253
Relacionamento do Tipo Um Para Um .......................................................................... 254
Relacionamento do Tipo Um Para Vários ...................................................................... 255
Relacionamento do Tipo Vários para Vários ................................................................. 255
Integridade Referencial .................................................................................................. 256
Normalização de Tabelas ...................................................................................................... 257
Primeira Forma Normal .................................................................................................. 258
Segunda Forma Normal .................................................................................................. 259
Terceira Forma Normal ................................................................................................... 260
Passos Para Projetar um Banco de Dados .............................................................................. 261
X
Sumário
Etapas na Estruturação de um Banco de Dados ............................................................ 261

Dicas Para Determinação dos Campos em uma Tabela ................................................. 262
Como Escolher o Campo que Será a Chave Primária? .................................................. 262
Noções Básicas da Linguagem SQL – Structured Query Language ............................................ 263
Introdução ............................................................................................................................. 263
A Instrução SELECT ............................................................................................................. 264
A Instrução UPDATE ............................................................................................................. 272
A Instrução INSERT .............................................................................................................. 273
A Instrução Delete ................................................................................................................. 274
Uma Visão Geral de ADO e OLE DB ............................................................................................ 275
Um Pouco Sobre ODBC – Open Database Conectivity ........................................................ 275
Criando uma Fonte ODBC Para um Banco de Dados do Microsoft Access 97 ............. 276
Criando uma Fonte ODBC Para um Banco de Dados do Microsoft SQL Server 2000 ....... 282
Um Pouco Sobre OLE DB e ADO .......................................................................................... 288
Uma Visão Geral do Modelo de Objetos ADO ............................................................................ 290
O Objeto Connection ................................................................................................................... 292
O Primeiro Exemplo .............................................................................................................. 295
Modificando um Pouco o Nosso Exemplo ............................................................................ 304
Um Pouco Mais Sobre o Objeto Connection ............................................................................... 306
Criando um Formulário Para Pesquisa ......................................................................................... 311
Criando a Página HTML com o Formulário de Pesquisa ...................................................... 312
Criando a Página ASP Para Pesquisar no Banco de Dados .................................................. 313
Conclusão ..................................................................................................................................... 318
Capítulo 6 – Bancos de Dados com ASP – Conceitos Avançados Parte I ................................. 321
Introdução .................................................................................................................................... 322
Estabelecendo Conexões sem a Utilização de ODBC .................................................................. 323
A Propriedade ConnectionString ................................................................................................. 324
Configurando Conexões com Bancos de Dados do Microsoft Access .......................... 324
Configurando Conexões com Bancos de Dados do Microsoft SQL Server ................... 326
Configurando Conexões com Bancos de Dados ORACLE ............................................. 331
Alguns Detalhes Finais Sobre o Objeto Connection ................................................................... 333
O Método Close ..................................................................................................................... 333
“Pool” de Conexões ............................................................................................................... 334
O Objeto RecordSet ...................................................................................................................... 335
Cursores .......................................................................................................................... 336
Localização do Cursor .................................................................................................... 339
Lock de Registros ............................................................................................................ 341
Propriedades do Objeto RecordSet ................................................................................ 343
Métodos do Objeto RecordSet ........................................................................................ 345
Uma Página ASP Para Inserir Informações no Banco de Dados ................................................. 347
Editando Registros em um Banco de Dados ................................................................................ 361
A Página ASP Para Selecionar o Produto a ser Alterado – produto.asp .............................. 362
A Página que Localiza o Registro do Produto a ser Atualizado – localiza.asp ........................... 365
A Página que Atualiza os Dados na Tabela Produtos do Banco de
Dados Nwind.mdb – Atualiza.asp ........................................................................................ 370
Utilizando o Nosso Exemplo de Alteração de Registro ........................................................ 372
Eliminando Registros de um Banco de Dados ............................................................................ 375
XI
A Página ASP Para Excluir o Produto Selecionado – Exclui.asp ......................................... 375

Utilizando o Nosso Exemplo de Exclusão de Registro ......................................................... 377
A Propriedade Filter do Objeto RecordSet .................................................................................. 380
Conclusão ..................................................................................................................................... 385
Capítulo 7 – Bancos de Dados com ASP – Conceitos Avançados Parte II ................................ 387
O Objeto Command ..................................................................................................................... 389
Um Breve Introdução ao Objeto Command ......................................................................... 389
Os Métodos do Objeto Command ......................................................................................... 393
As Propriedades do Objeto Command ................................................................................. 393
Consultas Parametrizadas no Microsoft Access ................................................................... 397
O Objeto Parameter ...................................................................................................................... 402
Utilizando o Objeto Command Para Passar Parâmetros Para uma Consulta Parametrizada ...... 403
Utilizando o Nosso Exemplo ................................................................................................ 414
Um Desafio Para o Amigo Leitor ........................................................................................... 415
Um Pouco Mais Sobre Pesquisas em Banco de Dados ................................................................ 417
A Utilização do Operador Like ............................................................................................. 418
A Utilização de Múltiplos Critérios ...................................................................................... 423
O Operador And ............................................................................................................. 423
O Operador Or ................................................................................................................ 424
Alguns Exemplos de Utilização de Múltiplos Critérios ....................................................... 424
Utilizando Funções de Agregação ......................................................................................... 426
Alguns Exemplos de Utilização de Funções de Agregação .................................................. 427
Um Formulário Genérico Para Pesquisas ..................................................................................... 437
Utilizando o Nosso Formulário de Pesquisa ......................................................................... 446
Conclusão ..................................................................................................................................... 450
Capítulo 8 – Aplicativos Web e Componentes .......................................................................... 453
Introdução .................................................................................................................................... 454
O que é uma Aplicação Web no IIS? ........................................................................................... 454
Uma Aplicação Cliente/Servidor Tradicional ...................................................................... 455
Aplicações Web – um Novo Paradigma ................................................................................ 456
Aplicações Web no IIS .......................................................................................................... 457
O Arquivo Global.asa ................................................................................................................... 465
Um Aplicativo só Pode ter um Arquivo Global.asa ...................................................... 466
O Objeto Application ................................................................................................................... 468
Eventos do Objeto Application ............................................................................................. 469
Evento Application_OnStart .......................................................................................... 469
Evento Application_OnEnd ........................................................................................... 478
Coleções do Objeto Application ........................................................................................... 478
A Coleção Contents ........................................................................................................ 479
A Coleção StaticObjects ................................................................................................. 483
Métodos do Objeto Application ............................................................................................ 483
O Objeto Session .......................................................................................................................... 486
Eventos do Objeto Session .................................................................................................... 487
O Evento Session_OnStart ............................................................................................. 488
Evento Session_OnEnd .................................................................................................. 496
Coleções do Objeto Session .................................................................................................. 496
XII
Sumário
A Coleção Contents ........................................................................................................ 497

A Coleção StaticObjects ................................................................................................. 501
Métodos do objeto Session ................................................................................................... 501
Propriedades do Objeto Session ........................................................................................... 503
Conclusão ..................................................................................................................................... 506
Capítulo 9 – Segurança de Aplicações Web com IIS e ASP ...................................................... 509
Autenticação de Usuários com o IIS 5.0 ..................................................................................... 512
O Acesso Anônimo ...................................................................................................................... 512
Como Definir a Conta Para Acesso Anônimo no IIS 5.0 ...................................................... 515
Verificando as Configurações da Conta Para
Acesso Anônimo no Windows 2000 Server ......................................................................... 519
Configurando Permissões NTFS em Pastas do Servidor Web .............................................. 525
Sistemas de Arquivos no Windows 2000 e Permissões NTFS ............................................. 526
Definindo Permissões NTFS .......................................................................................... 529
Autenticação Básica ..................................................................................................................... 539
Autenticação Integrada do Windows ........................................................................................... 540
Autenticação Utilizando Certificados ......................................................................................... 541
Mapeamento do Certificado Cliente ..................................................................................... 541
Configurando o Tipo de Autenticação no IIS .............................................................................. 542
Mais Configurações de Segurança do IIS .................................................................................... 546
Configurando Opções Gerais de Segurança ......................................................................... 546
Configuração de Segurança Para Aplicativos Web no IIS .................................................... 550
Definindo Restrições de Acesso a Nível de Endereço IP ............................................................ 552
Mecanismos de Segurança do Banco de Dados .......................................................................... 557
Conclusão ..................................................................................................................................... 561
Capítulo 10 – Utilizando Componentes do IIS .......................................................................... 563
Introdução .................................................................................................................................... 564
O Objeto Server ............................................................................................................................ 564
Propriedade do Objeto Server ............................................................................................... 565
Métodos do Objeto Server ..................................................................................................... 566
O Método CreateObject .................................................................................................. 566
O Método Execute(“url”) ................................................................................................ 568
Exemplo .............................................................................................................................. 569
O Método GetLastError( ) ............................................................................................... 570
O Método URLEncode(“texto”) ...................................................................................... 571
O Método MapPath(“url”) .............................................................................................. 573
O Método Transfer(“url”) ............................................................................................... 574
O Método HTMLEncode(“texto”) ................................................................................... 575
Um Exemplo Prático de Utilização do Objeto Server ................................................................. 576
Utilizando Componentes do Servidor em Páginas ASP ............................................................. 586
O Componente Content Link ................................................................................................ 586
Criando um Objeto do Tipo Content Link ..................................................................... 588
Métodos do Objeto Content Link ................................................................................... 588
Um Exemplo que Utiliza o Componente Content Link ................................................ 591
O Componente Ad Rotator .................................................................................................... 596
O Arquivo de Programação da Rotatória ....................................................................... 597
XIII
URL ..................................................................................................................................... 598

Largura ................................................................................................................................ 598
Altura .................................................................................................................................. 598
Borda ................................................................................................................................... 599
URL_anúncio ...................................................................................................................... 599
URL_home_page_anúncio .................................................................................................. 599
Texto .................................................................................................................................... 599
Impressões .......................................................................................................................... 599
Exemplo .............................................................................................................................. 600
O Arquivo de Redirecionamento ................................................................................... 600
Exemplo .............................................................................................................................. 600
Propriedades do Objeto Ad Rotator ............................................................................... 601
Método do Objeto Ad Rotator ........................................................................................ 602
O Componente Page Counter ................................................................................................ 605
Os Métodos do Componente Page Counter ................................................................... 606
O Componente Browser Capabilities – Capacidades do Navegador ................................... 609
Conclusão ..................................................................................................................................... 615
Capítulo 11 – Os Objetos FileSystemObject, Drive, Folder e File ............................................. 617
Introdução .................................................................................................................................... 618
O Objeto FileSystemObject .......................................................................................................... 618
Propriedade do Objeto FileSystemObject ............................................................................. 619
Métodos do Objeto FileSystemObject .................................................................................. 620
Métodos do Objeto FileSystemObject Para Trabalho com Drives ................................. 620
Métodos do Objeto FileSystemObject Para Trabalho com Pastas ................................. 621
Métodos do Objeto FileSystemObject Para Trabalho com Arquivos ............................ 628
O Objeto Drive .............................................................................................................................. 634
Propriedades do Objeto Drive ............................................................................................... 634
O Objeto Folder ............................................................................................................................ 637
Propriedades do Objeto Folder .............................................................................................. 638
Métodos do Objeto Folder ..................................................................................................... 642
O Objeto File ................................................................................................................................ 644
Propriedades do Objeto File .................................................................................................. 644
Métodos do Objeto File ......................................................................................................... 647
Exemplo Prático ........................................................................................................................... 649
Conclusão ..................................................................................................................................... 652
Capítulo 12 – Tratamento de Erros, Transações e Outros Assuntos ......................................... 655
O Objeto ASPError ....................................................................................................................... 657
Propriedades do Objeto ASPError ........................................................................................ 657
Algumas Dicas Para Minimizar Erros .......................................................................................... 658
Erros de Sintaxe .................................................................................................................... 658
Erros de Semântica ou de Tempo de Execução .................................................................... 659
Erros Lógicos ......................................................................................................................... 661
Algumas Dicas Para Reduzir a Ocorrência de Erros ............................................................ 662
O Conceito de Transações e a Utilização de Transações em Páginas ASP ................................. 663
O Conceito de Transação ...................................................................................................... 664
XIV
Sumário
Colocando uma Página ASP no Contexto de uma Transação .............................................. 665

Estabelecendo um Script Transacional ................................................................................ 666
Restabelecendo ou Abortando um Script ............................................................................. 667
Gravando Eventos de Transação ........................................................................................... 667
Registrando um Componente no Gerenciador de Serviços de Componente ...................... 669
Escopo de Objeto ................................................................................................................... 672
Colocando Transações em Fila ............................................................................................. 672
Utilizando a Diretiva #include .................................................................................................... 673
As Diretivas @ ............................................................................................................................. 675
A Diretiva de Processamento @CODEPAGE ........................................................................ 676
A Diretiva de Processamento @ENABLESESSIONSTATE .................................................. 677
A Diretiva de Processamento @LANGUAGE ....................................................................... 678
A Diretiva de Processamento @LCID ................................................................................... 678
A Diretiva de Processamento @TRANSACTION ................................................................. 679
Conclusão ..................................................................................................................................... 680
Apêndice – Referência Rápida da Linguagem VBScript ........................................................... 681
Declarando Variáveis com VBScript ............................................................................................ 683
Operadores ................................................................................................................................... 684
Estruturas de Decisão e Laços de Controle em VBScript ............................................................ 685
Estrutura de Decisão If Then Else ........................................................................................ 685
Estrutura de decisão If Then ElseIf ....................................................................................... 686
O Laço For...Next ................................................................................................................... 686
O Laço For Each...Next .......................................................................................................... 686
A Estrutura Select Case...End Select .................................................................................... 686
A Estrutura Do While Condição...Loop ................................................................................ 687
Loop ....................................................................................................................................... 687
A Estrutura Do... Loop While Condição ............................................................................... 688
A Estrutura Do Until Condição...Loop ................................................................................. 689
A Estrutura Do... Loop Until Condição ................................................................................ 690
Comentários em VBScript ........................................................................................................... 691
Funções no VBScript .................................................................................................................... 692
Funções Para Conversão de Valores ............................................................................................. 692
ASC(String) .................................................................................................................... 692
Chr(número) ................................................................................................................... 692
CBool(expressão) ............................................................................................................ 692
CByte(expressão) ............................................................................................................ 693
CCur(expressão) ............................................................................................................. 693
CDate(data) ..................................................................................................................... 693
CDbl(data) ....................................................................................................................... 694
CInt(expressão) ............................................................................................................... 694
CLng(expressão) ............................................................................................................. 694
CSng(expressão) ............................................................................................................. 694
CStr(expressão) ............................................................................................................... 695
Fix(expressão) ................................................................................................................. 695
Hex(expressão) ............................................................................................................... 695
Int(expressão) ................................................................................................................. 695
XV
Oct(expressão) ................................................................................................................ 695

Round(expressão,numcasasdecimais) ........................................................................... 695
Sgn(expressão) ................................................................................................................ 696
Funções Para Trabalho com Datas ............................................................................................... 696
Date( ) ............................................................................................................................. 696
DateAdd(intervalo,numerodeintervalos,data) ............................................................... 696
DatePart(intervalo,data) ................................................................................................. 697
DateSerial(ano,mês,dia) ................................................................................................. 698
DateValue(String) ........................................................................................................... 698
Day(data) ........................................................................................................................ 698
Hour(tempo) ................................................................................................................... 698
Minute(tempo) ................................................................................................................ 698
Month(data) .................................................................................................................... 698
MonthName(data) .......................................................................................................... 699
Now( ) ............................................................................................................................. 699
Second(tempo) ............................................................................................................... 699
Time( )............................................................................................................................. 699
TimeSerial(hora,minuto,segundo) ................................................................................. 699
TimeValue(String) .......................................................................................................... 700
WeekDay(data) ................................................................................................................ 700
WeekDayName(número) ................................................................................................ 700
Year(data) ........................................................................................................................ 700
Funções Matemáticas ................................................................................................................... 700
Atn(número) ................................................................................................................... 701
Cos(número) ................................................................................................................... 701
Exp(número) ................................................................................................................... 701
Log(número) ................................................................................................................... 701
Randomize( ) .................................................................................................................. 701
Rnd(número) .................................................................................................................. 701
Sin(número) ................................................................................................................... 702
Sqr(número) ................................................................................................................... 702
Tan(número) ................................................................................................................... 702
Funções Para Manipulação de Strings ......................................................................................... 702
FormatCurrency(expressão) ........................................................................................... 702
FormatDateTime(expressão,opção) ................................................................................ 702
FormatNumber(expressão,numdigitos) ......................................................................... 703
FormatPercent(expressão,numdigitos) ........................................................................... 703
InStr(String1,String2) ..................................................................................................... 703
LCase(string) ................................................................................................................... 704
Left(string,número) ........................................................................................................ 704
Len(string) ...................................................................................................................... 704
LTrim(string) ................................................................................................................... 704
Mid(string,start,número) ................................................................................................ 704
Replace(string,ocorrência,substituição) ........................................................................ 705
Right(string,número) ...................................................................................................... 705
RTrim(string) .................................................................................................................. 705
Space(número) ............................................................................................................... 705
StrComp(String1,String2) .............................................................................................. 705
XVI
Sumário
String(número,caractere) ............................................................................................... 706

StrReverse(string) ........................................................................................................... 706
Trim(string) ..................................................................................................................... 706
UCase(string) .................................................................................................................. 706
Índice Remissivo .......................................................................................................................... 707
XVII
Introdução – Sites Dinâmicos com ASP 3.0
Introdução
Sites Dinâmicos
com ASP 3.0
1
Neste livro vamos abordar diversos assuntos relacionados com a criação de sites dinâmicos.
Desta forma, o leitor terá condições de aprofundar os seus conhecimentos em conteúdos de
grande importância para a criação de aplicativos para a Web. Iremos apresentar, juntamente
com conceitos teóricos, um grande número de exemplos e aplicações práticas em detalhes,
para que o leitor tenha condições de entender com clareza os assuntos abordados.
O trabalho de criar sites e aplicações para Intranet/Internet tornou-se bastante complexo. O

profissional da Web precisa conhecer um número cada vez maior de ferramentas e tecnologias.
A criação de sites, simplesmente através da utilização de páginas HTML, já não é capaz de
gerar os resultados necessários. Hoje, um site na Internet ou na Intranet de uma empresa,
deve apresentar as características destacadas a seguir:
➥ Geração dinâmica de conteúdo.
➥ Conexão de páginas com banco de dados.
➥ Personalização do conteúdo, de acordo com as preferências de cada usuário.
➥ Segurança no acesso a áreas restritas do site, somente para usuários autorizados e com
nível de acesso adequado.
➥ Criptografia dos dados transmitidos, ofererecendo garantia de autenticidade e integridade
das informações, principalmente para sites de Comércio Eletrônico, onde o usuário deve
digitar informações importantes, tais como o número do cartão de crédito.
➥ Serviços como envio de mensagens ou grupos de discussão, diretamente através do site.
➥ Mecanismos de pesquisa rápidos e precisos.
➥ Layout atraente e funcional, de tal forma que o internauta possa, rapidamente, localizar
o conteúdo desejado.
➥ Bom conteúdo e atualização constante.
Desenvolver um site, que contenha essas características, não é uma tarefa simples. Exige o
uso de diversas tecnologias e ferramentas de apoio, além, é claro, de profissionais competentes
e adequadamente treinados.
Com a utilização da tecnologia ASP 3.0 – Active Server Pages – podemos obter bons resultados
na criação de sites com este nível de complexidade. Ao estudar os capítulos deste livro, o
leitor aprenderá a utilizar essa tecnologia. O aprendizado de ASP é simples, principalmente
para quem já conhece o Visual Basic ou o Visual Basic for Applications (linguagem de desenvol-
vimento para o Microsoft Office). Em várias situações, o código é bastante semelhante.
A tecnologia está disponível através da utilização do Internet Information Services 5.0, como
servidor Web, o qual pode ser instalado juntamente com o Windows 2000 Server. Podemos
notar uma mudança no nome do servidor Web da Microsoft. A versão anterior era denominada
Internet Information Server 4.0 – IIS 4.0; e a nova, Internet Information Services 5.0 – IIS 5.0.
2
Observe que o Server foi substituído por Services. No tópico sobre as novidades do IIS 5.0,
irei explicar o que significa, na prática, esta mudança.
Durante a instalação do Windows 2000 Server, podemos optar por instalar, ou não, o Internet
Information Services 5.0. Ao longo deste livro estarei utilizando a abreviatura IIS 5.0 (para
manter coerência com o padrão utilizado pela Microsoft no Resource Kit do Windows 2000
Server), ao fazer referência ao Internet Information Services 5.0. Caso não tenhamos instalado
o IIS 5.0 na instalação do Windows 2000 Server, podemos adicioná-lo quando for necessário.
Para isso, utilizamos o ícone Adicionar ou remover programas, no Painel de controle. No
próximo tópico desta introdução, veremos como instalar o IIS 5.0.
É importante salientar que o IIS 5.0, somente está disponível no Windows 2000 Server. Isso
significa que não é possível você continuar utilizando o Windows NT Server 4.0 (com o qual
está disponível o IIS 4, através da instalação do Option Pack 4.0) e apenas fazer o upgrade do
IIS 4.0 para o IIS 5.0. Também é importante destacar que as novas características do ASP 3.0,
somente estão disponíveis no IIS 5.0. Em outro tópico desta introdução estarei abordando
essas novas características.
Equipamento e Software Necessário

Para acompanhar todos os exemplos propostos no livro, precisamos de um computador com
Windows 2000 Server instalado. Também faz-se necessário que o IIS 5.0 esteja instalado e
corretamente configurado.
A configuração mínima necessária depende de uma série de fatores.
Se o equipamento vai ser utilizado como um servidor Web na Internet, vários são os aspectos
a serem considerados, tais como:
➥ Aplicações implementadas e recursos de hardware necessários, como memória, disco
e processador.
➥ Número estimado de acessos simultâneos e diários, sendo esta uma das estimativas
mais difíceis de se obter, uma vez que o sucesso de um site pode ser determinado por
um número muito grande de fatores, nem todos de fácil mensuração.
➥ Grau de segurança necessário desejável. Neste caso, entram questões como criptografia,
uso de certificados digitais, criação de VPN – Virtual Private Networks (Redes Privadas
Virtuais) –, procedimentos de recuperação de falha, plano de contingência, etc.
➥ Percentual de “folga” desejado para recursos tais como: memória, processador, disco. Ao
projetar um site, é bastante comum utilizar hardware que atenda as necessidades atuais
com uma certa folga, para que seja possível suportar crescimentos maiores do que os
3
estimados. Alguns sites famosos já enfrentaram problemas de crescimento além do

esperado. Quando isso acontece, mais recursos de hardware precisam ser adicionados
com o site em funcionamento. É a bem conhecida situação de “trocar o pneu com o carro
andando”. Eu diria que hoje, na velocidade em que as mudanças acontecem, seria um
pouco pior, algo como “trocar a turbina com o avião em pleno vôo”.
Para maiores informações sobre como planejar a capacidade de hardware para um servidor
Web com o IIS 5.0, consulte o capítulo “Capacity Planning” do livro “Internet Information
Services Resource Guide”, parte integrante do Windows 2000 Server Resource Kit.
Como equipamento para ser utilizado em casa, ou em um laboratório de teste na sua empresa,
aconselho a seguinte configuração:
➥ Processador Pentium 200 ou superior.
➥ 64 MB de RAM, sendo 128 MB, altamente recomendável.
➥ 2 GB de disco rígido.
Com menos de 64 MB de RAM, o Windows 2000 Server não pode ser instalado. Sendo detectada
memória inferior a 64 MB durante o processo de instalação, o mesmo será suspenso.
Além do Windows 2000 Server e do IIS 5.0, também precisaremos ter os seguintes programas
e serviços instalados, para que possamos acompanhar os exemplos deste livro:
➥ Internet Explorer 4.x (ou superior) ou Netscape Navigator 4.x.
➥ Microsoft Transaction Services (vem junto com o Windows 2000 Server).
➥ Microsoft Index Services (vem junto com o Windows 2000 Server).
Em cada um dos capítulos, estaremos apresentando vários exemplos práticos. Através destes
exemplos, você poderá entender melhor a aplicação dos conceitos teóricos apresentados. Em
muitas situações, a melhor maneira de entender um determinado assunto, é através da
utilização do mesmo para resolução de um problema prático do dia-a-dia. Muitos dos exemplos
apresentados, podem ser facilmente adaptados para uso em aplicações que você esteja
desenvolvendo. Situações como acesso a banco de dados através de páginas Web, indexação
e pesquisa de conteúdos, implementação de mecanismos de segurança, etc., são comuns a
maioria das aplicações Web atuais. Agora vamos aprender a instalar o IIS 5.0.
Instalando e Testando o IIS 5.0

Caso você não tenha instalado o IIS 5.0, quando da instalação do Windows 2000 Server, é
possível fazer a instalação quando for necessário. Agora aprenderemos, passo a passo, a instalar
o IIS 5.0. Nunca é demais lembrar que sem o IIS 5.0, não será possível testar os exemplos
práticos, propostos neste livro.
4
Para instalar o IIS 5.0:

1. Faça o logon no Windows 2000 Server.
2. Abra o Painel de controle (Iniciar/Configurações/Painel de controle).
3. Abra a opção Adicionar ou remover programas.
4. Surgirá a janela indicada na Figura 1.1.
Figura I.1: Janela Adicionar ou remover programas.
5. No lado esquerdo da janela, dê um clique na opção Adicionar ou remover componentes

do Windows.
6. Surgirá a janela indicada na Figura 1.2.
Figura I.2: Janela para alterar a instalação do Windows.
5
7. Dê um clique no botão Componentes.

8. Será exibida, por breves instantes, uma mensagem “Aguarde...”. Depois surge a janela
Assistente de componentes do Windows, conforme indicado na Figura 1.3.
Figura I.3: Janela Assistente de componentes do Windows.
9. Utilizando o Assistente de componentes do Windows podemos adicionar novos

serviços, ou remover serviços que não sejam mais necessários.
10. Vá descendo com a barra de rolagem vertical, até localizar o item Internet Information
Services (IIS), conforme indicado na Figura 1.4.
Se esta opção estiver marcada, o IIS 5.0 já está instalado. Neste caso clique no botão Cancelar.
Depois é só fechar a janela Adicionar ou remover programas e o Painel de controle.
Se esta opção estiver desmarcada, significa que o IIS 5.0 ainda não foi instalado. Marque esta
opção para instalar este serviço.
Observe que ao marcar a opção, o botão Detalhes é habilitado. O IIS 5.0 é formado por uma
série de componentes e funcionalidades. Existe um servidor de páginas (servidor HTTP), um
servidor de FTP, um servidor de notícias (NNTP), etc.
Ao instalarmos o IIS 5.0, podemos escolher um ou mais dos seus componentes, dependendo
das necessidades do nosso site. Não é necessários que todos os componentes do IIS 5.0 sejam
instalados. Por exemplo, se o serviço de cópia de arquivos não for necessário, não temos
porque instalar o serviço de FTP.
6
Figura I.4: O serviço Internet Information Services (IIS).
DICA
Instale somente os serviços realmente necessários. Não é uma boa idéia instalar todos os serviços
disponíveis, já que somente alguns serão utilizados. Quanto mais serviços instalados, maiores
as possibilidades de ataque e quebra da segurança do site, por parte de um hacker.
11. Clique no botão Detalhes.

12. Na lista de opções disponíveis, certifique-se de que somente as seguintes estão marcadas:
➥ Arquivos comuns.
➥ Documentação.
➥ Extensões de servidor do FrontPage 2000.
➥ Gerenciador de Internet Services (HTML).
➥ Servidor File Transfer Protocol (FTP).
➥ Servidor World Wide Web.
➥ Snap-In do Internet Information Services.
13. Observe que, após ter selecionado os componentes a serem instalados, o Windows
2000 Server, exibe o espaço em disco necessário, conforme indicado pela Figura 1.5.
7
Figura I.5: Indicação do espaço necessário no disco rígido.
14. Dê um clique em OK. Você estará de volta ao Assistente de componentes do Windows.

15. Dê um clique no botão Avançar para ir para a próxima etapa do assistente.
16. O Windows 2000 Server exibe uma janela indicando o progresso da Instalação, como
na Figura 1.6.
Figura I.6: Progresso da instalação do IIS 5.0.
8
17. Caso o Windows 2000 Server não encontre os arquivos necessários à instalação no
disco rígido, você será solicitado a inserir o CD de instalação do Windows, conforme
indicado pela Figura 1.7.
Figura I.7: Mensagem solicitando o CD de instalação do Windows.
18. Insira o CD e dê um clique em OK. O Windows 2000 Server inicia o processo de cópia
dos arquivos.
19. Após finalizada a cópia dos arquivos, o Assistente emite uma mensagem dizendo que
o processo foi concluído com sucesso.
20. Dê um clique no botão Concluir para encerrar o Assistente.
21. Você estará de volta à janela Adicionar ou remover programas. Dê um clique no botão
Fechar para sair desta janela.
22. Você estará de volta ao Painel de controle. Feche o Painel de controle.
23. Agora o IIS 5.0 está instalado e pronto para funcionar.
IMPORTANTE
Caso você não tenha acesso a um computador com o Windows 2000 Server não tem problema.
Você pode acompanhar a maioria dos exemplos deste livro, utilizando o Windows 2000 Profes-
sional. A maneira de instalar o IIS 5.0 é exatamente a mesma, quer seja no Windows 2000
Server, ou no Windows 2000 Professional. Para os exemplos mais simples, até mesmo o Per-
sonal Web Server, que acompanha o Windows 98, pode ser utilizado. Porém no Personal Web
Server, não existem os conceitos de Transação e segurança disponíveis no IIS 5.0.
Agora que já temos o IIS 5.0 instalado, vamos testar se o mesmo está funcionando corretamente.
Para testar se o IIS 5.0 foi instalado com sucesso:

1. Abra o Internet Explorer.
2. Digite o seguinte endereço: http://localhost.
9
Deve surgir uma janela conforme indicado na Figura 1.8.
Figura I.8: A página padrão do IIS 5.0, logo após a instalação.
Esta é a página inicial padrão do IIS 5.0 logo após a instalação. Isto comprova que o IIS 5.0 foi
instalado com sucesso.
3. Feche o Internet Explorer.
No próximo tópico, irei apresentar as melhorias do IIS 5.0, em relação a versão anterior, IIS
4.0, dentre as quais destaca-se a versão 3.0 do ASP – Active Server Pages 3.0, com a qual
estaremos trabalhando neste livro.
Novidades e Melhorias do IIS 5.0

O IIS 5.0 é a nova versão do Servidor Web da Microsoft, o qual é disponibilizado como um
Serviço (conforme indicado pelo nome Services e não mais Server) do Windows 2000 Server.
A versão anterior – IIS 4.0 – era instalada como parte do Option Pack 4.0, para o Windows NT
Server 4.0. No Windows 2000 Server, o IIS 5.0 faz parte do próprio Sistema Operacional.
Neste tópico, apresentaremos as principais novidades desta nova versão. Para simplificar o
entendimento, classificarei as novidades em duas categorias, conforme descrito abaixo:
10
➥ Administração e serviços (FTP e HTTP).

➥ Desenvolvimento de aplicações Internet/Intranet.
Administração e Serviços
Os novos recursos do IIS 5.0 aumentaram a sua estabilidade e segurança. Novos assistentes
foram introduzidos para facilitar as tarefas mais comuns de administração e segurança. Eis
algumas das novidades:
➥ Reinicialização de download: Agora o serviço de FTP é capaz de reinicializar um down-
load que tenha sido interrompido, a partir do ponto em que a interrupção ocorreu, isso
evita que tenhamos que começar do zero. Característica de grande utilidade, principal-
mente para arquivos grandes, uma vez que a velocidade da Internet ainda não é
nenhuma maravilha.
➥ Compactação HTTP: Toda a informação, enviada via HTTP, pode ser compactada. Para
arquivos de texto (arquivos com código HTML, por exemplo), o ganho é considerável
– na maioria dos casos, acima de 70 %. Podemos utilizar compactação também com
arquivos de imagens (.jpg, .gif), ou qualquer outro tipo de arquivo transmitido via
HTTP. O browser deve ser capaz de descompactar a informação (Internet Explorer e o
Netscape Navigator em versão 4.x, dentre outros).
➥ Assistentes de segurança: Novos assistentes facilitam a execução de tarefas relacionadas
com a segurança. Por exemplo, o Assistente de Permissões (Permissions Wizard) facilita
a tarefa de atribuir permissões de acesso de arquivo. Esta era uma tarefa complicada
em versões anteriores, uma vez que a permissão efetiva, depende da combinação entre
as permissões estabelecidas no Sistema Operacional (permissões NTFS) e as do IIS.
Temos também um assistente para gerenciar Certificados.
➥ Contabilidade de processos (Process Accounting): Modificações introduzidas no ker-
nel do Windows 2000 Server, permitem um controle bastante refinado nos processos
que estão rodando. Com isso, pode ser determinado o quanto de processador cada site
virtual está consumindo (lembrando que o IIS admite diversos sites em um único
servidor). Com isso é possível determinar se um dos sites está consumindo, despropor-
cionalmente, tempo do processador. Por exemplo, pode ser que uma página ASP mal
implementada, esteja elevando a carga no processador. Esta característica também pode
ser utilizada por provedores de conteúdo, os quais hospedam sites de outras empresas,
como um parâmetro para a cobrança do serviço de hospedagem do site.
➥ Melhor administração através do browser: Administrar o IIS 5.0, remotamente, através
do browser ficou bem mais fácil. Além disso, a maioria das tarefas podem ser executadas
através dele, o que não era possível em versões anteriores. O administrador também
pode criar “Contas Administrativas” (conhecidas como Operadores), com permissões
11
limitadas a determinadas tarefas, por exemplo, criar diretórios virtuais. Com isso é
possível distribuir a administração do IIS entre diversos Administradores.
➥ Web Distributed Authoring and Versioning (WebDAV): Permite que o autor de páginas, possa
remotamente editar, mover ou eliminar arquivos. Também é possível editar as propriedades
de arquivos e diretórios, remotamente, através de uma conecção HTTP. Com WebDAV, o
autor está utilizando o HTTP como um protocolo de compartilhamento de arquivo.
➥ Autenticação Digest: Aumenta a segurança e a confiabilidade da autenticação dos usuários.
Com a Autenticação Digest, é feito um hash das informações de senha antes da transmissão.
Informações ligadas à sessão e a hora do sistema são adicionadas ao hash. Com isso, mesmo
que a senha seja interceptada, não poderá ser decifrada. Os demais tipos de autenticação
continuam existindo: HTTP Basic, Windows NT Challenge/Response e NTLM authentica-
tion (conhecida como “integrated Windows authentication”).
Desenvolvimento de Aplicações Internet/Intranet

Muitas melhorias foram feitas nesta área. Vamos descrever, resumidamente, algumas das novidades.
➥ Proteção das aplicações: Por padrão, todas as aplicações rodam em um processo comum,
o qual é separado do processo do IIS 5.0. Porém é possível rodar aplicações de maior
importância (ou que necessitem de maior desempenho) em um processo separado.
➥ Principais novidades para páginas ASP – Active Server Pages:
➥ Novos métodos para o controle de fluxo da aplicação (Server.Transfer,
Server.Execute, etc.).
➥ Melhorias no tratamento de erros. Teremos um capítulo deste livro dedicado ao
tratamento de erros em páginas ASP.
➥ Scriptless ASP: Mesmo páginas que contenham somente código HTML podem ter
a extensão .ASP. Com isso pode-se criar toda a estrutura do site utilizando páginas
com a extensão .ASP e adicionar os scripts no momento oportuno.
➥ Integração com o XML – Extensible Markup Language. Ainda não ouviu falar de XML?
O caso é sério.
➥ Novas maneiras para detectar as capacidades do browser do cliente.
➥ Melhorias de performance: Capacidade de self-tunning das páginas ASP.
São muitas as novidades do IIS 5.0 e uma das melhores fontes para conhecê-las é o livro
Internet Information Services Resource Guide (em Inglês), o qual, conforme descrito
anteriormente, faz parte do Windows 2000 Server – Resource Kit.
12
É Hora de Começar
Bem, já estamos com o IIS instalado e funcionando, conhecemos as novidades desta versão e
estamos ansiosos para começar a trabalhar com páginas ASP, em sua versão 3.0. Pois é
exatamente o que estaremos fazendo deste ponto em diante. Você aprenderá a utilizar os
principais recursos do ASP 3.0, podendo criar páginas e aplicações para Web, com diversos
recursos e funcionalidades.
Abaixo apresento uma pequena descrição do conteúdo de cada capítulo deste livro. Caso
você esteja iniciando os estudos sobre ASP, aconselho que leia os capítulos na seqüência
apresentada. Caso já trabalhe com ASP, sinta-se a vontade para ler os capítulos na ordem que
julgar mais adequada. Cada capítulo apresenta exemplos completos, os quais ilustram os
conceitos teóricos apresentados.
Em todos os exemplos, estou utilizando a linguagem VBScript, devido a sua funcionalidade

e facilidade de aprendizado. Caso o leitor queira utilizar Java Script (agora formalmente ECMA
Script), sinta-se à vontade.
Visão Geral dos Capítulos do Livro

➥ Capítulo 1: Apresentaremos uma visão geral sobre a criação de sites dinâmicos, bem
como do desenvolvimento de aplicações para Internet/Intranet (também conhecidas
como aplicações para a Web). Veremos o que é ASP, bem como as tecnologias utilizadas
na criação de aplicações Web.
➥ Capítulo 2: Como em nossos exemplos estaremos utilizando a linguagem VBScript.
Neste capítulo serão apresentados os conceitos básicos desta linguagem, juntamente
com exemplos práticos de utilização dos conceitos apresentados.
➥ Capítulo 3: Apresentaremos aspectos adicionais da linguagem VBScript, aprendendo
a utilizar funções, comandos e outros. Também aprenderemos sobre o conceito de
eventos em páginas Web; além de aprender a criar código a ser executado em resposta
a determinados eventos de uma página, como por exemplo o clique em um determinado
botão de comando.
➥ Capítulo 4: Neste capítulo começaremos a estudar os objetos fornecidos pelo ASP 3.0.
Veremos os diversos métodos e propriedades de cada objeto, bem como a relação entre
eles. Utilizaremos alguns exemplos práticos para facilitar o entendimento dos conceitos
apresentados.
➥ Capítulo 5: Neste capítulo aprenderemos a conectar páginas ASP com bancos de dados.
Veremos como criar pesquisas personalizadas, utilizando como critério de pesquisa,
valores fornecidos pelo cliente, através de um formulário. Trataremos de diversos
métodos de acesso a bases de dados, desde a utilização de meios tradicionais, como
13
drivers ODBC, até métodos mais atuais, como a utilização de ADO (ActiveX Data Ob-
jects) e OLE-DB Providers.
➥ Capítulo 6: Neste capítulo trataremos de aspectos avançados de conexão de páginas ASP
com bancos de dados. Veremos como implementar pesquisas avançadas, efetuar
atualizações e alterações em bancos de dados. Analisaremos algumas situações usuais do
dia-a-dia. Também serão abordados aspectos ligados à segurança no acesso às informações.
➥ Capítulo 7: Abordaremos a conexão de páginas ASP com banco de dados. Vamos realizar
um estudo completo do objeto Command e aprender a utilizá-lo para enviar parâmetros
para consultas Parametrizadas do Microsoft Access.
➥ Capítulo 8: Veremos os conceitos de sessão e estado da conexão. Será apresentado o
conceito de aplicação Web. Aprenderemos, em detalhes, a utilizar os objetos Applica-
tion e Session. Também aprenderemos sobre a função e como utilizar o arquivo global.asa.
➥ Capítulo 9: Trataremos de aspectos de segurança envolvendo páginas ASP.
➥ Capítulo 10: Estudaremos diversos componentes que já vem junto com o IIS e fornecem
funcionalidades adicionais, bastante úteis na criação de aplicações Web.
➥ Capítulo 11: Neste capítulo faremos um estudo completo sobre um dos objetos mais
complexos do ASP: FileSystemObject. Estudaremos todos os seus métodos, bem como
os objetos derivados: Drive, Folder e File.
➥ Capítulo 12: Neste capítulo apresentaremos o objeto ASP Error. Também aprenderemos
sobre o conceito de Transações, além de aprendermos a utilizar a diretiva #include e
as diretivas @.
➥ Apêndice A: Teremos uma listagem dos comandos e funções mais utilizados na
linguagem VBScript, que poderá ser usada como uma referência.
Então, “Mãos à obra”

Bem, feitas as devidas apresentações, é hora de começarmos nossa jornada, rumo ao
aprendizado de ASP. Cabe ressaltar a grande aceitação que vem tendo a tecnologia de Active
Server Pages da Microsoft. Basta observar o grande número de sites na Internet que utilizam
esta tecnologia. Também é grande o número de empresas que desenvolvem aplicativos para
sua Intranet, utilizando-se da tecnologia ASP.
Sem a menor sombra de dúvidas, a facilidade no aprendizado, aliada aos recursos oferecidos,
é que tornaram a tecnologia de páginas ASP largamente difundida e utilizada. Quem já
programa em Visual Basic, ou Visual Basic for Applications, ficará absolutamente à vontade
para aprender a tecnologia ASP.
Então, mãos à obra, vamos aprender ASP 3.0.
14
Capítulo 1 – Uma Introdução à Tecnologia ASP
Capítulo 1
Uma Introdução à
Tecnologia ASP
15
A Internet faz parte da vida de um número cada vez maior de pessoas. Fazer compras, sem
sair de casa; receber, diretamente no seu computador, as últimas notícias; comprar e vender
ações; procurar emprego pela rede. Todos são exemplos de facilidades oferecidas pelo uso da
Internet. Talvez seja mais simples enunciar o que não é possível de se fazer pela rede, do que
listar todas suas possibilidades. Mas nem sempre foi assim. Para chegar ao nível que nos
encontramos hoje, com a disponibilização dos mais variados serviços via Internet, muita
evolução ocorreu. Desde os tempos de conteúdo meramente informativo, até a possibilidade
de escutar rádio e fazer compras pela rede, muitas tecnologias novas surgiram. E o ritmo de
evolução não pára, pelo contrário, parece acelerar cada vez mais.
Neste capítulo veremos um pouco sobre esta evolução da Internet. Passaremos pelas diversas
fases, desde a criação de sites com conteúdo estático, até os aplicativos de n-camadas atuais.
Também veremos como a tecnologia ASP, contribui para a criação de sites dinâmicos. Com
isso você verá em que situações é indicada a utilização de páginas ASP.
Era uma Vez uma Internet com Conteúdo Estático

Neste tópico veremos um pouco sobre a história de Internet e seus conceitos básicos. Aprenderemos
sobre os diversos elementos envolvidos quando um usuário acessa conteúdo da Internet. Também
veremos as limitações e problemas dos sites pioneiros que criavam conteúdo estático.
Um Começo Quase sem Querer

Poderíamos dizer que a origem da Internet foi casual e despretensiosa. Inicialmente, foi criada
uma rede conhecida como ARPANET, utilizada pelo Departamento de Defesa norte-americano,
alguns fornecedores e pesquisadores ligados a este departamento. Como a ARPANET mostrou-
se de grande utilidade, facilitando a troca de informações, acabou expandindo-se de uma
maneira rápida e inesperada. Neste ponto, a idéia de uma rede de computadores para a troca
de informações estava lançada.
Mais tarde, foi criada uma rede baseada nas mesmas tecnologias da ARPANET, porém com uma
abrangência maior (tanto geográfica, quanto de objetivos). A idéia era trazer os benefícios
demonstrados pela ARPANET, para um número maior de pessoas e empresas. Eis que nascia a
Internet. No final da década de 80, a Internet já era bastante conhecida nos meios acadêmicos do
mundo inteiro. Nesta época, porém, ainda tínhamos a Internet sem a interface gráfica. Normalmente
a troca de informações era feita por FTP, alguns aplicativos baseados em telnet, ou o popular “gopher”,
que tornou-se bastante conhecido nos primeiros anos da década de 90. O gopher, basicamente, era
um sistema baseado em opções de menu, para divulgação e pesquisa de informações.
Até 1991 era proibido o tráfego de qualquer informação comercial pela Internet. Esta proibição
era mantida pela National Science Fundation, entidade que financiou grande parte do
desenvolvimento da Internet nos EUA, até este momento. Com a liberação, as empresas
16
passaram a fazer uso da Internet para fins comerciais. Desde então a rede expandiu-se
enormemente, atingindo, hoje, milhões de pessoas em todo o mundo.
A popularização definitiva da rede veio com a criação de uma interface gráfica. Com a criação
da linguagem HTML, servidores HTTP, e programas para acessar as páginas HTML
armazenadas nos servidores (também conhecidos como browser ou navegadores), a Internet
tornou-se mais popular do que nunca. Este foi o momento do surgimento da WWW – World
Wide Web. Talvez a melhor tradução para World Wide Web seja: “Teia de Alcance Mundial”.
Esta é a idéia que temos de Internet. Uma rede (teia) que conecta computadores do mundo
inteiro (alcance mundial), proporcionando a troca de informações e uma infinidade de serviços
e facilidades para as empresas e para o cidadão comum.
Com certeza, os criadores da ARPANET, e depois da Internet, não imaginavam uma expansão
e popularização tão rápida da rede. Hoje, vemos anúncios de sites na televisão, durante o
Telejornal e na transmissão de partidas de futebol. A maioria dos jornais possui um caderno
de informática, quase totalmente dedicado a assuntos relacionados com a Internet. Vemos
reportagens sobre a rede em todas as revistas, e não somente nas especializadas em Informática,
que agora dedicam quase a totalidade de suas matérias a assuntos da Internet. Enfim, a Internet
já faz parte do nosso dia-a-dia; veio para ficar e facilitar a nossa vida.
Agora vamos conhecer um pouco mais sobre a Internet e os diversos elementos que a compõem.
Uma Visão Geral da Internet e de Seus Elementos

Encontrar uma definição precisa e unânime para a Internet é uma tarefa complexa. Vamos
ver os elementos que a compõe, sem nos preocuparmos com definições formais. Por exemplo,
o que é preciso para que o usuário doméstico possa acessar a Internet; onde fica e por onde
circula a informação que está sendo acessada.
Internet
Usuário
Servidor Web
Usuário doméstico conectado à Páginas HTML estáticas
Internet através da linha telefônica.
Figura 1.1: Uma visão geral da Internet, com conteúdo estático.
17
Antes de continuar com as explicações, considere o diagrama indicado na Figura 1.1. Nesta
figura, temos representados os elementos mais comuns da Internet, conforme descrito a seguir.
➥ Usuário: Representamos um usuário residencial. Normalmente este tipo de usuário faz
a conexão através da linha telefônica comum. Para isso é preciso a utilização de um
provedor de acesso, que fornece a conexão com a Internet. O usuário utiliza um programa
conhecido como navegador (browser), para acessar o conteúdo da Internet. Os dois
navegadores mais conhecidos são o Internet Explorer da Microsoft, e o Netscape Naviga-
tor da Netscape. Quando o usuário acessa um determinado conteúdo, dizemos que ele
está acessando um site (também encontramos o uso da palavra “página”, ao invés de
site). Por exemplo, quando o usuário acessa o endereço http://www.microsoft.com/brasil,
dizemos que ele está acessando a página, ou o site, da Microsoft Brasil. Quando o usuário
acessa o endereço http://wwww.microsoft.com/vbasic, dizemos que o usuário está
acessando a página do Visual Basic, no site da Microsoft. Durante este livro, estarei
utilizando a palavra página, significando que o usuário está acessando um determinado
conteúdo na Internet, ou na Intranet da empresa.
➥ Internet: Pelo fato de ser formada por um grande número de equipamentos – servidores,
hubs, switch, linhas de comunicação, satélites, etc. –, representamos a Internet como
uma nuvem. Esta é a representação que você encontrará na maioria dos livros.
➥ O servidor Web: Neste caso é o servidor que contém a informação solicitada pelo usuário.
Por exemplo, ao digitar www.axcel.com.br, no campo endereço do navegador, o usuário
está solicitando que seja carregado o conteúdo da página inicial do site da Editora
Axcel Books. Observe que o servidor também está conectado à Internet, isto é, faz
parte da Internet. As páginas armazenadas no servidor são desenvolvidas utilizando-
se a linguagem HTML – Hypertext Markup Language. Você pode encontrar muita
informação sobre HTML na própria Internet. O órgão responsável pela padronização
da linguagem HTML é o w3. No site www.w3.org, você pode encontrar um grande
volume de informações sobre HTML.
Na Figura 1.1, representamos a primeira geração de conteúdo da Internet. Conforme indicado

pela seta maior, a informação trafegava, basicamente, em um único sentido. O usuário solicita
um determinado conteúdo, e o mesmo é entregue e exibido no seu navegador. Observe que o
usuário não tem a possibilidade de enviar informações para o servidor. Além disso, nesta
primeira fase o conteúdo das páginas é estático.
Uma vez criada a página (através da utilização do HTML), a mesma não é modificada. Cada
vez que o usuário se conectar à página, verá o mesmo conteúdo. A única maneira de alterar o
conteúdo, é alterando o código HTML. Com isso, da próxima vez que o usuário se conectar à
página, verá a nova versão da mesma. Porém esta metodologia de modificação de páginas é
trabalhosa e pouco produtiva. Imagine que você esteja publicando um catálogo de produtos,
com informações diversas sobre vários produtos, tais como: código do produto, descrição e
18
preço. Uma das maneiras de criar este catálogo é através da utilização do código HTML, para
criar na página uma tabela com informações sobre os diversos produtos. Porém cada vez que
houver uma modificação em um dos produtos, você terá que editar a página e salvar a nova
versão da mesma. Convenhamos que é um processo bastante trabalhoso.
Embora trabalhoso, era assim que funcionavam os primeiros sites, no início da era WWW. O
conteúdo era estático, ou seja, alterações nas páginas, implicavam em alterações, diretamente
no código HTML das mesmas. Imagine o trabalho para a manutenção de grandes sites, com
diversas áreas de informações, onde o número de páginas pode facilmente chegar na casa dos
milhares. Com isso a evolução para a criação de conteúdo mais dinâmico, foi um processo
natural e necessário.
Conteúdo Dinâmico na Internet

Com o crescimento da Internet e a necessidade de constantes alterações no conteúdo das
páginas, surge uma segunda geração de sites na Internet, capazes de entregar conteúdo mais
atualizado, além de permitir que o usuário interagisse com as páginas Web, também enviando
informações e não apenas recebendo. Nesta fase surge a possibilidade de ligação das páginas
HTML com o conteúdo de bancos de dados. Observe o diagrama indicado na Figura 1.2.
A conexão de páginas HTML com

bancos de dados, permite a criação
de páginas mais dinâmicas e
interativas.
Internet
Usuário Servidor Web Servidor de Banco de Dados

Usuário doméstico Agora o usuário pode enviar e Páginas HTML dinâmicas Ex.: Microsoft SQL Server.
conectado a Internet através receber informações.
da linha telefônica.
Figura 1.2: Conectando páginas HTML com bancos de dados.
Pelo diagrama, podemos ver que o usuário tem possibilidade de enviar informações para a Internet,
e não apenas receber. Isto possibilitou o desenvolvimento de uma série de serviços, impossíveis de
serem desenvolvidos apenas com a utilização de páginas criadas com HTML.
19
Para enviar informações, o usuário preenche os campos de um formulário (o qual é criado

com a utilização de HTML) e, ao clicar em um botão Enviar, os dados são enviados para o site
da Web. Ao chegar no servidor Web, estes dados precisam ser “recebidos” por um programa
capaz de entender o formato dos dados e armazená-los em um banco de dados.
Os primeiros programas, capazes de realizar esta tarefa, seguiam a especificação conhecida

como CGI – Common Gateway Interface. Muitas aplicações Web foram desenvolvidas
utilizando-se a especificação CGI, e várias ainda continuam sendo utilizadas. A utilização de
scripts, desenvolvidos na linguagem Perl, é um exemplo de utilização de CGI. O script recebe
os dados enviados pelo formulário, os decodifica e armazena o resultado em um banco de
dados. Embora bastante funcional, a utilização de CGI começou a apresentar alguns problemas,
e novas alternativas foram desenvolvidas. Está fora do escopo deste livro discutir os problemas
da utilização de CGI.
Dentre as várias alternativas que surgiram para a geração de conteúdo dinâmico, podemos
citar a tecnologia de Active Server Pages, a qual faz parte do servidor Web IIS (Internet
Information Services), da Microsoft. Podemos criar uma página ASP, capaz de receber os
dados enviados por um formulário e armazenar estes dados em um banco de dados, por
exemplo o Microsoft Access ou o Microsoft SQL Server. Aprenderemos a criar este tipo de
página ASP, no Capítulo 4. Agora veremos apenas alguns exemplos simples da utilização de
ASP, sem conexão com bancos de dados.
Com a conexão de páginas com bancos de dados, uma série de possibilidades foram abertas,
como por exemplo:
➥ Criação de páginas para pesquisa em banco de dados.
➥ Cadastro de usuários que acessam o site, bem como a entrega de conteúdo
personalizado, de acordo com as preferências do usuário. Por exemplo, ao entrar no
site, o usuário informa um nome e senha, com os quais foi previamente cadastrado.
Com isso é aberta uma página com opções e conteúdo personalizados, de acordo com
preferências especificadas pelo usuário.
➥ Desenvolvimento de aplicações residentes em servidores Web e acessíveis através
do navegador. Devemos observar que estas aplicações ainda eram limitadas e não
possuíam todas as funcionalidades das aplicações convencionais, desenvolvidas para
o ambiente Windows.
Apesar das suas limitações, um novo panorama desenhava-se na Internet com a possibilidade
da criação de sites mais dinâmicos, através da conexão com bancos de dados. Apenas para
exemplificar o funcionamento de uma pesquisa em banco de dados, através da Internet,
observe a Figura 1.3.
20
A conexão de página HTML com bancos

de dados, permite a pesquisa em
bancos de dados.
Internet
Agora o usuário pode enviar e

receber informações.
Usuário
No servidor Web, um script CGI, ou uma Servidor de Banco de Dados
Usuário digita o critério de página ASP, recebe o critério de pesquisa, Ex. Microsoft SQL Server.
pesquisa em uma página Web. executa a consulta no banco de dados,
monta uma página HTML, com o resultado
de volta para o navegador do usuário.
Figura 1.3: Pesquisa em um banco de dados, através da Internet.
Vamos analisar os passos executados, desde o momento que o usuário preenche o critério de
pesquisa, até o momento em que o resultado da consulta é retornado:
➥ O usuário acessa a página onde temos um formulário para a digitação de um ou mais
critérios de pesquisa. Por exemplo, pode ser uma consulta a uma base dos CEP’s de
todo o Brasil. O usuário poderia digitar o nome da Cidade, selecionar um Estado e
digitar o nome, ou parte do nome, da Rua, conforme indicado pela Figura 1.4.
➥ Após preencher o(s) critério(s) de pesquisa, o usuário clica em um botão Enviar ou
Pesquisar. Os dados digitados no formulário são enviados para o servidor.
➥ Um script CGI, ou uma página ASP, no servidor, recebe os dados enviados pelo usuário.
Com estes dados, é montado um comando (normalmente uma String SQL – Structured
Query Language), o qual vai efetuar a consulta no banco de dados. Após montado o
comando, o mesmo é enviado para o servidor de Banco de Dados (que pode ser uma
máquina separada, ou pode estar instalado no próprio servidor Web).
➥ O servidor de Banco de Dados recebe o comando de pesquisa, localiza um ou mais
registros que atendam o(s) critério(s) de pesquisa e retorna o resultado para o script
CGI, ou para a página ASP.
➥ Com o resultado retornado pelo servidor de Banco de Dados, o script CGI, ou a página
ASP, monta uma página HTML, normalmente no formato de uma tabela, e envia esta
página HTML de volta para o navegador do cliente, conforme indicado na Figura 1.5.
Caso não seja encontrado nenhum registro que atenda o(s) critério(s) especificado(s), é
retornada uma página com uma mensagem de que não foi encontrado nenhum registro.
21
Figura 1.4: Digitando os critérios de pesquisa em um formulário criado com HTML.
Figura 1.5: Resultados obtidos a partir de um banco de dados do CEP.
22
Veja que ao mesmo tempo em que aumentaram as possibilidades de desenvolvimento, também

aumentaram as complexidades a serem gerenciadas, tanto na criação de páginas, quanto no
gerenciamento dos sites. Observe que ainda nem falamos de questões tais como segurança,
proteção do banco de dados contra acessos não-autorizados, ou até mesmo ataques de hackers
tentando roubar informação ou corromper a informação do banco de dados.
Além das novas complexidades, novas questões ainda precisavam ser resolvidas (sendo que
algumas ainda hoje não estão completamente solucionadas). Por exemplo, para vender pela
Internet, as questões de segurança precisavam ser bem resolvidas. Quem arriscaria a colocar
o número do cartão de crédito em um site de Comércio Eletrônico, sem a garantia de que o
mesmo seja seguro?
Além disso, existe a necessidade de troca de informações entre as diversas empresas, via
Web. Por exemplo, quando você vai fazer uma compra pela Internet, você digita o número do
seu cartão de crédito. Antes de finalizar o pedido, a empresa que está vendendo precisa verificar,
junto a operadora do cartão, se o número fornecido é válido, se não é um cartão vencido, se não
é um cartão que foi roubado, etc. Todas estas informações precisam ser verificadas rapidamente,
em tempo real. O usuário não está a fim de aguardar muito tempo em frente ao computador.
Note que um número grande de fatores começa a surgir, principalmente com o início do
Comércio Eletrônico. Para resolver tantos problemas, a simples conexão de páginas com bancos
de dados, embora necessária, não era mais suficiente.
No próximo item veremos um pouco mais sobre esta nova geração de sites Web, os quais
fazem uso de diversas tecnologias. Lembrando que a cada dia novidades estão surgindo.
A Era do Comércio Eletrônico

Estamos vivendo um nova era, a qual é marcada pelo Comércio Eletrônico, ou o chamado e-
business. Todas as revistas especializadas e meios de comunicação apresentam matérias,
diariamente, sobre Comércio Eletrônico. As possibilidades são inúmeras, tanto para as
empresas quanto para os usuários e profissionais envolvidos. O Comércio Eletrônico deixou
de ser apenas uma previsão em livros e revistas, e passou a ser uma realidade, presente no
dia-a-dia de todos nós. Com isso uma nova geração de sites está sendo criada, muito mais
complexa do que a anterior, necessitando de ferramentas de desenvolvimento e gerenciamento
cada vez mais sofisticadas.
Grande parte do orçamento de informática das empresas está direcionada para atividades ligadas
ao Comércio Eletrônico. Novas tecnologias surgem todos os dias, prometendo facilitar a criação
de sites para essas e outras atividades relacionadas. Neste tópico veremos quais as tecnologias
necessárias para criação destes sites, bem como as complexidades envolvidas.
23
O Comércio Eletrônico pode acontecer de duas maneiras distintas:

➥ B2B – Business to Business: Acontece quando são feitas transações comerciais entre duas
empresas. Pode ser uma montadora de automóveis comprando peças de um fornecedor,
ou uma livraria encomendando livros de uma editora. Em termos de volume financeiro, o
B2B é responsável por um grande percentual do que é comercializado via Internet.
➥ B2C – Business to Consumer: É um cliente, como eu e você, comprando um livro ou
um CD através de uma loja virtual na Internet. Hoje existem sites de Comércio Eletrônico
que vendem uma série de coisas: livros, revistas, cosméticos, CD’s, roupas, e até
remédios e carros.
À medida que aumenta o número de sites de Comércio Eletrônico, aumenta, também, a

concorrência. Portanto, conquistar e manter clientes têm sido o grande desafio. Não basta
colocar um catálogo de produtos, garantir a segurança e entregar a mercadoria no local indicado
e no prazo estipulado. Embora estas sejam questões fundamentais, não são mais suficientes
para garantir a fidelidade do cliente, pois, diferentemente do comércio tradicional, no Comércio
Eletrônico, o concorrente está apenas a um clique de mouse.
Hoje, um dos grandes desafios é conhecer o cliente, saber identificar seus hábitos e armazenar
o maior número de informações sobre ele, tal como o histórico de compras e pesquisas
realizadas no catálogo de produtos. De posse destas informações, o site deve ser capaz de
fazer ofertas personalizadas para o cliente. Posso citar o meu caso como exemplo. Há tempos
que compro livros importados em um determinado site. Ao acessar o site, após me identificar,
aparece um link: “Sugestões para o Júlio”. Vejam que até o link já vem personalizado; isso
atrai o cliente. É como entrar no mercadinho da esquina e o seu Manoel ir dizendo: “Olá seu
Júlio, aquele queijo colonial que o Sr. gosta, chegou.” Ao clicar no link de sugestões, recebo
uma listagem de livros. O mais interessante é que, nesta listagem, realmente estão os livros
nos quais estou interessado. Que milagre é este? Não é milagre nenhum. Desde a primeira
compra, o site vem armazenando informações sobre as pesquisas que faço no catálogo de
livros e sobre o que efetivamente compro. Com isso, foi possível identificar minhas preferências
e elaborar uma lista de sugestões personalizada. Quanto maior a quantidade de informações,
mais precisa será esta lista de sugestões.
Vejam que os sites de Comércio Eletrônico estão tentando fazer o que o seu Manoel do
mercadinho da esquina faz há muitos anos. Estão tentando dar um tratamento personalizado
para os seus clientes, com o objetivo de mantê-los satisfeitos. Clientes satisfeitos significam
vendas e lucros para a empresa.
Conhecer as preferências do cliente é apenas um dos exemplos de aplicação a partir de dados

obtidos pelo site. Com uma base de dados grande e confiável, muitas outras aplicações podem
ser construídas sobre esses dados. Por isso que, a maioria dos sites, mesmo os que fornecem
serviços gratuitos, exigem que você preencha um cadastro, antes de disponibilizar o acesso a
24
serviços e informações. Com as informações obtidas através do cadastro, a empresa está

tentando montar a sua base de dados.
Vejam que os dados precisam ser obtidos e armazenados em um banco de dados. Depois, a
segurança dos dados precisa ser garantida. Já pensou se alguém consegue invadir o site de
uma empresa e obter uma listagem de números de cartões de crédito? Seria péssimo para a
imagem e para as vendas desta empresa. Além da segurança, novas aplicações estão sendo
construídas para fazer uso destes dados, com o objetivo não só de melhorar as vendas, mas
também de melhorar as relações com os clientes. Não basta que a empresa seja capaz de
vender; para sobreviver ela precisa continuar vendendo para o cliente. Para continuar
vendendo, isto é, para fidelizar o cliente, a área de atendimento é de fundamental importância.
Se você compra, por exemplo, um CD e o mesmo é entregue fora do prazo, você reclama. Se
sua reclamação não for satisfatoriamente atendida, você deixará de comprar desta empresa e
irá procurar outra. Afinal na Internet, o concorrente está a um clique de mouse.
Um dos assuntos mais discutidos no momento é representado pela sigla CRM – Customer
Relationship Management. Traduzindo teríamos: Gerenciamento das Relações com o Cliente.
CRM representa um conjunto de soluções – de hardware e software –, capazes de melhorar a
relação das empresas com os clientes, principalmente no atendimento às questões do cliente,
quer seja suporte técnico, dúvidas sobre novos produtos, etc.
Quem já não ligou para uma central de atendimento e teve que contar a mesma história uma
dezena de vezes. Você liga alguém atende. Você descreve o seu problema, a pessoa diz que não
é com ela e passa para um outro setor. Um novo atendente e a mesma história; você é passado
para um outro setor. Depois da décima transferência (considerando que você seja uma pessoa
paciente, senão após a terceira você já desligaria o telefone), você desliga irritado, sem ter
solucionado o problema. Muito provavelmente, esta empresa acaba de perder mais um cliente.
Clientes não são raros, raras sãs as empresas que conseguem fidelizá-lo de forma eficiente.
Melhorar o atendimento ao cliente, ou de uma maneira mais genérica, a relação dos clientes
com a empresa, é o objetivo do CRM. Ao ligar para uma central de atendimento, a pessoa
identifica-se através do seu código de cliente, o sistema de CRM busca em uma base de
dados consolidada todas as informações sobre o cliente. Então, ele descreve o problema,
que é inserido no sistema. Caso o atendente não seja capaz de solucioná-lo, a chamada é
transferida diretamente para a pessoa capaz de solucionar o problema. O cliente não precisa
repetir toda a história porque toda a descrição do problema também está acessível à pessoa
que irá atendê-lo (os dados foram passados pelo sistema de CRM, quando da transferência
do chamado). O cliente é atendido, soluciona o seu problema e fica satisfeito. Cliente
satisfeito continua comprando.
25
A descrição do parágrafo anterior representa uma situação ideal; é claro que os sistemas de
CRM ainda não são perfeitos. Porém novas técnicas estão sendo introduzidas, através da
possibilidade de atendimentos via Internet, acessando o site da empresa. Com a melhoria dos
sistemas de telecomunicações, poderemos tornar realidade um atendimento de alta qualidade
e conclusivo, através da Internet. Por exemplo, o cliente está pesquisando o catálogo de
produtos. Na página com os dados do produto, existe um link “Outras dúvidas”. Ao clicar
neste link, o cliente entra numa seção de bate-papo com um atendente da empresa. O cliente
pode colocar as suas dúvidas, que serão respondidas em tempo real. Tendo as dúvidas
solucionadas, há maior probabilidade de ser feito um pedido. Além disso as dúvidas do
cliente podem ser armazenadas no banco de dados. Quando uma determinada dúvida começar
aparecer com certa freqüência, os dados que a solucionam podem ser disponibilizados no
catálogo. Assim, os próximos clientes que tiverem a mesma dúvida, não precisarão entrar em
contato com o atendimento. Vejam que novamente estamos em um processo de aquisição de
informações, através do próprio site, e utilização destas informações para melhorar a qualidade
dos serviços e produtos oferecidos.
No B2B também existem muitas questões a serem gerenciadas. Para entendermos a

complexidade destas situações imagine o seguinte exemplo, ilustrado pela Figura 1.6.
Concessionárias Fornecedores
Servidor Servidor
Servidor Servidor
Servidor Servidor
Figura 1.6: A complexidade das questões envolvidas no B2B.
Temos uma rede de concessionárias que prestam serviços de manutenção para uma
determinada marca de automóveis. O objetivo é ter um controle automatizado de estoque.
Cada peça catalogada possui um nível mínimo de unidades em estoque. Quando este nível é
atingido, o banco de dados deve lançar um pedido para este item automaticamente. O
funcionamento do sistema é descrito a seguir.
26
O cliente vai na concessionária para comprar uma determinada peça. O atendente efetua a
venda e o estoque é atualizado. Se a peça atingir o nível mínimo, previamente estabelecido,
um pedido será automaticamente gerado. Este pedido contém informações sobre a
concessionária, bem como sobre as peças que estão sendo encomendadas.
As informações sobre o pedido são criptografadas para garantir a segurança, e o pedido é

enviado, via Internet, para o fornecedor da peça. Dentro de um prazo preestabelecido, a peça
é entregue, evitando que a mesma fique com estoque zerado.
Observe que, neste caso, existe uma troca de informações entre as concessionárias e os
fornecedores. Para que possa haver esta troca de informações, os sistemas das duas
empresas devem ser capazes de trocar dados em um formato comum, efetuando negócios
através da Internet.
Vamos introduzir algumas questões que complicam um pouco mais a infra-estrutura necessária
para a realização do B2B. Por exemplo, ao invés de comprar uma determinada peça sempre do
mesmo fornecedor, o sistema deve ser capaz de enviar o pedido para vários fornecedores, e
selecionar aquele que fizer a melhor oferta, tanto em termos de preço quanto de prazo de
entrega. Neste caso, a concessionária lança o pedido no seu site e aguarda as propostas dos
fornecedores. Após recebidas as respostas, uma delas é selecionada. Este parece ser um sistema
de leilão ao contrário, ou seja, o comprador anuncia que está precisando de um determinado
produto, e os fornecedores esforçam-se para fazer a melhor proposta. Esta forma de fazer compras
é conhecida como e-procurement. Em determinados casos, a lista de propostas está disponível
para todos os fornecedores, isto é, se um fornecedor A fez uma proposta e, depois, ao consultar
a lista, viu que um fornecedor B fez uma melhor do que a sua, ele pode alterar a sua proposta,
dentro do período de tempo estipulado pelo comprador, no nosso caso, a concessionária.
Vejam que mesmo no sistema de B2B, a lógica tem sido revertida em favor do cliente, isto é,
os fornecedores é que disputam o cliente, através de boas ofertas, preços competitivos e
prazos adequados de entrega.
Porém a criação de sistemas deste tipo é uma tarefa complexa. A todo o momento temos
acesso a informações de bancos de dados, questões de segurança no acesso a essas informações,
além de uma lógica bastante complicada. Em diversos pontos do processo podemos fazer uso
da tecnologia ASP, para criar soluções bem interessantes. O uso de páginas ASP, em conjunto
com outras tecnologias, possibilita a criação de soluções complexas como as exemplificadas
neste capítulo.
27
Vamos inserir mais alguns detalhes no nosso exemplo. Pode ser que além de fazer o pedido,
uma vez aprovada a compra, a concessionária deva fazer o pagamento do mesmo, por meio
de uma transação on-line. O pagamento pode ser feito, por exemplo, através de uma
transferência da conta corrente da concessionária para a conta corrente do fornecedor. Neste
ponto, precisamos introduzir o conceito de transação, o qual será bastante detalhado no
Capítulo 12, Conceitos Avançados: Transações e o Microsoft Transaction Services.
Uma transação, de maneira bastante simples, é um conjunto de ações que deve acontecer
como um todo, ou seja, todas as ações contidas na transação têm que ser finalizadas com
sucesso, ou nenhuma delas deve ser realizada. Caso uma das ações, contida na transação,
falhe, as que ainda estiverem pendentes devem ser canceladas; e as ações já realizadas devem
ser revertidas. Com isso garantimos que a transação acontece como um todo, ou que nenhuma
das suas ações são realizadas.
Para entender, na prática, o conceito de transações, vamos voltar ao exemplo anterior. Ao

efetuar um pagamento, o sistema deve transferir valores da conta corrente da concessionária,
para a conta corrente do fornecedor. Estas duas ações devem acontecer no contexto de uma
transação, conforme indicado abaixo:
Início da Transação
Ação 1: Debita o valor da conta corrente da concessionária.
Ação 2: Credita o valor na conta corrente do fornecedor.
Final da Transação
A primeira ação efetua o débito na conta corrente da concessionária. Suponhamos que a

Ação 1 ocorra com sucesso, porém na hora de fazer o crédito na conta corrente do fornecedor,
ocorra um problema, o que devemos fazer? O valor deve ser estornado para a conta da
concessionária, ou seja, a Ação 1 deve ser cancelada, uma vez que nem todas as ações dentro
da transação puderem ser concluídas com êxito. Vejam a importância do conceito de transação,
pois neste caso, se não usássemos transação, o valor seria debitado da conta corrente da
concessionária e não teria sido creditado na conta corrente do fornecedor.
Poderíamos entrar em níveis cada vez mais profundos, sobre os aspectos tecnológicos
necessários à realização do Comércio Eletrônico. Porém estas questões fogem ao escopo deste
livro (quem sabe em um trabalho futuro...). Neste livro estaremos aprendendo a utilizar a
tecnologia ASP para abordar alguns destes aspectos, através de exemplos práticos e
detalhadamente explicados.
28
Aplicações Para a Web

Embora utilizamos os exemplos de Comércio Eletrônico, CRM, e-procurement, etc., como
situações onde podemos utilizar a tecnologia ASP, não é somente nestas situações que a
tecnologia pode ser utilizada. Hoje em dia, com o aumento da complexidade das redes de
computadores baseadas em PC’s, existe uma tendência bastante acentuada em favor do
desenvolvimento de aplicações que seguem o modelo Web. São aplicações que são acessadas
através de um browser. Neste tópico iremos falar um pouco sobre aplicações Cliente/Servidor
tradicionais e os problemas deste tipo de modelo. Falaremos sobre aplicações em duas, três
ou n camadas, e onde a tecnologia ASP se encaixa, neste mundo de desenvolvimento de
aplicações habilitadas para a Web.
A Complexidade de Gerenciamento do Modelo

Cliente/Servidor e Aplicações em Duas Camadas
O modelo Cliente/Servidor foi criado tendo como base a descentralização dos dados e recursos
de processamento, em oposição ao modelo centralizado utilizado na época em que o mainframe
dominava absoluto. Neste modelo, conforme indicado pela Figura 1.7, em uma rede de
computadores existem uma ou mais máquinas que atuam como Servidores, disponibilizando
recursos para as demais máquinas, as quais atuam como Clientes.
Servidor de Arquivos Bancos de Dados Outros Servidores
Clientes Clientes Clientes Clientes Clientes
Figura 1.7: O Modelo Cliente/Servidor tradicional.
Conforme pode ser visto na Figura 1.7, temos servidores para arquivos, banco de dados e
outras funções, tais como: Servidores de impressão, servidores Web, etc. Tipicamente estas
redes são formadas por servidores, que são equipamentos com um maior poder de
processamento e armazenamento do que os Clientes, os quais, na maioria dos casos, são
microcomputadores ligados em rede.
29
Aplicações em Duas Camadas

No início da utilização do modelo Cliente/Servidor, as aplicações foram desenvolvidas
utilizando-se um modelo de desenvolvimento em duas camadas. Neste modelo, um programa,
normalmente elaborado em um ambiente de desenvolvimento – como o Visual Basic, Delphi
ou Power Builder –, é instalado em cada cliente. Este programa acessa dados em um servidor
de Banco de dados, conforme ilustrado na Figura 1.8.
Banco de Dados
No modelo de duas camadas, toda a

"Lógica do negócio" fica no Cliente.
Quando o programa Cliente é
instalado, são instaladas todas as
regras de acesso ao banco de dados.
Cliente Cliente Cliente Cliente Cliente
Figura 1.8: O modelo de desenvolvimento em duas camadas.
No modelo em duas camadas, temos um programa que é instalado no cliente, e que faz acesso
a um banco de dados residente no servidor de Banco de Dados. Na maioria dos casos, a
máquina do cliente é um PC rodando Windows, e a aplicação cliente é desenvolvida utilizando-
se um dos ambientes conhecidos, conforme citado anteriormente. Sendo a aplicação Cliente,
um programa para Windows (na grande maioria dos casos), a mesma deve ser instalada em
cada um dos computadores da rede, que farão uso da aplicação. É o processo de instalação
normal, para qualquer aplicação Windows. No modelo em duas camadas, a aplicação Cliente
é responsável pelas seguintes funções:
➥ Apresentação: O código que gera a interface visível do programa faz parte da aplicação
Cliente. Todos os formulários, menus e demais elementos visuais, estão contidos no
código da aplicação Cliente. Caso sejam necessárias alterações na interface do programa,
faz-se necessária a geração de uma nova versão do programa, e todos os computadores
que possuem a versão anterior, devem receber a nova versão, para que o usuário possa
ter acesso as alterações da interface. Aí que começam a surgir os problemas no modelo
em duas camadas: uma simples alteração de interface é suficiente para gerar a
necessidade de atualizar a aplicação, em centenas ou milhares de computadores. O
gerenciamento desta tarefa é algo extremamente complexo.
30
➥ Lógica do Negócio: As regras que definem a maneira como os dados serão acessados e
processados, são conhecidas como “Lógica do Negócio”. Fazem parte da Lógica do Negócio
desde funções simples de validação da entrada de dados, como o cálculo do dígito
verificador de um CPF, até funções mais complexas, como descontos escalonados para
os maiores clientes, de acordo com o volume da compra. Questões relativas à legislação
fiscal e escrita contábil também fazem parte da Lógica do Negócio. Por exemplo, um
programa para gerência de Recursos Humanos, desenvolvido para a legislação dos EUA,
não pode ser utilizado, sem modificações, por uma empresa brasileira. Isso acontece
porque a legislação dos EUA é diferente da legislação brasileira. Em síntese, as regras
para o sistema de Recursos Humanos são diferentes. Alterações nas regras do negócio
são bastante freqüentes em função das constantes mudanças na legislação do nosso
país. Com isso, faz-se necessária a geração de uma nova versão do programa cada vez
que uma determinada regra muda, ou quando regras forem sendo acrescentadas ou
retiradas. Desta forma, todos os computadores que possuem a versão anterior devem
receber a nova versão, para que o usuário possa ter acesso às alterações. Aqui temos
mais um problema do modelo em duas camadas: qualquer alteração nas regras do negócio
é suficiente para gerar a necessidade de atualizar a aplicação em centenas ou milhares
de computadores. O gerenciamento desta tarefa é algo extremamente complexo.
Com a evolução do mercado e as alterações da legislação, mudanças nas regras do negócio

são bastante freqüentes. Por isso o modelo de duas camadas, demonstrou-se de difícil
manutenção e gerenciamento, além de apresentar um TCO muito elevado, conforme
comentado na Introdução deste livro.
A outra camada, vem a ser o banco de dados, o qual fica armazenado em servidor da rede.
Uma aplicação desenvolvida em Visual Basic, a qual acessa um banco de dados em um servidor
Microsoft SQL Server, é um típico exemplo de uma aplicação em duas camadas.
Em busca de soluções para os problemas do modelo em duas camadas, é que surge a proposta
do modelo em três camadas, conforme analisaremos a seguir.
Aplicações em Três Camadas

Como uma evolução do modelo em duas camadas, surge o modelo de três camadas. A idéia
básica deste novo modelo em três camadas, é retirar as regras do negócio do cliente e centralizá-
las em um determinado ponto, o qual é chamado de servidor de aplicações. O acesso ao
banco de dados é feito através das regras contidas no servidor de Aplicações. Ao centralizar
as regras do negócio em um único ponto, fica muito mais fácil a atualização das mesmas. A
Figura 1.9, nos dá uma idéia geral do modelo em três camadas.
31
Servidor de Aplicações Servidor de Banco de Dados
No modelo de três camadas, toda a

Lógica do Negócio fica no servidor de
Aplicações. Com isso, a atualização
das regras do negócio fica mais fácil.
Figura 1.9: O modelo de desenvolvimento em três camadas.
Todo o acesso do cliente ao banco de dados é feito de acordo com as regras contidas no servidor
de Aplicações. O cliente não tem acesso ao banco de dados, sem antes passar pelo servidor de
Aplicações. Com isso as três camadas são as seguintes:
➥ Apresentação: Continua no programa instalado no cliente. Alterações na interface do
programa geram a necessidade de atualizar a aplicação em todos os computadores,
onde a mesma está sendo utilizada. Porém, cabe ressaltar que alterações na interface
são menos freqüentes do que alterações nas regras do negócio.
➥ Lógica: São as regras do negócio, as quais determinam de que maneira os dados serão
utilizados. Esta camada foi deslocada para o servidor de aplicações. Desta maneira,
quando uma regra do negócio for alterada, basta atualizá-la no servidor de aplicações.
Após a atualização, todos os usuários passarão a ter acesso a nova versão, sem que seja
necessário reinstalar o programa em cada um dos computadores da rede. Vejam que ao
centralizar as regras do negócio em um servidor de Aplicações, estamos facilitando a
tarefa de manter a aplicação atualizada.
➥ Dados: Nesta camada temos o servidor de Banco de Dados, no qual reside toda a
informação necessária para o funcionamento da aplicação. Cabe ressaltar que os dados
somente são acessados através do servidor de Aplicação, e não diretamente pela
aplicação Cliente.
Com a introdução da camada de Lógica, resolvemos o problema de termos que atualizar a aplicação
em centenas ou milhares de computadores, cada vez que uma regra do negócio fosse alterada.
Porém continuamos com o problema de atualização da aplicação, cada vez que sejam necessárias
mudanças na interface. Por isso que surgiram os modelos de n-camadas. No próximo tópico,
iremos falar um pouco sobre o modelo em quatro camadas. No Capítulo 12, Conceitos Avançados:
Transações e o Microsoft Transaction Services, estaremos falando sobre camadas adicionais.
32
Aplicações em Quatro Camadas

Como uma evolução do modelo de três camadas, surge o modelo de quatro camadas. A idéia
básica do modelo em quatro camadas é retirar a apresentação do cliente e centralizá-la em
um determinado ponto, o qual na maioria dos casos é um servidor Web. Com isso o próprio
cliente deixa de existir como um programa que precisa ser instalado em cada computador da
rede. O acesso à aplicação é feito através de um navegador, como o Internet Explorer ou o
Netscape Navigator. A Figura 1.10 nos dá uma idéia geral do modelo em quatro camadas.
Servidor Web Servidor de Aplicações Servidor de Banco de Dados
O Cliente só precisa de um Navegador para ter acesso a aplicação.
Figura 1.10: O modelo de desenvolvimento em quatro camadas.
Para acessar a aplicação, o cliente acessa o endereço da aplicação, utilizando o seu navegador.
Por exemplo http://www.empresa-abc.com/sistemas/cadastro.asp. Todo o acesso do cliente
ao banco de dados é feito de acordo com as regras contidas no servidor de Aplicações. O
cliente não tem acesso ao banco de dados, sem antes passar pelo servidor de Aplicações. Com
isso as quatro camadas são as seguintes:
➥ Cliente: Neste caso o cliente é o navegador utilizado pelo usuário, quer seja o Internet
Explorer, quer seja o Netscape Navigator, ou outro navegador qualquer.
➥ Apresentação: Passa para o servidor Web. A interface pode ser composta de páginas
HTML, ASP, ou qualquer outra tecnologia capaz de gerar conteúdo para o navegador.
Com isso alterações na interface da aplicação são feitas diretamente no servidor Web, e,
portanto, estas alterações estarão, automaticamente, disponíveis para todos os clientes.
Com isso não existe a necessidade de reinstalar a aplicação em todos os computadores
da rede. Fica muito mais fácil garantir que todos estão tendo acesso à versão mais
33
atualizada da aplicação. A única coisa que o cliente precisa ter instalado na sua máquina,
é o navegador. O acesso ao banco de dados é feito através do servidor de Aplicações.
➥ Lógica: São as regras do negócio, as quais determinam de que maneira os dados serão
utilizados. Esta camada está no servidor de Aplicações. Desta maneira, quando uma regra do
negócio for alterada, basta atualizá-la no servidor de Aplicações. Após a atualização, todos
os usuários passarão a ter acesso à nova versão, sem que seja necessário reinstalar o programa
em cada um dos computadores da rede. Vejam que, ao centralizar as regras do negócio em
um servidor de Aplicações, estamos facilitando a tarefa de manter a aplicação atualizada.
➥ Dados: Nesta camada temos o servidor de banco de dados, no qual reside toda a
informação necessária para o funcionamento da aplicação.
Com o deslocamento da camada de apresentação para um servidor Web, resolvemos o problema
de termos que atualizar a aplicação em centenas ou milhares de computadores, cada vez que
uma regra do negócio for alterada. Neste ponto a atualização das aplicações é uma tarefa mais
gerenciável, muito diferente do que acontecia no caso do modelo em duas camadas.
Os servidores de Aplicação, Web e Banco de Dados não precisam ser necessariamente

servidores separados, isto é, uma máquina para fazer o papel de cada um dos servidores. O
conceito de servidor de Aplicação, Web ou Banco de Dados é um conceito relacionado com a
função que o servidor desempenha. Podemos ter, em um mesmo equipamento, um servidor
de Aplicações, um servidor Web e um servidor de Banco de Dados. Claro que questões de
desempenho devem ser levadas em consideração, conforme analisaremos no próximo tópico.
Questões a Considerarmos nos Modelos em Três ou Mais Camadas

Muitas são as vantagens dos modelos em três ou mais camadas em relação à facilidade de
gerenciamento e atualização das aplicações. Porém deve-se levar em consideração o
desempenho e dimensionamento dos equipamentos que atuarão como servidores.
A partir do momento que estamos deslocando funcionalidades (tipicamente lógica e

apresentação), do cliente para um ou mais servidores, também estamos deslocando capacidade
de processamento em termos de memória RAM e processador. Funções que antes eram
executadas pelos clientes, utilizando memória e processador da estação cliente, agora foram
deslocadas para os servidores, consumindo memória e processador do servidor. Portanto, um
dos fatores chave é o correto dimensionamento dos equipamentos servidores.
Para fazer o dimensionamento dos servidores, precisamos conhecer o número de usuários que
irão acessar a aplicação, o nível de exigência de cada usuário e os recursos necessários pelos
softwares do servidor, entre outros fatores. Para determinar o nível de recursos necessários em
cada um dos servidores, você precisa fazer um estudo bem detalhado, de tal forma que o servidor
não fique subdimensionado. Quando o servidor não está corretamente dimensionado, a tendência
é que o acesso a aplicação fique bastante lento, causando insatisfação entre os usuários.
34
Neste modelo de desenvolvimento para a Web, em três ou mais camadas, existem diversos
pontos nos quais podemos utilizar a tecnologia ASP. Ao desenvolver a interface da aplicação,
pode-se combinar código HTML com código ASP. Utilizando ASP, podemos desenvolver
páginas que acessam o banco de dados, através do servidor de Aplicações. Questões como
autenticação de usuários, determinação do nível de acesso e segurança da aplicação podem
ser desenvolvidas com a utilização de ASP.
Para que você possa utilizar a tecnologia ASP da melhor maneira, com o objetivo de atender
às necessidades da sua aplicação, é importante que você conheça o modelo de desenvolvimento
para a Web, bem como a utilização de ASP, para a criação das aplicações. No decorrer deste
livro, estaremos abordando diversos tópicos relacionados à criação de aplicações Web.
O que é ASP?
Definir exatamente o que é ASP é uma tarefa que pode gerar controvérsias. Eu, particularmente,
gosto de definir ASP, como sendo: “Uma tecnologia que permite a criação de páginas dinâmicas,
nas quais além de código HTML, temos código ASP. É justamente este código, que fornece a
funcionalidade, que torna os sites dinâmicos, possibilitando a criação de aplicações Web”.
Não defino ASP como uma linguagem de Script porque, para a criação de páginas ASP, podemos
utilizar diferentes linguagens, tais como VBScript e Java Script. Neste livro, estaremos
utilizando o VBScript. Teremos os Capítulos 2 e 3 dedicados à linguagem VBScript.
Melhor do que definições formais, é entender como funciona uma página ASP. Vamos nos
basear na Figura 1.11.
Internet
http://www.abc.com/cep.asp Servidor Web

www.abc.com
A página ASP é processada no servidor. O resultado do

processamento é uma página HTML. O que retorna para o cliente
é a página HTML, já resultante do processamento no servidor Web.
Figura 1.11: Como funciona o ASP.
35
Vamos fazer alguns comentários sobre a Figura 1.11.
O servidor Web, no nosso caso o IIS da Microsoft, reconhece que a página solicitada é uma
página ASP, pela extensão da página. As páginas ASP devem ter a extensão .asp. Se criarmos
uma página ASP e a salvarmos com a extensão .htm ou .html, o IIS simplesmente ignora o
código ASP. A criação de páginas ASP está ligada à utilização do IIS. Não podemos, por
exemplo, criar páginas ASP e disponibilizá-las utilizando outros servidores Web, como o
Netscape Web Server ou o Apache. Já existem empresas trabalhando para disponibilizar a
tecnologia ASP para alguns servidores Web, rodando no sistema operacional Unix ou Linux.
O usuário digita o endereço http://www.abc.com/cep.asp e tecla Enter. Feito isso, o pedido é

enviado para o servidor www.abc.com. O servidor identifica a extensão do arquivo – .asp.
Como a extensão é .asp, a página cep.asp é passada para o “Interpretador ASP”, o qual faz
parte do IIS. O Interpretador percorre toda a página, executando o código ASP e retornando o
código HTML, resultante deste processamento. Com isso o que é retornado para o usuário,
que solicitou a página ASP, é apenas o código HTML resultante do processamento da página.
Este fato pode ser comprovado pedindo para que o navegador exiba o código fonte da página.
No caso do Internet Explorer 5.0, basta selecionar a opção Código fonte, do menu Exibir. O
fato do retorno ser HTML puro traz diversos benefícios, dentro os quais podemos destacar:
➥ Os algoritmos, bem como o próprio código ASP, ficam protegidos. Isto significa que o
usuário não tem acesso ao código das aplicações Web, desenvolvidas em ASP. Isto é
bastante desejável, uma vez que não seria interessante que qualquer usuário pudesse
copiar, livremente, os algoritmos e códigos da empresa.
➥ O acesso à páginas ASP é independente do navegador utilizado. Não importa se estamos
utilizando o Netscape Navigator, o Internet Explorer, ou qualquer outro navegador.
Uma vez que o que retorna é código HTML, qualquer navegador é capaz de acessar
uma página ASP.
Em contrapartida, o servidor precisa ser o IIS da Microsoft. Outros servidores ainda não
possuem um Interpretador ASP, o que inviabiliza a utilização de páginas ASP nos mesmos.
Outra questão importante a considerar é o fato de uma página ASP ser interpretada no servidor.
Isto significa que você não pode criar uma página ASP e testá-la localmente, simplesmente
abrindo-a no navegador. Se você criar uma página ASP, salvá-la no seu disco rígido local e
tentar abri-la no navegador, todo o código ASP será ignorado, uma vez que não existe o
Interpretador ASP. Para poder testar as suas páginas ASP, você terá que salvá-las em um
servidor Web, que esteja rodando o IIS.
Para acompanhar os exemplos deste livro, aconselho que você utilize o Windows 2000 Server
ou o Windows 2000 Professional, com o IIS 5.0 instalado. Caso você não disponha de um
computador, com um destes dois sistemas instalados, você pode utilizar o Windows 98 com
36
o Personal Web Server instalado. Porém, com o Personal Web Server, alguns dos exemplos
deste livro, principalmente os que utilizam as novas características do ASP 3.0, não irão
funcionar corretamente.
Na Introdução, você aprendeu a instalar o IIS 5.0. No próximo item, aprenderemos a criar um
diretório no servidor do IIS e salvar nossas páginas neste local, para depois podermos testá-
las. Sugiro que você também crie este diretório para salvar nossos exemplos. Iremos criar um
diretório para cada capítulo do livro, de tal forma que os exemplos possam ficar melhor
organizados.
IMPORTANTE
Para os exemplos deste livro, estou utilizando um servidor com o Windows 2000 Server. O
nome do servidor é www.groza.com. Se você estiver utilizando um servidor com um nome
diferente, substitua www.groza.com, pelo nome do servidor que você estiver utilizando, sempre
que o mesmo aparecer nos nossos exemplos.
Preparando o Servidor Para Acompanhar os Exemplos

Neste item vamos criar uma pasta chamada livro. Dentro desta pasta vamos criar uma subpasta
para cada capítulo do livro: Capitulo1, Capitulo2, e assim por diante, até o Capitulo12. Depois
aprenderemos a tornar esta pasta, parte integrante do servidor IIS. Não são todas as pastas de
um servidor que podem ser acessadas através do IIS.
Criando a Estrutura de Pastas e Subpastas

Utilizando o Windows Explorer, crie uma estrutura de pastas e subpastas, conforme indicado
na Figura 1.12. Lembre-se de não utilizar acentos para o nome das subpastas.
IMPORTANTE
Estou utilizando o drive C:. Você pode utilizar qualquer um dos drives disponíveis no seu
computador.
Agora vamos fazer com que a pasta livro (e conseqüentemente, todas as suas subpastas)
passe a fazer parte do servidor IIS www.groza.com.
37
Figura 1.12: Criando a estrutura de pastas e subpastas.
Tornando a Pasta Livro Parte dos Servidor IIS

Agora vamos aprender passo a passo, como tornar a pasta livro, parte do servidor IIS. Para
isso utilizaremos o console “Gerenciamento do Internet Services”, do Windows 2000 Server.
Para maiores informações sobre MMC, Snap-in e Consoles administrativos, consulte a Unidade
IV, do livro “Série Curso Básico & Rápido, Microsoft Windows 2000 Server”, de minha autoria
e publicado pela editora Axcel Books.
Tornando a pasta livro parte do servidor IIS www.groza.com:

1. Faça o logon como Administrador.
2. Clique em Iniciar/Programas/Ferramentas administrativas/Gerenciador do Internet
Services.
3. Será aberta a janela Internet Information Services, conforme indicado pela Figura 1.13.
4. Dê um clique duplo no nome do computador para abri-lo. No exemplo da Figura 1.13,
o nome do computador é servidor. Feito isso são exibidas três opções, conforme indicado
pela Figura 1.14.
38
Figura 1.13: O Gerenciador do Internet Services.
Figura 1.14: Opções de gerenciamento para o IIS 5.0.
5. Dê um clique no sinal de +, ao lado da opção Site da Web padrão, para expandir esta
opção. As opções que aparecem são as pastas que já fazem parte do site.
6. Dê um clique com o botão direito do mouse sobre Site da Web padrão. No menu que
surge, aponte para Novo. Nas opções que surgem, dê um clique na opção Pasta virtual,
conforme indicado pela Figura 1.15.
39
Figura 1.15: Criando uma nova pasta virtual, no servidor IIS 5.0.
7. Esta pasta virtual será associada à pasta livros, criada anteriormente.

8. Será exibida a primeira tela do Assistente para a criação de pasta virtual. Dê um clique
no botão Avançar, passando à segunda etapa do assistente.
9. Nesta segunda etapa, você precisa definir um nome (Alias) para esta pasta virtual.
Utilizaremos o mesmo nome da pasta: livro. Não é obrigatório que seja utilizado o
mesmo nome. Por questão de facilidade de administração e gerenciamento, sempre
utilizo nomes iguais para o nome da pasta no disco rígido e o nome no IIS 5.0.
10. Digite livro, conforme indicado pela Figura 1.16.
Figura 1.16: Digitando um nome para a pasta no IIS 5.0.
40
11. Dê um clique no botão Avançar, passando à terceira etapa do assistente.

12. Na terceira etapa, o assistente pergunta qual a pasta a ser associada com o nome vir-
tual informado na etapa anterior. Nesta etapa você pode digitar o caminho completo
para a pasta, ou utilizar o botão procurar, para localizar a pasta desejada. No nosso
exemplo, vamos digitar C:\livro. Com isso estamos associando a pasta C:\livro com a
pasta virtual livro, do servidor IIS 5.0.
13. Digite C:\livro, conforme indicado na Figura 1.17, e dê um clique no botão Avançar,
para ir para a quarta etapa do assistente.
Figura 1.17: Informando o caminho da pasta C:\livro.
14. Na quarta etapa do assistente, podemos configurar as permissões de acesso à pasta

livro. Certifique-se de que as opções Leitura e Executar scripts (ASP, por exemplo)
estejam marcadas, conforme indicado pela Figura 1.18. Se a opção Executar scripts
(ASP, por exemplo) não estiver marcada, o código ASP será ignoradas pelo IIS.
15. Dê um clique em Avançar. Surge a tela final do assistente.
16. Dê um clique no botão Concluir, para finalizar o assistente.
17. Você estará de volta ao Gerenciador do Internet Services.
18. Observe que um novo diretório virtual chamado livro, já aparece como parte integrante
do servidor IIS, conforme indicado na Figura 1.19.
41
Figura 1.18: Configurando as opções de segurança.
Figura 1.19: O diretório virtual livro, recém criado.
19. Feche o Gerenciador do Internet Services.
Uma vez criado o diretório virtual livro, o qual está associado à pasta C:\livro, como posso
acessar o conteúdo que for colocado dentro da pasta C:\livro, ou em uma das suas subpastas?
42
A resposta para a questão acima é bastante simples, basta que entendamos como são formados
os endereços em um servidor como o IIS. No nosso exemplo, o endereço do servidor é
www.groza.com. Ao digitarmos este endereço, estamos acessando a página principal do
servidor. Vamos supor que dentro do diretório livro fosse colocada uma página chamada
index.asp. Como faríamos para acessar esta página, através do navegador? O endereço da
página em questão, seria o seguinte: www.groza.com/livro/index.asp.
A Figura 1.20, descreve em detalhes a formação deste endereço.
Nome do diretório virtual
www.groza.com/livro/index.asp
Nome do servidor. Nome da página a

ser acessada
Figura 1.20: A formação de endereços no servidor IIS.
Observe que primeiro vem o nome do servidor, depois o nome do diretório virtual e, finalmente,
o nome da página a ser acessada.
Como é que fica o endereço, quando eu quero acessar uma página que está dentro de uma
subpasta da pasta livro?
Seguindo o mesmo raciocínio anterior, fica fácil responder a esta pergunta. Vamos supor que você
queira acessar uma página chamada cep.asp, que está na subpasta Capitulo1, a qual está na pasta
livro. Como fica o endereço para acessar esta página? A Figura 1.21, responde esta questão.
Nome do diretório virtual Nome da subpasta
www.groza.com/livro/Capitulo1/cep.asp
Nome do servidor Nome da página a

ser acessada
Figura 1.21: A formação de endereços em subpastas do

diretorio virtual, no servidor IIS.
43
Com isso, podemos ver que existe uma lógica bem definida para a formação dos endereços.
Apenas para confirmar, vamos dar mais alguns exemplos de formação de endereços. Considere
os casos abaixo indicados:
➥ Qual o endereço de uma página chamada teste.htm, gravada no diretório Capitulo6?
Resposta: www.groza.com/livro/Capitulo6/teste.htm.
➥ Qual o endereço de uma página chamada cadastro.asp, gravada no diretório Capitulo10?
Resposta: www.groza.com/livro/Capitulo10/cadastro.asp.
É importante que você entenda bem a maneira como o servidor IIS constrói os endereços de acesso
para as páginas gravadas em seus diretórios virtuais. Observe que o diretório virtual, é simplesmente
um nome que nos leva até o diretório real, gravado no disco. Podemos criar diversos diretórios
virtuais, em um único servidor IIS. Em um trabalho futuro, estarei escrevendo sobre o IIS 5.0.
IMPORTANTE
Você pode criar a estrutura sugerida neste tópico para acompanhar os exemplos deste livro.
Você também pode optar pela criação de uma estrutura diferente, neste caso, lembre-se de
utilizar a estrutura correta quando estiver acompanhando os nossos exemplos.
Alguns Exemplos Práticos

Agora que já sabemos como uma página ASP é processada e retornada para o usuário, e
também sabemos como acontece a formação de endereços no servidor IIS, chegou o momento
de começar a aprender a criar páginas ASP. Neste item, veremos, através de exemplos simples,
como criar código ASP e como testar as páginas criadas. Também comprovaremos, na prática,
que o que retorna do servidor para o navegador é apenas código HTML.
O Tradicional “Hello World”

Para começar, vamos criar uma página ASP bastante simples. Criaremos uma página ASP que
retorna a frase Hello World para o usuário, em diferentes tamanhos, utilizando a tag HTML
para cabeçalhos, do <H1> até <H6>. O <H1> é a de maior tamanho, e vai diminuindo até
chegar ao menor tamanho que é o <H6>.
NOTA
As listagens de código deste livro, apresentam numeração de linhas. Porém, ao criar o código,
não devem ser digitados os números das linhas. Os números são utilizados, apenas para
facilitar a explicação dos códigos de exemplo.
44
Abra o Bloco de notas (Iniciar/Programas/Acessórios/Bloco de notas) e digite o texto indicado

na Listagem 1.1.
Listagem 1.1 – O exemplo do Hello World.

1 <HTML>
2 <HEAD>
3 <TITLE>Minha primeira página ASP!!</TITLE>
4 </HEAD>
5 <BODY>
6 <%
7 Response.Write “<H1> Hello World </H1>”
13 %>
14 </BODY>
15 </HTML>
IMPORTANTE
Não digite o número das linhas. A numeração apenas aparece na listagem, para servir como
referência na hora de explicarmos o código ASP.
Salve este documento na subpasta Capitulo1, da pasta livro. Salve o arquivo com o nome de
exemplo1.asp. Se você também estiver utilizando o Bloco de notas, é importante digitar a
extensão .asp, pois caso contrário o Bloco de notas, colocará a extensão .txt.
Antes de explicarmos o código da Listagem 1.1, vamos testá-lo. Para testar o código faça o seguinte:
2. No campo endereço digite o seguinte: www.groza.com/livro/Capitulo1/exemplo1.asp
3. Tecle Enter.
Se não foram cometidos erros na hora da digitação da Listagem 1.1, o Internet Explorer mostra
o resultado da página exemplo1.asp, conforme indicado na Figura 1.22.
45
Figura 1.22: O resultado da página exemplo1.asp.
Agora vamos falar um pouco sobre o código da Listagem 1.1.
Nas linhas de 1 até 5, temos o código HTML normal para qualquer página. De interessante
apenas a tag <TITLE> </TITLE>, que define o título que será exibido na Barra de títulos do
Internet Explorer, quando você acessa a página. Isso pode ser comprovado na Figura 1.22,
onde vemos a frase: “Minha primeira página ASP!! – Microsoft Internet Explorer”, na Barra
de títulos.
A partir da linha 6 é que temos novidades. Observe, na linha 6, a utilização de <%. Esta
combinação de sinais, indica o início de um trecho com código ASP, ou seja, código que deve
ser interpretado pelo servidor IIS.
A partir da linha 7, temos a utilização do comando Response.Write. Este comando, retorna

para o navegador, o texto que está entre aspas. No exemplo da linha 7, será retornado
<H1>Hello World</H1>, que é justamente a tag de cabeçalho do HTML. As demais linhas
repetem a operação, para as demais tag’s de cabeçalho do HTML.
Na linha 13, a combinação de sinais %>, indica o final do trecho de código ASP, iniciado na
linha 6.
46
IMPORTANTE
Todo trecho de código ASP, inicia com um <% e deve ser finalizado com um %>. Podemos
ter mais do que um trecho de código ASP, dentro de um mesmo documento. Com isso podemos
ir mesclando trechos de código HTML, com trechos de código ASP. Essa possibilidade nos dá
uma grande flexibilidade na hora de construir aplicações para a Web. Sempre que for necessário
algum tipo de processamento em uma página, podemos inserir código ASP para fazer o
processamento desejado, e depois retornar o resultado no formato HTML.
As linhas 14 e 15 são tag’s HTML, que aparecem no final de uma página. A tag </BODY> é
o fechamento da tag <BODY>, e a tag </HTML> é o fechamento da tag <HTML>. Para
maiores detalhes sobre a linguagem HTML, consulte o livro HTML 4 Curso Básico & Rápido,
da editora Axcel Books.
Conforme descrito anteriormente, o código ASP é processado pelo IIS, e o resultado deste
processamento é retornado para o navegador do cliente no formato HTML. Podemos facilmente
comprovar isto.
Comprovando que o que retorna é somente o código HTML:

1. Se você não estiver com a página exemplo1.asp aberta, abra-a conforme descrito no
exemplo anterior.
2. No menu Exibir, clique na opção Código fonte.
3. Será exibida uma janela, conforme indicado pela Figura 1.23.
Figura 1.23: Código HTML, resultante do processamento da página exemplo1.asp.
47
4. Observe que o código retornado para o cliente, é código HTML puro, sem nenhum
sinal do código ASP. Isso impede com que o usuário possa ter acesso ao código dos
aplicativos desenvolvidos em ASP. Além disso qualquer navegador pode ser utilizado
para acessar uma página ASP, uma vez que o que é, efetivamente, enviado para o
cliente é código HTML.
5. Feche a janela indicada na Figura 1.23.
Nesse exemplo, criamos a nossa primeira página ASP. Onde aprendemos alguns detalhes
importantes e confirmamos outros, anteriormente apresentados. Apenas para revisar, vamos
enunciar os principais tópicos abordados:
➥ Uma página pode conter um ou mais trechos com código ASP.
➥ Cada trecho de código ASP, inicia com <% e termina com %>.
➥ Uma página ASP é identificada pela sua extensão, que deve ser .asp, caso contrário o
código ASP será ignorado pelo servidor IIS.
➥ O código ASP é processado pelo servidor IIS, e o resultado desse processamento é que
é retornado para o navegador do cliente, no formato de código HTML. Você pode,
facilmente, comprovar este fato, selecionando a opção Código fonte, do menu Exibir,
do Internet Explorer.
➥ Pelo fato do resultado do processamento de uma página ASP ser código HTML, qualquer
navegador está habilitado para acessar páginas ASP, e não somente o Internet Explorer.
Para encerrarmos este capítulo, vamos a mais um exemplo prático. Na página exemplo1.asp,
não temos nenhuma vantagem em utilizar código ASP. Poderíamos utilizar código HTML,
que obteríamos o mesmo resultado, sem maiores problemas.
No próximo exemplo, veremos como a utilização de ASP pode facilitar a criação de páginas
dinâmicas e aplicativos para a Web. Por enquanto não se preocupe em entender todos os
comandos do ASP e do VBScript. Teremos todo este livro para aprendê-los. O objetivo do
próximo exemplo é salientar a natureza dinâmica do ASP na geração de páginas.
Um Exemplo de Página Dinâmica

Vamos imaginar que você queira criar uma página, onde no início apareça a seguinte frase:
“Boqueirão do Leão, 25 de Junho de 2000”; ou seja, o nome da cidade, e data.
NOTA DO AUTOR
Estou utilizando Boqueirão do Leão, como exemplo, porque é a minha terra natal. Claro que
pouca gente conhece, pois é uma cidade pequena. Mas sempre que o tempo permite, volto
para rever familiares e amigos.
48
Poderíamos criar esta página utilizando HTML, porém todos os dias, no final do dia, teríamos
que editar a página para alterar a data, uma vez que a mesma não será atualizada
automaticamente. Utilizando código ASP, podemos fazer com que a página acesse a data do
servidor IIS e exiba a data sempre atualizada, na página ASP. Com isso, cada vez que a página
for acessada pelo usuário, o código ASP irá determinar a data do servidor e enviar uma página
com a data atualizada. Este é um exemplo, bastante simples, de uma página dinâmica; pois a
data é dinamicamente determinada pelo código ASP.
A página da Listagem 1.2 soluciona o problema proposto.
Abra o Bloco de Notas (Iniciar/Programas/Acessórios/Bloco de notas) e digite o texto indicado

na Listagem 1.2.
Listagem 1.2 – Página dinâmica – O exemplo da determinação da data.

1 <HTML>
2 <HEAD>
3 <TITLE>Minha segunda página ASP!!</TITLE>
4 </HEAD>
5 <BODY>
6 <%
7 data_atual=Date()
8 mes_atual=Month(data_atual)
9 Select Case mes_atual

10 Case 1
11 mes_desc=“Janeiro”
12 Case 2
13 mes_desc=“Fevereiro”
14 Case 3
15 mes_desc=“Março”
16 Case 4
17 mes_desc=“Abril”
18 Case 5
19 mes_desc=“Maio”
20 Case 6
21 mes_desc=“Junho”
22 Case 7
23 mes_desc=“Julho”
24 Case 8
25 mes_desc=“Agosto”
49
26 Case 9
27 mes_desc=“Setembro”
28 Case 10
29 mes_desc=“Outubro”
30 Case 11
31 mes_desc=“Novembro”
32 Case 12
33 mes_desc=“Dezembro”
34 End Select
35 Response.Write “Boqueirão do Leão, ” & Day(data_atual) & “ de ” & mes_desc & “ de ”

& Year(data_atual)
36 %>
37 <p> Aqui o restante da página...</p>
38 </BODY>
39 </HTML>
IMPORTANTE
Não digite o número das linhas. A numeração apenas aparece na listagem para servir como
referência na hora de explicarmos o código ASP. Esta orientação é válida para todas as listagens
que aparecerem neste livro.
Salve este documento na subpasta Capitulo1, da pasta livro. Salve o arquivo com o nome de
exemplo2.asp. Lembre-se de digitar a extensão .asp, pois caso contrário o Bloco de notas,
colocará a extensão .txt.
Antes de explicarmos o código da Listagem 1.2, vamos testá-lo. Para testar o código faça o seguinte:
2. No campo endereço digite: www.groza.com/livro/Capitulo1/exemplo2.asp.
3. Tecle Enter.
4. Se não foram cometidos erros na hora da digitação da Listagem 1.2, o Internet Explorer
mostra o resultado da página exemplo2.asp, conforme indicado na Figura 1.24.
50
Figura 1.24: O resultado da página exemplo2.asp.
Agora vamos falar um pouco sobre o código da Listagem 1.2.
Da linha 1 até a linha 5 temos código HTML.
A partir da linha 6 é que temos o código ASP, conforme indicado pelo sinal <%. Na linha 7,
utilizamos a função Date( ), para atribuir a data do sistema à variável data_atual. Na linha
8, utilizamos a função Month para extrair apenas o mês da data atual, e atribuir este valor
a variável mes_atual. A função Month, retorna um número inteiro entre 1 e 12, o qual
indica o mês do ano; 1=Janeiro, 2=Fevereiro, 3=Março e assim por diante. Por isso, das
linhas 9 até 34, utilizamos o laço de controle Select Case ... End Select para definir a variável
mes_desc, com base no valor retornado pela variável mes_atual. Veremos o laço de controle
Select Case ... End Select, em detalhes, no Capítulo 2.
Finalmente, na linha 35, utilizo o comando Response.Write, para retornar a data no formato
desejado. Observe que, com o comando Response.Write, posso retornar diversos valores, quer
sejam valores fixos de texto, colocados entre aspas (como no exemplo “Boqueirão do Leão,”),
quer sejam valores obtidos de variáveis, como no caso mes_desc. Para juntar as várias partes
que devem ser retornadas, utilizamos o operador &.
Da linha 37 até a linha 39 temos código HTML.
Conforme descrito anteriormente, o código ASP é processado pelo IIS e o resultado deste
processamento é retornado para o navegador do cliente no formato HTML. Podemos facilmente
comprovar isto.
51
Comprovando, mais uma vez, que o que retorna é somente o código HTML.
1. Se você não estiver com a página exemplo2.asp aberta, abra-a conforme descrito no
exemplo anterior.
2. No menu Exibir, clique na opção Código fonte.
3. Será exibida uma janela, conforme indicado pela Figura 1.25.
Figura 1.25: Código HTML resultante do processamento da página exemplo2.asp.
4. Observe que o código retornado para o cliente, é código HTML puro, sem nenhum sinal
do código ASP. Não vemos as funções utilizadas, nem mesmo o laço de controle Select
Case. O que retorna é o resultado do comando Response.Write. Isso impede que o usuário
possa ter acesso ao código dos aplicativos desenvolvidos em ASP. Além disso, como já
disse anteriormente, qualquer navegador pode ser utilizado para acessar uma página
ASP, uma vez que o que é, efetivamente, enviado para o cliente é código HTML.
5. Feche a janela indicada na Figura 1.25.
Veja que, neste exemplo, temos uma página em que o conteúdo é gerado dinamicamente, a
partir da hora do servidor. Você pode testar este comportamento dinâmico da página,
facilmente. Altere a data do servidor. Carregue novamente a página exemplo2.asp. Observe
que a mesma já exibe a nova data. Altere novamente a data do servidor e pressione F5 para
atualizar a página exemplo2.asp. Isso é geração dinâmica de conteúdo, embora até o momento
seja um conteúdo bastante simples. Nos próximos capítulos avançaremos um pouco mais.
Agora que já entendemos os diversos aspectos envolvidos com a criação de páginas ASP,
estamos aptos a aprender um pouco mais sobre a linguagem VBScript, que estaremos utilizando
neste livro. Isso será assunto para os Capítulos 2 e 3.
52
Capítulo 2 – Uma Introdução ao VBScript
Capítulo 2
Uma Introdução
ao VBScript
53
Introdução
Neste capítulo aprenderemos o básico a respeito de VBScript. Veremos exatamente o que é
VBScript, e onde utilizá-lo. Aprenderemos que é possível executar código VBScript, tanto no
navegador do cliente, quanto no servidor Web. Depois apresentaremos os aspectos básicos da
linguagem, tais como a declaração de variáveis, operadores e laços de controle. À medida em
que os conceitos forem sendo apresentados, iremos trabalhando com exemplos práticos, para
que os conceitos possam ser melhor entendidos. Também aprenderemos a criar sub-rotinas e
funções. Na parte final do capítulo, desenvolveremos alguns exemplos práticos de utilização
de VBScript, na criação de páginas. Ao completar este capítulo, você terá uma noção básica
de VBScript, e será capaz de criar soluções simples utilizando esta linguagem.
NOTA
Os exemplos apresentados nas listagens deste capítulo, podem ser criados utilizando-se um
redator de texto, como o Bloco de notas, e salvando os arquivos com a extensão .htm. Depois é
só abrir os mesmos no Internet Explorer e testar. Os números das linhas que aparecem nas
listagens, não devem ser digitados. Os mesmos foram incluídos, nas respectivas listagens,
apenas para facilitar o acompanhamento das explicações de cada exemplo.
O que é VBScript
VBScript é uma linguagem de criação de scripts, a qual é derivada do Visual Basic (VB) e do
VBA (Visual Basic for Applications). O Visual Basic é o ambiente de desenvolvimento gráfico
mais utilizado para o desenvolvimento de aplicações para o ambiente Windows. Como o
nome sugere, a programação em Visual Basic é baseada na linguagem de programação Basic.
O VBA é derivado do Visual Basic (de certa forma, podemos dizer que é um subconjunto do
VB), e é a linguagem utilizada para automatizar tarefas nos aplicativos do Microsoft Office.
Por exemplo, quando você precisa criar código para automatizar alguma tarefa no Microsoft
Excel ou no Microsoft Access, você está utilizando o VBA.
Se você já conhece VB ou VBA irá sentir-se bastante à vontade com VBScript. Muitos dos
comandos básicos, como estruturas de controle, declarações de variáveis, operadores e
funções, são idênticos. Na verdade alguns artigos definem VBScript como sendo um
subconjunto do VB.
Devemos considerar alguns fatos importantes, dentre os quais podemos destacar:

➥ VBScript é uma linguagem para a criação de scripts. Um script não é compilado para
gerar um programa executável, ao invés disso, cada linha do script é interpretada, e
executada.
54
➥ O código é escrito juntamente com uma página HTML. A página é enviada para o
navegador, o qual interpreta e executa o código VBScript, uma linha por vez. O suporte
à VBScript é nativo no Internet Explorer, já no Netscape Navigator o suporte à VBScript
se dá através da instalação de um plug-in.
NOTA
Um plug-in é um programa que estende a funcionalidade de um navegador. No nosso exemplo
estamos falando de um plug-in que permite que o Netscape Navigator interprete e execute
código VBScript.
➥ Com a utilização do VBScript, podemos ampliar as capacidades de uma página HTML,

tornando-a mais funcional e interativa. Podemos realizar cálculos, exibir mensagens
em janelas pop-up, detectar eventos tais como o clique em um link ou em um botão de
comando, criar menus interativos, etc. Podemos utilizar código VBScript para fazer a
validação dos dados de um formulário. Caso exista erro em algum campo, ou caso
algum campo obrigatório não tenha sido preenchido, podemos retornar uma mensagem
para o usuário, com os dados que o mesmo preencheu, indicando qual ou quais cam-
pos estão com problema. Com isso o usuário corrige os problemas, antes que os dados
sejam enviados para o servidor, reduzindo as possibilidades de erro e agilizando o
processamento das informações. São muitas as possibilidades.
➥ A linguagem VBScript foi desenvolvida tendo-se a segurança como uma de suas
diretrizes. Através do uso de VBScript, não é possível criar uma página, por exemplo,
que tenha acesso ao sistema de arquivos do computador e possa apagar ou modificar
informações. Evidentemente que a criatividade de hackers mal intencionados não tem
limites. Porém diversos cuidados foram tomados, pela Microsoft, para tornar a VBScript
uma linguagem segura.
➥ Pela semelhança com o Visual Basic, VBScript é uma linguagem de fácil aprendizado.
Se você já programa em Visual Basic, aprender VBScript será simplesmente uma questão
de saber o que é possível fazer com VBScript e quais são as suas limitações.
Conforme podemos concluir, VBScript é uma linguagem para a criação de scripts, os quais
ampliam a funcionalidade das páginas HTML.
No próximo item faremos uma revisão rápida os principais elementos de uma página HTML.
Como o código VBScript que roda no cliente é “escrito” dentro da própria página HTML, é
importante que saibamos identificar seus principais elementos. Além disso, conforme veremos
a partir do Capítulo 4, uma página ASP mistura as tags HTML com elementos de código ASP.
Por isso é importante que saibamos reconhecer os principais elementos de uma página HTML.
Para maiores informações sobre HTML, consulte o livro HTML 4 Curso Básico & Rápido, da
editora Axcel Books.
55
Uma Revisão Rápida de HTML

Conforme descrevemos na introdução desse livro, as páginas da Internet, são criadas
utilizando-se da linguagem HTML – Hypertext Markup Language. Uma tradução seria:
Linguagem de Marcação de Texto. As páginas ficam gravadas no servidor Web, e quando o
cliente digita um endereço solicitando determinada página, a mesma é transportada até o
navegador do cliente. O navegador interpreta o código HTML e exibe a página, já formatada.
Neste tópico, faremos uma revisão rápida sobre os principais elementos de uma página HTML,
bem como sobre os principais elementos para a construção de formulários, como campos
para a digitação de texto, que estarão sendo usados durante os exemplos deste livro.
Estrutura Básica de uma Página HTML

Todo documento HTML apresenta a mesma estrutura básica. Documentos HTML são criados
utilizando o que chamamos de “tag” ou marcador. Por exemplo, existe uma tag para fazer
com que o navegador exiba um determinado texto em negrito, outra tag para exibir texto em
itálico, um conjunto de tags para criar as linhas e colunas de uma tabela, e assim por diante.
Na Listagem 2.1, vemos um exemplo da estrutura básica de um documento HTML.
Listagem 2.1 – O exemplo do Hello World.

1 <HTML>
2 <HEAD>
3 <META NAME=“GENERATOR” Content=“Microsoft Front Page 4.0”>
4 <TITLE>Criando Sites dinâmicos com ASP 3.0 !!!</TITLE>
5 </HEAD>
6 <BODY>
7 <P>Uma Página HTML muito simples !!!!</P>
8 </BODY>
9 </HTML>
IMPORTANTE
Cabe novamente ressaltar, que os números de linha, não fazem parte do código HTML. Apenas
foram colocados na listagem para facilitar a explicação da mesma. Esta recomendação é válida
para todas as listagens apresentadas neste livro. Com isso, se você for digitar esta listagem,
não digite o número das linhas. Este fato pode ser comprovado pela Figura 2.1.
56
As maioria das tags HTML são formadas por pares. Conforme podemos ver na Listagem 2.1,
todo documento HTML, começa com a tag <HTML> e termina com uma tag </HTML>
(linhas 1 e 9, respectivamente).
Logo após a tag <HTML>, temos a tag <HEAD>. Dentro das tags <HEAD> e </HEAD>
podemos colocar diversas informações, muitas vezes chamadas de Metainformação. Contida
nesta seção do documento está a informação a respeito do próprio documento, como por
exemplo: qual o programa utilizado para gerar o documento, nome do autor, data de criação,
etc. As informações contidas nesta seção do documento, são utilizadas, muitas vezes, pelos
mecanismos de pesquisa da Internet, como o Altavista (www.altavista.digital.com) e o Yahoo
(www.yahoo.com). Uma tag especial, que podemos utilizar é a tag <TITLE> </TITLE>. O
texto colocado dentro desta tag, será exibido na Barra de títulos do navegador. Este fato pode
ser comprovado pela Figura 2.1.
Figura 2.1: Um exemplo de utilização da tag <TITLE> </TITLE>.
Observe o título que aparece na Barra de títulos da Figura 2.1. Logo após o título, no caso do
Internet Explorer, aparece a expressão: Microsoft Internet Explorer.
57
Após o par de tags <HEAD> </HEAD>, temos a tag <BODY>. A partir da tag <BODY>, na
linha 6, é que começa a parte do documento que será exibida pelo navegador. Tudo o que
estiver entre o par de chaves <BODY> </BODY> é conteúdo que deve ser exibido pelo
navegador. Neste nosso exemplo, muito simples, temos apenas um parágrafo de texto sendo
exibido. A tag que define uma parágrafo de texto é <P> </P>, conforme indicado na linha 7.
Esta é a estrutura básica de todo documento HTML.
Cada tag do HTML pode conter um ou mais atributos. Um atributo modifica a maneira como
o navegador exibe o conteúdo da página. Por exemplo, na Listagem 2.2, estamos utilizando o
atributo color da tag <FONT>, para modificar as características da fonte do texto a ser exibido.
Listagem 2.2 – Utilizando atributos da tag <FONT> </FONT>.

1 <HTML>
2 <HEAD>
5 </HEAD>
6 <BODY>
7 <P><FONT color=navy><B>Uma Página HTML muito simples !!!!</B></FONT> </P>

8 </BODY>
9 </HTML>
Neste caso, na linha 7, o atributo color é definido para o valor navy, o qual equivale a uma
fonte de cor azul marinho. Observe que a tag <FONT> </FONT> é utilizada dentro da tag
de parágrafo, para modificar as características da fonte deste parágrafo. Também utilizamos a
tag <B></B>, para fazer com que o texto fosse exibido em negrito. Ao visualizar este
documento, no navegador, o texto “Uma Página HTML muito simples !!!” será exibido em
negrito e com fonte de cor azul marinho.
Um estudo mais detalhado sobre as tags da linguagem HTML foge ao escopo deste livro.
Novamente indico o livro HTML 4 Curso Básico & Rápido, da editora Axcel Books, para
maiores informações sobre a linguagem HTML. Apenas como um exemplo de uma página
mais completa, considere a Listagem 2.3, onde utilizamos as tags para criação de tabelas.
<TABLE> e </TABLE>, para criar a tabela; <TR> e </TR> para criar novas linhas; <TD>
e </TD>, para criar as células dentro de uma linha da tabela.
Listagem 2.3 – Uma página HTML com diversas tags.

1 <HTML>
2 <HEAD>
58
3 <META NAME=“GENERATOR” Content=“Microsoft Visual Studio 6.0”>

5 </HEAD>
6 <BODY>
7 <P><FONT color=navy><B>Produção de SOJA da Região Sul !!!</B></FONT></P>
8 <TABLE border=1 cellPadding=1 cellSpacing=1 width=“75%”>
9 <TR>
10 <TD align=middle>Ano de Produção</TD>
11 <TD align=middle>Produção em Toneladas</TD>
12 </TR>
13 <TR>
14 <TD align=middle>1996</TD>
16 </TR>
17 <TR>
20 </TR>
21 <TR>
24 </TR>
25 <TR>
28 </TR>
29 </TABLE>
30 <P>Dados atualizados em -> 30/06/2000.</P>
31 </BODY>
32 </HTML>
Na Figura 2.2, temos o documento da Listagem 2.3, sendo exibido no navegador.
59
Figura 2.2: Um exemplo de utilização da tag <TABLE> </TABLE>.
No próximo item estudaremos algumas tags ligadas a criação de formulários com HTML.
Estudaremos estas tags em maiores detalhes, pois estaremos utilizando-as em diversos
exemplos deste livro.
Tags Para a Criação de Formulários HTML

A criação de formulários, permite que o usuário preencha alguns campos e envie os dados
para o servidor Web. Por exemplo, quando você está comprando pela Internet, em um
determinado momento, precisa fornecer informações, como o endereço de entrega, telefone
de contato, etc. Você preenche estas informações em um formulário. Normalmente, existe
um botão “Enviar”, no qual você deve clicar, após ter preenchido os dados necessários. São
muitas as aplicações onde utilizamos formulários.
Criando o Formulário – a tag <FORM> </FORM>

Um formulário é criado utilizando as tags <FORM> </FORM>. Na Listagem 2.4, temos um
exemplo de utilização da tag <FORM>.
60
Listagem 2.4 – Tag para a criação de formulários.

1 <HTML>
2 <HEAD>
4 <TITLE>Um exemplo simples de formulário.</TITLE>
5 </HEAD>
6 <BODY>
7 <P>Cadastro de Clientes:<BR>
8 Preencha os campos e clique no botão Enviar Dados.</P>
9 <P>
10 <FORM action=“” id=FORM1 method=post name=FORM1><BR>
{ Aqui teríamos tags HTML de definição do formulário }
11 </FORM>
12 </BODY>
13 </HTML>
O atributo mais importante da tag <FORM> é o action. No atributo action, devemos informar
o endereço de uma página ASP, um script CGI, ou qualquer outro elemento capaz de processar
os dados digitados em um formulário. O usuário preenche os campos do formulário, e, ao
clicar no botão Enviar, é chamada a página ou programa indicados no atributo action, o qual
é responsável por processar as informações do formulário.
Na Listagem 2.5, temos um exemplo em que uma página ASP é responsável por processar os
dados enviados pelo formulário.
Listagem 2.5 – O atributo action contém o endereço de uma página ASP.

1 <HTML>
2 <HEAD>
4 <TITLE>Um exemplo simples de formulário.</TITLE>
5 </HEAD>
6 <BODY>
7 <P>Cadastro de Clientes: <BR>

8 Preencha os campos e clique no botão Enviar Dados.</P>
9 <P>
10 <FORM action=“http://www.meusite.com/processa.asp” id=FORM1 method=post
name=FORM1><BR>
61
{ Aqui teríamos tags HTML de definição do formulário }
11 </FORM>
12 </BODY>
13 </HTML>
A Figura 2.3 ilustra este processo.
Banco de
Dados
Cliente Servidor Web
O usuário preenche os dados do formulário A página ASP, no servidor, recebe os dados enviados pelo
e clica no botão Enviar. A página ASP, formulário e armazena os dados em um banco de dados,
especificada na tag action é chamada. como o Microsoft SQL Server, ou Microsoft Access.
Figura 2.3: A Página ASP armazena os dados digitados no formulário, em um banco de dados.
Neste caso, a página ASP recebe os dados do formulário preenchido pelo cliente, processa esses
dados, e os armazena em um banco de dados. O servidor de Banco de Dados pode ser o mesmo
servidor Web, ou um equipamento separado. Após armazenar os dados no banco de dados, a
página ASP envia código HTML puro, de volta para o cliente. Normalmente a página HTML, que
retorna para o cliente, apresenta uma mensagem dizendo que os dados foram enviados com
sucesso, ou, no caso de erros, apresenta uma mensagem de erro, com a possível causa do problema.
A partir do Capítulo 4, estaremos aprendendo a criar páginas ASP para tratar com formulários
e armazenar os dados enviados em bancos de dados, bem como para fazer pesquisas em
banco de dados.
Criando uma Caixa de Texto – a Tag <INPUT TYPE=“TEXT”>

A tag <INPUT TYPE=“TEXT”> cria uma caixa de texto, na qual podem ser exibidos e também
digitados valores, quer sejam números ou textos. Esta tag possui os seguintes atributos:
62
Tabela 2.1 Atributos da tag <INPUT TYPE=“TEXT”>.
Atributo Descrição
TYPE Indica o tipo do campo, no caso de campos para digitar ou
exibir informação, utilizamos TEXT.
SIZE Determina o tamanho do campo que será exibido no
navegador.
MAXSIZE Tamanho máximo de caracteres do campo. MAXSIZE pode
ser maior do que SIZE. Neste caso o navegador rola o
conteúdo do campo, quando o mesmo atingir o número de
caracteres definido por SIZE.
NAME É o nome associado ao campo, o qual será utilizado pela
página ASP, para fazer referência a este campo.
VALUE É o valor padrão do campo. Por exemplo, para um campo
Cidade, podemos definir o atributo VALUE como São Paulo.
Neste caso, ao carregar o formulário no navegador, o campo
Cidade, já vem com o valor São Paulo. Caso seja necessário, o
usuário pode modificar este valor.
ID Utilizado por linguagens de script, como o VBScript.
Na Listagem 2.6, temos um exemplo de criação de um formulário com dois campos para
entrada de texto. Um para o nome, outro para o endereço.
Listagem 2.6 – Um formulário com dois campos de texto.

1 <HTML>
2 <HEAD>
4 <TITLE></TITLE>
5 </HEAD>
6 <BODY>
7 <P>Digite os dados solicitados, depois clique no botão Enviar:</P>
8 <FORM action=“” id=FORM1 method=post name=FORM1>
9 <P>Nome: <INPUT type=“text” id=nome name=nome maxlength=20 ></P>
63
10 <P>Endereço: <INPUT type=“text” id=endereco name=endereco maxlength=20 ></P>
11 </FORM>
12 </BODY>
13 </HTML>
Nas linhas 9 e 10, temos o código HTML, que cria os dois campos do formulário. A Figura
2.4 mostra este formulário, sendo visualizado no Internet Explorer, com os dados digitados
pelo usuário.
Figura 2.4: Visualizando um formulário simples no Internet Explorer.
Criando uma Caixa de Texto Para a Digitação

de Senhas – a tag <INPUT TYPE=“PASSWORD”>
A tag <INPUT TYPE=“PASSWORD”> cria uma caixa de texto, apropriada para a digitação
de senhas, pois enquanto o usuário digita a senha, são exibidos, somente asteriscos (*). Isso
impede que alguém, descubra a senha do usuário, simplesmente observando quando o mesmo
está preenchendo o formulário. Esta tag possui os atributos descritos a seguir.
Tabela 2.2 Atributos da tag <INPUT TYPE=“PASSWORD”>.
TYPE Indica o tipo do campo, no caso de campos para digitar
senhas, utilizamos PASSWORD.
64
SIZE Determina o tamanho do campo que será exibido no
navegador.
MAXSIZE Tamanho máximo de caracteres do campo. MAXSIZE
pode ser maior do que SIZE. Neste caso o navegador
rola o conteúdo do campo, quando o mesmo atingir o
número de caracteres definido por SIZE.
página ASP, para fazer referência ao campo.
VALUE É o valor padrão do campo. Normalmente é deixado em
branco.
Na Listagem 2.7, temos um exemplo de criação de um formulário com um campo para a

digitação de senhas.
Listagem 2.7 – Formulário com um campo para a digitação de senha.

1 <HTML>
2 <HEAD>
4 <TITLE></TITLE>
5 </HEAD>
6 <BODY>

11 <P>Senha: <INPUT type=“password” id=senha name=senha maxLength=10></P>
12 </FORM>
13 </BODY>
14 </HTML>
Na linha 11, temos o código HTML, que cria o campo para a digitação de senha. A Figura 2.5,
mostra este formulário, sendo visualizado no Internet Explorer, já com os dados digitados
pelo usuário.
65
Figura 2.5: O campo para senha exibe somente asteriscos (*).
Criando um “Check Box” – a tag <INPUT TYPE=“CHECKBOX”>

A tag <INPUT TYPE=“CHECKBOX”> cria um pequeno quadradinho, conhecido como Check
Box. Um Check Box, pode estar em dois estados: marcado ou desmarcado. Normalmente é
utilizado para a entrada de dados. Por exemplo, você pode estar utilizando um formulário
para pesquisa, no qual podem existir questões que permitam a escolha de mais do que uma
alternativa. Neste caso, a utilização de várias tags do tipo Check Box é o mais indicado. Esta
tag possui os seguintes atributos.
Tabela 2.3 Atributos da tag <INPUT TYPE=“CHECKBOX”>.
TYPE Indica o tipo do campo, neste caso, utilizamos
CHECKBOX.
CHECKED Indica se o Check Box está, inicialmente, marcado ou não.
página ASP, para fazer referência a este campo.
VALUE É o valor de retorno do campo, caso o Check Box seja marcado.
66
Na Listagem 2.8, temos um exemplo de criação de um formulário com a utilização de vários

Check Box.
Listagem 2.8 – Um formulário com vários Check Box.

1 <HTML>
2 <HEAD>
4 <TITLE></TITLE>
5 </HEAD>
6 <BODY>

12 <P>Certificações:
13 <INPUT id=MCP name=MCP type=“checkbox” value=“MCP”> MCP

14 <INPUT id=MCSE name=MCSE type=“checkbox” value=“MCSE”>MCSE
15 <INPUT id=MCDBA name=MCDBA type=“checkbox” value=“MCDBA”>MCDBA
16 <INPUT id=MCSD name=MCSD type=“checkbox” value=“MCSD”>MCSD</P>
17 </FORM>
18 </BODY>
19 </HTML>
Nas linhas de 13 a 16, temos o código HTML que cria os diversos Check Box. Quando o
usuário seleciona um determinado Check Box, o valor do atributo value é associado com o
Check Box, que, por sua vez, pode ser armazenado em um campo de uma tabela do banco de
dados, pela página ASP, responsável pelo processamento dos dados do formulário. A Figura
2.6 mostra este formulário, sendo visualizado no Internet Explorer, onde o usuário digitou
dados nos campos e marcou alguns dos Check Box disponíveis. Observe que mais do que um
Check Box pode ser marcado.
67
Figura 2.6: O usuário selecionou vários Check Box.
Criando um Conjunto de “Radio Buttons” – a tag <INPUT TYPE=“RADIO”>

A tag <INPUT TYPE=“RADIO”> cria um Radio Button. Um Radio Button pode estar em
dois estados: marcado ou desmarcado. Utilizamos estes elementos em grupos. A característica
de um grupo de Radio Buttons é que somente um dos Radio Button do grupo pode estar
selecionado. Se você clicar em um Radio Button que não está selecionado, este será
selecionado, e o que estava selecionado será desmarcado. Para criar um grupo de Radio Buttons,
é bastante simples, basta atribuir o mesmo valor para o atributo name, para todos os Radio
Buttons, que farão parte do grupo. Desta maneira, de todos os Radio Buttons que tiverem o
mesmo nome, somente um poderá estar selecionado em um determinado momento. Esta tag
possui os atributos descritos na Tabela 2.4.
Tabela 2.4 Atributos da tag <INPUT TYPE=“RADIO”>.
TYPE Indica o tipo do campo, neste caso, utilizamos RADIO.
NAME É o nome associado a todos os Radio Buttons que fazem
parte do mesmo grupo, o qual será utilizado pela página
ASP, para fazer referência ao campo.
68
VALUE É o valor de retorno do campo, caso o Radio Button seja
marcado.
Na Listagem 2.9, temos um exemplo de criação de um formulário com a utilização de um

grupo de Radio Buttons, para a seleção do tipo de cartão de crédito.
Listagem 2.9 – Um formulário com um grupo de Radio Buttons.

1 <HTML>
2 <HEAD>
4 <TITLE></TITLE>
5 </HEAD>
6 <BODY>

13 <INPUT id=MCP name=MCP type=“checkbox” value=“MCP”>MCP

17 <P>Selecione o Cartão de Crédito:</P>
18 <P>
19 <INPUT id=cartao name=cartao type=“radio” value=“Visa”>Visa
20 <INPUT id=cartao name=cartao type=“radio” value=“Master Card”>Master Card
21 <INPUT id=cartao name=cartao type=“radio” value=“Outros”>Outros
22 </P>
23 </FORM>
24 </BODY>
25 </HTML>
69
Nas linhas de 19 a 21, temos o código HTML que cria os diversos Radio Buttons. Quando o
usuário seleciona um dos Radio Buttons, o valor do atributo value é associado com o grupo
de Radio Buttons, que, por sua vez, pode ser armazenado em um campo de uma tabela do
banco de dados, pela página ASP responsável pelo processamento dos dados do formulário.
A Figura 2.7 mostra este formulário, sendo visualizado no Internet Explorer, onde o usuário
digitou dados nos campos e marcou uma das opções disponíveis para o cartão de crédito.
Nunca é demais lembrar que o usuário somente conseguirá marcar uma das opções.
Figura 2.7: O usuário somente consegue selecionar uma

das opções para o cartão de crédito.
Criando um Campo Para Digitação de Comentários

e Textos Maiores – a tag <TEXTAREA> </TEXTAREA>
A tag <TEXTAREA> </TEXTAREA> cria um campo para a digitação de quantidades maiores
de texto no formulário. Por exemplo, pode ser um campo para digitação de comentários,
críticas e sugestões, ou um campo para detalhar a descrição de um produto, no caso de uma
página que apresenta um catálogo de produtos. Esta tag possui os seguintes atributos.
70
Tabela 2.5 Atributos da tag <TEXTAREA> </TEXTAREA>.
NAME É o nome associado ao campo, o qual será utilizado pela página
ASP, para fazer referência ao campo.
WRAP Determina se o texto deve trocar automaticamente de linha,
quando for atingido o tamanho limite do campo. O valor padrão
para este campo é SOFT.
Na Listagem 2.10, temos um exemplo de criação de um formulário com a utilização de um

campo para a digitação de sugestões e comentários.
Listagem 2.10 – Um formulário com um campo para sugestões e comentários.

1 <HTML>
2 <HEAD>
4 <TITLE></TITLE>
5 </HEAD>
6 <BODY>


18 <P>
71

22 </P>
23 <TEXTAREA id=coment name=coment wrap=SOFT> </TEXTAREA>
24 </FORM>
25 </BODY>
26 </HTML>
Na linha 23, temos o código HTML, que cria o campo para a digitação do texto, para as
críticas e sugestões. A Figura 2.8 mostra este formulário, sendo visualizado no Internet Explorer,
com as críticas e sugestões digitadas pelo usuário.
Figura 2.8: O usuário digita suas críticas e sugestões.
Criando uma Lista de Opções (Caixa de Combinação) – a tag

<SELECT></SELECT> em Combinação com <OPTION></OPTION>
A tag <SELECT></SELECT> cria a lista, e as tags <OPTION></OPTION> definem os
elementos da lista. Esta lista é chamada de “Caixa de combinação”, na qual é apresentada uma
72
lista de valores, dentre os quais o usuário pode clicar selecionando uma ou mais opções. Cada
opção (definida pela tag <OPTION></OPTION>) possui um valor que é exibido na lista, e um
valor associado, caso esta opção seja selecionada. Este valor associado é que será armazenado
no banco de dados, pela página ASP. Veja os principais atributos da tag <SELECT></SELECT>.
Tabela 2.6 Atributos da tag <SELECT></SELECT>.
NAME É o nome associado à lista, o qual será utilizado pela
página ASP, para fazer referência ao campo.
MULTIPLE Pode ser True ou False. Caso seja True, permite que sejam
selecionados múltiplo itens.
Na Listagem 2.11, temos um exemplo de um formulário com a criação de uma lista bairro,
com três valores possíveis.
Listagem 2.11 – Um formulário com uma Caixa de combinação bairro.

1 <HTML>
2 <HEAD>
4 <TITLE></TITLE>
5 </HEAD>
6 <BODY>
12 <P>Selecione o bairro:
13 <SELECT id=bairro name=bairro>
14 <OPTION selected value=CENTRO>CENTRO</OPTION>
15 <OPTION value=CAMOBI>CAMOBI</OPTION>
16 <OPTION value=DORES>DORES</OPTION>
17 </SELECT>
18 </P>
73

25 <P>
29 </P>
31 </FORM>
32 </BODY>
33 </HTML>
Nas linhas 13 a 17, temos o código HTML que cria a Caixa de combinação. Na primeira opção
<OPTION selected value=CENTRO>CENTRO</OPTION>, a palavra “selected”, indica que
esta opção deve estar selecionada por padrão. A Figura 2.9 mostra este formulário, com a
opção DORES sendo selecionada na Caixa de combinação bairros.
Figura 2.9: Selecionando uma opção, na Caixa de combinação.
74
Finalizando o Formulário com os Botões Enviar Dados e Limpar Dados

– as Tags <INPUT TYPE=“SUBMIT”> e <INPUT TYPE=“CLEAR”>
Todo formulário deve ter um botão do tipo Submit. Ao clicar neste botão, é chamada a página
ASP (ou outro endereço indicado), indicada no atributo “action” do formulário. A página ASP
processa os dados enviados pelo formulário HTML, podendo, por exemplo, adicionar os dados
digitados em uma tabela de um banco de dados. Na Tabela 2.7, temos os atributos para um
botão do tipo Submit.
Tabela 2.7 Atributos da tag <INPUT TYPE=“SUBMIT”>.
TYPE Deve ser definido como Submit.
NAME Utilizado por linguagens de script, como o VBScript.
VALUE É o texto que será exibido no botão.
Embora não seja de uso obrigatório, é bastante comum termos um botão do tipo Reset. Ao
clicar neste botão, todos os campos do formulário são apagados. O projetista da aplicação
Web é quem irá definir a necessidade, ou não, da utilização de um botão do tipo Reset. Na
Tabela 2.8, temos os atributos para um botão do tipo Reset.
Tabela 2.8 Atributos da tag <INPUT TYPE=“RESET”>.
TYPE Deve ser definido como Reset.
NAME Utilizado por linguagens de script, como o VBScript.
VALUE É o texto que será exibido no botão.
Na Listagem 2.12, completamos o nosso formulário de exemplo, com a adição de um botão

do tipo Submit e outro botão do tipo Reset.
Listagem 2.12 – O formulário completo, com os botões do tipo Submit e Reset já incluídos.
1 <HTML>
2 <HEAD>
75

4 <TITLE></TITLE>
5 </HEAD>
6 <BODY>
7 <P>Digite os dados solicitados, depois clique no botão Enviar dados.</P>

12 <P>Selecione o bairro:
13 <SELECT id=bairro name=bairro>

14 <OPTION selected value=CENTRO>CENTRO</OPTION>
15 <OPTION value=CAMOBI>CAMOBI</OPTION>
16 <OPTION value=DORES>DORES</OPTION>
17 </SELECT>
18 </P>
20 <INPUT id=MCP name=MCP type=“checkbox” value=“MCP”> MCP

25 <P>
29 </P>
31 <P>
32 <INPUT id=“Enviar” name=“Enviar” type=“submit” value=“Enviar dados”>
76
33 <INPUT id=“Limpar” name=“Limpar” type=“reset” value=“Limpar dados”>

34 </P>
35 </FORM>
36 </BODY>
37 </HTML>
Nas linhas 32 e 33, temos o código HTML que cria os botões “Enviar dados” e “Limpar dados”,
respectivamente. A Figura 2.10, mostra o nosso formulário de exemplo, já completo.
Figura 2.10: O formulário de exemplo, já completo.
Com isso concluímos a nossa revisão, sobre HTML. Esta revisão fez-se necessária, pois, ao
longo de todo livro, estaremos utilizando formulários HTML, em conjunto com páginas ASP.
No restante deste capítulo, e no seguinte, estarei apresentando os fundamentos do VBScript.
77
Declaração e Utilização de Variáveis no VBScript

O que é uma Variável ?
Uma variável é um espaço da memória do computador, reservado para armazenar valores.
Este espaço de memória é ligado ao nome da variável. Na maioria das aplicações, faz-se
necessário o uso de variáveis. Por exemplo, você desenvolve uma página para realizar cálculos
financeiros, como por exemplo, empréstimos de longo prazo. O usuário digita um valor para
o empréstimo e o prazo desejado. Com base na taxa de juros utilizada, é feito o cálculo das
prestações. Os valores digitados pelo usuário precisam estar disponíveis no momento do
cálculo. A maneira de manter estes dados disponíveis é através da utilização de variáveis.
Quando o usuário digita o valor do empréstimo desejado, este valor é armazenado em uma
variável, para utilização no momento de realização dos cálculos.
Estaremos utilizando variáveis ao longo de todo livro. Este é um conceito existente em todas as
linguagens de programação, como por exemplo em Visual Basic, C, C++, e assim por diante.
Inserindo Código VBScript

Antes de continuarmos com variáveis, vamos aprender a inserir código VBScript em uma página
HTML. Existem marcadores especiais, que indicam o início e o fim de um código VBScript.
Para inserir código VBScript, utilizamos a tag <SCRIPT>, conforme indicado abaixo:
<SCRIPT LANGUAGE=vbscript>
<!—
Aqui vamos inserir o código VBScript.
—>
</SCRIPT>
NOTA
Observe a utilização do atributo LANGUAGE. Este atributo define qual a linguagem de script
que será utilizada. Além do VBScript, poderíamos utilizar o JavaScript. Neste livro, estaremos
utilizando VBScript.
NOTA
A utilização de <!— , no início do código, e de —>, no final do código, não é obrigatória. Estas
são as tags para comentários em páginas HTML. No entanto, é recomendável que se utilize
estas tags. Os navegadores mais antigos, tais como Internet Explorer 1.0, não reconhecem
VBScript; se não utilizarmos as tags de comentário, o código VBScript será exibido como se
78
fosse texto, o que não é desejável. Com a utilização das tags de comentário, garantimos que os
navegadores que não “entendem” VBScript, simplesmente ignorem o código.
Na Listagem 2.13, temos um exemplo simples da inserção de um script em um página HTML.
Listagem 2.13 – Um exemplo simples de VBScript.

1. <HTML>
2 <HEAD>
3 <TITLE>Um exemplo simples de VBScript !!!</TITLE>
4 </HEAD>
5 <BODY>
6 <SCRIPT LANGUAGE=“vbscript”>
7 <!—
8 x=Date()
9 MsgBox x
10 —>
11 </SCRIPT>
12 <P>UM EXEMPLO SIMPLES DE VBScript !!!</P>
13 </BODY>
14 </HTML>
Nas linhas 8 e 9, é que temos o código VBScript, propriamente dito. Não se preocupe com o
código, neste momento. Neste e no próximo capítulo, veremos detalhes sobre a utilização de
funções, tais como Date( ) e MsgBox. Ao abrir esta página no Internet Explorer, será aberta
uma janela, na qual é exibida a data do sistema, conforme indicado na Figura 2.11.
Figura 2.11: Mensagem exibida pelo código VBScript.
Declaração e “Tipo” de Variável

No VBScript não é obrigatória a declaração de variáveis. Porém é recomendável que declaremos
todas as variáveis, de tal forma que o código fique mais claro e de fácil compreensão. Para
declararmos uma variável, utilizamos o comando Dim, conforme exemplificado a seguir:
79
Dim x
Dim nome
Dim teste
O formato geral para o comando Dim é: Dim nome_da_variável. Também podemos declarar
mais do que uma variável, com um único comando Dim. Para isto, basta separar as variáveis,
com vírgula, conforme exemplificado a seguir:
Dim x,y,z
Dim nome
Dim teste1,teste2
IMPORTANTE
Observe que definimos o “tipo” de cada variável. O tipo define quais dados podem ser
armazenados em uma variável. Por exemplo, variáveis que armazenam valores numéricos, não
devem aceitar caracteres de texto. Variáveis que armazenam datas, não devem aceitar datas
inválidas, como por exemplo 30/02/2000. Toda variável no VBScript é do tipo Variant, isto significa
que a variável pode ser de qualquer tipo. O que define o tipo da variável é o valor que está
armazenado no momento. Existem funções de conversão de tipo, conforme veremos mais adiante.
Também podemos utilizar variáveis que não foram, explicitamente, declaradas com o comando
Dim. Com isso, a variável é criada na memória, no momento da sua utilização.
Na Listagem 2.14, temos um exemplo simples de utilização de variáveis não declaradas

explicitamente.
Listagem 2.14 – Utilização de variáveis não declaradas.

1 <HTML>
2 <HEAD>
4 </HEAD>
5 <BODY>
7 <!—
8 a=5
9 b=2
10 c=a+b
11 Msgbox “A variável C vale: ” & c
12 —>
13 </SCRIPT>
14 <P>Exemplo de utilização de variáveis.</P>
80
15 </BODY>
16 </HTML>
Ao abrir esta página no Internet Explorer, será aberta uma janela, conforme indicado na
Figura 2.12.
Figura 2.12: Mensagem exibida pelo código VBScript.
Podemos fazer com que seja obrigatória a declaração de todas as variáveis. Para isso, basta
utilizar o comando Option Explicit. Este comando deve ser inserido, bem no início do bloco
de script, antes de qualquer procedimento. Veremos mais sobre procedimentos, no próximo
capítulo. Caso você utilize este comando, variáveis não declaradas, serão simplesmente
ignoradas, não sendo gerada nenhuma mensagem de erro. Porém os valores que dependem
das variáveis não declaradas, não serão corretamente calculados.
Na Listagem 2.15, acrescentamos a opção Option Explicit.
Listagem 2.15 – Tornando obrigatória a declaração de variáveis.

1 <HTML>
2 <HEAD>
4 </HEAD>
5 <BODY>
7 <!—
8 Option Explicit
9 a=5
11 b=2
12 c=a+b
13 Msgbox “A variável C vale: ” & c
14 —>
15 </SCRIPT>
16 <P>Exemplo de utilização de variáveis.</P>
17 </BODY>
18 </HTML>
81
Ao abrir esta página no Internet Explorer, não será exibida a janela indicada na Figura 2.12;
isto porque as variáveis a, b e c não foram declaradas. Uma vez que a declaração tornou-se
obrigatória, com a adição do comando Option Explicit, as variáveis simplesmente não existem.
O Internet Explorer exibirá somente o texto “Exemplo de utilização de variáveis”, conforme
Figura 2.13: As variáveis não declaradas foram ignoradas.
O tipo Variant é formado de pequenas unidades, chamadas subtipos. Cada subtipo, identifica
de que maneira os dados são armazenados em uma variável do tipo Variant. Por exemplo,
variáveis do subtipo Integer são armazenadas de uma maneira diferente de variáveis do subtipo
Long. Na Tabela 2.9, temos uma descrição dos principais subtipos.
Tabela 2.9 Subtipos do tipo Variant.
Subtipo Descrição
Empty O valor é zero para variáveis numéricas ou uma string de
tamanho zero (“ ”), para variáveis de texto.
Null A variável não contém dados válidos.
Boolean Contém variáveis que somente podem assumir dois
valores: Verdadeiro ou Falso (True ou False).
Byte Valor inteiro, na faixa de 0 até 255.
Integer Valor inteiro, na faixa de -32768 até 32767.
Currency Valores na faixa de –923.337.203.685.447,5808 até
922.337.203.685.447,5807
82
Subtipo Descrição
Long Valor inteiro, na faixa de –2.147.483.648 até
2.147.483.647.
Date(Time) É um número que representa a data entre 01 de Janeiro
do ano 100, até 31 de Dezembro de 9999 (olha o bug do
ano 10000 chegando).
String Texto de tamanho variável, pode conter,
aproximadamente, dois bilhões de caracteres.
Object Pode conter um objeto qualquer, como um Controle
ActiveX, ou um Objeto COM+.
Error Pode conter um número de erro.
Fazendo Cálculos e Comparações

com o VBScript – Operadores
Para realizarmos cálculos e comparações entre variáveis, podemos utilizar operadores. Neste
item estaremos tratando sobre operadores aritméticos e operadores de comparação.
Fazendo Cálculos com os Operadores Aritméticos

Podemos realizar cálculos, utilizando operadores no VBScript. Na Tabela 2.10, temos uma
descrição dos operadores que podemos utilizar.
Tabela 2.10 Operadores do VBScript.
Operador Símbolo Descrição

Adição + Soma o valor de duas ou mais variáveis.
Subtração - Subtração entre duas ou mais variáveis.
Multiplicação * Multiplica os valores de duas ou mais variáveis.
Divisão / Divide o valor de duas ou mais variáveis.
Inteiro da Divisão \ Retorna a parte inteira, da divisão entre dois
números.
83
Operador Símbolo Descrição

Exponenciação ^ x^y – É o valor do número x, elevado na
potência y.
Módulo Mod Retorna o resto de uma divisão de dois números.
Na Listagem 2.16, temos um exemplo, demonstrando o uso destes diversos operadores.
Listagem 2.16 – Exemplo de utilização dos operadores aritméticos.

1 <HTML>
2 <HEAD>
3 <TITLE>Um exemplo simples do uso de Operadores Aritméticos !!!</TITLE>
4 </HEAD>
5 <BODY>
7 <!—
8 Option Explicit
9 Dim a
10 Dim b
11 Dim som, subtr, divis, mult, intdivs, expo, modul
12 a=25
13 b=3
14 som=a+b
15 subtr=a-b
16 divis=a/b
17 mult=a*b
18 intdivs=a\b
19 expo=a^b
20 modul= a mod b
21 ‘Uso de MsgBox para exibir os resultados.
22 MsgBox “Os números são: ” & a & “ e ” & b & Chr(13)

23 MsgBox “Soma: ” & som & Chr(13)& “Subtração: ” & subtr & Chr(13)
24 MsgBox “Divisão: ” & divis & Chr(13)& “Multiplicação: ” & mult & Chr(13)
25 MsgBox “Divisão inteira: ” & intdivs & Chr(13)& “Exponenciação: ” & expo & Chr(13)
26 MsgBox “Resto da divisão: ” & modul
84
27 —>
28 </SCRIPT>
29 <P>Exemplo de utilização de Operadores Aritméticos.</P>
30 </BODY>
31 </HTML>
Neste exemplo, nas linhas de 14 a 20, utilizamos os operadores aritméticos, para realizar
uma série de operações com os valores atribuídos às variáveis “a” e “b”. Depois, da linha 22
até a 26, utilizamos a função MsgBox, para exibir os resultados obtidos. O uso da função
MsgBox merece alguns comentários. Primeiro, utilizamos a função MsgBox para exibir
mensagens em uma pequena janela, chamada de janela pop-up. Podemos exibir texto e também
valores de variáveis. Quando temos que exibir diversos componentes, como um pouco de
texto, em seguida o valor de uma variável, depois mais texto, e assim por diante, devemos
utilizar o operador de concatenação &. Este operador permite que as diversas partes sejam
exibidas como uma única mensagem. Considere o exemplo da linha 22:
22 MsgBox “Os números são: ” & a & “ e ” & b & Chr(13)
Neste exemplo, primeiro, é exibido o texto “Os números são: ”, logo em seguida o valor da
variável a. Observe que as duas partes são concatenadas com o operador &. Depois concatenamos
o valor da variável b, e finalmente utilizamos a função Chr(13). A função Chr(número) envia o
caractere correspondente ao número digitado entre parênteses. Este número é o número do
caractere no padrão ASCII (American Standard Caracter Interchange Information). No código
ASCII, cada caractere possui um número associado; o número 13, é associado ao <ENTER>.
Com isso, estamos enviando um <ENTER> para a caixa de mensagem, o que equivale a uma
troca de linha. Portanto, utilizamos o Chr(13) para simular um <ENTER>, de tal maneira que
os dados não saiam todos “emendados”, na mesma linha. Ao abrir a página da Listagem 2.16,
no Internet Explorer, o código da linha 22, produz a mensagem da Figura 2.14.
Figura 2.14: MsgBox da linha 22.
Ao clicar em OK, uma nova mensagem é exibida, devido a função MsgBox da linha 23. O
código da linha 23, produz a mensagem da Figura 2.15.
85
86
Com o uso de operadores, podemos realizar uma série de operações sobre as variáveis existentes
no script.
Comparando Valores com os Operadores de Comparação

Em determinadas situações, existe a necessidade de efetuarmos comparações entre os valores
de duas variáveis ou expressões. Com base no resultado da comparação – Verdadeiro ou Falso
–, o nosso script pode seguir caminhos diferentes. Normalmente utilizamos comparações,
nas estruturas de controle do script, também conhecidas como laços de controle. Para que
possamos estudar os operadores de comparação, vamos apresentar uma das estruturas de
controle mais simples que existem no VBScript, a estrutura If Then Else. Abaixo temos um
exemplo do funcionamento da estrutura If Then Else:
If x>y Then
‘ Comandos a serem executados quando x for maior do que y
Else
‘ Comandos a serem executados quando x for menor do que y
End If
Conforme podemos ver, a estrutura If Then Else é bastante simples. Fazemos um teste no
início da estrutura. Se o valor do teste for verdadeiro, executamos os comandos na seqüência,
caso contrário, executamos os comandos após o Else. Note que utilizamos o operador de
comparação “maior do que >”, no caso x>y, estamos testando se x é maior do que y. Observe
que no exemplo acima, não serão executados comandos, caso x seja igual a y. Podemos utilizar
laços If Then Else mais complexos, como os do exemplo:
If x>y Then
‘ Comandos a serem executados quando x for maior do que y
ElseIf x=y Then
‘ Comandos a serem executados quando x for igual a y
Else
‘ Comandos a serem executados quando x for menor do que y
End If
87
Podemos utilizar tantos ElseIf, quantos forem necessários.
Na Tabela 2.11, temos uma descrição dos operadores que podemos utilizar.
Tabela 2.11 Operadores de comparação do VBScript.
Descrição Símbolo Descrição

Igualdade = É igual a.
Desigualdade <> É diferente de.
Maior que > É maior do que.
Menor que < É menor do que.
Maior ou igual >= É maior ou igual a.
Menor ou igual <= É menor ou igual a.
Na Listagem 2.17, temos um exemplo, demonstrando o uso destes diversos operadores.
Listagem 2.17 – Exemplo de utilização dos operadores de comparação.

1 <HTML>
2 <HEAD>
3 <TITLE>Exemplo de utilização dos operadores de comparação.</TITLE>
4 </HEAD>
5 <BODY>
7 <!—
8 Option Explicit
9 Dim x,y,z,k
10 x=12
11 y=15
12 z=20
13 k=15
14 If x<y Then
15 MsgBox “x é menor do que y.”
16 Else
88
17 MsgBox “x é maior do que y.”

18 End If
19 If y<x Then
20 MsgBox “y é menor do que x”
21 Else
22 MsgBox “y é maior do que x”
23 End If
24 If y<=k Then
25 MsgBox “y é menor ou igual a k”
26 Else
27 MsgBox “y é maior do que k”
28 End If
29 If x<>z Then
30 MsgBox “x e z são diferentes”
31 End If
32 —>
33 </SCRIPT>
34 <P>EXEMPLO DE OPERADORES DE COMPARAÇÃO:</P>

35 </BODY>
36 </HTML>
Ao carregarmos a página de exemplo da Listagem 2.17, no Internet Explorer, veremos uma

seqüência de mensagens, produzidas pela função MsgBox. Na seqüência, descrevo cada uma
destas mensagens.
O código das linhas 14 até 18 produz a mensagem indicada na Figura 2.19, pois x é menor
do que y.
Figura 2.19: MsgBox produzida pela linha 15, uma vez

que x é menor do que y.
89
Ao clicar em OK, uma nova mensagem é exibida, devido a função MsgBox da linha 22. Como
o teste y<x é falso, não é executada a linha 20, mas sim a linha 22. O código da linha 22
produz a mensagem da Figura 2.20.
Figura 2.20: MsgBox produzida pela linha 22,

uma vez que y não é menor do que x.
Ao clicar em OK, uma nova mensagem é exibida, devido a função MsgBox da linha 25. Como
o teste y<=k é verdadeiro (pois os valores de y e de k são iguais), é executada a linha 25. O
código da linha 25 produz a mensagem da Figura 2.21.
Figura 2.21: MsgBox produzida pela linha 25,

uma vez que y é igual a k.
Ao clicar em OK, uma nova mensagem é exibida, devido a função MsgBox da linha 30. Como o
teste x<>z é verdadeiro, é executada a linha 30, este código produz a mensagem da Figura 2.22.
Figura 2.22: MsgBox produzida pela linha 30, uma

vez que x é diferente de z.
90
O uso de operadores de comparação amplia o leque de possibilidades para nossos scripts.

Devemos ter alguns cuidados quando comparamos variáveis que possuem valores de tipos
diferentes, como por exemplo, número e texto. A Tabela 2.12 descreve o que acontece, quando
comparamos variáveis com valores de tipos diferentes.
Tabela 2.12 Comparando valores de tipos diferentes.
Comparação Resultado
Entre duas variáveis com valores numéricos. Comparação normal.
Entre duas variáveis com valores de texto. É efetuada uma comparação entre
valores de texto. Por exemplo Xuxa
é maior do que Abel.
Uma das variáveis possui um valor numérico O valor numérico é sempre considerado
e a outra possui texto. menor do que o texto.
Uma das variáveis possui um valor numérico Efetua uma comparação numérica, sem
e a outra esta vazia, atribuindo 0, para a valor.
variável vazia.
Uma das variáveis possui um valor de texto Efetua uma comparação de texto, sem
e a outra esta vazia, atribuindo texto de valor.
comprimento zero (“ ”), para a variável vazia.
As duas variáveis possuem um valor vazio. Ambas são consideradas iguais.
Com a utilização dos operadores aritméticos e de comparação, ampliamos bastante o leque

de opções na criação de scripts com o VBScript. No próximo item, veremos alguns detalhes
sobre “Escopo” de variáveis.
O Escopo das Variáveis, no VBScript

O escopo de uma variável define em que partes do código de um script a variável pode ser
utilizada. Em VBScript, podemos ter dois escopos para as variáveis:
➥ Escopo de script: Uma variável declarada dentro do script, mas fora de qualquer
procedimento. Com isso a variável pode ser utilizada dentro de todo o bloco de código
do script, inclusive dentro dos procedimentos, caso exista algum. Uma variável
declarada em nível de script, existe enquanto o mesmo estiver sendo executado. Quando
falamos de script, não é um único bloco de script, pois sabemos que uma página pode
conter mais do que um bloco. Uma variável declarada em nível de script, poderá ser
utilizada em todos os blocos de script da página.
91
➥ Escopo de procedimento: A variável somente pode ser utilizada dentro do procedimento

onde a mesma é declarada. Se tentarmos utilizar a variável fora do procedimento,
onde foi declarada, não teremos acesso a mesma. Uma variável declarada em nível de
procedimento existe enquanto o procedimento estiver sendo executado.
NOTA
Um procedimento é um bloco de código que pode ser chamado em qualquer ponto do script.
Ao chamarmos um procedimento, a execução é deslocada para dentro do procedimento. Após
concluído o procedimento, a execução segue com a linha seguinte à que chamou o procedimento.
Veremos maiores detalhes sobre procedimentos e funções no final deste capítulo.
Vamos analisar o exemplo da Listagem 2.18, para entendermos melhor este conceito de escopo
de uma variável. Neste exemplo, também estaremos introduzindo um conceito muito
importante, o conceito de evento e procedimentos que executam código em resposta a eventos.
Listagem 2.18 – Exemplo para análise do escopo de variáveis.

1 <HTML>
2 <HEAD>
3 <TITLE>Analisando o escopo de variáveis !!!</TITLE>
4 <SCRIPT ID=clientEventHandlersVBS LANGUAGE=“vbscript”>

5 <!—
6 ‘ No evento onclick, do botão analisar,
7 ‘ chamamos o procedimento proc1.
8 Sub analisar_onclick
9 Call proc1
10 End Sub
11 —>
12 </SCRIPT>
13 </HEAD>
14 <BODY>
15 <SCRIPT LANGUAGE=vbscript>
16 <!—
17 ‘ As variáveis declaradas abaixo
18 ‘ Serão visíveis em todo o script
92
19 Dim x, y
20 x=10
21 y=20
22 ‘Agora vamos criar um procedimento

23 ‘E declarar duas variáveis dentro deste procedimento.
24 ‘Estas variáveis somente serão visíveis,
25 ‘Dentro deste procedimento.
26 Sub proc1()
27 Dim a, b
28 a=5
29 b=7
30 MsgBox “x= ” & x & “ y= ” & y & “ a= ” & a & “ b= ” & b
31 End Sub
32 ’ Agora vamos tentar utilizar os valores de a e b

33 ’ Fora do procedimento proc1.
34 ’ Observe que a variável aux1 não é calculada
35 ’ corretamente, uma vez que os valores de a e b
36 ’ não estão disponíveis, fora do procedimento proc1.
37 aux1=a+b
38 MsgBox “aux1= ” & aux1
39 —>
40 </SCRIPT>
41 <P>EXEMPLO PARA ANÁLISE DO ESCOPO DE VARIÁVIES.</P>

42 <P>CLIQUE NO BOTÃO ANALISAR - >>
43 <INPUT id=“analisar” name=“analisar” type=“button” value=“analisar”></P>
44 </BODY>
45 </HTML>
Vamos analisar uma série de detalhes sobre esta listagem.

➥ Na linha 43, temos a tag INPUT, com type=“button”, esta tag insere um botão de
comando, no qual o usuário pode clicar. Na Figura 2.23, podemos ver a página com o
botão analisar.
93
Figura 2.23: Botão analisar, criado com a tag <INPUT TYPE=“BUTTON”>.
➥ Ao carregar esta página no Internet Explorer, serão executadas as linhas 37 e 38, pois
todo código, que não estiver dentro de um procedimento, é automaticamente executado
quando a página é carregada. Este código exibe o valor da variável aux1. Porém,
conforme podemos notar na Figura 2.24, o valor exibido é zero (e não 12 que seria a
soma de a=5 com b=7). Isto acontece porque as variáveis “a” e “b” foram definidas
dentro do procedimento proc1, e somente existem quando o procedimento proc1 for
chamado. Neste caso, como não existem os valores, a variável aux1 fica com o seu
valor inicial de quando foi declarada, que por padrão do VBScript é zero.
Figura 2.24: Variável aux1, com seu valor zerado.
➥ Qualquer coisa que o usuário faça em uma página é considerado um evento. Por
exemplo, quando o usuário clica no botão analisar, é gerado o evento analisar_onclick.
Podemos escrever código VBScript para qualquer evento, definido no modelo de eventos
do Internet Explorer. No nosso exemplo, nas linhas de 8 a 10, definimos código em
94
resposta ao evento onclick, do botão analisar. Quando o usuário clicar no botão analisar,
este evento é gerado e o código da linha 9 é executado. Este código chama o
procedimento proc1. Dentro do procedimento proc1, são definidas as variáveis a e b
(linhas 27 a 29). Depois é utilizado o comando MsgBox para exibir os valores das
variáveis x, y, a e b. Como as variáveis x e y foram declaradas em nível de script, isto é,
fora de qualquer procedimento, as mesmas são acessíveis em qualquer ponto do script.
Com isso a mensagem exibe os valores corretamente, conforme indicado na Figura
2.25. Veremos maiores detalhes sobre eventos e procedimentos no Capítulo 4.
Figura 2.25: Variáveis em nível de script são visíveis em toda a página.
➥ Todas as linhas que iniciam com um apóstrofe (‘) são comentários. Linhas de comentários
servem para documentar nossos scripts, facilitando a interpretação dos mesmos.
Com esse exemplo foi possível verificar, na prática, o conceito de escopo (algumas vezes
chamado de visibilidade) das variáveis. No próximo item, trataremos das estruturas e laços
de controle, que são elementos muito importantes na criação de scripts.
Estruturas Para Controle de Fluxo em VBScript

Para que possamos criar aplicações com utilidade prática, aplicadas na solução de problemas
reais, precisamos poder controlar o fluxo de execução de um script. No VBScript, temos
diversas “estruturas” que permitem um controle bastante eficaz do fluxo de execução. Neste
item, estaremos estudando diversas destas estruturas.
Estruturas de Decisão
Em um primeiro grupo, temos as chamadas estruturas de decisão. São estruturas que realizam
um teste lógico, e executam determinados comandos quando o teste resultar verdadeiro, ou
um conjunto diferente de comandos, quando o teste resultar falso. Agora passaremos a analisar
as estruturas de decisão, disponíveis no VBScript.
95
A Estrutura If...Then
A estrutura If...Then é uma das estruturas de decisão mais conhecidas. Toda linguagem
implementa esta estrutura. É utilizada para executar determinados comandos, caso uma
condição seja verdadeira. A forma geral desta estrutura é a seguinte:
If condição Then
Comandos a serem executados, caso a condição seja verdadeira.
End If
Uma condição é testada; caso a condição seja verdadeira, um ou mais comandos podem ser
executados. Considere o exemplo da Listagem 2.19.
Listagem 2.19 – Um exemplo simples da estrutura If...Then.

2 <!—
3 Dim x, y
4 x=10
5 y=15
6 If x<y Then
7 MsgBox “x é menor do que y”
8 End If
9 —>
10 </SCRIPT>
Neste exemplo, a mensagem “x é menor do que y”, será exibida, uma vez que o teste x<y é
verdadeiro, conforme podemos constatar pelos valores atribuídos às variáveis x e y.
A Estrutura If...Then...Else
A estrutura If...Then...Else, acrescenta mais uma possibilidade à estrutura If...Then. É utilizada
para executar determinados comandos, caso uma condição seja verdadeira, ou um conjunto
diferente de comandos, caso a condição seja falsa. A forma geral desta estrutura é a seguinte:
If condição Then
Else
Comandos a serem executados, caso a condição seja falsa.
End If
96
Uma condição é testada; caso a condição seja verdadeira, um determinado comando, ou

conjunto de comandos será executado; caso a condição seja falsa, um comando, ou conjunto
de comandos diferentes, será executado. Considere o exemplo da Listagem 2.20.
Listagem 2.20 – Um exemplo simples da estrutura If...Then...Else.

2 <!—
3 Dim x, y
4 x=15
5 y=10
6 If x<y Then
8 Else
9 MsgBox “x é maior do que y”
10 End If
11 —>
12 </SCRIPT>
Neste exemplo, a mensagem “x é maior do que y” será exibida, uma vez que o teste x<y é
falso, conforme podemos constatar pelos valores atribuídos às variáveis x e y.
A Estrutura If...Then...ElseIf...Else
A estrutura If...Then...ElseIf...Else nos dá um poder maior, para testarmos diversas possibilida-
des. É utilizada quando precisamos realizar mais do que um teste lógico. Neste caso, para cada
novo teste que se faça necessário, utilizamos um ElseIf. A forma geral desta estrutura é a seguinte:
If condição Then
ElseIf condição 2
Comandos a serem executados, caso a condição2 seja verdadeira.
ElseIf condição 3
Comandos a serem executados, caso a condição3 seja verdadeira.
...
ElseIf condição n
Comandos a serem executados, caso a condição n seja verdadeira.
Else
Comandos a serem executados, caso nenhuma das condições anteriores seja
verdadeira.
End If
97
Uma condição é testada; caso a condição seja verdadeira, um determinado comando, ou

conjunto de comandos será executado; caso a condição seja falsa, podemos fazer um segundo
teste (condição 2). Caso a segunda condição seja verdadeira, um determinado comando, ou
conjunto de comandos será executado, e assim por diante, para n condições. Caso nenhuma
das condições seja verdadeira, os comandos após a cláusula Else, serão executados. Considere
o exemplo da Listagem 2.21.
Listagem 2.21 – Um exemplo simples da estrutura If...Then...ElseIf...Else.

2 <!—
3 Dim x, y
4 Dim z, k
5 Dim w, p
6 x=35
7 y=30
8 z=25
9 k=20
10 w=15
11 p=10
12 If x<y Then
14 ElseIf x<z Then
15 MsgBox “x é menor do que z”
16 ElseIf x<k Then
17 MsgBox “x é menor do que k”
18 ElseIf x<w Then
19 MsgBox “x é menor do que w”
20 ElseIf x<p Then
21 MsgBox “x é menor do que p”
22 Else
23 MsgBox “x é o maior dos números”
24 End If
25 —>
26 </SCRIPT>
Neste exemplo, a mensagem “x é maior dos números” será exibida, uma vez que todos os testes
falham (pois x é o maior número). Será executado o comando da linha 23, logo abaixo do Else.
Mas o que acontece, quando um dos ElseIf é verdadeiro?
98
Os teste vão sendo feitos. Quando o teste de um dos ElseIf for verdadeiro, os comandos abaixo
do ElseIf verdadeiro, serão executados e o laço será encerrado. Em resumo, quando um dos
ElseIf apresentar um teste verdadeiros, os comandos relacionados serão executados, e os demais
não serão avaliados, seguindo a execução para o primeiro comando, após o End If.
A Estrutura Select...Case
Quando precisamos realizar uma série de testes, é mais eficiente utilizarmos uma estrutura
Select...Case, do que utilizarmos uma série de testes utilizando a estrutura If...Then...ElseIf.
O funcionamento da estrutura Select...Case é bastante intuitivo. Considere o exemplo da

Listagem 2.22.
Listagem 2.22 – Um exemplo simples da estrutura Select...Case.

1 <SCRIPT LANGUAGE=vbscript>
2 <!—
3 Dim x
4 x=10
5 Select Case x
6 Case 2
7 MsgBox “x vale 2 !”
8 Case 4
10 Case 6
12 Case 8
14 Case 10
16 Case Else
17 MsgBox “x não é um número par, menor do que 12 ”
18 End Select
19 —>
20 </SCRIPT>
A estrutura Select Case x vai testar o valor de x. Em cada um dos Case, o valor de x está sendo
testado. Quando for encontrado um valor coincidente com o de x, os comandos abaixo deste
Case serão executados. No nosso exemplo, o comando MsgBox “x vale 10 !”, abaixo de Case
10, será executado. O comando abaixo do Case Else somente será executado, se todos os
testes anteriores falharem.
99
O uso da estrutura Select...Case torna o código mais eficiente e de mais fácil leitura.
Estruturas de Repetição
Em determinadas situações, precisamos repetir um ou mais comandos, um número específico
de vezes, ou até que uma determinada condição torne-se verdadeira ou falsa. Para isso,
utilizamos as chamadas estruturas de repetição, ou laços. A partir de agora, estaremos
analisando as estruturas de repetição disponíveis.
A Estrutura For...Next
Utilizamos o laço For...Next para repetir um segmento de código, um número determinado de
vezes. Utilizamos esta estrutura, quando já sabemos o número de vezes que uma determinada
seção de código deve ser repetida. Neste tipo de estrutura, normalmente, utilizamos uma
variável como contador. Este contador varia de um valor inicial até um valor final. O formato
geral desta estrutura é o seguinte:
For contador=inicio to fim incremento
Comando1
Comando2
...
Comandon
Next
No início a variável contador tem o valor definido para um determinado valor. Em cada
passagem do laço, a variável contador é incrementada pelo valor definido em incremento.
Caso não seja definido o incremento, será utilizado o padrão 1.
Considere o exemplo da Listagem 2.23.
Listagem 2.23 – Um exemplo simples da estrutura For...Next.

2 <!—
3 Dim x
4 x=10
5 Soma=0
6 ‘ Faz a soma dos dez primeiros números maiores do que zero
7 For i=1 to x
8 Soma = Soma +i
100
9 Next
10 MsgBox “Valor da Soma = ” & Soma
11 —>
12 </SCRIPT>
Neste exemplo, a variável i inicia com o valor 1. Em cada passo, o valor de i é acrescentado à
variável Soma. Como o incremento não foi definido, será utilizado o padrão que é 1. Com
isso, ao final do laço For...Next, a variável Soma terá armazenado o valor da soma dos dez
primeiros números inteiros, conforme indicado pela Figura 2.26.
Figura 2.26: A soma dos dez primeiros números inteiros.
Poderíamos utilizar um valor de incremento diferente de 1, por exemplo, para obter a soma
somente dos números ímpares, menores do que 10. Considere o exemplo da Listagem 2.24.
Listagem 2.24 – Um exemplo simples da estrutura For...Next.

2 <!—
3 Dim x
4 x=10
5 Soma=0
6 ‘ Faz a soma dos cinco primeiros números ímpares maiores do que zero
7 For i=1 to x Step 2

8 Soma = Soma +i
9 Next
11 —>
12 </SCRIPT>
Com este script, obtemos o resultado indicado na Figura 2.27.
101
Figura 2.27: A soma dos cinco primeiros números ímpares.
A Estrutura Do...Loop
Esta estrutura pode ser utilizada para repetir um trecho de código, enquanto uma determinada
condição for verdadeira, ou até que uma determinada condição torne-se verdadeira. Podemos
utilizar dois operadores condicionais diferentes: While ou Until. Os operadores While ou
Until, podem ser utilizados de duas maneiras diferentes: no início ou no final do laço. Com
isso temos quatro situações distintas; vamos analisar cada uma delas a partir de agora.
A Estrutura Do While Condição...Loop

Neste caso, estamos utilizando o operador condicional While, no início do laço. O formato
geral, neste caso é o seguinte:
Do While condição
‘Comando1
‘Comando2
...
Comandon
Loop
Nesta estrutura, enquanto a condição for verdadeira, o código dentro do laço é executado.
Quando a condição tornar-se falsa, o primeiro comando após o final do laço será executado.
Neste caso, se a condição for falsa já na primeira vez, o laço não será executado nenhuma vez.
IMPORTANTE
O código dentro do laço deve ser capaz de alterar a condição para Falso, quando for necessário,
pois caso contrário a condição será sempre verdadeira, e os comandos dentro do laço ficarão
em execução infinitamente, ou até o programa travar. A criação de laços infinitos, devido a
erros de programação, é uma causa comum de travamentos.
102
Listagem 2.25 – Um exemplo simples da estrutura de laço Do While Condição...Loop.

2 <!—
3 Dim x
4 x=10
5 Contador=1
6 Soma=0
8 Do While Contador <= x

9 Soma = Soma + Contador
10 Contador = Contador + 1
11 Loop

13 —>
14 </SCRIPT>
Com esse script, obtemos o resultado indicado na Figura 2.28.
Observe que dentro do laço, vamos incrementando o valor da variável Contador, uma unidade
para cada passagem do laço. Com isso, quando o valor de Contador, atingir 11, o teste do
início do laço torna-se falso, e o laço é encerrado.
A Estrutura Do... Loop While Condição

Neste caso, deslocamos o teste de condição para o final do laço. Com o teste no final do laço,
o código dentro do laço, será executado pelo menos uma vez, pois o teste somente é feito no
103
final, e continuará sendo executado, enquanto a condição for verdadeira. O formato geral,
neste caso é o seguinte:
Do
‘Comando1
‘Comando2
...
Comandon
Loop While condição
Nesta estrutura, enquanto a condição for verdadeira, o código dentro do laço é executado.
Quando a condição tornar-se falsa, o primeiro comando após o final do laço será executado.
Neste caso, se a condição for falsa já na primeira vez, o laço será executado uma única vez.
IMPORTANTE
pois caso contrário a condição será sempre verdadeira, e os comandos dentro do laço ficarão
em execução, infinitamente, ou até o programa travar. A criação de laços infinitos, devido a
erros de programação, é uma causa comum de travamentos.
Listagem 2.26 – Um exemplo simples da estrutura de laço Do... Loop While Condição.
2 <!—
3 Dim x
4 x=10
6 Contador=1
6 Soma=0

8 Do
11 Loop While Contador <= x

13 —>
14 </SCRIPT>
104
Vamos modificar um pouco o nosso exemplo. Considere o exemplo mostrado na Listagem 2.27.
Listagem 2.27 – Outro exemplo simples da estrutura de laço Do... Loop While Condição.
2 <!—
3 Dim x
4 x=10
7 Contador=11
6 Soma=0
7 ‘ O laço será executado uma única vez, pois a condição

8 ‘ Contador < x é falsa.
9 Do
12 Loop While Contador <= x
14 —>
15 </SCRIPT>
Qual o valor será exibido para a variável Soma?
Muito simples. A condição Contador < x é falsa, pois x=10 e Contador=12 (lembre que o
Contador foi incrementado de uma unidade na linha 11, antes do teste ser realizado). Neste
caso, o laço será executado uma única vez, pois o teste de condição está no final do laço.
Quando o laço é executado, a linha 10 atribui o valor 11 para a variável Soma. Com isso, o
valor exibido para a variável Soma, será 11, conforme indicado na Figura 2.30.
105
Figura 2.30: Resultado obtido, com uma única execução do laço.
A Estrutura Do Until Condição...Loop

Neste caso, estamos utilizando o operador condicional Until, no início do laço. O formato
Do Until condição
‘Comando1
‘Comando2
...
Comandon
Loop
Nesta estrutura, enquanto a condição for falsa, o código dentro do laço é executado. Quando a
condição tornar-se verdadeira, o primeiro comando após o final do laço será executado. Neste
caso, se a condição for verdadeira, já na primeira vez, o laço não será executado nenhuma vez.
IMPORTANTE
O código dentro do laço deve ser capaz de tornar a condição Verdadeira, quando for necessário,
pois caso contrário a condição será sempre Falsa, e os comandos dentro do laço ficarão em
execução, infinitamente, ou até o programa travar. A criação de laços infinitos, devido a erros
de programação, é uma causa comum de travamentos.
Listagem 2.28 – Um exemplo simples da estrutura de laço Do Until Condição...Loop.

2 <!—
3 Dim x
4 x=10
8 Contador=1
106
6 Soma=0
8 Do Until Contador > x

11 Loop

13 —>
14 </SCRIPT>
Observe que, dentro do laço, vamos incrementando o valor da variável Contador, uma unidade
para cada passagem do laço. Com isso, quando o valor de Contador atingir 11, o teste do
início do laço torna-se Verdadeiro, e o laço é encerrado.
A Estrutura Do... Loop Until Condição

o código dentro do laço, será executado pelo menos uma vez, pois o teste somente é feito no
final; e continuará sendo executado, enquanto a condição for Falsa. O formato geral, neste
caso, é o seguinte:
Do
‘Comando1
‘Comando2
...
Comandon
Loop Until condição
107
Nesta estrutura, enquanto a condição for Falsa, o código dentro do laço é executado. Quando a
condição tornar-se Verdadeira, o primeiro comando após o final do laço será executado. Neste
caso, se a condição for Verdadeira, já na primeira vez, o laço será executado uma única vez.
IMPORTANTE
de programação, é uma causa comum de travamentos.
Listagem 2.29 – Um exemplo simples da estrutura de laço Do... Loop Until Condição.
2 <!—
3 Dim x
4 x=10
9 Contador=1
6 Soma=0

8 Do
11 Loop Until Contador > x

13 —>
14 </SCRIPT>
108
Vamos modificar um pouco o nosso exemplo. Considere o que é mostrado na Listagem 2.30.
Listagem 2.30 – Outro exemplo simples da estrutura de laço Do... Loop Until Condição.
2 <!—
3 Dim x
4 x=10
10 Contador=11
6 Soma=0
7 ‘ O laço será executado uma única vez, pois a condição

8 ‘ Contador >= x é verdadeira.
9 Do
12 Loop Until Contador >= x

14 —>
15 </SCRIPT>
Qual o valor será exibido para a variável Soma?
Muito simples. A condição Contador >= x é verdadeira, pois x=10 e Contador=12 (lembre
que o Contador foi incrementado de uma unidade, na linha 11, na primeira passagem do
laço). Neste caso, o laço será executado uma única vez, pois o teste de condição está ao final.
Quando o laço é executado, a linha 10 atribui o valor 11 para a variável Soma. Com isso, o
valor exibido para a variável Soma, será 11, indicado na Figura 2.33.
Figura 2.33: Resultado obtido, com uma única execução do laço.
109
Conclusão
Neste capítulo apresentamos diversos conceitos importantes, os quais serão utilizados ao
longo de todo livro.
Primeiro, definimos o que é VBScript e fizemos uma revisão de HTML, principalmente das
tags para a criação de formulários com HTML.
Depois, passamos a analisar os aspectos básicos do VBScript. Vimos declaração de variáveis,

o comando Option Explicit. Passamos a estudar questões como operadores aritméticos e
operadores lógicos de comparação. Também falamos sobre o escopo de variáveis. Depois
passamos a tratar de estruturas de controle, onde vimos estruturas como If...Then,
If...Then...Else, Select....Case, etc.
Diversos exemplos foram apresentados com o objetivo de ilustrar os conceitos, facilitando a

compreensão.
No próximo capítulo, estaremos analisando alguns aspectos mais avançados do VBScript,

tais como a utilização de funções internas do VBScript, além da criação de procedimentos.
110
Capítulo 3 – Funções, Procedimentos e Eventos com VBScript
Capítulo 3
Funções, Procedimentos
e Eventos com VBScript
111
Neste capítulo, veremos uma série de aspectos que vão além do básico do VBScript. Iniciaremos
falando um pouco mais sobre tipos de dados e funções para conversão de tipos. Este tópico é de
grande importância, principalmente quando criamos páginas que efetuam cálculos.
Depois passaremos a analisar uma série de funções internas do VBScript. São funções que
fazem parte do VBScript, como por exemplo a função Date( ), que retorna a data do sistema.
Na seqüência, aprenderemos a criar nossas próprias funções e sub-rotinas. Aprenderemos as
diferenças entre uma sub-rotina e uma função, e quando utilizar uma ou outra.
Em seguida, trataremos de um assunto muito importante: a utilização de eventos e o modelo de

eventos do Internet Explorer. Também falaremos sobre a diferença entre os modelos de eventos
dos dois principais navegadores do mercado – o Internet Explorer e o Netscape Navigator.
Então, mãos à obra. É hora de aprendermos um pouco mais sobre VBScript, para, a partir do
Capítulo 4, começarmos a tratar de ASP 3.0, utilizando os conhecimentos apresentados nestes
capítulos iniciais.
NOTA
Os exemplos apresentados nas listagens deste capítulo podem ser criados utilizando-se um
redator de texto, como o Bloco de notas, e salvando os arquivos com a extensão .htm. Depois é
só abrir os mesmos no Internet Explorer e testar. Os números das linhas, que aparecem nas
listagens, não devem ser digitados. Os mesmos foram incluídos, apenas para facilitar o
acompanhamento das explicações de cada exemplo.
Tipos de Dados e Funções Para Conversão de Tipos

Neste item, aprenderemos a determinar qual o tipo de dado que está armazenado em uma
variável, bem como a converter valores de um tipo para outro, utilizando as funções para
conversão de tipos.
Determinando o Tipo de Dados Contido em uma Variável

Existem diversas funções, que permitem que seja determinado o tipo de valor contido em
uma variável. Existem diversas aplicações para este tipo de função. Por exemplo, ao digitar
dados em um formulário, podemos utilizar uma função para determinar se os valores digitados
pelo usuário não apresentam problemas. Por exemplo, o usuário pode ter digitado, por engano,
texto em um campo que deve conter valores numéricos.
112
A Função IsArray
Um Array é um tipo especial de variável, a qual pode armazenar diversos valores em uma
única variável. De uma forma simples, um Array é um conjunto. Cada valor armazenado no
Array é um elemento do conjunto. Por exemplo, poderíamos criar um Array para armazenar
os nomes dos meses do ano. Com isso teríamos um Array de 12 elementos.
Cada elemento de um Array é acessado através do nome da variável Array e de um índice. O

índice inicia em zero, e não em um. Por isso, se tivermos um Array de dez elementos, teremos
o elemento 0, o elemento 1, o elemento 2, e assim por diante, até o elemento 9. O fato do
índice começar com 0 influencia na hora de declarar um Array. Para declarar um Array
chamado produtos, com 20 elementos, utilizaríamos a seguinte declaração:
Dim produtos(19)
O 19 significa que temos 20 elementos (sempre um a mais do que o número que aparece na
declaração), isto é, do elemento 0, indicado por produtos(0), até o elemento 20, indicado por
produtos(19).
Na Listagem 3.1, temos um exemplo simples de utilização de Array.
Listagem 3.1 – Utilizando um Array para armazenar os dias da semana.

1 <HTML>
2 <HEAD>
3 <TITLE>Utilizando uma variável Array!!</TITLE>
4 </HEAD>
5 <BODY>
6 <P>EXEMPLO DE CRIAÇÃO E UTILIZAÇÃO DE ARRAYS.</P>
8 <!—
9 ‘Declara um Array de sete posições

10 ‘Como a primeira posição é a posição zero,
11 ‘Indicamos o tamanho como 6, o que significa
12 ‘da posição 0 até a posição 6 = 7 elementos.
13 Dim Dias(6)
14 ‘Atribuímos valores para os dias da semana
113
15 Dias(0)= “Segunda-feira”
16 Dias(1)= “Terça-feira”
17 Dias(2)= “Quarta-feira”
18 Dias(3)= “Quinta-feira”
19 Dias(4)= “Sexta-feira”
20 Dias(5)= “Sábado”
21 Dias(6)= “Domingo”
22 ‘Agora utilizamos um laço For...Next

23 ‘Para criar uma string, com o conteúdo
24 ‘Do Array Dias.
25 For i=0 to 6
26 mensagem = mensagem & “Dia: ” & i+1 & “ ” & Dias(i)& Chr(13)
27 Next
28 ‘Utilizamos uma MsgBox, para exibir a mensagem
29 ‘com o conteúdo do Array Dias.
30 MsgBox mensagem
31 —>
32 </SCRIPT>
33 </BODY>
34 </HTML>
Ao carregar este exemplo, no Internet Explorer, será exibida a janela mostrada na Figura 3.1.
Figura 3.1: Um exemplo de utilização de Array.
114
Utilizamos a função IsArray, para determinar se uma variável do tipo Variant (lembre que
todas as variáveis do VBScript são do tipo Variant) está armazenando um Array.
Utilizamos a seguinte sintaxe:

IsArray(NomeDaVariável)
A função IsArray retorna verdadeiro se a variável for um Array, e falso em caso contrário.
Por exemplo, se adicionássemos, à Listagem 3.1, o comando:

MsgBox IsArray(Dias)
o resultado seria o indicado na Figura 3.2.
Figura 3.2: A função IsArray retornando Verdadeiro.
A Função VarType
Podemos utilizar a função VarType para determinar o subtipo de uma variável. Como todas as
variáveis são do tipo Variant, o subtipo pode ser utilizado para determinar o tipo de dado
armazenado na variável. Passamos, para a função, o nome de uma variável ou expressão. A
função retorna um número inteiro que indica o subtipo da variável.
A sintaxe da função é a seguinte:

VarType(NomeDaVariável)
ou
VarType(expressão)
Na Tabela 3.1, temos os códigos de retorno da função VarType.
Tabela 3.1 Valores de retorno da função VarType.
Valor Descrição
0 Vazio (não inicializado)
115
Valor Descrição
1 Nulo (dados não válidos)
2 Inteiro
3 Inteiro longo
4 Número de precisão simples
5 Número de precisão dupla
6 Monetário
7 Data
8 Texto
9 Objeto de automação
10 Erro
11 Boleano
12 Variant (somente é utilizado com Arrays de variantes)
13 Objeto para acesso a dados
17 Byte
8192 Array
Na Listagem 3.2, temos um exemplo de utilização da função VarType.
Listagem 3.2 – Utilizando a função VarType.

1 <HTML>
2 <HEAD>
3 <TITLE>Exemplo de uso da função VarType!!!</TITLE>
4 </HEAD>
5 <BODY>
6 <P>EXEMPLO DE UTILIZAÇÃO DA FUNÇÃO VarType</P>
8 <!—
9 Dim x,y,z
116
10 Dim a, b
11 Dim c(20)
12 x=12
13 y=23.456
14 y=123456789
15 a=“Este é um valor de texto!”
16 ‘Utilizamos a função Date( ), para capturar a data do sistema.

17 b=Date( )
18 mensagem = “Tipo da variável x: ” & Vartype(x) & Chr(13)

19 mensagem = mensagem & “Tipo da variável y: ” & Vartype(y) & Chr(13)
20 mensagem = mensagem & “Tipo da variável z: ” & Vartype(z) & Chr(13)
21 mensagem = mensagem & “Tipo da variável a: ” & Vartype(a) & Chr(13)
22 mensagem = mensagem & “Tipo da variável b: ” & Vartype(b) & Chr(13)
23 mensagem = mensagem & “Tipo da variável c: ” & Vartype(c) & Chr(13)
24 MsgBox mensagem
25 —>
26 </SCRIPT>
27 </BODY>
28 </HTML>
Ao carregar este exemplo no Internet Explorer, obteremos o resultado indicado na Figura 3.3.
Figura 3.3: Utilizando a função VarType.
117
Observe, principalmente, no tipo da variável z, o qual retornou 0. Isto significa que a variável
z está vazia, ou seja, não foi inicializada. Este resultado está coerente com a Tabela 3.1. Também
podemos salientar o retorno para a variável b, o qual retornou 7, indicando que o valor
armazenado nesta variável é do tipo Data. Portanto, também está coerente com a Tabela 3.1,
uma vez que usamos a função Date( ), para armazenar a data do sistema, na variável b.
Finalmente observe o valor de retorno para a variável c, o qual retornou 8192, indicando que
a variável c é um Array. Este resultado está coerente com a Tabela 3.1, e com a declaração da
linha 11 – Dim c(20), a qual declarou a variável c como sendo um Array.
Muitas são as aplicações práticas para a função VarType, dentre as quais podemos destacar a
validação dos dados digitados em um formulário.
A Função IsDate
A função IsDate recebe uma variável ou expressão como argumento, e determina se a variável
ou expressão é uma data válida, ou pode ser convertida para uma data válida. Caso o argumento
passado seja uma data válida, a função retorna Verdadeiro, caso contrário, retorna Falso.
Podemos utilizar esta função, por exemplo, para verificar se o usuário digitou uma data válida,
em um campo de um formulário.
A sintaxe da função IsDate é a seguinte:

IsDate(NomeDaVariável)
ou
IsDate(expressão)
Na Listagem 3.3, temos um exemplo de utilização da função IsDate.
Listagem 3.3 – Utilizando a função IsDate.

1 <HTML>
2 <HEAD>
3 <TITLE>Utilizando a função IsDate!!</TITLE>
4 <SCRIPT ID=clientEventHandlersVBS LANGUAGE=“vbscript”>

5 <!—
6 Sub verifica_onclick
7 If IsDate(Window.dataen.value) Then
8 MsgBox “Você digitou uma data válida!”
9 Else
10 MsgBox “Data inválida, digite novamente!”
11 window.dataen.value=“”
118
12 window.dataen.focus
13 End If
14 End Sub
15 —>
16 </SCRIPT>
17 </HEAD>
18 <BODY>
19 <P>Exemplo de uso da função IsDate</P>
20 <P>Digite a data de encerramento:
21 <INPUT id=“dataen” maxLength=10 name=“dataen” > (dd/mm/aaaa)
22 </P>
23 <P>Clique no botão para verificar se a data é válida:
24 <INPUT id=“verifica” name=“verifica” type=button value=“Verificar data”></P>
25 </BODY>
26 </HTML>
A seguir alguns comentários sobre este exemplo.
No código HTML do documento – linha 17 à 25 –, colocamos dois elementos de formulário:

um campo de texto, que chamamos de dataen; e um botão de comando, do tipo Button, que
chamamos de verifica.
A Figura 3.4 mostra este documento aberto no Internet Explorer, onde o usuário digitou uma
data inválida, no nosso exemplo, o usuário digitou 30/02/2000.
Figura 3.4: O usuário digitou uma data inválida.
119
Após digitar a data, o usuário clica no botão “Verificar data”, para testar se a data é válida.
Esta ação do usuário, gera o evento onclik deste botão. Observe que das linhas 6 a 13, definimos
um procedimento que responde ao evento onclick do botão verifica. O que define que este
procedimento atua em resposta ao evento onclick, do botão verifica, é o nome do procedimento:
Sub verifica_onclick
Esta definição faz parte do modelo de objetos e eventos do Internet Explorer, a qual
analisaremos em maiores detalhes mais adiante, ainda neste capítulo.
Dentro do procedimento verifica_onclick, utilizamos a função IsDate, para verificar se a data

digitada pelo usuário é valida. Se a data for válida, simplesmente exibimos uma mensagem,
notificando que a data digitada é válida, conforme indicado na Figura 3.5.
Figura 3.5: A data digitada pelo usuário é válida.
Caso a data não seja válida, emitimos uma mensagem avisando – linha 10. Na linha 11, voltamos
a utilizar o modelo de objetos do Internet Explorer. A expressão window.dataen.value significa:
o valor do campo dataen, da janela atual do navegador. Com este comando, estamos “apagando”
a data digitada pelo usuário. Na linha 12, utilizamos o método focus, para posicionar o cursor
de volta no campo dataen. Com isso, quando o usuário clicar em OK, na janela da mensagem de
data inválida, o campo dataen será apagado (linha 11) e o cursor posicionado no campo (linha
12), para que o usuário possa digitar uma nova data, conforme indicado na Figura 3.6.
Figura 3.6: Cursor posicionado no campo dataen.
120
A Função IsEmpty
A função IsEmpty recebe uma variável ou expressão como argumento, e determina se, em
algum momento, foi atribuído algum valor para a variável ou expressão. Caso tenha sido
atribuído algum valor, a função retorna Verdadeiro, caso contrário, retorna Falso. Podemos
utilizar esta função, por exemplo, para verificar se um campo de digitação obrigatória, como
por exemplo o nome, não foi deixado em branco.
A sintaxe da função IsEmpty é a seguinte:

IsEmpty(NomeDaVariável)
ou
IsEmpty(expressão)
Na Listagem 3.4, temos um exemplo de utilização da função IsEmpty.
Listagem 3.4 – Utilizando a função IsEmpty.

1 <HTML>
2 <HEAD>
3 <TITLE>Utilizando a função IsEmpty!!</TITLE>
5 <!—
6 ‘ Vamos declarar uma variável x que nunca
7 ‘ será utilizada no nosso script
8 Dim a, b, c
9 Dim x
10 a=10
11 b=23
12 c=a+b
13 If IsEmpty(x) Then
14 MsgBox “A variável x não foi utilizada!”
15 End If
16 —>
17 </SCRIPT>
18 </HEAD>
121
19 <BODY>
20 <P>Exemplo de uso da função IsEmpty</P>

21 <P> Clique no botão para verificar o nome digitado:
22 <INPUT id=“verifica” name=“verifica” type=button value=“Verificar nome”>
23 </P>
24 </BODY>
25 </HTML>
Ao abrir este documento, no Internet Explorer, você recebe a mensagem indicada na Figura 3.7.
Figura 3.7: A variável x está vazia.
A Função IsNull
A função IsNull recebe uma variável ou expressão como argumento, e determina se, em
algum momento, foi atribuído o valor Null para a variável ou expressão. Se tiver sido atribuído
o valor Null, a função retorna Verdadeiro, caso contrário, retorna Falso. Para atribuirmos Null
para uma variável, utilizamos a seguinte sintaxe:
NomeDaVariável = Null
IMPORTANTE
Uma variável com valor Null, não é a mesma coisa que uma variável com valor zero, ou uma
variável de texto com tamanho zero. Quando é atribuído o valor Null para a variável, a mesma
continua existindo na memória, porém sem nenhum valor definido.
A sintaxe da função IsNull é a seguinte:

IsNull(NomeDaVariável)
ou
IsNull(expressão)
122
Na Listagem 3.5, temos um exemplo de utilização da função IsNull.
Listagem 3.5 – Utilizando a função IsNull.

1 <HTML>
2 <HEAD>
3 <TITLE>Utilizando a função IsNull!!</TITLE>
5 <!—
6 ‘ Vamos declarar uma variável x, e atribuir
7 ‘ Null para a mesma.
8 Dim x
9 x = Null
10 If IsNull(x) Then
11 MsgBox “A variável x é Nula!”
12 End If
13 —>
14 </SCRIPT>
15 </HEAD>
16 <BODY>
17 <P>Exemplo de uso da função IsNull.</P>
18 </BODY>
19 </HTML>
123
Figura 3.8: A variável x possui o valor Null.
A Função IsNumeric
A função IsNumeric recebe uma variável ou expressão como argumento, e determina se o
valor atribuído à variável ou expressão é numérico, ou pode ser convertido para numérico.
Se o valor for numérico, ou puder ser convertido, a função retorna Verdadeiro, caso contrário,
retorna Falso.
A sintaxe da função IsNumeric é a seguinte:

IsNumeric(NomeDaVariável)
ou
IsNumeric(expressão)
Na Listagem 3.6 temos um exemplo de utilização da função IsNumeric.
Listagem 3.6 – Utilizando a função IsNumeric.

1 <HTML>
2 <HEAD>
3 <TITLE>Utilizando a função IsNumeric!!</TITLE>
5 <!—
6 Dim x,y,z
7 x=123
8 ‘Atribuo um valor que não pode ser convertido

9 ‘para numérico
10 y= “Riachuelo - 80”
124
11 z = Date()
12 mensagem = “Valor de x: ” & x &“ É numérico? ” & IsNumeric(x)& Chr(13)

13 mensagem = mensagem & “Valor de y: ” & y &“ É numérico? ” & IsNumeric(y)& Chr(13)
14 mensagem = mensagem & “Valor de z: ” & z &“ É numérico? ” & IsNumeric(z)
15 MsgBox mensagem
16 —>
17 </SCRIPT>
18 </HEAD>
19 <BODY>
20 <P>Exemplo de uso da função IsNumeric.</P>
21 </BODY>
22 </HTML>
Figura 3.9: Utilizando a função IsNumeric.
Cabe salientar a utilização da função Date( ), para capturar a data do sistema, e atribuir esta data
à variável z. Observe que esta data não foi considerada um valor numérico para a função IsNumeric.
A Função IsObject
A função IsObject recebe uma variável como argumento, e determina se o valor atribuído à
variável é um objeto ActiveX. Se for, a função retorna Verdadeiro, caso contrário, retorna Falso.
Para exemplificarmos esta função, faremos uso de uma página ASP, e iremos utilizar um dos
objetos do ASP. Falaremos mais sobre os objetos do ASP no Capítulo 4.
125
A sintaxe da função IsObject é a seguinte:

IsObject(NomeDaVariável)
ou
IsObject(expressão)
Na Listagem 3.7 temos um exemplo de utilização da função IsObject.
Listagem 3.7 – Utilizando a função IsObject.

1 <%@ Language=VBScript %>
2 <HTML>
3 <HEAD>
4 </HEAD>
5 <BODY>
6 <P>Exemplo de utilização da função IsObject!</P>
7 <%
8 Set tiponav= Server.CreateObject(“MSWC.BrowserType”)
9 If IsObject(tiponav) Then
10 Response.Write “A variável tiponav é um objeto”
11 Else
12 Response.Write “A variável tiponav não é um objeto.”
13 End If
14 %>
15 </BODY>
16 </HTML>
IMPORTANTE
Como este é um arquivo .asp, o mesmo não pode ser aberto localmente no Internet Explorer.
Toda página .asp é interpretada no servidor, e o resultado do processamento, na forma de
HTML puro, é devolvido para o navegador. Para testar um arquivo .asp, o mesmo precisa ser
salvo no servidor IIS e acessado utilizando-se o endereço para a página .asp.
Ao abrir este documento, no Internet Explorer, obtemos o resultado indicado na Figura 3.10.
126
Figura 3.10: Utilizando a função IsObject.
Observe no campo endereço, que estamos acessando a página .asp, em um servidor, e não
localmente, conforme indicado pelo endereço: http://servidor/Chap3/IsObject.asp.
Funções Para Conversão de Tipos

Neste item aprenderemos a utilizar as principais funções para conversão de tipos. Existem
situações em que um determinado tipo de dado deve ser convertido para outro. Por exemplo,
se tivermos um número, armazenado na forma de texto, precisamos convertê-lo para inteiro
ou double, para que possamos realizar cálculos com o mesmo.
Na seqüência, apresento as principais funções de conversão, bem como um pequeno fragmento

de código, exemplificando a utilização de cada uma delas.
Função Cbool
A função Cbool converte uma variável ou resultado de uma expressão para o subtipo Boolean.
Qualquer número, com exceção do zero, é automaticamente convertido para Verdadeira. O
valor zero é sempre convertido para Falso. O argumento desta função não pode ser texto, caso
contrário será gerado um erro em tempo de execução.
Observe esta linha de código:

MsgBox Cbool(10>25) & Chr(13) & Cbool(3)
127
Esta linha gera a mensagem indicada na Figura 3.11.
Figura 3.11: A função Cbool retorna Verdadeiro ou Falso.
A expressão 10>25 é avaliada, como a expressão é falsa, a função Cbool retorna Falso. Já no segundo
uso da função Cbool, foi passado o parâmetro 3 para a função. Qualquer valor diferente de zero
(com exceção de texto) a função interpreta como Verdadeiro, o que é comprovado pela Figura 3.11.
Função CByte
A função CByte converte uma variável ou resultado de um expressão para o subtipo Byte. O
valor a ser convertido, deve estar na faixa aceitável para o tipo byte, que vai de 0 a 255. Caso
o número esteja fora desta faixa, será gerada uma mensagem de erro; e, se o argumento desta
função for texto também será gerada uma mensagem de erro, em tempo de execução.

MsgBox CByte(10+34) & Chr(13) & CByte(35)
Figura 3.12: A função CByte converte os valores para o subtipo Byte.
A expressão 10+34 é calculada, e o resultado (44), é convertido para o tipo Byte. A linha de
código abaixo, irá gerar uma mensagem de erro, em tempo de execução, pois o valor a ser
convertido para byte, está fora da faixa de 0 a 255.
MsgBox CByte(100+200)
128
Função CCur
A função CCur converte uma variável, ou resultado de um expressão, para o subtipo Currency.
O argumento desta função não pode ser Texto, caso contrário será gerado um erro.

MsgBox CCur(250.335677+324.3333) & Chr(13) & CCur(1250.326582)
Figura 3.13: A função CCur converte os valores para o subtipo Currency.
A expressão 250.335677+324.3333 é calculada, e o resultado é convertido para o tipo Currency.
Se passarmos um argumento de texto para a função CCur será gerado um erro de execução,
conforme indicado na Figura 3.14.
Figura 3.14: Erro gerado ao passar um texto como argumento para CCur.
129
Função CDate
A função CDate converte uma variável ou resultado de um expressão para o subtipo Date. O
argumento desta função deve estar em um formato que seja aceitável para datas, caso contrário
será gerada uma mensagem de erro, em tempo de execução.

MsgBox CDate(“31/10/1980”) & Chr(13) & CDate(“23-01-2007”)
Figura 3.15: A função CDate converte os valores para o subtipo Date.
A linha de código abaixo irá gerar uma mensagem de erro, em tempo de execução, conforme
indicado na Figura 3.16.
MsgBox CDate(“31/02/1980”)
Figura 3.16: Erro gerado ao passar um argumento com uma data inválida.
130
Função CDbl
A função CDbl converte uma variável ou resultado de um expressão para o subtipo Double. O
argumento desta função não pode ser do tipo texto, caso contrário será gerada uma mensagem
de erro, em tempo de execução.

MsgBox CDbl(“4.940651247E-17”)
Figura 3.17: A função CDouble converte os valores para o subtipo Double.
MsgBox CDbl(“Teste”)
Figura 3.18: Erro gerado ao passar um argumento de tipo inválido para a função Cdbl.
131
Função CInt
A função CInt converte uma variável ou resultado de um expressão para o subtipo Integer. O
de erro, em tempo de execução.

MsgBox CInt(32.36) & Chr(13) & CInt(20.35+40.45)
Figura 3.19: A função CInt converte os valores para o subtipo Integer.
MsgBox CInt(“Teste”)
Figura 3.20: Erro gerado ao passar um argumento de tipo inválido para a função CInt.
132
Função CLng
A função CLng converte uma variável ou resultado de um expressão para o subtipo Long. O
de erro, em tempo de execução. O argumento também não pode estar fora da faixa admitida
pelo subtipo Long, caso contrário será gerada uma mensagem de erro, em tempo de execução.

MsgBox CLng(“3462315”)
Figura 3.21: A função CLng converte os valores para o subtipo Long.
MsgBox CLng(“Teste”)
Figura 3.22: Erro gerado ao passar um argumento de tipo inválido para a função CLng.
133
Função CSng
A função CSng converte uma variável ou resultado de um expressão para o subtipo Single. O
de erro, em tempo de execução. O argumento também não pode estar fora da faixa admitida
pelo subtipo Single, caso contrário será gerada uma mensagem de erro, em tempo de execução.

MsgBox CSng(“3.1418256927”)
Figura 3.23: A função CSng converte os valores para o subtipo Single.
A linha de código abaixo, irá gerar uma mensagem de erro, em tempo de execução, conforme
MsgBox CSng(“Teste”)
Figura 3.24: Erro gerado ao passar um argumento de tipo inválido para a função CSng.
134
Função CStr
A função CStr converte uma variável ou resultado de um expressão para o subtipo String.

MsgBox CStr(“12345” & “hectares de terra”)
Figura 3.25: A função CStr converte os valores para o subtipo String.
Funções Int e Fix

As funções Int e Fix retornam somente a parte inteira de um determinado número. A diferença,
entre as duas funções, é quando o número for negativo. Observe os exemplos abaixo:
➥ Fix(-10.2) – Retorna –10
➥ Int(-10.2) – Retorna –11
A função Int, retorna, no caso de números negativos, o primeiro número inteiro, menor ou igual
ao parâmetro passado. No caso de –10.2, retornou –11. Já Fix, retorna, no caso de números negativos,
o primeiro inteiro, maior ou igual ao parâmetro passado. No caso de –10.2, retornou –10.

MsgBox Fix (-7.35) & Chr(13) & MsgBox Int(-7.35)
Figura 3.26: A diferença entre Int e Fix, para números negativos.
135
Com isso, terminamos a nossa apresentação sobre as principais funções para a conversão de
tipos de dados. No próximo item, estaremos analisando mais algumas funções do VBScript,
para operações com dados do tipo String e do tipo Data/Hora.
Outras Funções do VBScript – Tratamento

de String, Datas e Funções Matemáticas
Neste item, aprenderemos a utilizar as principais funções do VBScript. Apresentaremos as
funções divididas em categorias, conforme a funcionalidade das mesmas. Estaremos tratando
das seguintes categorias:
➥ Funções para manipulação de String.
➥ Funções para manipulação de Data/Hora.
➥ Funções matemáticas.
Para uma referência completa sobre todas as funções do VBScript, você pode consultar o
seguinte endereço: http://msdn.microsoft.com/scripting.
Funções Para Tratamento de String

Veremos as principais funções para tratamento de String. Nos exemplos práticos, no final do
capítulo, estaremos utilizando algumas destas funções.
Função Asc
A função Asc retorna o valor numérico do código ASCII, para a primeira letra de uma String.
Considere o exemplo:
Asc(“Ainda chovia”)
Este exemplo de uso da função retorna o valor 65, o qual é o código ASCII para a letra A
maiúscula. Caso fosse a letra a minúscula, o código retornado seria 97.
Função Chr
A função Chr(número), recebe um número como parâmetro, e retorna o caractere ASCII,
correspondente. Considere o exemplo:
Chr(65)
Este exemplo de uso da função retorna o caractere A maiúsculo.
136
NOTA
Até agora, utilizamos a função Chr em alguns exemplos. Utilizamos o Chr(13) para simular
um ENTER, o que faz uma quebra de linha, nas mensagens montadas com o MsgBox.
Função Len
Esta função determina o tamanho da String que foi passada como parâmetro para a função.
MsgBox Len(“Este é um exemplo de uso da função Len!!”)
Este exemplo de uso da função, retorna 41, conforme indicado na Figura 3.27.
Figura 3.27: Exemplo de uso da função Len.
Função LCase
Esta função converte para minúsculas a String que foi passada como parâmetro para a função.
MsgBox Lcase(“ESTE É UM EXEMPLO DE USO DA FUNÇÃO LCASE”)
Este exemplo de uso da função converte, o parâmetro passado, para letras minúsculas,
Figura 3.28: Exemplo de uso da função LCase.
137
Função UCase
Esta função converte para maiúsculas a String que foi passada como parâmetro para a função.
MsgBox Ucase(“este é um exemplo do uso da função ucase!!”)
Este exemplo de uso da função converte, o parâmetro passado, para letras maiúsculas, conforme
Figura 3.29: Exemplo de uso da função UCase.
Função Left
Esta função retorna um número especificado de caracteres, a partir do início (Left – Esquerda)
de uma String. É importante salientar que espaços em branco também devem ser considerados.
O formato geral da função é o seguinte:

Left(String, n)
onde n é o número de caracteres a retornar.
MsgBox Left(“Júlio Cesar Fabris Battisti”,5)
Este exemplo de uso da função, retorna as cinco primeiras letras da String passada, neste
caso, retornará Júlio.
Vamos alterar um pouco o nosso exemplo:

MsgBox Left(“Júlio Cesar Fabris Battisti”,7)
Irá retornar: Júlio C. Observe que o espaço em branco também é considerado.
Função Right
Esta função retorna um número especificado de caracteres, a partir do final (Right – Direita)
de uma String. É importante salientar que espaços em branco também devem ser considerados.
138

Right(String, n)
onde n é o número de caracteres a retornar.
MsgBox Right(“Júlio Cesar Fabris Battisti”,6)
Este exemplo de uso da função, retorna as seis últimas letras da String passada, neste caso,
retornará ttisti.
Vamos alterar um pouco o nosso exemplo:

MsgBox Right(“Júlio Cesar Fabris Battisti”,10)
Irá retornar: s Battisti. Observe que o espaço em branco também é considerado.
Função Mid
Esta função retorna um número especificado de caracteres, a partir de uma posição especificada
dentro da String. É importante salientar que espaços em branco também devem ser
considerados.

Mid(String, posicao_inicio, n)
onde posicao_inicio é a posição a partir da qual devem ser retornados caracteres, e n é o

número de caracteres a retornar.
Considere alguns exemplos:

Mid(“Júlio Cesar Fabris Battisti”,7,5)
Este exemplo de uso da função, retorna, a partir da posição 7, cinco caracteres, neste caso,
retornará Cesar.
Mid(“SANTA MARIA”,3,7)
irá retornar NTA MAR. Observe que o espaço em branco também é considerado.
Um detalhe interessante, é que podemos utilizar o retorno de uma função, como parâmetro
para outra função. Considere o seguinte exemplo:
LCase(Mid(“SANTA MARIA”,3,7))
139
Este exemplo retorna nta mar.
A função Mid retira os caracteres NTA MAR, os quais são passados como parâmetros para a
função LCase, a qual converte os caracteres para minúsculos.
Função String
Esta função retorna um determinado caractere, um número especificado de vezes.

String(n, Caracter)
onde n é o número de vezes que o caractere deve ser repetido.
MsgBox String(35,“*”)
A Figura 3.30 mostra o resultado deste comando.
Figura 3.30: Exemplo de uso da função String.
Funções Para Tratamento de Data e Hora

Veremos as principais funções para tratamento de Data e Hora. Nos exemplos práticos, no
final do capítulo, estaremos utilizando algumas destas funções.
Função Date
Retorna a data corrente do sistema. Não precisamos passar parâmetros para esta função.
Considere o exemplo abaixo:
MsgBox “Data do Sistema: ” & Date( )
O resultado deste comando está indicado na Figura 3.31.
140
Figura 3.32: Exemplo de uso da função Date.
Função Time
Retorna a hora corrente do sistema. Não precisamos passar parâmetros para esta função.
MsgBox “Hora do Sistema: ” & Time( )
Figura 3.32: Exemplo de uso da função Time.
Função Day
Recebe como parâmetro uma data, e retorna um número entre 1 e 31, indicando o dia do mês.
O formato geral é o seguinte:
Day(data)

MsgBox “Dia do mês: ” & Day(Date( ))
A função Date( ) captura a data do sistema e passa como parâmetro para a função Day, que,
por sua vez, retorna apenas o dia do mês.
141
Figura 3.33: Exemplo de uso da função Day.
Função Month
Recebe como parâmetro uma data, e retorna um número entre 1 e 12, indicando o mês do
ano. O formato geral é o seguinte:
Month(data)

MsgBox “Mês do ano: ” & Month(Date( ))
Figura 3.34: Exemplo de uso da função Month.
A função Date( ) captura a data do sistema e passa como parâmetro para a função Month, que,
por sua vez, retorna apenas o mês do ano.
Função Now
Retorna a hora e a data corrente do sistema. Não precisamos passar parâmetros para esta
função. Considere o exemplo abaixo:
MsgBox “Data e Hora do Sistema: ” & Now( )
142
Figura 3.35: Exemplo de uso da função Now.
Função MonthName
Recebe como parâmetro um número, indicativo do mês do ano (1 – Janeiro, 2 – Fevereiro, e assim
por diante), e um segundo parâmetro que pode ser Verdadeiro ou Falso. Se o segundo parâmetro
for Verdadeiro, o nome do mês será exibido abreviadamente. O formato geral é o seguinte:
MonthName(número_do_mês, abreviar)

MsgBox “Mês do ano: ” & MonthName(Month(Date(),False)
Figura 3.36: Exemplo de uso da função MonthName.
A função Date( ) captura a data do sistema e passa como parâmetro para a função Month. A
função Month retorna o número do mês retornado pela data. Este número é passado como
primeiro parâmetro para a função MonthName. O segundo parâmetro é definido em Falso, o
que significa que é para exibir o nome do mês por extenso, isto é, não abreviado.
Função Hour
Recebe como parâmetro uma hora, e retorna um número entre 0 e 23, indicando o hora do
dia. O formato geral é o seguinte:
Hour(horário)
143

MsgBox “Hora do sistema: ” & Hour(Time( ))
Figura 3.37: Exemplo de uso da função Hour.
A função Time( ) captura a hora do sistema e passa como parâmetro para a função Hour, que,
por sua vez, retorna apenas a hora do dia.
A função DateDiff
Esta função pode ser utilizada para determinar o número de intervalos (em dias, trimestres,
semestres, anos, etc.), entre duas datas. A sintaxe desta função é o seguinte:
DateDiff(intervalo, data1, data2)
O parâmetro intervalo é uma String que diz que tipo de intervalo vamos calcular. Por exemplo,
é este parâmetro que define se queremos calcular o número de dias, ou o número de meses
entre duas datas. Na Tabela 3.2, temos os valores possíveis para o parâmetro intervalo.
Tabela 3.2 Valores para o parâmetro intervalo.
Valor Descrição
yyyy Anos
q Trimestres
m Meses
y Dias do ano (o mesmo que dias)
d Dias
w Semanas
ww Semanas do ano (o mesmo que semanas)
144
Valor Descrição
h Horas
n Minutos
s Segundos
A título de exemplo, vamos calcular o número de meses, desde o descobrimento do Brasil,

até 31 de Dezembro de 1999. Para isso, utilizaríamos o seguinte comando:
MsgBox “Meses desde o descobrimento: ” & DateDiff(“m”,“22/04/1500”,“31/12/1999”)
O resultado deste comando pode ser conferido na Figura 3.38.
Figura 3.38: Exemplo de uso da função DateDiff.
Vamos modificar um pouco o nosso exemplo, e calcular o número de horas desde o

descobrimento. Para isto, podemos utilizar o seguinte comando:
MsgBox “Número aproximado de horas, desde o descobrimento: ” & DateDiff(“h”,“22/04/
1500”,“31/12/1999”)
Figura 3.39: O número aproximado de horas, desde o descobrimento do Brasil.
A Função DateAdd
Esta função pode ser utilizada para determinar uma data futura, com base em uma data
fornecida, o tipo de período a ser acrescentado (dias, meses, anos, etc.), e o número de períodos
a serem acrescentados. A sintaxe desta função é a seguinte:
145
DateAdd(intervalo, número_de_intervalos, data)
O parâmetro intervalo é uma String que diz que tipo de intervalo vamos acrescentar. Por
exemplo, é este parâmetro que define se queremos acrescentar um número especificado de
dias, meses, anos, etc. Na Tabela 3.3, temos os valores possíveis para o parâmetro intervalo.
Tabela 3.3 Valores para o parâmetro intervalo.
Valor Descrição
yyyy Anos
q Trimestres
m Meses
y Dias do ano (o mesmo que dias)
d Dias
w Semanas
ww Semanas do ano (o mesmo que semanas)
h Horas
n Minutos
s Segundos
A título de exemplo, vamos calcular a data em que tivemos um período de 1.000 meses, após
o descobrimento do Brasil. Para isso, utilizaríamos o seguinte comando:
MsgBox “Mil meses após o descobrimento foi em: ” & DateAdd(“m”,1000,“22/04/1500”)
Figura 3.40: Exemplo de uso da função DateAdd.
Vamos modificar um pouco o nosso exemplo, e calcular em que data teremos passado um
milhão de dias após o descobrimento.
146
MsgBox “Um milhão de dias após o descobrimento em : ” & DateAdd(“d”,1000000,“22/04/1500”)
Figura 3.41: Em 19/03/4238, o Brasil completará um milhão de dias.
Função Year
Recebe como parâmetro uma data, e retorna um número indicativo do ano. O formato geral é
o seguinte:
Year(data)

MsgBox “Ano atual: ” & Year(Date( ))
Figura 3.42: Exemplo de uso da função Year.
A função Date( ) captura a data do sistema e passa como parâmetro para a função Year, a qual
por sua vez, retorna apenas o ano.
Função WeekDay
Recebe como parâmetros uma data, e um parâmetro opcional, que indica qual o primeiro dia da
semana. Se este parâmetro for omitido, o primeiro dia da semana será considerado domingo. O
valor para o primeiro dia da semana é numérico: 1 – domingo, 2 – segunda-feira, e assim por diante.
WeekDay(data, prim_dia_semana.)
147

MsgBox “Dia da semana: ” & WeekDay(“31/12/1999”)
Figura 3.43: Exemplo de uso da função WeekDay.
O valor 6 indica que foi uma sexta-feira, o que confere com o calendário.
Poderíamos determinar que o primeiro dia da semana é a segunda-feira (2). Com isso o nosso
exemplo, ficaria assim:
MsgBox “Dia da semana: ” & WeekDay(“31/12/1999”,2)
Figura 3.44: Definindo a segunda-feira como o primeiro dia da semana.
O valor 5 indica que foi uma sexta-feira, pois agora a segunda-feira passou a ser o dia 1, a
terça-feira o dia 2, e assim por diante. Novamente confere com o calendário.
Função WeekDayName
Recebe como parâmetro um número, indicativo do dia da semana, e um segundo parâmetro
que pode ser Verdadeiro ou Falso. Se o segundo parâmetro for Verdadeiro, o nome do dia da
semana será exibido abreviadamente. O formato geral é o seguinte:
WeekDayName(número_do_dia, abreviar)
148

MsgBox “Dia da semana: ” & WeekDayName(6,False)
Figura 3.45: Exemplo de uso da função WeekDayName.
Funções Para Cálculos Matemáticos

Veremos as principais funções para efetuar cálculos matemáticos. Nos exemplos práticos, no
final do capítulo, estaremos utilizando algumas destas funções.
Na Tabela 3.4, temos a descrição das principais funções matemáticas, disponíveis no VBScript.
Tabela 3.4 Funções para cálculos matemáticos.
Função Descrição
Abs(n) Retorna o valor absoluto (sem sinal) do número n.
Atn(n) Retorna o valor do arco, cuja tangente é o número n. O
número n deve ser fornecido em radianos.
Cos(n) Retorna o coseno do número n. O número n deve ser
fornecido em radianos.
Exp(n) Retorna o número e (logaritmo neperiano e=2,7183),
elevado no número n.
Log(n) Retorna o logaritmo natural de um número n.
Rnd(n) Retorna um número aleatório entre 0 e 1.
Sgn(n) Retorna um número inteiro, indicando o sinal do
número n. Retorna –1 para números negativos e 1 para
números positivos.
149
Sin(n) Retorna o seno do número n. O número n deve ser
Sqr(n) Retorna a raiz quadrada do número n.
Tan(n) Retorna a tangente do número n. O número n deve ser
NOTA
Para converter graus para radianos, multiplique o valor em graus por π (3.14), e divida o
resultado por 180.
Na Tabela 3.5, temos alguns exemplos de utilização das funções matemáticas do VBScript.
Tabela 3.5 Alguns exemplos de utilização das funções matemáticas.
Exemplo Valor de retorno

Abs(-2350) 2350
Atn(2) 1,1071487177
Cos(0) 1
Exp(1) 2,71828182845905
Log(1000) 6,90775527898214
Rnd*10 Gera um número aleatório entre 0 e 10.
Sgn(-235) Retorna –1, pois o número é negativo.
Sin(0) Retorna 0
Sqr(400) Retorna 20
Tan(0) Retorna 0
Com isso, encerramos a apresentação das principais funções do VBScript. Para uma referência
completa, você pode consultar o site http://msdn.microsoft.com/scripting, ou os CD’s da
assinatura do MSDN (Microsoft Developer Network). Junto com o Visual Studio 6.0 é fornecida
uma cópia do MSDN.
150
Criando Suas Próprias Funções e Procedimentos

Neste item, aprenderemos a criar nossas próprias funções e sub-rotinas. O princípio, por trás
da criação de funções e sub-rotinas, é o de reaproveitamento de código e facilidade de
manutenção do programa. Imagine que estejamos criando uma página para cálculos
financeiros, por exemplo, depreciação contábil. Vamos supor que, em diversos pontos do
nosso script, seja necessária a realização do cálculo de depreciação. Poderíamos colocar o
código que faz o cálculo, em cada um dos pontos, onde o mesmo seja necessário. Porém esta
não é a melhor maneira de criarmos nosso script. Imagine, por exemplo, quando fosse
necessário alterar a maneira de realizar os cálculos. Teríamos que repassar todo o script,
procurando os pontos onde o código está, e fazer as alterações. Sem contar que estaríamos
criando um script bastante longo, dependendo do número de cálculos necessários.
Para resolver estes problemas, poderíamos criar uma função ou sub-rotina que faz os cálculos
de depreciação. Depois, em cada local onde precisamos fazer os cálculos, é só chamar a
função (ou sub-rotina), para fazer os cálculos. Quando fosse necessária a alteração da
metodologia de cálculo, era só alterar a função (ou sub-rotina) e pronto! Os novos cálculos
passarão a ser feitos com base na nova metodologia. Isto poupa esforço, reduz o número de
linhas do script, facilita a manutenção do mesmo, além de reduzir a possibilidade de erros.
Agora é chegada a hora de aprendermos a criar funções e sub-rotinas.
NOTA
Um termo que pode aparecer é “procedimento”. Um procedimento é um grupo de instruções
que pode ser chamado pelo nome atribuído a ele. Neste contexto, funções e sub-rotinas são
tipos de procedimentos.
Criando e Utilizando Sub-rotinas

Uma sub-rotina é um grupo de comandos que podem ser executados, simplesmente através
da chamada do nome da Sub-rotina. Podemos passar um ou mais argumentos para uma Sub-
rotina. Quando a mesma é chamada, a execução desloca-se para dentro da Sub-rotina e executa
todos os comandos. Depois, a execução do script continua, com o comando seguinte ao que
chamou a Sub-rotina.
A sintaxe para declaração de uma sub-rotina é a seguinte:

Sub Nome_da_Sub-rotina(argumento1, argumento2, ..., argumenton)
Comando1
Comando2
...
Comandon
End Sub
151
Uma sub-rotina pode, ou não, conter argumentos. Caso sejam necessários argumentos, os
mesmos serão passados quando a Sub-rotina for chamada, e devem ser passados, na mesma
ordem em que foram definidos.
DICA
Quando você criar Sub-rotinas, procure utilizar nomes que descrevam a função que ela tem.
Com isso você torna o entendimento do código mais fácil para quem for utilizá-lo.
Considere o seguinte exemplo de declaração de uma Sub-rotina:

Sub Calcula_imposto(salario, desconto, extras)
Comando1
Comando2
...
Comandon
End Sub
Neste caso, declaramos uma Sub-rotina chamada Calcula_imposto, a qual espera receber três
parâmetros: salario, desconto e extras. Os parâmetros devem ser fornecidos nesta ordem,
para que a Sub-rotina funcione corretamente.
Uma vez criada a Sub-rotina, podemos chamá-la, simplesmente digitando o nome, ou

utilizando a palavra Call, mais o nome da Sub-rotina. Nos exemplos abaixo, temos dois métodos
de chamada da Sub-rotina Calcula_imposto:
Calcula_imposto(1500,23,125)
ou
Call Calcula_imposto(1500,23,125)
Observe que os parâmetros são passados dentro do parênteses.
Também poderíamos declarar uma Sub-rotina sem parâmetros. Neste caso posso simplesmente
não utilizar os parênteses após o nome da Sub-rotina, ou utilizar um par de parênteses, sem
nada dentro, conforme indicado abaixo:
Sub Nome_da_Sub-rotina
Comando1
Comando2
...
Comandon
End Sub
ou
152
Sub Nome_da_Sub-rotina( )
Comando1
Comando2
...
Comandon
End Sub
Por exemplo, poderíamos criar uma Sub-rotina que exibe uma caixa de mensagem com a data
do sistema e a hora, no formato indicado na Figura 3.46.
Figura 3.46: Exibindo a data e a hora em uma caixa de mensagem.
Poderíamos criar todos os comandos necessários, para exibir a hora e a data neste formato, cada
vez que a exibição fosse necessária. Porém é mais prático criar uma Sub-rotina que faz este trabalho.
Cada vez que precisarmos exibir a data e a hora neste formato, é só chamarmos a Sub-rotina.
Na Listagem 3.8, temos o código da Sub-rotina exibe_data_hora, a qual faz a exibição da data
e da hora, no formato proposto pela Figura 3.46.
Listagem 3.8 – A Sub-rotina exibe_data_hora.

1 Sub exibe_data_hora
2 mes_atual=Month(Date())
3 mes_nome=MonthName(mes_atual,False)
153
4 mensagem = “Ano atual: ” & Year(Date()) & Chr(13)

5 mensagem = mensagem & “Mês atual: ” & mes_nome & Chr(13)
6 mensagem = mensagem & “Hoje é dia: ” & Day(Date())& Chr(13)
mensagem = mensagem & Chr(13) & “***************” & Chr(13)& Chr(13)
7 hora_atual = Hour(Time())
8 minuto_atual = Minute(Time())
9 segundo_atual = Second(Time())
10 mensagem = mensagem & “Hora atual: ” & hora_atual & chr(13)
11 mensagem = mensagem & “Minuto atual: ” & minuto_atual & chr(13)
12 mensagem = mensagem & “Segundo atual: ” & segundo_atual
13 MsgBox mensagem
14 End Sub
Agora, cada vez que for necessário exibir a data e a hora nos formatos do exemplo, basta
chamar a Sub-rotina exibe_data_hora, utilizando um dos seguintes comandos:
Call exibe_data_hora
ou
exibe_data_hora
Criando e Utilizando Funções

Uma função é um grupo de comandos que podem ser executados, simplesmente através da
chamada do nome da Função. Podemos passar um ou mais argumentos para uma Função, e
quando a mesma é chamada, a execução desloca-se para dentro da Função e executa todos os
comandos. Depois, a execução do script continua, com o comando seguinte ao que chamou a
Função. A diferença da Função para a Sub-rotina, é que a primeira sempre retorna um valor
para o comando que a chamou.
A sintaxe para declaração de uma Função é a seguinte:

Function Nome_da_Função(argumento1, argumento2, ..., argumenton)
Comando1
Comando2
...
Comandon
End Function
154
Uma Função pode, ou não, conter argumentos. Caso sejam necessários argumentos, os mesmos
serão passados quando a Função for chamada, e devem ser passados, na mesma ordem em
que foram definidos.
DICA
Quando você criar Função, procure utilizar nomes que descrevam os objetivos da Função.
Com isso você torna o entendimento do código mais fácil para quem for utilizá-lo.
Considere o seguinte exemplo de declaração de uma Função:

Function Converte_para_dolar(valor_em_real, cotacao_dolar)
Comando1
Comando2
...
Comandon
End Function
Neste caso, declaramos uma Função chamada Converte_para_dolar, a qual espera receber
dois parâmetros: um valor em real e a cotação do dólar.
Uma vez criada a Função, devemos chamá-la, em um comando de atribuição, isto é, o valor retornado
pela função, deve ser atribuído a uma variável, ou exibido através de um comando como MsgBox.
No exemplo abaixo, estamos atribuindo o valor de retorno da função, à variável valor_dolar.
valor_dolar = Converte_para_dolar (1500,1.81)
Também poderíamos exibir o valor retornado pela função, utilizando o comando MsgBox,
conforme indicado a seguir:
MsgBox “Valor em dólar: ” & Converte_para_dolar (1500,1.81)
Observe que os parâmetros são passados dentro dos parênteses, e na mesma ordem definida
quando da criação da função.
Também poderíamos declarar uma Função, sem parâmetros. Neste caso posso simplesmente
não utilizar os parênteses após o nome da Função, ou utilizar um par de parênteses, sem nada
dentro, conforme indicado a seguir:
Function Nome_da_Função
Comando1
Comando2
...
Comandon
End Function
155
ou
Function Nome_da_Função( )
Comando1
Comando2
...
Comandon
End Function
Por exemplo, vamos criar uma Função que converte um valor de um ângulo de graus para
radianos. Depois a utilizaremos dentro de um laço For...Next, para exibir o valor em radianos,
para os ângulos de 0 a 20 graus.
Na Listagem 3.9, temos o exemplo de um script onde foi criada a função CRad, que converte
um valor em graus para radianos. Depois utilizamos um laço For para exibir, através de uma
caixa de mensagem, os valores em radianos, para os ângulos de 0 a 20 graus.
Listagem 3.9 – A Função CRad – Converte valores de graus para radianos.

1 <HTML>
2 <HEAD>
3 <TITLE>Exemplo de criação de Função – CRad.</TITLE>
4 </HEAD>
5 <BODY>
7 <!—
8 ‘Criação da função CRad.
9 Function CRad(valor_graus)
10 CRad = (valor_graus*3.14)/180
11 End Function
12 For i=0 to 20
13 mensagem = mensagem & “Angulo: ” & i & “Valor em Radianos: ” &
FormatNumber(CRad(i),5)& Chr(13)
14 Next
15 MsgBox mensagem
156
16 —>
17 </SCRIPT>
18 <P>Converte de graus para radianos.</P>
19 </BODY>
20 </HTML>
Observe que, dentro da Função, atribuímos à variável CRad um determinado valor. É isso
que caracteriza uma Função. Dentro de seu código, devemos atribuir a uma variável que
tenha o mesmo nome da Função, um determinado valor. Este valor é que será o valor de
retorno da Função.
Também cabe salientar o uso da função FormatNumber, dentro do laço For. Essa função é
utilizada para formatar a maneira como um número é exibido. Neste caso, utilizamos a função
FormatNumber, para limitar o número de casas decimais, a cinco casas depois da vírgula.
Em cada passada do laço For...Next chamamos a função CRad, para fazer a conversão de
graus para radianos. O valor retornado pela função CRad, é passado para a função
FormatNumber, para ser formatado com apenas cinco casas decimais.
OBSERVAÇÃO
A linha 13 está sendo exibida em duas linhas, por questões de espaço. Quando for criar este
script, todo o conteúdo da linha 13, deve ser digitado em uma única linha.
Trabalhando com Eventos no VBScript

Com o Internet Explorer, temos um conjunto de objetos a nossa disposição. Cada um destes
objetos possui um conjunto de eventos, para os quais podemos criar código.
Um evento é uma ação realizada pelo usuário em uma página. Por exemplo, quando o usuário
clica com o mouse, em um botão de comando, é gerado o evento onclick deste botão. Para
cada evento, existe uma Sub-rotina associada, para a qual podemos criar código em resposta
ao evento. Por exemplo, quando o usuário clica em um botão de comando, podemos colocar
código no evento onclick deste botão, que valida os dados digitados pelo usuário. Caso algum
dado esteja com problemas, uma mensagem de erro é exibida, solicitando que o usuário
corrija os dados com problema.
No Modelo de Objetos do Internet Explorer, temos quatro objetos que podem responder a eventos:
157
➥ Window.
➥ Document.
➥ Form.
➥ Element.
Para criar procedimentos que respondam a eventos utilizamos o seguinte formato:
<SCRIPT ID=clientEventHandlersVBS LANGUAGE=vbscript>
<!—
Sub NomeDoObjeto_NomeDoEvento
Comando1
Comando2
...
Comandon
End Sub
—>
</SCRIPT>
O nome da Sub-rotina é que define a qual evento a mesma irá responder. O padrão para o
nome da Sub-rotina é: NomeDoObjeto_NomeDoEvento.
Na Listagem 3.10, temos um exemplo de utilização do evento Onload, do objeto Window.

Este evento, conforme o próprio nome sugere, ocorre quando a página é carregada. Observe
que o nome da Sub-rotina é: Window_onload, o que conforme descrito, significa o evento
Onload do objeto Window.
Listagem 3.10 – O evento Onload do objeto Window.

1 <HTML>
2 <HEAD>
3 <TITLE>Exemplo de eventos.</TITLE>
4 <SCRIPT ID=clientEventHandlersVBS LANGUAGE=vbscript>

5 <!—
6 Sub Window_onload
7 MsgBox “A página está sendo carregada!!”
8 End Sub
9 —>
158
10 </SCRIPT>
11 </HEAD>
12 <BODY>
13 <P>Exemplo de utilização do evento onload do objeto Window.</P>
14 </BODY>
15 </HTML>
Ao ser carregada esta página, o evento Onload do objeto Window é disparado, e o código da
Sub-rotina Window_onload é executado. Com isso é exibida uma caixa de mensagem, conforme
Figura 3.47: Caixa de diálogo criada pelo evento Window_onload.
Principais Eventos dos Objetos do Internet Explorer

O objeto Window é o objeto de mais alto nível. Ele representa a janela do Internet Explorer e
todos os seus elementos. Existem diversos eventos disponíveis para o objeto Window, conforme
descrito na Tabela 3.6.
Tabela 3.6 Os eventos do objeto Window.
Evento Descrição
Onbeforeunload Ocorre quando a janela está para ser fechada.
Onblur Ocorre quando a janela perde o foco.
Onerror Ocorre quando um erro é gerado na janela.
Onfocus Ocorre quando a janela recebe o foco.
Onhelp Ocorre quando é pressionada a tecla F1.
159
Evento Descrição
Onload Ocorre quando a janela está sendo carregada.
Onresize Ocorre quando a janela é redimensionada.
Onscroll Ocorre quando o usuário rola através do
conteúdo da janela.
Onunload Ocorre quando a janela é fechada.
Na Listagem 3.11, temos código definido para os eventos Window_onload, Window_onhelp

e Window_onunload.
Listagem 3.11 – Utilizando alguns eventos do objeto Window.

1 <HTML>
2 <HEAD>
3 <TITLE>Exemplo de eventos.</TITLE>
5 <!—
6 Sub Window_onload
7 MsgBox “A página está sendo carregada!!”
8 End Sub
9 Sub Window_onhelp
10 MsgBox “Você pressionou a tecla F1!!”
11 End Sub
12 Sub Window_onunload
13 MsgBox “Você está fechando este documento!!!”
14 End Sub
15 —>
16 </SCRIPT>
17 </HEAD>
18 <BODY>
19 <P>Exemplo de utilização de eventos do objeto Window.</P>
20 </BODY>
21 </HTML>
160
NOTA
Ao pressionar F1, será exibida a mensagem indicada na Figura 3.48, e logo em seguida será
aberta uma janela com a Ajuda do Internet Explorer, conforme indicado na Figura 3.49, uma
vez que F1 é a tecla padrão de Ajuda no Windows.
Figura 3.48: Mensagem exibida pelo evento Window_onhelp.
Figura 3.49: Janela com a Ajuda do Internet Explorer.
O objeto Document representa todo o conteúdo existente dentro do objeto Window. Existem
diversos eventos disponíveis para o objeto Document, conforme descrito na Tabela 3.7.
161
Tabela 3.7 Os eventos do objeto Documento.
Evento Descrição
Onafterupdate Ocorre após os dados terem sido enviados para o servidor
Web. Por exemplo, quando a página possui um formulário, no
qual o usuário preenche os campos e depois clica no botão
Enviar, enviando os dados para o servidor Web. Este, na
verdade, é um evento que ocorre no objeto Form, mas como
o objeto Form está contido no objeto Document, o objeto
Documento também é capaz de responder a este evento.
Onbeforeupdate Ocorre antes que os dados tenham sido enviados para o
servidor Web. Por exemplo, quando a página possui um
formulário, no qual o usuário preenche os campos e
depois clica no botão Enviar, enviando os dados para o
servidor Web. Este, na verdade, é um evento que ocorre
no objeto Form, mas como o objeto Form está contido no
objeto Document, o objeto Document também é capaz de
responder a este evento.
Onclick Ocorre cada vez que o usuário clica no documento.
Ondblclick Ocorre quando o usuário dá um clique duplo no
documento.
Ondragstart Ocorre quando o usuário começa a arrastar algum
elemento no documento.
Onhelp Ocorre quando o usuário pressiona a tecla F1.
OnKeyDown Ocorre quando uma tecla é pressionada, com exceção de
algumas teclas especiais, como Alt, por exemplo.
OnKeyPress Ocorre quando qualquer tecla é pressionada, inclusive as
teclas especiais.
OnKeyUp Ocorre quando uma tecla, que estava pressionada, é liberada.
Onmousedown Ocorre quando um botão do mouse é pressionado.
Onmousemove Ocorre quando o mouse é movimentado sobre o documento.
Onmouseup Ocorre quando um botão, que estava pressionado, é liberado.
Onselectstart Ocorre quando um elemento do documento é selecionado.
162
Agora vamos listar os principais eventos do objeto Form. O objeto Form é criado com a tag
<FORM> </FORM>. Podemos ter mais do que um objeto Form em um documento, desde
que os mesmos possuam nomes diferentes. Existem diversos eventos disponíveis para o objeto
Form, conforme descrito na Tabela 3.8.
Tabela 3.8 Os eventos do objeto Form.
Evento Descrição
Web. Por exemplo, quando a página possui um formulário,
no qual o usuário preenche os campos e depois clica no
botão Enviar, enviando os dados para o servidor Web.
servidor Web.
Onclick Ocorre cada vez que o usuário clica no formulário.
Ondblclick Ocorre quando o usuário dá um clique duplo no formulário.
Ondragstart Ocorre quando o usuário começa a arrastar algum
elemento no formulário.
OnKeyPress Ocorre quando qualquer tecla é pressionada, inclusive as
teclas especiais.
Onmousemove Ocorre quando o mouse é movimentado sobre o
formulário.
Onmouseout Ocorre quando o usuário move o mouse para fora da área
do formulário.
Onmouseover Ocorre quando o mouse é movimentado sobre o
formulário.
163
Evento Descrição
Onmouseup Ocorre quando um botão, que estava pressionado, é
liberado.
Onselectstart Ocorre quando um elemento do formulário é selecionado.
Onsubmit Ocorre quando o usuário clica no botão Enviar do formulário.
Onreset Ocorre quando o usuário clica no botão Reset do formulário.
Agora vamos listar os principais eventos do objeto Element. O objeto Element, representa
qualquer controle ou elemento visível que possa ser colocado em uma página. Podemos ter
mais do que um objeto Element em um documento, sendo que cada objeto é identificado pelo
seu nome. Não podemos ter dois elementos com o mesmo nome. Existem diversos eventos
disponíveis para o objeto Element, conforme descrito na Tabela 3.9.
Tabela 3.9 Os eventos do objeto Element.
Evento Descrição
Web. Por exemplo, quando a página possui um formulário,
no qual o usuário preenche os campos e depois clica no
botão Enviar, enviando os dados para o servidor Web.
servidor Web.
Onblur Ocorre quando o elemento perde o foco.
Onchange Ocorre quando os dados do elemento são alterados. Por
exemplo, quando alteramos o valor de um campo de
texto, em um formulário.
Onclick Ocorre cada vez que o usuário clica no elemento.
Ondblclick Ocorre quando o usuário dá um clique duplo no elemento.
Ondragstart Ocorre quando o usuário começa a arrastar um elemento
pela primeira vez.
164
Evento Descrição
Onfocus Ocorre quando o elemento recebe o foco.
OnKeyPress Ocorre quando qualquer tecla é pressionada, inclusive
as teclas especiais.
Onmousemove Ocorre quando o mouse é movimentado sobre o formulário.
Onmouseout Ocorre quando o usuário move o mouse para fora da área
do formulário.
Onmouseover Ocorre quando o mouse é movimentado sobre o formulário.
Onmouseup Ocorre quando um botão, que estava pressionado, é liberado.
Onresize Ocorre quando o elemento é redimensionado.
Onselectstart Ocorre quando um elemento é selecionado.
Onsubmit Ocorre quando o usuário clica no botão Enviar do formulário.
Onselect Ocorre quando o usuário termina de selecionar os dados de
um controle de entrada, como uma caixa de texto, por exemplo.
Apenas para exemplificar a utilização de eventos, vamos criar uma página onde temos uma
caixa de seleção. Nesta caixa de seleção temos três opções: Axcel Books, Developers Magazine
e Microsoft. Quando o usuário seleciona uma destas opções, o Internet Explorer,
automaticamente, carrega a página relacionada.
A Figura 3.50, mostra a página de exemplo.
Para tornar esta lista dinâmica, utilizamos o modelo de eventos e código VBScript, conforme
indicado na Listagem 3.12.
165
Figura 3.50: Criando uma lista de navegação.
Listagem 3.12 – Criando uma lista de navegação dinâmica.

1 <HTML>
2 <HEAD>
3 <TITLE></TITLE>

5 <!—
6 Sub navega_onchange
7 window.navigate window.navega.value
8 End Sub
9 —>
10 </SCRIPT>
11 </HEAD>
12 <BODY>
13 <P>Selecione uma opção na lista, para ir à página selecionada:</P>

14 <P>
15 <SELECT id=“navega” name=“navega”>

16 <OPTION selected value=Informativo>Selecione uma opção na lista</OPTION>
166
17 <OPTION value=http://www.axcel.com.br>Axcel Books Editora</OPTION>

18 <OPTION value=http://www.developers.com.br>Developers Magazine</OPTION>
19 <OPTION value=http://www.microsoft.com>Microsoft</OPTION>
20 SELECT>
21 </P>
22 </BODY>
23 </HTML>
Para tornar a lista dinâmica, utilizamos o evento onchange, do controle Navega. O controle
navega é uma caixa de combinação. Para maiores informações sobre criação de formulário
com HTML, consulte o Capítulo 2. Utilizamos o evento navega_onchange, o qual acontece
toda vez que um elemento da lista for selecionado.
Vejam que com uma única linha de código, tornamos a lista dinâmica. A linha de código foi
a seguinte:
window.navigate window.navega.value
A primeira parte utiliza o método Navigate do objeto Window. Este método é utilizado para
carregar uma página no Internet Explorer. O método Navigate espera receber um único
parâmetro, que é o endereço da página que deve ser carregada. Este parâmetro é obtido a
partir da propriedade value do controle Navega. Cada opção da caixa de combinação possui
um valor associado. Por exemplo, quando o usuário seleciona Microsoft, a propriedade value
é definida como http://www.microsoft.com, e este parâmetro é passado para o método
window.navigate, fazendo com que seja carregada a página da Microsoft. Este é o comportamen-
to desejado para a nossa página, ou seja, quando uma opção é selecionada, a página associada
a ela, deve ser carregada no Internet Explorer.
IMPORTANTE
Estamos utilizando o modelo de objetos e de eventos do Internet Explorer. O Nestcape Navigator
possui um modelo de objetos diferente do modelo do Internet Explorer. Por isso, scripts
desenvolvidos para o modelo do Internet Explorer, podem não funcionar corretamente no Netscape.
Conclusão
Neste capítulo, abordamos diversos tópicos importantes do VBScript. Iniciamos pelas funções
para determinação do subtipo de uma variável, bem como funções para conversão de subtipos.
Depois passamos a tratar de outras funções, tais como as para tratamento de texto, data e hora
e funções matemáticas. Estas funções são utilizadas na criação de aplicações práticas e são
de grande ajuda.
167
Em seguida, aprendemos a criar e utilizar Sub-rotinas e Funções, conhecendo as vantagens

de sua utilização.
Na parte final do capítulo, tratamos sobre o modelo de objetos do Internet Explorer e os

principais eventos associados a cada um dos objetos. Para quem procura maiores informações
sobre este assunto, sugiro o seguinte endereço: http://msdn.microsoft.com/scripting.
A partir do próximo capítulo estaremos aprendendo a utilizar a tecnologia ASP na criação de

páginas e sites dinâmicos. O conteúdo apresentado nestes capítulos iniciais é de fundamental
importância para a aprendizagem de ASP, e formam a base para o restante do livro.
168
Capítulo 4 – A Tecnologia ASP e o Modelo de Objetos do ASP 3.0
Capítulo 4
A Tecnologia ASP e o Modelo
de Objetos do ASP 3.0
169
Introdução
Vamos iniciar, a partir deste capítulo, a nossa jornada rumo a aprendizagem da tecnologia de
Active Server Pages – ASP 3.0. Passaremos ao aprendizado de uma série de conceitos importantes,
os quais são utilizados na construção de páginas dinâmicas e aplicativos para a Web.
Iniciaremos o capítulo com uma apresentação detalhada sobre a tecnologia ASP, para que
possam ser solucionadas quaisquer dúvidas, que por ventura o leitor ainda tenha a respeito
do que é exatamente esta tecnologia e do que é necessário para utilizá-la.
Em seguida, passaremos ao estudo do Modelo de Objetos do ASP 3.0, apresentando uma

visão geral sobre o Modelo de Objetos e a função de cada um dos objetos existentes.
Feitas as devidas apresentações, passaremos a estudar alguns objetos do ASP 3.0, sempre
ilustrando os conceitos apresentados com exemplos práticos e de fácil assimilação. Nos
exemplos procuro ilustrar a forma de utilização de cada um dos objetos, de modo que os
mesmos possam ser facilmente, adaptados para uso nas aplicações que se esteja desenvolvendo.
NOTA
Os objetos, que não forem tratados neste capítulo, serão vistos nos demais capítulos deste livro.
Finalizaremos o capítulo com alguns exemplos mais elaborados, onde procuro apresentar
diversas utilizações práticas para os objetos da tecnologia ASP 3.0.
Entendendo e Utilizando ASP

Quando começamos a utilizar ASP, surgem algumas dúvidas a respeito desta tecnologia. Conhecer
os diversos objetos, métodos e comandos é importante, porém igualmente importante é conhecer
o funcionamento de uma página ASP. Para isso temos que responder às seguintes perguntas:
➥ Como e onde uma página ASP é processada?
➥ O que uma página ASP retorna para o navegador do cliente?
➥ O que é preciso para criar e acessar páginas ASP?
Vamos às respostas.
170
Como e Onde uma Página ASP é Processada?

Primeiro devemos lembrar que o que caracteriza uma página como sendo uma página ASP é
a extensão .asp. Isto significa que nossas páginas devem ter a extensão .asp e não .htm ou
.html, normalmente utilizadas para páginas HTML estáticas. Por exemplo, quando o usuário
digita um endereço como o seguinte:
http://www.abc.com.br/compras.asp
o servidor identifica a página como sendo uma página ASP, devido a extensão .asp.
Uma vez identificada, a página ASP é “processada” pelo servidor Web (que pode ser o IIS ou o
Personal Web Server). O servidor, após identificar a página ASP, passa a mesma para uma DLL
chamada ASP.DLL. O código contido nesta DLL analisa toda a página ASP, linha por linha, em
busca de linhas de código ASP, o qual é executado. Após executado todo o código existente na
página, o resultado, no formato de uma página HTML simples, é enviado para o navegador do
cliente. Este processo é detalhado na Figura 4.1 e explicado em seguida.
1) www.abc.com.br/page1.asp
Cliente
Servidor Web – IIS
2) Identifica que é uma página ASP.

3) Passa o processamento para ASP.DLL
4) Interpreta e executa o código existente.
Cliente 5) Retorna um resultado no formato HTML.
1) www.abc.com.br/page2.asp
Figura 4.1: O processamento de uma página ASP.
Abaixo descrevemos, detalhadamente, os passos indicados na Figura 4.1.

1. O usuário digita o endereço ou clica em um link para uma página ASP, como por
exemplo www.abc.com.br/catalogo/precos.asp. O pedido do usuário é enviado para o
servidor Web, que no nosso exemplo é o IIS – Internet Information Services.
171
2. O servidor identifica que o pedido é para uma página que contém código ASP, pois a
extensão da página é .asp. No exemplo da Figura 4.1 um dos clientes solicita a página
page1.asp e o outro a página page2.asp.
3. Uma vez identificada como uma página ASP, o servidor Web passa o processamento da
página para o interpretador ASP (que no caso é a DLL ASP.DLL, normalmente instalada
no diretório winnt\System32\inetsrv, o qual é o diretório de instalação do IIS).
4. O interpretador passa linha por linha da página ASP. Sempre que for encontrado código
ASP, o mesmo é interpretado e executado.
5. Após todo o código ter sido executado, o resultado do processamento é enviado para o
navegador do cliente, no formato de uma página HTML padrão. É importante detalhar
bastante este ponto, pois existem muitas confusões e interpretações errôneas a respeito
do mesmo. Vamos fazer isso no próximo item.
Com isso podemos responder a pergunta do item: como e onde uma página ASP é processada?
Uma página ASP é processada no servidor Web (IIS ou Personal Web Server) pelo interpretador
ASP (ASP.DLL). O interpretador percorre a página, linha por linha, interpretando e executando
todo o código existente na página.
Agora vamos detalhar um pouco mais sobre o que a página ASP retorna para o navegador
do cliente.
O que uma Página ASP Retorna Para o Navegador do Cliente?

Quando o usuário digita o endereço ou clica em um link para uma página ASP, por exemplo
www.abc.com.br/page1.asp, a página page1.asp é interpretada e o código ASP executado.
Enquanto a página está sendo executada nada é retornado para o cliente (embora possamos
ter um certo controle sobre isso, fazendo com que a página seja exibida à medida que a
mesma vai sendo interpretada e executada. Aprenderemos a fazer este controle mais adiante.).
Após o processamento da página, o resultado é retornado para o navegador do cliente. Nunca

é demais repetir que o que é enviado para o navegador do cliente é apenas código HTML
padrão, resultante do processamento da página ASP. Isso pode facilmente ser comprovado.
No Internet Explorer 5.0 ou superior, basta que o usuário selecione o comando Exibir/Código
fonte, no menu de Opções. Isto irá exibir o código fonte da página que é enviada para o
navegador do cliente. Uma observação atenta é suficiente para verificar que o resultado é
apenas código HTML. Vamos exemplificar este fato. Considere a página ASP, extremamente
simples, da Listagem 4.1.
172
Listagem 4.1 – Uma página ASP simples – list4-1.asp.

2 <HTML>
3 <HEAD>
4 </HEAD>
5 <BODY>
6 <H1>EXEMPLO DE PÁGINA ASP</H1>
7 <%
8 Response.Write “Toda página ASP é interpretada <BR>”
9 Response.Write “e executada no servidor WEB !!!<BR>”
10 Response.Write “O resultado que retorna para o navegador<BR>”
11 Response.Write “do cliente, é código HTML padrão.”
12 %>
13 </BODY>
14 </HTML>
Ao acessar esta página ASP, o servidor Web interpreta e executa todo o código existente. No
nosso exemplo, o código ASP inicia na linha 7 e termina na linha 12. Relembrando o que
vimos no Capítulo 1: toda seção de código ASP inicia com <% e termina com %>.
O resultado, gerado pela página ASP, é código HTML padrão, o qual é enviado para o navegador
do cliente. A Figura 4.2, mostra a página list4-1.asp sendo acessada no Internet Explorer.
Figura 4.2: Acessando a página list4-1.asp.
173
Se escolhermos o comando Exibir/Código fonte, veremos o resultado indicado na Figura 4.3,

o que nada mais é do que código HTML. Isto comprova o que foi descrito neste item.
Figura 4.3: Código HTML resultante do processamento da página ASP.
Apenas para esclarecer,vamos ver qual o código ASP que gerou a seguinte linha de código HTML:
Toda página ASP é interpretada <BR>
Esta linha de código HTML é resultado da execução da seguinte linha de código ASP:
Response.Write “Toda página ASP é interpretada <BR>”
Ao executar esta linha de código ASP, o interpretador encontra o comando Response.Write. O

interpretador sabe que é para enviar para o navegador do cliente, tudo o que estiver entre aspas,
pois o comando Response.Write foi criado justamente para enviar um determinado texto para o
navegador do cliente (seria melhor dizer: “O método Write do objeto Response”, ao invés de
Response.Write, mas falaremos mais sobre objetos e seus métodos durante todo este capítulo).
Neste exemplo, simplesmente estamos utilizando o comando Response.Write para enviar o
código HTML para o cliente. A tag <BR> é a utilizada para quebra de linha: BR – Break Row.
Outro detalhe interessante a ser observado é que temos código HTML fora da seção de código
ASP. Na listagem 4.1, a linha 6 <H1>EXEMPLO DE PÁGINA ASP</H1> é código HTML.
Neste caso estamos utilizando a tag <H1> para criar o cabeçalho do documento, conforme
indicado na Figura 4.2. Este código HTML, que não é gerado por comandos ASP, é enviado
diretamente para o navegador do cliente, quando a página ASP é acessada.
174
Veja que a possibilidade de alternar trechos de código HTML, com trechos de código ASP,
dentro de uma mesma página ASP, nos dá uma grande flexibilidade. As partes da página que
não apresentam natureza dinâmica, podem ser criadas simplesmente utilizando código HTML.
Outras partes que necessitam ser dinamicamente criadas, quer seja através da realização de
cálculos ou através do acesso a campos de uma tabela de um banco de dados, podem ser
criadas utilizando código ASP. Além disso podemos ter várias seções de código ASP dentro
de uma mesma página. Para iniciar uma seção utilizo <% e para finalizar a seção utilizo %>.
Posso colocar código HTML entre as diversas seções de código ASP. Com isso vou criando a
página utilizando HTML nos pontos estáticos e ASP nos pontos que precisam ser dinâmicos.
O que é Preciso Para Criar e Acessar Páginas ASP?

Uma página ASP é gravada no servidor, no formato de um arquivo de texto comum, no qual
colocamos código HTML e código ASP, conforme descrito anteriormente. Por isso, posso
utilizar um redator de texto, como por exemplo o Bloco de Notas, para criação de páginas
ASP. Uma vez criado o arquivo .asp, basta salvá-lo em uma pasta no servidor Web e pronto, o
mesmo já pode ser acessado pelo navegador do cliente.
Também existem ferramentas gráficas que facilitam a criação de aplicações para a Web,
utilizando a tecnologia ASP. Uma ferramenta, desenvolvida pela própria Microsoft, é o
Microsoft Visual Interdev, o qual está, atualmente, na sua versão 6.0.
Como descrito anteriormente, uma página ASP é interpretada e executada no servidor Web.
Como servidor Web devemos utilizar o IIS – Internet Information Services 5.0 (o qual faz
parte do Windows 2000 Server), ou o Personal Web Server, para Windows 95 ou Windows 98.
Não existe, por exemplo, um interpretador ASP para o servidor Web Apache, ou para o Domino
da Lotus. Para maiores informações sobre os servidores Web que suportam ASP, consulte a
Introdução deste livro.
Podemos acessar páginas ASP utilizando qualquer navegador disponível (Internet Explorer,
Netscape Navigator, Mosaic, etc.). Isto é possível pelo fato de que uma página ASP é interpreta-
da e executada no servidor Web, retornando apenas código HTML padrão. Qualquer navegador
é capaz de exibir o conteúdo do código HTML de retorno. Com isso a utilização de páginas
ASP independe do navegador do cliente, o que passa a ser uma preocupação a menos para
quem desenvolve as páginas.
O fato de uma página ASP ser interpretada e executada no servidor Web traz inúmeras
vantagens, conforme já descrevemos, porém traz a desvantagem de não poder ser testada
localmente. Isto significa que você não pode simplesmente gravar uma página ASP em uma
pasta do seu computador e tentar acessá-la através do seu navegador. Fazendo isso, todo o
código ASP será, simplesmente, ignorado. Para que uma página ASP seja processada
175
corretamente, a mesma precisa estar armazenada em um servidor como o IIS, onde existe o
interpretador ASP. A página deve ser acessada utilizando-se o protocolo HTTP, isto é, ou você
digita o endereço da página, como por exemplo http://www.abc.com.br/page1.asp, ou clica
em um link que aponta para a página ASP gravada no servidor Web.
Uma das novidades da tecnologia ASP 3.0 é que podemos ter páginas com a extensão .asp,
sem que as mesmas contenham código ASP. Por exemplo, posso ter uma página .asp que
contém apenas código HTML. Quando esta página é solicitada, o servidor Web passa a
solicitação para o interpretador ASP (ASP.DLL). A primeira coisa que o interpretador faz é
verificar se existe algum código a ser interpretado e executado. Caso não exista código ASP, a
página é enviada de volta para o IIS, o qual retorna a página para o navegador do cliente. Com
este procedimento o interpretador não precisa passar a página, linha por linha. Isto torna a
execução das páginas bem mais rápida.
Caso a página possua código ASP, o código é interpretado e executado, e o resultado do

processamento é retornado para o IIS. Será inserido o código HTML, retornado pelo processador
ASP, nos pontos específicos da página, e o IIS enviará, depois, a página resultante no formato
HTML para o navegador do cliente. Com isso posso criar todas as páginas com a extensão
.asp, mesmo aquelas que não irão conter código ASP. Caso sejam necessárias mudanças nas
páginas, posso inserir o código ASP, sem que precise alterar os links do site, pois as extensões
das páginas não precisarão ser alteradas (isso aconteceria somente se tivéssemos criado as
páginas como .htm e depois trocado a extensão para .asp quando fosse necessário inserir
código ASP nas páginas).
Objetos do ASP 3.0

Com a tecnologia ASP 3.0 temos acesso a uma série de objetos e métodos que fazem parte do
próprio ASP. Estes objetos e métodos fornecem diversas funcionalidades necessárias à criação
de páginas dinâmicas. Como exemplo, temos um objeto chamado Request, o qual pode ser
utilizado para processar as informações que o usuário preenche em um formulário. Temos
também um objeto Response, do qual já utilizamos o método Write na Listagem 4.1, o qual é
utilizado para retornar informações para o navegador do cliente, além de vários outros.
Neste item faremos uma apresentação genérica sobre o Modelo de Objetos do ASP 3.0, bem
como uma breve descrição de cada objeto. Nos demais itens deste capítulo estaremos tratando,
em detalhes, de cada um destes objetos. Estudaremos os objetos através de exemplos práticos
de utilização dos mesmos.
176
Uma Visão Geral do Modelo de Objetos do ASP 3.0

O Modelo de Objetos do ASP 3.0 apresenta os seguintes objetos:
➥ Response
➥ Request
➥ Application
➥ Session
➥ Server
➥ ASPError (este é novidade do ASP 3.0).
Cada um destes objetos pode possuir os seguintes elementos:

➥ Methods (Métodos)
➥ Collections (Coleções)
➥ Properties (Propriedades)
➥ Events (Eventos)
Chamamos um método de um objeto para que o mesmo realize uma determinada ação. De
maneira geral, sem nos preocuparmos em sermos precisos em relação à teoria de Orientação
a Objetos, poderíamos dizer que: “Um método é um comportamento ou ação realizada por
um objeto”. Por exemplo, quando utilizamos o método Write do objeto Response
(Response.Write), o comportamento esperado é que o método Write envie o texto fornecido
entre aspas, para o servidor Web, que por sua vez envia para o navegador do cliente.
Conforme pode ser constatado pela Listagem 4.1, para chamarmos um método de um objeto,
utilizamos a seguinte sintaxe:
Nome_do_objeto.Nome_do_método parâmetros
Observe o exemplo da Figura 4.4.
Método
Response.Write "Objetos do ASP 3.0!!!"
Objeto Parâmetro
Figura 4.4: Utilizando o método Write do objeto Response.
177
Uma propriedade de um objeto define uma característica ou atributo do mesmo. Por exemplo,
temos a propriedade ScriptTimeout, a qual define o tempo máximo em que o código ASP
pode ficar sendo executado em uma página, antes que o servidor cancele a execução e retorne
uma mensagem de erro. O valor padrão é de 90 segundos. O exemplo seguinte define esta
propriedade para 5 minutos (300 segundos):
Server.ScriptTimeout = 300
Observe que as propriedades de um objeto são chamadas da mesma maneira que os métodos,
isto é:
Nome_do_objeto.Nome_da_propriedade = valor
Uma coleção contém um ou mais valores, os quais podem ser acessados pelo código ASP. Por
exemplo, a coleção Form, do objeto Request, contém os nomes e valores de todos os controles de
um formulário cujos dados foram passados para processamento da página ASP. Lembre que isto
é feito através do atributo Action da tag FORM, além disso o atributo Method deve ser definido
em POST. Para maiores detalhes sobre os atributos Action e Method, consulte o Capítulo 2.
Figura 4.5: O Modelo de Objetos do ASP 3.0.
Um evento é uma determinada ação que acontece, e para a qual podemos escrever código
ASP em resposta. Por exemplo, o objeto Session contém um evento OnStart, que ocorre quando
um usuário estabelece uma sessão com uma página ASP antes que uma requisição do usuário
178
seja executada. Podemos utilizar este evento para iniciar variáveis ou rodar qualquer outro
código que seja necessário. Você já deve ter entrado em um site onde é necessário preencher
um formulário de cadastramento. Da próxima vez que você entra no site, você recebe uma
mensagem dizendo “Bem vindo Fulano de tal!”. Como é que o site sabe que é você, ou pelo
menos o seu computador, que está entrando no site? A página utiliza o evento Session.OnStart
para ler informações que foram gravadas no seu computador, normalmente na forma de um
Cookie e determinar quem está acessando a página.
Na Figura 4.5, temos uma visão geral de todos os Objetos, seus métodos, coleções, eventos e
propriedades. No restante deste capítulo, estaremos aprendendo a utilizar os objetos Response
e Request. Os demais objetos serão vistos ao longo do livro.
O Objeto Request
Com o objeto Request podemos ter acesso a diversas informações fornecidas pelo cliente ao
acessar uma página ASP, ou ao preencher dados em um formulário e enviá-los. Podemos ter
acesso a informações a respeito do navegador que o cliente está utilizando, quais os Cookies
gravados no computador do usuário, qual Certificado Digital o usuário está utilizando e muitas
outras informações importantes.
A partir de agora passaremos a estudar os principais métodos, coleções e propriedades do

objeto Request. Analisaremos os diversos aspectos deste objeto, através da utilização de alguns
exemplos práticos.
Coleções do Objeto Request

O objeto Request possui diversas coleções. Uma coleção nada mais é do que uma estrutura de
dados. Nesta estrutura de dados temos diversos valores, e a cada um deles está associada
uma chave de identificação, a qual pode ser utilizada para acessar o valor contido na coleção.
Através das coleções do objeto Request, podemos ter acesso a diversas informações do cliente,
como por exemplo, os dados que digita em um formulário.
A Coleção Form do Objeto Request

Para estudar esta coleção, vamos fazer uma revisão rápida sobre a maneira como os dados
digitados em um formulário são passados para o servidor para processamento.
Considere o formulário da Listagem 4.2.
179
Listagem 4.2 – Um formulário HTML simples – list4-2.htm.

1 <HTML>
2 <HEAD>
3 <TITLE>Formulário para Cadastro de Clientes !!</TITLE>
4 </HEAD>
5 <BODY>
6 <P><STRONG>Formulário para Cadastro de Clientes:</STRONG></P>
7 <P>Digite os dados solicitados e clique no botão Enviar.</P>
8 <FORM action=“list4-2.asp” method=“post”>
9 <P>Nome: <INPUT id=nome maxLength=50 name=nome></P>

10 <P>Rua: <INPUT id=rua maxLength=35 name=rua ></P>
11 <P>Cidade: <INPUT id=cidade maxLength=30 name=cidade></P>
12 <P>e-mail: <INPUT id=email maxLength=50 name=email></P>
13 <P>Cartão Crédito:
14 <INPUT id=cartao name=cartao type=radio value=“Visa”>Visa
15 <INPUT id=cartao name=cartao type=radio value=“Master Card”>Master Card
16 <INPUT id=cartao name=cartao type=radio value=“Outros”>Outros</P>
17 <P>
18 <INPUT id=enviar name=enviar type=submit value=Enviar>
19 <INPUT id=limpar name=limpar type=reset value=Reset>
20 </P>
21 </FORM>
22 </BODY>
23 </HTML>
Ao acessarmos o arquivo da Listagem 4.2, no Internet Explorer, obtemos o resultado indicado

na Figura 4.6.
Para maiores detalhes sobre a construção de formulários HTML, veja o Capítulo 2.
Observe que cada campo possui as propriedades “id” e “name” iguais. Definimos estas duas
propriedades para de manter a padronização. Para os objetos do ASP, o que é realmente utilizado
é a propriedade name, a qual identifica cada um dos campos de um formulário.
Observe que o atributo method do formulário, na linha 8, foi definido como post. Quando
utilizamos o método post, os dados digitados no formulário são enviados em uma conexão
separada, fazendo com que os mesmos não fiquem visíveis na linha de endereço do navegador.
180
Além disso o método post permite que mais informações sejam enviadas, do que se
estivéssemos utilizando o método get. Falaremos um pouco mais sobre as diferenças entre os
métodos post e get, no próximo item.
Figura 4.6: O formulário da Listagem 4.2.
O atributo action do formulário, na linha 8, foi definido como list4-2.asp. Isto significa que a
página ASP list4-2.asp é que vai processar os dados enviados pelo formulário. Neste caso
digitamos somente o nome da página porque a página HTML, que contém o formulário, e a
página ASP, que irá processar os dados digitados no formulário, estão na mesma pasta do
servidor Web. Poderia acontecer da página ASP estar, inclusive, em um outro servidor. Neste
caso devemos digitar o endereço completo da página ASP, como por exemplo:
<FORM action=“http://www.abc.com.br/Capitulo4/list4-2.asp” method=“post”>
Ao clicar no botão Enviar, os dados digitados no formulário são passados para a página list4-
2.asp. Precisamos de uma maneira de acessar estes dados. A coleção que nos permite ter
acesso a estes dados é a coleção Form do objeto Request.
181
IMPORTANTE
A coleção Form somente é utilizada quando o atributo method do formulário é definido como
post. Quando o método for definido como get, conforme veremos mais adiante, devemos utilizar
a coleção QueryString, ao invés da coleção Form.
A maneira de acessar os dados é exemplificada abaixo:

Request.Form(“Nome_do_Campo”)
Onde Nome_do_Campo é o valor definido no atributo name de cada um dos campos do

formulário. Por exemplo, o campo nome, na Listagem 4.2, tem a sua propriedade name definida
como nome. Para acessar o valor digitado no campo nome, utilizaríamos o seguinte comando:
Request.Form(“nome”)
Na Listagem 4.3, temos um exemplo para a página list4-2.asp, a qual simplesmente informa
ao usuário quais os valores que ele digitou em cada um dos campos. Para isso, utilizamos a
coleção Form do objeto Request.
Listagem 4.3 – A página ASP list4-2.asp.

2 <HTML>
3 <HEAD>
4 </HEAD>
5 <BODY>
6 <h2> Você digitou os seguintes dados !!</h2>
7 <P>Nome:
8 <%
9 =Request.Form(“nome”)
10 %>
11 </P>
12 <p>Rua:
13 <%
14 =Request.Form(“rua”)
15 %>
16 </p>
17 <p>Cidade:
182
18 <%
19 =Request.Form(“cidade”)
20 %>
21 </p>
22 <p>E-mail:
23 <%
24 =Request.Form(“email”)
25 %>
26 </p>
27 <p>Cartão de Crédito:
28 <%
29 =Request.Form(“cartao”)
30 %>
31 </p>
32 <P><A href=“list4-2.htm”>Clique aqui para voltar ao formulário</A></P>
33 </BODY>
34 </HTML>
Observe que vamos alternando trechos de código HTML com trechos de código ASP. Vamos
analisar o seguinte trecho de código:
7 <P>Nome:
8 <%
9 =Request.Form(“nome”)
10 %>
11 </P>
Na linha 7, é aberta uma tag de parágrafo <P>. Dentro deste parágrafo é colocado o texto
Nome:. Na linha 8 é aberto um trecho de código ASP, e utilizo a coleção Form do objeto
Request para ter acesso ao valor digitado no campo nome. No nosso exemplo, a linha 9
simplesmente retorna o texto digitado no campo nome do formulário. Este nome é colocado
logo após Nome:. Finalmente na linha 11 é fechado o parágrafo. O resultado deste trecho de
código que retorna para o usuário é o seguinte (supondo que no campo nome tenha sido
digitado Júlio Cesar Fabris Battisti):
<P>Nome: Júlio Cesar Fabris Battisti</P>
Na Figura 4.7, temos o retorno da página list4-2.asp, para os dados de exemplo indicados na
Figura 4.6.
183
Figura 4.7: O retorno da página list4-2.asp.
Observe que, com o uso da coleção Form, podemos ter acesso a todos os campos do formulário.
A maneira como a página list4-2.asp foi construída irá funcionar bem, porém poderemos ter
alguns problemas. Por exemplo, vamos supor que por algum motivo, o nome de um dos
campos do formulário precise ser alterado. Caso isso aconteça, precisaríamos alterar a página
ASP, pois a coleção Form, utiliza a propriedade name do campo, para ter acesso ao conteúdo
do mesmo.
Podemos contornar esta dificuldade utilizando uma estrutura de controle que permite percorrer
todos os itens de uma coleção. Percorreremos os itens da coleção Form capturando o nome do
campo e o valor do mesmo. Com isso se o nome de algum campo mudar, a mudança será
detectada cada vez que a página ASP for chamada, pois o nome do campo não estará fixado
dentro do próprio arquivo ASP, como ocorre na Listagem 4.3.
A estrutura de controle que permite percorrer todos os elementos de uma coleção possui a
seguinte estrutura:
For Each membro In Nome_da_Coleção
Comando1
184
Comando2
...
Comandon
Next
Com a estrutura For Each...Next, conseguimos percorrer todos os membros de uma coleção.
Considere o seguinte exemplo:
<%
For Each Item in Request.Form
=Item
Next
%>
Neste caso estaremos listando todos os nomes dos campos do formulário, através da utilização
da estrutura For Each...Next.
Agora vamos utilizar a estrutura For Each...Next para rescrever a nossa página ASP de uma
maneira mais genérica, conforme indicado na Listagem 4.4.
Listagem 4.4 – A página ASP list4-2-2.asp.

2 <HTML>
3 <HEAD>
4 </HEAD>
5 <BODY>
6 <H2> Você digitou os seguintes dados !!</H2>
7 <%
8 For Each Item in Request.Form %>
9 <P>
10 <%=Item%>
11 :
12 <%=Request.Form(Item)%>
13 </P>
14 <% Next %>

16 </BODY>
17 </HTML>
185
Esta página produz o mesmo resultado que a página ASP da Listagem 4.3, porém vejam como
o código é bem menor. Além disso este código funciona sempre, mesmo que o nome de
algum dos campos do formulário seja alterado. Para testar este código basta salvar esta listagem
com o nome de list4-2-2.asp e alterar a página list4-2.htm. No atributo action da tag <FORM>
troque action=“list4-2.asp” por action=“list4-2-2.asp”.
Também é interessante notar que fomos alternando trechos de código HTML com código
ASP. Por exemplo, as linhas 7 e 8 são código ASP, onde é iniciado o laço For Each...Next. Na
linha 9 abrimos uma tag de parágrafo. Na linha 10 é exibido o nome do campo, através da
utilização de <% = Item%>. Na linha 11 colocamos o sinal : que vai ficar entre o nome do
campo e o valor digitado no campo. Na linha 12 é exibido o valor digitado no campo do
formulário, cujo atributo nome foi exibido pela linha 10. A linha 13 fecha a tag de parágrafo
e, finalmente, a linha 14 encerra o laço For Each...Next. Observe que o laço foi aberto em uma
seção de código e fechado em outra, o que nos dá uma grande flexibilidade.
A Coleção QueryString do Objeto Request

Utilizamos a coleção QueryString quando o formulário utilizar o método get ao invés do
método post. Quando utilizamos o método get, os dados são passados para o servidor, junto
com a URL de endereço. Vamos alterar o formulário da Listagem 4.2, para que o mesmo
utilize o método get ao invés do método post. Também vamos alterar o atributo action, para
que o mesmo chame a página ASP formget.asp, para processar os dados digitados no
formulário. Com estas modificações, teremos o formulário indicado na Listagem 4.5.
Listagem 4.5 – Um formulário HTML simples – formget.htm.

1 <HTML>
2 <HEAD>
3 <TITLE>Formulário para Cadastro de Clientes !! </TITLE>
4 </HEAD>
5 <BODY>

8 <FORM action=“formget.asp” method=“get”>

186
17 <P>
20 </P>
21 </FORM>
22 </BODY>
23 </HTML>

na Figura 4.8.
Figura 4.8: O formulário da Listagem 4.5.
187
Para criar o arquivo formget.asp, basta pegar o código da Listagem 4.4 e trocar Request.Form
por Request.QueryString. Com isso teremos o código da Listagem 4.6.
Listagem 4.6 – A página ASP formget.asp.

2 <HTML>
3 <HEAD>
4 </HEAD>
5 <BODY>
7 <%
8 For Each Item in Request.QueryString %>
9 <P>
10 <%=Item%>
11 :
12 <%=Request.QueryString(Item)%>
13 </P>
14 <% Next %>
15 <P><A href=“formget.htm”>Clique aqui para voltar ao formulário</A></P>

16 </BODY>
17 </HTML>
Esta página fornece o retorno indicado na Figura 4.9. Observe que o resultado é praticamente
o mesmo da Figura 4.7, porém com a diferença de que os dados foram passados através do
endereço de chamada da página.
No campo endereço temos o seguinte:

http://servidor/Capitulo4/formget.asp?nome=J%FAlio+Cesar+Fabris+Battisti&rua=Sinimbu+-
+456&cidade=Boqueir%E3o+do+Le%E3o&email=batisti@hotmail.com&cartao=Outros&enviar=Submit
Observe que os dados foram passados dentro da própria URL. Caracteres especiais, como o u
com acento agudo, são substituídos. Observe que o nome Júlio foi substituído por J%FAlio,
ou seja, o ú foi substituído por %FA. Também podemos observar que todo espaço em branco
foi substituído pelo sinal +, e assim por diante. Neste caso a coleção QueryString sabe tratar
estes caracteres especiais e exibi-los corretamente, conforme indicado pela Figura 4.9.
O método get possui limitações quanto a quantidade de informações que o mesmo pode
passar para o servidor. Esta limitação está em torno de 1.000 caracteres, conforme definição
188
do protocolo HTTP. Além disso, toda a informação passada será visível na URL, o que em
muitas situações não é desejado.
Figura 4.9: O retorno da página formget.asp.
É por isso que hoje, na maioria dos casos, utilizamos o método post, que não tem as mesmas
limitações do método get. Algumas aplicações antigas, com alguns scripts CGI, podem ter
sido desenvolvidos para usar o método get, neste caso os mesmos não funcionarão com o
método post. No restante deste livro, estaremos utilizando o método post.
Alguns Campos que Merecem Considerações Especiais

Um dos campos de formulários que merecem considerações especiais é o grupo de Check
Box. Quando temos um grupo de Check Box, um ou mais itens do grupo podem ser
selecionados. Neste caso precisamos determinar qual ou quais itens foram selecionados e
qual o valor associado a cada um deles. Observe a Listagem 4.7.
189
Listagem 4.7 – Modificando o formulário formget.htm.

1 <HTML>
2 <HEAD>
3 <TITLE>Formulário para Cadastro de Clientes !! </TITLE>
4 </HEAD>
5 <BODY>

8 <FORM action=“formget.asp” method=“get”>

17 <P>
20 </P>
21 <P>
22 <INPUT id=estado name=estado type=checkbox value=SP>SP
23 <INPUT id=estado name=estado type=checkbox value=RJ>RJ
24 <INPUT id=estado name=estado type=checkbox value=RS>RS
25 <INPUT id=estado name=estado type=checkbox value=SC>SC
26 <INPUT id=estado name=estado type=checkbox value=PR>PR
27 </P>
21 </FORM>
22 </BODY>
23 </HTML>
190

na Figura 4.10.
Figura 4.10: Um grupo de Check Box foi adicionado ao formulário.
Ao clicar no botão Enviar receberemos os resultados indicados na Figura 4.11. Observe que a
nossa página ASP formget.asp já processou corretamente os resultados.
Um detalhe que devemos observar é que os valores associados a cada um dos Check Box
marcados é o valor do atributo value. Se este atributo não tiver sido definido, será exibido On
para cada um dos Check Box marcados. Observe, na Listagem 4.7, que o atributo name é o
mesmo para todos os Check Box do grupo. É justamente isto que caracteriza um grupo de
Check Box, todos possuem o mesmo valor para a propriedade name.
191
Figura 4.11: O resultado dos Check Box marcados já é exibido corretamente.
Quando a página ASP recebe os dados, ela recebe os valores selecionados, todos no nome do
grupo. Por exemplo o seguinte código:
<% =Request.QueryString(“estado”)%>
produziria uma saída com o valor dos Check Box selecionados. Caso mais do que um Check Box
tenha sido selecionado, os valores serão exibidos separados por vírgula, conforme indicado abaixo:
SP, RS, PR
Com isso dizemos que o elemento estado, da coleção QueryString, possui valores múltiplos.
Existem situações em que pode ser necessário acessar um destes valores individualmente.
Isto é possível, pois cada um dos valores possui uma propriedade de índice associada. O
primeiro valor selecionado possui índice 1, o segundo possui índice 2 e assim por diante.
192
IMPORTANTE
No caso de um grupo de Check Box, os índices não são associados à ordem com que os Check
Box são apresentados no formulário, mas sim em relação a quantos são selecionados. Se
tivermos 2 Check Box selecionados, somente teremos o índice 1 e o índice 2. O índice 1 é ligado
ao primeiro Check Box selecionado que aparece no formulário. O índice 2 é ligado ao próximo
Check Box do grupo que aparecer selecionado, e assim por diante.
Caso quiséssemos acessar somente o valor do primeiro Check Box selecionado, utilizaríamos
o seguinte código:
<% =Request.QueryString(“estado”)(1) %>
Observe a utilização do índice (1) após o nome do campo. Com isso estou pedindo para que
seja retornado apenas o valor do primeiro Check Box selecionado. Este código retornaria
somente SP, no nosso exemplo.
NOTA
Estas mesmas considerações são válidas para elementos do tipo Caixa de seleção e Caixa de
combinação.
A Coleção ServerVariables do Objeto Request

A coleção ServerVariables possui valores que são somente de leitura, isto é, não podemos
modificar os valores desta coleção. São valores enviados através da requisição do navegador do
cliente, dentro do cabeçalho do protocolo HTTP, e alguns valores existentes no servidor Web.
Podemos acessar o valor de uma determinada variável utilizando a seguinte sintaxe:

Request.ServerVariables(“Nome_da_Variável)
Por exemplo, o seguinte código retorna o número IP do computador do cliente:

<%=Request.ServerVariables(“remote_addr”)%>
Na Tabela 4.1, temos uma descrição das principais variáveis disponíveis.
Tabela 4.1 Variáveis de ambiente acessíveis através da coleção ServerVariables.
Nome Descrição
ALL_HTTP Retorna todos os cabeçalhos HTTP enviados pelo cliente.
ALL_RAW Captura todos os cabeçalhos, da maneira como foram
enviados pelo cliente.
193
Nome Descrição
AUTH_TYPE Retorna o tipo de autenticação utilizado pelo servidor
Web.
AUTH_USER Retorna o nome do usuário autenticado no servidor Web.
CERT_COOKIE Retorna um identificador único, ligado ao certificado
do cliente.
CERT_FLAGS Mostra se o certificado do cliente é válido.
PATH_INFO Retorna informações sobre o caminho relativo à
página que está sendo exibida.
PATH_TRANSLATED Retorna informações sobre o caminho físico (por
exemplo: c:\inetpu\wwroot\page1.asp), relativo à
página que está sendo exibida.
QUERY_STRING Retorna os valores de um formulário passados através
do método get.
REMOTE_ADDR Retorna o endereço IP da máquina do cliente.
REMOTE_HOST Retorna o nome da máquina do cliente.
REQUEST_METHOD Retorna o método utilizado para a requisição da
página: post ou get.
SERVER_PORT Retorna a porta TCP na qual a requisição foi feita. Por
padrão, o servidor Web atende requisições na porta 80.
SERVER_PROTOCOL Retorna a versão e o nome do protocolo de requisição,
por exemplo HTTP 1.1.
SERVER_SOFTWARE Retorna o nome e a versão do servidor HTTP.
URL Retorna a porção básica da URL.
Na Listagem 4.8, utilizamos o laço For Each...Next, para exibir todos os valores contidos na
coleção ServerVariables.
Listagem 4.8 – Exibindo os valores contidos na coleção ServerVariables – variables.asp.

2 <HTML>
3 <HEAD>
4 </HEAD>
194
5 <BODY>
6 <TABLE border=2>
7 <%For Each Variavel in Request.ServerVariables %>
8 <TR>
9 <TD>
10 <% =Variavel %>
11 =</TD>
12 <TD>
13 <% =Request.ServerVariables(Variavel) %>
14 </TD></TR>
15 <%Next%>
16 </BODY>
17 </HTML>
Com este código simples conseguimos exibir todo o conteúdo da coleção ServerVariables.
Observe, na Listagem 4.8, que utilizamos algumas tags HTML para a construção de tabelas.
Estas tags foram utilizadas apenas para melhorar a aparência do documento resultante. Para
cada variável exibimos o nome da variável (linha 10) e o valor contido na variável (linha 13).
Na linha 14, utilizamos &nbsp. Este é um caractere especial para o HTML e é utilizado para
que o navegador do cliente exiba as células da tabela, mesmo quando estas estiverem vazias.
O Internet Explorer não exibe os contornos de uma célula, caso não exista nenhum conteúdo
na mesma, o que torna o resultado final pouco elegante. Na Figura 4.12, podemos ver a parte
final do resultado do processamento do documento variables.asp.
Figura 4.12: Exibindo o conteúdo da coleção ServerVariables.
195
Observe a variável SERVER_SOFTWARE, a qual exibe o valor Microsoft-IIS/5.0, indicando

que esta página está armazenada em um servidor Windows 2000, com servidor Web IIS 5.0.
Um pequeno exemplo prático: vamos supor que você deseja construir uma página que somente
deve ser acessada por pessoas de uma determinada rede. Os computadores da Internet utilizam
um protocolo chamado TCP/IP. Todo computador que faz parte da rede deve possuir um
número IP, e não podem existir dois computadores com o mesmo número IP. O número IP é
um número no seguinte formato:
10.200.120.135
162.233.140.72
São quatro números separados por um ponto. O valor máximo de cada número é 249, ou seja,
não posso ter um endereço IP 10.300.210.143. O 300 é um valor inválido em termos de número
IP. Parte do número IP identifica a rede a qual pertence o computador e outra parte identifica
o número do computador dentro da rede. Esta fora do escopo deste livro uma discussão mais
ampla sobre o protocolo TCP/IP, mas existem excelentes fontes de referência na Internet.
Você pode começar pelos sites da CISCO (www.cisco.com) e 3COM (www.3com.com).
Vamos supor que somente devem acessar a nossa página computadores cujo endereço IP
começa com 10.204.123 (que é exatamente o número da rede que utilizo em minha casa),
sendo que o quarto número não importa. Neste caso estamos admitindo que os três primeiros
números identificam a rede (10.204.123) e o último número identifica o computador dentro
da rede. Neste caso, quero construir uma página que somente permita acesso a computadores
da rede 10.204.123. Vamos ver como se faz isto?
O algoritmo que utilizaremos é o descrito a seguir.
Utilizaremos a variável REMOTE_ADDR para capturar o número IP do computador que está

tentando acessar a nossa página.
Depois utilizaremos funções do VBScript para capturar apenas a parte do endereço da rede
(três primeiros números), e comparo este valor com o valor 10.204.123.
Caso o valor esteja OK, o acesso ao restante da página é liberado, caso contrário o usuário será
direcionado para um outra página, a qual contém uma mensagem dizendo que o mesmo não
tem permissão para acessar a página desejada.
A código que implementa o nosso algoritmo é mostrado na Listagem 4.9.
Listagem 4.9 – Um exemplo prático de uso da coleção ServerVariables – filtro.asp.

2 <HTML>
196
3 <HEAD>
4 </HEAD>
5 <BODY>
6 <%
7 ‘Captura o número IP do computador do Cliente
8 Dim ip_cliente
9 Dim num_rede
10 ip_cliente=Request.ServerVariables(“REMOTE_ADDR”)
11 ‘ Utilizo a função Left para extrair apenas

12 ‘ os 10 primeiros caracteres, os quais devem
13 ‘ ser iguais a 10.204.123
14 num_rede=Left(ip_cliente,10)
15 ‘ Agora comparo o número de rede do cliente com

16 ‘ o número de rede permitido
17 If num_rede=“10.204.123" Then
18 Response.Write “<P>Parabéns !!!</P>”

19 Response.Write “<P>VOCÊ CONSEGUIU ACESSAR ESTA PÁGINA,<BR> PORQUE O SEU ”
20 Response.Write “COMPUTADOR<BR> FAZ PARTE DA REDE<BR>” %>
21 <%=num_rede%>
22 <% Response.Write “</P>” %>
23 <% Else
24 Response.Redirect(“erro.htm”)
25 End If
26 %>
27 </BODY>
28 </HTML>
Ao acessar esta página de um computador que faz parte da rede 10.204.123, receberemos a
página indicada na Figura 4.13.
197
Figura 4.13: Usuários da rede 10.204.123 têm permissão de acesso.
Ao acessar esta página de um computador que não faz parte da rede 10.204.123, receberemos
a mensagem de erro indicada na Figura 4.14.
Figura 4.14: Usuários fora da rede 10.204.123 não têm permissão de acesso.
198
NOTA
Na linha 24 utilizamos o método Redirect do objeto Response (Response.Redirect) para
redirecionar o usuário para uma outra página (erro.htm), caso o mesmo não fizesse parte da
rede 10.204.123. Falaremos mais sobre o objetos Response e seus métodos ainda neste capítulo.
A Coleção Cookies do Objeto Request

Esta coleção contém os valores de todos os Cookies enviados pelo navegador do cliente,
juntamente com a requisição da página ASP. Conforme descrevemos anteriormente, Cookies
são pequenos arquivos que são gravados no computador do usuário. A informação contida
nestes Cookies, normalmente, é utilizada para o site poder identificar o usuário na próxima
vez que for acessado. Quando o usuário acessa uma determinada página, o navegador envia,
junto com a requisição da página, todos os Cookies relacionados com o site que está sendo
acessado. Cada Cookie pode conter um ou mais valores, e podem existir um ou mais Cookies
associados ao site acessado. Todos os valores de todos os Cookies são acessíveis através da
coleção Cookies do objeto Request. Estes valores são somente para leitura, isto é, não podem
ser modificados. Os Cookies são gravados utilizando o método Cookies do objeto Response.
Veremos o objeto Response em mais detalhes ainda neste capítulo. A título de exemplo,
vamos considerar a página da Listagem 4.10.
Listagem 4.10 – Criando um Cookie no computador do usuário – CreateCookie.asp.

2 <HTML>
3 <HEAD>
4 </HEAD>
5 <BODY>
6 <p>ESTA PÁGINA CRIA UM COOKIE CHAMADO TESTE_COOKIE</p>
7 <%
8 Response.Cookies(“TESTE_COOKIE”)(“Nome”)= “Júlio Battisti”
9 Response.Cookies(“TESTE_COOKIE”)(“Cidade”)= “Boqueirão do Leão”
10 Response.Cookies(“TESTE_COOKIE”)(“Data”)= Date()
11 %>
12 </BODY>
13 </HTML>
A página da Listagem 4.10 cria um Cookie chamado TESTE_COOKIE. Dentro deste Cookie
são gravados três campos ou chaves, conforme indicado na Tabela 4.2.
199
Tabela 4.2 Valores gravados no Cookie TESTE_COOKIE.
Campo/Chave Valor
Nome Júlio Battisti
Cidade Boqueirão do Leão
Data 3/7/1999
Na Figura 4.15, temos o resultado do acesso à página da Listagem 4.10.
Figura 4.15: Criando um Cookie no computador do usuário.
Observe que o endereço desta página, no nosso exemplo é: http://servidor/Capitulo4/

CreateCookie.asp. Conforme descrevemos anteriormente, o Cookie é associado com o domínio
no qual reside a página. No nosso exemplo, todas as páginas que estiverem em http://servidor
poderão acessar informações deste Cookie.
Para acessar as informações do Cookie, podemos utilizar a coleção Cookies do objeto Request,
conforme indicado na Listagem 4.11.
Listagem 4.11 – Acessando os valores gravados no Cookie TESTE_COOKIE – getCookie.asp.

2 <HTML>
3 <HEAD>
4 </HEAD>
200
5 <BODY>
6 <B><FONT COLOR=BLUE> Seja bem vindo:
7 <%Response.Write Request.Cookies (“TESTE_COOKIE”)(“Nome”)& “<br>”%>
8 </FONT></B>
9 <%
10 Response.Write “Valores presentes em Cookies” & “<br>”
11 Response.Write Request.Cookies (“TESTE_COOKIE”)(“Nome”)& “<br>”
12 Response.Write Request.Cookies (“TESTE_COOKIE”)(“Cidade”)& “<br>”
13 Response.Write Request.Cookies (“TESTE_COOKIE”)(“Data”)& “<br>”
14 %>
15 <P> </P>
16 </BODY>
17 </HTML>
Observe que a sintaxe para acessar os valores da coleção Cookie é a seguinte:

Request.Cookies(“Nome_do_Cookie”) (“Nome_da_chave”)
Por exemplo, a linha de código:

11 Response.Write Request.Cookies (“TESTE_COOKIE”)(“Nome”)& “<br>”
acessa o valor da chave nome, do Cookie TESTE_COOKIE. Este valor é retornado para o
navegador do cliente pelo método Write do objeto Response.
Figura 4.16: Acessando os valores, utilizando a coleção Cookies do objeto Request.
201
Também podemos utilizar a estrutura For Each...Next para percorrer todos os valores de um
determinado Cookie, exibindo o nome das chaves e o valor associado à cada chave, conforme
indicado na Listagem 4.12.
Listagem 4.12 – Utilizando a estrutura For Each...Next, para acessar as chaves do Cookie
TESTE_COOKIE – forCookie.asp.
2 <HTML>
3 <HEAD>
4 </HEAD>
5 <BODY>
6 <I><B><FONT COLOR=RED><P>Valores de Cookies:</P></FONT></B></I>

7 <%
8 For Each Chave in Request.Cookies(“TESTE_COOKIE”)
9 Response.Write Chave & “: ”
10 Response.Write Request.Cookies(“TESTE_COOKIE”)(Chave) & “<BR>”
11 Next
12 %>
13 </BODY>
14 </HTML>
Figura 4.17: Utilizando a estrutura For Each...Next para acessar todas as

chaves do Cookie TESTE_COOKIE.
202
A Coleção ClientCertificate do Objeto Request

Com a necessidade de serem efetuadas operações seguras através da Internet, foi criada a
tecnologia de Certificados Digitais. Um Certificado funciona como uma espécie de carteira
de identidade do usuário ou do site que está sendo acessado, e pode conter diversas
informações, tais como nome, e-mail, endereço, telefone, etc.
Quando o usuário acessa uma determinada página, o navegador envia informações sobre seu
Certificado Digital, caso possua um. Para acessar as informações sobre o Certificado Digital
do Cliente, podemos utilizar a coleção ClientCertificate do objeto Request.
A sintaxe para utilizarmos a coleção ClientCertificate é a seguinte:

Request.ClientCertificate(Chave[Subchave])
Onde temos:
➥ Chave: É o nome do campo do certificado a ser acessado. Por exemplo, o campo
ValidForm retorna a data a partir da qual o certificado é válido; o campo ValidUntil,
determina a data de expiração do Certificado; e assim por diante. A código da linha
abaixo irá exibir a data de expiração do Certificado do cliente:
Response.Write “Seu Certificado expira em: ”
Response.Write Request.ClientCertificate(“ValidUntil”)
Propriedade do Objeto Request

O objeto Request apresenta uma única propriedade: TotalBytes. Esta propriedade informa o
número total de bytes enviados pelo navegador do cliente. Esta informação está ligada a
utilização do método post, para enviar as informações digitadas em um formulário. A sintaxe
é bastante simples, conforme indicado no exemplo seguinte.
total_bytes = Request.TotalBytes
Na Listagem 4.13 temos um exemplo da utilização da propriedade TotalBytes. Este exemplo

é uma pequena modificação do exemplo da Listagem 4.4, onde incluímos código para informar
quantos bytes foram enviados pela requisição do usuário (linhas 7 até 9).
Listagem 4.13 – Utilizando a propriedade TotalBytes do objeto Request – TotalBytes.asp.

2 <HTML>
3 <HEAD>
4 </HEAD>
5 <BODY>
6 <B><P>A sua requisição enviou o seguinte quantitativo de bytes para o servidor:</B></P>
203
7 <%
8 Response.Write Request.TotalBytes
9 %>
11 <%
12 For Each Item in Request.Form %>
13 <P>
14 <%=Item%>
15 =
16 <%=Request.Form(Item)%>
17 </P>
18 <% Next %>
20 </BODY>
21 </HTML>
O código da linha 8 informa quantos bytes foram enviados pelo navegador do cliente.
Método do Objeto Request

O objeto Request apresenta um único método: BinaryRead(quantidade_de_bytes). Este método
é utilizado para capturar um determinado número de bytes, do total de bytes que foram
enviados pela requisição do cliente, através do método post. O número de bytes a ser capturado
é definido pelo parâmetro “quantidade_de_bytes”. Não podemos utilizar este método na mesma
página ASP em que utilizamos Request.Form, ou utilizamos a coleção Request.Form, ou o
método BinaryRead. A sintaxe para utilização deste método é a seguinte:
tantos_bytes = Request.BinaryRead(tantos_bytes).
O exemplo abaixo coloca os 100 primeiros bytes enviados pelo cliente, na variável 100_bytes:
100_bytes = Request.BinaryRead(100)
Na Listagem 4.14 temos um exemplo onde tentamos utilizar a propriedade BinaryRead e a

coleção Request.Form, na mesma página.
Listagem 4.14 – Não podemos utilizar Request.BinaryRead e Request.Form na mesma

página – BinaryRead.asp.
2 <HTML>
3 <HEAD>
4 </HEAD>
204
5 <BODY>
6 <P>Não podemos utilizar Request.BinaryRead e</P>

7 <P>Request.Form na mesma página!</P>
8 <%
9 Dim vinte_bytes
10 vinte_bytes=Request.BinaryRead(20)
11 ‘ Esta linha irá gerar um erro.
12 Nome=Request.Form(“Nome”)
13 %>
14 </BODY>
15 </HTML>
Ao tentarmos acessar esta página, receberemos a mensagem de erro indicada na Figura 4.18.
Figura 4.18: Mensagem de erro.
Com isso, encerramos o estudo do objeto Request. Vimos todos as coleções, propriedades e
métodos do objeto Request, lembrando que o mesmo não possui nenhum evento. Com a
utilização do objeto Request, podemos ter acesso a diversas informações enviadas pelo cliente,
como por exemplo, informações enviadas através do preenchimento de um formulário.
205
No próximo item passaremos ao estudo do objeto Response. Os demais objetos do Modelo de

Objetos do ASP 3.0 serão estudados em outros capítulos deste livro.
O Objeto Response
Utilizamos o objeto Response para retornar o resultado do processamento de uma página ASP,
para o navegador do cliente. Conforme descrito anteriormente, o resultado retornado é código
HTML puro. Podemos utilizar o objeto Response para montar uma página de retorno, por
exemplo, com os resultados de uma pesquisa em um banco de dados. Nos exemplos do final
deste capítulo, teremos uma introdução ao acesso à bancos de dados, através de páginas ASP.
Também podemos utilizar o objeto Response para gravar Cookies no computador do cliente.
A partir de agora passaremos a estudar os principais métodos, coleções e propriedades do

objeto Response. Analisaremos os diversos aspectos do objeto através da utilização de alguns
exemplos práticos.
Coleção do Objeto Response

O objeto Response possui uma única coleção: Cookies. Esta coleção é utilizada para gravar
informações no equipamento do cliente. Estas informações são conhecidas como Cookies.
Existem diversas aplicações práticas para os Cookies. Por exemplo, quando estamos fazendo
compras em um site de Comércio Eletrônico, vamos escolhendo os itens a serem comprados.
Quando selecionamos um determinado item, adicionamos o mesmo à lista de compras. Ao
sairmos da página da lista de compras para selecionarmos mais itens, precisamos guardar a
informação sobre os itens já selecionados, caso contrário esta informação será perdida e
somente seria possível adquirir um item por vez. Muitos bancos de dados gravam a informação
da lista de compras em um banco de dados no servidor e as informações sobre a identificação
do usuário em um Cookie, na máquina do usuário. Com isso, quando o usuário volta à lista
de compras, é identificado através da leitura das informações contidas no Cookie, as quais
são utilizadas para pesquisar o banco de dados e exibir sua lista de compras. Outra abordagem
seria gravar os itens da compra em um Cookie, e enviar estas informações para o servidor,
somente quando o usuário finalizar a compra. As possibilidades são variadas, depende da
necessidade de cada aplicação.
Outro detalhe importante que devemos conhecer é quando o navegador envia para o servidor,
um Cookie gravado no cliente. Cada Cookie está associado com um determinado domínio.
Por exemplo, a primeira vez que você acessa o site http://www.abc.com, vamos supor que seja
gravado um Cookie no seu computador. Toda vez que você acessar uma página no domínio
www.abc.com, as informações contidas neste Cookie serão enviadas para o site, mesmo que
a página que esteja sendo acessada não utilize estas informações. Quando você acessa, por
206
exemplo, a página: http://www.abc.com/cadastro/index.asp, as informações contidas no Cookie

associado ao domínio www.abc.com serão enviadas para o servidor, mesmo que a página
index.asp não utilize estas informações. Podemos ter mais do que um Cookie associado com
um determinado domínio. Neste caso, todos os Cookies associados com o domínio serão
enviados quando uma página deste domínio for acessada.
A página que cria o Cookie também pode determinar a qual domínio o mesmo está relacionado,
podendo inclusive precisar que o Cookie somente esteja relacionado com uma determinada
área do site. Por exemplo, posso determinar que o Cookie somente seja enviado para o servidor
quando forem acessadas páginas da seguinte área: http://www.abc.com/cadastro. Também
podemos definir uma data de expiração para o Cookie. Vamos estudar estas possibilidades
através de exemplos práticos.
Na Listagem 4.15, temos um exemplo de criação de um Cookie chamado Cliente.
Listagem 4.15 – Criando um Cookie associado ao domínio http://servidor –

CriandoCookie.asp.
2 <HTML>
3 <HEAD>
4 </HEAD>
5 <BODY>
6 <B>
7 <P>Esta página cria um Cookie associado ao domínio
8 http://servidor. Toda vez que uma página do domínio
9 http://servidor for acessada, as informações contidas
10 neste Cookie serão enviadas.
11 </B>
12 </P>
13 <%
14 ‘ Cria um Cookie chamado Cliente
15 Response.Cookies(“Cliente”)(“Nome”)= “Júlio Battisti”

16 Response.Cookies(“Cliente”)(“Endereco”)=“Boqueirão do Leão”
17 Response.Cookies(“Cliente”)(“Email”)=“juliobattisti@hotmail.com”
18 Response.Cookies(“Cliente”)(“Cartao”)=“ABC”
19 Response.Cookies(“Cliente”)(“Preferencial”)=“Sim”
20 %>
21 <P><FONT COLOR=BLUE>
207
22 O Cookie Cliente foi criado com sucesso. <br>

23 Foram adicionadas as seguintes informações:
24 </FONT></P>
25 <%
26 ‘ Exibe os valores gravados no Cookie Cliente.
27 For Each Chave in Request.Cookies(“Cliente”)
29 Response.Write Request.Cookies(“Cliente”)(Chave) & “<BR>”
30 Next
31 %>
32 </BODY>
33 </HTML>
Figura 4.19: O Cookie Cliente foi gravado com sucesso.
Conforme descrito anteriormente, podemos definir o domínio, ou uma área do site, ao qual o
Cookie está associado, bem como a data para expiração. Para isso utilizamos os comandos
abaixo indicados.
Para definir o domínio ao qual o Cookie está associado:

Response.Cookies(“Nome_do_Cookie”).domain=“URL do domínio”
EX: Response.Cookies(“Cliente”).domain=“http://servidor”
208
Para associar o Cookie apenas com uma determinada área do site:

Response.Cookies(“Nome_do_Cookie”).path=“caminho virtual”
EX: Response.Cookies(“Cliente”).path=“/cadastro”
Assim, estou dizendo que o Cookie somente deve ser enviado quando o usuário acessar páginas
que estão dentro do seguinte endereço: http://servidor/cadastro, como por exemplo: http://
servidor/cadastro/index.asp ou http://servidor/cadastro/carros.asp. Se você quiser que o Cookie
seja enviado para qualquer página do site, utilize o seguinte comando:
Response.Cookies(“Cliente”).path=“/”
Para definir uma data de expiração para o Cookie:

Response.Cookie(“Nome_do_Cookie”).expires=#data#
EX: Response.Cookie(“Cliente”).expires=#31/12/2000#
Neste exemplo, estou definindo a data de expiração do Cookie para 31 de Dezembro de 2000.
Se não for definida uma data de expiração para o Cookie, o mesmo será eliminado quando o
usuário fechar o navegador.
IMPORTANTE
Em versões anteriores do ASP, o código para criar Cookies deveria ser colocado no cabeçalho
do documento, antes da tag <BODY>. Isso era necessário, porque o Cookie deveria ser criado,
antes que qualquer conteúdo fosse enviado para o navegador do cliente. Isso porque, nas
versões anteriores do ASP, o conteúdo ia sendo enviado para o cliente à medida em que a
página era processada. No ASP 3.0, o conteúdo somente é enviado quando toda a página foi
processada com sucesso, ou quando for utilizado o comando Response.Flush. Este
comportamento pode ser controlado através da habilitação ou não de “buffer” para a página,
conforme veremos mais adiante neste capítulo.
Na Listagem 4.16, temos um exemplo definindo algumas características do Cookie Cliente2.
Listagem 4.16 – Criando um Cookie Cliente2 – CriandoCliente2.asp.

2 <HTML>
3 <HEAD>
4 </HEAD>
5 <BODY>
6 <B><P>Esta página cria um Cookie associado ao caminho
7 http://servidor/Capitulo4.
8 Toda vez que uma página do caminho
9 http://servidor/Capitulo4, ou um dos
209
10 seus subdiretórios, for acessada, as informações

11 contidas neste Cookie serão enviadas.
12 </B></P>
13 <%
14 ‘ Cria um Coockie chamado Cliente2
15 ‘ E define algumas propriedades adicionais
16 Response.Cookies(“Cliente2”).domain=“http://servidor”
17 Response.Cookies(“Cliente2”).path=“/Capitulo4"
18 Response.Cookies(“Cliente2”).expires=#31/12/2000#
19 Response.Cookies(“Cliente2”)(“Nome”)= “Júlio Battisti”
20 Response.Cookies(“Cliente2”)(“Endereco”)=“Boqueirão do Leão”
21 Response.Cookies(“Cliente2”)(“Email”)=“juliobattisti@hotmail.com”
22 Response.Cookies(“Cliente2”)(“Cartao”)=“ABC”
23 Response.Cookies(“Cliente2”)(“Preferencial”)=“Sim”
24 %>
25 <P><FONT COLOR=BLUE>
26 O Cookie Cliente2 foi criado com sucesso. <br>
27 Foram adicionadas as seguintes informações:
28 </FONT></P>
29 <%
30 For Each Chave in Request.Cookies(“Cliente”)
32 Response.Write Request.Cookies(“Cliente”)(Chave) & “<BR>”
33 Next
34 %>
35 </BODY>
36 </HTML>
O Cookie Cliente2 é um Cookie com múltiplos valores, isto é, temos armazenado diversos
campos de informação, tais como: Nome, Endereço, Email, etc. Também podemos ter os
chamados Cookies simples, os quais contém um único valor. O seguinte código cria um
Cookie simples:
Response.Cookies(“Cliente”)=“Júlio Battisti”
Nós podemos utilizar o atributo HasKeys, para determinar se um Cookie possui um único
valor ou possui múltiplos valores. Considere a seguinte linha de código:
Response.Write Response.Cookies(“Cliente2”).HasKeys
210
Figura 4.20: O Cookie Cliente2 foi gravado com sucesso.
Caso o Cookie Cliente2 possua múltiplos valores, esta linha de código retorna Verdadeiro,
caso contrário retorna Falso.
Agora passaremos ao estudo das propriedades do objeto Response.
Propriedades do Objeto Response

O objeto Response possui diversas propriedades, as quais são utilizadas para definir algumas
características da comunicação entre o servidor Web e o navegador do cliente. A correta
utilização destas propriedades permite um controle refinado sobre a maneira como as
informações são enviadas do servidor Web para o navegador do cliente.
A Propriedade Buffer do Objeto Response

Esta propriedade é do tipo Boolean, isto é, pode ser definida como Verdadeiro (True) ou Falso
(False). Os comportamentos desta propriedade, de acordo com o seu valor, são os seguintes:
➥ Verdadeiro (True): Quando esta propriedade for definida como Verdadeiro, o servidor
Web somente enviará conteúdo para o navegador do cliente depois que todo o código
ASP da página for executado; isto é, à medida que a página for sendo processada, o
211
resultado do processamento é mantido em um Buffer do servidor Web. Após todo o

código da página ter sido processado, o conteúdo do Buffer é enviado para o navegador
do cliente. Este é o comportamento padrão no ASP 3.0. Também é possível enviar o
conteúdo já processado para o navegador do cliente, a qualquer momento, utilizando-
se os métodos Response.Flush ou Response.End. Falaremos mais sobre estes dois
métodos no próximo item.
➥ Falso (False): Quando a propriedade Buffer for definida como Falso, à medida em que
a página for sendo processada, o conteúdo será enviado para o navegador do cliente;
isto é, o conteúdo processado não fica armazenado em um Buffer no servidor Web.
Esta propriedade deve ser definida antes que qualquer conteúdo tenha sido enviado para o
navegador do cliente. O código da Listagem 4.17 mostra onde é o local mais indicado para
definirmos esta propriedade.
Listagem 4.17 – Definindo a propriedade Buffer do objeto Response.

2 <% Response.Buffer=False%>
3 <HTML>
4 <HEAD>
5 </HEAD>
6 <BODY>
7 <P>Documento com Buffer desabilitado</P>
8 </BODY>
9 </HTML>
Observe que devemos utilizar as expressões em inglês: True, para Verdadeiro, e False, para
Falso. Também não devemos esquecer que, por padrão, no ASP 3.0, esta propriedade é definida
como True. Em situações onde devemos efetuar algum processamento, tais como cálculos ou
pesquisas em banco de dados, antes de enviar a página para o navegador do cliente é
interessante mantermos a propriedade Buffer em seu valor padrão True. Em situações onde
não sejam necessários processamentos deste tipo, podemos desabilitar o Buffer definindo
esta propriedade como False.
A Propriedade CacheControl do Objeto Response

Hoje em dia é muito comum a utilização de servidores Proxy para acesso a Internet. As
diversas máquinas da Rede Local acessam a Internet através deste servidor. Com isso, é possível
aumentar a segurança de mecanismos do próprio servidor. Uma das funções que o servidor
Proxy pode executar é o Cache de páginas. Quando alguém acessa uma determinada página,
uma cópia da mesma é gravada no Cache do servidor Proxy. O servidor armazena páginas
HTML em Cache para que solicitações repetidas da mesma página possam ser retornadas
212
com rapidez e eficiência aos navegadores. Na próxima vez que alguém for acessar esta página,
e a mesma estiver no Cache, não existe necessidade de carregar novamente a página da Internet.
A cópia que está no Cache é enviada para o navegador do cliente. O uso de Cache no servidor
Proxy agiliza o acesso, principalmente, às páginas mais utilizadas.
Por padrão, o ASP instrui servidores Proxy a não armazenarem a própria página ASP em cache
(embora imagens, mapas de imagens, miniaplicativos e outros itens aos quais a página faz
referência sejam armazenados em Cache). Você pode permitir o armazenamento de determinadas
páginas em Cache usando a propriedade Response.CacheControl. Com o uso da propriedade
CacheControl podemos definir se uma página ASP deve ou não ser mantida no Cache do servidor
Proxy. Este controle nos é oferecido devido à natureza dinâmica das páginas ASP, as quais
mudam constantemente. Caso uma página tenha sido colocada no Cache do servidor Proxy, o
usuário corre o risco de estar recebendo uma versão desatualizada da página.
Listagem 4.18 – Definindo a propriedade CacheControl do objeto Response.

2 <% Response.CacheControl=“Public”%>
3 <HTML>
4 <HEAD>
5 </HEAD>
6 <BODY>
7 <P>Definindo a propriedade CacheControl do objeto Response.</P>
8 </BODY>
9 </HTML>
Esta propriedade pode assumir os seguintes valores:

➥ Public: Permite que a página ASP seja armazenada no Cache do servidor Proxy.
➥ Private: Faz com que a página ASP não seja armazenada no Cache do servidor Proxy.
A Propriedade CharSet do Objeto Response

Quando o servidor envia informações para o cliente, antes de mandar o conteúdo da página
propriamente dito, é enviado um cabeçalho (Header) de informações. Neste cabeçalho existem
diversas definições importantes, tais como o tipo de conteúdo que está sendo enviado. Uma
das informações contidas neste cabeçalho é qual o conjunto de caracteres a ser utilizado para
exibir o conteúdo enviado. Para ter uma noção exata do que significa um conjunto de caracteres
213
basta observar as diferenças entre uma página desenvolvida para o idioma Português e outra
para ser exibida no idioma Chinês ou Japonês.
Listagem 4.19 – Definindo a propriedade Charset do objeto Response.

2 <% Response.Charset(“ISO-LATIN-1”)”%>
3 <HTML>
4 <HEAD>
5 </HEAD>
6 <BODY>
7 <P>Definindo a propriedade Charset do cabeçalho do documento.</P>
8 </BODY>
9 </HTML>
IMPORTANTE
Todas as propriedades que alteram alguma característica do cabeçalho do documento devem
ser definidas antes que qualquer conteúdo visível seja enviado para o navegador do cliente.
Por isso, o local mais indicado para definir estas propriedades é antes da abertura da tag
<BODY>, que é onde realmente começa o conteúdo que comporá a página a ser enviada.
A Propriedade ContentType do Objeto Response

Esta propriedade define o tipo de conteúdo que será enviado para o cliente. Os tipos de
conteúdo são definidos por um padrão conhecido como MIME-type. A propriedade
ContentType informa ao navegador qual o tipo de conteúdo que o mesmo deverá receber.
Apenas para exemplificar, vamos citar alguns dos tipos mais conhecidos:
➥ “text/html”: Define o arquivo como sendo do tipo texto, com conteúdo de código HTML.
É o tipo padrão, isto é, se não for definido outro tipo, este será o utilizado.
➥ “image/gif”: O navegador espera receber um arquivo de imagem do tipo .gif.
➥ “image/jpg”: O navegador espera receber um arquivo de imagem do tipo .jpg.
214
Listagem 4.20 – Definindo a propriedade ContentType do objeto Response.

2 <% Response.ContentType = “text/html” %>
3 <HTML>
4 <HEAD>
5 </HEAD>
6 <BODY>
7 <P>Definindo a propriedade ContentType para o cabeçalho do documento.</P>
8 </BODY>
9 </HTML>
A Propriedade Expires do Objeto Response

A propriedade Expires especifica o tempo decorrido antes que uma página armazenada no
Cache de um navegador perca a validade. Se o usuário retornar para a mesma página antes
dela expirar, a versão armazenada em Cache será exibida.
A sintaxe para esta propriedade é a seguinte:

Response.Expires=Número
onde Número é especificado em minutos.
Quando a página .asp chama Response.Expires, o IIS cria um cabeçalho HTTP indicando a
hora no servidor. Se a hora do sistema do cliente é anterior à hora do sistema do servidor
(caso o cliente ou servidor não tenham uma configuração de hora precisa ou haja diferenças
de fuso horário) a configuração do parâmetro como 0 não terá o efeito de expirar a página
imediatamente. Você pode usar a propriedade Response.ExpiresAbsolute (veja próximo item)
para obter a expiração imediata de uma página. Além disso, pode usar um número negativo
para a propriedade Expires. Por exemplo:
<% Response.Expires = -1 %>
expirará a resposta imediatamente.
NOTA
Se existirem várias chamadas para Response.Expires em uma única página, o servidor usará
o período de tempo mais curto.
215
Listagem 4.21 – Definindo a propriedade Expires do objeto Response.

2 <% Response.Expires = 1440 %>
3 <HTML>
4 <HEAD>
5 </HEAD>
6 <BODY>
7 <P>Definindo a propriedade Expires para o cabeçalho do documento.</P>
8 </BODY>
9 </HTML>
Neste exemplo estou definindo em um dia (1.440 minutos) o tempo de expiração para a
página. Para forçar uma nova requisição para o servidor Web, a cada solicitação da página,
podemos utilizar o seguinte código:
<% Response.Expires = 0 %>
Com isso a página expira imediatamente. Na próxima requisição do cliente, a página será
novamente carregada a partir do servidor. Isto garante que sempre a última versão da página
será enviada do servidor Web para o navegador do cliente.
A Propriedade ExpiresAbsolute do Objeto Response

A propriedade ExpiresAbsolute especifica a data e a hora na qual uma página armazenada
em Cache em um navegador expira. Se o usuário retornar para a mesma página antes dessa
data e hora, a versão em Cache será exibida. Se uma hora não for especificada, a página
expirará à meia-noite desse dia. Se uma data não for especificada, a página expirará na hora
determinada no dia que o script for executado.

Response.ExpiresAbsolute =#[data] [hora]#
NOTA
Se essa propriedade for definida mais de uma vez em uma página, a data ou hora de expiração
mais próxima à atual será usada. Se tentarmos definir a data de expiração como uma data
que já passou, a data e hora atuais serão utilizadas como de expiração.
216
Listagem 4.22 – Definindo a propriedade ExpiresAbsolute do objeto Response.

2 <% Response.ExpiresAbsolute=#May 29,2002 18:30:35# %>
3 <HTML>
4 <HEAD>
5 </HEAD>
6 <BODY>
7 <P>Definindo a propriedade ExpiresAbsolute para o cabeçalho do documento.</P>
8 </BODY>
9 </HTML>
NOTA
Observe que a data e a hora devem estar entre os caracteres #.
A Propriedade IsClientConnected do Objeto Response

A propriedade IsClientConnected é uma propriedade somente de leitura que indica se o
cliente foi desconectado do servidor.

Response.IsClientConnected ( )
IMPORTANTE
Essa propriedade permite que você tenha um maior controle sobre as circunstâncias nas quais
o cliente pode ter se desconectado do servidor. Por exemplo, se um longo período de tempo tiver
decorrido entre o momento de uma solicitação do cliente e o momento em que o servidor
respondeu, talvez seja benéfico garantir que o cliente ainda esteja conectado antes de continuar
a processar o script.
Esta propriedade retorna True (Verdadeiro) ou False (Falso). Se o cliente continua conectado
a propriedade retorna True, caso contrário retorna False.
O código da Listagem 4.23 mostra um exemplo de utilização desta propriedade.
Listagem 4.23 – Utilizando a propriedade IsClientConnected do objeto Response.

2 <HTML>
3 <HEAD>
4 </HEAD>
217
5 <BODY>
7 <P>Exemplo de utilização da propriedade IsClientConnected.</P>
8 <% If Response.IsClientConnected( ) Then

9 Response.Write “O Cliente continua conectado.”
10 Else
11 Response.Write “O Cliente foi desconectado.”
12 End If
13 %>
14 </BODY>
15 </HTML>
A Propriedade PICS do Objeto Response

Um rótulo PICS – Platform for Internet Content Selection (Plataforma para Seleção de Conteúdo
da Internet) é um rótulo que define uma página em termos do seu conteúdo, tais como:
➥ Infantil
➥ Sexo
➥ Violência
Estes rótulos podem ser utilizados para classificar a informação da Internet. Os principais
navegadores do mercado permitem que seja ativado um Supervisor de Conteúdo com a
definição de uma senha. Para alterar as definições do Supervisor de Conteúdo, somente com
o conhecimento da senha. Pais podem usar este Supervisor de Conteúdo para evitar que os
filhos tenham acesso a sites com conteúdo de sexo explícito ou violência.

Response.PICS(PICSLabel)
IMPORTANTE
A propriedade PICS insere qualquer seqüência de caracteres no cabeçalho, independente dela
representar ou não um rótulo PICS válido.
Exemplo:
<% Response.PICS(“(PICS-1.1 <http://www.rsac.org/ratingv01.html> labels on ” &
chr(34) & “1997.01.05T08:15-0500” & chr(34) & “ until” & chr(34) & “1999.12.31T23:59-
0000” & chr(34) & “ ratings (v 0 s 0 l 0 n 0))”) %>
218
NOTA
Para maiores informações sobre a Classificação de Conteúdo consulte os sites www.rsac.org ou
os www.w3.org, ou o livro “Internet Explorer 5.0 – Resource Kit”.
A informação do cabeçalho PICS é enviada para o navegador do cliente. Com base na

classificação da página e das configurações do navegador, o conteúdo da página pode não ser
exibido, como no exemplo de pais que bloqueiam o acesso a sites de sexo.
A Propriedade Status do Objeto Response

A propriedade Status define a mensagem que será enviada para o cliente, dentro do cabeçalho
HTTP da resposta. Esta mensagem pode ser utilizada para indicar um erro ou o processamento
com sucesso da requisição do usuário. Os valores de Status são definidos na especificação HTTP.

Response.Status = DescriçãoDoStatus
Exemplo:
<% Response.Status = “410 Unauthorized” %>
ou
<% Response.Status = “404 Not Found” %>
Abaixo temos uma descrição das principais mensagens de status de erro:

➥ 400 Bad Request
➥ 410 Unauthorized – Login Failed
➥ 404 Not Found
➥ 414 Request – URL Too Long
➥ 500 Internal Server Error
➥ 501 Not Implemented
Com isso encerramos o estudo das propriedades do objeto Response. Agora passaremos ao
estudo dos métodos do objeto Response.
Métodos do Objeto Response

O objeto Response possui diversos métodos, os quais permitem o controle sobre o conteúdo
que será enviado para o cliente. Um método, conforme já descrito anteriormente, realiza uma
219
determinada ação. Por exemplo, já utilizamos inúmeras vezes o método Write do objeto Response.
Este método é utilizado para enviar conteúdo do servidor Web para o navegador do cliente.
O Método AddHeader do Objeto Response

O método AddHeader adiciona um cabeçalho HTML com um valor especificado. Esse método
sempre adiciona um novo cabeçalho HTTP à resposta. Ele não substituirá um já existente de
mesmo nome. Uma vez que um cabeçalho tenha sido adicionado, ele não poderá ser removido.
NOTA
Este método é pouco utilizado, se outro método Response fornecer a funcionalidade necessária,
é recomendável que você o utilize.
Como o protocolo HTTP requer que os cabeçalhos sejam enviados antes do conteúdo, em
geral, você deve modificar todos os cabeçalhos enviados antes que seu script ASP gere alguma
saída. No IIS 4.0, isso significava que era necessário chamar AddHeader no script antes que
alguma saída (como aquela gerada pelo código HTML ou pelo método Write) fosse enviada ao
cliente, normalmente antes da tag <BODY>. No IIS 5.0, com ASP 3.0, o Buffer é ativado por
padrão, conforme descrito anteriormente. Portanto, você pode chamar o método AddHeader
em qualquer ponto do script, desde que o Buffer não tenha sido desativado
(Response.Buffer=False) e que ele preceda todas as chamadas para Flush.
O código da Listagem 4.24 mostra um exemplo de utilização deste método.
Listagem 4.24 – Utilizando o método AddHeader do objeto Response.

2 <% Response.AddHeader “AVISO IMPORTANTE” , “Servidor Indisponível” %>
3 <HTML>
4 <HEAD>
5 </HEAD>
6 <BODY>
7 <P>Exemplo de utilização do método AddHeader.</P>
8 </BODY>
9 </HTML>
O Método AppendToLog do Objeto Response

Todo servidor Web mantém um arquivo de Log. Neste arquivo são gravadas diversas
informações, tais como o número IP da máquina do cliente, a página que o mesmo está
acessando, a hora de acesso, etc. Estas informações podem ser utilizadas para, por exemplo,
220
gerar estatísticas de acesso. No IIS 5.0 podemos configurar quais tipos de informação devem
ser gravadas no Log. Além disso, temos o método AppendToLog, o qual adiciona uma seqüência
de caracteres ao final da entrada de Log do servidor Web. Você pode chamá-lo várias vezes
em uma seção do script. Cada vez que o método é chamado, ele anexa a seqüência de caracteres
especificada à entrada existente.
Este método utiliza a seguinte sintaxe:

Response.AppendToLog seqüência de caracteres
O código da Listagem 4.25 mostra um exemplo de utilização deste método.
Listagem 4.25 – Utilizando o método AppendToLog do objeto Response.

2 <HTML>
3 <HEAD>
4 </HEAD>
5 <BODY>
6 <P>Exemplo de utilização do método AppendToLog.</P>
7 <% Response.AppendToLog “Início da página.” %>

8 <P>Conteúdo da Página.</P>
9 <% Response.AppendToLog “Final da página” %>
10 </BODY>
11 </HTML>
Este exemplo adiciona os textos “Início da página” e “Final da página” ao Log do IIS.
O Método BinaryWrite do Objeto Response

O método BinaryWrite grava as informações especificadas na saída HTTP atual sem nenhum
caractere de conversão. Esse método é útil para gravar informações que não são seqüências
de caracteres como dados binários requeridos por um aplicativo personalizado, ou quando é
preciso enviar qualquer tipo de dado que não seja do tipo text/html.
Este método apresenta a seguinte sintaxe:

Response.BinaryWrite dados

<% Response.BinaryWrite dados_enviar %>
221
Onde dados_enviar pode ser um objeto que contém, por exemplo, um trecho de vídeo no
formato .avi.
O Método Clear do Objeto Response

O método Clear limpa todas as saídas HTML armazenadas no Buffer. No entanto, este método
limpa apenas o conteúdo do corpo da resposta; ele não limpa os cabeçalhos.
Utilizamos a seguinte sintaxe para o método Clear:

Response.Clear
ou
Response.Clear( )
IMPORTANTE
Esse método causará um erro de tempo de execução se Response.Buffer não tiver sido definido
para True, isto é, se não houver conteúdo no Buffer, a chamada ao método Response.Clear
causará um erro.
O código da Listagem 4.26 mostra um exemplo de utilização deste método quando o Buffer
está desabilitado, isto irá gerar a mensagem de erro indicada na Figura 4.21. Este erro é causado
por termos desabilitado o Buffer (Response.Buffer=False) e mesmo assim tentar utilizar o
método Response.Clear.
Listagem 4.26 – Utilizando o método Response.Clear – ErroClear.asp.

2 <% Response.Buffer = False %>
3 <HTML>
4 <HEAD>
5 </HEAD>
6 <BODY>
7 <P>A próxima linha irá gerar um erro.</P>
8 <% Response.Clear %>
9 </BODY>
10 </HTML>
222
Figura 4.21: Erro causado pelo uso do método Response.Clear.
O método End do Objeto Response

O método End faz com que o servidor Web páre o processamento do script e retorne o resultado
atual. O conteúdo restante do arquivo não será processado.

Response.End
ou
Response.End( )
Comentários
Se Response.Buffer tiver sido definido para True (o que é o padrão no ASP 3.0), a chamada de
Response.End liberará o Buffer. Se você não deseja que a saída retorne para o usuário, deve
chamar primeiro Response.Clear, conforme indicado no exemplo abaixo:
<%
Response.Clear
Response.End
%>
223
O Método Flush do Objeto Response

O método Flush envia, imediatamente, a saída armazenada no Buffer do servidor. Esse método
causará um erro de tempo de execução se Response.Buffer tiver sido definido para False.

Response.Flush
ou
Response.Flush( )
O código da Listagem 4.27 mostra um exemplo de utilização deste método quando o Buffer
está desabilitado, isto irá gerar a mensagem de erro indicada na Figura 4.22. Este erro é causado
por termos desabilitado o Buffer (Response.Buffer=False) e depois de desabilitá-lo tentamos
utilizar o método Response.Flush.
Figura 4.22: Erro causado pelo uso do método Response.Flush.
Listagem 4.27 – Utilizando o método Response.Flush – ErroFlush.asp.

2 <% Response.Buffer = False %>
3 <HTML>
4 <HEAD>
5 </HEAD>
224
6 <BODY>
7 <P>A próxima linha irá gerar um erro.</P>
8 <% Response.Flush( ) %>
9 </BODY>
10 </HTML>
O Método Redirect do Objeto Response

O método Redirect faz com que o navegador tente acessar a página passada como parâmetro
para o método. Por exemplo, podemos utilizar o método Redirect para carregar uma página
personalizada, dependendo das opções que o usuário preencheu em um determinado formulário.
A sintaxe para este método é a seguinte:

Response.Redirect URL
Como exemplo, vamos supor que o usuário preencheu um formulário onde existe um campo
chamado Destino. Este campo pode ter um dos seguintes valores:
➥ Brasil
➥ Canadá
➥ EUA
➥ Europa
➥ Outros
Com base no valor selecionado neste campo, você deseja enviar o usuário para uma página
personalizada para cada caso. Na listagem 4.28 temos um exemplo de código que soluciona o
problema proposto.
Listagem 4.28 – Utilizando o método Response.Redirect.

2 <HTML>
3 <HEAD>
4 </HEAD>
5 <BODY>
6 <P>Aguarde – Redirecionando...</P>
7 <%
8 Vai_para = Request.Form(“Destino”)
9 Select Case Vai_para
10 Case “Brasil”
225
11 Response.Redirect “http://www.abc.com/brasil”
12 Case “Canadá”
13 Response.Redirect “http://www.abc.com/canada”
14 Case “EUA”
15 Response.Redirect “http://www.abc.com/eua”
16 Case “Europa”
17 Response.Redirect “http://www.abc.com/europa”
18 Case “Outros”
19 Response.Redirect “http://www.abc.com/outros”
20 End Select
21 %>
22 </BODY>
23 </HTML>
O Método Write do Objeto Response

Já utilizamos o método Write inúmeras vezes. Este método é utilizado para enviar uma
seqüência de caracteres para a saída HTML, enviada para o navegador do cliente. Esta seqüên-
cia de caracteres pode ser texto comum, tags HTML, valor de variáveis calculadas pela página
ASP ou até mesmo valores de campos de dados em um banco de dados. Em resumo, podemos
dizer que o método Write é utilizado para montar a página HTML que retorna para o usuário.
A sintaxe para o método é bastante simples:

Response.Write Conteúdo
O seguinte exemplo envia texto para a saída HTML, que é enviada para o cliente:
Response.Write “Bem vindos à tecnologia de Páginas Dinâmicas.”
No próximo exemplo, além do texto, enviamos uma tag HTML de quebra de linha:
Response.Write “Utilização do método Write <BR>”
Assim, o seguinte conteúdo é enviado para o navegador do cliente:

Utilização do método Write <BR>
O texto “Utilização do método Write” é exibido e a tag <BR> é reconhecida como sendo uma
tag HTML que orienta o navegador a fazer uma quebra de linha.
Com certeza este é o método que mais utilizaremos ao longo deste livro.
Agora encerramos o estudo do objeto Response, do qual estudamos todos os métodos,

propriedades e a coleção Cookies. A partir de então, passaremos a analisar alguns exemplos
práticos de utilização do conteúdo visto até agora.
226
Alguns Exemplos Práticos de Aplicação

Neste item veremos alguns exemplos práticos de aplicação do conteúdo visto até o momento.
Serão propostos alguns problemas e, para resolvê-los, utilizaremos o conhecimento aprendido,
com a utilização dos objetos ASP já apresentados, além de elementos da linguagem VBScript.
Também precisaremos dos conhecimentos de HTML introduzidos no Capítulo 2.
Exemplo 1: Validação dos Dados de um Formulário

Descrição do problema: vamos supor que tenhamos um formulário para cadastro dos nossos
clientes em um banco de dados. Alguns campos deste formulário são de preenchimento
obrigatório, isto é, não podem ficar em branco ou conter valores nulos. Caso o usuário deixe
um ou mais destes campos sem preencher, devemos retornar o formulário para o cliente,
indicando qual ou quais campos de preenchimento obrigatório não foram preenchidos. Ao
voltar o formulário para o cliente, não podemos fazer com que ele tenha que preencher todos
os campos novamente, mas somente os que estiverem faltando. Portanto, o formulário voltará
para o cliente, mantendo os valores que ele já preencheu, apenas indicando quais campos
obrigatórios não foram preenchidos.
NOTA
Na prática os valores preenchidos no formulário deveriam ser armazenados em um banco de
dados como o Microsoft SQL Server 7.0 ou o Microsoft Access 2000. Como ainda não aprendemos
a trabalhar com banco de dados, vamos apenas validar os dados digitados. Caso o usuário
tenha digitado todos os dados corretamente, apenas informaremos que os dados foram digitados
com sucesso e exibiremos os valores. No próximo capítulo estaremos tratando sobre a conexão
de páginas ASP com bancos de dados.
Na Listagem 4.29 temos o formulário que o usuário deverá preencher. Neste formulário, são
de preenchimento obrigatório os seguintes campos:
➥ Nome
➥ Rua
➥ Cidade
➥ Bairro
➥ email
➥ CPF
227
Listagem 4.29 – Formulário para cadastro do cliente – exemplo-1.htm.

1 <HTML>
2 <HEAD>
3 <TITLE>Formulário para Cadastro de Clientes !!</TITLE>
4 </HEAD>
5 <BODY>
8 <FORM action=“exemplo-1.asp” method=“post”>
9 <P>Nome: <INPUT id=nome maxLength=50 name=nome>(*)</P>
10 <P>Rua: <INPUT id=rua maxLength=35 name=rua >(*)</P>
11 <P>Cidade: <INPUT id=cidade maxLength=30 name=cidade>(*)
12 Bairro: <INPUT id=Bairro maxLength=20 name=Bairro></P>
13 <P>e-mail: <INPUT id=email maxLength=50 name=email>(*)
14 Fone:<INPUT id=fone maxLength=15 name=fone></P>
15 <P>CPF: <INPUT id=cpf maxLength=11 name=cpf>(*)
16 <FONT size=2><STRONG>(Digite sem o ponto e sem o traço)
17 </STRONG></FONT></P>
21 <INPUT id=cartao name=cartao type=radio value=“Outros”>Outros
22 </P>
23 <P><INPUT id=enviar name=enviar type=submit value=Enviar>
25 <BR>
26 (*)->Campos de digitação obrigatória.<BR></P>
27 </FORM>
28 </BODY>
29 </HTML>
Ao visualizarmos este formulário no Internet Explorer, obtemos o resultado mostrado na Figura 4.23.
Observe, na linha 8, que o atributo action, da tag FORM é definido como exemplo-1.asp.
Agora precisamos criar a página exemplo-1.asp, a qual vai processar os dados digitados no
formulário quando o usuário clicar no botão Enviar. A página exemplo-1.asp deve verificar se
todos os campos obrigatórios foram digitados. Em caso afirmativo a página informará os
valores digitados pelo usuário, caso contrário, o formulário será enviado de volta, indicando
quais os campos obrigatórios que não foram preenchidos. Além disso ao enviar o formulário
de volta para o usuário, os valores digitados pelo usuário serão preservados, evitando que
seja preciso digitar todos os campos novamente.
228
Figura 4.23: O formulário para cadastro de clientes.
Existem diversas maneiras e algoritmos diferentes para solucionar este problema. Na Listagem
4.30 apresentamos uma solução para o problema proposto.
Listagem 4.30 – Fazendo a validação dos dados obrigatórios – exemplo-1.asp.

2 <HTML>
3 <HEAD>
4 </HEAD>
5 <BODY>
6 <%
7 ‘ Inicia a verificação para saber se todos
8 ‘ os campos obrigatórios foram preenchidos.
9 ‘ Atribui os campos obrigatórios à variáveis.
10 nome = Request.Form(“nome”)
11 rua = Request.Form(“rua”)
12 cidade = Request.Form(“cidade”)
229
13 email = Request.Form(“email”)
14 cpf = Request.Form(“CPF”)
15 ‘Verifica se os campos obrigatórios foram preenchidos.

16 ‘Qualquer dado obrigatório que não tenha sido preenchido,
17 ‘definirá a variável faltou_dado em Sim.
18 If (nome=“”)Then
19 mensagem_nome=“Preencha o campo Nome:”
20 faltou_dado=“Sim”
21 faltou_nome=“Sim”
22 End If
23 If (rua=“”)Then
24 mensagem_rua=“Preencha o campo Rua:”
26 faltou_rua=“Sim”
27 End If
28 If (cidade=“”)Then
29 mensagem_cidade=“Preencha o campo Cidade:”
31 faltou_cidade=“Sim”
32 End If
33 If (email=“”)Then
34 mensagem_email=“Preencha o campo email:”
36 faltou_email=“Sim”
37 End If
38 If (cpf=“”)Then
39 mensagem_cpf=“Preencha o campo CPF:”
41 faltou_cpf=“Sim”
42 End If
43 ‘Caso todos os campos obrigatórios tenham sido

44 ‘preenchidos, apenas informo os valores digitados.
45 If faltou_dado<>“Sim” Then
230
46 Response.Write “<P>Você digitou os seguintes dados !</P>”

47 Response.Write “<HR>”
48 For Each Dado in Request.Form %>

49 <P>
50 <% =Dado %>
51 :
52 <%=Request.Form(Dado)%>
53 </P>
54 <%Next
55 End If
56 ‘Caso algum dado obrigatório não tenha sido digitado

57 ‘Envia o formulário de volta para o cliente,
58 ‘preservando os valores que o mesmo já digitou.
59 ‘Observe que utilizamos Response.Write para ir
60 ‘recriando todo o formulário.
61 ‘Também observe que o formulário é enviado de volta
62 ‘na página exemplo-1.asp e que o atributo action
63 ‘da tag FORM é definido como exemplo-1.asp, ou seja
64 ‘a página exemplo-1.asp chama a si mesma após o
65 ‘usuário clicar no botão Enviar.
66 ‘Esta é uma técnica bastante interessante.
67 ‘Antes de enviar o formulário, informamos quais
68 ‘os campos obrigatório que não foram preenchidos.
69 If faltou_nome=“Sim” Then
70 Response.Write “O campo Nome deve ser preenchido. <BR>”
71 End If
72 If faltou_rua=“Sim” Then
73 Response.Write “O campo Rua deve ser preenchido. <BR>”
74 End If
75 If faltou_cidade=“Sim” Then
76 Response.Write “O campo Cidade deve ser preenchido. <BR>”
77 End If
78 If faltou_email=“Sim” Then
79 Response.Write “O campo email deve ser preenchido. <BR>”
231
80 End If
81 If faltou_cpf=“Sim” Then
82 Response.Write “O campo CPF deve ser preenchido. <BR>”
83 End If
84 ‘Começo a reenviar o formulário para o usuário.

85 %>
86 <P><B>Formulário para Cadastro de Clientes:</B></P>

88 <FORM action=“exemplo-1.asp” method=“post” id=form1 name=form1>
89 <% Response.Write “Caso queira alterar algum dado, digite no formulário abaixo.”
91 Response.Write “<P>Nome: <INPUT id=nome maxLength=50 name=nome
size=50>(*)</P>”
92 Else
size=50 value=” & Chr(34)& Request.Form(“nome”) & Chr(34) & “>(*)</P>”
94 End If
96 Response.Write “<P>Rua: <INPUT id=rua maxLength=35 name=rua size=35>
(*)</P>”
97 Else
98 Response.Write “<P>Rua: <INPUT id=rua maxLength=35 name=rua size=35
value=” & Chr(34)& Request.Form(“rua”) & Chr(34) & “>(*)</P>”
99 End If

101 Response.Write “<P>Cidade: <INPUT id=cidade maxLength=30
name=cidade size=18>(*)”
102 Else
103 Response.Write “<P>Cidade: <INPUT id=cidade maxLength=30
name=cidade size=18 value=” & Chr(34) &
Request.Form(“cidade”) & Chr(34) & “>(*)”
104 End If
232
105 Response.Write “Bairro:<INPUT id=bairro maxLength=25 name=bairro

value=” & Chr(34) & Request.Form(“bairro”) & Chr(34) & “></P>”
106 If faltou_email=“Sim” Then

107 Response.Write “<P>Email: <INPUT id=email maxLength=35
name=email size=19>(*)</P>”
108 Else
109 Response.Write “<P>Email: <INPUT id=email maxLength=30
name=email size=19 value=” & Chr(34)& Request.Form(“email”)
& Chr(34) & “>(*)”
110 End If
111 Response.Write “Fone:<INPUT id=fone maxLength=15 name=fone
value=” & Chr(34) & Request.Form(“fone”) & Chr(34) & “></P>”
112 If faltou_cpf=“Sim” Then

Response.Write “<P>CPF: <INPUT id=cpf maxLength=11 name=cpf
size=11>(*)”
113 Else
114 Response.Write “<P>CPF: <INPUT id=cpf maxLength=11 name=cpf
size=11 value=” & Chr(34)& Request.Form(“cpf”) & Chr(34) & “>(*)”
115 End If
116 Response.Write “<FONT size=2><B>(Digite sem o ponto e sem o traço)

</B></FONT></P>”
117 Response.Write “<P>Cartão Crédito: ”
118 If Request.Form(“cartao”)=“Visa” Then

119 Response.Write “<INPUT id=cartao name=cartao type=radio
value=Visa checked>Visa”
120 Else
121 Response.Write “<INPUT id=cartao name=cartao type=radio value=Visa>Visa”
122 End If
121 If Request.Form(“cartao”)=“Master Card” Then

122 Response.Write “<INPUT id=cartao name=cartao type=radio value=”
& Chr(34) & “Master Card” & Chr(34)& “ checked>Master Card”
123 Else
124 Response.Write “<INPUT id=cartao name=cartao type=radio value=”
& Chr(34) & “Master Card” & Chr(34)& “ checked>Master Card”
125 End If
233
126 If Request.Form(“cartao”)=“Outros” Then

127 Response.Write “<INPUT id=cartao name=cartao type=radio
value=Outros checked>Outros”
128 Else
129 Response.Write “<INPUT id=cartao name=cartao type=radio value=
Outros>Outros</P>”
130 End If
131 Response.Write “<P><INPUT id=enviar name=enviar type=submit value=Enviar> ”
132 Response.Write “<INPUT id=limpar name=limpar type=reset value=Reset>”
133 Response.Write “<BR>”
134 Response.Write “(*)->Campos de digitação obrigatória.</P>”
135 ‘Neste ponto encerro a montagem do formulário
136 %>
137 </FORM>
138 </BODY>
139 </HTML>
Algumas observações sobre a Listagem 4.30:

➥ Linhas de código como a do seguinte exemplo:
111 Response.Write “Fone:<INPUT id=fone maxLength=15 name=fone
value=” & Chr(34) & Request.Form(“fone”) & Chr(34) & “></P>”
devem ser digitadas em uma única linha. A linha aparece dividida por questões de espaço
para exibição, quando for digitar esta linha, digite-a como uma linha única.
➥ O exemplo foi desenvolvido de maneira que o código fosse de fácil compreensão, além
disso foram inseridas diversas linhas de comentário para facilitar o acompanhamento
do exemplo proposto. Cabe lembrar que, para criarmos uma linha de comentário,
devemos iniciar a mesma com o sinal de apóstrofe.
➥ Observe o seguinte fragmento de código:
22 End If
Neste fragmento, estamos testando se o campo obrigatório “nome” foi preenchido. Caso o
mesmo não tenha sido preenchido, definimos a variável faltou_dado como sendo igual a
234
Sim. Também definimos a variável faltou_nome como sendo igual a Sim. Este procedimento
é repetido para os demais campos obrigatórios. Desta forma, qualquer campo obrigatório que
esteja faltando, irá definir a variável faltou_dado como sendo igual a Sim. Estas variáveis
serão utilizadas mais adiante para informar quais campos obrigatórios estão faltando, e caso
nenhum esteja faltando, para informar os valores digitados pelo usuário.
➥ Observe o seguinte fragmento de código:
46 Response.Write “<P>Você digitou os seguintes dados !</P>”
48 For Each Dado in Request.Form %>
49 <P>
50 <% =Dado %>
51 =
52 <%=Request.Form(Dado)%>
53 </P>
54 <%Next
55 End If
Neste fragmento, verificamos se não faltou nenhum dado (faltou_dado<>“Sim”), em caso

afirmativo, simplesmente exibimos os dados digitados pelo usuário. Veja que utilizamos a
estrutura For Each...Next para percorrer todos os valores do formulário.
➥ A partir da linha 69 começo a enviar mensagens, informando os campos de
preenchimento obrigatório que não foram digitados. Considere o fragmento abaixo:
70 Response.Write “O campo Nome deve ser preenchido. <BR>”
71 End If
Neste caso, se o campo nome não foi digitado, envio a seguinte mensagem: “O campo Nome
deve ser preenchido.”
➥ A partir da linha 90:
verifico um a um os campos obrigatórios para ver qual ou quais estão faltando. Caso o campo
esteja faltando, emito uma mensagem dizendo que o mesmo deve ser digitado, caso contrário
crio o campo do formulário e defino o seu valor conforme digitado pelo usuário. Observe o
fragmento de código abaixo:
size=50>(*)</P>”
92 Else
235

94 End If
Primeiro (linha 90), testamos se o nome não foi digitado. Em caso afirmativo criamos o campo
nome, em branco. Isto é feito pela linha 91:
size=50>(*)</P>”
Esta linha envia o texto entre aspas para o navegador do cliente:

<P>Nome: <INPUT id=nome maxLength=50 name=nome size=50>(*)</P>
E este é justamente o código HTML que cria o campo nome e define os seus atributos. Veja
que estamos utilizando Response.Write para recriar o formulário HTML original.
Caso o campo tenha sido preenchido, criamos o campo novamente com o cuidado de já preenchê-
lo com o valor digitado previamente pelo usuário. Isto é feito pelo código abaixo:
Veja que esta instrução Response.Write é um pouco mais complexa. A instrução é formada
por diversas partes, sendo que cada parte é concatenada pelo operador &. Na primeira parte
é enviado o texto:
“<P>Nome: <INPUT id=nome maxLength=50 name=nome size=50 value=
A segunda parte Chr(34) envia um sinal de aspas (“). Depois do sinal de aspas, usamos
Request.Form(“nome”) para capturar o nome digitado pelo usuário. Vamos supor que o usuário
tenha digitado José da Silva no campo nome. Neste ponto, o nosso comando estaria assim:
“<P>Nome: <INPUT id=nome maxLength=50 name=nome size=50 value=“José da Silva
Depois enviamos mais um sinal de aspas, Chr(34), e a parte final “>(*)</P>”. Com isso o
código enviado por este comando é o seguinte:
“<P>Nome: <INPUT id=nome maxLength=50 name=nome size=50 value=”José da Silva”>(*)</P>
que é justamente o código HTML necessário para criar o campo Nome e definir o seu valor
conforme o valor digitado pelo usuário. Um detalhe importante a salientar é a utilização do
Chr(34) antes e depois do nome do usuário. Precisamos envolver o nome digitado entre aspas,
pois caso contrário o nome seria truncado no primeiro espaço em branco. Se o usuário digitasse
José da Silva, sem as aspas seria retornado apenas José. Tudo o que vier depois do primeiro espaço
em branco será ignorado, por isso que utilizamos uma sinal de aspas antes e outro depois.
Veja que com a utilização de código ASP vamos recriando o formulário original. Além disso
mesclamos diversos trechos de código ASP com HTML. Perceba que dentro do código ASP podemos
utilizar todos os recursos da linguagem VBScript, ou seja, as possibilidades são variadas.
236
Agora vamos a alguns exemplos de utilização da nossa aplicação. Na figura 4.24, temos um
exemplo onde o formulário original foi aberto no Internet Explorer e o usuário preencheu
todos os campos, isto é, não deixou de preencher nenhum campo obrigatório.
Figura 4.24: O usuário preencheu todos os campos.
Ao clicar no botão Enviar os dados são enviados para a página exemplo-1.asp. Como todos os
campos obrigatórios foram preenchidos, a página simplesmente exibe os valores digitados
pelo usuário, conforme mostrado na Figura 4.25.
Figura 4.25: A página ASP informa os valores digitados.
237
Além de informar os valores digitados, a página retorna o formulário com os dados digitados
pelo usuário. Caso o usuário queira alterar algum valor digitado é só fazer as alterações
necessárias e clicar no botão Enviar. O formulário aparece abaixo da informação dos valores
digitados, mais no final da página, conforme indicado na Figura 4.26.
Figura 4.26: O usuário pode alterar os valores digitados.
Vamos testar uma outra situação do nosso aplicativo. Suponhamos que o usuário deixe de preencher
um dos campos obrigatórios. No exemplo da Figura 4.27, o usuário não preenche o campo Cidade.
Figura 4.27: O usuário não preencheu um campo obrigatório.
238
Neste caso, ao clicar no botão Enviar, o usuário recebe uma página contendo uma mensagem
que avisa que o campo Cidade é de preenchimento obrigatório, e contendo o formulário
somente com o campo Cidade em branco para que o mesmo seja preenchido, conforme
Figura 4.28: Formulário informando que o campo Cidade é obrigatório.
Exemplo 2: Formulário Para Cálculo de Imposto

Descrição do problema: vamos supor que tenhamos um formulário para pedido de mercadorias.
O usuário preenche o formulário com os produtos desejados e clica em um botão Calcular.
Este botão chama uma página ASP que retorna o formulário de pedidos mais o valor do frete
e do imposto, bem como o valor total do pedido. Vamos supor que, por motivos de simplicidade,
somente são possíveis entregas para os estados do RS, PR, SC, SP e RJ. Sendo que o imposto
e a taxa de frete é diferente para cada um destes estados.
Tabela 4.3 Valores de frete e imposto para cada estado.
Estado Frete (R$) Imposto (%)

RS 3,50 12
PR 4,50 11
239
Estado Frete (R$) Imposto (%)

SC 4,20 13
SP 5,50 17
RJ 5,50 14
O frete é único para o pedido, independente do número de itens. O imposto será calculado
sobre o total da Nota, sem contar o valor do frete, isto é, sobre o valor total das mercadorias.
O nosso pedido permitirá a entrada de até três produtos. Também faremos uso de tabelas para
facilitar o layout da página.
Na Listagem 4.31 temos o formulário de pedidos.
Listagem 4.31 – Formulário de pedidos – exemplo-2.htm.

1 <HTML>
2 <HEAD>
3 <TITLE>Pedido de mercadorias.</TITLE>
4 </HEAD>
5 <BODY>
6 <P><B>FORMULÁRIO DE PEDIDOS:</B></P>
7 <P>Digite até três produtos a serem entregues.</P>

8 <P>
9 <FORM action=“exemplo-2.asp” method=post>

10 <TABLE align=left bgColor=gray border=1 cellPadding=1 cellSpacing=1 width=“75%”>
11 <TR>
12 <TD>Descrição</TD>
13 <TD>Pr. Unit.</TD>
14 <TD>Quant.</TD>
15 <TD>Subtotal</TD>
16 </TR>
17 <TR>
18 <TD><INPUT id=prod1 name=prod1></TD>
19 <TD><INPUT id=unit1 name=unit1 style=“HEIGHT: 22px; WIDTH: 37px”></TD>
240
20 <TD><INPUT id=quant1 name=quant1 style=“HEIGHT: 22px; WIDTH: 37px”></TD>

21 <TD><INPUT id=valor1 name=valor1 style=“HEIGHT: 22px; WIDTH: 51px”></TD>
22 </TR>
23 <TR>
28 </TR>
29 <TR>
34 </TR>
35 </TABLE>
36 <P><INPUT id=enviar name=enviar type=submit value=“Calcular Total”></P>
37 <SELECT id=estado name=estado>

38 <OPTION selected value=“”>Estado -></OPTION>
39 <OPTION value=RS>RS</OPTION>
40 <OPTION value=SC>SC</OPTION>
41 <OPTION value=PR>PR</OPTION>
42 <OPTION value=SP>SP</OPTION>
43 <OPTION value=RJ>RJ</OPTION>
44 </SELECT>
45 </P>
46 </FORM>
47 </BODY>
48 </HTML>
Na Figura 4.29, podemos ver este formulário no Internet Explorer.
241
Figura 4.29: Formulário para preenchimento do pedido.
Agora vamos criar a página ASP (exemplo2-asp) que faz o cálculo de cada item individual-
mente, depois calcula o total dos três itens e, finalmente, aplica o imposto e o frete de acordo
com o estado selecionado pelo cliente. Após fazer os cálculos a página ASP retorna os valores
fornecidos pelo usuário mais os cálculos realizados.
Na Listagem 4.32 temos o código para a página – exemplo-2.asp. Sempre lembrando que
procuramos desenvolver o código pensando na facilidade do entendimento. Diversas soluções
diferentes poderiam ser adotadas, com a obtenção do mesmo resultado.
Listagem 4.32 – A página ASP para cálculo do total do pedido.

2 <HTML>
3 <HEAD>
4 </HEAD>
5 <BODY>
6 <%
7 Response.Write “<B>VALORES TOTAIS PARA O SEU PEDIDO:</B><BR>”
242
8 ‘Crio uma variável para o subtotal de cada produto.

9 If Request.Form(“unit1”)<>“” Then
10 subtot1=CSng(Request.Form(“unit1”))*Csng(Request.Form(“quant1”))
11 Else
12 subtot1=0
13 End If
16 Else
17 subtot2=0
18 End If
21 Else
22 subtot3=0
23 End If
24 total_inicial=subtot1+subtot2+subtot3
25 ‘Agora acrescento o imposto e o frete com base no estado.
26 Select Case Request.Form(“estado”)
27 Case “RS”
28 total_imposto=total_inicial+total_inicial*0.12
29 total_geral=total_imposto+3.50
30 valor_frete=3.50
31 Case “SC”
34 valor_frete=4.20
35 Case “PR”
38 valor_frete=4.50
39 Case “SP”
243
42 valor_frete=5.50
43 Case “RJ”
46 valor_frete=5.50
47 End Select
48 ‘A partir de agora começo a devolver a página

49 ‘com os valores digitados pelo usuário, mais
50 ‘os valores calculados.
51 %>
52 <FORM action=“exemplo-2.asp” method=post id=form1 name=form1>
53 <TABLE align=left bgColor=gray border=1 cellPadding=1 cellSpacing=1 width=“75%”>
54 <TR>
55 <TD>Descrição</TD>
56 <TD>Pr. Unit.</TD>
57 <TD>Quant.</TD>
58 <TD>Subtotal</TD>
59 </TR>
60 <TR>
61 <TD><INPUT id=prod1 name=prod1 value=“ <%=Request.Form(“prod1”)%> ”></TD>
62 <TD><INPUT id=unit1 name=unit1 value=“ <%=Request.Form(“unit1”)%>”
style=“HEIGHT: 22px; WIDTH: 37px”></TD>
63 <TD><INPUT id=quant1 name=quant1 value=“<%=Request.Form(“quant1”)%>”
64 <TD align=right ><B><%=subtot1%></B></TD>
65 </TR>
66 <TR>
244

71 </TR>
72 <TR>
77 </TR>
78 <%
79 ‘Agora monto uma linha para o total de produtos.

80 ‘Uma linha para o valor do frete.
81 ‘Uma linha para o valor do imposto.
82 ‘Uma linha para o total geral.
83 %>
84 <TR>
85 <TD>TOTAL PROD.->></TD>
86 <TD></TD>
87 <TD></TD>
88 <TD align=right><% =FormatNumber(subtot1+subtot2+subtot3,2)%></TD>
89 </TR>
90 <TR>
91 <TD>IMPOSTO ->></TD>
92 <TD></TD>
93 <TD></TD>
94 <TD align=right><% =FormatNumber(total_imposto-total_inicial,2)%></TD>
95 </TR>
96 <TR>
97 <TD>FRETE ->></TD>
98 <TD></TD>
99 <TD></TD>
245
100 <TD align=right><% =FormatNumber(valor_frete,2)%></TD>

101 </TR>
102 <TR>
103 <TD>TOTAL GERAL ->></TD>
104 <TD></TD>
105 <TD></TD>
106 <TD align=right><% =FormatNumber(total_geral,2)%></TD>
107 </TR>
108 </TABLE>
109 <A HREF=“exemplo-2.htm”>Clique aqui para voltar a página de Pedidos.</A>
110 </BODY>
111 </HTML>

➥ Linhas de código como a do seguinte exemplo:
devem ser digitadas em uma única linha. A linha aparece dividida por questões de espaço
para exibição; quando for digitá-la, digite-a como uma linha única.
➥ O exemplo foi desenvolvido de maneira que o código fosse de fácil compreensão, além
disso foram inseridas diversas linhas de comentário para facilitar o acompanhamento
do exemplo proposto. Cabe lembrar que para criarmos uma linha de comentário
devemos iniciar a mesma com o sinal de apóstrofe.
➥ Observe que utilizamos diversos elementos da linguagem VBScript, tais como a
estrutura Select Case...End Select, para calcular o imposto e o frete, com base no Estado
selecionado pelo cliente. Utilizamos também a função Csng para converter os valores
de Preço Unitário e Quantidade em valores numéricos, de tal forma que fosse possível
realizar cálculos com estes valores. Utilizamos a função FormatNumber para formatar
os valores calculados, de tal forma a exibir os valores com duas casas decimais, conforme
mostrado no fragmento de código a seguir:
<% =FormatNumber(valor_frete,2)%>
Agora vamos a um exemplo de utilização da nossa aplicação. Na figura 4.30, temos um exemplo
onde o formulário de pedidos foi aberto no Internet Explorer e o usuário preencheu o pedido
com três produtos. O estado selecionado foi SP.
246
Figura 4.30: Preenchendo os dados do pedido.
Ao clicar no botão Calcular Total será chamada a página exemplo-2.asp, a qual faz os cálculos
e exibe os resultados, conforme indicado na Figura 4.31.
Figura 4.31: Resultados calculados para o pedido.
247
Com isso comprovamos que a nossa página, para cálculo do Total do Pedido, está funcionando
corretamente.
Conclusão
Neste capítulo aprendemos aspectos fundamentais do ASP 3.0.
Primeiro, aprendemos exatamente o que é uma página ASP, onde a mesma é processada e
qual o resultado que retorna para o navegador do cliente. Depois tivemos uma visão geral
sobre o Modelo de Objetos do ASP 3.0.
Em seguida fizemos um estudo completo sobre os objetos Request e Response. Estudamos

todas as coleções, métodos e propriedades destes objetos. Para cada elemento apresentado
foram colocados exemplos de código, facilitando o entendimento.
Na parte final do capítulo apresentamos dois exemplos mais elaborados, onde utilizamos
diversos conceitos apresentados até o momento, tais como o conhecimento dos objetos Request
e Response e da linguagem VBScript.
Mas, para que nossos exemplos assumam um aspecto mais profissional, precisamos aprender
a acessar bancos de dados a partir de páginas ASP. Este é o assunto do Capítulo 5. Então,
vamos lá, sem mais demoras.
248
Capítulo 5 – Conectando Páginas ASP com Bancos de Dados
Capítulo 5
Conectando Páginas ASP
com Bancos de Dados
249
Estamos vivendo na Era da Informação. Os aplicativos, quer sejam os tradicionais quer sejam
aplicativos para a Web, são todos ligados à informações de bancos de dados. Quando você faz
o cadastro em um site de Comércio Eletrônico, os dados fornecidos são armazenados em um
banco de dados. Da próxima vez que você visitar o site, estas informações poderão ser
recuperadas a partir deste banco de dados. Quando ligamos para a companhia telefônica
para reclamar, o atendente pede que seja informado o nosso código de cliente. É através deste
código que as informações sobre o cliente são recuperadas, a partir do banco de dados da
empresa. Existem incontáveis exemplos de aplicações que usam bancos de dados, não
importando se este está residente em um Mainframe ou em um servidor de Rede que roda um
servidor de banco de Dados, como o Microsoft SQL Server 2000. Devemos salientar a
importância e a necessidade da utilização de banco de dados para o armazenamento de um
volume cada vez maior de informações, sendo que estas informações e sua correta utilização
são de fundamental importância para a empresa.
Durante muito tempo, os bancos de dados residiam em computadores de grande porte, os

conhecidos Mainframe. Depois veio uma onda de descentralização, na qual a grande estrela
eram as Redes Locais de microcomputadores, com bancos de dados em servidores de Rede.
Esta foi a época da criação das aplicações em duas camadas, no tradicional modelo Cliente-
Servidor. Com o avanço do modelo Web e da Internet, surgiu a necessidade do desenvolvimento
de aplicações Web com conexão a banco de dados. Hoje esta necessidade está mais do que
justificada: não existe aplicação Web que não faça conexão com bancos de dados. Desde um
simples formulário para consulta ao CEP até aplicações mais complexas de cotação eletrônica
de preços, todas necessitam de acesso a bancos de dados.
Neste capítulo aprenderemos a utilizar a tecnologia ASP 3.0 para conectar nossas páginas com
banco de dados. Iniciaremos por uma revisão de dois conceitos muito importantes:
➥ Modelo Relacional de dados.
➥ Linguagem SQL – Structured Query Language.
Uma vez revistos estes conceitos partiremos para a conexão de páginas ASP com bancos de
dados utilizando os objetos do ASP. Uma vez estabelecida a conexão aprenderemos a utilizar
objetos do ASP que recuperam informações do banco de dados. Diversos exemplos práticos
serão apresentadospara facilitar o entendimento dos conceitos apresentados. Também veremos
como inserir informações em um Banco de dados, a partir de um formulário HTML.
Para facilitar o acompanhamento dos exemplos apresentados, estaremos utilizando um banco

de dados do Microsoft Access.
Este capítulo fornece a base necessária para conectar páginas ASP com bancos de dados,
além da revisão dos conceitos básicos relativos a bancos de dados e à linguagem SQL. No
próximo capítulo estaremos abordando diversos aspectos avançados em relação a utilização
de bancos de dados com páginas ASP.
250
Uma Revisão dos Conceitos Básicos de Banco de Dados

Neste item iremos revisar alguns conceitos básicos sobre bancos de dados. Estes conceitos
são importantes para o projeto, a criação e a correta utilização dos bancos de dados.
Em muitas situações teremos que conectar nossas páginas ASP com bancos de dados já
existentes, neste caso precisamos conhecer os conceitos aqui apresentados, para podermos
otimizar sua utilização.
Em outras situações teremos que criar o banco de dados a ser utilizado pela aplicação
Web. Neste caso, os conceitos apresentados neste item auxiliam na criação de um banco
de dados melhor estruturado e otimizado, tanto em termos de espaço de armazenamento,
quanto da qualidade e disponibilidade das informações nele contidas. Revisaremos os
seguintes conceitos:
➥ Entidades e Atributos.
➥ Chave Primária.
➥ Relacionamentos entre Entidades (Tabelas).
➥ Integridade Referencial.
➥ Normalização de Tabelas.
Entidades e Atributos
Toda informação de um banco de dados é armazenada em Tabelas, que também são chamadas
de Entidades. Por exemplo, poderíamos ter uma tabela “Clientes”, onde seriam armazenadas
informações sobre os diversos clientes.
Sobre cada um dos clientes poderíamos armazenar informações tais como: Nome, Rua, Bairro,
Telefone, CEP, Data de Nascimento, etc. Essas diversas características de cada cliente são os
“atributos” do cliente, muitas vezes chamados de Campos da entidade Cliente. O conjunto de
todos os atributos de um cliente e os valores dos mesmos forma o Registro do cliente. Com
isso teremos a tabela constituída por um conjunto de registros (uma linha completa com
informações sobre o cliente) e cada registro formado por um conjunto de atributos (Nome,
Endereço, etc.).
Resumindo:
➥ Entidade ou Tabela – Conjunto de Registros.
➥ Campos ou Atributos – Características individuais da Entidade.
Considere o exemplo da Figura 5.1, onde temos uma tabela Cliente com os seus diversos
campos (atributos):
251
Figura 5.1: A entidade (tabela) Clientes e seus diversos atributos (campos).
No exemplo da Figura 5.1, temos uma entidade – Clientes – e seus diversos atributos – Código
do Cliente, Nome da Empresa, Nome do Contato, Cargo do Contato, Endereço, etc. Em cada
linha temos um conjunto de atributos e seus valores. Cada linha forma um registro. Cada
coluna é um atributo da tabela Clientes.
Um dos grandes desafios em se projetar um banco de dados com sucesso é a correta determinação
das entidades que existirão, bem como dos atributos de cada uma delas.
Chave Primária
O conceito de Chave Primária é fundamental para o correto entendimento do funcionamento
de um banco de dados. Vamos procurar entender o que significa um campo ser a chave
primária de uma tabela.
Ao definirmos um campo como sendo uma chave primária, estamos informando ao banco de
dados que não podem existir dois registros com o mesmo valor de chave primária, ou seja, os
valores neste campo precisam ser únicos. Por exemplo, se defino o campo Número da
Identidade da tabela Clientes como sendo uma chave primária, estou dizendo ao banco de
dados que não podem existir dois clientes com o mesmo valor neste campo. Na prática, estou
garantindo que não podem ser cadastrados dois clientes com o mesmo Número de Identidade.
Em outras palavras poderíamos dizer que o campo chave primária identifica de maneira
única cada registro de uma tabela, isto é, de posse do valor da chave primária somente
localizaremos um registro com determinado valor neste campo.
252
Este é um conceito muito importante, pois, conforme veremos mais adiante, os conceitos de
Integridade Referencial e Normalização estão diretamente ligados ao conceito de chave primária.
Na Figura 5.2 vemos um exemplo da tabela Clientes onde o campo Código do Cliente é definido
como uma chave primária. Observe que não existem dois clientes com o mesmo código.
Figura 5.2: O campo Código do Cliente é uma chave primária.
Um detalhe importante é que a chave primária pode ser formada pela combinação de mais de
um campo. Podem existir casos em que um único campo não é capaz de atuar como chave
primária, pelo fato do mesmo apresentar valores repetidos. Nestes casos podemos definir
uma combinação de dois ou mais campos para ser a nossa chave primária. Lembre-se que
uma tabela pode ter somente uma chave primária, seja ela simples ou composta.
Relacionamentos Entre Tabelas

Na prática, em um banco de dados existem diversas tabelas, como por exemplo: Clientes,
Produtos, Pedidos, Detalhes do Pedido, etc. Embora as informações estejam separadas em
cada uma das tabelas, na prática devem existir relacionamentos entre elas.
Por exemplo: um pedido é feito para um cliente e neste pedido podem existir diversos itens,
os quais são armazenados na tabela Detalhes do Pedido. Além disso cada pedido tem um
número único, e um mesmo cliente pode fazer diversos pedidos.
253
Em um banco de dados precisamos de uma maneira para representar estes relacionamentos,

da vida real, em termos das tabelas e atributos. Isto é possível com a utilização de relacionamen-
tos entre tabelas, os quais podem ser de três tipos:
➥ Um para Um
➥ Um para Vários
➥ Vários para Vários
Relacionamento do Tipo Um Para Um

Esta relação existe quando os campos que se relacionam são ambos chaves primárias em suas
respectivas tabelas. Cada um dos campos não apresenta valores repetidos. Na prática existem
poucas situações onde utilizaremos um relacionamento deste tipo.
Um exemplo poderia ser o seguinte: imagine uma escola com um cadastro de alunos na
tabela Alunos. Apenas uma pequena parte deles participa da Banda da escola. Por questões
de projeto do banco de dados, podemos optar por criar uma segunda tabela Alunos da Banda,
a qual pode se relacionar com a tabela Alunos através de um relacionamento Um para Um.
Cada aluno somente é cadastrado uma vez na tabela Alunos e uma única vez na tabela Alunos
da Banda. Poderíamos utilizar o campo Matrícula do Aluno como o campo que relaciona as
duas tabelas.
Na tabela Alunos da Banda poderíamos colocar apenas o Número da Matrícula do aluno,

além das informações a respeito do instrumento que ele toca, tempo de banda, etc. Quando
for necessário buscar as informações tais como nome, endereço, etc., as mesmas podem ser
recuperadas através do relacionamento existente entre as duas tabelas, evitando, com isso,
que a mesma informação (Nome, Endereço, etc.) tenha que ser duplicada nas duas tabelas, o
que diminui a probabilidade de erros de digitação.
Na Figura 5.3 vemos o exemplo de um relacionamento do tipo Um para Um entre as tabelas

Alunos e Alunos da Banda.
Figura 5.3: Um relacionamento do tipo Um para Um.
254
Relacionamento do Tipo Um Para Vários

Este, com certeza, é o tipo de relacionamento mais comum entre duas tabelas. Uma das
tabelas (o lado Um do relacionamento) possui um campo que é a chave primária e a outra
tabela (o lado Vários) se relaciona através de um campo cujos valores relacionados podem se
repetir várias vezes.
Considere o exemplo entre a tabela Clientes e Pedidos. Cada Cliente somente é cadastrado
uma única vez (por isso o campo Código do Cliente é uma chave primária, indicando que não
podem existir dois clientes com o mesmo código); portanto a tabela Clientes será o lado Um
do relacionamento. Porém cada cliente pode fazer diversos pedidos, por isso que o Código do
Cliente poderá aparecer várias vezes na tabela Pedidos, tantas vezes quantos forem os pedidos
que o cliente tiver feito. Por isso que temos um relacionamento do tipo Um para Vários entre
a tabela Clientes e Pedidos, através do campo Código do Cliente, indicando que um mesmo
cliente pode realizar diversos pedidos.
Na Figura 5.4 vemos um exemplo de um relacionamento Um para Vários entre as tabelas

Clientes e Pedidos, através do campo Código do Cliente.
Figura 5.4: Um relacionamento do tipo Um para Vários.
No lado Um do relacionamento o campo é definido como uma chave primária (campo

CódigoDoCliente na tabela Clientes) e no lado Vários não (campo CódigoDoCliente na tabela
Pedidos), indicando que no lado Vários o Código do Cliente pode se repetir várias vezes, uma
vez que um mesmo cliente pode fazer diversos pedidos.
Relacionamento do Tipo Vários para Vários

Este tipo de relacionamento ocorre em uma situação onde, em ambos os lados do relacionamen-
to, os valores poderiam se repetir. Vamos considerar o caso entre Produtos e Pedidos. Posso
ter vários Pedidos nos quais aparece um determinado produto, além disso vários Produtos
podem aparecer no mesmo Pedido. Esta é uma situação em que temos um relacionamento do
tipo Vários para Vários: Vários produtos podem aparecer em Vários pedidos.
255
Na prática não temos como implementar um relacionamento deste tipo, devido a uma série
de problemas que este procedimento implicaria. Por exemplo, na tabela Pedidos teríamos
que repetir o Número do Pedido, Nome do Cliente, Nome do Funcionário, Data do Pedido,
etc. para cada item do Pedido.
Para evitar este tipo de problema é bastante comum quebrarmos um relacionamento do tipo
Vários para Vários em dois relacionamento do tipo Um para Vários. Isso é feito através da criação
de uma nova tabela, a qual fica com o lado Vários dos relacionamentos. No nosso exemplo
poderíamos criar a tabela Detalhes do Pedido, onde ficam armazenadas as informações sobre os
diversos itens de cada pedido. Então, ao invés de termos um relacionamento do tipo Vários para
Vários, teremos dois relacionamentos do tipo Um para Vários, conforme indicado na Figura 5.5.
Figura 5.5: “Quebrando” um relacionamento Vários para Vários.
Esta situação em que um relacionamento Vários para Vários é “quebrado” em dois relaciona-
mentos do tipo Um para Vários é bastante comum. Diversas vezes utilizamos esta técnica
para eliminar uma série de problemas no banco de dados, tais como informação repetida e
inconsistência de dados.
Agora que já conhecemos os tipos de relacionamentos existentes, no próximo item veremos o

conceito de Integridade Referencial como uma maneira de garantir a consistência dos dados.
Integridade Referencial
A Integridade Referencial é utilizada para garantir a integridade dos dados entre as tabelas
relacionadas, evitando inconsistências dos dados, bem como repetições desnecessárias.
Por exemplo, existe um relacionamento do tipo Um para Vários entre a tabela Clientes e a
tabela Pedidos (um cliente pode fazer vários pedidos). Com a Integridade Referencial, o banco
de dados não permite que seja cadastrado um pedido para um cliente ainda não cadastrado.
Também podemos garantir o seguinte:
256
➥ Quando o código de um cliente for alterado na tabela Clientes, o banco de dados atualiza,
automaticamente, todos os Códigos do Cliente na tabela Pedidos, de tal maneira que
não fiquem registros órfãos, isto é, registros de Pedidos com um código de cliente que
não existe mais na tabela Clientes. Esta ação é conhecida como “Propagar atualização
dos campos relacionados”.
➥ Quando um cliente for excluído da tabela Clientes, podemos pedir para que o banco
de dados exclua, na tabela Pedidos, todos os pedidos do cliente que está sendo excluído.
Essa opção é conhecida como “Propagar exclusão dos registros relacionados” e pode
ser habilitada ou não, dependendo da especificação do banco de dados. Caso seja
necessário manter todo o histórico de compras do cliente, por exemplo, esta opção não
deve ser habilitada. Com isso, quando o cliente for eliminado da tabela Clientes, os
seus pedidos continuarão gravados na tabela Pedidos.
Essas opções são definidas no momento da criação das tabelas e dos relacionamentos entre as
tabelas do banco de dados.
A opção de “Propagar atualização dos campos relacionados” é utilizada na maioria das situações,
já a opção de “Propagar exclusão dos registros relacionados” deve ser estudada, caso a caso.
Normalização de Tabelas
O conceito de Normalização foi criado no início da década de 70.
O objetivo da Normalização é evitar os problemas provocados por falhas no projeto do banco de

dados, bem como eliminar a mistura de assuntos e as correspondentes redundâncias de dados.
Uma regra de ouro que devemos observar durante a elaboração do projeto de banco de dados
é a de “Não misturar assuntos em uma mesma tabela”.
Por exemplo na tabela Clientes devemos colocar somente campos relacionados com o assunto
Clientes. Não devemos misturar campos relacionados com outros assuntos, tais como Pedidos,
Produtos, etc. Essa “mistura de assuntos” em uma mesma tabela acaba por gerar repetição
desnecessária dos dados bem como inconsistência dos mesmos.
O processo de Normalização aplica uma série de regras sobre as entidades de um banco de

dados, para verificar se as mesmas estão corretamente projetadas. Embora existam cinco Formas
Normais (ou regras de Normalização), na prática usamos um conjunto de três Formas Normais.
Com freqüência, após a aplicação das regras de Normalização, algumas tabelas acabam se dividindo
em duas ou mais, o que no final gera um número maior de tabelas do que o originalmente existente.
Este processo causa a simplificação dos atributos de uma tabela, colaborando para a estabilidade
do modelo, reduzindo-se consideravelmente as necessidades de manutenção.
257
Vamos estudar e entender o processo de Normalização na prática, através de exemplos.
Primeira Forma Normal

Uma tabela está na Primeira Forma Normal quando seus atributos não contém Grupos de Repetição.
Por isso dizemos que uma tabela que possui Grupos de Repetição não está na Primeira Forma
Normal. Considere a tabela indicada na Figura 5.6.
Figura 5.6: Uma tabela que não está na Primeira Forma Normal.
Podemos notar que uma tabela com esta estrutura apresentaria diversos problemas. Por
exemplo, se um casal tiver mais de um filho, teríamos que digitar o nome do pai e o nome da
mãe diversas vezes, tantas quantas forem os filhos. Isso forma um Grupo de Repetição. Além
do mais, pode ser que por erro de digitação o nome dos pais não seja digitado exatamente
igual todas as vezes, o que pode acarretar problemas na hora de fazer pesquisas ou emitir
relatórios. Este problema ocorre porque misturamos assuntos em uma mesma tabela.
Colocamos as informações dos pais e dos filhos em uma mesma tabela.
A resolução para este problema é simples: criamos uma tabela separada para a informação
dos pais e relacionamos a tabela Pais com a tabela Filhos através de um relacionamento do
tipo Um para Vários, ou seja, Um casal pode ter Vários filhos.
Esta solução é indicada na Figura 5.7.
As duas tabelas resultantes desse processo de Normalização, Pais e Filhos, estão na Primeira
Forma Normal; a tabela original, a qual misturava informações de Pais e Filhos, não estava na
Primeira Forma Normal.
258
Figura 5.7: As tabelas Pais e Filhos estão na Primeira Forma Normal.
Segunda Forma Normal

Ocorre quando a chave primária é composta por mais de um campo. Neste caso, devemos
observar se todos os campos que não fazem parte da chave primária dependem de todos os
campos que a compõem. Se algum campo depender somente de parte da chave composta,
então este campo deve pertencer a outra tabela.
Observe o exemplo indicado na tabela da Figura 5.8.
Figura 5.8: Uma tabela que não está na Segunda Forma Normal.
A chave primária composta é formada pela combinação dos campos NúmeroDaMatrícula e

CódigoDoCurso. O campo Avaliação depende tanto do CódigoDoCurso quanto do
NúmeroDaMatrícula, porém o campo DescriçãoDoCurso, depende apenas do CódigoDoCurso.
Com isso temos um campo que não faz parte da chave primária e depende apenas de um dos
campos que a compõem, por isso dizemos que esta tabela não está na Segunda Forma Normal.
A resolução para este problema também é simples: dividimos a tabela, que não está na Segunda
Forma Normal, em duas outras tabelas, conforme indicado pela Figura 5.9, sendo que as duas
tabelas resultantes estão na Segunda Forma Normal.
259
Figura 5.9: Duas tabelas na Segunda Forma Normal.
NOTA
A distinção entre a Segunda e a Terceira Formas Normais, que veremos no próximo item,
muitas vezes é confusa. A Segunda Forma Normal, na maioria das vezes, está ligada a ocorrência
de chaves primárias compostas.
Terceira Forma Normal

Na definição dos campos de uma entidade podem ocorrer casos em que um campo não seja
dependente diretamente da chave primária, ou de parte dela, mas sim dependente de um
outro atributo constante na tabela e que não é a chave.
Quando isto ocorre, dizemos que a tabela não está na Terceira Forma Normal, conforme
indicado pela tabela da Figura 5.10.
Figura 5.10: Uma tabela que não está na Terceira Forma Normal.
Observe que o campo DescriçãoDoCurso depende apenas do campo CódigoDoCurso, o qual não
faz parte da chave primária. Por isso dizemos que esta tabela não está na Terceira Forma Normal.
A solução para este caso também é simples. Novamente basta dividir a tabela em duas outras,
conforme indicado pela Figura 5.11. As duas tabelas resultantes estão na Terceira Forma Normal.
260
Figura 5.11: Duas tabelas na Terceira Forma Normal.
IMPORTANTE
Com isso podemos concluir que, como resultado do processo de Normalização, iremos obter
um número maior de tabelas, porém sem problemas de redundância e inconsistência dos
dados, ou com estes problemas minimizados.
Passos Para Projetar um Banco de Dados

Neste item iremos apresentar os passos básicos para projetar um banco de dados. Aplicaremos
os conhecimentos sobre Entidades, Atributos, Relacionamentos, Chave Primária e Normalização.
Um banco de dados bem projetado fornece um acesso conveniente às informações desejadas.

Com uma boa estrutura, gasta-se menos tempo na construção do banco de dados e, ao mesmo
tempo, assegura-se resultados mais rápidos e precisos.
Etapas na Estruturação de um Banco de Dados

➥ Determinar qual o objetivo do banco de dados. Isto ajuda na determinação de quais os
dados devem ser armazenados.
➥ Determinar as tabelas necessárias. Após definirmos o objetivo do banco de dados, as
informações devem ser definidas e separadas em assuntos diferentes, tais como Clientes,
Empregados, Pedidos, pois cada um irá compor uma tabela no banco de dados.
➥ Determinar os campos necessários em cada tabela. Definir quais informações devem
ser mantidas em cada tabela. Por exemplo, a tabela Clientes poderia ter um campo
para o Código do Cliente, outro para o Nome do Cliente e assim por diante.
➥ Determinar, em cada tabela, qual ou quais campos serão utilizados como chave primária.
Esta é uma etapa importante para a definição dos relacionamentos que vem a seguir.
➥ Determinar os relacionamentos. Decidir como os dados de uma tabela se relacionam
com os dados de outras tabelas. Por exemplo, clientes podem fazer vários pedidos.
fornecedores podem fornecer vários produtos, etc.
261
➥ Refinar a estrutura do banco de dados. Antes de inserir muitos dados, ou até mesmo
antes de inserir qualquer dado, verificar se a estrutura contém erros, isto é, verificar se
os resultados obtidos são os desejados. Isto, freqüentemente, pode ser obtido através do
processo de Normalização. Caso necessário, deve-se alterar a estrutura do banco de dados.
Dicas Para Determinação dos Campos em uma Tabela

➥ Relacionar diretamente cada campo ao assunto da tabela. Se um campo descreve o
assunto de uma tabela diferente, este campo deve pertencer a outra tabela. O mesmo
acontece quando uma informação se repete em diversas tabelas. Este é um indício de
que existem campos desnecessários em algumas tabelas.
➥ Não incluir dados derivados ou calculados. Não é recomendado armazenar o resultado
de cálculos nas tabelas. O correto é que o cálculo seja executado quando necessitarmos
do resultado.
➥ Incluir todas as informações necessárias. Como é fácil esquecer informações
importantes, deve-se ter em mente todas as informações coletadas desde o início do
processo e verificar se com elas é possível obter todos os resultados desejados.
➥ Armazenar todas as informações separadamente. Existe uma tendência em armazenar
informações em um único campo, por exemplo o nome do curso e o tempo de duração
em um mesmo campo. Como as duas informações foram combinadas em um único
campo, ficará difícil conseguir um relatório classificado pelo tempo de duração dos
cursos, por exemplo.
Como Escolher o Campo que Será a Chave Primária?

Um bom Sistema Gerenciador de Banco de Dados (SGBD) é aquele que encontra e nos fornece,
rapidamente, todas as informações necessárias que nele estejam armazenadas, mesmo que
em diferentes tabelas. Para que isto seja possível é necessário incluir um campo ou conjunto
de campos que identifiquem de modo único cada registro de uma tabela. Esta informação é
chamada Chave Primária, conforme descrito anteriormente. Deve-se ter certeza que este campo
(ou conjunto de campos) seja sempre diferente para cada registro, por não ser permitido
valores duplicados em um campo de chave primária.
Ao escolher campos de chave primária, considere os seguintes detalhes:

➥ Não é permitido duplicidade de valores ou nulos (informações desconhecidas). Caso
não exista um identificador único para uma determinada tabela, pode-se usar um campo
que numere os registros seqüencialmente.
➥ Pode-se utilizar o valor deste campo para encontrar registros.
262
➥ O tamanho da chave primária afeta a velocidade das operações, portanto, para um

melhor desempenho, devemos utilizar o menor tamanho que acomode os valores
necessários para armazenar no campo.
Noções Básicas da Linguagem

SQL – Structured Query Language
Em diversas situações estaremos utilizando a linguagem SQL em nossas páginas ASP. Para
recuperar dados, inserir novas informações ou, até mesmo, para atualizar informações em
um banco de dados, estaremos utilizando a linguagem SQL. Por isso que é importante
conhecermos os aspectos básicos desta linguagem, conforme veremos neste item.
Introdução
Na Figura 5.12 temos um exemplo de uma instrução SQL. Embora possa parecer complexa, em
um primeiro momento, veremos que a linguagem SQL é bastante simples e de fácil aprendizado.
Figura 5.12: Um exemplo de instrução SQL.
Uma instrução SQL descreve o conjunto de dados que você deseja recuperar (campos, de
quais tabelas, critérios, classificação, expressões calculadas, etc.).
Todas as instruções SQL são conduzidas com um único comando que contém uma descrição
completa da informação exigida. Ao escrever uma instrução SQL, você não deve se preocupar
em como os dados são recuperados, mas somente com o conteúdo do conjunto de dados.
Esse é o principal benefício do método SQL.
263
Lembre-se que o SQL é um padrão genérico para expressões de consulta em banco de dados.
Embora a maior parte das versões do SQL compartilhe elementos básicos, elas não são
idênticas. O Access SQL usa algumas palavras-chave que você não encontra em outras versões
do SQL. Também existem pequenas diferenças entre o Microsoft Access e o Microsoft SQL
Server, conforme iremos salientar durante este capítulo.
Veremos através de exemplos a utilização das principais palavras-chave do SQL para a

construção de expressões SQL para pesquisa em banco de dados.
A Instrução SELECT
Esta é com certeza, a instrução SQL mais importante; não existe pesquisa que não utilize esta
instrução. Agora vamos conhecê-la em detalhes.
A instrução Select é utilizada para especificar quais os campos de quais tabelas farão parte da
consulta, quais critérios de pesquisa serão utilizados, qual a ordem de classificação, etc.
A sintaxe simplificada da instrução é conforme indicado abaixo:

SELECT
campo1, campo2, campo3
FROM nome_da_tabela
[WHERE condição ]
[GROUP BY nome_do_campo ]
[HAVING ... ]
[ORDER BY... ]
Na Tabela 5.1 temos uma descrição destes elementos.
Tabela 5.1 Os principais elementos da instrução Select.
Elemento Descrição
campo1, campo2 ... campon Nome dos campos a serem retornados a partir
de uma ou mais tabelas.
nome_da_tabela Nome da tabela a partir da qual os dados devem
ser recuperados.
WHERE Permite que sejam especificados
critérios de pesquisa.
GROUP BY Podemos agrupar os resultados em
torno de um ou mais campos de dados.
264
Elemento Descrição
Por exemplo, em um relatório de vendas anuais,
posso ter os resultados agrupados por mês, com
a soma das vendas do mês logo após a listagem
de vendas do mês.
HAVING Especifica critérios para serem utilizados
juntamente com Group By.
ORDER BY Podemos ordenar os resultados obtidos com
base em um ou mais campos de dados. Por
exemplo, podemos ordenar uma listagem de
vendas em ordem alfabética do nome do cliente
ou do nome do vendedor.
Vamos analisar alguns exemplos práticos de utilização da linguagem SQL.
Exemplo 1
Criar uma instrução SQL que retorne o campo NúmeroDoPedido, o campo DataDoPedido, o
campo Frete e o campo PaísDeDestino da tabela Pedidos.
SELECT Pedidos.NúmeroDoPedido, Pedidos.DataDoPedido, Pedidos.PaísDeDestino,
Pedidos.Frete FROM Pedidos;
Toda instrução SQL deve terminar com um ponto e vírgula (;), conforme indicado no Exemplo 1.
Observe que os nomes dos campos estão separados por vírgula, além disso estamos utilizando o
nome completo, isto é: Nome_da_tabela.Nome_do_campo. Também poderíamos utilizar o
comando, sem o nome da tabela antes do nome do campo, conforme indicado no seguinte comando:
SELECT NúmeroDoPedido, DataDoPedido, PaísDeDestino, Frete FROM Pedidos;
IMPORTANTE
Somente é obrigatória a utilização do nome da tabela antes do nome do campo quando o
mesmo campo existir em duas ou mais tabelas que fazem parte da instrução SQL. Por exemplo,
imagine que estejamos escrevendo uma instrução SQL para criar uma listagem com o código
e o nome do cliente, bem como todos os pedidos efetuados pelo cliente. Acontece que o Código
do Cliente, no nosso exemplo, existe nas duas tabelas: Clientes e Pedidos. Neste caso devemos
especificar o nome da tabela, antes do nome do campo.
265
Exemplo 2
Alterar a instrução SQL anterior para que os registros sejam classificados em ordem crescente
pelo valor do Frete.
SELECT NúmeroDoPedido, DataDoPedido, PaísDeDestino, Frete FROM Pedidos
ORDER BY Frete;
Observe a utilização da cláusula “ORDER BY Frete” para classificar os registros em ordem

crescente. A classificação em ordem crescente é a padrão . Quando formos classificar em ordem
decrescente, precisamos especificar a palavra DESC, conforme indicado no seguinte comando:
ORDER BY Frete DESC;
Exemplo 3
Agora vamos começar a inserir condições. Muitas vezes as condições são chamadas de filtro;
uma vez estabelecida uma condição, somente os registros que atendem a condição especificada
serão retornados. Desta forma a condição atua como se fosse um filtro. Neste exemplo vamos
alterar a instrução SQL anterior para que sejam exibidos somente os pedidos cujo PaísDeDestino
seja Brasil.
WHERE PaísDeDestino=“Brasil”
ORDER BY Frete;
Observe a utilização da cláusula WHERE para filtrar somente os pedidos cujo PaísDeDestino seja
Brasil. Como o campo PaísDeDestino é um campo do tipo texto, o valor do critério (Brasil) tem
que vir entre aspas. Se fosse um campo do tipo data, o valor do critério teria que vir delimitado
pelo sinal #, por exemplo #01/01/1995#. Vamos trabalhar um pouco mais com a cláusula WHERE.
Exemplo 4
Altere a instrução SQL anterior para que sejam exibidos somente os pedidos para o Brasil ou
Alemanha como PaísDeDestino.
WHERE (((Pedidos.PaísDeDestino)=“Brasil” Or (Pedidos.PaísDeDestino)=”Alemanha”))
ORDER BY Frete;
Observe a utilização da cláusula OR ligando os dois critérios. Lembre que a cláusula OR

retorna um registro se o PaísDeDestino atender a um dos dois critérios, ou seja, se for Brasil
ou se for Alemanha, o registro será selecionado, isto é exatamente o que desejamos: todos os
pedidos para o Brasil ou para a Alemanha.
266
Exemplo 5
Altere a instrução SQL anterior, retirando o critério para PaísDeDestino. Adicione um critério
para NúmeroDoPedido maior do que 10500, retire a classificação do campo Frete a classifique
pelo campo NúmeroDoPedido.
WHERE NúmeroDoPedido>10500
ORDER BY NúmeroDoPedido;
Observe a cláusula WHERE utilizando o operador de comparação maior do que (>) e a

classificação através da cláusula ORDER BY no campo NúmeroDoPedido.
Podemos ver, através dos exemplos, que a linguagem SQL não é tão difícil como pode parecer
à primeira vista. Observe que a sintaxe da linguagem é bastante intuitiva e orientada a extração
de dados através das consultas.
Vamos continuar analisando alguns exemplos de aplicação da linguagem SQL com a utilização
de recursos mais avançados.
Exemplo 6
Alterar a instrução SQL anterior, e adicionar um critério de tal maneira que somente sejam
exibidos os pedidos para o ano de 1995. Tirar o critério do campo NúmeroDoPedido.
WHERE ((Year([DataDoPedido])=1995))
ORDER BY NúmeroDoPedido;
Observe a utilização da função Year (Ano) para extrairmos apenas o ano do campo DataDoPedido a
fim de especificarmos como critério o Ano=1995. Também a cláusula ORDER BY foi mantida,
classificando a listagem em ordem crescente pelo número do pedido. A utilização de funções junto
com os comando SQL nos fornece inúmeras possibilidades de refinamento em nossas consultas.
Exemplo 7
Alterar a instrução SQL anterior, para que sejam exibidos somente os pedidos no período de 01/
01/1995 até 31/07/1995 e que tenham como PaísDeDestino Brasil, Argentina, Alemanha ou Canadá.
WHERE (((DataDoPedido) Between #1/1/95# And #8/31/95#)
AND
((PaísDeDestino) In (“Brasil”,“Argentina”,“Alemanha”,”Canadá”)))
ORDER BY Pedidos.NúmeroDoPedido;
267
Observe a utilização de vários critérios em diferentes campos. Colocamos critérios nos campos
DataDoPedido e PaísDeDestino. Os critérios de dois ou mais campos são ligados através do
operador AND, indicando que um registro deve atender ambos os critérios para ser selecionado.
Também temos a utilização dos operadores Between (Entre) para selecionar as datas dentre
um determinado intervalo e do operador In (Em) para selecionar o campo PaísDeDestino que
seja igual a um dos valores apresentados na lista. Observe também que os valores de data
vem delimitados pelos marcadores #, conforme descrito anteriormente. A utilização dos
parênteses visa facilitar o entendimento da instrução e facilitar a avaliação da expressão.
IMPORTANTE
Algumas destas funcionalidades podem necessitar de pequenas alterações para funcionar em
nossas páginas ASP, conforme veremos mais adiante neste capítulo.
Exemplo 8
Criar uma instrução SQL que retorne os campos NúmeroDoPedido, DataDoPedido,
DataDeEntrega, Frete e PaísDeDestino da tabela Pedidos. Criar uma coluna adicional que calcula
o número de dias entre a DataDeEntrega e a DataDoPedido. Chamar esta coluna de Dias_Ped_Entr.
SELECT NúmeroDoPedido, DataDoPedido, DataDeEntrega, PaísDeDestino, Frete,
[DataDeEntrega]-[DataDoPedido] AS Dias_Ped_Entr FROM Pedidos
AND
((PaísDeDestino) In (“Brasil”,“Argentina”,“Alemanha”,“Canadá”)))
Veja que a coluna calculada [DataDeEntrega]-[DataDoPedido] está junto com a listagem dos
campos no início da instrução SELECT. Além disso foi utilizada a palavra AS para atribuir
um nome (apelido) para esta coluna calculada. Este nome é o que será utilizado para fazer
referência à coluna, no nosso código ASP.
Você também pode classificar a listagem em ordem crescente ou decrescente de um campo

calculado. Por exemplo, se você quisesse classificar a listagem do item anterior, em ordem
crescente, do número de dias entre a DataDeEntrega e a DataDoPedido, bastaria utilizar a
seguinte instrução SQL:
[DataDeEntrega]-[DataDoPedido] AS Dias_Ped_Entr
FROM Pedidos
AND
((PaísDeDestino) In (“Brasil”,“Argentina”,“Alemanha”,“Canadá”)))
ORDER BY [DataDeEntrega]-[DataDoPedido];
268
Exemplo 9
Alterar a instrução SQL anterior, eliminando os critérios para a DataDoPedido e para o
PaísDeDestino. Colocar um novo critério para PaísDeDestino, onde sejam exibidos apenas os
pedidos cujo PaísDeDestino tem a primeira letra na faixa de A até M. Utilize o operador Like.
[DataDeEntrega]-[DataDoPedido] AS Dias_Ped_Entr
FROM Pedidos
WHERE ((PaísDeDestino) Like “[A-M]%”))
ORDER BY PaísDeDestino;
Observe a utilização do operador Like (Como) como critério de pesquisa para esta consulta.
Nunca é demais salientar que a utilização das instruções SQL juntamente com as funções de
operadores como o Like, nos fornece um amplo conjunto de possibilidades. O caractere % é
utilizado como um caractere curinga. Por exemplo, se especificarmos o seguinte critério:
WHERE NomeDoCliente Like “João%”
serão retornados todos os registros para Clientes cujo nome inicia com João. O caractere
curinga % significa, em termos simples, “qualquer coisa”, ou seja, o critério especifica que o
nome inicie com João, não importando (qualquer coisa) o que vier depois.
IMPORTANTE
Aqui cabe um aviso importante para os usuários do Microsoft Access. No Microsoft Access, o
caractere curinga é o *, já na construção de páginas ASP, utilizamos como caractere curinga o
%, o qual também é utilizado no Microsoft SQL Server.
Até agora estivemos trabalhando com instruções que selecionam registros de uma única tabela.
Porém é bastante comum criarmos instruções SQL baseadas em duas ou mais tabelas. Quando
criamos instruções SQL que buscam dados em duas ou mais tabelas, dizemos que está sendo
feito um “Join” entre as duas tabelas. Normalmente este Join (ou ligação) é feito através de um
campo comum às duas tabelas. Por exemplo, NúmeroDoPedido na tabela Pedidos e
NúmeroDoPedido na tabela Detalhes do Pedido. Outro exemplo, CódigoDoCliente na tabela
Pedidos e CódigoDoCliente na tabela Clientes. Pode acontecer de termos consultas que
trabalham com três ou mais tabelas, neste caso teremos diversos Joins.
Agora passaremos e explorar na prática, através de exemplos, a construção de instruções

SQL que trabalham com duas ou mais tabelas.
269
Exemplo 10
Criar uma instrução SQL que selecione os seguintes campos:
➥ NúmeroDoPedido da tabela Pedidos.
➥ DataDoPedido da tabela Pedidos.
➥ PaísDeDestino da tabela Pedidos.
➥ Frete da tabela Pedidos.
➥ CódigoDoProduto, PreçoUnitário e quantidade da tabela DetalhesdoPedido.
Além disso, as tabelas Pedidos e DetalhesdoPedido estão relacionadas através do campo

NúmeroDoPedido, através de um relacionamento do tipo Um para Vários. Classificar a listagem
em ordem crescente do NúmeroDoPedido.
Para resolver este exemplo podemos utilizar a seguinte instrução SQL:

Pedidos.Frete, DetalhesdoPedido.CódigoDoProduto, DetalhesdoPedido.PreçoUnitário,
DetalhesdoPedido.Quantidade
FROM Pedidos
INNER JOIN
DetalhesdoPedido
ON Pedidos.NúmeroDoPedido=DetalhesdoPedido.NúmeroDoPedido
Primeiro devemos observar que, pelo fato de estarmos tratando com dados de duas tabelas,
estamos utilizando a nomenclatura completa, isto é, Nome_da_tabela.Nome_do_campo.
Observe a utilização da cláusula INNER JOIN, ligando as tabelas Pedidos e DetalhesdoPedido,

através do campo NúmeroDoPedido, conforme especificado na cláusula ON, onde temos o seguinte:
Observe que esta listagem irá trazer vários registros para cada pedido, tantos quantos forem
os itens de cada pedido.
E se, ao invés do CódigoDoProduto, nós quisermos que seja exibida a descrição do produto?
Em primeiro lugar, esta informação encontra-se na tabela Produtos, logo teremos que adicionar
a tabela à nossa consulta, a qual irá se ligar à tabela DetalhesDoPedido através do campo
CódigoDoProduto. Logo, teremos mais um Join.
Após adicionar a tabela Produtos e substituir o campo CódigoDoProduto pelo campo

NomeDoProduto, a nossa instrução SQL deve ficar conforme indicado no seguinte comando:
SELECT Pedidos.NúmeroDoPedido, Pedidos.DataDoPedido, Pedidos.PaísDeDestino, Pedidos.
Frete, Produtos.NomeDoProduto, DetalhesdoPedido.PreçoUnitário,
270
FROM Produtos
INNER JOIN (Pedidos INNER JOIN DetalhesdoPedido ON Pedidos.NúmeroDoPedido=Detalhesdo
Pedido.NúmeroDoPedido) ON Produtos.CódigoDoProduto=DetalhesdoPedido.CódigoDoProduto
Observe que neste caso temos um INNER JOIN dentro do outro. Dentro do parênteses é feita
a ligação entre as tabelas Pedidos e DetalhesdoPedido, através do campo NúmeroDoPedido, e
externamente é feita a ligação entre as tabelas Produtos e DetalhesdoPedido, através do campo
NúmeroDoPedido.
Podemos utilizar diversos níveis de INNER JOIN, embora esta não seja uma prática
recomendada, pois se aumentarmos muito os níveis de INNER JOIN, podemos ter pesquisas
mais lentas, em conseqüência do aumento da complexidade das mesmas. Até três ou quatro
níveis é considerado normal, acima disso é preciso repensar a maneira de construir a consulta.
Exemplo 11
Alterar a instrução SQL do item anterior para que somente sejam exibidos os pedidos para os
produtos cujo NomeDoProduto inicie com uma letra na faixa de A até J. Tirar a classificação
do campo NúmeroDoPedido e classificar em ordem crescente do campo NomeDoProduto.
Pedidos.Frete, Produtos.NomeDoProduto, DetalhesdoPedido.PreçoUnitário,
FROM Pedidos
INNER JOIN (Produtos INNER JOIN DetalhesdoPedido ON
Produtos.CódigoDoProduto=DetalhesdoPedido.CódigoDoProduto)
WHERE (((Produtos.NomeDoProduto) Like “[A-J]*”))
ORDER BY Produtos.NomeDoProduto;
Observe, além dos dois INNER JOIN, a utilização da cláusula WHERE com o operador Like
para especificar o critério desejado.
Até este momento estivemos construindo instruções SQL que executam consultas no banco
de dados. Especificamos quais campos serão exibidos, critérios de filtragem para estes campos
e uma ordem de classificação. A partir de agora aprenderemos a utilizar instruções SQL para
a construção de outros tipos de instruções SQL, as quais realizam alterações e inclusões em
tabelas de banco de dados.
271
A Instrução UPDATE
A instrução UPDATE é utilizada para alterar informações em um banco de dados. Podemos
criar um formulário onde o usuário pode alterar os seus dados cadastrais. Primeiro os dados
são recuperados a partir do banco de dados, em seguida as alterações são enviadas de volta
para o banco de dados, através de uma instrução UPDATE. Vamos estudar esta instrução
através de exemplos, assim como fizemos com a instrução SELECT.
Exemplo 1
Criar uma instrução SQL que aumenta o PreçoUnitário em 20 % na tabela DetalhesdoPedido,
devido a um ajuste na moeda e uma desvalorização em relação ao Dólar.
UPDATE DetalhesdoPedido
SET PreçoUnitário = PreçoUnitário*1.2;
Observe a simplicidade da instrução SQL. Utilizamos uma instrução UPDATE, seguida do

nome da tabela onde será feita a atualização. Em seguida uma instrução SET com a expressão
de atualização para aumentar em 20 % o PreçoUnitário.
Vamos alterar a instrução anterior, para incluir um critério na consulta de atualização.
Exemplo 2
Alterar a instrução SQL do item anterior para que somente sejam aumentados os registros
cujo PreçoUnitário for maior ou igual a R$ 20,00.
SET PreçoUnitário = PreçoUnitário*1.2
WHERE PreçoUnitário>=20;
Apenas foi adicionada uma cláusula WHERE, para atualizar apenas os registros cujo
PreçoUnitário seja maior ou igual a R$ 20,00.
Exemplo 3
Alterar a instrução SQL do exemplo anterior para que somente sejam aumentados os registros cujo
PreçoUnitário for maior ou igual a R$ 20,00 e cujo NúmeroDoPedido seja menor do que 10500.
SET PreçoUnitário = PreçoUnitário*1.2
WHERE (((PreçoUnitário)>=20)
AND
((NúmeroDoPedido)<10500));
272
Observe que utilizamos critérios em dois campos (PreçoUnitário e NúmeroDoPedido) e que

estes critérios estão ligados por um operador AND, o que significa que um registro, somente
será atualizado se ele atender aos dois critérios ao mesmo tempo (PreçoUnitário maior ou
igual a 20 e NúmeroDoPedido menor do que 10500). Se o registro atender a apenas uma das
condições, o mesmo não terá o seu PreçoUnitário atualizado.
Vamos refinar um pouco mais a nossa consulta de atualização. Vamos fazer com que somente
sejam atualizados os pedidos para o ano da DataDoPedido igual a 1995, e ainda iremos manter
os critérios adicionados até agora.
Exemplo 4
Alterar a instrução SQL do exemplo anterior para incluir um critério para que o ano da
DataDoPedido seja 1995. Você terá que incluir a tabela Pedidos, uma vez que o campo
DataDoPedido, encontra-se nesta tabela.
UPDATE Pedidos INNER JOIN DetalhesdoPedido
ON Pedidos.NúmeroDoPedido = DetalhesdoPedido.NúmeroDoPedido
SET DetalhesdoPedido.PreçoUnitário = PreçoUnitário*1.2
WHERE (((DetalhesdoPedido.PreçoUnitário)>=20)
AND
((DetalhesdoPedido.NúmeroDoPedido)<10500)
AND
(Year([DataDoPedido])=1995));
Temos diversos detalhes interessantes a observar nesta instrução SQL. Primeiro um INNER
JOIN relacionando as tabelas Pedidos e DetalhesdoPedido, através do campo NúmeroDoPedido.
Isso mostra que é perfeitamente possível utilizar um INNER JOIN dentro de uma consulta de
atualização. Segundo, temos a utilização da função Year para extrair apenas o ano do campo
DataDoPedido e compará-lo com o critério 1995.
Novamente, a utilização de operadores e funções nos fornece uma grande flexibilidade em

termos de construção de nossas consultas.
A Instrução INSERT
A instrução INSERT é utilizada para gravar registros em uma tabela de um banco de dados. Por
exemplo, quando o usuário preenche os dados de um formulário de cadastro e os envia para
uma página ASP, podemos utilizar a instrução INSERT para os inserir em um banco de dados.
Vamos analisar alguns exemplos.
273
Exemplo 1
Este exemplo cria um novo registro na tabela Funcionários:
INSERT INTO Funcionários (Nome, Sobrenome, Cargo) VALUES (‘Paulo’, ‘Braga’,
‘Estagiário’);
Esta instrução insere um registro na tabela Funcionários com os seguintes dados:

➥ Nome: Paulo
➥ Sobrenome: Braga
➥ Cargo: Estagiário
Exemplo 2
Este exemplo seleciona todos os estagiários de uma tabela Estagiários que tenham sido
contratados há mais de 30 dias e adiciona os registros selecionados à tabela Funcionários.
INSERT INTO Funcionários
SELECT Estagiários.* FROM Estagiários
WHERE DataDaContratação < Hoje() - 30;
Observe que utilizamos a função Hoje( ) para capturar a data do sistema e subtraímos 30,
para obter apenas os funcionários contratados a mais do que 30 dias.
A Instrução DELETE
A instrução DELETE é utilizada para excluir registros de um banco de dados. Vamos supor
que você tenha desenvolvido uma aplicação Web para agenda eletrônica, onde o usuário
pode cadastrar contatos, endereços, telefones e compromissos. Podemos criar uma página
ASP que permite ao usuário eliminar dados que não sejam mais necessários na agenda. Neste
caso podemos fazer uso da instrução DELETE. Vamos a um exemplo prático.
Exemplo 1
Criar uma instrução SQL que elimine todos os pedidos da tabela Pedidos cujo PaísDeDestino
seja a Alemanha.
DELETE Pedidos.PaísDeDestino
FROM Pedidos
WHERE (((Pedidos.PaísDeDestino)=“Alemanha”));
A instrução é tão simples, que praticamente dispensa comentários. A única recomendação

importante é que não devemos utilizar uma instrução DELETE, sem a utilização de uma
274
cláusula WHERE. Utilizar um DELETE sem uma cláusula WHERE significa que estaremos
eliminando todos os registros da tabela.
Agora que já revisamos os aspectos básicos relacionados a bancos de dados e à linguagem SQL,
chegou o momento de aprendermos a conectar nossas páginas ASP com bancos de dados.
Uma Visão Geral de ADO e OLE DB

A Microsoft vem há muito tempo desenvolvendo tecnologias que permitam acesso às mais
variadas fontes de dados, quer sejam dados estruturados em bancos de dados tradicionais,
como o Microsoft SQL Server, dados nos formatos mais tradicionais, como os armazenados
em Mainframes, até dados não estruturados, como mensagens de correio eletrônico e arquivos
com conteúdo multimídia, como sons e imagem. A expressão por trás deste esforço é conhecida
como “Acesso Universal aos Dados” ou UDA do inglês – Universal Data Access.
Porém, na tentativa de disponibilizar o Acesso Universal aos Dados, muitas tecnologias foram
criadas, causando uma certa confusão e até desconforto para quem trabalha com desenvolvimento
de aplicações. Isso porque, a cada nova tecnologia anunciada, um novo ciclo de aprendizado se
inicia, sem contar que muitas vezes a comunicação entre as diferentes tecnologias não é exatamente
a esperada. Neste mundo de tecnologias já nos deparamos com siglas como:
➥ DAO – Data Access Objects.
➥ RDS – Remote Data Access.
➥ ADO – Activex Data Object.
➥ ODBC – Open Database Conectivity.
➥ OLE DB.
É normal que o desenvolvedor fique um pouco confuso com esta “sopa de letrinhas”. Mais
importante do que decorar o significado de cada sigla é entender a tecnologia que fornece
acesso aos dados e saber utilizá-las corretamente. Hoje, a tecnologia mais utilizada, e
recomendada pela Microsoft, é a dobradinha ADO/OLE DB. A utilização de ODBC é bastante
forte e deve se manter por um bom período. Por isso, analisaremos estas duas opções neste
capítulo, e muitas vezes estaremos utilizando as duas ao mesmo tempo; mas isto será mais
adiante, agora vamos procurar entender um pouco melhor estas tecnologias.
Um Pouco Sobre ODBC – Open Database Conectivity

ODBC é um padrão da indústria de informática para acesso a bancos de dados estruturados.
Um banco de dados estruturado utiliza o tradicional modelo Relacional, onde temos tabelas
275
e relacionamentos entre tabelas. São exemplos de bancos de dados estruturados: o Microsoft

SQL Server, Oracle, Microsoft Access, Sybase, DB2 da IBM, etc.
ODBC é uma interface que permite que os aplicativos acessem qualquer base de dados para
a qual existe um driver ODBC. Utilizando ODBC, podemos criar páginas ASP que acessem
dados para os quais existam drives ODBC, de uma maneira simples e rápida.
Com a utilização de ODBC, podemos criar aplicações que se tornam independentes do sistema
de banco de dados que está sendo utilizado. Por exemplo, desenvolvemos uma aplicação para
acessar uma fonte de dados ODBC. A fonte de dados ODBC está ligada a um banco de dados do
Microsoft Access. Em determinado momento resolvemos migrar do Microsoft Access para o
Microsoft SQL Server. Sem problemas. Basta alterar nossa fonte de dados ODBC para que a
mesma passe a referenciar o banco de dados no Microsoft SQL Server e pronto! A nossa aplicação
passa a utilizar a nova fonte de dados de maneira transparente, através do driver ODBC.
Na Figura 5.13, temos uma visão geral do acesso aos dados utilizando ODBC.
Aplicação Web
Gerenciador ODBC
Driver ODBC Driver ODBC Driver ODBC

SQL Server Microsoft Access Oracle
Figura 5.13: ODBC para acesso a dados.
Para que uma fonte ODBC possa ser utilizada a mesma precisa ser previamente criada,
utilizando-se o Gerenciador ODBC, o qual é acessível através das Ferramentas administrativas
do menu Programas. Agora aprenderemos a criar fontes de dados ODBC. Ao desenvolver o
aplicativo, o desenvolvedor fará referência a fonte ODBC criada. A título de exemplo, iremos
criar duas fontes, uma para um banco de dados Microsoft Access 97 e outra para um banco
de dados Microsoft SQL Server 2000 – Beta 2.
Criando uma Fonte ODBC Para um Banco de Dados do Microsoft Access 97

Vamos criar uma fonte para um banco de dados do Microsoft Access 97. Utilizaremos uma
base de exemplo que já vem com o Microsoft Access 97 – nwind.mdb. No nosso exemplo esta
fonte estará localizada em C:\Meus documentos.
276
IMPORTANTE
Dependendo da versão do ODBC instalado em seu computador, as telas apresentadas podem
ser um pouco diferentes das aqui apresentadas.
Para criar uma fonte ODBC chamada nwind:

1. Abra o Gerenciador de fontes ODBC (Iniciar/Programas/Ferramentas administrativas/
Fontes da dados (ODBC).
2. Surge a janela indicada na Figura 5.14.
Figura 5.14: O Gerenciador de fontes ODBC.
3. Uma fonte de dados é chamada de DSN – Data Source Name, a qual pode ser de três tipos:
➥ User DSN
➥ System DSN
➥ File DSN
No nosso caso estaremos trabalhando, sempre, com System DSN.
277
NOTA
Para maiores informações sobre os diferentes tipos de DSN consulte o site http://
msdn.microsoft.com.
4. Dê um clique na guia System DSN.

Figura 5.15: Criando uma fonte do tipo System DSN.
6. Dê um clique no botão Add, para criar uma nova fonte ODBC.

7. Surge uma janela perguntando qual o tipo de banco de dados que você deseja acessar.
Selecione Drive do Microsoft Access (*.mdb), conforme indicado na Figura 5.16.
278
Figura 5.16: Selecionando o banco de dados a ser usado.
8. Dê um clique no botão Concluir. É aberta a janela Configurar ODBC para Microsoft

Access, conforme indicado na Figura 5.17.
Figura 5.17: Definições para a fonte ODBC para o Microsoft Access.
9. Nesta janela devemos fornecer diversas informações, tais como o nome para a fonte
ODBC, a localização do arquivo .mdb, etc.
10. No campo Nome da fonte de dados, digite nwind.
279
11. No campo Descrição digite Fonte de dados Access.

12. A janela Configurar ODBC para Microsoft Access deve estar conforme indicado na
Figura 5.18.
Figura 5.18: Definindo a fonte ODBC.
14. Dê um clique no botão Selecionar. Utilizamos este botão para selecionar o arquivo
.mdb que será relacionado à fonte ODBC que está sendo criada.
15. Surge a janela Selecionar banco de dados.
16. Navegue até a pasta onde está o arquivo .mdb. No nosso exemplo vamos navegar até a
pasta Meus documentos do drive C:, e dentro da pasta Meus documentos vou selecionar
nwind.mdb, conforme indicado na Figura 5.19.
17. Dê um clique no botão OK e você estará de volta à janela Configurar ODBC para
Microsoft Access.
18. Dê um clique no botão OK para fechar esta janela.
19. Você estará de volta à janela do Gerenciador de fontes ODBC, com a fonte ODBC nwind
já criada, conforme indicado pela Figura 5.20.
280
Figura 5.19: Selecionando o arquivo C:\Meus documentos\nwind.mdb.
Figura 5.20: Fonte ODBC nwind já criada.
NOTA
Estaremos utilizando esta fonte ODBC em diversos exemplos deste livro.
281
Criando uma Fonte ODBC Para um Banco de Dados do Microsoft SQL Server 2000
Vamos criar uma fonte para um banco de dados do Microsoft SQL Server 2000. Utilizaremos
o banco de dados de exemplo que já vem com o Microsoft SQL Server 2000 – pubs. No nosso
exemplo, o nome do servidor SQL é SERVIDOR. Caso você esteja trabalhando em um servidor
com um nome diferente, utilize o nome do servidor no qual você está trabalhando.
IMPORTANTE
Dependendo da versão do ODBC instalado em seu computador, as telas apresentadas podem
ser um pouco diferentes das aqui apresentadas.
Para criar uma fonte ODBC chamada sqlpubs:

1. Abra o Gerenciador de fontes ODBC (Iniciar/Programas/Ferramentas administrativas/
Fontes da dados (ODBC).
2. Dê um clique na guia System DSN.
3. Dê um clique no botão Add para criar uma nova fonte ODBC.
4. Surge uma janela perguntando qual o tipo de banco de dados que você deseja acessar.
Selecione SQL Server, conforme indicado na Figura 5.21.
Figura 5.21: Definindo uma fonte para o SQL Server.
282
5. Dê um clique no botão Concluir. É aberta a janela Create a New Data Source to SQL
Server, conforme indicado na Figura 5.22.
Figura 5.22: Definições para a fonte ODBC para o SQL Server.
6. Nesta janela devemos fornecer diversas informações, tais como o nome para a fonte
ODBC, o nome do servidor, etc.
7. No campo Name digite sqlpubs.
8. No campo Description digite Fonte de dados SQL Server.
9. Na lista Server, selecione o nome do Servidor SQL a ser utilizado.
10. A janela Create a New Data Source to SQL Server deve estar conforme indicado na
Figura 5.23.
11. Dê um clique no botão Avançar para ir para a próxima etapa.
12. Aceite as opções selecionadas e dê um clique no botão Avançar, indo para a terceira etapa.
14. Em um servidor SQL Server podem existir diversos bancos de dados. Neste caso
precisamos definir a qual banco de dados a nossa fonte ODBC irá conectar-se.
15. Marque a opção Change the default database to.
16. Na lista abaixo desta opção selecione pubs, conforme indicado na Figura 5.25.
283
Figura 5.23: Definições para a fonte ODBC.
Figura 5.24: Definindo a qual banco de dados a fonte ODBC irá conectar-se.
284
Figura 5.25: Fazendo conexão com o Banco de dados pubs.
17. Dê um clique no botão Avançar para ir para a última etapa.

18. Nesta etapa podemos definir diversas opções, tais como:
➥ O idioma para as mensagens do SQL Server.
➥ Se devemos ou não utilizar criptografia dos dados para aumentar a segurança.
➥ Se devemos utilizar as configurações regionais tais como hora, data e formato para
números em geral e para valores monetários.
19. Selecione as opções conforme indicado na Figura 5.26.
Figura 5.26: Finalizando a configuração da fonte ODBC.
285
20. Dê um clique no botão Concluir para finalizar a criação da fonte ODBC.

21. Surge a janela ODBC Microsoft SQL Server Setup, a qual informa as diversas opções
selecionadas, conforme indicado na Figura 5.27.
Figura 5.27: Resumo das opções selecionadas para a fonte ODBC.
22. Nesta janela podemos clicar no botão Test Data Source..., para verificar se a conexão
com o banco de dados está OK.
23. Dê um clique neste botão.
24. Deve surgir uma janela indicando que o teste foi realizado com sucesso, conforme
25. Dê um clique em OK para fechar a janela de teste.
26. Dê um clique em OK para fechar a janela de resumo.
27. Você estará de volta à janela do Gerenciador de fontes ODBC, com a fonte ODBC sqlpubs
já criada, conforme indicado pela Figura 5.29.
28. Dê um clique em OK para fechar o Gerenciador de fontes ODBC.
NOTA
Estaremos utilizando esta fonte ODBC em diversos exemplos deste livro.
286
Figura 5.28: Teste indicando que a conexão está OK.
Figura 5.29: Fonte ODBC sqlpubs já criada.
287
Agora que já sabemos um pouco sobre ODBC vamos falar sobre OLE DB.
Um Pouco Sobre OLE DB e ADO

OLE DB é uma nova tecnologia, baseada na tecnologia COM da Microsoft, para acesso a bases
de dados. Uma das grandes novidades trazidas pela tecnologia OLE DB é a possibilidade de
acesso a bases não estruturadas, como por exemplo arquivos de mensagens de correio
eletrônico, arquivos de texto, e bancos de dados de documentos como o Lotus Notes ou o
Microsoft Exchange. Além disso, a tecnologia OLE DB foi construída tendo a performance
como uma de suas diretivas.
Diferente do ODBC, não existe um driver OLE DB para cada fonte de dado. Na tecnologia
OLE DB, o conector para uma fonte de dados é chamado de OLE DB Provider. Por exemplo,
existe um OLE DB Provider para Microsoft Access, um para Microsoft SQL Server, um OLE
DB Provider para mensagens de correio do Microsoft Exchange, um para bancos de dados
Oracle e assim por diante.
OLE DB é a tecnologia preferencial, segundo a Microsoft, para acesso a dados estruturados ou

não. Em diversos documentos e manuais oficiais da Microsoft, existem referências a utilização
de OLE DB como a tecnologia a ser utilizada para acesso a qualquer fonte de dados.
Muitos usuários pensam que OLE DB veio para substituir completamente o padrão ODBC. Na
verdade, isto pode até acontecer daqui a algum tempo. Porém, na prática, existe um OLE DB
Provider para ODBC. Com isso, utilizando OLE DB podemos ter acesso a qualquer fonte de
dados ODBC. O ODBC funciona como se fosse um subconjunto de OLE DB, uma vez que OLE
DB fornece acesso a todas as fontes de dados ODBC (utilizando o OLE DP Provider para ODBC),
mais as fontes de dados não estruturadas para as quais existem OLE DB Provider disponíveis.
Na Figura 5.30, temos uma visão geral do acesso a fontes de dados, utilizando OLE DB.
Veja que é possível o acesso a qualquer fonte de dados ODBC. Também é possível o acesso
sem a utilização de ODBC, utilizando-se o OLE DB Provider adequado para cada situação.
Quanto estamos utilizando OLE DB temos a figura da fonte de dados e do consumidor de
dados. Um OLE DB Provider é a fonte de dados, já o aplicativo é o consumidor de dados. No
próximo item criaremos páginas ASP que acessam dados de um arquivo do Microsoft Access.
Com isso, nossas páginas ASP atuarão como consumidores de dados.
Porém, OLE DB, na verdade, é uma API (Application Programming Interface) baseada na
tecnologia COM da Microsoft. Utilizar diretamente uma API é algo que requer conhecimentos
avançados de programação, tais como o domínio das linguagens C e C++. Embora seja factível
utilizar diretamente OLE DB, é muito pouco produtivo, além de exigir profissionais com
conhecimentos avançados de programação.
288
OLE DB
OLE DB Providers
Jet Jet Exchange

Server Gerenciador ODBC
Provider Provider Provider

Drivers ODBC
Microsoft Microsoft Microsoft Microsoft Microsoft ORACLE

Access SQL Exchange SQL Access
Server Server Server
Fontes de dados: Estruturadas e Não estruturadas.
Figura 5.30: Acessando fontes de dados com OLE DB.
Para solucionar o problema de utilização direta de OLE DB foi criada uma camada adicional
de programação, a qual é conhecida como ADO – ActiveX Data Objects. Com a utilização de
ADO temos acesso a uma série de objetos e seus métodos. A utilização dos objetos ADO é
bem mais simples do que a utilização direta da API OLE DB. Com a utilização de ADO, a
produtividade do desenvolvedor aumenta bastante, pois seus objetos são de fácil aprendizagem
e utilização, principalmente para quem já programa em Visual Basic. Quando utilizamos um
objeto ADO, o próprio objeto sabe como converter a chamada feita em ADO, para comandos
que a API OLE DB entende e é capaz de executar.
Neste livro, sempre que formos fazer acesso a bases de dados, estaremos utilizando objetos
ADO. Por exemplo, quando estabelecemos uma conexão com um banco de dados, estaremos
utilizando o objeto Connection; para extrair informações de uma tabela estaremos utilizando
um objeto chamado Recordset e assim por diante.
Na Figura 5.31, representamos o acesso a dados através de ADO, o qual se comunica com a
API OLE DB.
IMPORTANTE
Com isso, terminamos nosso estudo sobre os aspectos teóricos necessários ao entendimento da
conexão de páginas ASP com bancos de dados. A partir do próximo item estaremos aprendendo,
na prática, a escrever páginas ASP que fazem conexão com banco de dados. Grande parte do
nosso trabalho será estudar os objetos, métodos, propriedades e eventos da tecnologia ADO.
Nunca é demais salientar que ADO é a forma de acesso a dados indicada pela Microsoft. No
289
site msdn.microsoft.com existem diversos documentos que ensinam como migrar de outras
tecnologias mais antigas (como DAO, por exemplo), para a tecnologia ADO/OLE DB. Além
disso, a Microsoft vem anunciando que as tecnologias mais antigas (como DAO e RDO) serão
descontinuadas, isto é, serão substituídas por ADO.
ADO
OLE DB
OLE DB Providers
Exchange
Jet Jet Server Gerenciador ODBC

Drivers ODBC
Microsoft Microsoft Microsoft

Microsoft Microsoft ORACLE
SQL Exchange SQL
Access Access
Figura 5.31: Acessando fontes de dados com ADO/OLE DB.
Outro ponto importante a salientar é que ADO não é somente para uso em aplicações Web.
Podemos utilizar ADO para qualquer aplicação, como as tradicionais aplicações Cliente/
Servidor de duas camadas desenvolvidas em Visual Basic ou qualquer outra linguagem com
suporte a ADO/OLE DB.
Uma Visão Geral do Modelo de Objetos ADO

Neste item será apresentada uma visão geral do Modelo de Objetos do ADO. Nos demais itens
deste capítulo e do próximo capítulo iremos aprender a utilizar diversos objetos deste modelo,
à medida que forem apresentados exemplos práticos. Na Figura 5.32 temos uma visão geral
dos principais objetos do Modelo de Objetos ADO.
290
Connection
Errors Error
Properties Property
Command
Parameters Parameter
Properties Property
Recordset
Fields Field
Properties Property
Record
Fields Field
Stream
Figura 5.32: O Modelo de Objetos ADO.
Abaixo uma descrição resumida dos principais objetos:

➥ Connection: Este objeto é utilizado para estabelecer uma conexão com uma fonte de
dados, seja através de um Driver ODBC ou de um OLE DB Provider. O primeiro passo
para acessar uma fonte de dados é estabelecer uma conexão com esta fonte. Uma vez
estabelecida esta conexão, podemos utilizar outros objetos para extrair, alterar, inserir
dados ou qualquer outra operação que seja permitida pela fonte de dados. Quando
estabelecemos a conexão, também podemos passar informações de autenticação, tais
como o nome do usuário e senha, de tal forma que seja dado acesso aos dados de
acordo com as permissões de cada usuário. Por exemplo, podem existir usuários que
devem ter permissão somente para leitura dos dados; já outros usuários podem
necessitar de permissão para leitura e alteração.
Um detalhe importante a ser salientado é que a criação de uma conexão com um banco de
dados, através da utilização do objeto Connection, não é obrigatória. Podemos utilizar
diretamente os objetos Command, Recordset e Record, pois cada vez que utilizarmos um
destes objetos, uma conexão será automaticamente criada. Porém, pode ser mais prática a
criação explícita de uma conexão, principalmente em situações em que muitos comandos
são executados contra a fonte de dados. Neste caso a criação de uma conexão, com a utilização
do objeto Connection, pode melhorar o desempenho da aplicação Web.
291
➥ Command: Este objeto pode ser utilizado para executar um comando (uma instrução
SQL por exemplo) em uma fonte de dados. Podemos utilizar este objeto para efetuar
uma consulta em um banco de dados e retornar o resultado em um objeto Recordset.
Também podemos utilizar este objeto para alterar a estrutura de um banco de dados,
desde que tenhamos permissão para isso.
➥ Recordset: Este objeto representa um conjunto de registros obtidos a partir de um
banco de dados. Este conjunto de registros pode, por exemplo, ter sido retornado devido
a uma operação do objeto Command. Todo objeto Recordset é formado por linhas e
colunas, como se fosse uma tabela de um banco de dados.
➥ Record: Este objeto representa uma única linha (ou seja, um único registro) de um
objeto Recordset.
➥ Stream: Este objeto é utilizado para manipular dados não estruturados, normalmente
organizados em formas de árvores hierárquicas. Pode ser utilizado para acessar
informações de um sistema de arquivos ou um sistema de correio eletrônico.
Cada um destes objetos apresenta uma série de métodos, propriedades, eventos e coleções.
Iniciaremos o estudo de cada objeto com uma apresentação rápida de cada um destes
elementos. À medida que formos utilizando estes métodos, propriedades, eventos e coleções,
apresentaremos maiores detalhes sobre cada um deles.
IMPORTANTE
Na maioria das situações utilizamos os objetos Connection e Recordset juntos em uma mesma
página. No próximo item iremos estudar o objeto Connection, porém já fazendo uso do objeto
Recordset nos exemplos práticos. No item a seguir será apresentado apenas o básico sobre o
objeto Recordset. Na parte final do capítulo e nos próximos capítulos estudaremos maiores
detalhes sobre o objeto Recordset.
O Objeto Connection
Conforme descrevemos anteriormente, o primeiro passo para conectar uma página ASP com
uma fonte de dados, é estabelecer uma “conexão” com a fonte de dados. Para estabelecermos
esta conexão utilizamos o objeto Connection.
Ao estabelecermos uma conexão estamos informando para a nossa página ASP uma série de
detalhes que a mesma necessita para poder acessar os dados. Utilizando o objeto Connection
podemos definir qual o OLE DB Provider a ser utilizado, qual a fonte de dados e demais
informações, tais como nome de usuário e senha, caso sejam necessários.
Na Tabela 5.2 temos uma breve descrição dos principais métodos do objeto Connection.
292
Tabela 5.2 Os principais métodos do objeto Connection.
Método Descrição
BeginTrans Inicia uma nova transação. Falaremos mais sobre Transações
no Capítulo 12.
Cancel Cancela a execução assíncrona dos comandos Execute e
Open.
Close Fecha uma conexão que esteja aberta e quaisquer objetos
que sejam dependentes desta conexão.
CommitTrans Salva as alterações que foram feitas e encerra a transação
corrente.
Execute Executa um consulta, um comando ou uma instrução SQL
e retorna um objeto do tipo Recordset. Pode, por exemplo,
ser utilizado para obter uma listagem de vendas de
um banco de dados, ou qualquer outra listagem podendo
ser obtida a partir de uma instrução SQL.
Open Abre uma conexão com uma fonte de dados. Feito isso,
comandos podem ser executados através desta conexão.
OpenSchema Utilizado para obter informação sobre a estrutura de uma
fonte de dados, tais como as definições de tabelas e
relacionamentos de um banco de dados relacional.
RoolbackTrans Cancela quaisquer alterações que tenham sido feitas pela
transação e finaliza a transação.
Na Tabela 5.3 temos uma breve descrição das principais propriedades do objeto Connection.
Tabela 5.3 As principais propriedades do objeto Connection.
Propriedade Descrição
Attributes Indica uma ou mais características de um objeto
Connection. Retorna um valor Long.
CommandTimeout Indica o tempo máximo de execução de um comando.
Caso o comando demore mais do que o tempo definido
nesta propriedade, será gerado um erro. O valor padrão
é 30 segundos.
293
ConnectionString Contém todas as informações utilizadas para
estabelecer a conexão com a fonte de dados.
ConnectionTimeout Indica o tempo máximo para tentativa de estabelecer
uma conexão. Caso a conexão não seja estabelecida
em um tempo menor ou igual ao definido em
ConnectionTimeout, a conexão será encerrada e um
erro gerado. Por padrão este valor é definido em 15
segundos.
CursorLocation Define ou retorna a localização do cursor, se no
servidor ou no cliente. Iremos falar um pouco mais
sobre cursores no próximo capítulo.
DefaultDatabase Indica qual o banco de dados padrão para um objeto
Connection. Por exemplo, quando estamos conectando
com um servidor SQL precisamos definir qual a base
de dados que será acessada. Fazemos isso definindo
qual o banco de dados padrão, através da utilização
da propriedade DefaultDatabase.
Errors Contém todos os objetos Error criados em resposta a
falhas envolvendo o provedor de dados. Falaremos
mais sobre o objeto Error no Capítulo 11.
IsolationLevel Define o nível de isolamento das transações para um
objeto Connection. Voltaremos a este assunto no
Capítulo 12.
Mode Indica as permissões disponíveis para modificação de
dados através de uma conexão.
Properties Contém todos os objetos Property de um determinado
objeto Connection.
Provider Retorna o nome do Provedor para uma determinada
conexão.
State Indica se a conexão está aberta ou fechada.
Version Retorna a versão da tecnologia ADO. Por exemplo,
2.0 ou 2.5.
294
Na Tabela 5.4 temos uma breve descrição dos principais eventos do objeto Connection.
Tabela 5.4 Os principais eventos do objeto Connection.
Evento Descrição
BeginTransComplete Ocorre após o término de uma operação
BeginTrans.
CommitTransComplete Ocorre após o término de uma operação
CommitTrans.
ConnectComplete Ocorre após o início de uma conexão.
Disconnect Ocorre após o término de uma conexão.
ExecuteComplete Ocorre após o término da execução de um comando.
InfoMessage Ocorre sempre que a operação ConnectionEvent
ocorre com sucesso e uma informação adicional
é retornada pelo provedor de dados.
RollBackTransComplete Ocorre após a execução da operação RollbackTrans.
WillConnect Ocorre antes do início de uma conexão.
WillExecute Ocorre antes que um comando pendente seja
executado em uma determinada conexão.
O Primeiro Exemplo
Neste item vamos utilizar o conhecimento que já temos para criar uma página ASP que conecta
o banco de dados Nwind e mostra uma listagem de clientes com as seguintes informações:
➥ Código do Cliente (CodigoDoCliente)
➥ Cargo (Cargo)
➥ Endereço (Endereco)
➥ Telefone (Fone)
NOTA
O nome entre parênteses é o nome do campo na tabela clientes do banco de dados Nwind.
Caso você esteja utilizando outro banco de dados ou outra tabela, utilize os nomes de campo
adequados. O banco de dados Nwind é um banco de exemplo que é instalado juntamente com
o Microsoft Access.
295
Na Figura 5.33 podemos ver a estrutura da tabela Clientes que está sendo utilizada no nosso
exemplo.
Figura 5.33: A tabela Clientes do banco de dados Nwind.
Pode acontecer que a estrutura do Nwind esteja em inglês. Os nomes dos campos aparecem
com CustomerID, City, Address e assim por diante. Utilize os nomes conforme os mesmos se
apresentam na sua cópia do banco de dados Nwind.mdb.
Na Listagem 5.1 apresentamos uma página ASP que faz a conexão com o banco de dados Nwind
e exibe uma listagem de clientes. Logo após explicaremos cada um dos comandos utilizados.
Listagem 5.1 – Uma página ASP que conecta com o banco de dados Nwind – clientes.asp.
2 <HTML>
3 <HEAD>
4 <TITLE>Listagem de Clientes</TITLE>
5 </HEAD>
6 <BODY>
7 <H1>
8 <FONT color=navy>Clientes da Empresa ABC Ltda.</FONT>
9 </H1>
10 <%
11 ‘O Primeiro passo é criar a conexão com o banco de dados

12 ‘Para isto crio um objeto do tipo Connection
296
13 ‘Cria um objeto do tipo ADODB.Connection
14 Set conn = Server.CreateObject(“ADODB.Connection”)
15 ‘Agora abro uma conexão com a fonte ODBC “nwind”

16 ‘criada anteriormente.
17 conn.Open “nwind”
18 ‘O próximo passo é criar uma instrução SQL

19 ‘a qual é utilizada para criar a listagem de clientes.
20 inst_sql=“SELECT Clientes.CodigoCliente, Clientes.Cargo, Clientes.Endereco,
Clientes.Fone FROM Clientes”
21 ‘Esta instrução SQL retorna os campos CodigoCliente, Cargo,

22 ‘Endereco e Fone, da tabela Clientes.
23 ‘Agora criamos um objeto RecordSet.

24 ‘Este objeto irá executar a instrução SQL e
25 ‘receber o resultado da consulta.
26 Set Clientes = Server.CreateObject(“ADODB.Recordset”)
27 ‘Agora executamos a instrução SQL

28 ‘retornando os registros da tabela Clientes.
29 Clientes.Open inst_sql, conn, 3, 3
30 ‘Os dois últimos parâmetros serão discutidos

31 ‘no próximo capítulo.
32 ‘Neste ponto já tenho todos os registros retornados

33 ‘pela instrução SQL. Estes registros estão armazenados
34 ‘no objeto Clientes, que é um objeto do tipo Recordset.
35 ‘Agora passo a montar a página que será retornada para o

36 ‘navegador do cliente. Vamos montar uma tabela com o
37 ‘resultado da consulta.
38 %>
297
39 <P>
40 <HR>
41 <TABLE bgColor=gray border=1 borderColor=navy cellPadding=1 cellSpacing=1

width=“100%”>
42 <TR>
43 <TD align=middle bgColor=gray>Código</TD>
44 <TD align=middle bgColor=gray>Cargo</TD>
45 <TD align=middle bgColor=gray>Endereço</TD>
46 <TD align=middle bgColor=gray>Fone</TD>
47 </TR>
48 <%
49 ‘Inicio um Loop para percorrer todos os registros

50 ‘do RecordSet Clientes, exibindo um registro em
51 ‘cada linha da tabela.
52 Do Until Clientes.eof %>
53 <TR>
54 <TD align=middle bgColor=gray><%=Clientes.Fields(“CodigoCliente”)%></TD>
55 <TD align=middle bgColor=gray><%=Clientes.Fields(“Cargo”)%></TD>
56 <TD align=middle bgColor=gray><%=Clientes.Fields(“Endereco”)%></TD>
57 <TD align=middle bgColor=gray><%=Clientes.Fields(“Fone”)%></TD>
58 </TR>
59 <%
60 Clientes.MoveNext
61 Loop %>
62 </TABLE>
63 </P>
64 <HR>
65 </BODY>
66 </HTML>
298
Ao carregar esta página no Internet Explorer, o usuário recebe uma listagem conforme indicado
na Figura 5.34.
Figura 5.34: A listagem de clientes do banco de dados Nwind.
Antes de comentarmos esta listagem gostaria de salientar a natureza dinâmica das páginas
criadas com ASP. Neste exemplo, qualquer alteração que seja feita na tabela Clientes, será
exibida na listagem de clientes, na próxima vez que o usuário carregar a página Clientes.asp.
Isto acontece porque a listagem é montada, a partir do banco de dados, cada vez que a página
é carregada. Com isso ao carregar a página, todos os dados existentes na tabela Clientes serão
exibidos. Por isso que dizemos que a página é criada dinamicamente, ou seja, cada vez que a
página é solicitada, o código ASP estabelece a conexão com o banco de dados, solicita a
listagem de clientes e apresenta a listagem no formato de uma tabela, conforme definimos.
Agora vamos às explicações a respeito do código da Listagem 5.1. Embora existam diversos
comentários na própria listagem, cabe aqui alguns esclarecimentos. Vamos detalhar diversos
trechos de código desta listagem, pois estaremos utilizando estas técnicas ao longo do livro.
299
➥ Trecho 1: Considere o seguinte trecho de código:

14 Set conn = Server.CreateObject(“ADODB.Connection”)
Esta linha cria um objeto Connection chamado conn. Poderíamos utilizar qualquer nome
válido para este objeto. Um ponto importante a salientar é a utilização da instrução Set.
Sempre que formos criar um objeto (Connection, Recordset, etc.), devemos usar a instrução
Set. Se não utilizarmos esta instrução na criação de objetos, obteremos um erro na hora de
carregar a página.
Também é importante observarmos o seguinte:

Server.CreateObject(“ADODB.Connection”)
Este código cria um objeto no servidor, que é do tipo ADODB.Connection, ou seja, uma conexão
ADO para banco de dados.
Após a execução deste comando, um objeto Connection foi criado, porém o mesmo ainda não
faz referência a nenhum banco de dados específico.
➥ Trecho 2: Considere o seguinte trecho de código:
Na linha 17 estou associando a conexão conn com uma fonte ODBC nwind. Lembrando que
esta fonte ODBC foi criada previamente. Caso você esteja utilizando uma fonte ODBC diferente,
utilize o nome adequado. Esta associação é feita através do método Open, do objeto Connection.
A partir deste momento, a minha conexão “conn” está associada ao banco de dados Nwind,
conforme definido pela fonte ODBC nwind.
Uma vez estabelecida a conexão é hora de recuperar dados, isto é, registros, a partir do banco
de dados. Isto é feito pelo seguinte trecho de código:
➥ Trecho 3: Considere o seguinte trecho de código.
20 inst_sql=“SELECT Clientes.CodigoCliente, Clientes.Cargo,
Clientes.Endereco, Clientes.Fone FROM Clientes”

22 ‘Endereco e Fone, da tabela Clientes.

300

28 ‘retornando os registros da tabela Clientes.

Na linha 20, criamos uma variável chamada inst_sql, a qual contém a instrução SQL que será
executada no banco de dados Nwind. Observe que é uma instrução SQL bastante simples, a
qual, basicamente, seleciona os campos CodigoCliente, Cargo, Endereco e Fone da tabela
Clientes do banco de dados Nwind.
Uma vez definida a instrução SQL, partimos para a criação de um objeto RecordSet. A criação
do objeto RecordSet, chamado Clientes, é feita na linha 26. Poderíamos ter escolhido qualquer
nome para este objeto. Observe a utilização da instrução Set. Como estamos criando um
objeto (do tipo RecordSet), devemos utilizar a instrução Set.
Agora devemos executar a instrução SQL para que o objeto Recordset contenha os registros
retornados pela instrução. Isto é feito pelo seguinte código:
Neste caso utilizamos o método Open do objeto RecordSet Clientes. O primeiro parâmetro é
a instrução SQL a ser utilizada – inst_sql. O segundo parâmetro é o nome da conexão a ser
utilizada – conn. O terceiro e quatro parâmetros definem comportamentos para o objeto
RecordSet, tais como se é possível mover-se para frente e para trás, avançando e voltando
pelos registros, se os registros retornados são apenas para leitura ou para leitura e alterações
e assim por diante. Estudaremos estas opções no próximo capítulo.
Bem, neste momento já temos um objeto RecordSet chamado Clientes, o qual possui uma
série de registros obtidos a partir da tabela Clientes do banco de dados Nwind. Cada registro
possui quatro campos, conforme foi definido pela nossa instrução SQL que somente retorna
os campos CodigoCliente, Cargo, Endereco e Fone.
➥ Trecho 4: Considere o seguinte trecho de código.
41 <TABLE bgColor=gray border=1 borderColor=navy cellPadding=1
cellSpacing=1
width=“100%”>
42 <TR>
301

47 </TR>
53 <TR>
54 <TD align=middle bgColor=gray><%=Clientes.Fields
(“CodigoCliente”)%></TD>
56 <TD align=middle bgColor=gray><%=Clientes.Fields(“Endereco”)%></
TD>
58 </TR>
59 <%
61 Loop %>
62 </TABLE>
Uma vez que o RecordSet Clientes foi criado com sucesso, é hora de criarmos uma tabela que
exibe os dados do objeto RecordSet. Começamos criando a primeira linha da tabela, a qual irá
conter o título das colunas. Isto é feito pelo seguinte código:
width=“100%”>
42 <TR>
47 </TR>
Observe que para criar o cabeçalho da tabela, utilizamos código HTML puro. Veja que estamos
criando uma tabela com quatro colunas. Vamos exibir um registro por linha, como cada registro
possui quatro campos, precisamos de uma tabela com quatro colunas. Esta tabela terá tantas
linhas quantos forem os registros do objeto Clientes.
A construção do corpo da tabela é feita com o seguinte trecho de código:

53 <TR>
302

58 </TR>
59 <%
61 Loop %>
62 </TABLE>
Na linha 52, iniciamos um laço Do Until Condição... Loop. Como condição utilizamos a propriedade
Eof do objeto Clientes. O laço continua sendo executado até que a condição Clientes.eof se torne
Verdadeira. Esta condição somente irá tornar-se Verdadeira quando o indicador de registro já
estiver além do último registro. Com isso, o laço somente será encerrado depois que tivermos
percorrido todos os registros do objeto Clientes, que é exatamente o que queremos.
Para cada registro é criada uma nova linha na tabela. Isto é feito pelo seguinte trecho de código:
53 <TR>
58 </TR>
Observe o seguinte fragmento de código:

<%=Clientes.Fields(“CodigoCliente”)%>
Este fragmento retorna o valor do campo CodigoCliente do registro atual do Recordset Clientes.
Com isso vamos preenchendo cada coluna com os respectivos valores. A primeira coluna com o
campo CodigoCliente, a segunda com o campo Cargo, e assim por diante. Neste caso, utilizamos a
coleção Fields do RecordSet Clientes, a qual nos dá acesso aos campos individuais de cada registro.
As linhas seguintes são de grande importância:

59 <%
61 Loop %>
62 </TABLE>
Se não colocássemos a linha 60, esta página ASP entraria em Loop infinito e somente o primeiro
registro seria exibido repetidamente, até congelar a página. Quando criamos um objeto RecordSet,
por padrão, o indicador de registro é posicionado no primeiro registro. Utilizamos o método
MoveNext para mover o indicador para o próximo registro. Com isso, a cada passagem do laço Do
303
Until, o indicador é posicionado no próximo registro, até o momento em que todos os registros
foram percorridos. Se não houvesse esta linha, o indicador ficaria sempre no primeiro registro e
o laço nunca seria encerrado, pois a condição Clientes.eof seria sempre verdadeira, impedindo o
encerramento do laço. A linha 62 é simplesmente a tag HTML de fechamento da tabela.
Modificando um Pouco o Nosso Exemplo

Vamos fazer uma pequena modificação no exemplo anterior, com o objetivo de salientar a
importância de conhecermos a linguagem SQL. Conforme podemos observar pela Figura 5.34,
a listagem foi exibida na mesma ordem em que encontrava-se na tabela Clientes, isto é,
ordenada pelo campo CodigoCliente. Mas, vamos supor que fosse necessária uma listagem
ordenada pelo campo Cargo. Como faríamos isso?
Muito simples, basta modificar a instrução SQL para incluir a ordenação. Isto é feito,
modificando-se a linha 20 da Listagem 5.1. A nova instrução SQL, já ordenando pelo campo
Cargo ficaria assim:
Clientes.Fone FROM Clientes ORDER BY Clientes.Cargo”
Feita esta alteração, ao acessarmos esta página no Internet Explorer, obteremos o resultado
Figura 5.35: A listagem de clientes do banco de dados Nwind, ordenada pelo campo Cargo.
304
Observe que uma simples modificação na instrução SQL já produz os resultados desejados.
Também poderíamos sugerir outra alteração. Vamos supor que foi solicitado que retirássemos
o campo Fone e incluíssemos o campo Fax. Esta mudança também é extremamente simples.
Bastaria alterar as seguintes linhas:
➥ A instrução SQL na linha 20 ficaria assim:
20 inst_sql=“SELECT Clientes.CodigoCliente, Clientes.Cargo,
Clientes.Endereco, Clientes.Fax FROM Clientes ORDER BY Clientes.Cargo”
➥ O cabeçalho da quarta coluna, na linha 46 ficaria assim:
46 <TD align=middle bgColor=gray>Fax</TD>
➥ Na linha 57 basta trocar o nome do campo de Fone para Fax, conforme indicado:
57 <TD align=middle bgColor=gray><%=Clientes.Fields(“Fax”)%></TD>
Com estas três alterações, obteremos os resultados indicados na Figura 5.36.
Figura 5.36: A listagem de clientes do banco de dados Nwind, com o campo Fax.
Com a utilização de SQL e ASP fica fácil fazer alterações em nossas páginas.
A partir do próximo item estudaremos mais detalhes sobre o objeto Connection. Ainda neste
capítulo, aprenderemos a criar um formulário onde o usuário pode digitar um critério e
pesquisar registros que atendam ao critério digitado. Conforme descrito, continuaremos
305
fazendo uso de objetos RecordSet, embora somente iremos estudar os mesmos, em detalhes,
no próximo capítulo.
Um Pouco Mais Sobre o Objeto Connection

Neste item iremos testar algumas propriedades e métodos do objeto Connection. É importante
conhecermos estes métodos e propriedades, pois o objeto Connection é de fundamental
importância para a conexão de páginas ASP com bancos de dados.
Listagem 5.2 – As propriedades do objeto Connection – propconn.asp.

2 <HTML>
3 <HEAD>
4 <TITLE>Propriedades do Objeto Connection!!</TITLE>
5 </HEAD>
6 <BODY>
7 <H3>
8 <FONT color=navy>Tabela com as propriedades do objeto Connection !!!
9 </FONT>
10 </H3>
11 <%
13 Set obj_conn=Server.CreateObject(“ADODB.Connection”)

16 obj_conn.Open “nwind”

Clientes.Fax FROM Clientes ORDER BY Clientes.Cargo”
306

20 ‘Endereco e Fax, da tabela Clientes.
21 ‘Agora passamos a exibir as propriedades da
22 ‘conexão obj_conn, em uma tabela de duas colunas.

24 ‘navegador do cliente. Vamos montar uma tabela com as
25 ‘propriedades da conexão obj_conn
26 %>
27 <P>
28 <HR>

width=“100%”>
30 <TR>
31 <TD align=middle bgColor=gray>Propriedade</TD>
32 <TD align=middle bgColor=gray>Valor</TD>
33 </TR>
34 <TR>
35 <TD align=middle bgColor=gray>Attributes</TD>
36 <TD align=middle bgColor=gray><%=obj_conn.Attributes %></TD>
37 </TR>
38 <TR>
39 <TD align=middle bgColor=gray>CommandTimeout</TD>
40 <TD align=middle bgColor=gray><%=obj_conn.CommandTimeout %></TD>
41 </TR>
42 <TR>
43 <TD align=middle bgColor=gray>ConnectionString</TD>
44 <TD align=middle bgColor=gray><%=obj_conn.ConnectionString %></TD>
45 </TR>
46 <TR>
47 <TD align=middle bgColor=gray>ConnectinTimeout</TD>
48 <TD align=middle bgColor=gray><%=obj_conn.ConnectionTimeout %></TD>
49 </TR>
307
50 <TR>
51 <TD align=middle bgColor=gray>CursorLocation</TD>
52 <TD align=middle bgColor=gray><%=obj_conn.CursorLocation %></TD>
53 </TR>
54 <TR>
55 <TD align=middle bgColor=gray>DefaultDatabase</TD>
56 <TD align=middle bgColor=gray><%=obj_conn.DefaultDatabase %></TD>
57 </TR>
58 <TR>
59 <TD align=middle bgColor=gray>IsolationLevel</TD>
60 <TD align=middle bgColor=gray><%=obj_conn.IsolationLevel %></TD>
61 </TR>
62 <TR>
63 <TD align=middle bgColor=gray>Provider</TD>
64 <TD align=middle bgColor=gray><%=obj_conn.Provider %></TD>
65 </TR>
66 <TR>
67 <TD align=middle bgColor=gray>State</TD>
68 <TD align=middle bgColor=gray><%=obj_conn.State %></TD>
69 </TR>
70 <TR>
71 <TD align=middle bgColor=gray>Version</TD>
72 <TD align=middle bgColor=gray><%=obj_conn.Version %></TD>
73 </TR>
74 </TABLE>
75 <% obj_conn.Close %>
76 </P>
77 <HR>
78 </BODY>
79 </HTML>
Ao acessarmos esta página, utilizando o Internet Explorer, obtemos o resultado indicado na

Figura 5.37.
308
Figura 5.37: As principais propriedades do objeto Connection.
Agora vamos detalhar alguns aspectos do código da Listagem 5.2:

➥ Estamos utilizando a mesma conexão utilizada no exemplo anterior, a qual utiliza a
fonte ODBC nwind.
➥ Outro aspecto a ser salientado é a forma como utilizamos as propriedades do objeto
Connection:
<%=obj_conn.CommandTimeout %>
Este trecho de código ASP retorna o valor da propriedade CommandTimeout do objeto

obj_conn, o qual por sua vez é um objeto Connection. A sintaxe para acessar as propriedades
é a mesma para qualquer objeto, conforme indicado abaixo:
Nome_do_objeto.Nome_da_propriedade
➥ Algumas propriedades são somente para leitura, isto é, somente podemos verificar o
valor da propriedade. Como exemplo de propriedades que são apenas para leitura,
podemos citar as propriedades State e Version.
➥ Outras propriedades são para leitura e escrita, isto é, além de acessarmos o valor atual
da propriedade, podemos alterá-lo. A título de exemplo, vamos supor que quiséssemos
309
alterar a propriedade ConnectionTimeout para 200 segundos, ao invés de manter o

padrão que é 15 segundos. Para isto, bastaria que utilizássemos o seguinte comando:
obj_conn.ConnectionTimeout = 200
NOTA
Cuidado! A propriedade ConnectionTimeout deve ser definida antes da conexão ser aberta com
a utilização do método Open, caso contrário será gerado um erro e a página não será carregada.
➥ Observe a propriedade ConnectionString, cujo valor para o nosso exemplo é o seguinte:

Provider=MSDASQL.1;Data Source=nwind;Extended Properties=“DSN=nwind;
DBQ=C:\MEUS DOCUMENTOS\NWIND.MDB;DriverId=281;
FIL=MS Access;MaxBufferSize=2048;PageTimeout=5;”
Estes valores são obtidos a partir da fonte ODBC nwind.
IMPORTANTE
Uma dúvida que muitos usuários têm é sobre a obrigatoriedade ou não de utilizarmos ODBC. A
utilização de uma fonte ODBC não é obrigatória, podemos montar uma conexão OLE DB diretamente
para qualquer fonte de dados. Basta, para isso, montar a String de conexão correta e passá-la
como um parâmetro para o método Open da conexão, que irá referenciar, diretamente, a fonte de
dados, sem a necessidade de uma fonte ODBC estar configurada.
Agora vamos fazer alguns comentários sobre os valores padrão de algumas propriedades.
A propriedade CursorLocation pode apresentar os valores indicados na Tabela 5.5.
Tabela 5.5 – Valores da propriedade CursorLocation.
Valor Descrição
1 Não utiliza os serviços de cursor. Falaremos mais sobre
cursores no próximo capítulo.
2 Este é o valor padrão, conforme pode ser comprovado na
Figura 5.37. Com este valor são utilizados os serviços de
cursor do provedor de dados, isto é, no lado do Servidor.
3 Utiliza cursor no Cliente.
310
A propriedade State pode apresentar os valores indicados na Tabela 5.6.
Tabela 5.6 – Valores da propriedade State.
Valor Descrição
0 Indica que a conexão está fechada.
1 Indica que a conexão está aberta.
2 Indica que a conexão está sendo efetuada.
4 Indica que está sendo executado um comando através da
conexão.
8 Indica um resultado sendo retornado, como por exemplo,
os registros de um Recordset.
➥ Por último gostaria de salientar a utilização do método Close, para fechar a conexão,
conforme indicado no seguinte trecho de código:
75 <% obj_conn.Close %>
Agora vamos explorar mais um exemplo de utilização da conexão de páginas ASP com banco
de dados.
Criando um Formulário Para Pesquisa

Vamos aprender mais alguns detalhes, através da utilização de um exemplo bastante comum
no dia-a-dia.
Problema: Criar um formulário, onde o usuário possa digitar o número do produto e clicar em
um botão Pesquisar. Ao clicar neste botão é chamada uma página ASP (definida no atributo
action da tag FORM), que conecta com o banco de dados Nwind.mdb, através da fonte ODBC
nwind e exibe as informações da tabela Produtos, para o produto cujo código foi digitado no
formulário de pesquisa. A página ASP deve ter um formulário para o usuário digitar outro
código e clicar em um botão Pesquisar para buscar as informações de outro produto. Neste
caso, ao clicar no botão Pesquisar da página ASP, a própria página será chamada (através da
definição do atributo action da tag FORM). A página ASP fará a pesquisa para o novo código
digitado e exibirá o produto correspondente.
Solução: Para solucionar este problema, temos duas etapas:

➥ A criação da página HTML com o formulário de pesquisa.
➥ A criação da página ASP para responder a requisição do formulário de pesquisa.
311
Criando a Página HTML com o Formulário de Pesquisa

A criação desta página é extremamente simples, utilizando os conhecimentos que foram
apresentados até o momento.
Na Listagem 5.3 temos o código para criação do formulário de pesquisa.
Listagem 5.3 – O formulário de pesquisa para o usuário digitar o código do produto –

produto.htm.
1 <HTML>
2 <HEAD>
3 <TITLE>Pesquisa de Produtos !!!</TITLE>
4 </HEAD>
5 <BODY>
6 <P><FONT color=navy>
7 <B>PESQUISA DE PRODUTOS.</B>
8 </FONT>
9 </P>
10 <FORM action=produto.asp method=post>
11 <P><FONT color=#000080><B>Digite o Código (de 1 a 77):

12 <INPUT id=codigo maxLength=2 name=codigo size=5>
13 </B>
14 </FONT></P>
15 <P><B><FONT color=#000080>
16 <INPUT id=pesquisar name=pesquisar type=submit value=“Clique aqui para pesquisar
o produto !!” >
17 </FONT>
18 </B>
19 </P>
20 </FORM>
21 </BODY>
22 </HTML>
312
Ao visualizarmos este formulário no Internet Explorer, obtemos o resultado indicado na

Figura 5.38.
Figura 5.38: O formulário para pesquisa do produto.
NOTA
Estamos pedindo para que seja digitado um número entre 1 e 77 pois estes são os dados
existentes para produtos no banco de dados Nwind.mdb. Porém, vamos fazer um teste: iremos
digitar um código 95 e mandar pesquisar. A nossa página ASP detectará que não existe nenhum
produto com este código e avisará que nenhum produto foi encontrado para o código digitado.
Criando a Página ASP Para Pesquisar no Banco de Dados

A criação desta página apresenta alguns elementos novos, ainda não apresentados até o momento.
Na Listagem 5.4 temos o código para criação da página ASP. Após a Listagem apresentaremos
os esclarecimentos necessários.
Listagem 5.4 – A página ASP para pesquisar no banco de dados – produto.asp.

2 <HTML>
3 <HEAD>
4 <TITLE>Pesquisa de Produto !!</TITLE>
5 </HEAD>
313
6 <BODY>
7 <H2>
8 <FONT color=navy>Resultado para a Pesquisa.</FONT>
9 </H2>
10 <P><FONT color=navy>
11 <B>PESQUISA DE PRODUTOS.</B>
12 </FONT>
13 </P>
14 <FORM action=produto.asp method=post id=form1 name=form1>
15 <P><FONT color=#000080><B>Digite o Código (de 1 a 77):

16 <INPUT id=codigo maxLength=2 name=codigo size=5>
17 </B>
18 </FONT></P>
19 <P><B><FONT color=#000080>
20 <INPUT id=pesquisar name=pesquisar type=submit value=“Clique aqui para pesquisar

o produto !!” >
21 </FONT>
22 </B>
23 </P>
24 </FORM>
25 <%
26 ‘O primeiro passo é criar a conexão com o banco de dados
29 Set conn=Server.CreateObject(“ADODB.Connection”)

34 sqlbuscaproduto =“SELECT * FROM Produtos where ProductID=” &

Request.Form(“codigo”)
35 ‘Esta instrução SQL retorna o produto cujo código
314
36 ‘é igual ao código digitado no formulário de pesquisa.

40 Set Produto = Server.CreateObject(“ADODB.Recordset”)

42 Produto.Open sqlbuscaproduto, conn, 3, 3

45 ‘Agora retorno as informações do produto encontrado.
46 ‘Caso não tenha sido encontrado nenhum produto, informo.
47 %>
48 <HR>
49 <%
50 If Produto.RecordCount = 0 Then
51 Response.Write “Nenhum produto foi encontrado para o código: ”
52 Response.Write Request.Form(“codigo”) & “<BR>”
53 Response.Write “Tente pesquisar um outro código !”
55 Else
56 Response.Write “<B>DADOS DO PRODUTO:</B><BR>”
57 Response.Write “Código: ” & produto.Fields(“ProductID”) & “<BR>”
58 Response.Write “Nome: ” & produto.Fields(“ProductName”) & “<BR>”
59 Response.Write “Cód. Fornec.: ” & produto.Fields(“SupplierID”) & “<BR>”
60 Response.Write “Cód. Categ.: ” & produto.Fields(“CategoryID”) & “<BR>”
61 Response.Write “Preço Unit.: ” & produto.Fields(“UnitPrice”) & “<BR>”
62 Response.Write “Estoque: ” & produto.Fields(“UnitsInStock”) & “<BR>”
64 End If
65 %>
66 </BODY>
67 </HTML>
315
Agora vamos testar o nosso exemplo. Na figura 5.39 temos o formulário de pesquisa carregado,
onde o usuário digitou o código 32.
Figura 5.39: Pesquisando o produto cujo código é 32.
Ao clicarmos no botão “Clique aqui para pesquisar o produto !!”, é retornado o resultado
Figura 5.40: O resultado da pesquisa para o produto com código 32.
316
Observe que no próprio formulário do resultado, colocamos a opção do usuário entrar com
um novo código para fazer outra pesquisa, conforme havíamos proposto na apresentação
deste problema.
Agora vamos fazer o seguinte teste: vamos digitar um código para um produto que não existe
e clicar fazer a pesquisa. Por exemplo, digite o código 89 e clique no botão de pesquisa. Você
obterá o resultado indicado na Figura 5.41.
Observe que, além de informar que o produto não foi encontrado, é informado qual o código
que foi digitado.
Agora vamos fazer alguns comentários sobre a Listagem 5.4.
Figura 5.41: Resultados para a pesquisa de um produto que não existe.
➥ O primeiro ponto a comentar é a construção da instrução SQL na linha 34.

34 sqlbuscaproduto =“SELECT * FROM Produtos where ProductID=” &
Request.Form(“codigo”)
Nesta construção estamos utilizando a cláusula Where para especificar um critério. Ao executar a
página ASP, o código Request.Form(“Código”) é substituído pelo valor digitado pelo usuário. Vamos
supor que o usuário digitou 32 para o código. Neste caso a nossa instrução SQL ficaria assim:
SELECT * FROM Produtos where ProductID=32
que é justamente, a instrução que retorna o produto cujo código é igual ao digitado no
formulário de pesquisa. Esta é uma técnica bastante útil, pois inúmeras vezes precisamos
construir instruções semelhantes a esta em nossas aplicações Web.
317
Um detalhe que devemos levar em consideração é quando o critério a ser pesquisado é do

tipo texto. Neste caso, devemos colocar o critério entre apóstrofes. Para fazer isso utilizamos
a função Chr(39) (39 é o código ASCII para o apóstrofe) antes e depois do critério, pois se
digitarmos o código diretamente na página ASP, será gerado um erro em tempo de execução.
No exemplo a seguir é ilustrada esta técnica, onde estamos especificando um critério para o
campo Cidade, o qual é do tipo texto:
sqlbuscaproduto =“SELECT * FROM Clientes where Cidade=” & Chr(39)
Request.Form(“Cidade”) & Chr(39).
Observe o Chr(39) antes e depois do critério.
Também gostaria de comentar o seguinte trecho de código:

50 If Produto.RecordCount = 0 Then
51 Response.Write “Nenhum produto foi encontrado para o código: ”
52 Response.Write Request.Form(“codigo”) & “<BR>”
53 Response.Write “Tente pesquisar um outro código !”
55 Else
56 Response.Write “<B>DADOS DO PRODUTO:</B><BR>”
57 Response.Write “Código: “ & produto.Fields(“ProductID”) & “<BR>”
58 Response.Write “Nome: ” & produto.Fields(“ProductName”) & “<BR>”
59 Response.Write “Cód. Fornec.: ” & produto.Fields(“SupplierID”) & “<BR>”
60 Response.Write “Cód. Categ.: ” & produto.Fields(“CategoryID”) & “<BR>”
61 Response.Write “Preço Unit.: ” & produto.Fields(“UnitPrice”) & “<BR>”
62 Response.Write “Estoque: ” & produto.Fields(“UnitsInStock”) & “<BR>”
64 End If
Neste caso utilizamos a propriedade RecordCount do objeto Recordset. Caso esta propriedade
seja igual a zero, significa que nenhum registro foi encontrado. Neste caso, informamos ao
usuário que nenhum produto foi encontrado.
Caso tenha sido encontrado algum produto, retornamos os dados sobre o Produto, o que é
feito na parte Else do laço If..Then...Else.
No próximo capítulo iremos tratar de algumas técnicas mais avançadas de pesquisa.
Conclusão
Neste capítulo foram apresentados diversos conceitos fundamentais para a utilização de banco
de dados com páginas ASP.
318
Começamos com uma revisão do Modelo Relacional de banco de dados, onde vimos conceitos
como Entidades, Atributos, Chave Primária, relacionamentos e Normalização. Em seguida
fizemos uma rápida revisão da linguagem SQL que, conforme descrito anteriormente, é de
fundamental importância em se tratando de banco de dados.
Na seqüência, vimos as tecnologias para acesso a fontes de dados; conceitos como ODBC, OLE
DB e ADO e a maneira como os mesmos se relacionam. Também aprendemos a criar uma fonte
ODBC para um banco de dados do Microsoft Access e do Microsoft SQL Server 2000.
Depois estudamos o Modelo de Objetos do ADO, onde vimos em detalhes o objeto Connection.
Nos exemplos de aplicação vimos como conectar uma página ASP para exibir uma listagem a
partir de uma tabela de um banco de dados do Microsoft Access. Também aprendemos alguns
detalhes sobre o objeto Recordset, que será melhor detalhado no próximo capítulo.
Para finalizar o capítulo foi apresentado um exemplo no qual o usuário digita um critério e
é efetuada uma pesquisa em uma tabela do banco de dados, com base no critério digitado
pelo usuário.
319
Capítulo 6 – Bancos de Dados com ASP – Conceitos Avançados Parte I
Capítulo 6
Bancos de Dados com ASP –
Conceitos Avançados Parte I
321
Introdução
Neste capítulo veremos uma série de conceitos avançados sobre a conexão de páginas ASP
com bancos de dados.
Aprenderemos mais detalhes sobre conexões com fontes de dados, inclusive como conectar,
sem a utilização de ODBC, somente através da utilização do objeto Connection e de sua
propriedade ConnectionString.
Estudaremos, detalhadamente, o objeto Recordset, aprendendo a utilizar suas propriedades,

métodos e coleções. Teremos um item sobre a utilização de Cursores e sobre Lock em banco de
dados. Estes são conceitos de grande importância que são, muitas vezes, ignorados. A correta
utilização de cursores é fundamental para a construção de aplicações Web, utilizando ASP.
Também aprenderemos a interagir com fontes de dados, não somente através de consultas.
Aprenderemos a inserir, alterar e excluir dados que não sejam mais necessários. Neste item
continuaremos utilizando, intensamente, as propriedades, métodos e coleções do objeto Recordset.
Serão apresentados alguns exemplos práticos de utilização, como o clássico exemplo de

construção de uma Caixa de combinação de maneira dinâmica. Por exemplo, em um
determinado formulário, necessito de uma Caixa de combinação que liste todos os Bairros da
cidade de Porto Alegre. Podemos construir esta lista, dinamicamente, a partir de um banco de
dados, onde tenhamos esta informação armazenada em uma tabela.
Veremos exemplos práticos de operações de inserção, alteração e exclusão de registros,

utilizando páginas ASP. Também aprenderemos a filtrar os registros retornados por um objeto
RecordSet.
Veremos como construir instruções SQL que utilizam funções para gerar campos calculados,
os quais não existem nas tabelas dos banco de dados. Por exemplo, utilizaremos a função
Year para criar um campo que retorna apenas o ano de um campo data. Depois utilizaremos
este campo para filtrar os resultados obtidos.
Com os assuntos tratados neste capítulo, teremos estudado diversos aspectos do Modelo de
Objetos ADO. Mas de maneira alguma teremos esgotado o assunto, uma vez que o mesmo é
bastante extenso. Nos demais capítulos do livro continuaremos a aprender um pouco mais
sobre ADO, além de outros assuntos, como gerenciamento de sessões e aplicações, utilização
de componentes ASP do servidor, segurança e tratamento de erros dentre outros.
322
Estabelecendo Conexões sem a Utilização de ODBC

Vamos repetir uma figura que foi apresentad no Capítulo 5, a qual ilustra a conexão de páginas
ASP com fontes de dados, através da utilização de OLE DB, conforme indicado na Figura 6.1.
OLE DB
OLE DB Providers
Jet Jet Exchange

Server Gerenciador ODBC

Drivers ODBC
Microsoft Microsoft Microsoft Microsoft Microsoft ORACLE

Access SQL Exchange SQL Access
Figura 6.1: Acessando fontes de dados com OLE DB.
Conforme ilustrado nesta figura, é possível o acesso a fontes de dados sem a utilização de
ODBC. Este é um ponto de confusão entre muitos programadores iniciantes em ASP. Em
diversas conversas com colegas que estavam iniciando o estudo de ASP, surgiu esta dúvida:
“É possível conectar com uma fonte de dados, como por exemplo um banco de dados do
Microsoft Access, sem a utilização de um driver ODBC?”
A resposta é sim; é perfeitamente possível. Para isto basta criar um objeto Connection e
configurar corretamente a sua propriedade ConnectionString.
A propriedade ConnectionString deve conter as informações necessárias para estabelecer a

conexão com uma fonte de dados. Através desta propriedade, devemos fornecer informações
tais como:
➥ Provedor
➥ Nome do usuário
➥ Senha do usuário
➥ Nome do arquivo
323
➥ Nome do servidor (como no caso de um servidor SQL Server)

➥ Nome do banco de dados no servidor
São informações necessárias para que a página ASP possa estabelecer a conexão com a fonte
de dados, utilizando o OLE DB Provider correto. Pode até ser que seja utilizado o OLE DB
Provider para ODBC, mas isto não é obrigatório.
Agora aprenderemos um pouco mais sobre a propriedade ConnectionString. Também veremos

alguns exemplos de utilização desta propriedade.
A Propriedade ConnectionString
Esta propriedade deve ser configurada de maneira diferente, de acordo com a fonte de dados
que estiver sendo utilizada. Por exemplo, a configuração para acessar um banco de dados do
Microsoft Access é diferente da configuração para acessar um banco de dados do Microsoft
SQL Server ou do Oracle. Vamos estudar como configurar esta propriedade para acessar
algumas das principais fontes de dados: Microsoft Access, Microsoft SQL Server e Oracle.
A propriedade ConnectionString possui uma série de comandos no formato:

argumento = valor
onde argumento pode ser a informação sobre o provedor, o nome do usuário, etc. Apenas a
título de exemplo, listamos a seguir a propriedade ConnectionString do exemplo da Listagem
5.2, do capítulo anterior:
Provider=MSDASQL.1;Data Source=nwind;Extended Properties=“DSN=nwind;DBQ=C:\MEUS
DOCUMENTOS\NWIND.MDB;DriverId=281;FIL=MS Access;MaxBufferSize=2048;PageTimeout=5;”
Agora vamos decifrar e aprender a utilizar esta propriedade.
Configurando Conexões com Bancos de Dados do Microsoft Access

Para configurar a propriedade ConnectionString para estabelecer uma conexão com um banco
de dados do Microsoft Access, podemos configurar os parâmetros indicados na Tabela 6.1.
Tabela 6.1 Definindo a propriedade ConnectionString para uma fonte do Microsoft Access.
Provider Deve ser especificado o OLE DB Provider para o Microsoft
Access. Para esta propriedade utilizamos o seguinte valor:
Microsoft.Jet.OLEDB.4.0.
324
Data Source Informamos o caminho para o arquivo .mdb. Por exemplo,
C:\Arquivos de programas\office\nwind.mdb.
User ID Especifica o nome do usuário com a qual a conexão será
estabelecida. Caso esta propriedade não seja informada, a
mesma será definida como “admin”, o qual é o usuário padrão.
Password Informa a senha para o usuário que fará a conexão. Caso não esta
propriedade não seja informada, a mesma será definida como “ ”.
IMPORTANTE
Por padrão, o OLE DB Provider para Microsoft Access (também chamado de Jet OLE DB Provider),
abre o banco de dados com permissão de leitura e escrita, isto é, os dados também podem ser
modificados. Para alterar o modo de abertura, para, por exemplo, somente escrita, devemos utilizar
a propriedade Mode, do objeto Connection.
Abaixo temos um exemplo de uma conexão com um banco de dados, utilizando a propriedade
ConnectionString:
conn.Open “PROVIDER=MICROSOFT.JET.OLEDB.4.0;DATA SOURCE=c:\meus documentos\
nwind.mdb”
Primeiro criamos um objeto do tipo Connection. Depois utilizamos o método Open, para
abrir esta conexão. Observe que após o método Open é passada uma String de conexão com
o parâmetro para o método Open. Este parâmetro é a propriedade ConnectionString.
Poderíamos obter o mesmo resultado de uma maneira diferente: primeiro vamos definir a
propriedade ConnectionString, depois simplesmente chamamos o método Open. Ao chamar
o método Open, o mesmo verifica se a propriedade ConnectionString já está definida e utiliza
a mesma. Nosso exemplo ficaria assim:
2 conn.ConnectionString = “PROVIDER=MICROSOFT.JET.OLEDB.4.0;DATA SOURCE=c:\meus
documentos\nwind.mdb”
3 conn.Open
Neste caso, na linha 2 foi definida a propriedade ConnectionString e na linha 3 utilizamos o

método Open.
325
OBSERVAÇÃO
Utilizamos os números de linha apenas para referência. Quando criamos nossas páginas ASP
não devemos utilizar números de linhas.
NOTA
A linha 2 aparece “quebrada” em duas linhas por questões de espaço para exibição, mas a
mesma deve ser digitada em uma única linha.
No exemplo a seguir, temos um caso onde foi fornecido o nome do usuário e a senha para
conexão:
documentos\nwind.mdb; User ID=jsilva;Password=senha12”
3 conn.Open
Para maiores detalhes sobre segurança de bancos de dados do Microsoft Access, consulte a
documentação do próprio Access.
Configurando Conexões com Bancos de Dados do Microsoft SQL Server

de dados do Microsoft SQL Server, podemos configurar os parâmetros indicados na Tabela 6.2.
Tabela 6.2 Definindo a propriedade ConnectionString para uma fonte do Microsoft Access.
Provider Deve ser especificado o OLE DB Provider para
o Microsoft SQL Server. Para esta propriedade
utilizamos o seguinte valor: SQLOLEDB.
Data Source ou Server Informamos o nome do servidor SQL.
Initial Catalog ou Database Nome do banco de dados a ser utilizado. Em
um servidor SQL, podem existir vários bancos
de dados.
User ID ou uid Especifica o nome do usuário com o qual a
conexão será estabelecida.
326
Password ou pwd Informa a senha para o usuário que fará a
conexão. Caso esta propriedade não seja
informada, a mesma será definida como “ ”.
Na Listagem 6.1, temos um exemplo de uma conexão com um banco de dados do Microsoft
SQL Server, utilizando a propriedade ConnectionString:
Listagem 6.1 – Conectando com um banco de dados do Microsoft SQL Server 2000 –
nwind_sql.asp.
2 <HTML>
3 <HEAD>
4 <TITLE>Conectando com o SQL Server 2000</TITLE>
5 </HEAD>
6 <BODY>
7 <H1>
8 <FONT color=navy>Pedidos da Empresa ABC Ltda.</FONT>
9 </H1>
10 <%
15 ‘Agora defino a propriedade ConnectionString do objeto Connection

16 ‘criado anteriormente.
17 conn.ConnectionString = “PROVIDER=SQLOLEDB;
Data Source=SERVIDOR\SERVIDOR;Initial Catalog=Northwind;
User ID=sa;Password=senha123"
18 conn.Open
20 inst_sql=“SELECT Orders.OrderID, Orders.OrderDate, Orders.ShipCity,

Orders.ShipCountry FROM Orders ORDER BY Orders.OrderDate”
327
21 ‘Esta instrução SQL retorna os campos OrderID, OrderDate,

‘ShipCity e ShipCountry, da tabela Orders, do banco de dados NorthWind.

25 Set Pedidos = Server.CreateObject(“ADODB.Recordset”)

27 Pedidos.Open inst_sql, conn, 3, 3
28 ‘Neste ponto já tenho todos os registros retornados

29 ‘pela instrução SQL. Estes registros estão armazenados
30 ‘no objeto Pedidos, que é um objeto do tipo Recordset.
32 ‘navegador do cliente. Vamos montar uma tabela com o
33 ‘resultado da consulta.
34 %>
35 <P>
36 <HR>
width=“100%”>
38 <TR>
40 <TD align=middle bgColor=gray>Data</TD>
41 <TD align=middle bgColor=gray>Cidade</TD>
42 <TD align=middle bgColor=gray>País</TD>
43 </TR>
44 <%
45 ‘Inicio um Loop para percorrer todos os registros

46 ‘do RecordSet Pedidos, exibindo um registro em
47 ‘cada linha da tabela.
48 Do Until Pedidos.eof %>
328
49 <TR>
50 <TD align=middle bgColor=gray><%=Pedidos.Fields(“OrderID”)%></TD>
51 <TD align=middle bgColor=gray><%=Pedidos.Fields(“OrderDate”)%></TD>
52 <TD align=middle bgColor=gray><%=Pedidos.Fields(“ShipCity”)%></TD>
53 <TD align=middle bgColor=gray><%=Pedidos.Fields(“ShipCountry”)%></TD>
54 </TR>
55 <% Pedidos.MoveNext
56 Loop %>
57 </TABLE>
58 </P>
59 <HR>
60 </BODY>
61 </HTML>
Ao acessarmos este arquivo, obtemos o resultado indicado na Figura 6.2.
Figura 6.2: Dados carregados a partir do Microsoft SQL Server.
329
Alguns detalhes importantes a serem comentados a respeito deste exemplo:

➥ Primeiro, vamos considerar o seguinte fragmento de código:
Data Source=SERVIDOR\SERVIDOR;Initial Catalog=Northwind;
18 conn.Open
Observe que, neste caso, primeiro definimos a propriedade ConnectionString, depois

utilizamos o método Open, para abrir a conexão. O método Open utiliza as informações da
propriedade ConnectionString, já definida, para estabelecer a conexão com o banco de dados.
➥ Segundo, vamos considerar a String de conexão:
“PROVIDER=SQLOLEDB;
Data Source=SERVIDOR\SERVIDOR;
Initial Catalog=Northwind;
Observe que estamos informando os parâmetros descritos na tabela a seguir.
Tabela 6.3 Parâmetros para a String de conexão com o servidor SQL Server.
Parâmetro Valor fornecido

Provider SQLOLEDB
Data Source ou Server SERVIDOR\SERVIDOR
Initial Catalog ou Northwind
User ID ou uid sa
Password ou pwd senha123
Temos dois parâmetros que merecem maiores comentários.
O parâmetro Data Source ou Server foi informado da seguinte maneira:

SERVIDOR\SERVIDOR
Este formato é uma novidade do Microsoft SQL Server 2000. O valor antes da barra (\) é o
nome do servidor e o valor depois da barra é o nome da “instância” do SQL Server a ser
utilizada (neste exemplo é igual ao nome do servidor, mas poderia ser diferente). Com o
Microsoft SQL Server 2000, posso ter várias instâncias do servidor SQL, isto é como se eu
tivesse vários servidores SQL Server 2000 diferentes no mesmo equipamento, sendo que
cada um deles deve possuir um nome diferente. Assim poderíamos ter o seguinte exemplo:
330
SERVIDOR\SERVIDOR
SERVIDOR\PRODUCAO
SERVIDOR\ESPECIAL
Neste caso temos três “instâncias” do servidor SQL Server 2000 no computador de nome
SERVIDOR. As três instâncias são:
SERVIDOR
PRODUCAO
ESPECIAL
Quando vou definir a String de conexão, preciso definir a qual instância quero conectar a
página ASP.
Se você estiver utilizando o Microsoft SQL Server 7.0, basta fornecer o nome do servidor.
Neste caso definiríamos a propriedade ConnectionString da seguinte maneira:
“PROVIDER=SQLOLEDB;
Data Source=SERVIDOR;
Initial Catalog=Northwind;
User ID=sa;Password=senha123”
➥ Observe que estamos conectando com o banco de dados Northwind. Dentro deste
banco de dados, a nossa instrução SQL acessa dados da tabela Orders, conforme
indicado pelo seguinte fragmento de código:
Orders.ShipCountry FROM Orders ORDER BY Orders.OrderDate”
Com esta instrução são retornados os campos OrderID, OrderDate, ShipCity e ShipCountry.
Além disso a listagem obtida é classificada pelo campo OrderDate, conforme pode ser
confirmado pelos resultados exibidos na Figura 6.2.
Configurando Conexões com Bancos de Dados ORACLE

de dados de um servidor ORACLE, podemos configurar os parâmetros indicados na Tabela 6.4:
Tabela 6.4 Definindo a propriedade ConnectionString para uma fonte ORACLE.
Provider Deve ser especificado o OLE DB Provider para o ORACLE. Para
esta propriedade utilizamos o seguinte valor: MSDAORA.
Data Source Informamos o nome do servidor ORACLE.
331
User ID Especifica o nome do usuário com o qual a conexão será
estabelecida.
Password Informa a senha para o usuário que fará a conexão.
Abaixo temos um exemplo de uma conexão com um banco de dados, utilizando a propriedade
ConnectionString:
2 conn.Open “Provider=MSDAORA;Data Source=SERVIDOR;User ID=admin; Password=admin123”
Primeiro criamos um objeto do tipo Connection. Depois utilizamos o método Open, para
abrir esta conexão. Observe que após o método Open é passada uma String de conexão como
parâmetro para o método Open. Este parâmetro é a propriedade ConnectionString.
Poderíamos obter o mesmo resultado de uma maneira diferente: primeiro vamos definir a
propriedade ConnectionString, depois simplesmente chamamos o método Open. Ao chamar
o método Open, o mesmo verifica se a propriedade ConnectionString já está definida e a
utiliza. Nosso exemplo ficaria assim:
2 conn.ConnectionString = “Provider=MSDAORA;Data Source=SERVIDOR;
User ID=admin; Password=admin123”
3 conn.Open
Neste caso, na linha 2 foi definida a propriedade ConnectionString e na linha 3 utilizamos o

método Open.
OBSERVAÇÕES
Utilizamos os números de linha apenas para referência. Quando criamos nossas páginas ASP
não devemos utilizar números de linhas.
NOTA
A linha 2 aparece “quebrada” em duas linhas por questões de espaço para exibição, mas a
mesma deve ser digitada em uma única linha.
IMPORTANTE
Para maiores detalhes sobre o ORACLE, consulte a documentação do produto.
332
Microsoft Access, Microsoft SQL Server e ORACLE são os casos mais comuns de conexões de
páginas ASP com fontes de dados. Porém, conforme descrito no Capítulo 5, através de OLE
DB podemos estabelecer conexões com qualquer fonte de dados para a qual esteja disponível
um OLE DB Provider, inclusive fontes de dados não estruturadas no formato de bancos de
dados relacionais. Como exemplos de fontes que não possuem o tradicional formato dos
bancos de dados relacionais, poderíamos citar os arquivos de mensagens de correio eletrônico
do Microsoft Exchange ou do Lotus Notes, um catálogo de indexação do Microsoft Index
Server ou, até mesmo, uma fonte de dados residente em um Mainframe.
Alguns Detalhes Finais Sobre o Objeto Connection

Agora veremos mais alguns detalhes importantes sobre o objeto Connection. Conforme
mostrado nos exemplos práticos, para conectar uma página ASP com uma fonte de dados,
estamos utilizando os seguintes passos:
➥ Criamos um objeto do tipo Connection e conectamos este objeto com uma fonte de
dados, quer seja via ODBC (como nos exemplos do Capítulo 5), quer seja via OLE DB
(como nos exemplos deste capítulo).
➥ Criamos um objeto do tipo RecordSet e executamos uma instrução SQL. Feito isto, o
objeto RecordSet conterá os dados retornados pela fonte de dados.
Uma vez obtidos os dados, utilizamos código ASP para exibir os resultados desejados. Esta
metodologia funciona sem maiores problemas, porém existem alguns aspectos importantes a
serem considerados, tais como o encerramento de uma conexão e o nível de acesso aos dados
oferecido por determinada conexão.
O Método Close
O método Close é utilizado para fechar/encerrar uma conexão e quaisquer outros objetos que
sejam dependentes da conexão. Por exemplo, se criamos um objeto RecordSet que obteve
dados a partir da conexão que está sendo encerrada, o objeto RecordSet também será encerrado.
A sintaxe deste método é bastante simples. Vamos supor que tenhamos criado uma conexão
chamada Clientes; para encerrá-la, poderíamos utilizar o seguinte código:
<% Clientes.Close %>
Ao fecharmos um objeto, estaremos liberando os recursos computacionais que o mesmo

utilizava, tais como conexões e uso do processador. Porém o objeto continua na memória,
com isso podemos utilizar o método Open para abrir novamente a conexão e voltar a utilizá-
333
la. No exemplo abaixo, fechamos o objeto Clientes e depois voltamos a abri-lo, utilizando o
método Open.
<% Clientes.Close
Clientes.Open
%>
Neste caso poderíamos voltar a utilizar o objeto Clientes. Para remover um objeto, em definitivo,
da memória, devemos definir o seu valor como “Nothing”, conforme indicado no exemplo:
<% Set Clientes = Nothing %>
Feito isso, somente poderemos voltar a utilizar o objeto se o mesmo for novamente criado,
utilizando o seguinte código:
Set Clientes = Server.CreateObject(“ADODB.Connection”)
Observe que, pelo fato de Clientes ser um objeto (do tipo Connection) e não simplesmente uma
variável, devemos utilizar o operador Set. Se tentarmos criar ou remover um objeto, sem a
utilização do operador Set, obteremos uma mensagem de erro e a página não será exibida.
“Pool” de Conexões
Quando um usuário fecha uma conexão, através da utilização do método Close, conforme
descrito anteriormente, esta conexão é mantida na memória e adicionada a um “Pool” de
conexões inativas. Da próxima vez que o mesmo usuário, ou qualquer outro, for abrir uma
nova conexão, o OLE DB primeiro verifica se, no Pool de conexões inativas, existe uma conexão
exatamente igual ao que o usuário está solicitando. Se for encontrada, a mesma será utilizada,
caso contrário uma nova conexão será criada e enviada para o usuário que solicitou.
O OLE DB mantém um Pool de conexões porque o processo de criar uma conexão é o que
mais exige recursos do servidor Web. Sempre que uma conexão puder ser reaproveitada, a
partir do Pool de conexões, estaremos economizando recursos do servidor.
As conexões inativas não permanecem indefinidamente no Pool de conexões. Após um período

padrão sem utilização, as mesmas são removidas, para não onerar os recursos do servidor
Web, sem que estejam sendo utilizadas.
A utilização de Pool de conexões é de grande importância, principalmente para servidores

Web muito acessados, em que novas conexões estão sendo criadas e fechadas a todo instante.
Neste caso o Pool de conexões representa um alívio na carga de recursos como memória RAM
e processador.
334
O Objeto RecordSet
Nos exemplos que foram apresentados até aqui, já utilizamos o RecordSet. Agora chegou o
momento de fazer um estudo mais aprofundado deste objeto.
O objeto RecordSet contém o resultado de uma instrução SQL executada em um banco de

dados. Contém um conjunto de Registros. É como se fosse uma tabela, onde cada linha é um
registro, e cada registro é formado por um conjunto de campos (colunas da tabela). Por exemplo,
ao executarmos a seguinte instrução SQL:
Select * from Pedidos
Estaremos selecionando todos os registros da tabela Pedidos, os quais poderão ser acessados
através de um objeto do tipo RecordSet.
Existem detalhes importantes que devemos conhecer a respeito do acesso aos dados. Devemos
considerar questões como:
➥ O acesso deve ser somente para leitura dos dados ou devem ser permitidas alterações
e inserções de novos dados?
➥ Como tratar questões sobre o acesso simultâneo aos dados? Por exemplo, como tratar a
situação em que dois usuários tentam alterar o mesmo registro, ao mesmo tempo?
Estas são questões importantes e devem ser consideradas sempre que formos disponibilizar
acesso aos dados da nossa empresa, para usuários da Internet. Também precisamos conhecer
o que são Cursores, quais os tipos disponíveis e para que utilizamos. Vamos estudar estes
pontos neste tópico.
Para criar um objeto RecordSet, utilizamos a seguinte sintaxe:

Set Pedidos = Server.CreateObject(“ADODB.Recordset”)
Neste exemplo estamos criando um RecordSet chamado Pedidos. Uma vez criado o RecordSet,
o próximo passo é utilizarmos o método Open. Este método possui a seguinte sintaxe:
recordset.Open Source, ActiveConnection, CursorType, LockType, Options
Pedidos.Open inst_sql, conn, 3, 3
Os parâmetros a serem passados para o método Open estão descritos na Tabela 6.5.
335
Tabela 6.5 Parâmetros do método Open do objeto RecordSet.
Parâmetro Descrição
Source Pode ser o nome de um objeto Command; uma instrução
SQL ou o nome de uma variável que contém uma
instrução SQL; o nome de uma tabela ou de um Store
Procedure do banco de dados; ou até uma URL que
aponta para uma fonte de dados.
ActiveConnection O nome da conexão a ser utilizada ou a String de conexão
para uma fonte de dados ODBC ou OLE DB. É opcional.
CursorType É um valor que determina o tipo de cursor que será
utilizado pelo provedor de dados na abertura do
RecordSet. É opcional. Falaremos mais sobre tipos de
cursores ainda neste item.
LockType É um valor que determina o tipo de Lock que será utilizado
pelo provedor de dados na abertura do RecordSet. É opcional.
Falaremos mais sobre tipos de Lock ainda neste item.
Options Um valor do tipo Long, o qual define como o provedor de
dados deve avaliar o argumento Source, quando o mesmo
for algo diferente de um objeto Command, ou quando o
RecordSet deve ser recuperado a partir de um arquivo
salvo previamente.
Cursores
Um Cursor é o mecanismo utilizado em ADO para gerenciar o conjunto de registros de um
objeto RecordSet. Somente podemos ter acesso a um registro chamado de Registro Corrente.
Quando utilizamos o método Open, por padrão, o primeiro registro é o Registro Corrente.
Um Cursor também é utilizado para determinar qual o Registro Corrente, bem como para
movimentar o indicador de registro entre os diversos registros do objeto RecordSet. O
mecanismo que identifica qual é o Registro Corrente é chamado de “Record pointer”. Quem
lida com a manipulação do Record pointer é o Cursor. Por isso quando utilizamos os métodos
MoveNext (mover para o próximo registro), MovePrevious (mover para o registro anterior) ou
qualquer outro método de movimentação, estamos utilizando o Cursor.
O mecanismo do Cursor também gerencia situações em que tentamos avançar além do último
registro ou voltar além do primeiro registro, ou quando acessamos o valor de um campo de
336
um registro. De uma maneira simples, podemos afirmar que grande parte da funcionalidade
de um objeto RecordSet é fornecida pelo mecanismo do Cursor.
Quando utilizamos o método Open, podemos definir diferentes formas de comportamento

para o mecanismo do Cursor. São estas formas que determinam os tipos de Cursores
disponíveis, conforme a Tabela 6. 6. O tipo do Cursor pode ser definido com um valor numérico
ou através de uma constante.
Tabela 6.6 Tipos de Cursores disponíveis.
Valor/Constante Tipo/Descrição
3 Define um Cursor do tipo Static. Um Cursor deste tipo
adOpenStatic contém uma cópia estática dos registros. O conteúdo
do RecordSet é definido no momento da criação do
mesmo. Caso sejam feitas alterações no banco de dados,
estas alterações não serão visíveis para o RecordSet que
utiliza um Cursor do tipo Static. Somente recriando o
RecordSet é que poderemos ter acesso às alterações
efetuadas. Podemos movimentar o ponteiro de registro
em ambas as direções, isto é, podemos utilizar os
métodos MoveNext, MovePrevious e assim por diante.
0 Cria um Cursor do tipo Forward Only. Este é o valor
adOpenForwardOnly padrão que será utilizado caso não seja definido nenhum
outro tipo. Somente podemos utilizar o método MoveNext.
Se tentarmos utilizar um outro método de movimentação,
será gerado um erro e a página não será carregada. Também
é um Cursor do tipo Static, com a diferença que somente
podemos nos movimentar para a frente.
2 Cria um Cursor do tipo Dynamic. Um Cursor deste tipo
adOpenDynamic não possui um conjunto fixo de registros. Quaisquer
alterações, adições e exclusões feitas por outros usuários
serão visíveis para o objeto RecordSet, sem que o
mesmo tenha que ser eliminado e recriado. Podemos nos
movimentar em ambas as direções dentro do RecordSet.
1 Cria um Cursor do tipo Keyset. Um Cursor deste tipo
adOpenKeyset é parecido com um Cursor Dynamic, com a exceção de
que o conjunto de registros é fixo. O RecordSet
enxerga as alterações feitas por outros usuários, porém
a adição de novos registros não é visível para um
337
RecordSet deste tipo. Caso algum registro seja
eliminado por outros usuários, o respectivo registro
estará inacessível. podemos nos movimentar em
ambas as direções dentro do RecordSet.
O tipo de Cursor a ser utilizado depende da aplicação que estamos desenvolvendo. Por
exemplo, se estamos desenvolvendo uma página ASP apenas para exibir um conjunto de
registros, podemos utilizar um cursor do tipo Static. Cursores mais simples, como o do
tipo Static, consomem menos recursos. Cursores mais sofisticados, como o do tipo
Dynamic, consomem mais recursos computacionais. Estes recursos podem ser consumidos
na estação do cliente ou no servidor Web, dependendo da localização do Cursor. Veremos
como definir a localização do Cursor através da utilização da propriedade CursorLocation,
no próximo item.
Agora alguns exemplos de utilização do método Open.
Este exemplo cria um RecordSet chamado Clientes e define um cursor do tipo Static:
<%
inst_sql=“Select * from Clientes”
Set Clientes = Server.CreateObject(“ADODB.Recordset”)
Clientes.Open inst_sql, conn, 3, 3
%>
Ao invés de utilizarmos o valor 3, podemos utilizar a constante correspondente adOpenStatic,

conforme o exemplo:
<%
Clientes.Open inst_sql, conn, adOpenStatic, 3
%>
O próximo exemplo cria um RecordSet chamado Clientes e define um Cursor do tipo Keyset.
<%
%>
338
Ao invés de utilizarmos o valor 1, podemos utilizar a constante correspondente adOpenKeyset,

conforme o exemplo:
<%
Clientes.Open inst_sql, conn, adOpenKeyset, 3
%>
Localização do Cursor
O Cursor pode estar localizado no servidor Web ou no cliente que está acessando os dados.
Algumas fontes de dados, como o Microsoft SQL Server, podem oferecer serviços de Cursor
no servidor. O Microsoft Access não oferece serviços de Cursor e, com isso, o mesmo fica
localizado no cliente. Quando acessamos fontes de dados, utilizando OLE DB, podemos utilizar
o serviço de Cursor oferecido pelo próprio OLE DB. A opção padrão, caso não seja definido
nada em contrário, é que o Cursor esteja no servidor.
Para definir a localização do cursor, devemos utilizar a propriedade CursorLocation, do objeto
RecordSet. Definimos esta propriedade antes da utilização do método Open deste objeto. A
Tabela 6.7 descreve os valores possíveis para esta propriedade.
Tabela 6.7 Valores para a propriedade CursorLocation.
3 Utiliza serviços de Cursor no cliente.
adUseClient
1 Não utiliza serviços de Cursor. Somente é mantido por
adUseNone questões de compatibilidade com as versões anteriores.
2 Utiliza serviços de Cursor do servidor ou do provedor
adUseServer OLE DB.
No próximo exemplo, definimos o Cursor no cliente:

<%
Clientes.CursorLocation = 3
%>
339
IMPORTANTE
A propriedade CursorLocation deve ser definida antes da utilização do método Open. Se
tentarmos definir a propriedade CursorLocation, com o RecordSet aberto, obteremos a seguinte
mensagem de erro:
Tipo de erro:
ADODB.Recordset (0x800A0E79)
Operation is not allowed when the object is open.
/Capitulo6/pubs_sql.asp, line 40
A mensagem indica que a operação (definir a localização do Cursor) não é permitida quando
o objeto está aberto.
Ao invés de utilizarmos o valor 3, podemos utilizar a constante correspondente, adUseClient,

conforme o exemplo:
<%
Clientes.CursorLocation = adUseClient
%>
Quando criamos um RecordSet com o Cursor no servidor, é responsabilidade do servidor gerenciar

a navegação e as atualizações do RecordSet, sendo que serão consumidos recursos no servidor.
Ao utilizar o Cursor no cliente, todo o conteúdo do RecordSet é copiado para a estação do

cliente e gerenciado por um Cursor local. Devemos considerar a questão da velocidade da
conexão do usuário com a Internet ou com a Intranet da empresa, pois se o RecordSet for
muito grande, isto é, um grande número de registros, o tempo para copiá-lo todo será
considerável. Porém, uma vez copiado o RecordSet para a estação do cliente, a utilização do
mesmo é mais rápida, pois não é preciso acessar o servidor para simples operações, tais como
movimentar-se para o próximo registro.
Quando uma aplicação Web é desenvolvida, a localização dos Cursores deve ser discutida na
fase de projeto, sempre procurando propiciar o melhor desempenho possível para a aplicação.
Em uma mesma aplicação posso ter páginas que utilizam o Cursor no servidor e outras que
utilizam o Cursor no cliente, depende apenas da natureza de cada página.
No próximo exemplo, definimos o Cursor no servidor:

<%
340

Clientes.CursorLocation = 2
%>
Ao invés de utilizarmos o valor 2, podemos utilizar a constante correspondente, adUseServer,

conforme o exemplo:
<%
Clientes.CursorLocation = adUseServer
%>
Lembrando que não é necessário definir o Cursor no servidor, pois essa é a definição padrão,
ou seja, se não for definida, explicitamente, a propriedade CursorLocation assume o valor
adUseServer.
Lock de Registros
Os bancos de dados utilizam o Lock de registros como uma maneira de garantir a integridade
dos dados. Com a utilização do Lock garantimos que um mesmo registro não esteja sendo
alterado, simultaneamente, por mais do que um usuário. Quando um usuário acessa um registro
para fazer alguma alteração, o mesmo é bloqueado, de tal forma que outros usuários não possam
ter acesso a ele. O acesso ao registro somente será liberado após as alterações terem sido salvas
no banco de dados. O tipo de Lock é definido pela propriedade LockType do objeto RecordSet.
Existem diferentes maneiras de se fazer o Lock dos registros, conforme descrito na Tabela 6.8.
Tabela 6.8 Tipos de Lock.
1 Cria um Lock do tipo Read Only. É o tipo padrão de
adLockReadOnly Lock. O RecordSet é somente leitura, isto é, os registros
não podem ser modificados, logo não precisam ser
bloqueados. Com isso tem um processamento mais
rápido, porém perde-se a capacidade de fazer alterações
nos registros.
2 Cria um Lock do tipo Pessimistic. O provedor OLE DB
adLockPessimistic tenta bloquear o registro no momento em que o mesmo
começa a ser editado. Isso é feito para tentar garantir
que o registro será editado com sucesso.
341
3 Cria um Lock do tipo Optimistic. O registro não é
adLockOptimistic bloqueado enquanto as alterações não forem salvas
no banco de dados através da utilização do método
Update do RecordSet.
4 Cria um Lock do tipo Batch Optimistic. Este tipo de
adLockBatchOptimistic Lock permite que vários registros sejam modificados.
Os registros somente serão bloqueados quando for
chamado o método UpdateBatch do objeto RecordSet.
-1 Não define o tipo de Lock. Quando utilizamos o método
adLockUnspecified Clone, para criar uma cópia do RecordSet, o Clone
será criado com o mesmo tipo de Lock do RecordSet
original.
A maneira e os tipos de Lock possíveis de serem utilizados também dependem da fonte de

dados que está sendo utilizada. Quando não existe a necessidade de fazer alterações nos
registros, devemos utilizar, sempre, um Lock do tipo Read Only (ou seja, como o RecordSet é
apenas leitura, os registros não precisam ser bloqueados), pois isso evita que o Provider tenha
que fazer verificações ao acessar cada registro, para verificar se o registro não está bloqueado
no momento. Assim teremos um processamento bem mais rápido.
Um registro bloqueado não pode nem sequer ser visualizado pelos usuários, evitando-se que
seja exibido um registro que está sendo alterado.
Para definir o tipo de Lock, utilizamos a propriedade LockType, conforme indicado no exemplo
a seguir, onde definimos o tipo de Lock como Optimistic:
<%
Clientes.LockType = 3
%>
IMPORTANTE
A propriedade LockType deve ser definida antes da utilização do método Open. Ao tentarmos
definir a propriedade CursorLocation, com o RecordSet aberto, obteremos a seguinte
mensagem de erro:
342
Tipo de erro:
ADODB.Recordset (0x800A0E79)
Operation is not allowed when the object is open.
/Capitulo6/pubs_sql.asp, line 40
A mensagem indica que a operação (definir a localização do Cursor) não é permitida quando
o objeto está aberto.
Ao invés de utilizarmos o valor 3, podemos utilizar a constante correspondente, adLockOpti-

mistic, conforme o exemplo:
<%
Clientes.LockType = adLockOptimistic
%>
Agora que já discutimos um pouco sobre Cursores, localização do Cursor e Lock de registros,
podemos partir para o estudo de mais alguns detalhes do objeto RecordSet.
Propriedades do Objeto RecordSet

Através da utilização de propriedades de um objeto podemos definir algumas de suas
características e também retornar as características do mesmo. Algumas propriedades são
somente para leitura, isto significa que apenas podemos verificar o valor da propriedade.
Outras são de leitura e escrita, isto é, podemos definir seu valor. Para definir o valor de uma
propriedade, utilizamos a seguinte sintaxe:
<% RecordSet.nome_da_propriedade = valor %>
Na Tabela 6.9 estão listadas as principais propriedades do objeto RecordSet.
Tabela 6.9 Principais propriedades do objeto RecordSet.
AbsolutePage Retorna a página do Registro Corrente. Página é um
conceito de armazenamento de banco de dados.
AbsolutePosition Indica a posição do Registro Corrente, dentro do
RecordSet.
343
ActiveCommand Retorna o objeto Command utilizado para criar o
RecordSet, caso tenha sido utilizado um objeto
Command. Esta propriedade é somente leitura.
BOF Esta propriedade torna-se verdadeira quando
estivermos no primeiro registro e utilizarmos o método
MovePrevious, ou seja, indica uma tentativa de
voltarmos além do primeiro registro. É somente leitura.
Bookmark Retorna um marcador (bookmark) que identifica de
maneira única cada registro do RecordSet. Também
pode ser utilizado para tornar o registro identificado
pelo Bookmark como o Registro Corrente. Nem todas as
fontes de dados e seus respectivos OLE DB Providers
oferecem esta propriedade.
CacheSize Indica o número de registros do RecordSet que devem
ser mantidos no Cache local de memória. Também pode
ser utilizada para definir este número de registros.
CursorLocation Pode ser utilizada para definir ou retornar a posição do
Cursor.
CursorType Indica o tipo de Cursor utilizado em um objeto
RecordSet. Também pode ser utilizada para definir o
tipo de Cursor. Deve ser utilizada antes do método
Open, caso contrário irá provocar um erro quando a
página for carregada.
EditMode Retorna um valor que indica o status de edição do
registro atual. Este valor pode ser: 0 – indica que não
existe edição em andamento; 1– indica que os dados
do registro atual foram modificados, porém ainda não
foram salvos; 2 – indica que o método AddNew foi
chamado e o registro que está sendo criado, ainda não
foi salvo no banco de dados; 4 – indica que o registro
atual foi deletado. É somente leitura.
EOF Esta propriedade torna-se verdadeira quando
estivermos no último registro e utilizarmos o método
MoveNext, ou seja, indica uma tentativa de avançarmos
além do último registro. É somente leitura.
344
Filter Pode ser utilizada para filtrar os registros de um
RecordSet de acordo com um critério definido.
Falaremos sobre esta propriedade mais adiante.
Também serão mostrados alguns exemplos práticos.
LockType Indica o tipo de Lock que está sendo utilizado. Também
pode ser utilizada para definir o tipo de Lock, antes que
o método Open tenha sido utilizado.
MaxRecords Define o número máximo de registros que uma consulta
deve retornar para o objeto RecordSet. O valor padrão é
zero, o que significa sem limite de registros.
PageCount Indica quantas páginas de dados o objeto RecordSet
contém. É somente leitura.
PageSize Indica o número de registros por página.
RecordCount Indica o número de registros do objeto RecordSet. É
somente leitura.
Sort Especifica um ou mais campos para ordenação do
RecordSet, além do tipo de ordenação se ascendente
ou descendente. Para utilizarmos esta propriedade
devemos utilizar o Cursor no cliente.
Source Indica as fontes dos dados de um objeto RecordSet.
Por exemplo, exibe a instrução SQL que deu origem
aos dados ou o nome da tabela ou consulta que
originou os dados do objeto RecordSet.
State Indica o estado do objeto RecordSet. Indica se o mesmo
está aberto, fechado ou executando uma operação de
maneira assíncrona. É somente leitura.
Métodos do Objeto RecordSet

O objeto RecordSet nos fornece diversos métodos, os quais podem ser utilizados para nos
deslocar através dos registros, fazer uma cópia do RecordSet, etc. Para utilizarmos um método
do objeto RecordSet, utilizamos a seguinte sintaxe:
<% RecordSet.nome_do_método parâmetro1, parâmetro2, ..., parâmetron %>
Na Tabela 6.10 estão listados os principais métodos do objeto RecordSet.
345
Tabela 6.10 Principais métodos do objeto RecordSet.
Método Descrição
AddNew Utilizado para adicionar um novo registro em um
RecordSet que seja atualizável.
Cancel Cancela a execução de uma operação Open assíncrona.
CancelBatch Cancela uma operação de atualização em Batch.
CancelUpdate Cancela qualquer alteração feita no Registro Corrente,
ou alterações feitas em um novo registro antes da
chamada do método Update.
Clone Cria uma cópia do objeto RecordSet.
Close Fecha o objeto RecordSet e todos os objetos dele
dependentes.
Delete Elimina o registro corrente ou um grupo de registros
selecionados.
Find Pesquisa no RecordSet por um registro que atende um
critério especificado.
GetRows Retorna registros de um RecordSet e os armazena em
um array.
GetString Retorna todo o RecordSet como uma String.
Move Movimenta o indicador de registro a partir de uma
posição especificada de um determinado número de
registros. Por exemplo, posso movimentar o indicador
dez registros a partir do registro 10, com isso o
indicador fica no registro 20.
MoveFirst Movimenta o indicador para o primeiro registro.
MoveLast Movimenta o indicador para o último registro.
MoveNext Movimenta o indicador para o próximo registro.
MovePrevious Movimenta o indicador para o registro anterior.
Open Abre o objeto RecordSet.
Requery Atualiza o conjunto de registros do RecordSet,
executando novamente a consulta que deu origem ao
RecordSet.
346
Método Descrição
Resync Atualiza os dados do RecordSet, buscando os dados a
partir do banco de dados.
Save Salva o conteúdo do RecordSet em um arquivo.
Update Salva quaisquer alterações que tenham sido feitas para
o objeto RecordSet.
Agora vamos aprender a executar algumas operações bastante comuns em aplicações Web.
Aprenderemos a inserir, excluir e alterar um determinado registro.
Uma Página ASP Para Inserir

Informações no Banco de Dados
Neste exemplo aprenderemos a construir uma página ASP que recebe os dados digitados em
um formulário HTML e os armazena no registro de uma tabela. Também faremos a validação
para verificar se todos os campos obrigatórios foram preenchidos. Caso algum campo
obrigatório não tenha sido preenchido, devolvemos o formulário para o usuário informando
qual ou quais campos obrigatórios não foram preenchidos. Caso todos os campos tenham
sido preenchidos corretamente, os valores digitados serão gravados no banco de dados.
Podemos utilizar este exemplo para criar um formulário de cadastro de usuários ou qualquer
outra aplicação que necessite armazenar os dados digitados em um formulário.
NOTA
Eu, por exemplo, utilizo uma aplicação deste tipo para fazer a avaliação dos treinamentos que
ministro em todo o país. Ao final do treinamento, os usuários, sem se identificar, preenchem
um formulário com as opiniões sobre o treinamento, o material e o desempenho do instrutor.
Estes dados são armazenados diretamente em um banco de dados do Microsoft Access, a
partir do qual faço uma série de estatísticas.
Na Listagem 6.2 temos o código HTML para a criação do formulário de cadastro, no qual o
usuário poderá digitar os dados.
Listagem 6.2 – O formulário para digitação dos dados – cadastro.htm.

1 <HTML>
2 <HEAD>
347
3 <TITLE>Cadastro de novos Clientes !!</TITLE>

4 </HEAD>
5 <BODY bgColor=#c0c0c0>
6 <P>
7 <FONT color=white size=6 style=“BACKGROUND-COLOR: navy”>
8 <B>Empresa ABC Ltda. - (0-xx-11-1111-2222)</B>
9 </FONT>
10 </P>
11 <P>
12 <FONT color=#ffffff size=5 style=“BACKGROUND-COLOR: darkred”>
13 <B><EM>CADASTRO DE NOVOS CLIENTES:</EM></B>
14 </FONT>
15 </P>
16 <P>
17 <FONT color=navy size=4>
18 <EM>Digite os dados solicitados e clique no botão Enviar.</EM>
19 </FONT>
20 </P>
21 <P>
22 <FORM ACTION=cadastro.asp METHOD=POST>
23 <TABLE bgColor=#ffffff border=1 cellPadding=1 cellSpacing=1 width=“100%”

style=“HEIGHT: 161px; WIDTH: 340px”>
24 <TR>
25 <TD>Nome:</TD>
26 <TD><INPUT id=nome maxLength=50 name=nome size=35>
27 <FONT color=red><B>(*)</B></FONT></TD>
28 </TR>
29 <TR>
30 <TD>Rua:</TD>
31 <TD><INPUT id=rua maxLength=30 name=rua size=35>
33 </TR>
348
34 <TR>
35 <TD>Bairro:</TD>
36 <TD><INPUT id=bairro maxLength=20 name=bairro>
38 </TR>
39 <TR>
40 <TD>Cidade:</TD>
41 <TD><INPUT id=cidade maxLength=25 name=cidade size=25>
43 </TR>
44 <TR>
45 <TD>CEP:</TD>
46 <TD><INPUT id=cep maxLength=10 name=cep size=10>
47 <FONT color=red><FONT color=#000000>nnnnn-nnn
48 </FONT><B>(*)</B></FONT></TD>
49 </TR>
50 <TR>
52 <TD>Fone:</TD>
53 <TD><INPUT id=fone maxLength=20 name=fone></TD>
54 </TR>
55 <TR>
56 <TD>Fax:</TD>
57 <TD><INPUT id=fax maxLength=20 name=fax></TD></TR>
58 <TR>
59 <TD>Cartão:</TD>
60 <TD>
61 <INPUT id=cartaotipo name=cartaotipo type=radio value=Visa>Visa
62 <INPUT id=cartaotipo name=cartaotipo type=radio value=Master_Card>Master
Card
63 <INPUT id=cartaotipo name=cartaotipo type=radio value=Outros>Outros
64 <FONT color=red><B>(*)</B></FONT>
65 </TD>
66 </TR>
67 <TR>
68 <TD colSpan=2>
349
69 <INPUT id=enviar name=enviar style=“HEIGHT: 24px; WIDTH:109px”

type=submit value=“Enviar dados.”>
70 <INPUT id=limpar name=limpar type=submit value=“Limpar
formulário.”>
71 </TD>
72 </TR>
73 </TABLE>
74 </FORM>
75 </P><BR>
76 <FONT color=red><B>(*)
77 <FONT color=navy>Campos de preenchimento obrigatório.</FONT></B></FONT>
78 </BODY>
79 </HTML>
Ao carregarmos o exemplo da Listagem 6.2, obteremos o resultado indicado na Figura 6.3.
Figura 6.3: O formulário para digitação dos dados.
350
Agora precisamos construir a página – cadastro.asp, a qual irá verificar se todos os campos de
preenchimento obrigatório foram preenchidos. Se todos os campos obrigatórios foram
preenchidos, os dados serão gravados em um banco de dados, caso contrário o formulário é
enviado para o usuário, solicitando que o mesmo preencha os campos que estão faltando.
Para armazenar os dados, utilizaremos um banco de dados do Microsoft Access – clientes.mdb.

Este banco de dados está gravado em C:\Meus documentos. Neste banco de dados temos uma
tabela chamada Cadastro, com a estrutura indicada na Figura 6.4.
Figura 6.4: Tabela Cadastro do banco de dados Clientes.
Para acessar este banco de dados utilizaremos OLE DB, sem a necessidade da criação de uma
fonte ODBC. Faremos isto através da utilização da propriedade ConnectionString, já descrita
neste capítulo.
A página cadastro.asp fará o seguinte:

➥ Estabelece conexão com o banco de dados clientes.mdb e cria um RecordSet chamado
Cadastro, o qual está ligado à tabela Cadastro do banco de dados.
➥ Depois a página verifica se algum campo obrigatório não foi preenchido.
➥ Caso todos os campos obrigatórios tenham sido preenchidos, os dados são gravados
na tabela Cadastro do banco de dados clientes.mdb.
➥ Caso algum campo obrigatório não tenha sido preenchido, a página ASP informa quais
campos obrigatórios não foram preenchidos, e retorna o formulário para o usuário,
351
mantendo os campos que já haviam sido preenchidos, para que o usuário possa
preencher somente os campos que estão faltando.
Na Listagem 6.3 temos o código para a página cadastro.asp.
Listagem 6.3 – Página ASP para processamento dos dados – cadastro.asp.

2 <HTML>
4 <HEAD>
5 </HEAD>
6 <BODY>
7 <%
12 ‘Agora abro uma conexão com o arquivo clientes.mdb

13 ‘utilizando OLE DB.
14 conn.ConnectionString = “PROVIDER=MICROSOFT.JET.OLEDB.4.0;
DATA SOURCE=c:\meus documentos\clientes.mdb”
15 conn.Open

17 ‘Este objeto irá acessar a tabela Cadastro.
18 Set Cadastro = Server.CreateObject(“ADODB.Recordset”)

19 Cadastro.Open “Cadastro”, conn, 3, 3
20 ‘Neste ponto tenho o objeto Cadastro ligado com a tabela

21 ‘Cadastro do banco de dados clientes.mdb.
22 ‘**************************************************
23 ‘ Inicia a verificação para saber se todos
24 ‘ os campos obrigatórios foram preenchidos.
‘**************************************************
352
25 ‘ Atribuo os campos obrigatórios à variáveis, para facilitar a verificação.
26 nome=Request.Form(“nome”)
27 rua =Request.Form(“rua”)
28 bairro=Request.Form(“bairro”)
29 cidade=Request.Form(“cidade”)
30 cep=Request.Form(“cep”)
31 cartao=Request.Form(“cartaotipo”)
32 ‘Verifica se os campos obrigatório foram preenchidos.
33 ‘Qualquer dado obrigatório que não tenha sido preenchido,
34 ‘definirá a variável faltou_dado em Sim.
39 End If
40 If (rua=“”)Then
41 mensagem_rua=“Preencha o campo Rua:”
43 faltou_rua=“Sim”
44 End If
45 If (bairro=“”)Then
46 mensagem_bairro=“Preencha o campo Bairro:”
48 faltou_bairro=“Sim”
49 End If
50 If (cidade=“”)Then
51 mensagem_cidade=“Preencha o campo Cidade:”
53 faltou_cidade=“Sim”
54 End If
55 If (cep=“”)Then
56 mensagem_cep=“Preencha o campo CEP:”
58 faltou_cep=“Sim”
353
59 End If
60 If (cartao=“”)Then
61 mensagem_cartao=“Preencha o campo Cartão:”
63 faltou_cartao=“Sim”
64 End If
65 ‘Caso todos os campos obrigatórios tenham sido

66 ‘preenchidos, gravo os dados no banco de dados.
67 ‘e informo que a operação foi realizada com sucesso.
69 Cadastro.AddNew
70 Cadastro.Fields(“Nome”)= Request.Form(“nome”)
71 Cadastro.Fields(“Rua”)= Request.Form(“rua”)
72 Cadastro.Fields(“Bairro”)= Request.Form(“bairro”)
73 Cadastro.Fields(“Cidade”)= Request.Form(“cidade”)
74 Cadastro.Fields(“Cep”)= Request.Form(“cep”)
75 Cadastro.Fields(“Fone”)= Request.Form(“fone”)
76 Cadastro.Fields(“Fax”)= Request.Form(“fax”)
77 Cadastro.Fields(“Cartao”)= Request.Form(“cartaotipo”)
78 Cadastro.Update
79 Cadastro.Close
80 Set Cadastro = Nothing
81 Response.Write “CLIENTE CADASTRADO COM SUCESSO<BR>”

82 Response.Write “<A href=cadastro.htm>Clique aqui para cadastrar outro
cliente</A>”
84 End If
85 ‘Caso algum dado obrigatório não tenha sido digitado

86 ‘Envia o formulário de volta para o cliente,
87 ‘preservando os valores que o mesmo já digitou.
88 ‘Observe que utilizamos Response.Write para ir
89 ‘recriando todo o formulário.
90 ‘Também observe que o formulário é enviado de volta
91 ‘na página cadastro.asp e que o atributo action
92 ‘da tag FORM é definido como cadastro.asp, ou seja
354
93 ‘a página cadastro.asp chama a si mesma após o

94 ‘usuário clicar no botão Enviar.
95 ‘Esta é uma técnica bastante interessante.
96 ‘Antes de enviar o formulário, informamos quais
97 ‘os campos obrigatório que não foram preenchidos.
99 Response.Write “<B>O campo Nome deve ser preenchido.</B> <BR>”
100 End If
102 Response.Write “<B>O campo Rua deve ser preenchido.</B> <BR>”
103 End If

105 Response.Write “<B>O campo Cidade deve ser preenchido.</B> <BR>”
106 End If
107 If faltou_bairro=“Sim” Then

108 Response.Write “<B>O campo Bairro deve ser preenchido.</B> <BR>”
109 End If
110 If faltou_cep=“Sim” Then

111 Response.Write “<B>O campo CEP deve ser preenchido.</B> <BR>”
112 End If
113 If faltou_cartao=“Sim” Then

114 Response.Write “<B>O campo Cartão deve ser preenchido.</B> <BR>”
115 End If
116 %>
117 <%
118 ‘Começo a reenviar o formulário para o usuário, utilizando Response.Write.
119 ‘Caso esteja faltando algum dado, envio o formulário

120 ‘para o usuário preencher os campos que estão faltando.
121 ‘Os valores já digitados, são preservados.
122 %>
123 <% If faltou_dado=“Sim” Then
355
124 Response.Write “<BODY bgColor=#c0c0c0>”

125 Response.Write “<P><FONT color=white size=6 style=BACKGROUND-COLOR:
navy><STRONG>Empresa ABC LTDA - ”
126 Response.Write “(0-xx-11-1111-2222)<BR> ”
127 Response.Write “</STRONG></FONT><FONT color=#000000><FONT size=5
><STRONG><EM>CADASTRO DE NOVOS ”
128 Response.Write “CLIENTES:</EM></STRONG></FONT> <BR></FONT><FONTcolor=navy
size=4><EM>Digite os dados solicitados e clique no botão ”
129 Response.Write “Enviar.</EM></FONT></P>”
130 Response.Write “<P>”
131 Response.Write “Caso queira alterar algum dado”

132 Response.Write “ digite no formulário abaixo.<BR>”
133 Response.Write “<FORM ACTION=cadastro.asp METHOD=post id=form1 name=form1>”
134 Response.Write “<TABLE bgColor=#ffffff border=1 cellPadding=1 cellSpacing=1

width=100% style=HEIGHT: 161px; WIDTH: 340px>”
135 Response.Write “<TR>”

136 Response.Write “<TD>Nome:</TD>”
137 Response.Write “<TD><INPUT id=nome maxLength=50 name=nome size=35 value=” &
Chr(34) & Request.Form(“nome”) & Chr(34) & “> <FONT ”
138 Response.Write “color=red><B>(*)</B></FONT></TD></TR>”

140 Response.Write “<TD>Rua:</TD>”
141 Response.Write “<TD><INPUT id=rua maxLength=30 name=rua size=35 value=” &
Chr(34) & Request.Form(“rua”) & Chr(34) & “><FONT Color=red><B>(*)</B></FONT></
TD></TR>”

143 Response.Write “<TD>Bairro:</TD>”
144 Response.Write “<TD><INPUT id=bairro maxLength=20 name=bairro value=” & Chr(34)
& Request.Form(“bairro”) & Chr(34) &”><FONT ”
145 Response.Write “color=red><B>(*)</B></FONT></TD></TR>”

147 Response.Write “<TD>Cidade:</TD>”
148 Response.Write “<TD><INPUT id=cidade maxLength=25 name=cidade value=” &
Chr(34) & Request.Form(“cidade”) & Chr(34)
149 Response.Write “size=25><FONT color=red><B>(*)</B></FONT></TD></TR>”
356

151 Response.Write “<TD>CEP:</TD>”
152 Response.Write “<TD><INPUT id=cep maxLength=10 name=cep value=” & Chr(34)& 153
Request.Form(“cep”)& Chr(34)
154 Response.Write “size=10> <FONT color=red><FONT color=#000000>nnnnn-nnn ”
155 Response.Write “</FONT><B>(*)</B></FONT></TD></TR>”
157 Response.Write “<TD>Fone:</TD>”
158 Response.Write “<TD><INPUT id=fone maxLength=20 name=fone value=” & Chr(34) & 159
Request.Form(“fone”) & Chr(34) & “></TD></TR>”

161 Response.Write “<TD>Fax:</TD>”
162 Response.Write “<TD><INPUT id=fax maxLength=20 name=fax value=” & Chr(34) &
Request.Form(“fax”) & Chr(34) & “></TD></TR>”
164 Response.Write “<TD>Cartão:</TD>”
165 If Request.Form(“cartaotipo”)=“Visa” Then

166 Response.Write “<TD><INPUT id=cartaotipo name=cartaotipo type=radio
CHECKED>Visa”
167 Else
168 Response.Write “<TD><INPUT id=cartaotipo name=cartaotipo
type=radio>Visa”
169 End If
170 If Request.Form(“cartaotipo”)=“Master Card” Then

171 Response.Write “<INPUT id=cartaotipo name=cartaotipo type=radio
CHECKED>Master Card <INPUT id=cartaotipo ”
172 Else
173 Response.Write “<INPUT id=cartaotipo name=cartaotipo type=radio>Master
Card <INPUT id=cartaotipo ”
174 End If
175 If Request.Form(“cartaotipo”)=“Outros” Then

176 Response.Write “name=cartaotipo type=radio CHECKED>Outros”
177 Else
178 Response.Write “name=cartaotipo type=radio>Outros”
179 End If
180 Response.Write “<FONT color=red><B>(*)</B></FONT></TD></TR>”

357
182 Response.Write “<TD colSpan=2><INPUT id=enviar name=enviar style=HEIGHT: 24px;

WIDTH: 109px type=submit value=Enviar_dados.> ”
183 Response.Write “<INPUT id=limpar name=limpar type=submit
value=Limpar_formulário.></TD></TR>”
184 Response.Write “</TABLE>”
185 Response.Write “</FORM>”
186 Response.Write “</P><FONT color=red><B>(*) <FONT color=navy>Campos de
preenchimento ”
187 Response.Write “obrigatório.</FONT></B></FONT>”
188 End If
189 %>
190 </BODY>
191 </HTML>
NOTA
Algumas linhas aparecem divididas em duas ou mais linhas. Nunca é demais lembrar que
estas linhas devem ser digitadas como uma linha única. As mesmas estão exibidas em duas ou
mais linhas apenas por questão de espaço.

➥ A primeira observação a ser feita é a respeito do código que insere um novo registro na
tabela Cadastro do Banco de dados clientes.mdb. O código ASP que realiza esta tarefa
é o seguinte:
69 Cadastro.AddNew
70 Cadastro.Fields(“Nome”)= Request.Form(“nome”)
71 Cadastro.Fields(“Rua”)= Request.Form(“rua”)
72 Cadastro.Fields(“Bairro”)= Request.Form(“bairro”)
73 Cadastro.Fields(“Cidade”)= Request.Form(“cidade”)
74 Cadastro.Fields(“Cep”)= Request.Form(“cep”)
75 Cadastro.Fields(“Fone”)= Request.Form(“fone”)
76 Cadastro.Fields(“Fax”)= Request.Form(“fax”)
77 Cadastro.Fields(“Cartao”)= Request.Form(“cartaotipo”)
78 Cadastro.Update
79 Cadastro.Close
80 Set Cadastro = Nothing
81 Response.Write “CLIENTE CADASTRADO COM SUCESSO<BR>”
82 Response.Write “<A href=cadastro.htm>Clique aqui para cadastrar outro
cliente</A>”
84 End If
358
Neste código, utilizamos o método AddNew do objeto RecordSet Cadastro. Depois vamos
preenchendo cada novo campo do registro, com o respectivo valor preenchido pelo usuário
no formulário. No final, utilizamos o método Update para salvar o registro na tabela.
O método Close é utilizado para fechar o RecordSet Cadastro e, por fim, tiramos o objeto
Cadastro da memória. Isto é feito atribuindo-se o valor “Nothing” para o objeto Cadastro. É
importante lembrar que para atribuir valor para um objeto, devemos utilizar o operador Set,
caso contrário obteremos uma mensagem de erro.
➥ Também gostaria de observar a situação em que o usuário deixa de preencher algum
campo obrigatório. Neste caso, o usuário é informado a respeito de qual ou quais cam-
pos não foram preenchidos. O formulário é retornado para o usuário, juntamente com
os valores já digitados, para que o usuário não precise redigitar todos os valores
novamente. Observe que todo o código HTML que gera o formulário é retornado
utilizando-se Response.Write – da linha 124 à linha 189.
➥ Vamos testar o funcionamento da página cadastro.asp.
Na Figura 6.5, o usuário preencheu alguns campos, porém não preencheu os campos
obrigatórios Bairro e Rua.
Figura 6.5: Os campos obrigatórios Bairro e Rua não foram preenchidos.
Ao clicar no botão Enviar dados, a página cadastro.asp detecta que alguns campos obrigatórios
não foram preenchidos e informa isto ao usuário, conforme indicado na Figura 6.6.
359
Figura 6.6: O usuário é informado que alguns campos obrigatórios não foram preenchidos.
Agora o usuário preenche os campos obrigatórios que estão faltando, conforme indicado na
Figura 6.7.
Figura 6.7: O usuário preenche os campos que estão faltando.
360
Ao clicar em Enviar dados, as informações serão salvas no banco de dados. A página

cadastro.asp informa que os dados foram salvos com sucesso e retorna um link para que o
usuário possa voltar ao formulário de cadastro e cadastrar outro cliente, conforme indicado
na Figura 6.8.
Figura 6.8: O cliente foi cadastrado com sucesso.
Editando Registros em um Banco de Dados

Neste tópico aprenderemos a criar uma página ASP que atualiza um registro do banco de dados.
Nosso exemplo será composto dos seguintes elementos:

➥ Uma página ASP – produto.asp, onde temos um campo com a listagem de produtos
disponíveis na tabela Produtos, do banco de dados Nwind. Esta listagem será construída
dinamicamente, isto é, cada vez que a página for carregada, a listagem será construída a
partir das informações disponíveis na tabela Produtos.
➥ Após selecionar o produto a ser alterado, o usuário clica em um botão Localizar produto.
Feito isso, a página produto.asp chama uma página chamada localiza.asp, que localiza
o registro selecionado no banco de dados. Com isso, o usuário pode alterar os dados do
produto.
➥ Após alterar os dados desejados, o usuário clica em um botão Atualizar produto. A
página localiza.asp chama a página atualiza.asp, que acessa o banco de dados e faz as
alterações solicitadas pelo usuário. Ao final é emitida uma mensagem indicando que
os dados foram atualizados com sucesso.
NOTA
Existem maneiras mais simples para executar este procedimento. Optei pela utilização de três
páginas, para que os passos envolvidos ficassem bem claros. O código ASP também foi
desenvolvido de uma maneira didática, visando facilitar o entendimento do mesmo.
361
A Página ASP Para Selecionar o Produto a ser Alterado – produto.asp

Na Listagem 6.4 temos o código ASP para a criação da página produto.asp.
Listagem 6.4 – A página ASP para selecionar o produto a ser alterado – produto.asp.
2 <HTML>
3 <HEAD>
4 <TITLE>Selecione o produto a ser alterado.</TITLE>
5 </HEAD>
6 <BODY>
7 <%
8 ‘O primeiro passo é criar a conexão com o banco de dados.

9 ‘Para isto crio um objeto do tipo Connection.
12 ‘Agora abro uma conexão com o arquivo nwind.mdb

DATA SOURCE=c:\meus documentos\nwind.mdb”
15 conn.Open

17 ‘Este objeto irá acessar o campo ProductName
18 ‘da tabela Produtos
19 Set Produtos = Server.CreateObject(“ADODB.Recordset”)

20 Produtos.Open “Select ProductName from Produtos Order By ProductName”, conn, 3, 3
21 ‘Neste ponto tenho o objeto Produtos ligado com a tabela

22 ‘Produtos do banco de dados nwind.mdb.
23 %>
362
24 <P><B>Selecione o produto a ser alterado.</B></P>

25 <P><B><I>Depois clique no botão Localizar Produto.</I></B></P>
26 <FORM action=localiza.asp method=post>
27 <SELECT id=listaprodutos name=listaprodutos>
28 <%
29 ‘Agora construo a lista de opções a partir dos

30 ‘dados obtidos da tabela Produtos.
31 ‘Para cada produto obtido, crio uma nova opção
32 ‘na lista.
33 Do While Not Produtos.EOF
34 Response.Write “<OPTION value=” & Chr(34) & Produtos.Fields(“ProductName”) &
Chr(34) & “>” & Produtos.Fields(“ProductName”)& “</OPTION>”
35 Produtos.MoveNext
36 Loop
37 %>
38 </SELECT>
39 <BR>
40 <BR>
41 <HR>
42 <INPUT type=“submit” value=“Localizar Produto” id=Localizar name=Localizar>
43 </FORM>
44 </BODY>
45 </HTML>
Para esta listagem vamos comentar apenas o código ASP que constrói a lista com os nomes de
produtos disponíveis.
Lembrando da nossa revisão de HTML, o código para construir uma Caixa de combinação é
o seguinte:
<SELECT id=select1 name=Item1>
<OPTION value=Item1>Item1</OPTION>
363
</SELECT>
Neste exemplo temos uma lista com três itens. Para cada produto encontrado devemos criar
um item da lista, o que é feito com as tags <OPTION> </OPTION>. Por exemplo, para o
produto “Alice Mutton”, teríamos que criar a seguinte opção:
<OPTION value=Alice Mutton>Alice Mutton</OPTION>
A primeira vez que aparece o nome – value=Alice Mutton – é a designação do nome associado
com cada opção. Na segunda vez que aparece o nome, é a definição do texto que será exibido
na lista. Para construir esta lista dinamicamente, utilizamos o seguinte código ASP:
33 Do While Not Produtos.EOF
34 Response.Write “<OPTION value=” & Chr(34) & Produtos.Fields(“ProductName”) &
Chr(34) & “>” & Produtos.Fields(“ProductName”)& “</OPTION>”
35 Produtos.MoveNext
36 Loop
Para preencher a lista com os nomes do produto, utilizamos Produtos.Fields(“ProductName”),

com isso, vou construindo uma nova opção da lista, para cada nome de produto encontrado
na tabela Produtos. É justamente isto que queremos. A construção dinâmica de listas é bastante
útil, sendo que esta técnica pode ser aplicada em diversas situações práticas no
desenvolvimento de aplicações Web.
IMPORTANTE
Observe que utilizamos Chr(34) antes e depois de Produtos.Fields(“ProductName”), na definição
do atributo value, conforme indicado a seguir: Chr(34) & Produtos.Fields(“ProductName”) & Chr(34)
Isto é feito para tratar o caso de nomes de produtos que tem espaço em branco no nome. Se
não utilizássemos as aspas (Chr(34)), somente o primeiro nome do produto seria utilizado.
Por exemplo, um produto chá mate, seria truncado em chá. Com isso, na hora de pesquisar o
nome do produto, não iríamos encontrá-lo na tabela Produtos.
Ao carregarmos a página produto.asp, obteremos o resultado indicado na Figura 6.9.
Nesta página o usuário seleciona o produto a ser alterado, conforme indicado na Figura 6.10,
onde o usuário selecionou o produto Camembert Pierrot. Após selecionar o produto, o usuário
clica no botão Localizar Produto. Ao fazer isso, é chamada a página localiza.asp, que irá
carregar o registro correspondente ao produto selecionado.
364
Figura 6.9: A página produto.asp.
Figura 6.10: O usuário seleciona um produto na lista de produtos.
A Página que Localiza o Registro do

Produto a ser Atualizado – localiza.asp
A página localiza.asp é indicada na Listagem 6.5.
365
Listagem 6.5 – Página ASP que carrega o registro a ser alterado.

2 <HTML>
3 <HEAD>
4 </HEAD>
5 <TITLE>Altere os dados do produto.</TITLE>
6 <BODY>
7 <%

15 conn.Open

17 ‘Este objeto irá acessar os campos
20 inst_sql=“Select * from Produtos WHERE Produtos.ProductName=‘” &

Request.Form(“listaprodutos”)& “’”
21 Produtos.Open inst_sql,conn,3,3
22 ‘Neste ponto tenho o objeto Produtos ligado com a tabela

24 %>
25 <P><FONT color=navy size=5><STRONG>Altere os campos que
forem necessários.</STRONG></FONT></P>
26 <P><I><B><FONT size=4>
Depois clique no botão Atualizar Produto</FONT>.</B></I></P>
366
27 <FORM action=atualiza.asp method=post>
28 <%
29 ‘Agora construo o formulário e exibo os dados

30 ‘do produto para que o usuário possa alterar
31 ‘os campos que forem necessários.
32 %>
33 <TABLE>
34 <%
35 Response.Write “<TR><TD>Código:</TD><TD><INPUT id=ProductID maxLength=10

name=ProductID size=10 value=” & Chr(34)& Produtos.Fields(“ProductID”) & Chr(34)&
“></TD></TR>”
36 Response.Write “<TR><TD>Nome:</TD><TD><INPUT id=ProductName maxLength=35

name=ProductName size=35 value=” & Chr(34)& Produtos.Fields(“ProductName”) &
Chr(34)& “></TD></TR>”
37 Response.Write “<TR><TD>Fornecedor:</TD><TD><INPUT id=SupplierID maxLength=30

name=SupplierID size=15 value=” & Chr(34) & Produtos.Fields(“SupplierID”) &
Chr(34) & “></TD></TR>”
38 Response.Write “<TR><TD>Categoria:</TD><TD><INPUT id=CategoryIDmaxLength=10 name=

CategoryID size=10 value=” & Chr(34) & Produtos.Fields(“CategoryID”) & Chr(34)
& “></TD></TR>”
40 Response.Write “<TR><TD>Quant/unid:</TD><TD><INPUT id=QuantityPerUnit maxLength=20

name=QuantityPerUnit size=20 value=” & Chr(34) & Produtos.Fields(“QuantityPerUnit”) &
Chr(34) & “></TD></TR>”
41 Response.Write “<TR><TD>Preço Unit:</TD><TD><INPUT id=UnitPrice 42

maxLength=10 name=UnitPrice size=10 value=” & Chr(34) & 43 Produtos.Fields
(“UnitPrice”) & Chr(34) & “></TD></TR>”
42 Response.Write “<TR><TD>Estoque:</TD><TD><INPUT id=UnitsInStockmaxLength=10
name=UnitsInStock size=10 value=” & Chr(34) & Produtos.Fields(“UnitsInStock”) &
Chr(34) & “></TD></TR>”
43 Response.Write “<TR><TD>Unid. Pedid:</TD><TD><INPUT id=UnitsOnOrder maxLength=10

name=UnitsOnOrder size=10 value=” & Chr(34) & 45Produtos.Fields(“UnitsOnOrder”) &
Chr(34) & “></TD></TR>”
367
44 Response.Write “<TR><TD>Nível Ordenação:</TD><TD><INPUT id=ReorderLevel maxLength=10

name=ReorderLevel size=10 value=” & Chr(34) & Produtos.Fields(“ReorderLevel”) &
Chr(34) & “></TD></TR>”
45 Response.Write “<TR><TD>Descontinuado:</TD><TD><INPUT id=Discontinued maxLength=10

name=Discontinued size=10 value=” & Chr(34) & Produtos.Fields(“Discontinued”) &
Chr(34) & “></TD></TR>”
46 %>
47 </TABLE>
48 <BR>
49 <HR>
50 <INPUT type=“submit” value=“Atualizar Produto” id=Atualizar name=Atualizar>
51 </FORM>
52 </BODY>
53 </HTML>
NOTA
Algumas linhas aparecem divididas em duas ou mais linhas. Nunca é demais lembrar que as
mesmas devem ser digitadas como uma linha única; apenas estão exibidas, em duas ou mais
linhas, por questão de espaço.
Alguns comentários sobre o código:

➥ Primeiro vamos tratar da construção da instrução SQL, conforme indicado no seguinte
trecho de código:
Request.Form(“listaprodutos”)& “’”
Esta é uma instrução SQL, que utiliza a cláusula WHERE para pesquisar apenas o registro
cujo nome do produto foi selecionado na lista de produtos. Vamos supor que o usuário tenha
selecionado o produto Geitost. A instrução SQL para localizar o registro para este produto,
deve ser a seguinte:
Select * from Produtos WHERE Produtos.ProductName=‘Geitost’
Observe no código da linha 20 que colocamos o apóstrofe logo após o sinal de igual (=), depois
utilizamos Request.Form(“listaprodutos”), para capturar o valor do produto que o usuário
selecionou na lista de produtos e, finalmente, anexamos o apóstrofe final (“ ’ ”). Com isso o código
ASP monta a instrução SQL correta, seja qual for o produto selecionado na lista de produtos.
Um detalhe importante a ser observado é que o critério, quando for um campo de texto, deve vir
entre os sinais de apóstrofe. Já para um campo do tipo data, o critério deve vir entre os sinais #.
368
Uma vez montada a instrução SQL corretamente, a mesma é passada como parâmetro para o
método Open do RecordSet Produtos. Com isso, apenas o registro para o produto selecionado,
será retornado pelo banco de dados.
➥ Após termos recuperado o registro para o produto selecionado, passamos a montar um
formulário, onde são exibidos os diversos campos do produto selecionado. Observe
que utilizamos uma tabela para facilitar o posicionamento e o alinhamento dos cam-
pos. Cada uma das linhas da tabela, possui duas colunas: uma onde vai a descrição do
campo e outra que exibe o campo propriamente dito. No exemplo abaixo, é montada a
primeira linha da tabela, onde é exibido o campo ProductID:
35 Response.Write “<TR><TD>Código:</TD><TD><INPUT id=ProductID maxLength=10
name=ProductID size=10 value=“ & Chr(34)& Produtos.Fields(“ProductID”) &
Chr(34)& “></TD></TR>”
Uma linha semelhante é utilizada para todos os demais campos do produto selecionado.
➥ Na Figura 6.11, o usuário selecionou o produto Queso Cabrales.
Figura 6.11: O usuário seleciona o produto a ser alterado.
Ao clicar no botão “Localizar Produto”, será chamada a página localiza.asp, a qual localiza o
registro do produto selecionado e exibe o mesmo em um formulário, para que o usuário
possa alterar os campos que forem necessários, conforme indicado na Figura 6.12.
O usuário pode alterar um ou mais campos, simplesmente clicando no campo e digitando

um novo valor. Após ter alterado os campos necessários, é só clicar no botão Atualizar Produto,
que os dados para o produto serão atualizados na tabela Produtos do banco de dados
nwind.mdb.
369
Figura 6.12: O usuário pode alterar quaisquer campos do produto.
A Página que Atualiza os Dados na Tabela Produtos do

Banco de Dados Nwind.mdb – Atualiza.asp
Quando o usuário clica no botão Atualizar Produto, é chamada a página atualiza.asp, a qual
é indicada na Listagem 6.6.
Listagem 6.6 – Página ASP que atualiza os dados no banco de dados – atualiza.asp.
2 <HTML>
3 <HEAD>
4 </HEAD>
5 <TITLE>Dados atualizados com sucesso.</TITLE>
6 <BODY>
7 <%
370

15 conn.Open
17 ‘Este objeto irá acessar o registro do Produto
18 ‘que será alterado.
Request.Form(“ProductName”)& “’”
22 ‘Começo a alterar os campos do registro
23 Produtos.Fields(“ProductName”)= Request.Form(“ProductName”)
24 Produtos.Fields(“SupplierID”)= Request.Form(“SupplierID”)
25 Produtos.Fields(“CategoryID”)= Request.Form(“CategoryID”)
26 Produtos.Fields(“QuantityPerUnit”)= Request.Form(“QuantityPerUnit”)
27 Produtos.Fields(“UnitPrice”)= Request.Form(“UnitPrice”)
28 Produtos.Fields(“UnitsInStock”)= Request.Form(“UnitsInStock”)
29 Produtos.Fields(“UnitsOnOrder”)= Request.Form(“UnitsOnOrder”)
30 Produtos.Fields(“ReorderLevel”)= Request.Form(“ReorderLevel”)
31 Produtos.Fields(“Discontinued”)= Cbool(Request.Form(“Discontinued”))
32 ‘Atualizo o registro, utilizando o método Update.
33 Produtos.Update
34 Response.Write “PRODUTO :”
35 Response.Write Request.Form(“ProductName”)
36 Response.Write “ Atualizado com sucesso <BR>”
38 %>
39 <A HREF=produto.asp>Clique aqui para atualizar outro produto</A>
40 </BODY>
41 </HTML>
Para atualizar o registro utilizamos o seguinte código:

23 Produtos.Fields(“ProductName”)= Request.Form(“ProductName”)
24 Produtos.Fields(“SupplierID”)= Request.Form(“SupplierID”)
25 Produtos.Fields(“CategoryID”)= Request.Form(“CategoryID”)
26 Produtos.Fields(“QuantityPerUnit”)= Request.Form(“QuantityPerUnit”)
371
27 Produtos.Fields(“UnitPrice”)= Request.Form(“UnitPrice”)
28 Produtos.Fields(“UnitsInStock”)= Request.Form(“UnitsInStock”)
29 Produtos.Fields(“UnitsOnOrder”)= Request.Form(“UnitsOnOrder”)
30 Produtos.Fields(“ReorderLevel”)= Request.Form(“ReorderLevel”)
31 Produtos.Fields(“Discontinued”)= Cbool(Request.Form(“Discontinued”))
32 ‘Atualizo o registro, utilizando o método Update.
33 Produtos.Update
Cada campo do registro recebe o valor contido no campo respectivo do formulário da Figura
6.12. Depois utilizamos o método Update para atualizar o registro. No momento que chamamos
o método Update é que as atualizações são gravadas no banco de dados.
Utilizando o Nosso Exemplo de Alteração de Registro

Vamos utilizar o nosso exemplo, passo a passo, para que possamos visualizar o funcionamento
completo do mesmo. Conforme indicado na Figura 6.13, carregamos a página produto.asp e
selecionamos o produto Ravioli Angelo.
Figura 6.13: Selecionando o produto Ravioli Angelo.
Ao clicarmos no botão Localizar Produto, é carregada a página localiza.asp, a qual nos exibe
os campos do produto Ravioli Angelo, conforme indicado na Figura 6.14.
Nesta página vamos alterar o valor do campo Preço Unit. Vamos alterar de 19,52 para 25,34,
372
Figura 6.14: O registro do produto Ravioli Angelo foi localizado.
Figura 6.15: Alterando o valor do campo Preço Unit.
Ao clicar no botão Atualizar Produto, é chamada a página atualiza.asp, que faz as atualizações
no banco de dados, exibe uma mensagem de que estas atualizações foram feitas com sucesso
373
e apresenta um link para que o usuário possa voltar para a página produto.asp para selecionar
um outro produto a ser atualizado, conforme indicado na Figura 6.16.
Figura 6.16: Os dados foram alterados com sucesso.
Na Figura 6.17, abrimos a tabela Produtos do banco de dados C:\meus documentos\ nwind.mdb,
na qual podemos comprovar que o preço unitário para o produto Ravioli Angelo foi realmente
alterado para 25,34.
Figura 6.17: Comprovando as alterações efetuadas.
IMPORTANTE
Veja que através da utilização de ASP podemos construir aplicações Web com as mesmas
funcionalidades de banco de dados existentes em aplicações tradicionais. Podemos inserir, pesquisar
e alterar registros. No próximo item aprenderemos a eliminar registros, utilizando ASP.
374
Eliminando Registros de um Banco de Dados

Neste tópico aprenderemos a criar uma página ASP que elimina um registro do banco de dados.
Nosso exemplo será composto dos seguintes elementos:

➥ Uma página ASP – produto.asp, onde temos um campo com a listagem de produtos
disponíveis na tabela Produtos, do banco de dados Nwind. Esta listagem será construída
dinamicamente, isto é, cada vez que a página for carregada, a listagem será construída
a partir das informações disponíveis na tabela Produtos. Está página já foi construída
no exemplo do item anterior, consulte a Listagem 6.4.
➥ Após selecionar o produto a ser alterado, o usuário clica em um botão Localizar produto.
Feito isso, a página produto.asp chama uma página chamada localiza.asp, a qual localiza
o registro selecionado no banco de dados. Com isso, o usuário pode conferir se este
realmente é o produto que ele deseja eliminar. Esta página já foi construída no item
anterior, consulte a Listagem 6.5, sendo que apenas iremos alterar a legenda do botão
de comando, ao invés de Alterar Produto, teremos Excluir Produto. Também será
alterado o atributo action da tag FORM, para que aponte para a página exclui.asp, ao
invés de apontar para a página atualiza.asp.
➥ Após conferir se o produto a ser excluído é o que está sendo exibido, o usuário clica no
botão Excluir produto. Então, a página localiza.asp chama a exclui.asp, que acessa o
banco de dados e exclui o produto selecionado pelo usuário. Ao final é emitida uma
mensagem indicando que os dados foram atualizados com sucesso.
A Página ASP Para Excluir o Produto Selecionado – Exclui.asp

Na Listagem 6.7 temos o código ASP para a criação da página exclui.asp.
Listagem 6.7 – Página ASP para excluir o produto selecionado – exclui.asp.

2 <HTML>
3 <HEAD>
4 </HEAD>
5 <TITLE>Produto excluído com sucesso.</TITLE>
6 <BODY>
7 <%

375

15 conn.Open
17 ‘Este objeto irá acessar o registro do Produto
18 ‘que será excluído.
20 inst_sql=“Select * from Produtos WHERE Produtos.ProductName=‘” & Request.Form
(“ProductName”)& “’”
22 If Produtos.RecordCount <> 1 Then
23 Response.Write “<B>O produto não existe, ou ”
24 Response.Write “existe mais do que um <BR> produto com este nome: </B>”
26 Else
27 Produtos.Delete
28 Response.Write “PRODUTO: ”
30 Response.Write “ foi excluído da tabela de Produtos. <BR>”
31 End If
33 %>
34 <A HREF=produto.asp>Clique aqui para selecionar outro produto a ser excluído.</A>
35 </BODY>
36 </HTML>
NOTA
Algumas linhas aparecem divididas em duas ou mais linhas. Nunca é demais lembrar que
estas devem ser digitadas como uma linha única. As mesmas estão exibidas em duas ou mais
linhas apenas por questão de espaço.
Comentário sobre o código:

➥ A única novidade na Listagem 6.7 é o trecho indicado a seguir:
22 If Produtos.RecordCount <> 1 Then
23 Response.Write “<B>O produto não existe, ou ”
376
24 Response.Write “existe mais do que um <BR> produto com este nome: </B>”
26 Else
27 Produtos.Delete
28 Response.Write “PRODUTO: ”
30 Response.Write “ foi excluído da tabela de Produtos. <BR>”
31 End If
Neste código utilizamos o método RecordCount para verificar se não foi encontrado nenhum
produto (RecordCount = 1) ou foi encontrado mais do que um produto (RecordCount>1).
Nestas duas situações informamos que o produto não existe ou existe mais do que um produto
com o nome selecionado. Em ambos os casos não podemos utilizar o método Delete.
Caso tenha sido encontrado somente um registro (RecordCount = 1), utilizamos o método
Delete do objeto Produtos, para eliminar o registro encontrado.
Neste exemplo, utilizamos o método Delete sem nenhum parâmetro, o que faz com que seja
eliminado somente o registro atual. Podemos passar um parâmetro para o método Delete, o
qual altera o comportamento do mesmo. Para isso utilizaríamos a seguinte sintaxe:
RecordSet.Delete parâmetro
Na Tabela 6.11, descrevemos os valores mais utilizados para o parâmetro do método Delete.
Tabela 6.11 Valores de parâmetro para o método Delete.
Valor Descrição
1 Elimina o registro atual, isto é, o registro no qual está o
indicador de registros.
2 Elimina somente os registros selecionados através da
utilização da propriedade Filter do objeto RecordSet. A
propriedade Filter já deve ter sido definida anteriormente.
3 Elimina todos os registros do objeto RecordSet.
Utilizando o Nosso Exemplo de Exclusão de Registro

Vamos utilizar o nosso exemplo, passo a passo, para que possamos visualizar o funcionamento
completo do mesmo. Conforme indicado na Figura 6.18, carregamos a página produto.asp e
selecionamos o produto Filo Mix.
377
Figura 6.18: Selecionando o produto Filo Mix.
Ao clicarmos no botão Localizar Produto, é carregada a página localiza.asp, a qual nos exibe
os campos do produto Filo Mix, conforme indicado na Figura 6.19.
Figura 6.19: O registro do produto Filo Mix foi localizado.
378
Os dados do produto Filo Mix são exibidos para que o usuário confira se este realmente é o
produto a ser excluído no banco de dados. Para excluir o produto selecionado é só clicar no
botão Excluir Produto.
Ao clicar no botão Excluir Produto, é chamada a página exclui.asp, que exclui o produto
selecionado, e exibe uma mensagem de que a exclusão foi realizada com sucesso e apresenta
um link para que o usuário possa voltar para a página produto.asp para selecionar um outro
produto a ser excluído, conforme indicado na Figura 6.20.
Figura 6.20: O produto Filo Mix foi excluído com sucesso.
Na Figura 6.21, abrimos a tabela Produtos do banco de dados C:\meus documentos\ nwind.mdb,
na qual podemos comprovar que o produto Filo Mix foi realmente excluído.
Figura 6.21: Comprovando a exclusão do produto Filo Mix.
379
IMPORTANTE
Veja que através da utilização de ASP podemos construir aplicações Web com as mesmas
funcionalidades de banco de dados existentes em aplicações tradicionais. Podemos inserir,
pesquisar, alterar e excluir registros.
A Propriedade Filter do Objeto RecordSet

Podemos configurar a propriedade Filter para exibir apenas um conjunto de registros que
satisfaçam uma ou mais condições. Por exemplo, posso ter criado um RecordSet que retorna
todos os registros da tabela Pedidos (Orders) do banco de dados nwind.mdb. Depois posso
configurar a propriedade Filter para que somente sejam exibidos os registros cujo País de
destino seja o Brasil.
A configuração da propriedade Filter apenas faz com que seja limitada a visibilidade do
RecordSet. Podemos redefinir a propriedade Filter, de tal maneira que todos os registros voltem
a estar disponíveis.
Na Listagem 6.8, criamos uma página que acessa a tabela Orders, do banco de dados
nwind.mdb. São recuperados os campos OrderID, OrderDate, ShipCity e ShipCountry. Depois
utilizamos a propriedade Filter, para exibir somente os pedidos para o ano de 1994.
Listagem 6.8 – Exibindo somente os pedidos para o ano de 1994 – filter_pedidos.asp.

2 <HTML>
3 <HEAD>
4 </HEAD>
5 <TITLE>Utilizando a propriedade Filter.</TITLE>
6 <BODY>
7 <%

380

documentos\nwind.mdb”
15 conn.Open

18 ‘da tabela Orders.
20 inst_sql=“SELECT Orders.OrderID, Orders.OrderDate, Orders.ShipCity, Orders.

ShipCountry, Year([OrderDate]) AS AnoPedido FROM Orders Order By ShipCountry ”
22 ‘Neste ponto tenho o objeto Pedidos ligado com a tabela

24 %>
25 <P><FONT color=navy size=6><B>Empresa ABC Ltda.</B></FONT></P>

26 <P><B><I>Listagem de Produtos para o ano de: <FONT color=red>1994</FONT>
27 </I></B>
28 <HR>
29 </P>
30 <%
31 ‘Configura a propriedade Filter para exibir

32 ‘somente os registros em que o ano do campo
33 ‘OrderDate é igual a 1994.
34 Pedidos.Filter = “AnoPedido=1994”
35 ‘Agora construo uma tabela para exibir os resultados.
36 %>
381
37 <%
38 <TABLE>
39 <TR>
40 <TD>Código</TD>
41 <TD>Data</TD>
42 <TD>Cidade</TD>
43 <TD>País</TD>
44 <TD>Ano</TD>
45 </TR>
46 <%
47 Pedidos.MoveFirst
48 Do Until Pedidos.EOF %>
49 <TR>
50 <TD><% =Pedidos.Fields(“OrderID”) %></TD>
51 <TD><% =Pedidos.Fields(“OrderDate”) %></TD>
52 <TD><% =Pedidos.Fields(“ShipCity”) %></TD>
53 <TD><% =Pedidos.Fields(“ShipCountry”)%></TD>
54 <TD><% =Pedidos.Fields(“AnoPedido”) %></TD>
55 </TR>
56 <%
57 Pedidos.MoveNext
58 Loop
59 %>
60 </TABLE>
61 </BODY>
62 </HTML>
Ao carregarmos esta página, obteremos o resultado indicado na Figura 6.22.
382
Figura 6.22: Pedidos para o ano de 1994.
Vamos fazer alguns comentários sobre o código.

➥ Primeiro gostaria de comentar a construção da instrução SQL:
Orders.ShipCountry, Year([OrderDate]) AS AnoPedido FROM Orders Order By
ShipCountry”
Observe que na instrução SQL, utilizamos a função Year(NomeDoCampo), para criar um campo
chamado AnoPedido, o qual contém apenas o ano da data do Pedido. Esta construção mostra o
poder e a simplicidade da linguagem SQL, motivo pelo qual foi colocado anteriormente sobre a
importância de aprendermos a utilizar com eficiência a linguagem SQL.
➥ Agora vamos observar a utilização da propriedade Filter, no seguinte fragmento de código:
34 Pedidos.Filter = “AnoPedido=1994”
Com este comando estamos restringindo os registros de tal forma que somente sejam exibidos
os registros cujo campo AnoPedido seja igual a 1994.
Para salientar a flexibilidade desta propriedade, vamos considerar um outro exemplo. Vamos
supor que seja necessário exibir apenas os pedidos para o ano de 1994 e cujo país de destino
fosse o Brazil (com “z” porque no banco de dados Nwind está com “z”). Para obter este resultado,
bastaria definir a propriedade Filter da seguinte maneira:
Pedidos.Filter = “AnoPedido=1994 And ShipCountry=“Brazil’”
383
Quando queremos que os registros atendam a dois ou mais critérios, simultaneamente,

utilizamos o operador And. Neste caso somente serão exibidos os registros em que o campo
AnoPedido for 1994 e o campo ShipCountry for Brazil, conforme indicado na Figura 6.23.
Figura 6.23: Pedidos para o “Brazil” no ano de 1994.
Vamos refinar um pouco mais. Vamos fazer com que sejam exibidos apenas os registros para
o ano de 1994 e para Brazil ou Germany (Alemanha).
Pedidos.Filter = “(AnoPedido=1994 And ShipCountry=‘Brazil’) OR (AnoPedido=1994 And
ShipCountry=‘Germany’)”
Este comando deve ser digitado em uma única linha, além disso os espaços devem ser
rigorosamente respeitados. Após fechar parênteses, apenas um espaço, após o OR mais um
espaço e assim por diante. Na Figura 6.24 temos o resultado desta pesquisa, na qual são
exibidos apenas os pedidos para o Brazil e para a Germany, no ano de 1994.
Observe que, com a correta utilização da propriedade Filter, podemos obter resultados
interessantes. Voltaremos a utilizar esta propriedade em outros exemplos deste livro.
Para eliminar qualquer filtro aplicado e voltar a disponibilizar todos os registros, basta utilizar
os seguinte comando:
Pedidos.Filter = “ ”
384
Figura 6.24: Pedidos para “Brazil” e para “Germany” no ano de 1994.
Com isso elimino qualquer filtro que tenha sido aplicado.
Também podemos utilizar o operador Like para fazer uma pesquisa por padrões. Por exemplo,
vamos supor que queremos filtrar apenas os registros cujo campo NomeCliente inicie com a
letra J. Poderíamos utilizar o seguinte comando:
Pedidos.Filter = “NomeCliente Like ‘J%’ ”
Neste caso o % funciona como um caractere curinga, isto é, a primeira letra do nome deve ser
J e o que vem depois não importa. Neste caso seriam retornados registros tais como:
➥ José da Silva
➥ Juvenal Pereira
➥ Júlio Battisti
Conclusão
No início do capítulo aprendemos a estabelecer conexões com banco de dados, sem utilizar
ODBC. Fizemos isto, definimos a propriedade ConnectionString do objeto Connection,
385
acessando as fontes de dados utilizando o provedor OLE DB para cada fonte. Foram
apresentados exemplos para o Microsoft Access, Microsoft SQL Server e ORACLE.
Neste capítulo também fizemos um estudo detalhado do objeto RecordSet.
Saber utilizar o objeto RecordSet é de fundamental importância para a criação de aplicações

Web com acesso a bancos de dados. Estudamos os diversos métodos, propriedades e eventos
deste objeto.
Aprendemos a criar páginas ASP que fazem operações bastante comuns em aplicações Web,
tais como:
➥ Pesquisar registros em um banco de dados.
➥ Alterar registros.
➥ Eliminar registros.
➥ Fazer a validação dos dados digitados em um formulário.
➥ Filtrar os registros retornados por um objeto RecordSet.
386
Capítulo 7 – Bancos de Dados com ASP – Conceitos Avançados Parte II
Capítulo 7
Bancos de Dados com ASP –
Conceitos Avançados Parte II
387
Neste capítulo serão apresentados mais alguns tópicos sobre o acesso a banco de dados.
Iniciaremos por um estudo do objeto Command, o qual pode ser utilizado para retornar um
conjunto de registros em um objeto RecordSet e para efetuar operações que envolvem diversos
registros – como, por exemplo, atualizar o campo PreçoUnitário em todos os registros da
tabela Produtos. O objeto Command também pode ser utilizado para passar parâmetros para
uma Consulta Parametrizada.
Faremos um exemplo completo sobre a passagem de parâmetros para uma Consulta

Parametrizada do Microsoft Access. Com a utilização de Consultas Parametrizadas podemos
criar páginas ASP bastante flexíveis, que nos permitem executar consultas de maneira interativa
com o banco de dados. O usuário seleciona um valor para um ou mais parâmetros e executa
a consulta. Caso deseje uma nova consulta é só selecionar novos valores para os parâmetros
e executar novamente a consulta. Com isso podemos obter uma série de resultados de maneira
simples e prática.
Veremos exemplos de acesso a banco de dados com a utilização dos métodos e propriedades
do objeto Command. Serão apresentadas tabelas com a descrição dos principais métodos e
propriedades deste objeto. A utilização do objeto Command é especialmente indicada para
situações onde temos que passar parâmetros para Consultas Parametrizadas ou para Stored
Procedures. Através da utilização do objeto Command e de seus métodos, propriedades e
coleções, podemos criar os diversos parâmetros necessários, passá-los para o banco de dados
e, até mesmo, receber valores de retorno de Stored Procedures em parâmetros definidos para
o objeto Command.
Também estudaremos o objeto Parameter, utilizado na criação e definição dos parâmetros a

serem utilizados pelo objeto Command. Veremos como criar e definir um determinado
parâmetro.
Também serão apresentadas tabelas com a descrição dos principais métodos e propriedades
dos diversos objetos estudados.
Na seqüência, analisaremos mais alguns exemplos de pesquisa em banco de dados, utilizando

páginas ASP. Trataremos um pouco mais sobre a construção de instruções SQL avançadas, as
quais utilizam o operador Like e funções de agregação como Sum, Avg, Min e Max. Também
trataremos, diretamente em uma instrução SQL, da utilização dos operadores And e Or, bem
como de funções como Year, Month e Day.
Como exemplo de aplicação, no final do capítulo, criaremos um formulário que permite que
o próprio usuário defina a pesquisa a ser realizada. No formulário, o usuário poderá fazer
pesquisa na tabela Orders do banco de dados Nwind. O usuário poderá decidir se deseja
fazer a pesquisa por País de destino, País de destino e Cidade, por Ano da Data do Pedido ou
388
Mês da Data do Pedido. Também utilizaremos o modelo de eventos do Internet Explorer para
ativar ou desativar campos à medida em que o usuário seleciona opções no formulário.
Neste capítulo, estaremos utilizando como exemplo o banco de dados nwind.mdb do Microsoft
Access. Existem pequenas diferenças na linguagem SQL do Microsoft Access e do Microsoft
SQL Server. Para maiores detalhes sobre a criação de instruções com o Microsoft SQL Server,
consulte a documentação do produto.
O Objeto Command
Utilizamos o objeto Command para definir um determinado “comando” que deverá ser
executado em um fonte da dados, como um banco de dados do Microsoft Access ou do
Microsoft SQL Server. O objeto Command é especialmente indicado para a execução de
comandos que necessitem de parâmetros, com por exemplo, Stored Procedures de um banco
de dados do Microsoft SQL Server, ou Consultas Parametrizadas do Microsoft Access.
NOTA
Uma Consulta Parametrizada é um tipo especial de consulta, a qual espera receber um ou
mais valores (os parâmetros). Os valores recebidos são utilizados, normalmente, como critérios
de pesquisa, de tal forma que somente serão retornados os registros que atenderem os critérios
especificados. Por exemplo, poderíamos ter um parâmetro no campo ShipCountry da tabela
Orders do banco de dados nwind.mdb. Se passarmos para este parâmetro o valor Germany,
serão retornados apenas os registros em que o campo ShipCountry for igual a Germany.
Um Breve Introdução ao Objeto Command

Para criar um objeto Command utilizamos a seguinte sintaxe:
Set nome_objeto = Server.CreateObject(“ADODB.Command”)
O exemplo, a seguir, cria o objeto Command chamado Pedidos:

Set Pedidos = Server.CreateObject(“ADODB.Command”).
IMPORTANTE
Nunca é demais lembrar que, para criar um objeto, devemos utilizar o operador Set, caso
contrário obteremos um erro quando a página for carregada.
Para iniciarmos o estudo do objeto Command, vamos analisar o exemplo da Listagem 7.1.
389
Listagem 7.1 – Utilizando o objeto Command para retornar dados – command1.asp.

2 <HTML>
3 <HEAD>
4 </HEAD>
5 <TITLE>Utilizando o objeto Command.</TITLE>
6 <BODY>
7 <%


15 conn.Open
16 ‘Agora crio um objeto do tipo Command, o qual será,

17 ‘automaticamente, associado com a conexão conn.
18 Set com_orders = Server.CreateObject(“ADODB.Command”)
19 com_orders.CommandText = “Select * From Orders Order By OrderDate”

20 com_orders.ActiveConnection = conn
21 ‘Agora retorno o resultado do comando, utilizando o

22 ‘método Execute.
23 ‘Este resultado será armazenado em um objeto RecordSet
24 ‘chamado Ped.
25 Set Ped= Server.CreateObject(“ADODB.RecordSet”)

26 Set Ped=com_orders.Execute
390
27 %>
28 <HR>
29 <TABLE>
30 <TR>
31 <TD>Código</TD>
32 <TD>Data </TD>
33 </TR>
34
35 <%
36 Do Until Ped.EOF
37 %>
38 <TR>
39 <TD><%=Ped.Fields(“OrderID”) %> </TD>
40 <TD><%=Ped.Fields(“OrderDate”)%> </TD>
41 </TR>
42 <%
43 Ped.MoveNext
44 Loop
45 %>
46 </TABLE>
47 <HR>
48 </BODY>
49 </HTML>
Ao carregarmos este arquivo obtemos o resultado indicado na Figura 7.1.
A novidade na Listagem 7.1 é a utilização do objeto Command para a obtenção do RecordSet

Ped. Vamos analisar os métodos e propriedades que foram utilizados.
Primeiro criamos um objeto do tipo Command, conforme indicado pelo seguinte comando:
18 Set com_orders = Server.CreateObject(“ADODB.Command”)
391
Figura 7.1: Carregando a página comand1.asp.
O próximo passo é definir a propriedade CommandText. Esta propriedade foi configurada

com a instrução SQL que deverá ser executada no banco de dados, para retornar os registros
desejados. No nosso exemplo, a instrução SQL retorna todos os registros da tabela Orders e
ordena a listagem pelo campo OrderDate, conforme indicado no seguinte comando:
19 com_orders.CommandText = “Select * From Orders Order By OrderDate”
Em seguida definimos a conexão com a qual o objeto com_orders está associado. Para isto
definimos a propriedade ActiveConnection, conforme indicado no seguinte comando:
20 com_orders.ActiveConnection = conn
A partir de agora, os comandos executados pelo objeto Command serão executados na conexão
conn, que está ligada ao banco de dados nwind.mdb.
Agora criamos um objeto do tipo RecordSet chamado Ped:

O último passo é utilizar o método Execute do objeto com_orders. Ao utilizarmos este método,
é executada a instrução contida na propriedade CommandText. O resultado é retornado para
o objeto RecordSet especificado no comando, conforme indicado abaixo:
26 Set Ped=com_orders.Execute
392
Neste caso após a execução do método Execute, os registros retornados estarão armazenados
no objeto Ped, o qual é um objeto do tipo RecordSet.
Veja que o que fizemos foi, simplesmente, utilizar um objeto Command e as propriedades
CommandText, ActiveConnection e o método Execute, para criar um objeto RecordSet com
todos os registros da tabela Orders.
Você pode estar questionando: “Por que todos esses passos, se podemos simplesmente utilizar
o método Open do objeto RecordSet, como já fizemos nos capítulos anteriores?”.
A resposta é simples. Estamos estudando o objeto Command porque existem determinadas

operações que somente podem ser executadas com este objeto, como por exemplo, passar
parâmetros para um Stored Procedure ou uma Consulta Parametrizada.
Agora que já fizemos um estudo preliminar do objeto Command, vamos apresentar as demais
propriedades e métodos deste objeto.
Os Métodos do Objeto Command

Na Tabela 7.1 temos uma descrição dos métodos do objeto Command.
Tabela 7.1 Os métodos do objeto Command.
Método Descrição
Cancel Cancela a execução do método Execute caso a mesma
ainda esteja pendente.
CreateParameter Cria um novo objeto do tipo Parameter. Pode ser
utilizado, por exemplo, para passar parâmetros para
Consultas Parametrizadas do Microsoft Access.
Execute Executa uma pesquisa, instrução SQL ou Stored
Procedure especificado na propriedade CommandText.
Ainda neste item veremos exemplos de aplicação destes métodos.
As Propriedades do Objeto Command

Na Tabela 7.2 temos uma descrição das propriedades do objeto Command.
393
Tabela 7.2 As propriedades do objeto Command.
ActiveConnection Determina a qual conexão o objeto Command estará
ligado, isto é, através de qual conexão os comandos
serão executados.
CommandText Contém o texto do comando que será executado contra
a conexão definida na propriedade ActiveConnection.
CommandTimeout Indica por quanto tempo o comando pode ser
executado. Caso o comando não retorne um resultado
no tempo especificado por esta propriedade, será
gerada uma mensagem de erro e a execução do
comando será suspensa. O tempo é especificado em
segundos e o valor padrão é 30 segundos.
CommandType Indica o tipo de comando que será executado. Na tabela
7.3 temos uma descrição dos tipos de comandos possíveis.
Name Indica o nome do objeto Command.
Parameters Contém todos os objetos do tipo Parameter definidos
para o objeto Command.
Prepared Indica se é para salvar ou não uma versão compilada
do objeto Command após a execução do mesmo. O
armazenamento de versões compiladas melhora o
desempenho do banco de dados. Esta possibilidade
depende do banco de dados que está sendo acessado.
O Microsoft SQL Server 2000 permite que sejam
criadas e armazenadas versões compiladas dos
comandos e Store Procedures executados. Assim, da
próxima vez que o comando for executado, o mesmo
não precisa ser novamente interpretado para gerar a
versão compilada. Em ambientes acessados por um
grande número de usuários, este recurso pode ser de
grande valia para melhorar o desempenho.
Properties Contém todos os objetos do tipo Property definidos
para o objeto Command.
State Indica se o objeto Command está aberto (Open) ou
fechado (Closed). Esta propriedade é somente para leitura.
394
Na Tabela 7.3, temos uma relação dos tipos de comandos possíveis, os quais são definidos
pela propriedade CommandType.
Tabela 7.3 Valores possíveis para a propriedade CommandType.
Valor/Constante Tipo de comando

-1/adCmdUnspecified Não especifica o tipo de Comando.
1/adCmdText Avalia o texto definido na propriedade
CommandText, o qual pode ser uma instrução SQL
ou uma chamada para um Stored Procedure do
banco de dados.
2/adCmdTable Considera o valor da propriedade CommandText
como sendo o nome de uma tabela que foi gerada
a partir de uma instrução SQL. Somente retorna as
colunas definidas pela instrução SQL. Para retornar
todas as colunas, devemos utilizar o tipo 512 –
adCmdTableDirect.
4/adCmdStoredProc Considera o valor da propriedade CommandText
como sendo o nome de um Stored Procedure.
8/adCmdUnknown Considera o valor da propriedade CommandText
como sendo de tipo desconhecido. É o valor padrão.
256/adCmdFile Considera o valor da propriedade CommandText
como sendo o nome de um RecordSet armazenado
em um arquivo.
512/adCmdTableDirect Considera o valor da propriedade CommandText
como sendo o nome de um tabela em que todos os
campos são retornados.
A sintaxe para definir a propriedade CommandType é a seguinte:

Objeto.CommandType = valor
ou
Objeto.CommandType = constante
Observe que podemos utilizar o valor numérico ou uma constante predefinida. Por exemplo,
podemos utilizar o valor 1 ou a constante adCmdText para definir o tipo do comando como
sendo texto.
395
Existe um grande número de constantes predefinidas para os objetos ADO. Estas constantes
estão localizadas nos seguintes arquivos:
➥ adovbs.inc: Constantes para a linguagem VBScript.
➥ adojavas.inc: Constantes para a linguagem JScript.
Estes arquivos estão localizados, normalmente, em uma das seguintes pastas:
➥ Para o Windows 2000 em Português: Arquivos de programas\Arquivos comuns\System\ADO.
➥ Para o Windows 2000 em Inglês: Program Files\Common Files\system\ado.
Para que possamos utilizar estas constantes, devemos utilizar uma diretiva include para incluir
estes arquivos, ou definir uma referência utilizando a tag a seguir:
<!- -METADATA TYPE=“typelib” uuid=”{00000205-0000-0010-8000-00AA006D2EA4}” – ->
Esta tag deve ser incluída dentro da seção <HEAD></HEAD> de cada página ASP que
utilizará as constantes ou no arquivo global.asa. Ao serem incluídas no arquivo global.asa, as
constantes estarão disponíveis para qualquer página ASP que faça parte da aplicação Web.
NOTA
Voltaremos a falar sobre o arquivo global.asa.
Agora vamos ver alguns exemplos de código para o objeto Command, alguns de seus métodos
e propriedades.
Vamos iniciar criando um objeto Connection e um objeto Command, conforme indicado pelo
trecho a seguir:
‘Criamos um objeto do tipo Connection
Set conn=Server.CreateObject(“ADODB.Connection”)
‘Agora abro uma conexão com o arquivo nwind.mdb

‘utilizando OLE DB.
conn.ConnectionString = “PROVIDER=MICROSOFT.JET.OLEDB.4.0;
conn.Open
‘Agora crio um objeto do tipo Command
Set com_orders = Server.CreateObject(“ADODB.Command”)
396
Uma vez criado o objeto Command, vamos definir qual a conexão que o mesmo utilizará.
Para isso definimos a propriedade ActiveConnection:
com_orders.ActiveConnection = conn
Agora vamos definir o tipo de comando. Para isso utilizaremos a propriedade CommandType:
com_orders.CommandType = 1
Ao invés do valor numérico podemos utilizar a constante equivalente, conforme indicado no exemplo:
com_orders.CommandType = adCmdText
Agora vamos definir o comando que o objeto Command executará. Para isso definimos a
propriedade CommandText:
com_orders.CommandText = “Select * From Orders Order By OrderDate”
Vamos definir o TimeOut em 2 minutos (120 segundos) para a execução deste objeto Command,
utilizando a propriedade CommandTimeout:
com_orders.CommandTimeout= 120
Agora vamos criar um objeto RecordSet e utilizar o método Execute do objeto Command para
retornar registros para o objeto RecordSet:
Set Ped= Server.CreateObject(“ADODB.RecordSet”)
Set Ped=com_orders.Execute
Consultas Parametrizadas no Microsoft Access

Conforme descrito anteriormente, podemos utilizar o objeto Command para passar parâmetros
para Consultas Parametrizadas do Microsoft Access ou para Stored Procedures do Microsoft
SQL Server. Neste tópico aprenderemos a trabalhar com parâmetros.
NOTA
Para saber mais sobre a criação de consultas no Microsoft Access, consulte a documentação do
produto ou consulte o livro “Microsoft Access 2000 Curso Básico e Rápido”, da editora Axcel Books.
Na Figura 7.2 temos uma consulta do Microsoft Access. A consulta é baseada na tabela Orders
e foram incluídos os seguintes campos:
➥ OrderID
➥ OrderDate
➥ ShipName
397
➥ ShipCity
➥ ShipCountry
Figura 7.2: Consulta no Microsoft Access.
Ao executarmos esta consulta, no Microsoft Access, são exibidos todos os pedidos, pois nenhum
critério de filtragem foi imposto. Na Figura 7.3, vemos o resultado da execução desta consulta.
Figura 7.3: Execução da consulta sem critérios de filtragem.
398
Podemos definir um critério de filtragem. Por exemplo, queremos que sejam exibidos os pedidos
apenas para a Argentina. Para isso poderíamos especificar um critério para o campo
ShipCountry, conforme indicado na Figura 7.4.
Figura 7.4: Especificando um critério para o campo ShipCountry.
Ao executarmos esta consulta, no Microsfot Access, serão exibidos apenas os pedidos em que
o campo ShipCountry seja igual a Argentina. Na Figura 7.5, vemos o resultado da execução
desta consulta.
Figura 7.5: Execução da consulta com um critério de pesquisa.
399
Observe que somente foram exibidos os pedidos para a Argentina, o que confirma o correto
funcionamento do critério que foi especificado.
Porém esta maneira de especificar critérios é pouco flexível, pois cada vez que quisermos
alterar o critério, teremos que digitar o novo critério, salvar a consulta e executá-la novamente.
Podemos obter uma maior flexibilidade especificando um parâmetro para a consulta. Depois,
colocamos este parâmetro como critério no campo ShipCountry. Ao especificarmos um
parâmetro como critério para este campo, cada vez que a consulta for executada, o Microsoft
Access nos pergunta o valor do parâmetro. Nós digitamos o valor desejado que passa a servir
como critério de filtragem.
Para definir um parâmetro, selecione o menu Consulta -> Parâmetros. Na janela que surge
digite Pais (sem acento) para o nome do parâmetro e selecione Texto para o tipo do parâmetro,
Figura 7.6: Definindo um parâmetro para a consulta.
Depois basta colocar como critério, no campo ShipCountry, o nome do parâmetro entre
colchetes, conforme indicado na Figura 7.7.
Ao executar esta consulta, o Microsoft Access reconhece a existência do parâmetro, e abre

uma janela pedindo para que o usuário digite um valor para o parâmetro, conforme indicado
na Figura 7.8.
Vamos supor que o usuário digite France e dê um clique em OK. Serão exibidos todos os
pedidos em que o campo ShipCountry seja igual a France, conforme indicado na Figura 7.9.
400
Figura 7.7: Definindo o parâmetro como critério para o campo ShipCountry.
Figura 7.8: O usuário deve digitar um valor para o parâmetro.
Figura 7.9: Execução da consulta com o valor do parâmetro definido como France.
401
Utilizando parâmetros, cada vez que a consulta é executada, podemos fornecer um valor
diferente para o parâmetro, valor esse que serve para filtrar os resultados. Podemos definir
parâmetros em mais do que um campo da consulta, com isso, ao executar a consulta, serão
pedidos valores para cada um dos parâmetros definidos.
O nosso objetivo é poder, a partir de uma página ASP, executar uma Consulta Parametrizada
do Microsoft Access. Para isso, precisamos passar, a partir da página ASP, os valores para os
parâmetros definidos na consulta. Isso é possível de ser feito com a utilização do objeto
Parameter e a propriedade Parameters do objeto Command.
Na seqüência deste capítulo estudaremos o objeto Parameter, bem como a passagem de

parâmetros utilizando o objeto Command.
NOTA
Esta consulta foi salva com o nome de con_pedidos. Utilizaremos este nome em exemplos mais
adiante. Caso você tenha criado uma consulta com um nome diferente, utilize o nome da
consulta que você criou, nos exemplos deste capítulo.
O Objeto Parameter
O objeto Parameter representa parâmetros associados com Consultas Parametrizadas ou
argumentos de entrada e valores de retorno para Stored Procedures. Com a utilização do
objeto Parameter podemos definir, detalhadamente, os parâmetros que serão enviados para
uma Consulta Parametrizada, ou os argumentos de entrada enviados para um Stored Procedure.
Na Tabela 7.4, temos uma descrição das principais propriedades do objeto Parameter.
Tabela 7.4 Principais propriedades do objeto Parameter.
Attributes Indica uma ou mais características do objeto Parameter.
Direction Define se o objeto Parameter representa um parâmetro de
entrada, de saída ou ambos; ou indica se o parâmetro é
um valor de retorno de um Stored Procedure.
Name Contém o nome do objeto Parameter.
NumericScale Indica uma faixa de valores numéricos aceitáveis para o
valor do parâmetro.
402
Precision Indica a precisão a ser utilizada para valores numéricos.
Size Indica o tamanho máximo do parâmetro, em bytes ou
caracteres.
Type Indica o tipo de dados para o objeto Parameter.
Value Indica o valor associado com o objeto Parameter.
NOTA
Um Stored Procedure é um conjunto de comandos gravados com um nome no banco de dados.
Podemos, por exemplo, criar um Stored Procedure que gera uma listagem com o total de vendas
por mês do ano. Um Stored Procedure pode receber valores como argumentos de entrada. Um
exemplo de argumento de entrada poderia ser o ano para o qual deve ser gerada uma listagem
do total de vendas mensais. Um Stored Procedure também pode retornar valores após a sua
execução. Podemos utilizar o objeto Parameter para enviar argumentos de entrada e também
para receber os valores calculados pelo Stored Procedure.
Para cada parâmetro, que o objeto Command precisa tratar, é criado um objeto Parameter.
Todos os objetos Parameter podem ser acessados através da coleção Parameters do objeto
Command. Para criar um objeto do tipo Parameter, podemos utilizar o método CreateParameter
do objeto Command.
Utilizando o Objeto Command Para Passar

Parâmetros Para uma Consulta Parametrizada
Neste item vamos utilizar o objeto Command e a sua coleção Parameters para acessar a consulta
con_pedidos e passar um valor para o parâmetro Pais da consulta. Vamos criar um formulário,
onde temos uma lista, gerada dinamicamente pelo ASP, na qual temos a listagem dos países
em ordem alfabética. O usuário seleciona um país na lista e clica no botão Pesquisar. Feito
isso será chamada uma página procurapais.asp, que passa o valor selecionado na lista como
parâmetro para a consulta con_pedidos, a qual retorna a listagem dos pedidos para o país
selecionado. A página inicial, na qual construiremos a listagem de países, será chamada de
command2.asp.
Na Figura 7.10 temos um diagrama do funcionamento do nosso exemplo.
403
nwind.mdb
command2.asp procurapais.asp
Consulta:
con_pedidos
Figura 7.10: Diagrama de funcionamento do exemplo proposto.
Na Listagem 7.2 temos o código que cria a página command2.asp.
Listagem 7.2 – Criando a lista com o nome dos países – command2.asp.

2 <HTML>
3 <HEAD>
4 </HEAD>
5 <TITLE>Selecione o País de destino.</TITLE>
6 <BODY>
7 <%

9 ‘para isto crio um objeto do tipo Connection.

15 conn.Open

19 Set Paises = Server.CreateObject(“ADODB.Recordset”)
404
20 Paises.Open “Select ShipCountry from Orders Group By ShipCountry Order By

ShipCountry”, conn, 3, 3
21 ‘Neste ponto tenho o objeto Paises com uma listagem

22 ‘em ordem ascendente, dos países para os quais existem
23 ‘pedidos efetuados.
24 %>
25 <P><B>Selecione o país a ser pesquisado.</B></P>

26 <P><B><I>Depois clique no botão Pesquisar.</I></B></P>
27 <FORM action=procurapais.asp method=post id=form1 name=form1>

28 <SELECT id=listapaises name=listapaises>
29 <%

31 ‘dados obtidos da tabela Orders.
32 ‘Para cada país obtido, crio uma nova opção
33 ‘na lista.
34 Do While Not Paises.EOF

35 Response.Write “<OPTION value=” & Chr(34) & Paises.Fields(“ShipCountry”) &
Chr(34) & “>” & Paises.Fields(“ShipCountry”)& “</OPTION>”
36 Paises.MoveNext
37 Loop
38 %>
39 </SELECT>
40 <BR>
41 <HR>
42 <INPUT type=“submit” value=Pesquisar id=Pesquisar name=Pesquisar>
43 </FORM>
44 </BODY>
45 </HTML>
405
Agora precisamos construir a página procurapais.asp. Esta página receberá o valor selecionado
na lista, passará este valor para o parâmetro Pais da consulta con_pedidos, a qual irá retornar
somente os pedidos para o país selecionado. A página procurapais.asp também exibirá os
resultados obtidos.
Na Listagem 7.3 temos o código que cria a página procurapais.asp.
Listagem 7.3 – Passando um valor para o parâmetro Pais da consulta con_pedidos.

2 <HTML>
3 <HEAD>
4 </HEAD>
5 <TITLE>Resultados da pesquisa.</TITLE>
6 <BODY>
7 <%

15 conn.Open
16 ‘Agora criamos um objeto RecordSet para reapresentar

17 ‘a lista de países no final, para que o usuário possa
18 ‘fazer uma nova pesquisa.

21 ‘Agora crio um objeto do tipo Command

22 ‘defino a conexão ativa utilizando a propriedade ActiveConnection.
23 ‘Depois defino o tipo de comando utilizando a propriedade
406
24 ‘CommandType. O valor 4 significa que é um Stored Procedure.

25 ‘Para o caso de consultas do Microsoft Access devemos definir
26 ‘o tipo como sendo Stored Procedure.
27 ‘Ao invés do valor 4 poderíamos utilizar a constante
28 ‘adCmdStoredProc
29 Set com_paises = Server.CreateObject(“ADODB.Command”)
30 com_paises.ActiveConnection = conn
31 com_paises.CommandType = 4
32 ‘Agora começo a definir as características do parâmetro.
33 ‘Crio variável para definir o nome do parâmetro.
34 nome_par = “Pais”
35 ‘Crio uma variável para conter o valor do parâmetro.

36 ‘Defino este valor como sendo o valor selecionado
37 ‘na lista de países.
38 valor_par= Request.Form(“listapaises”)
39 ‘Agora crio variáveis que definem as demais

40 ‘ características do parâmetro.
41 tipo_par = 129 ‘parâmetro do tipo string.

42 tama_par = 50 ‘define o tamanho do parâmetro.
43 dire_par = 1 ‘define um parâmetro de entrada.
44 ‘Agora crio um objeto do tipo Parameter
45 Set pais_par=com_paises.CreateParameter
(nome_par,tipo_par,dire_par,tama_par,valor_par)
46 ‘Adiciono o parâmetro à coleção Parameters.
47 com_paises.Parameters.Append pais_par
48 ‘Defino o comando a ser executado como sendo o nome
407
49 ‘da consulta con_pedidos
50 com_paises.CommandText = “con_pedidos”
51 ‘Crio um objeto RecordSet e utilizo o método

52 ‘execute do objeto Command para retornar valores
53 ‘para o objeto RecordSet.
54 Set Resultados = Server.CreateObject(“ADODB.RecordSet”)

55 Set Resultados = com_paises.Execute
56 ‘Reexibo a lista de países para que o usuário possa

57 ‘pesquisar os pedidos para um outro país.
58 %>
59 <P><B>Para pesquisar outro país, selecione na lista.</B></P>

61 <FORM action=procurapais.asp method=post id=form1 name=form1>
63
64 <%

68 ‘na lista.

Chr(34)
71 If Paises.Fields(“ShipCountry”)= Request.Form(“listapaises”) Then

72 Response.Write “SELECTED”
73 End If
74 Response.Write “>” & Paises.Fields(“ShipCountry”)& “</OPTION>”

75 Paises.MoveNext
76 Loop
77 %>
408
78 </SELECT>
79 <INPUT type=“submit” value=“Pesquisar” id=Pesquisar name=Pesquisar>
80 </FORM>
81 <%
82 ‘Exibo os resultados obtidos a partir da consulta

83 ‘con_pedidos.
84 %>
85 <B>Relação de pedidos para: <% =Request.Form(“listapaises”) %>.</B>

86 <HR>
87 <% ‘Agora exibo os resultados utilizando uma tabela. %>
88 <TABLE border=1>
89 <TR>
90 <TD><B>Código</B></TD>
91 <TD><B>Data</B></TD>
92 <TD><B>Cidade</B></TD>
93 <TD><B>País</B></TD>
94 </TR>
95 <%
96 Do While Not Resultados.EOF
97 %>
98 <TR>
99 <TD><% =Resultados.Fields(“OrderID”) %></TD>
100 <TD><% =Resultados.Fields(“OrderDate”) %></TD>
101 <TD><% =Resultados.Fields(“ShipCity”) %></TD>
102 <TD><I><% =Resultados.Fields(“ShipCountry”) %></I></TD>
103 </TR>
104 <% Resultados.MoveNext

105 Loop
106 %>
409
107 </TABLE>
108 <BR>
109 <HR>
110 </BODY>
111 </HTML>
A Listagem 7.3 salienta diversos pontos importantes na utilização do objeto Command para a execução
de Consultas Parametrizadas, através da passagem de parâmetros utilizando o objeto Parameter.
Vamos detalhar alguns trechos desta listagem. Observe o seguinte trecho de código:
29 Set com_paises = Server.CreateObject(“ADODB.Command”)
30 com_paises.ActiveConnection = conn
31 com_paises.CommandType = 4
Inicialmente criamos um objeto do tipo Command, depois definimos a sua propriedade

ActiveConnection como sendo a conexão conn. Por último definimos a propriedade
CommandType com o valor 4. Ao invés do valor 4 poderíamos ter utilizado a constante
adCmdStoredProc, o que significa que o valor passado para a propriedade CommandText
deve ser o nome de uma consulta (no caso do Microsoft Access), ou de um Stored Procedure
(no caso do Microsoft SQL Server). Como queremos executar a consulta con_pedidos,
definimos a propriedade CommandType com o valor 4.
NOTA
Na Tabela 7.3 estão listados os valores e respectivas constantes para a propriedade
CommandType.
Em seguida começo a definir as características do parâmetro que será criado e passado para a
consulta. Isto é feito com o seguinte trecho de código:
32 ‘Agora começo a definir as características do parâmetro.
33 ‘Crio variável para definir o nome do parâmetro.
34 nome_par = “Pais”
35 ‘Crio uma variável para conter o valor do parâmetro.

36 ‘Defino este valor como sendo o valor selecionado
37 ‘na lista de países.
410
39 ‘Agora crio variáveis que definem as demais

40 ‘ características do parâmetro.
41 tipo_par = 129 ‘parâmetro do tipo string.

Primeiro definimos o nome do parâmetro, que deve ser o mesmo utilizado para a definição
do parâmetro, quando da criação da consulta no Microsoft Access. Neste caso criamos uma
variável chamada nome_par e definimos o seu valor como “Pais”.
Logo em seguida criamos a variável valor_par, a qual irá conter o valor que será passado para
o parâmetro Pais. Este valor é o selecionado na lista de países da página command2.asp,
conforme indicado pelo código abaixo:
Seguindo as definições, criamos uma variável para o tipo do parâmetro – tipo_par. A esta
variável foi atribuído o valor 129. Ao invés do valor 129 poderíamos ter utilizado a constante
adChar, que define o parâmetro como sendo uma String, isto é, do tipo texto. Na Tabela 7.5
temos uma listagem com os principais valores e respectivas constantes que podem ser definidas
para o tipo do parâmetro.
Tabela 7.5 Principais Valores/Constantes para definição do tipo do parâmetro.
Valor/Constante Descrição
0x2000/adArray Um valor de Flag indicativo de que temos um array
de valores, o qual deve ser combinado com outro
valor indicativo de tipo. Este valor indica um array
de parâmetros de um determinado tipo.
20/adBigInt Indica um inteiro de 8 bytes.
128/adBibary Indica um valor binário.
11/adBoolean Indica um valor boleano, do tipo Verdadeiro ou
Falso, Sim ou Não.
8/sdBSTR Indica uma String de caracteres de terminação nula
(Unicode).
129/adChar Indica um valor de String, isto é, texto.
411
6/adCurrency Indica um valor do tipo currency, o qual é um
número com quatro casas decimais fixas.
7/adDate Indica um valor do tipo Data.
134/adDBTime Indica um valor de hora, no formato hhmmss.
135/adDBTimeStamp Indica um valor de data/hora no formato
yyyymmddhhmmss
14/adDecimal Indica um valor decimal.
5/adDouble Indica um valor numérico de precisão dupla.
0/adEmpty Não define nenhum valor.
10/adError Indica um código de erro de 32 bits.
72/adGUID Indica um valor do tipo GUID – Globally Unique
Identifier.
3/adInteger Indica um valor inteiro de 4 bytes.
4/adSingle Indica um valor numérico de precisão simples.
Em seguida definimos um tamanho máximo em bytes para o parâmetro, que no nosso exemplo
foi definido para 50, conforme indicado pelo seguinte comando:
Finalmente definimos uma variável para conter o valor de definição para a propriedade
Direction do parâmetro. Este valor foi definido em 1, o que significa um parâmetro de entrada,
isto é, um parâmetro que envia um valor para a consulta do Microsoft Access. Esta definição
está indicada no código a seguir:
Ao invés do valor 1, poderíamos ter utilizado a constante adParamInput. Na Tabela 7.6 temos
uma listagem com os valores e respectivas constantes que podem ser definidas para a
propriedade Direction.
Tabela 7.6 Valores/Constantes para a propriedade Direction.
1/adParamImput Indica um parâmetro de entrada. É o valor padrão.
2/adParamOutput Indica que o parâmetro é de saída.
412
3/adParamInputOutput Indica que o parâmetro é de entrada e saída.
4/adParamReturnValue Indica que o parâmetro representa um valor de
retorno.
0/adParamUnknown Indica um parâmetro com direção desconhecida.
NOTA
Criamos variáveis para conter estes valores. Depois passaremos estas variáveis para o método
CreateParameter. Ao invés de criarmos as variáveis, poderíamos passar os valores diretamente para
o método CreateParameter. Adotamos este procedimento para facilitar o entendimento do código.
O próximo passo é criar um objeto do tipo Parameter, utilizando o método CreateParameter

do objeto Command. Chamamos este objeto de pais_par, conforme indicado abaixo:
44 ‘Agora crio um objeto do tipo Parameter
45 Set pais_par=com_paises.CreateParameter
(nome_par,tipo_par,dire_par,tama_par,valor_par)
A sintaxe para o método CreateParameter é a seguinte:

Set nome_parameter = nome_command.CreateParameter (Name, Type, Direction, Size, Value)
Onde temos:
➥ Name: O nome do parâmetro.
➥ Type: O tipo do parâmetro. Os principais valores de tipo possíveis estão listados na
Tabela 7.5.
➥ Direction: Definição da direção do parâmetro. Os principais valores de direção possíveis,
estão listados na Tabela 7.6.
➥ Size: Define o tamanho máximo para o parâmetro.
➥ Value: Define o valor do parâmetro. No nosso caso é o valor que será enviado para a
consulta con_pedidos, e que servirá como critério de filtragem para o campo
ShipCountry.
Uma vez criado o parâmetro é hora de adicioná-lo à coleção Parameters do objeto Command.
Para fazer isso, utilizamos o método Append da coleção Parameters, conforme indicado a seguir:
46 ‘Adiciono o parâmetro à coleção Parameters.
47 com_paises.Parameters.Append pais_par
413
Observe que passamos para o método Append o nome do objeto Parameter a ser adicionado
a coleção Parameters. Utilizando Append, podemos adicionar novos parâmetros.
Agora preciso definir a propriedade CommandText do objeto com_paises. Como definimos a

propriedade CommandType como 4 (Stored Procedure), vamos passar para o objeto
CommandText o nome da consulta a ser executada, que no nosso exemplo é con_pedidos.
Isto é feito com o seguinte código:
50 com_paises.CommandText = “con_pedidos”
O passo final é criar um objeto RecordSet utilizando o método Execute do objeto Command.
Isto é feito com o seguinte código:
54 Set Resultados = Server.CreateObject(“ADODB.RecordSet”)
55 Set Resultados = com_paises.Execute
Assim, o valor selecionado na lista de países é passado para a consulta con_pedidos. A consulta
é executada e somente são retornados os registros em que o campo ShipCountry contém o
valor selecionado na lista de países.
Com a utilização do objeto Command e do objeto Parameter foi possível executar uma Consulta
Parametrizada no Microsoft Access, passando o valor do parâmetro para a consulta.
Utilizando o Nosso Exemplo

Agora vamos utilizar o nosso exemplo, para comprovar o correto funcionamento do mesmo.
Ao carregar a página command2.asp, obtemos o resultado indicado na Figura 7.11.
Figura 7.11: Selecionando um país da lista.
414
Vamos supor que o usuário selecionou “Norway”, na lista de países. Ao clicar no botão Pesquisar
serão exibidos apenas os pedidos para o país selecionado, conforme indicado na Figura 7.12.
Figura 7.12: Exibindo os pedidos para Norway.
Observe que novamente é exibida a lista de países e o país selecionado anteriormente aparece
selecionado na lista. Para pesquisar os pedidos para outro país é só selecionar o país desejado
e clicar no botão Pesquisar. Veja que com isso construímos um formulário de pesquisa bastante
interativo. O usuário seleciona o país desejado e manda pesquisar. Cada vez que o usuário
seleciona um país diferente na lista, e clica no botão Pesquisar, o novo valor selecionado é
passado como parâmetro para a consulta con_pedidos. A consulta é executada e retorna
somente os registros que atendem ao critério passado como parâmetro.
Um Desafio Para o Amigo Leitor

Agora que já conhecemos vários detalhes sobre o acesso a bancos de dados, através de páginas
ASP, fica aqui um pequeno desafio para o amigo leitor.
415
Desafio: Modificar o exemplo anterior fazendo as seguintes melhorias.

➥ Modificar a consulta con_pedidos incluindo um parâmetro chamado AnoPedido. Este
parâmetro será utilizado para filtrar somente os registros de um determinado ano. Adicionar
um campo calculado à consulta, que exiba somente o ano do campo OrderDate.
➥ Modificar a página command2.asp para que, além de uma lista com os nomes dos
países, seja exibida uma lista com a relação de anos para os quais existem pedidos.
Construir esta lista dinamicamente, assim como foi construída a lista para os países.
➥ Modificar a página procurapais.asp, para que a mesma crie mais um parâmetro chamado
ano_ped e passe esse parâmetro para a consulta con_pedidos, de tal forma que somente
sejam retornados os pedidos para o País selecionado e para o Ano selecionado.
Vamos exemplificar como deve ser o resultado final, após estas alterações.
Ao carregar a página command2.asp, obtemos o resultado indicado na Figura 7.13.
Figura 7.13: Selecione um país da lista País e o ano na lista Ano.
Vamos supor que o usuário selecionou “Brazil”, na lista de países e 1994 na lista Ano. Ao
clicar no botão Pesquisar serão exibidos apenas os pedidos para país e ano selecionados,
Para fazer uma nova pesquisa, basta selecionar novos critérios e clicar no botão Pesquisar.
416
Figura 7.14: Pedidos para “Brazil” no ano de 1994.
Em caso de dificuldades na criação da nova versão do nosso exemplo é só entrar em contato pelo
e-mail: juliobattisti@hotmail.com. Mas antes de entrar em contato procure revisar os conceitos já
apresentados até o momento. Praticar é muito importante para conseguir fixá-los.
Um Pouco Mais Sobre Pesquisas em Banco de Dados

Neste item iremos explorar um pouco mais a utilização da linguagem SQL em páginas ASP.
IMPORTANTE
Estaremos utilizando exemplos que acessam bancos de dados do Microsoft Access. Para o
acesso a outros bancos de dados, podem existir pequenas diferenças, dependendo do OLE DB
Provider para cada caso. Caso você esteja utilizando outro banco de dados, consulte a
documentação do padrão SQL do mesmo.
417
Trataremos dos seguintes tópicos:

➥ A utilização do operador Like.
➥ Definindo múltiplos critérios.
➥ Utilizando funções de agregação.
A Utilização do Operador Like

Com o operador Like, podemos criar consultas que retornam resultados contendo um
determinado padrão. Por exemplo, podemos fazer uma consulta que localize todos os clientes
em que o primeiro nome inicie com “Jo”. Neste caso serão retornados os registros de João da
Silva, João Santos, José da Silva, Josimar da Silva e assim por diante. O operador Like nos dá
uma flexibilidade bastante grande, pois permite que façamos pesquisa, digitando apenas
parte do valor procurado.
Considere a seguinte instrução SQL:

SELECT CustomerID, CompanyName, ContactName FROM Customers
WHERE CompanyName Like ‘La%’
NOTA
Estamos tomando como base a tabela Customers do banco de dados nwind.mdb.
Esta instrução iria selecionar apenas os registros cujo campo CompanyName iniciasse com La.
IMPORTANTE
Quando utilizamos o Microsoft Access, utilizamos o “*” como caractere coringa; já em ASP
utilizamos o “%”. Outra diferença importante é em relação a critérios de texto. Quando
utilizamos o Microsoft Access, todo critério de texto deve vir entre aspas (“), já no caso de
páginas ASP, todo critério de texto deve vir entre apóstrofes (‘).
Na Listagem 7.4 temos exemplo de página que utiliza o operador Like.
Listagem 7.4 – Utilizando o operador Like para fazer pesquisas – exlike.asp.

2 <HTML>
3 <HEAD>
4 </HEAD>
418
5 <TITLE>Utilizando o operador Like.</TITLE>
6 <BODY>
7 <%

12 DATA SOURCE=c:\meus documentos\nwind.mdb”
13 conn.Open
14 ‘Agora crio uma instrução SQL que utiliza o operador Like.
15 inst_sql=“Select * from Customers where CompanyName Like ‘La%’”
16 Set Cust= Server.CreateObject(“ADODB.RecordSet”)

17 Cust.Open inst_sql,conn,3,3
18 %>
19 <P>
20 <FONT color=navy size=4><B>
21 Relação de Clientes cujo nome começa com La.
22 </B></FONT>
23 </P>
24 <HR>
25 <TABLE>
26 <TR>
28 <TD><B>Nome </B></TD>
29 <TD><B>Cidade </B></TD>
30 </TR>
31 <%
419
32 Do Until Cust.EOF
33 %>
34 <TR>
35 <TD><%=Cust.Fields(“CustomerId”) %> </TD>
36 <TD><%=Cust.Fields(“CompanyName”)%> </TD>
37 <TD><%=Cust.Fields(“City”)%> </TD>
38 </TR>
39 <%
40 Ped.MoveNext
41 Loop
42 %>
43 </TABLE>
44 <HR>
45 </BODY>
46 </HTML>
Ao carregarmos este exemplo no Internet Explorer, obteremos o resultado indicado na Figura 7.15.
Figura 7.15: Resultados obtidos com o operador Like.
Agora vamos supor que você quisesse uma listagem de todos os consumidores que possuem
o texto “La” em qualquer parte do nome, não necessariamente no início. Mais uma vez a
420
utilização do operador Like facilita a nossa vida. Para obter o resultado desejado, bastaria
alterar a instrução SQL da Listagem 7.4. A instrução deve ficar da seguinte maneira:
inst_sql=“Select * from Customers where CompanyName Like ‘%La%’”
Bastou colocar mais um caractere % antes do La. Com isso serão retornados todos os registros que
contiverem La em qualquer parte do campo CompanyName, conforme indicado na Figura 7.16.
Figura 7.16: Mais um exemplo de utilização do operador Like.
Poderíamos começar a refinar mais ainda a nossa consulta. Vamos pesquisar todos os registros
em que o Nome do Cliente (campo CompanyName) possui “La” e o CEP (campo PostalCode)
possui o número 3.
Para obter o resultado desejado, bastaria alterar a instrução SQL da Listagem 7.4. A instrução
deve ficar da seguinte maneira:
inst_sql=“Select * from Customers where CompanyName Like ‘%La%’ and
PostalCode Like ‘%3%’”
Na Figura 7.17 temos a listagem obtida após esta alteração da instrução SQL.
421
Figura 7.17: Utiliando o operador Like e And.
Agora vamos supor que você queira uma listagem somente com os registros em que o campo
CompanyName inicie com uma letra na faixa de A até M, isto é, a primeira letra do nome deve
estar entre A e M. Além disso você deseja que esta listagem seja classificada em ordem ascendente
do campo CompanyName. Para obter este resultado, basta utilizar a instrução SQL a seguir:
inst_sql=“Select * from Customers where CompanyName Like ‘[A-M]%’ Order By CompanyName”
O resultado desta pesquisa está indicado na Figura 7.18.
NOTA
Ao invés de digitar a instrução SQL diretamente no código ASP, a mesma pode ser construída
a partir de valores digitados ou selecionados em um formulário. No final do capítulo, criaremos
um formulário genérico para pesquisas, onde o usuário poderá definir por qual ou quais critérios
deseja fazer a pesquisa e selecionar um valor para os critérios. Ao clicar em um botão Pesquisar,
os dados são enviados para uma página ASP, que monta a instrução SQL de acordo com as
opções selecionadas pelo usuário.
Com estes exemplos, podemos comprovar a versatilidade e facilidade de uso do operador Like.
422
Figura 7.18: Utiliando o operador Like e uma faixa inicial.
A Utilização de Múltiplos Critérios

Para realizarmos uma pesquisa com mais de um critério, utilizamos os operadores And e Or.
Inicialmente vamos salientar a diferença entre ambos.
O Operador And
Quando utilizamos o operador And para “ligar” dois critérios, somente serão selecionados os
registros que atenderem, ao mesmo tempo, aos dois critérios. Caso o registro somente atenda
a um dos critérios, não será selecionado. Considere o seguinte exemplo:
inst_sql=“Select * from Orders where ShipCountry = ‘France’ and ShipCity = ‘Lyon’ ”
Neste caso somente serão selecionados os registros em que o país for France e a cidade Lyon,
isto é, somente os registros que atenderem aos dois critérios.
Podemos utilizar mais do que um operador And. Com isso podemos especificar três ou mais
critérios. Mas, a regra se mantém: para que um registro seja selecionado, ele precisa atender
423
a todos os critérios ligados pelos operadores And. Se um único critério falhar, o registro não
será selecionado.
O Operador Or
Quando utilizamos o operador Or para “ligar” dois critérios, somente serão selecionados os
registros que atenderem, pelo menos, a um dos dois critérios. O registro somente não será
selecionado se não atender a nenhum dos dois critérios. Considere o seguinte exemplo:
inst_sql=“Select * from Orders where ShipCountry = ‘France’ Or ShipCity = ‘Lyon’”
Neste caso serão selecionados todos os registros que atenderem a pelo menos um dos critérios,
isto é, se o país for igual a France, o registro será selecionado, independente da cidade. Se a
cidade for igual a Lyon, o registro será selecionado, independente do país. Caso o registro
atenda aos dois critérios também será selecionado. A única situação em que o registro não será
selecionado é quando não atender a nenhum dos dois critérios ligados pelo operador Or.
Podemos utilizar mais do que um operador Or. Com isso podemos especificar três ou mais
critérios. Mas a regra se mantém, para que um registro seja selecionado, ele precisa atender a
pelo menos um dos critérios ligados pelos operadores Or. Somente se todos os critérios falharem
é que o registro não será selecionado.
Alguns Exemplos de Utilização de Múltiplos Critérios

Exemplo 1: Vamos supor que desejamos uma listagem dos pedidos que atendam aos seguintes
critérios:
➥ Campo ShipCountry = France
➥ OrderDate deve estar dentro do ano de 1994.
A instrução SQL é a seguinte:
inst_sql=“Select * from Orders where ShipCountry=‘France’ And OrderDate>#01/01/1994#
And OrderDate<#31/12/1994#”
Observe que quando formos definir um critério para um campo do tipo Data, devemos colocar
o valor entre os sinais de #.
Na figura 7.19, temos o resultado da execução da instrução SQL do nosso exemplo.
424
Figura 7.19: Especificando critérios para o País e para a Data.
Exemplo 2: Se, no exemplo anterior, trocarmos o primeiro And por um Or e utilizarmos

parênteses para determinar a ordem de avaliação, conforme indicado no exemplo:
inst_sql=“Select * from Orders where ShipCountry=‘France’ Or
(OrderDate>#01/01/1994# And OrderDate<#31/12/1994#)”
qual seria o resultado desta instrução SQL?
Seriam retornados todos os pedidos para o país France, independente do ano. Também seriam
retornados todos os pedidos para o ano de 1994, independente do País. Lembre que para ser
selecionado, basta que o registro atenda um dos critérios ligados pelo Or. Ao colocarmos os
parênteses, estamos forçando que os critérios da data sejam avaliados de uma maneira única.
O resultado desta comparação é que é ligado pelo Or à primeira parte do critério.
Exemplo 3: Vamos fazer uma pesquisa em que sejam exibidos os pedidos para todos os países,
com exceção dos pedidos em que o campo ShipCountry seja igual a France. Podemos utilizar
a seguinte instrução SQL:
inst_sql=“Select * from Orders where ShipCountry <>‘France’”
425
Neste caso fizemos uso do operador diferente <>. Com isso estamos dizendo que devem ser
selecionados todos os registros em que o campo ShipCountry for diferente de France.
Exemplo 4: Queremos pesquisar por registros que possam apresentar dois ou mais valores
em um determinado campo, como por exemplo, pesquisar todos os pedidos para Brazil, France,
Argentina ou Germany. Poderíamos utilizar vários critérios ligados pelo operador Or, porém
existe uma maneira mais simples de fazer isso, que é através da utilização do operador In,
conforme indicado no exemplo abaixo:
inst_sql=“Select * from Orders where ShipCountry In (‘France’,‘Argentina’, ‘Brazil’,
‘Germany’) Order By ShipCountry”
Com o uso do operador In, podemos definir dois ou mais critérios para um determinado
campo. A lista de critérios vem entre parênteses, cada critério deve ser colocado entre
apóstrofes e separados por vírgula.
Exemplo 5: Vamos “inverter” um pouco o exemplo anterior: criar uma listagem de todos os
pedidos, com exceção dos pedidos enviados para os seguintes países:
➥ Argentina
➥ Brazil
➥ France
➥ Germany
Podemos utilizar a mesma instrução anterior, apenas colocando o operador Not, antes do
operador In, conforme indicado a seguir:
inst_sql=“Select * from Orders where ShipCountry Not In (‘France’,‘Argentina’, ‘Brazil’,
‘Germany’) Order By ShipCountry”
O Not informa que devem ser selecionados todos os registros, com exceção daqueles em que
o campo ShipCountry contiver os valores especificados como parâmetros do operador In.
A utilização de operadores nos permite criar consultas bastante avançadas, combinando

critérios, e utilizando critérios múltiplos. Também podemos utilizar as chamadas funções de
agregação, que será o assunto do próximo item.
Utilizando Funções de Agregação

As funções de agregação nos permitem criar valores consolidados dos dados de uma ou mais
tabelas, como por exemplo:
➥ A soma de todos os pedidos enviados para a Argentina.
➥ A média dos pedidos para um determinado cliente.
426
➥ O número de pedidos enviados para um determinado país em determinado ano.

➥ O menor e o maior pedido para um determinado cliente ou país.
Para obter estes resultados consolidados, podemos utilizar as diversas funções de agregação
disponíveis. Na Tabela 7.7, temos a descrição das principais funções de agregação disponíveis.
Tabela 7.7 Funções de agregação.
Count( ) É utilizada para efetuar uma contagem. Pode ser uma
contagem geral, como por exemplo o número de registros de
uma tabela, ou específica, como o número de pedidos para
cada país.
AVG( ) É utilizada para cálculo de médias. Calcula a média aritmética
de um determinado campo. Somente pode ser utilizada com
campos numéricos. Valores do tipo Null serão ignorados.
Sum( ) É utilizada para efetuar a soma de campos numéricos.
Max( ) É utilizada para determinar o maior valor de um campo
numérico.
Min( ) É utilizada para determinar o menor valor de um campo
numérico.
Alguns Exemplos de Utilização de Funções de Agregação

Exemplo 1: Vamos começar com um exemplo em que seja exibida uma listagem, com o número
de pedidos para cada país, classificada pelo nome do país de destino.
inst_sql=“Select ShipCountry, Count(OrderID) As Totais from Orders
Group By ShipCountry Order By ShipCountry”
Na Listagem 7.5, temos um exemplo de uma página ASP, excount.asp, que faz uso desta
instrução SQL.
Listagem 7.5 – Utilizando a função de agregação Count( ) – excount.asp.

2 <HTML>
3 <HEAD>
4 </HEAD>
427
5 <TITLE>Utilizando a função Count.</TITLE>
6 <BODY>
7 <%


15 conn.Open
16 ‘Agora crio um objeto do tipo RecordSet, o qual será,

17 ‘automaticamente associado com a conexão conn.
18 inst_sql=“Select ShipCountry, Count(OrderID) As Totais from Orders

Group By ShipCountry Order By ShipCountry”

20 Ped.Open inst_sql,conn,3,3
21 %>
22 <P>
24 Número de pedidos por país de destino.
25 </B></FONT>
26 </P>
27 <HR>
28 <TABLE border=1>
29 <TR>
428
31 <TD><B>Pedidos </B></TD>
32 </TR>
33 <%
34 Do Until Ped.EOF
35 %>
36 <TR>
37 <TD> <%=Ped.Fields(“ShipCountry”) %> </TD>
38 <TD><B><%=Ped.Fields(“Totais”) %> </B></TD>
39 </TR>
40 <%
41 Ped.MoveNext
42 Loop
43 %>
44 </TABLE>
45 <HR>
46 </BODY>
47 </HTML>
Na Figura 7.20, temos o resultado da página excount.asp, quando a mesma é carregada no

Internet Explorer.
Figura 7.20: Resultados obtidos com a utilização da função Count( ).
429
Exemplo 2: Vamos supor que devêssemos alterar a nossa listagem, para classificá-la em ordem
descendente do número de pedidos, isto é, devem ser listados primeiro os países com o
maior número de pedidos. Para obter este resultado, bastaria alterar a instrução SQL, deixando-
a da seguinte maneira:
inst_sql=“Select ShipCountry, Count(OrderID) As Totais from Orders Group By
ShipCountry Order By Count(OrderID)Desc”
Ao utilizarmos esta instrução, obteremos o resultado indicado na Figura 7.21.
Figura 7.21: Resultados em ordem decresente do número de pedidos.
IMPORTANTE
Quando formos fazer a ordenação, utilizando a cláusula Order By, não podemos utilizar o
“aliás” do campo. O aliás é o nome que damos ao campo que está sendo calculado. No nosso
exemplo, chamamos o campo com o total de pedidos de Totais. Um aliás é criado com a
palavra “As”. Se utilizarmos um aliás na cláusula Order By, obteremos um erro e a página não
será carregada. A instrução a seguir comete este erro.
430
Cuidado – instrução incorreta:

inst_sql=“Select ShipCountry, Count(OrderID) As Totais from Orders Group By
ShipCountry Order By Totais Desc”
Se utilizarmos esta instrução, ao tentarmos carregar a página, obteremos o erro indicado na

Figura 7.22.
Figura 7.22: Erro causado pelo uso de um aliás na cláusula Order By.
Exemplo 3: Agora vamos utilizar a função Sum para retornar a soma do valor do Frete (Freight)
para cada país. Para obter este resultado, podemos utilizar o comando SQL a seguir:
inst_sql=“Select ShipCountry, Sum(Freight) As SomFrei from Orders Group By
ShipCountry Order By Sum(Freight) Desc”
Na Listagem 7.6, temos um exemplo de uma página ASP, exsum.asp, que faz uso desta
instrução SQL.
Listagem 7.6 – Utilizando a função de agregação Sum ( ) – exsum.asp.

2 <HTML>
3 <HEAD>
4 </HEAD>
5 <TITLE>Utilizando a função Sum.</TITLE>
6 <BODY>
431
7 <%


15 conn.Open

18 inst_sql=“Select ShipCountry, Sum(Freight) As SomFrei from Orders

Group By ShipCountry Order By Sum(Freight) Desc”

21 %>
22 <P>
24 Soma do frete por país de destino.
25 </B></FONT>
26 </P>
27 <HR>
28 <TABLE border=1>
29 <TR>
31 <TD><B>Soma do Frete </B></TD>
32 </TR>
432
33 <%
34 Do Until Ped.EOF
35 %>
36 <TR>
37 <TD> <%=Ped.Fields(“ShipCountry”) %> </TD>
38 <TD align=Right><B><%=FormatNumber(Ped.Fields(“SomFrei”),2)
39 %> </B></TD>
40 </TR>
41 <%
42 Ped.MoveNext
43 Loop
44 %>
45 </TABLE>
46 <HR>
47 </BODY>
48 </HTML>
Na Figura 7.23, temos o resultado da página exsum.asp, quando a mesma é carregada no

Internet Explorer.
Figura 7.23: Resultados obtidos com a utilização da função Sum( ).
433
Apenas um comentário sobre a utilização da função FormatNumber: esta função foi utilizada
para delimitar o resultado da soma em duas casas decimais.
Exemplo 3: Ao invés da função Sum, vamos utilizar a função Avg, para retornar a média
aritmética do valor do Frete (Freight) para cada país. Para obter este resultado, podemos utilizar
o comando SQL a seguir:
inst_sql=“Select ShipCountry, Avg(Freight) As AvgFrei from Orders Group By
ShipCountry Order By Avg(Freight) Desc”
O resultado obtido com esta instrução é mostrado na Figura 7.24.
Figura 7.24: Resultados obtidos com a utilização da função Avg( ).
Exemplo 4: Vamos construir um exemplo um pouco mais sofisticado. Vamos fazer com que
sejam listados todos os pedidos, cujo valor do frete seja maior do que o valor médio do frete.
A listagem será classificada em ordem decrescente do valor do frete. Podemos utilizar a seguinte
instrução SQL:
Select ShipCountry, OrderID, OrderDate, Avg(Freight) As AvgFrei from Orders
Group By ShipCountry, OrderID, OrderDate
Having Avg(Freight)>Davg(‘Freight’,’Orders’) Order By Avg(Freight) Desc
Observe que nesta instrução utilizamos algumas elementos novos, como por exemplo:
434
➥ A cláusula Having: quando utilizamos a cláusula Group By, devemos utilizar a cláusula
Having ao invés da cláusula Where.
➥ Utilizamos a função Davg, que é uma função chamada de domínio. A função Davg foi
utilizada para calcular a média geral do frete na tabela Orders. Utilizamos a seguinte sintaxe:
Davg(‘Nome_campo’,‘Nome_da_tabela’)
Ao executarmos esta instrução SQL, obteremos os resultados indicados na Figura 7.25.
Figura 7.25: Resultados obtidos com a utilização da função de domínio Davg( ).
Exemplo 5: Agora vamos utilizar as funções Max e Min, para retornar o pedido com o menor
valor de frete e o pedido com o maior valor de frete.
Na Listagem 7.7, temos um exemplo de uma página ASP, exmaxmin.asp, a qual faz uso das
funções Max e Min
Listagem 7.7 – Utilizando as funções de agregação Max ( ) e Min( )– exmaxmin.asp.

2 <HTML>
3 <HEAD>
4 </HEAD>
5 <TITLE>Utilizando as funções Max e Min.</TITLE>
435
6 <BODY>
7 <%


15 conn.Open

18 inst_sql=“Select Max(Freight) As MaiorFrete, Min(Freight) As MenorFrete From Orders”
21 %>
22 <P>
24 Valores Máximos e Mínimos de Frete.
25 </B></FONT>
26 </P>
27 <HR>
28 <TABLE border=1>
29 <TR>
30 <TD><B>Máximo</B></TD>
31 <TD><B>Mínimo</B></TD>
32 </TR>
33 <TR>
34 <TD> <%=Ped.Fields(“MaiorFrete”) %> </TD>
436
35 <TD> <%=Ped.Fields(“MenorFrete”) %> </TD>

36 </TR>
37 </TABLE>
38 <HR>
39 </BODY>
40 </HTML>
A Figura 7.26 mostra o resultado da página exmaxmin.asp, ao ser carregada no Internet Explorer.
Figura 7.26: Resultados obtidos com a utilização das funções Max( ) e Min( ).
Agora vamos ao nosso exemplo final, no qual iremos construir um formulário genérico, onde
o usuário poderá selecionar por qual campo e por qual critério deseja fazer a pesquisa.
Um Formulário Genérico Para Pesquisas

Para finalizar este capítulo vamos criar um formulário que permite pesquisas genéricas por
até três critérios:
➥ País de destino.
➥ Ano do pedido.
➥ Parte do endereço.
437
O formulário permite que sejam feitas pesquisa utilizando um ou mais destes critérios. Na
Figura 7.27 temos um exemplo do formulário geral.asp, onde o usuário pode selecionar por
quais campos deseja pesquisar a tabela Orders e qual o valor para cada campo.
Figura 7.27: O formulário onde o usuário define os critérios a serem utilizados – geral.asp.
Na Listagem 7.8, temos o código para a página geral.asp.
Listagem 7.8 – O formulário para definição dos critérios de pesquisa – geral.asp.

2 <HTML>
3 <HEAD>
4 </HEAD>
5 <BODY bgColor=silver>
6 <HR>
438
7 <FONT color=White style=“BACKGROUND-COLOR: navy”>

8 <B>
9 Formulário para pesquisas na

10 tabela de Pedidos.<BR>
11 <FONT color=White>
12 Selecione por qual ou quais campos deseja fazer a pesquisa,
13 <BR>
14 depois defina valores para os campos selecionados.<BR>
15 <HR>
16 <%


24 conn.Open
25 ‘Agora criamos os objetos RecordSet,

26 ‘para criação das listas com os nomes dos países e
27 ‘com a lista de anos para os quais existem pedidos.

29 Set Anos = Server.CreateObject(“ADODB.Recordset”)

31 Anos.Open “Select Year(OrderDate) As AnoPedido from Orders Group By

Year(OrderDate) Order By Year(OrderDate)”, conn, 3, 3
32 ‘Neste ponto tenho os objetos RecordSet necessários para a
33 ‘criação das listas.
34 %>
439
35 <FORM action=pesquisa.asp method=post id=form1 name=form1>
36 Pesquisar por País?

37 <INPUT id=pesqpais name=pesqpais type=radio value=Sim>Sim
38 <INPUT CHECKED id=pesqpais name=pesqpais type=radio value=Nao>Não<BR>
39 </FONT></B></FONT>
41 <%


Chr(34) & “>” & Paises.Fields(“ShipCountry”)& “</OPTION>”
46 Paises.MoveNext
47 Loop
48 %>
49 </SELECT>

51 <B>
52 <HR>
53 Pesquisar pelo Ano?

54 <INPUT id=pesqano name=pesqano type=radio value=Sim>Sim
55 <INPUT CHECKED id=pesqano name=pesqano type=radio value=Nao>Não
56 <BR>
57 </FONT>
58 </B>
59 </FONT>
60 <SELECT id=listaano name=listaano>
61 <%
440

64 ‘Para cada ano obtido, crio uma nova opção
65 ‘na lista.
66 Do While Not Anos.EOF
67 Response.Write “<OPTION value=” & Chr(34) & Anos.Fields(“AnoPedido”)
& Chr(34) & “>” & Anos.Fields(“AnoPedido”)& “</OPTION>”
68 Anos.MoveNext
69 Loop
70 %>
71 </SELECT>

73 <B>
74 <HR>
75 O campo endereço deve conter?
76 <INPUT id=pesqend name=pesqend type=radio value=Sim>Sim

77 <INPUT CHECKED id=pesqend name=pesqend type=radio value=Nao>Não
78 <BR>
79 Digite parte do endereço:</FONT></B></FONT>

80 <INPUT type=“text” id=partend name=partend size=25 maxlength=25>
81 <HR>

83 </FORM>
84 </BODY>
85 </HTML>
Observe que mais uma vez as listas com os nomes dos países e os anos, para os quais existem
pedidos, foram construídas dinamicamente, a partir dos dados da tabela Orders. Ao construir
as listas dinamicamente, evitamos que o usuário tente pesquisar, por exemplo, os pedidos
para um país que não existe na tabela Orders. Com isso o usuário não perde tempo e faz as
pesquisas apenas para os países para os quais realmente existem pedidos cadastrados. O
mesmo é válido para a lista com os anos para os quais existem pedidos cadastrados.
441
O próximo passo é construir a página pesquisa.asp. Esta página irá montar uma instrução
SQL de acordo com as opções selecionadas pelo usuário na página geral.asp. Por exemplo, se
o usuário marcar Sim somente para a lista de países e selecionar Argentina, a página
pesquisa.asp terá que montar uma instrução SQL que pesquise a tabela Orders e retornar
somente os pedidos em que o campo ShipCountry for igual a Argentina.
Então vamos à construção da página pesquisa.asp. O ponto central da página pesquisa.asp é

a montagem da instrução SQL com base nas opções selecionadas pelo usuário. O usuário
possui três opções para definir parâmetros de pesquisa:
➥ País
➥ Data
➥ Endereço
O usuário poderá selecionar uma ou mais opções. Com isto teremos oito possibilidades a
serem consideradas; o usuário está pesquisando:
➥ Apenas pelo nome do país.
➥ Apenas pelo ano da data do pedido.
➥ Apenas pelo endereço ou parte do endereço.
➥ Pelo nome do país e pelo ano da data do pedido.
➥ Pelo nome e pelo endereço ou parte do endereço.
➥ Pelo ano da data do pedido e pelo endereço ou parte do endereço.
➥ Com base nos três critérios.
Ou ainda:
➥ O usuário não especificou nenhum critério de pesquisa.
A página pesquisa.asp terá que analisar essas oito possibilidades e montar uma instrução
SQL diferente para cada uma delas.
Na Listagem 7.9, temos o código para a página pesquisa.asp.
Listagem 7.9 – O formulário para definição dos critérios de pesquisa – pesquisa.asp.

2 <HTML>
3 <HEAD>
4 <TITLE>Resultado da pesquisa! </TITLE>
5 </HEAD>
6 <BODY bgColor=silver>
442
7 <%


15 conn.Open
16 ‘Agora passamos a analisar cada uma das oito possibilidades.
17 ‘**************************************************
18 ‘A primeira possibilidade é o caso em que o usuário
19 ‘selecionou apenas um país na lista de países.
20 If (Request.Form(“pesqpais”)=“Sim” And Request.Form(“pesqano”)=“Nao” And

Request.Form(“pesqend”)=“Nao”) Then
21 inst_sql=“Select * from orders where ShipCountry=’” & Request.Form
(“listapaises”) & “‘“
22 Response.Write “Você pesquisou pelo critério País = <B>” & Request.Form
(“listapaises”) & “</B><HR>”
23 End If
24 ‘**************************************************
25 ‘A segunda possibilidade é o caso em que o usuário
26 ‘selecionou apenas um ano na lista de anos.
27 If (Request.Form(“pesqpais”)=“Nao” And Request.Form(“pesqano”)=“Sim” And

28 inst_sql=“Select * from orders where Year(OrderDate)=” & Request.Form
(“listaano”)
29 Response.Write “Você pesquisou pelo critério Ano = <B>” & Request.Form
(“listaano”) & “</B><HR>”
30 End If
31 ‘**************************************************
32 ‘A terceira possibilidade é o caso em que o usuário
33 ‘digitou um critério para pesquisar no endereço.
443
34 If (Request.Form(“pesqpais”)=“Nao” And Request.Form(“pesqano”)=“Nao” And

Request.Form(“pesqend”)=“Sim”) Then
35 inst_sql=“Select * from orders where ShipAddress Like ‘%” & Request.Form
(“partend”) & “%’”
36 Response.Write “Você pesquisou pelo critério Endereço contendo: <B>” &
Request.Form(“partend”) & “</B><HR>”
37 End If
38 ‘**************************************************
39 ‘A quarta possibilidade é o caso em que o usuário
40 ‘selecionou um país na lista de países e também
41 ‘selecionou um ano na lista de anos.
42 If (Request.Form(“pesqpais”)=“Sim” And Request.Form(“pesqano”)=“Sim” And

Request.Form(“pesqend”)=”Nao”) Then
(“listapaises”) & “‘ and Year(OrderDate)=” & Request.Form(“listaano”)
44 Response.Write “Você pesquisou pelos seguintes critérios <BR>”
45 Response.Write “País = <B>” & Request.Form(“listapaises”) & “</B><BR>”
46 Response.Write “Ano = <B>” & Request.Form(“listaano”) & “</B><BR><HR>”
47 End If
48 ‘**************************************************
49 ‘A quinta possibilidade é o caso em que o usuário
50 ‘selecionou um país na lista de países e também
52 If (Request.Form(“pesqpais”)=“Sim” And Request.Form(“pesqano”)=“Nao” And
(“listapaises”) & “‘ and ShipAddress Like ‘%” & Request.Form(“partend”)& “%’”
56 Response.Write “Endereço contendo:<B>” & Request.Form(“partend”) &
“</B><BR><HR>”
57 End If
58 ‘**************************************************
59 ‘A sexta possibilidade é o caso em que o usuário
60 ‘selecionou um ano na lista de anos e também
62 If (Request.Form(“pesqpais”)=“Nao” And Request.Form(“pesqano”)=”Sim” And

(“listaano”) & “ and ShipAddress Like ‘%” & Request.Form(“partend”)& “%’”
444
65 Response.Write “Ano = <B>” & Request.Form(“listaano”) & “</B><BR>”

“</B><BR><HR>”
67 End If
68 ‘**************************************************
69 ‘A sétima possibilidade é o caso em que o usuário
70 ‘não selecionou nenhum dos três critérios.
71 If (Request.Form(“pesqpais”)=“Nao” And Request.Form(“pesqano”)=“Nao” And

72 inst_sql=“Select * from orders”
73 Response.Write “Você não especificou nenhum critério. <BR>”
74 Response.Write “Foram retornados todos os registros.<HR>”
75 End If
76 ‘**************************************************
77 ‘A oitava possibilidade é o caso em que o usuário
78 ‘selecionou os três critérios
79 If (Request.Form(“pesqpais”)=“Sim” And Request.Form(“pesqano”)=“Sim” And

(“listaano”) & “ and ShipAddress Like ‘%” & Request.Form(“partend”)& “%’ and
ShipCountry=’” & Request.Form(“listapaises”) & “‘“
83 Response.Write “Ano = <B>” & Request.Form(“listaano”) & “</B><BR>”
“</B><BR><HR>”
85 End If
89 ‘Neste ponto tenho o objeto RecordSet com
90 ‘os resultados da pesquisa.
91 ‘*************************************************
92 ‘Passo a exibir os resultados obtidos.
93 Response.Write “<B>Foram Encontrados: ” & Pedidos.RecordCount & “Registros
</B><HR>”
94 %>
95 <A HREF=“geral.asp”>Clique aqui para fazer outra pesquisa.</A>
96 <HR>
97 <TABLE BORDER=1>
445
98 <TR>
99 <TD><B>Código </B></TD>
100 <TD><B>Data </B></TD>
101 <TD><B>Endereço</B></TD>
102 <TD><B>País </B></TD>
103 </TR>
104 <%
105 Do While Not Pedidos.EOF
106 %>
107 <TR>
110 <TD><% =Pedidos.Fields(“ShipAddress”)%></TD>
111 <TD><% =Pedidos.Fields(“ShipCountry”)%></TD>
112 </TR>
113 <%
114 Pedidos.MoveNext
115 Loop
116 %>
117 </TABLE>
118 </BODY>
119 </HTML>
Observe que a página pesquisa.asp não tem nada de especial. Apenas testamos as oito
possibilidades descritas anteriormente. Para cada uma das possibilidades montamos a instrução
SQL correspondente e informamos os critérios de pesquisa especificados pelo usuário.
Utilizando o Nosso Formulário de Pesquisa

Agora vamos demonstrar a utilização do nosso formulário genérico para pesquisas na tabela Orders.
Na Figura 7.28 temos um exemplo onde o usuário apenas definiu um país como critério, no
caso o país selecionado foi Austria.
446
Figura 7.28: Pesquisando os pedidos para Austria.
Ao clicar no botão Pesquisar, são obtidos os resultados indicados na Figura 7.29. Observe que
foram encontrados 40 registros para Austria.
Figura 7.29: Listagem de pedidos para Austria.
447
Agora vamos clicar no link Clique aqui para fazer outra pesquisa, com isso voltaremos para a
página geral.asp, onde poderemos definir outros critérios de pesquisa.
Vamos refinar um pouco mais a nossa pesquisa. Selecione Austria na lista País e 1994 na lista
Ano. Não esqueça de marcar a opção Sim ao lado de cada critério selecionado, caso contrário o
critério será ignorado. O formulário de pesquisa deverá estar igual ao indicado na Figura 7.30.
Figura 7.30: Pesquisando os pedidos para Austria no ano de 1994.
Ao clicar no botão Pesquisar, são obtidos os resultados indicados na Figura 7.31. Observe que
foram encontrados cinco registros para Austria no ano de 1994.
Agora vamos fazer uma pesquisa envolvendo os três critérios. Vamos definir os seguintes critérios:
➥ País: Brazil
➥ Ano: 1994
➥ Endereço contendo: Rua
Clique no link Clique aqui para fazer outra pesquisa, com isso voltaremos para a página
geral.asp. Defina os critérios de pesquisa conforme indicado na Figura 7.32.
448
Figura 7.31: Listagem de pedidos para Austria no ano de 1994.
Figura 7.32: Pesquisando os pedidos para Brazil, no ano de 1994 e com o endereço contendo a palavra Rua.
449
Ao clicar no botão Pesquisar, são obtidos os resultados indicados na Figura 7.33. Observe que foram
encontrados seis registros para Brazil, no ano de 1994, com o endereço contendo a palavra Rua.
Figura 7.33: Listagem de pedidos para Brazil, no ano de 1994, com o endereço contendo a palavra Rua.
Veja que, através deste exemplo, conseguimos criar um formulário de pesquisa extremamente
versátil. Podemos definir de um a três critérios de pesquisa, além de definir o valor para cada
critério. Este exemplo demonstra as possibilidades na utilização de ASP para a construção de
sites dinâmicos.
Conclusão
Neste capítulo aprendemos uma série de técnicas úteis na construção de aplicações Web
profissionais.
Iniciamos pelo estudo dos objetos Command e Parameter, os quais facilitam a execução de
Consultas Parametrizadas, bem como o envio de parâmetros e o recebimento de valores de
retorno dos Stored Procedures. Além disso, utilizando os métodos e propriedades dos objetos
450
Command e Parameter podemos ter um controle bastante apurado sobre tipo, tamanho e
outras características dos parâmetros a serem passados para consultas e Stored Procedures.
Foram apresentados exemplos práticos de utilização destes dois objetos.
Depois passamos a estudar alguns conceitos avançados na utilização da linguagem SQL.

Aprendemos a utilizar os operadores Like, And e Or, In e Not. Também aprendemos a utilizar
as funções de agregação e a função de domínio Davg. Foram apresentados exemplos práticos de
utilização dos conceitos avançados da linguagem SQL.
Por fim, apresentamos um exemplo prático que salienta a natureza dinâmica e as capacidades
do ASP 3.0, na construção de sites dinâmicos, principalmente no que se refere a conexão e
pesquisas em bancos de dados.
Os exemplos deste capítulo foram baseados no arquivo nwind.mdb, o qual é fornecido

juntamente com o Microsoft Access. O nome dos campos estão em inglês. Caso você esteja
utilizando uma versão do nwind.mdb que esteja com o nome dos campos em português,
utilize os nomes de campos da sua versão.
No próximo capítulo falaremos um pouco mais sobre o que é uma aplicação Web e sobre os
conceitos de Sessão e Aplicação, além de aprendermos o conceito de componentes ASP.
451
Capítulo 8 – Aplicativos Web e Componentes
Capítulo 8
Aplicativos Web
e Componentes
453
Introdução
Neste capítulo veremos o que significa uma “Aplicação Web” criada em ASP, que fica
armazenada no servidor IIS. Veremos exatamente quais os componentes que formam uma
aplicação Web. Revisaremos o conceito de estado e os problemas oriundos do fato do protocolo
HTTP não manter uma conexão aberta após o carregamento da página.
Iremos conhecer a utilização e o funcionamento do arquivo global.asa, o qual é de grande

importância para o gerenciamento de aplicações Web no IIS. Em seguida passaremos a estudar
o objeto Session. Com o objeto Session, podemos manter valores para um determinado usuário,
enquanto o mesmo estiver acessando uma aplicação Web.
Por exemplo, quando um usuário passa de uma página para outra, a página acessada não teria
como acessar as opções selecionadas pelo usuário e os dados da página anterior, a não ser que
tivessem sido armazenados em um banco de dados. Então, a página que está sendo acessada,
recuperaria estas informações a partir deste banco de dados. Porém, trabalhar intensivamente
com o banco de dados pode degradar o desempenho da aplicação.
Com o objeto Session podemos armazenar informações utilizadas em uma sessão do usuário.
As variáveis armazenadas no objeto Session não serão perdidas quando o usuário acessar
outras páginas da nossa aplicação Web. Estas variáveis somente serão descartadas quando o
usuário sair da aplicação, ou quando a sessão for encerrada por TimeOut.
O objeto Application pode ser utilizado para compartilhar informações entre todos os usuários
que estão acessando uma determinada aplicação Web. Enquanto o objeto Session permite
que um usuário tenha acesso à variáveis armazenadas nele; o objeto Application permite que
todos os usuários que estão acessando a aplicação Web tenham acesso às informações
armazenadas neste objeto.
Veremos exemplos de código que utilizam os objetos Session e Application, bem como os
diversos métodos, propriedades e eventos destes objetos.
O que é uma Aplicação Web no IIS?

Antes de definirmos exatamente o que compõe uma aplicação Web no IIS, vamos fazer uma
comparação entre as aplicações Cliente/Servidor tradicionais e as aplicações Web, com ênfase
no conceito de conexão e estado.
454
Uma Aplicação Cliente/Servidor Tradicional

Em uma aplicação Cliente/Servidor tradicional, temos a aplicação Cliente instalada em cada
uma das estações da rede que farão acesso a aplicação, e podemos ter uma camada de lógica
instalada no servidor de Aplicações, através da qual é feito o acesso ao banco de dados.
Quando o usuário inicia a aplicação Cliente, o mesmo se identifica, normalmente através de
um nome de usuário (username ou login) e de uma senha.
As informações de identificação são utilizadas para estabelecer uma “conexão” com o servidor.
Esta conexão é mantida enquanto a aplicação Cliente estiver sendo utilizada. Através desta
conexão, o lado servidor da aplicação consegue identificar o usuário. Com a identificação do
usuário podem ser aplicadas regras de segurança, como níveis de permissão de acesso aos
dados, níveis de permissão para as funcionalidades da aplicação, log das ações realizadas
pelo usuário, etc. Por exemplo, as opções de menu da aplicação Cliente podem ser montadas
com base nas permissões de acesso que o usuário possui. Se o usuário não possui permissões
para alterar os dados, o menu com as opções de alteração não será exibido para ele.
Através da manutenção da conexão e da respectiva possibilidade de identificar unicamente

cada um dos usuários conectados, podemos implementar a maioria das funcionalidades
essenciais nas aplicações Cliente/Servidor tradicionais.
Porém, existem diversos problemas na atualização e manutenção deste tipo de aplicação,

dentre os quais podemos destacar:
➥ A atualização dos sistemas é problemática pois, neste modelo, cada vez que houver
alteração na camada de apresentação (no modelo de n camadas) ou até mesmo na
camada de Lógica do Negócio (no modelo mais antigo de duas camadas), a aplicação
terá que ser atualizada em todas as estações de trabalho que utilizam a aplicação.
NOTA
Para maiores detalhes sobre os modelos de aplicação de duas ou mais camadas, consulte o
Capítulo 1.
➥ Controle de versão: Garantir que todas as estações de trabalho estejam com a última versão
da aplicação é uma tarefa nada fácil, a qual, dependendo do número de estações da rede
da empresa, pode exigir uma equipe de Help Desk praticamente dedicada a esta tarefa.
➥ Problemas de conflitos de DLL e padronização de ambiente tornam a manutenção e o
gerenciamento destas aplicações uma tarefa difícil e de custo elevado.
455
Estes problemas surgem para cada aplicação Cliente/Servidor tradicional que estiver sendo
usada. Agora imagine o caso de uma grande empresa, com milhares de computadores ligados
em rede, com dezenas de aplicações. A situação torna-se insustentável, além do custo de
manutenção e suporte atingir patamares impraticáveis.
Para resolver estes e outros problemas das aplicações Cliente/Servidor tradicionais é que
começaram a ser desenvolvidas aplicações para a Web, das quais vamos falar um pouco mais.
Aplicações Web – um Novo Paradigma

Para resolver os tradicionais problemas das aplicações Cliente/Servidor é que surge o conceito
de aplicação Web.
Para acessar uma aplicação Web o único programa que o usuário precisa é um navegador
instalado na sua estação. Existem inclusive aplicações Web bem projetadas que não obrigam
o usuário a utilizar um navegador específico, o que aumenta mais ainda a flexibilidade.
Uma aplicação Web reside no servidor, no nosso caso no IIS. Toda e qualquer alteração que se
fizer necessária na aplicação, será feita diretamente no servidor Web, sem que seja necessária
nenhuma modificação nas estações dos usuários. Na próxima vez que o usuário acessar a
aplicação, utilizando o navegador instalado em sua estação, já estarão disponíveis as alterações
efetuadas. Com este modelo não é necessária a “atualização” (que muitas vezes significa uma
reinstalação) da aplicação em todas as estações da rede, cada vez que forem feitas alterações
na aplicação. Com isso, a equipe de suporte fica dispensada da tediosa tarefa de atualização
da aplicação em cada estação da rede.
O modelo de aplicações Web traz inúmeras vantagens, dentre as quais podemos destacar:
➥ Atualização das aplicações centralizada no servidor Web, sem a necessidade de atualizar
todas as estações da rede que acessam a aplicação.
➥ Facilidade de manutenção e suporte, uma vez que o cliente precisa somente de um
navegador para acessar a aplicação.
➥ Redução do chamado TCO – Total Cost Ownership (Custo Total de Propriedade). O
TCO é uma medida de quanto custa, por ano, a manutenção de uma estação de rede
em funcionamento. O cálculo do TCO leva em consideração diversos fatores. Para
maiores informações sobre este cálculo acesse o site do Gardner Group na Internet.
Porém nem tudo são vantagens. Pela natureza e implementação do modelo Web, o qual faz
uso do protocolo HTTP, as aplicações Web não têm como manter uma conexão permanente
com o usuário. Por isso que o modelo Web, muitas vezes, é conhecido como “State Less”, isto
é, “Sem estado”. Isso acontece porque após ter enviado a página solicitada pelo usuário, a
456
conexão é encerrada, não sendo possível continuar trocando informações com o usuário, a
não ser que uma nova conexão seja estabelecida.
Para vencer as limitações impostas por este modelo “State Less”, é que iremos estudar os objetos
Application e Session do ASP, além de aprendermos sobre o que é e como utilizar o arquivo global.asa.
Através da utilização destes objetos, podemos manter diversas informações sobre o usuário
que está acessando a aplicação Web. Na verdade estamos “simulando” uma conexão, porém
utilizando os recursos disponibilizados pelos objetos Application e Session.
A possibilidade de diferenciar cada usuário que está acessando uma aplicação Web é de
fundamental importância, para que possamos criar conteúdos mais personalizados e
interativos, além da possibilidade de aplicar conceitos como níveis de permissão de acesso
aos dados e auditoria de acesso.
Aplicações Web no IIS

Agora que já sabemos que o modelo de desenvolvimento baseado na Web é o modelo dominante
para o desenvolvimento de novas aplicações, vamos aprender a identificar quais os elementos
que compõem uma aplicação Web no IIS.
De uma maneira simples e didática poderíamos definir uma aplicação Web desenvolvida
com ASP como sendo:
“Uma pasta virtual e todas as suas subpastas, com o conjunto de páginas ASP e componentes
COM ou COM+, projetadas para executar uma ou mais tarefas específicas, por exemplo um
sistema para controle do departamento de Recursos Humanos.”
Conforme detalharemos mais adiante, componentes COM ou COM+ (no Windows 2000 o
padrão COM foi aperfeiçoado e transformado em COM+) são elementos de software que
desempenham funções específicas. Por exemplo, a minha aplicação de controle do
departamento de Recursos Humanos pode fazer uso de um componente COM+ o qual faz
cálculos previdenciários. Um componente COM+ pode ser desenvolvido internamente na
empresa, para ser utilizado por uma ou mais aplicações ou pode ser adquirido de empresas
especializadas no desenvolvimento de componentes.
O nosso conjunto de páginas ASP pode fazer uso dos diversos componentes disponíveis para
a aplicação Web.
NOTA
No Capítulo 10 voltaremos a falar de componentes e do Microsoft Transaction Services.
457
No IIS, o ponto de partida para criar uma aplicação Web é criar uma pasta. O próximo passo
é transformar esta pasta em uma “Pasta Virtual” do servidor IIS.
NOTA
Para saber como transformar uma pasta em uma “Pasta Virtual” do IIS, consulte o Capítulo 1,
no item “Tornando a pasta livro, parte do servidor IIS”.
Vamos supor que você tenha criado uma pasta chamada WebApl no drive (C:\WebApl), de
um servidor IIS chamado www.abc.com.br. Agora você registrou esta pasta como uma pasta
virtual chamada WebApl. Dentro do diretório você criou uma página ASP chamada index.asp,
a qual será a página inicial da aplicação Web. Você lembra como seria o endereço para acessar
a página index.asp do diretório virtual WebApl do servidor www.abc.com.br?
O endereço seria o seguinte:

http://www.abc.com.br/WebApl/index.asp
Dentro da pasta WebApl poderíamos criar outras pastas, conforme a necessidade da nossa
aplicação Web. As pastas criadas dentro de uma pasta virtual, já passam a ser acessíveis para
o servidor Web. Por exemplo, dentro da pastas WebApl criamos uma pasta chamada Seguranca.
Dentro dela colocamos um arquivo chamado login.asp. O endereço para acessar o arquivo
login.asp seria o seguinte:
http://www.abc.com.br/WebApl/Seguranca/login.asp
Todos as subpastas da pasta WebApl também farão parte da aplicação Web. Com isso podemos
concluir, em um primeiro momento, que uma aplicação Web do IIS está ligada à criação de
uma pasta virtual no servidor IIS.
O próximo passo é configurar as propriedades da aplicação Web. Para isso utilizamos o

Gerenciador do Internet Services, conforme ilustrado nos passos a seguir.
Para configurar as propriedades de uma aplicação Web faça o seguinte:

1. Faça o logon no Windows 2000 Server, com permissões de administrador.
2. Abra o Gerenciador do Internet Services: Iniciar/Programas/Ferramentas administrativas/
Gerenciador do Internet Services.
458
Figura 8.1: Gerenciador do Internet Services.
4. Esta é a janela do console de administração do IIS 5.0.

5. Dê um clique duplo no nome do computador. No nosso exemplo o nome é servidor.
6. Surgem as opções indicadas na Figura 8.2.
Figura 8.2: Opções de gerenciamento do IIS.
7. Todos os aplicativos Web estão disponíveis através da opção Site da Web Padrão. Dê
um clique no sinal de + ao lado desta opção para abri-la.
8. Serão exibidas todas as pastas virtuais disponíveis no servidor IIS, conforme indicado
na Figura 8.3.
459
Figura 8.3: Pastas virtuas do servidor IIS.
9. No nosso exemplo queremos configurar as propriedades da pasta virtual WebApl. Neste

ponto o conceito de pasta virtual confunde-se com o de aplicação Web. Na verdade, a
nossa aplicação WebApl está contida na pasta virtual WebApl.
10. Dê um clique com o botão direito do mouse sobre WebApl.
11. No menu de opções que surge dê um clique em Propriedades.
12. Será exibida a janela Propriedades de WebApl, conforme indicado na Figura 8.4.
Observe que nesta janela temos diversas informações, tais como:
➥ Caminho da pasta: C:\WebApl. Este é o caminho físico onde são gravados os elementos
da aplicação Web. No nosso exemplo, é a pasta WebApl do drive C:.
➥ Permissões de acesso à pasta virtual da aplicação: Observe que, por padrão, somente
são marcadas as opções de leitura, criação de log e indexação. Falaremos mais sobre
estas permissões no Capítulo 9, sobre segurança em aplicações desenvolvidas com
ASP. No Capítulo 9 também falaremos das opções: Permissões de execução e Proteção
do aplicativo.
460
Figura 8.4: Propriedades da aplicação Web – WebApl.
➥ Nome do aplicativo: No nosso exemplo é WebApl.

A principal opção desta janela é o botão Configuração.
13. Dê um clique no botão Configuração.
14. Surge a janela Configuração de aplicativo, indicada na Figura 8.5.
Figura 8.5: Configurando as propriedades da aplicação Web – WebApl.
461
Na primeira guia, Mapeamento de aplicativo, temos a indicação de qual componente do IIS

irá processar cada requisição do usuário. Este mapeamento é baseado na extensão do arquivo.
Por exemplo, toda página com a extensão .asp será processada pela DLL asp.dll (que na verdade
é o interpretador ASP), conforme indicado pela Figura 8.6.
Figura 8.6: A DLL asp.dll é responsável pelo processamento das páginas ASP.
15. Não iremos alterar nenhuma opção nesta guia.

16. Dê um clique na guia Opções de aplicativo.
17. Nesta segunda guia, temos diversas configurações importantes, conforme indicado na
Figura 8.7.
Figura 8.7: Opções da guia Opções de aplicativo.
462
Abaixo temos a descrição destas opções:

➥ Ativar o estado da sessão: Use essa caixa de seleção para ativar ou desativar o estado
da sessão.
Quando o estado da sessão é ativado, o Active Server Pages cria uma sessão para cada usuário
que acessa um aplicativo ASP, de modo que você possa identificar o usuário através das páginas
do aplicativo. Quando o estado da sessão é desativado, o ASP não controla usuários e não
permite que um script do ASP armazene informações no objeto Session ou use os eventos
Session.OnStart ou Session.OnEnd. Uma sessão é finalizada automaticamente se o usuário não
solicitou ou atualizou uma página em um aplicativo no fim do tempo limite – TimeOut.
Um script pode terminar explicitamente uma sessão com o método Session.Abandon. Mesmo
que o estado da sessão esteja ativado em um aplicativo, você poderá desativá-lo em uma
página ASP individual usando a diretiva <%@ ENABLESESSIONSTATE = False %>, no
cabeçalho da página.
Veremos mais detalhes sobre o objeto Session, ainda neste capítulo.

➥ Tempo limite da sessão: No nosso exemplo está definido em 20 minutos. Uma sessão é
finalizada automaticamente se o usuário não solicitou ou atualizou uma página em
um aplicativo por um tempo maior do que o tempo limite – TimeOut.
➥ Ativar o Buffer: Por padrão esta opção é ativada no IIS 5.0. Nas versões anteriores esta
propriedade era desativada por padrão. Quando o Buffer está ativo, o resultado do
processamento de uma página ASP somente é enviado para o navegador do cliente,
quando toda a página tiver sido processada, a menos que seja utilizado o método Flush
do objeto Response.
➥ Ativar os caminhos pai: Marque esta caixa de seleção para permitir que as páginas
ASP usem os caminhos relativos do diretório pai do diretório atual (caminhos que
usam a sintaxe ..), também conhecidos como endereços relativos.
IMPORTANTE
Se você ativar essa opção, não forneça acesso de execução aos diretórios pai, caso contrário,
um script poderá tentar executar um programa não autorizado em um diretório pai.
➥ Linguagem ASP padrão: Por padrão é definida como sendo VBScript. Caso deseje,
pode alterar para JScript. Também podemos especificar o nome de qualquer outra
linguagem para a qual tenhamos o interpretador instalado no servidor IIS, como por
exemplo Perl. Esta opção define a linguagem que será utilizada para interpretar os
comandos dentro das tags <% e %>.
463
➥ Tempo limite do script ASP: Especifica o período de tempo durante o qual o ASP
permitirá a execução de um script. Se a execução do script não terminar ao final do
período de tempo limite, o ASP irá pará-lo e gravar um evento no arquivo de log de
eventosYdo Windows 2000. Você pode definir o período de tempo limite como um
valor entre 1 e 2147483647, além de poder substituir essa opção em uma página ASP
usando o método Server.ScriptTimeout.
19. Dê um clique na guia Depuração de aplicativo.
20. Na guia Depuração de aplicativo, temos diversas configurações relacionadas com a
depuração de erros em páginas ASP, conforme indicado na Figura 8.8.
Figura 8.8: Opções da guia Depuração de aplicativo.
Abaixo temos a descrição das opções:

➥ Ativar a depuração de script ASP do lado do servidor: Marque esta opção para permitir
que o servidor Web entre no depurador de scripts da Microsoft durante o processamento
de páginas ASP. Em seguida, você pode usar o depurador para examinar seus scripts.
Por questões de desempenho, a depuração do ASP não é recomendada em um ambiente
de produção.
464
➥ Ativar a depuração de script ASP do lado do cliente: Essa caixa de seleção está reservada
para uso futuro e não tem efeito sobre a versão atual do ASP (esta é a informação
contida na própria documentação do IIS 5.0).
➥ Enviar mensagens de erro do ASP detalhadas para o cliente: Selecione essa opção para
enviar informações específicas de depuração (incluindo o nome do arquivo, a mensagem
de erro e o número da linha) para o navegador. Principalmente quando estamos
desenvolvendo nossas aplicações é importante que esta opção esteja selecionado, pois
ao testarmos uma página, se a mesma contiver um erro, o navegador informa o número
da linha onde está o erro, o que facilita a correção do script.
➥ Enviar mensagem de erro de texto para o cliente: Selecione esta opção para enviar
uma mensagem de erro padrão ao navegador quando algum erro impedir o servidor
Web de processar a página ASP. Uma mensagem de erro específica é gravada no log de
erros. Você pode alterar a mensagem de erro padrão digitando uma nova mensagem na
caixa de texto. Não é recomendada a utilização desta opção no ambiente de
desenvolvimento, pelos motivos descritos no parágrafo anterior.
22. Dê um clique no botão OK para fechar a janela de configuração.
23. Dê um clique no botão OK para fechar a janela de propriedades da pasta virtual WebApl.
24. Você estará de volta ao Gerenciador do Internet Services.
25. Feche-o.
Bem, agora já conhecemos o que é uma aplicação Web do IIS e quais os elementos que a
compõem. Um último elemento, porém não menos importante, é um arquivo chamado
global.asa. No próximo item iremos aprender o que é este arquivo.
O Arquivo Global.asa
O arquivo global.asa é um arquivo opcional, porém é bastante comum a utilização do mesmo
em nossas aplicações Web residentes no IIS. A extensão .asa é uma abreviatura para Active
Server Applications. O arquivo global.asa trabalha em conjunto com os objetos Application
e Session, para permitir o gerenciamento das informações de estado de cada usuário que
acessa a aplicação.
No arquivo global.asa é possível especificar scripts de eventos e declarar os objetos que têm
escopo de sessão (Session) ou de aplicação (Application).
Não se trata de um arquivo de conteúdo exibido para os usuários; em vez disso, o arquivo
armazena informações de eventos e os objetos utilizados globalmente pelo aplicativo. Esse
arquivo deve ser nomeado como global.asa e armazenado na pasta raiz do aplicativo.
465
Um Aplicativo só Pode ter um Arquivo Global.asa

A capacidade de manter informações sobre cada usuário conectado com a aplicação é de
fundamental importância, conforme já descrito anteriormente. Quando a aplicação é acessada
pela primeira vez, o arquivo global.asa é carregado na memória do servidor Web. Depois é
utilizado para acompanhar eventos da aplicação como um todo e de cada usuário conectado.
Através do arquivo global.asa podemos acompanhar, para o objeto Session, os seguintes eventos:
➥ Session_OnStart: Este evento ocorre quando o usuário acessa uma das páginas da
aplicação Web. Quando o usuário acessar outras páginas, dentro da mesma aplicação,
este evento não ocorrerá novamente, ou seja, o evento Session_OnStart somente ocorre
para a primeira página da aplicação que o usuário acessar; ele ocorre quando o servidor
cria uma nova sessão. O servidor processa esse script antes de executar a página solicitada.
O evento Session_OnStart é o momento adequado para definir as variáveis no nível de
sessão, porque as mesmas serão definidas antes de se acessar quaisquer páginas.
➥ Session_OnEnd: Este evento ocorre quando a sessão do usuário é encerrada por TimeOut
ou quando o usuário acessar uma página de outra aplicação Web.
Estes eventos são utilizados para o acompanhamento de informações de sessões individuais

de cada usuário, através da utilização do objeto Session. O objeto Session pode ser utilizado
para passar informações entre as diversas páginas ASP da aplicação, dentro de uma sessão de
usuário. Não podemos utilizar o objeto Session para passar informações entre sessões de
usuários diferentes, para isso utilizamos o objeto Application.
Para o objeto Application podemos acompanhar os eventos:

➥ Application_OnStart: Ocorre quando o primeiro usuário acessar uma das páginas da
aplicação Web. O evento Application_OnStart ocorre antes da criação da primeira
sessão nova, isto é, antes do evento Session_OnStart. Por exemplo, se você está
desenvolvendo uma aplicação de Comércio Eletrônico, na qual os preços estão em
dólar, mas o usuário tem a opção de converter os valores para reais, você pode utilizar
o evento Application_OnStart para tornar disponível a cotação do dólar, para qualquer
página dentro da aplicação.
➥ Application_OnEnd: O evento Application_OnEnd ocorre quando o aplicativo é
encerrado, após o evento Session_OnEnd.
Estes objetos são utilizados para monitorar todos os objetos Application, os quais contém
informações disponíveis para quaisquer usuários que acessarem a aplicação.
Na Listagem 8.1, temos um exemplo de um arquivo global.asa típico.
466
Listagem 8.1 – Um exemplo de arquivo global.asa.

1 <SCRIPT LANGUAGE=VBScript RUNAT=Server>
2 ‘Sub Session_OnStart
3 ‘** Código para o evento.
4 ‘End Sub
5 ‘EventName Description
6 ‘Session_OnStart Runs the first time a user runs any page in your application
7 ‘Session_OnEnd Runs when a user’s session times out or quits your
application
8 ‘Application_OnStart Runs once when the first page of your application is run
for the first 9 time by any user
10 ‘Application_OnEnd Runs once when the web server shuts down
11 </SCRIPT>
13 Sub Application_OnStart
14 Application(“nwind_ConnectionString”) = “DSN=nwind;DBQ=C:\MEUS
DOCUMENTOS\NWIND.MDB;DriverId=281;FIL=MS
Access;MaxBufferSize=2048;PageTimeout=5;”
15 Application(“nwind_ConnectionTimeout”) = 15
16 Application(“nwind_CommandTimeout”) = 30
17 Application(“nwind_CursorLocation”) = 3
18 Application(“nwind_RuntimeUserName”) = “”
19 Application(“nwind_RuntimePassword”) = “”
20 End Sub
21 </SCRIPT>
Observe que no evento Application_OnStart configuramos os parâmetros para uma conexão,

via ODBC, com o banco de dados C:\Meus documentos\nwind.mdb. Estas informações estarão
disponíveis para qualquer usuário que acessar a nossa aplicação Web, pois as mesmas foram
definidas através do evento Application_OnStart.
Agora que já conhecemos a anatomia de uma aplicação Web no IIS, bem coma a função do
arquivo global.asa, vamos estudar os objetos Session e Application, para que possamos
aprender na prática a utilizá-los.
467
O Objeto Application
Conforme descrito anteriormente, podemos utilizar o objeto Application para compartilhar
informações entre todos os usuários de um determinado aplicativo. Um aplicativo Web baseado
no ASP é definido como todos os arquivos .asp em uma pasta virtual e seus subdiretórios. Como
o objeto Application pode ser compartilhado por mais de um usuário, existem os métodos Lock e
Unlock para garantir que vários usuários não tentarão alterar uma propriedade ao mesmo tempo.
Itens do objeto Application podem ser variáveis necessárias para todos os usuários que acessam
uma aplicação, como a cotação do dólar ou o índice da poupança. Também podemos utilizar
o objeto Application para criar uma instância de um componente que fornece uma determinada
funcionalidade utilizada pela nossa aplicação Web.
Uma aplicação Web é inicializada quando qualquer uma de suas páginas ASP for acessada. A
partir do momento em que a primeira página ASP for acessada, o objeto Application estará
disponível e quaisquer valores que tenham sido definidos por este objeto, estarão disponíveis
para todos os usuários que acessarem a aplicação.
O diagrama da Figura 8.9, demonstra a relação entre o objeto Application, o servidor Web e as
diversas aplicações Web hospedadas no servidor.
Usuário 1
Aplicação: web1
Usuário 2
objeto Application
Usuário 3
Aplicação: web2
Usuário 4
objeto Application
Usuário 5
Servidor Web
Aplicação: web3
objeto Application Usuário 6
Cada aplicação possui o seu próprio objeto Application.
Figura 8.9: Relação entre o objeto Application, o servidor Web e as diversas aplicações.
Cada aplicação Web possui seu próprio objeto Application e informações disponíveis no
objeto Application podem ser acessadas por quaisquer usuário que estiverem acessando a
468
aplicação. Também podemos notar, na Figura 8.9, que em um mesmo servidor Web podemos
ter várias aplicações Web.
Agora passaremos a estudar os eventos, coleções e métodos do objeto Application.
Eventos do Objeto Application

Na Tabela 8.1 temos a descrição dos eventos do objeto Application.
Tabela 8.1 Os eventos do objeto Application.
Evento Descrição
OnStart Ocorre quando a aplicação Web é iniciada (quando a primeira
página da aplicação é acessada), antes da página solicitada
pelo usuário ser interpretada e antes que qualquer objeto
Session tenha sido criado. É por isso que o objeto Session
pode utilizar valores armazenados no objeto Application, pois
obrigatoriamente o objeto Application será criado antes de
qualquer objeto Session. Este evento pode ser utilizado para
inicializar variáveis, criar objetos ou rodar código necessário
à inicialização da aplicação.
OnEnd Ocorre quando a aplicação Web é finalizada. Isto acontece após
o encerramento do último objeto Session e depois que
o código para o evento Session_OnEnd é executado. Todas
as variáveis existentes são retiradas da memória quando a
aplicação é encerrada. O encerramento da sessão normalmente
ocorre quando existia somente um usuário conectado e o
mesmo fecha o navegador ou acessa outro site ou outra
aplicação dentro do mesmo site.
O código para os eventos OnStart e OnEnd deve ser colocado no arquivo global.asa. Agora
passaremos a estudar a utilização destes dois eventos.
Evento Application_OnStart
A seguir é mostrada a sintaxe para este evento.
469
Sintaxe para o evento OnStart:

<SCRIPT LANGUAGE=Linguagem_de_script RUNAT=Server>
Sub Application_OnStart
’ Código para o evento OnStart. . .
End Sub
</SCRIPT>
A seguir temos um exemplo de definição de código para o evento OnStart. Neste exemplo são
criadas duas variáveis de nível de aplicação. Uma com a estação do ano e outra com cotação
do dólar.
<SCRIPT LANGUAGE=“VBScript” RUNAT.= “Server”>
Sub Application_OnStart
Application(“EstacaoAno”) = “Inverno”
Application(“CotDolar”) = 1.77
End Sub
</SCRIPT>
Uma das principais utilização do evento Application_OnStart é para a criação e inicialização

de variáveis em nível de aplicação ou até mesmo objetos, como por exemplo, uma conexão
com um banco de dados.
Para criar uma variável em nível de aplicação, utilizamos a seguinte sintaxe:

Application(“Nome_da_Variável”) = Valor_da_Variável
As variáveis EstacaoAno e CotDolar podem ser acessadas por qualquer usuário, em qualquer
página ASP da aplicação Web, pois são variáveis de nível de aplicação, tecnicamente falando,
diríamos que são variáveis de nível do objeto Application.
Um detalhe importante a ser lembrado é que não é apenas no evento Application_OnStart

que podemos definir variáveis de nível de aplicação. Em qualquer página ASP podemos
definir uma variável que estará disponível para todos os usuários da aplicação. Para isso
utilizamos a mesma sintaxe utilizada no arquivo global.asa, conforme indicado abaixo:
Application(“Nome_da_Variável”) = Valor_da_Variável
Para acessar os valores das variáveis do objeto Application é muito simples, basta utilizar a
sintaxe:
<% = Application(“Nome_da_Variável”) %>
Com isso será retornado o valor da variável.
470
Vamos a um exemplo prático. Suponhamos que tenham sido definidas três variáveis no evento
Application_OnStart da aplicação Web denominada Capitulo8, conforme indicado na Listagem
8.2, onde temos o arquivo global.asa para a aplicação Capitulo8.
Listagem 8.2 – Arquivo global.asa onde são definidos três variáveis de nível de aplicação.
3 Application(“Mensagem”)= “Bem vindo ao site da empresa ABC Ltda!”
4 ‘Cotação do dólar até o meio-dia

5 Application(“CotAM”)= 1.50
6 ‘Cotação do dólar após o meio-dia.

7 Application(“CotPM”)= 2.00
8 End Sub
9 </SCRIPT>
Neste exemplo de arquivo global.asa, no evento Application_OnStart, definimos as variáveis

Mensagem, CotAM e CotPM. Estas são variáveis do objeto Application, portanto disponíveis
para qualquer página da aplicação.
Agora vamos criar uma página ASP que faz uso destas variáveis. A página usa_appvar.asp irá
detectar a hora do dia. Até às 11:59 será apresentada a mensagem “Bom Dia” e será informado
a cotação do dólar armazenada na variável CotAM. A partir de 12:00 será apresentada a
mensagem “Boa Tarde” e será informada a cotação do dólar armazenada na variável CotPM.
Em ambos os casos será emitida a mensagem contida na variável Mensagem.
Na Listagem 8.3 temos o código para a página usa_appvar.asp.
Listagem 8.3 – Utilizando variáveis do objeto Application.

2 <HTML>
3 <HEAD>
4 <TITLE> Utilizando variáveis em nível de aplicação !!</TITLE>
5 </HEAD>
6 <BODY>
471
7 <%
8 ‘ Atribui a hora do dia para a variável hora_dia
9 hora_dia = hour(Time())
10 If hora_dia<12 Then
12 Response.Write “Bom Dia ! <BR>”
13 Response.Write “Cotação do dólar: “ & Application(“CotAM”) & “<BR>”
14 Response.Write Application(“Mensagem”)
16 Else
18 Response.Write “Boa tarde ! <BR>”
19 Response.Write “Cotação do dólar: “ & Application(“CotPM”) & “<BR>”
20 Response.Write Application(“Mensagem”)
22 End If
23 %>
24 </BODY>
25 </HTML>
Observe que utilizamos a função hour(Time( )); como parâmetro para a função hour, passamos
a função Time. A função Time captura a hora do servidor Web e a função hour retira apenas
o valor numérico da hora.
Observe que, para ter acesso a uma variável do objeto Application, é só utilizar a sintaxe:
Application(“Nome_da_Variável”)
Ao visualizarmos o arquivo da Listagem 8.3, antes do meio-dia, obteremos o resultado indicado

na Figura 8.10.
Já, ao visualizarmos o arquivo da Listagem 8.3, após o meio-dia, obteremos o resultado indicado
na Figura 8.11.
A possibilidade de criar variáveis no evento Application_OnStart é bastante interessante,

principalmente pelo fato de que estas variáveis estarão disponíveis para qualquer usuário
que acessar a aplicação Web.
472
Figura 8.10: Resultado obtido antes do meio-dia.
Figura 8.11: Resultado obtido após o meio-dia.
Porém não estamos limitados à criação de variáveis simplesmente. Podemos criar objetos no
evento OnStart. Por exemplo, posso criar um objeto do tipo ADODB.Connection e utilizar o método
Open do mesmo. Com isso estou disponibilizando uma conexão de banco de dados para todas as
páginas da minha aplicação. Esta técnica apresenta, dentre outras, duas vantagens importantes:
➥ Não é necessário a colocação do código para criação da conexão, em cada página que
precisar da mesma. Isto facilita a construção das páginas e reduz a possibilidade de erros.
473
➥ Se, por algum motivo, for necessária a alteração das propriedades da conexão, basta
alterar a String de conexão em um único local (no arquivo global.asa), e não em todas
as páginas que fazem uso da conexão que está sendo alterada.
Na Listagem 8.4, temos um exemplo de conexão criada no evento Application_OnStart.
Listagem 8.4 – Criando uma conexão no evento Application_OnStart.

3 Application(“Mensagem”)= “Bem vindo ao site da empresa ABC Ltda!”

5 Application(“CotAM”)= 1.50

7 Application(“CotPM”)= 2.00
8 ‘Agora cria uma conexão com o banco de dados

9 ‘C:\Meus documentos\nwind.mdb
10 ‘Esta conexão estará disponível para todas as
11 ‘páginas da aplicação.
12 Set Application(“conn”)=Server.CreateObject(“ADODB.Connection”)
13 Application(“conn”).ConnectionString = “PROVIDER=MICROSOFT.JET.OLEDB.4.0;
14 Application(“conn”).Open
15 End Sub
16 </SCRIPT>
IMPORTANTE
Para que o objeto conn seja uma conexão do objeto Application, e com isso disponível para
todas as páginas da aplicação, devemos utilizar a sintaxe indicada na Listagem 8.4, ou seja:
12 Set Application(“conn”)=Server.CreateObject(“ADODB.Connection”)
Desta forma, precisamos utilizar Application(“Nome_do_Objeto”), pois se utilizarmos

simplesmente o nome do objeto, o mesmo não pertencerá ao objeto Application e não estará
disponível em todas as páginas. O mesmo é válido na definição da propriedade ConnectionString
e na utilização do método Open.
474
Agora que criamos uma conexão no evento OnStart, podemos utilizar esta conexão em qualquer
página da aplicação. Vamos a um exemplo de página ASP que utiliza esta conexão.
Na Listagem 8.5 temos uma página ASP que utiliza a conexão criada no evento OnStart.
Observe que estamos criando um objeto RecordSet que utiliza esta conexão como parâmetro
para o método Open do objeto RecordSet.
Listagem 8.5 – Utilizando a conexão criada no evento OnStart – usa_appcon.asp.

2 <HTML>
3 <HEAD>
4 <TITLE> Utilizando uma conexão criada no arquivo global.asa.</TITLE>
5 </HEAD>
6 <BODY>
7 <%
8 ‘Nesta página estamos criando um objeto RecordSet,

9 ‘o qual utiliza a conexão Conn criada no evento
10 ‘Application_OnStart.
11 ‘O código que cria a conexão está no arquivo global.asa.

13 Pedidos.Open “Select * from Orders Order By OrderID”, Application(“conn”), 3, 3

15 ‘Orders do banco de dados nwind.mdb.
16 ‘Agora passo a exibir os resultados.
17 %>
18 <P><B>Utilizei uma conexão criada no arquivo global.asa.</B></P>
19 <TABLE border=1 width=100%>

20 <TR>
25 </TR>
26 <%
475
27 ‘Agora exibo os registros obtidos a partir da tabela Orders.
28 Response.Write “Foram encontrados: ” & Pedidos.RecordCount & “ Registros.<HR>”

31 %>
32 <TR>
36 <TD><% =Pedidos.Fields(“ShipCountry”) %></TD>
37 </TR>
38 <%
39 Pedidos.MoveNext
39 Loop
40 %>
41 </TABLE>
42 <BR>
43 <HR>
44 </BODY>
45 </HTML>
Na Figura 8.12 vemos o resultado quando a página usa_appcon.asp é carregada no Internet

Explorer.
IMPORTANTE
No evento Application_OnStart não podemos utilizar os seguintes objetos:
➥ Response
➥ Request
➥ Session
Se tentarmos utilizar um destes objetos no evento Application_OnStart, obteremos a mensagem
de erro indicada na Figura 8.13.
476
Figura 8.12: Página que utiliza uma conexão criada no arquivo global.asa.
Figura 8.13: Erro devido à utilização de Response no evento Application_OnStart.
477
Evento Application_OnEnd
Embora possamos criar variáveis e objetos no evento Application_OnEnd isto não teria
utilidade prática. Normalmente utilizamos o evento OnEnd para funções administrativas,
tais como gravar informações em um log de auditoria ou parar um determinado serviço para
manutenção.
Sintaxe para o evento Application_OnEnd:

Sub Application_OnEnd
’ Código para o evento OnEnd. . .
End Sub
</SCRIPT>
A seguir temos um exemplo de definição de código para o evento OnEnd. Neste exemplo
estamos retirando o objeto conn da memória.
Set Application(“conn”) = Nothing
End Sub
</SCRIPT>
NOTA
Uma situação especial em que o evento Application_OnEnd ocorre é quando o arquivo global.asa
precisa ser novamente interpretado e carregado na memória. Isto acontece quando este arquivo
é alterado e as alterações são salvas.
Coleções do Objeto Application

Na Tabela 8.2 temos a descrição das coleções do objeto Application.
478
Tabela 8.2 As coleções do objeto Application.
Coleção Descrição
Contents Contém todos os itens que foram adicionados ao objeto
Application, com exceção dos que foram declarados com a
tag <OBJECT>. Todas as variáveis e objetos criados com Set,
fazem parte desta coleção. Podemos usar a coleção Contents
para obter a lista de itens aos quais tenha sido atribuído
escopo do aplicativo ou para especificar um item específico
para ser o destino de uma operação. É possível também
remover os itens da coleção com os métodos Remove e
RemoveAll. No próximo tópico falaremos sobre os métodos
do objeto Application.
StaticObjects A coleção StaticObjects contém todos os objetos criados com
as tags <OBJECT> dentro do escopo do objeto Application.
Podemos usar esta coleção para determinar o valor de uma
propriedade específica de um objeto ou fazer interação através
da coleção e recuperar todas as propriedades dos objetos
estáticos.
Agora passaremos a estudar a sintaxe e alguns exemplos de utilização das coleções do objeto
Application.
A Coleção Contents
Para acessarmos um item da coleção Contents, utilizamos a seguinte sintaxe:
Application.Contents(Chave)
onde Chave é o nome do item a ser recuperado.
Por exemplo, vamos supor que as seguintes variáveis tenham sido criadas no arquivo global.asa,
no evento Application_OnStart:
Application(“Var1”) = “José da Silva”
Application(“Var2”) = “Maria do Socorro”
Application(“HoraDia”) = Hour(Time( ))
Poderíamos exibir o valor destas variáveis utilizando o seguinte código:

<%
Response.Write “Variáveis de nível de aplicação.<HR>”
Response.Write “Var1: ” & Application.Contents(“Var1”) & “<BR>”
479
Response.Write “Var2: ” & Application.Contents(“Var2”) & “<BR>”

Response.Write “Hora do início da aplicação: ” &
Application.Contents(“HoraDia”) & “<BR>”
%>
O comando Application.Contents(“Var1”) retorna o valor da variável de aplicação Var1. O

comando Application.Contents(“Var2”) retorna o valor da variável de aplicação Var2 e assim
por diante.
Como estamos trabalhando com uma coleção, podemos utilizar o operador For Each...Next
para percorrer todos os itens da coleção Contents. No exemplo de código a seguir, exibimos o
nome de todos os elementos da coleção Contents.
<%
For Each elemento in Application.Contents
Response.Write “Nome do elemento: ” & elemento & “<BR>”
Next
%>
Considere a Listagem 8.6, onde fazemos uso do operador For Each...Next para exibir o nome
de todos os itens da coleção Contents do objeto Application.
Listagem 8.6 – Acessando os elementos da coleção Contents – contents.asp.

2 <HTML>
3 <HEAD>
4 <TITLE>Utilizando a coleção Contents</TITLE>
5 </HEAD>
6 <BODY>
7 <HR>
8 <%
9 Response.Write “Elementos da coleção Contents. <HR>”
10 For Each elemento in Application.Contents

11 Response.Write “Elemento: ” & elemento & “<BR>”
12 Next
14 %>
15 </BODY>
16 </HTML>
Ao carregarmos esta página no Internet Explorer, obtemos o resultado indicado na Figura 8.14.
480
Figura 8.14: Usando For Each...Next para exibir o nome dos elementos da coleção Contents.
NOTA
Neste caso a página contents.asp faz parte da aplicação que utiliza o arquivo global.asa da
Listagem 8.4. Observe que inclusive o elemento conn, o qual é um objeto do tipo Connection,
faz parte da coleção Contents.
Poderíamos modificar a Listagem 8.6, para que, além de exibir o nome de cada elemento, a mesma
exibisse o valor de cada um dos elementos. Esta alteração está indicada na Listagem 8.7.
Listagem 8.7 – Exibindo o nome e o conteúdo dos elementos da coleção Contents.

2 <HTML>
3 <HEAD>
5 </HEAD>
6 <BODY>
7 <HR>

9 <TR>
10 <TD><B>Elemento</B></TD>
481
11 <TD><B>Valor</B></TD>
12 </TR>
13 <%
15 For Each elemento in Application.Contents %>

16 <TR>
17 <TD><% =elemento %> </TD>
18 <TD><% =Application.Contents(elemento)%></TD>
19 </TR>
20 <%
21 Next
23 %>
24 </TABLE>
25 </BODY>
26 </HTML>
Ao carregarmos esta nova versão da página, no Internet Explorer, obtemos o resultado indicado
na Figura 8.15.
Figura 8.15: Usando For Each...Next para exibir o nome e o conteúdo

dos elementos da coleção Contents.
482
A Coleção StaticObjects
Para acessarmos um item da coleção StaticObjects, utilizamos a seguinte sintaxe:
Application.StaticObjects(Chave)
nome de todos os elementos da coleção StaticObjects.
<%
For Each elemento in Application.StaticObjects
Next
%>
Agora que já conhecemos os eventos e coleções do objeto Application, vamos ao estudo dos
métodos deste objeto.
Métodos do Objeto Application

Na Tabela 8.3 temos a descrição dos métodos do objeto Application.
Tabela 8.3 Os métodos do objeto Application.
Método Descrição
Contents.Remove O método Application.Contents.Remove exclui um
item de uma coleção. Este método considera uma
seqüência de caracteres ou um inteiro como um
parâmetro de entrada. Se o parâmetro de entrada for
uma seqüência de caracteres, o método pesquisará a
coleção Contents para localizar um item com esse
mesmo nome e o removerá. Se o parâmetro de entrada
for um inteiro, o método contará o número de itens
equivalente a partir do início da coleção e removerá o
item correspondente.
Contents.RemoveAll O método Application.Contents.RemoveAll remove
todos os itens que foram adicionados à coleção
Application.Contents.
483
Método Descrição
Lock O método Lock impede que outros clientes
modifiquem as variáveis armazenadas no objeto
Application, garantindo que apenas um cliente de
cada vez possa alterar ou acessar as variáveis do
objeto Application. Se o método Unlock não for
chamado explicitamente, o servidor desbloqueará o
objeto Application bloqueado quando o arquivo .asp
for concluído ou atingir seu tempo limite – TimeOut.
Unlock O método Unlock permite que outros clientes
modifiquem as variáveis armazenadas no objeto
Application após ele ter sido bloqueado usando o
método Lock. Se você não chamar explicitamente esse
método, o servidor Web desbloqueará objeto
Application quando o arquivo .asp for concluído ou
atingir seu tempo limite – TimeOut.
Agora vamos analisar alguns exemplos de código que utilizam os métodos do objeto Application.
A sintaxe para o método Contents.Remove é a seguinte:

Application.Contents.Remove(Nome_da_Variável)
No exemplo a seguir são adicionadas três variáveis em nível de aplicação. Depois utilizamos
o método Contents.Remove para remover uma das variáveis.
<%
Application(“Nome”) = Request.Form(“nome”)
Application(“Idade”) = Request.Form(“idade”)
Application(“ValorDolar”) = 1.72
Application.Contents.Remove(Idade)
%>
A sintaxe para o método Contents.RemoveAll é a seguinte:

Application.Contents.RemoveAll( )
No exemplo a seguir são adicionadas três variáveis em nível de aplicação. Depois utilizamos
o método Contents.RemoveAll para remover todas as variáveis, inclusive variáveis que tenham
sido adicionadas em outras páginas ASP da aplicação, ou através do arquivo global.asa.
<%
Application(“Nome”) = Request.Form(“nome”)
Application(“Idade”) = Request.Form(“idade”)
484
Application(“ValorDolar”) = 1.72
Application.Contents.RemoveAll( )
%>
A sintaxe para o método Lock é a seguinte:

Application.Lock
No exemplo a seguir, o método Lock impede que mais de um cliente acesse a variável
NumVisitantes ao mesmo tempo. Se o aplicativo não tivesse sido bloqueado, dois clientes
poderiam tentar incrementar a variável NumVisitantes simultaneamente.
<%
Application.Lock
Application(“NumVisitantes”) = Application(“NumVisitantes”) + 1
Application(“DataUltimaVisita”) = Now()
Application.Unlock
Response.Write “Esta aplicação já foi visitada: ”

%>
<%
= Application(“NumVisitantes”)
%>
<%
Response.Write “ Vezes!!!”
%> Vezes !!!
A sintaxe para o método UnLock é a seguinte:

Application.Unlock
No exemplo a seguir, o método Unlock libera o objeto bloqueado para que o próximo cliente
possa incrementar NumVisitantes.
<%
Application.Lock
Application(“NumVisitantes ”) = Application(“NumVisitantes ”) + 1
Application(“DataUltimaVisita ”) = Now()
Application.Unlock
%>
IMPORTANTE
O método Lock do aplicativo é cumulativo, significando que se o mesmo script chamar Lock
várias vezes, ele também deverá chamar Unlock o mesmo número de vezes para liberar
totalmente o aplicativo. Se isso não ocorrer, o bloqueio do aplicativo será mantido até que o
script termine de executar.
485
Com isso encerramos o estudo do objeto Application. Conforme estudamos, podemos criar
variáveis que estarão acessíveis para todos os usuários da aplicação (semelhante ao conceito
de variável global nas aplicações tradicionais); podemos criar objetos, como por exemplo um
objeto Connection, de tal forma que qualquer página ASP da aplicação utilize-o sem que para
isso o mesmo tenha que ser criado em cada página.
Agora passaremos ao estudo do objeto Session.
O Objeto Session
Podemos usar o objeto Session para armazenar as informações necessárias para uma
determinada sessão de usuário. As variáveis armazenadas no objeto Session não são
descartadas quando o usuário alterna entre as páginas do aplicativo; em vez disso, essas
variáveis persistem durante toda a sessão de usuário.
O servidor Web cria automaticamente um objeto Session quando uma página da Web de um
aplicativo é solicitada por um usuário que não tem uma sessão. O servidor descarta o objeto
Session quando a sessão expira (por TimeOut) ou é abandonada.
Um uso comum para o objeto Session é para armazenar as preferências do usuário. Por exemplo,
se um usuário indicar que prefere não visualizar elementos gráficos, você deverá armazenar
essa informação no objeto Session.
O diagrama da Figura 8.16 demonstra a relação entre o objeto Application, os diversos objetos
Session, o servidor Web e as diversas aplicações Web hospedadas no servidor.
Cada aplicação Web possui seu próprio objeto Application e informações disponíveis neste
objeto podem ser acessadas por qualquer usuário que estiver acessando a aplicação. Para
cada usuário que acessa a aplicação Web é criado um objeto Session, onde ficam armazenadas
as informações relacionadas a ele. Também podemos notar, na Figura 8.16, que em um mesmo
servidor Web podemos ter várias aplicações Web.
Informações armazenadas no objeto Session do usuário podem ser acessadas em qualquer

página da aplicação Web, desta forma é possível passar informações entre as diversas páginas
da aplicação Web durante a existência do objeto Session.
IMPORTANTE
O objeto Session é baseado em Cookies, por isso o estado da sessão só é mantido para
navegadores que suportam Cookies.
486
Usuário 1
Aplicação: web1
objeto Application
Sessão1 Usuário 2
Sessão2
Sessão3
Usuário 3
Aplicação: web2
objeto Application
Usuário 4
Sessão4
Sessão5
Usuário 5
Aplicação: web3
objeto Application Usuário 6
Sessão6
Cada aplicação Web possui o seu próprio objeto Application.

Para cada usuário conectado é criado um objeto Session
Diferente, o qual mantem informações relativas a cada usuário.
Figura 8.16: Para cada usuário conectado é criado um objeto Session.
Agora passaremos a estudar os eventos, coleções, propriedades e métodos do objeto Session.
Eventos do Objeto Session

Na Tabela 8.4, temos uma descrição dos eventos do objeto Session.
Tabela 8.4 Os eventos do objeto Session.
Evento Descrição
OnStart O evento Session_OnStart ocorre quando o servidor cria uma nova
sessão, processando esse script antes de executar a página solicitada.
O evento Session_OnStart é uma ótima oportunidade de definir as
variáveis no nível de sessão, porque as mesmas serão definidas antes
de se acessar quaisquer páginas. Todos os objetos incorporados
(Application, ObjectContext, Request, Response, Server e Session)
estão disponíveis e podem ser referenciados no script do evento
Session_OnStart. Você pode chamar o método Redirect no evento
Session_OnStart, por exemplo, para assegurar que os usuários sempre
iniciem uma sessão em determinada página da Web. Quando o
usuário entrar no aplicativo, o servidor criará uma sessão para este
usuário e processará o script do evento Session_OnStart. É possível
incluir um script nesse evento para verificar se a página aberta pelo
usuário é a página inicial e, se não for, podemos redirecioná-lo para a
página inicial através de uma chamada ao método Response.Redirect.
487
Evento Descrição
OnEnd O evento Session_OnEnd ocorre quando uma sessão é abandonada ou
o tempo limite expira – TimeOut. Para esse evento, somente estão
disponíveis os objetos Application, Server e Session.
O Evento Session_OnStart
A seguir é mostrada a sintaxe para este evento:
Sub Session_OnStart
’ Código para o evento Session_OnStart. . .
End Sub
</SCRIPT>
A seguir temos um exemplo de definição de código para o evento Session_OnStart. Neste

exemplo são criadas duas variáveis de nível de sessão. Uma com a estação do ano e outra com
cotação do dólar.
Sub Session_OnStart
Session(“EstacaoAno”) = “Inverno”
Session(“CotDolar”) = 1.77
End Sub
</SCRIPT>
Uma das principais utilizações do evento Session_OnStart é para a criação e inicialização de

variáveis em nível de sessão ou até mesmo objetos, como por exemplo, uma conexão com um
banco de dados.
Para criar uma variável em nível de sessão, utilizamos a seguinte sintaxe:

Session(“Nome_da_Variável”) = Valor_da_Variável
As variáveis EstacaoAno e CotDolar podem ser acessadas, pelo usuário conectado, em qualquer
página ASP da aplicação Web, pois são variáveis de nível de sessão, tecnicamente falando,
diríamos que são variáveis de nível do objeto Session, as quais estão disponíveis, em qualquer
página, para o usuário ligado à sessão.
488
Um detalhe importante a ser lembrado é que não é apenas no evento Session_OnStart que
podemos definir variáveis de nível de sessão. Em qualquer página ASP podemos definir uma
variável que estará disponível em nível de sessão. Para isso utilizamos a mesma sintaxe
utilizada no arquivo global.asa, conforme indicado abaixo:
<%
Session(“Nome_da_Variável”) = Valor_da_Variável
%>
Para acessar os valores das variáveis do objeto Session é muito simples, basta utilizar a sintaxe:
<%
= Session(“Nome_da_Variável”)
%>
Com isso será retornado o valor da variável.
Vamos a um exemplo prático. Suponhamos que tenham sido definidas três variáveis no evento
Session_OnStart, conforme indicado na Listagem 8.8, onde temos o arquivo global.asa para a
aplicação Capitulo8.
Listagem 8.8 – Arquivo global.asa onde são definidos três variáveis de nível de sessão.
2 Sub Session_OnStart
3 Session(“Mensagem”)= “Bem-vindo ao site da empresa ABC Ltda !”

5 Session(“CotAM”)= 1.50

7 Session(“CotPM”)= 2.00
8 End Sub
9 </SCRIPT>
Neste exemplo de arquivo global.asa, no evento Session_OnStart, definimos as variáveis

Mensagem, CotAM e CotPM. Estas são variáveis do objeto Session, portanto disponíveis para
qualquer página a ser acessada pelo usuário, desde que tenha sido estabelecida uma conexão.
Lembre que se o usuário estiver utilizando um navegador que não suporta Cookies, ou tiver
desabilitado o suporte a Cookies, a sessão não será estabelecida e as informações disponíveis
no objeto Session não estarão disponíveis.
489
Agora vamos criar uma página ASP que faz uso destas variáveis. A página usa_sessionvar.asp
irá detectar a hora do dia. Até às 11:59 será apresentada a mensagem “Bom Dia” e será
informado a cotação do dólar armazenada na variável CotAM. A partir de 12:00 será
apresentada a mensagem “Boa Tarde” e será informada a cotação do dólar armazenada na
variável CotPM. Em ambos os casos será emitida a mensagem contida na variável Mensagem.
Na Listagem 8.9 temos o código para a página usa_sessionvar.asp.
Listagem 8.9 – Utilizando variáveis do objeto Session.

2 <HTML>
3 <HEAD>
4 <TITLE> Utilizando variáveis em nível de Sessão !!</TITLE>
5 </HEAD>
6 <BODY>
7 <%
8 ‘ Atribui a hora do dia para a variável hora_dia
9 hora_dia = hour(Time())
10 Response.Write “Hora do dia: ” & hora_dia & “<HR>”
11 If hora_dia<12 Then
13 Response.Write “Bom Dia! <BR>”
14 Response.Write “Cotação do dólar: ” & Session(“CotAM”) & “<BR>”
15 Response.Write Session(“Mensagem”)
17 Else
19 Response.Write “Boa tarde ! <BR>”
20 Response.Write “Cotação do dólar: ” & Session(“CotPM”) & “<BR>”
21 Response.Write Session(“Mensagem”)
23 End If
24 %>
25 </BODY>
26 </HTML>
Observe que utilizamos a função hour(Time( )); como parâmetro para a função hour, passamos
a função Time ( ). A função Time( ) captura a hora do servidor Web e a função hour retira
apenas o valor numérico da hora.
490
Observe que para ter acesso a uma variável do objeto Session é só utilizar a seguinte sintaxe:
Session(“Nome_da_Variável”).
Ao visualizarmos o arquivo da Listagem 8.9, após o meio-dia, obteremos o resultado indicado

na Figura 8.17.
Figura 8.17: Resultado obtido após o meio-dia.
Já, ao visualizarmos o arquivo da Listagem 8.3, antes do meio-dia, obteremos o resultado

Figura 8.18: Resultado obtido antes do meio-dia.
491
A possibilidade de criar variáveis no evento Session_OnStart é bastante interessante,

principalmente pelo fato de que estas variáveis estarão disponíveis para o usuário em todas
as páginas que ele acessar na aplicação Web. Por exemplo, uma vez identificado o usuário,
podemos carregar, a partir de um banco de dados, uma série de informações sobre o mesmo
e atribui-las a variáveis do objeto Session. Com isso, em qualquer página da aplicação, as
informações sobre o usuário estarão disponíveis.
Um exemplo de utilização do objeto Session é encontrado em sites que oferecem treinamento

pela Internet. O usuário faz o cadastro no site e recebe um username e uma senha. Ao entrar
no site, o usuário se identifica através do seu username e senha. Após identificado, podemos
utilizar o objeto Session para localizar informações sobre os cursos em que o usuário está
cadastrado, os módulos já cursados e as suas preferências, tais como idioma de exibição da
página. Com isso posso criar um conteúdo personalizado para cada usuário, baseado nas
preferências do mesmo.
Porém não estamos limitados a criação de variáveis simplesmente. Podemos criar objetos no
evento Session_OnStart. Por exemplo, posso criar um objeto do tipo ADODB.Connection e
utilizar o método Open do mesmo. Com isso estou disponibilizando uma conexão de banco
de dados para o usuário, e em qualquer página da aplicação esta conexão pode ser utilizada.
Esta técnica apresenta, dentre outras, duas vantagens importantes:
➥ Não é necessário a colocação do código para criação da conexão, em cada página que
precisar da mesma. Isto facilita a construção das páginas e reduz a possibilidade de erros.
➥ Se, por algum motivo, for necessária a alteração das propriedades da conexão, basta
alterar a String de conexão em um único local (no arquivo global.asa), e não em todas
as páginas que fazem uso da conexão que está sendo alterada.
Na Listagem 8.10, temos um exemplo de conexão criada no evento Session_OnStart.
Listagem 8.10 – Criando uma conexão no evento Session_OnStart.

2 Sub Session_OnStart
3 Session(“Mensagem”)= “Bem-vindo ao site da empresa ABC Ltda!”

5 Session (“CotAM”)= 1.50

7 Session (“CotPM”)= 2.00
492
8 ‘Agora cria uma conexão com o banco de dados

9 ‘C:\Meus documentos\nwind.mdb
10 ‘Esta conexão estará disponível para todas as
11 ‘páginas da aplicação.
12 Set Session (“conexao”)=Server.CreateObject(“ADODB.Connection”)

13 Session (“conexao”).ConnectionString =“PROVIDER=MICROSOFT.JET.OLEDB.4.0;
14 Session(“conexao”).Open
15 End Sub
16 </SCRIPT>
IMPORTANTE
Para que o objeto conexao seja uma conexão do objeto Session, e com isso esteja disponível
para todas as páginas que o usuário acessar dentro da aplicação, devemos utilizar a sintaxe
indicada na Listagem 8.10, ou seja:
12 Set Session(“conexao”)=Server.CreateObject(“ADODB.Connection”)
Desta forma, precisamos utilizar Session(“Nome_do_Objeto”), pois se utilizarmos simplesmente

o nome do objeto, a mesma não pertencerá ao objeto Session e não estará disponível em todas
as páginas. O mesmo é válido na definição da propriedade ConnectionString e na utilização
do método Open.
Agora que criamos uma conexão no evento Session_OnStart, podemos utilizar esta conexão
em qualquer página da aplicação. Vamos a um exemplo de página ASP que utiliza esta conexão.
Na Listagem 8.11 temos uma página ASP que utiliza a conexão criada no evento
Session_OnStart. Observe que estamos criando um objeto RecordSet que utiliza esta conexão
como parâmetro para o método Open do objeto RecordSet.
Listagem 8.11 – Utilizando a conexão criada no evento OnStart – usa_sessioncon.asp.

2 <HTML>
3 <HEAD>
4 <TITLE> Utilizando uma conexão criada no arquivo global.asa.</TITLE>
5 </HEAD>
6 <BODY>
493
7 <%
8 ‘Nesta página estamos criando um objeto RecordSet,

9 ‘o qual utiliza a conexão Conn criada no evento
10 ‘Session_OnStart.
11 ‘O código que cria a conexão está no arquivo global.asa.

13 Pedidos.Open “Select * from Orders Order By OrderID”, Session(“conexao”), 3, 3

15 ‘Orders do banco de dados nwind.mdb.
16 ‘Agora passo a exibir os resultados.
17 %>
18 <P><B>Utilizei uma conexão criada no arquivo global.asa.</B></P>
20 <TR>
25 </TR>
26 <%
27 ‘Agora exibo os registros obtidos a partir da tabela Orders.
28 Response.Write “Foram encontrados: ” & Pedidos.RecordCount & “ Registros.<HR>”

31 %>
32 <TR>
494

36 <TD><% =Pedidos.Fields(“ShipCountry”) %></TD>
37 </TR>
38 <%
39 Pedidos.MoveNext
39 Loop
40 %>
41 </TABLE>
42 <BR>
43 <HR>
44 </BODY>
45 </HTML>
Na Figura 8.19 vemos o resultado quando a página usa_sessioncon.asp é carregada no Internet

Explorer.
Figura 8.19: Página que utiliza uma conexão criada no evento Session_OnStart.
495
Evento Session_OnEnd
Embora possamos criar variáveis e objetos no evento Application_OnEnd isto não teria
utilidade prática. Normalmente utilizamos o evento OnEnd para funções administrativas,
tais como gravar informações em um log de auditoria ou para gravar escolhas feita pelo usuário
em um banco de dados.
Sintaxe para o evento Session_OnEnd:

’ Código para o evento OnEnd. . .
End Sub
</SCRIPT>
A seguir temos um exemplo de definição de código para o evento OnEnd. Neste exemplo
estamos retirando o objeto conexao da memória, para liberar recursos no servidor Web.
Set Application(“conexao”) = Nothing
End Sub
</SCRIPT>
Coleções do Objeto Session

Na Tabela 8.5 temos a descrição das coleções do objeto Session.
Tabela 8.5 As coleções do objeto Session.
Contents Contém todos os itens que foram adicionados para uma
sessão, com exceção dos que foram declarados com a tag
<OBJECT>. Todas as variáveis e objetos criados com Set,
fazem parte desta coleção. Podemos usar a coleção Contents
para obter uma lista de itens aos quais tenha sido atribuído
escopo da sessão. É possível também remover os itens da
coleção com os métodos Remove e RemoveAll.
496
StaticObjects A coleção StaticObjects contém todos os objetos criados com
as tags <OBJECT> dentro do escopo da sessão. Podemos usar
esta coleção para determinar o valor de uma propriedade
específica de um objeto ou fazer interação através da coleção
e recuperar todas as propriedades de todos os objeto.
Agora passaremos a estudar a sintaxe e alguns exemplos de utilização das coleções do objeto
Session.
A Coleção Contents
Para acessarmos um item da coleção Contents, utilizamos a seguinte sintaxe:
Session.Contents(Chave)
Por exemplo, vamos supor que as seguintes variáveis tenham sido criadas no arquivo global.asa,
no evento Application_OnStart
Session(“Var1”) = “José da Silva”
Session (“Var2”) = “Maria do Socorro”
Session (“HoraDia”) = Hour(Time( ))
Poderíamos exibir o valor destas variáveis utilizando o seguinte código:

<%
Response.Write “Variáveis de nível de sessão.<HR>”
Response.Write “Var1: ” & Session.Contents(“Var1”) & “<BR>”
Response.Write “Var2: ” & Session.Contents(“Var2”) & “<BR>”
Response.Write “Hora do início da aplicação: ” & Session.Contents(“HoraDia”) &
“<BR>”
%>
O comando Session.Contents(“Var1”) retorna o valor da variável de sessão Var1. O comando

Session.Contents(“Var2”) retorna o valor da variável de sessão Var2 e assim por diante.
nome de todos os elementos da coleção Contents.
497
<%
For Each elemento in Session.Contents
Next
%>
Considere a Listagem 8.12, onde fazemos uso do operador For Each...Next para exibir o nome
de todos os itens da coleção Contents do objeto Session.
Listagem 8.12 – Acessando os elementos da coleção Contents – contents2.asp.

2 <HTML>
3 <HEAD>
5 </HEAD>
6 <BODY>
7 <HR>
8 <%
10 For Each elemento in Session.Contents

11 Response.Write “Elemento: ” & elemento & “<BR>”
12 Next
14 %>
15 </BODY>
16 </HTML>
Ao carregarmos esta página no Internet Explorer, obtemos o resultado indicado na Figura 8.20.
498
Figura 8.20: Usando For Each...Next para exibir o nome dos elementos da coleção Contents.
Poderíamos modificar a Listagem 8.11, para que além de exibir o nome de cada elemento, a
mesma exibisse o valor de cada um dos elementos. Esta alteração está indicada na Listagem 8.12.
Listagem 8.12 – Exibindo o nome e o conteúdo dos elementos da coleção Contents.

2 <HTML>
3 <HEAD>
5 </HEAD>
6 <BODY>
7 <HR>

9 <TR>
10 <TD><B>Elemento</B></TD>
11 <TD><B>Valor</B></TD>
12 </TR>
13 <%
499
15 For Each elemento in Application.Contents %>

16 <TR>
17 <TD><% =elemento %> </TD>
18 <TD><% =Session.Contents(elemento)%></TD>
19 </TR>
20 <%
21 Next
23 %>
24 </TABLE>
25 </BODY>
26 </HTML>
Ao carregarmos esta nova versão da página, no Internet Explorer, obtemos o resultado indicado
na Figura 8.21.
Figura 8.21: Usando For Each...Next para exibir o nome e o conteúdo dos
elementos da coleção Contents.
500
A Coleção StaticObjects
Para acessarmos um item da coleção StaticObjects, utilizamos a seguinte sintaxe:
Session.StaticObjects(Chave)
nome de todos os elementos da coleção StaticObjects.
<%
For Each elemento in Session.StaticObjects
Next
%>
Agora que já conhecemos os eventos e coleções do objeto Session, vamos ao estudo dos
métodos deste objeto.
Métodos do objeto Session

Na Tabela 8.6 temos a descrição dos métodos do objeto Session.
Tabela 8.6 Os métodos do objeto Session.
Método Descrição
Abandon O método Abandon elimina todos os objetos
armazenados em um objeto Session e libera seus
recursos. Se você não chamar o método Abandon
explicitamente, o servidor eliminará esses objetos
quando a sessão atingir seu tempo limite. Quando o
método Abandon é chamado, o objeto Session atual é
colocado em fila para exclusão, mas na verdade não é
excluído até que todos os comandos de script da página
atual tenham sido processados. Isso significa que você
pode acessar as variáveis armazenadas no objeto
Session na mesma página que utilizou o método
Abandon, mas não em quaisquer páginas subseqüentes
da aplicação Web.
501
Método Descrição
Contents.Remove O método Session.Contents.Remove exclui um item
especificado da coleção Contents. O método
Contents.Remove considera uma seqüência de
caracteres ou um inteiro como um parâmetro de
entrada. Se o parâmetro de entrada for uma seqüência
de caracteres, o método pesquisará a coleção Contents
para localizar um item com esse mesmo nome e o
removerá. Se o parâmetro de entrada for um inteiro, o
método contará o número de itens equivalente a partir
do início da coleção e removerá o item correspondente.
Contents.RemoveAll O método Session.Contents.RemoveAll remove todos os
itens que foram adicionados à coleção Session.Contents.
Agora vamos analisar alguns exemplos de código que utilizam os métodos do objeto Session.
A sintaxe para o método Contents.Remove é a seguinte:

Session.Contents.Remove(Nome_da_Variável)
No exemplo a seguir são adicionadas três variáveis em nível de sessão. Depois utilizamos o
método Contents.Remove para remover uma das variáveis.
<%
Session(“Nome”) = Request.Form(“nome”)
Session (“Idade”) = Request.Form(“idade”)
Session (“ValorDolar”) = 1.72
Session.Contents.Remove(Idade)
%>
A sintaxe para o método Contents.RemoveAll é a seguinte:

Session.Contents.RemoveAll( )
No exemplo a seguir são adicionadas três variáveis em nível de sessão. Depois utilizamos o
método Contents.RemoveAll para remover todas as variáveis, inclusive as que tenham sido
adicionadas pela sessão do usuário, em outras páginas ASP da aplicação, ou através do arquivo
global.asa utilizando o método Session_OnStart.
<%
Session (“Nome”) = Request.Form(“nome”)
Session (“Idade”) = Request.Form(“idade”)
502
Session (“ValorDolar”) = 1.72

Session.Contents.RemoveAll( )
%>
A sintaxe para o método Abandon é a seguinte:

<%
Session.Abandon
%>
Observe o exemplo a seguir, onde utilizamos o método Session.Abandon, porém após termos
utilizado este método, definimos e exibimos uma variável em nível de sessão. Esta variável será
exibida pois, conforme descrito anteriormente, a sessão somente será destruída após todas as
linhas de Script da página que chamou o método Session.Abandon terem sido executadas.
<%
Session.Abandon
Session(“NomeUsuario”) = “José da Silva”
Response.Write “Nome do usuário: ” & Session (“NomeUsuario”)
%>
NOTA
O servidor cria um novo objeto Session quando você abre uma página subseqüente da aplicação
Web depois de abandonar uma sessão. Você pode armazenar variáveis e objetos nesse novo
objeto Session.
Agora vamos ao estudo das propriedades do objeto Session.
Propriedades do Objeto Session

Na Tabela 8.7 temos a descrição das propriedades do objeto Session.
Tabela 8.7 Propriedades do objeto Session.
CodePage É uma propriedade de leitura e escrita, representada por um
número inteiro. A propriedade CodePage determina a página
de código que será usada para exibir o conteúdo dinâmico de
uma página ASP. Uma página de código é um conjunto de
caracteres que pode incluir números, marcas de pontuação e
503
outros hieróglifos. Diferentes idiomas e locais podem usar
diferentes páginas de código. Por exemplo, a página de código
ANSI 1252 é usada para o inglês americano e a maioria dos
idiomas europeus; a página de código OEM 932 é usada para
o Kanji japonês.
LCID A propriedade LCID determina o identificador de local que
será usado para exibir o conteúdo dinâmico.
SessionID A propriedade SessionID retorna o identificador da sessão,
um identificador exclusivo que é gerado pelo servidor quando
a sessão é criada. Uma identificação da sessão é retornada
como um tipo de dado LONG.
TimeOut A propriedade TimeOut especifica o tempo limite de duração
do objeto Session para esse aplicativo, em minutos. Se o
usuário não atualizar ou solicitar uma página dentro do período
de limite de tempo, a sessão é encerrada pelo servidor IIS.
Vamos estudar mais alguns detalhes sobre estas propriedades.
A sintaxe para a propriedade CodePage é a seguinte:

<%
Session.CodePage = número_página_código
%>
Por exemplo:
<%
Session.CodePage = 1252
%>
Na Tabela 8.8 temos o número para algumas páginas de código.
Tabela 8.8 Principais páginas de Código
Número Descrição
437 MS-DOS / EUA
850 MS-DOS / Internacional
1251 Windows / Rússia
504
Número Descrição
1252 Windows/ ANSI
1253 Windows/ Grécia
10000 Macintosh/ Padrão
A sintaxe para a propriedade LCID é a seguinte:

<%
Session.LCID = número_indicador_local
%>
Por exemplo:
<%
Session.LCID = 0816
%>
Este comando define as configurações de localidade para o Português de Portugal. O código

para o Brasil é 0416.
NOTA
As configurações de localidade definem diversas configurações, como por exemplo o símbolo da
moeda, o número de casas decimais, o formato da data e da hora, etc. São as opções configuradas
através do ícone Opções regionais do Painel de Controle. Para maiores detalhes sobre a
configuração das Opções regionais, consulte o Capítulo 2 do livro “Microsoft Windows 2000
Server Curso Básico & Rápido”, de minha autoria e publicado pela editora Axcel Books.
A sintaxe para a propriedade SessionID é a seguinte:

Session.SessionID
Por exemplo:
<%
Response.Write “Identificador da sessão: ” & Session.SessionID
%>
Este comando retorna um resultado semelhante ao seguinte:

Identificador da Sessão: 117013627
O número varia, pois para cada sessão este número é gerado automaticamente pelo servidor IIS.
505
IMPORTANTE
Você não deve usar a propriedade SessionID para gerar valores de chave primária para um
aplicativo de banco de dados. Isso porque se o servidor Web for reinicializado, alguns valores
de SessionID poderão ser os mesmos daqueles gerados antes do servidor ser parado. Em vez
disso, você deve usar os campos de auto-incremento do próprio banco de dados.
A sintaxe para a propriedade TimeOut é a seguinte:

Session.TimeOut = minutos
Por exemplo:
<%
Session.TimeOut = 20
%>
Este comando define o TimeOut da sessão para 20 minutos.
Com isso encerramos o estudo destes dois importantes objetos do ASP: Application e Session.
Conclusão
Neste capítulo estudamos alguns conceitos fundamentais, tais como:
➥ O que é uma aplicação Web no IIS.
➥ Quais os componentes de uma aplicação Web no IIS.
➥ O problema de manter o estado de uma conexão.
Aprendemos sobre quais elementos que compões uma aplicação Web no servidor IIS. Também
tratamos sobre as configurações de uma aplicação Web, utilizando o Gerenciador do Internet
Services. Aprendemos sobre diversas propriedades que podem ser configuradas para uma
aplicação Web.
Na seqüência aprendemos sobre o arquivo global.asa. Vimos que toda aplicação Web pode
conter um arquivo global.asa, no qual podem ser definidas variáveis de inicialização, tanto em
nível de aplicação quanto em nível de sessão. Para isso utilizamos, basicamente, quatro eventos
para os quais podemos escrever código no arquivo global.asa. Os eventos são os seguintes:
➥ Application_OnStart
➥ Application_OnEnd
➥ Session_OnStart
➥ Session_OnEnd
506
Fizemos um estudo detalhado do objeto Application. Foram explicados e exemplificados todos

os métodos, coleções e eventos deste objeto. Apresentamos alguns exemplos completos de
utilização deste objeto, tanto no arquivo global.asa quanto em páginas ASP. Também aprendemos
que, além de variáveis, é possível a criação de objetos no evento Application_OnStart. A título
de exemplos criamos um objeto que representa uma conexão com um Banco de dados.
O próximo passo foi o estudo detalhado do objeto Session. Foram explicados e exemplificados
todos os métodos, coleções, eventos e propriedades deste objeto. Apresentamos alguns
exemplos completos de utilização do objeto Session, tanto no arquivo global.asa quanto em
páginas ASP. Criamos um objeto do tipo ADODB.Connection, no evento Session_OnStart e
depois utilizamos este objeto em exemplos de páginas ASP.
No próximo capítulo iremos estudar alguns aspectos de segurança. Hoje em dia, com a
crescente onda de ataques a sites e aplicativos Web, em um mundo em que milhões de usuários
estão conectados a Internet, a questão de segurança é crítica. Iremos analisar algumas medidas
que podem melhorar o nível de segurança de nossos sites e aplicações Web, embora a
“criatividade” dos ataques tem sido cada vez mais surpreendente.
507
Capítulo 9 – Segurança de Aplicações Web com IIS e ASP
Capítulo 9
Segurança de Aplicações
Web com IIS e ASP
509
Quando se fala de Internet nos dias de hoje, o assunto mais tratado, sem nenhuma dúvida, é
Segurança. Muitos relatos, alguns verdadeiros e outros mais fantasiosos, sobre invasões
mirabolantes, roubo de número de cartões de créditos, acesso a informações sigilosas de
órgãos governamentais e assim por diante.
Não podemos negar que o problema de segurança existe e é crítico, principalmente hoje
quando o Comércio Eletrônico é, mais do que uma realidade, uma necessidade e um diferencial
competitivo para as empresas. O diferencial competitivo não é entrar ou não no mundo do e-
business, e sim criar serviços agregados ao Comércio Eletrônico, capazes de gerar diferenciais
competitivos. Assuntos como fidelização do cliente, melhorias nos sistemas de CRM –
Customer Relationship Management (Gerenciamento das Relações com o Cliente), B2B –
Bussines to Bussines, B2C – Bussines to Consumer e outros, estão em evidência.
Porém, sistemas de Comércio Eletrônico, CRM e assemelhados, exigem acesso a um conjunto

de dados estratégicos da empresa. Uma vez que estes sistemas estão acessíveis na Internet, os
dados empresariais precisam estar protegidos. Neste ponto é que a questão segurança é de
fundamental importância.
Existem os mais variados tipos de ataques pela Internet. Um engano comum é pensar que
único tipo ataque capaz de causar prejuízos é aquele que rouba ou destrói dados. No caso de
um site de Comércio Eletrônico, qualquer ataque que torne o site indisponível por um
determinado período de tempo causa prejuízos incalculáveis. Isso porque, além das compras
que deixaram de ser realizadas no período de indisponibilidade, tem a questão da imagem da
empresa, e da possibilidade de o cliente ter feito a compra no site do concorrente, gostar, e
passar a fazer as próximas compras lá.
Por todos estes motivos é que a questão de segurança é fundamental e deveria ser prioritária
quando tratamos de aplicações Web. Outro fato importante a ser mencionado é que a maioria
dos ataques, ao contrário do que muitos pensam, é originado na Intranet da própria empresa.
Pode ser um funcionário descontente ou desonesto, ou um usuário com permissões de acesso
indevidas que causa algum prejuízo por imperícia técnica. O fato é que a Segurança não deve
ser tratada apenas como uma questão de proteção contra “as forças do mal que vem da Internet”.
O que precisa-se é definir uma política de segurança que permita que todos possam realizar
o seu trabalho, porém com os níveis de permissão adequados.
Além de definir uma política de segurança, é necessária a ampla divulgação da mesma. É

alarmante constatar que muitas empresas não possuem uma política de segurança definida e
amplamente divulgada.
Outro erro bastante comum é achar que a questão de segurança é responsabilidade somente
da equipe de desenvolvimento ou do administrador da rede. Na verdade o item segurança é
510
bastante complexo e exige que o pessoal de desenvolvimento trabalhe em sintonia com a

administração da rede.
Conforme veremos neste capítulo, existem aspectos de segurança que são de responsabilidade
do desenvolvimento e outros que são de responsabilidade da administração de rede. Na
verdade, o que se faz é criar várias barreiras para que o hacker não tenha sucesso em sua
tentativa de invasão. Algumas destas barreiras são criadas na própria rede da empresa e
outras em nível de aplicação Web.
Neste capítulo estaremos tratando de:

➥ Questões como autenticação do usuário com o servidor Web.
➥ Aspectos de segurança a nível de Windows 2000 Server.
➥ Aspectos de segurança no IIS 5.0.
➥ Implementação de segurança a nível de banco de dados.
De maneira alguma temos a pretensão de que este capítulo seja um guia completo para a
segurança na Internet e para o Comércio Eletrônico. O objetivo é fornecer as informações
básicas para que o usuário possa tomar as medidas mínimas necessárias para garantir algum
grau de segurança para seu site e suas aplicações Web.
Quando trabalhamos com ASP, IIS e Windows 2000 Server, o endereço a seguir é de consulta
obrigatória para assuntos relacionados à segurança de tecnologias Microsoft: http://www.
microsoft.com/security.
Neste site são publicados boletins sobre segurança dos produtos Microsoft. Sempre que algum
novo problema é descoberto, são divulgadas informações sobre o problema, bem como a maneira
de corrigi-los. Também são disponibilizados arquivos para download. Estes arquivos normalmente
contém correções (Hot-fix) que devem ser aplicadas para solucionar problemas de segurança.
NOTA
Para acompanhar este capítulo o usuário deve conhecer alguns aspectos básicos do Windows
2000 Server, tais como: Permissões NTFS; Contas de Usuários e Grupos de Usuários; Utilização
do MMC – Microsoft Management Console e de Snap-in.
DICA
Para informações sobre estes itens, consulte o livro Windows 2000 Server Curso Básico & Rápido,
de minha autoria, publicado pela editora Axcel Books.
511
Autenticação de Usuários com o IIS 5.0

Quando um usuário tenta acessar uma página, a primeira coisa que o servidor precisa
determinar é a identidade deste usuário, isto é, o IIS precisa conhecer “quem” está tentando
acessar a página. Uma das maneiras de saber quem é o usuário que está acessando o site, é
através da utilização de um username e senha. Porém não seria nada “simpático” apresentar
uma tela de logon para o usuário a primeira vez que ele está acessando o site. Até mesmo nas
próximas tentativas de acesso, a necessidade de logon pode acabar afastando o usuário.
Através da autenticação do usuário, podem ser definidos os níveis de acesso a informação

que o mesmo tem, bem como podem ser feitos registros das ações realizadas pelo usuário,
mediante a gravação de logs de acesso. Existem diversos tipos de autenticação possíveis com
o IIS. Passaremos a estudá-los individualmente. Os tipos de autenticação que estudaremos
são os seguintes:
➥ Anônima.
➥ Básica.
➥ Avançada.
➥ Integrada ao Windows 2000.
➥ Com certificados.
O Acesso Anônimo
Um tipo de autenticação bastante comum é o que permite o acesso anônimo. O IIS permite
que seja configurado um tipo de acesso chamado Acesso Anônimo, no qual não é necessário
que o usuário forneça um username e senha para ter acesso ao site. Este acesso anônimo está
ligado a uma única conta de usuário do Windows 2000 Server. Todo o usuário que acessar
um site configurado para permitir acesso anônimo, será identificado como se estivesse
autenticado usando a conta de usuário configurada para este tipo de acesso.
A conta de usuário para acesso anônimo é automaticamente criada quando instalamos o

Internet Information Services 5.0. Por padrão esta conta possui o seguinte nome:
IUSR_NOME_DO_COMPUTADOR
Por exemplo, ao instalarmos o IIS em um servidor chamado SERVER02SP, será criada a seguinte
conta para permitir o acesso anônimo:
IUSR_SERVER02SP
A autenticação anônima fornece aos usuários acesso a áreas públicas do seu site, sem solicitar
um nome de usuário ou uma senha.
512
Por padrão, a conta IUSR_NOME_DO_COMPUTADOR é incluída no grupo de usuários

“Convidados do Windows”. Esse grupo tem restrições de segurança, impostas pelas permissões
do NTFS (sistema de arquivos do Windows 2000 que possui recursos de segurança mais
avançados do que o sistema FAT ou FAT32), que designam o nível de acesso e o tipo de
conteúdo disponível para os usuários públicos. Com isso o usuário possui limitações sobre
os recursos que o mesmo pode acessar no servidor, sendo que estas limitações já atuam como
um nível de segurança.
Se existem vários sites no seu servidor ou áreas no seu site que exigem privilégios de acesso
diferentes, você pode criar várias contas anônimas, uma para cada área site, diretório ou arquivo.
Por exemplo, você pode querer medir o nível de acesso a diferentes áreas do seu site, utilizando
para isso diferentes contas para o acesso anônimo a cada uma destas áreas.
O IIS usa a conta IUSR_NOME_DO_COMPUTADOR da seguinte forma:

➥ A conta IUSR_NOME_DO_COMPUTADOR é adicionada ao grupo Convidados no
computador, conforme descrito anteriormente.
➥ Quando uma solicitação é recebida, o IIS representa a conta IUSR_NOME_DO_COMPU-
TADOR antes de executar qualquer código ou acessar qualquer arquivo. O IIS pode
representar a conta IUSR_NOME_DO_COMPUTADOR pois conhece o nome de usuário
e a senha dessa conta.
➥ Antes de retornar uma página ao cliente, o IIS verifica as permissões dos arquivos e
diretórios do NTFS para ver se a conta IUSR_NOME_DO_COMPUTADOR tem permissão
para acessar o arquivo. Neste ponto é que podemos limitar as áreas as quais o usuário,
que entra como anônimo, tem acesso. Basta configurar as permissões NTFS para que a
conta associada ao acesso anônimo somente tenha acesso às áreas públicas do site.
➥ Se o acesso for permitido, a autenticação é concluída e os recursos tornam-se disponíveis
para o usuário.
➥ Se o acesso não for permitido, o IIS tenta usar outro método de autenticação. Se nenhum
método for selecionado, o IIS retorna uma mensagem de erro “HTTP 403 Acesso negado”
ao navegador do cliente.
NOTA
Veremos sobre os outros métodos de autenticação ainda neste capítulo.
Na Figura 9.1, temos uma representação desta seqüência para o acesso anônimo.
513
IUSR_SERVER02SP IUSR_SERVER02SP
tem permissões não tem permissões
NTFS, então acesso OK. NTFS, acesso negado.
Autenticado:
Usuário
IUSR_SERVER02SP
Servidor: SERVER02SP
Figura 9.1: Acesso anônimo no IIS.
Se a autenticação anônima for ativada, o IIS tentará sempre a autenticação usando-a primeiro,
mesmo se outros métodos forem ativados.
Em alguns casos, o navegador solicitará ao usuário um nome de usuário e uma senha.
Você pode alterar a conta usada para a autenticação anônima no Snap-in do IIS, no nível de
serviço do servidor Web ou para diretórios virtuais ou arquivos individuais.
A conta anônima deve ter o direito de usuário de efetuar logon localmente. Se a conta não
tiver a permissão “Efetuar logon localmente”, o IIS não poderá atender qualquer solicitação
anônima. Ao instalarmos o IIS, automaticamente, a permissão “Efetuar logon localmente” é
concedida à conta IUSR_NOME_DO_COMPUTADOR.
NOTA
As contas IUSR_NOME_DO_COMPUTADOR em controladores de domínio não são adicionadas
ao grupo Convidados do domínio, por padrão, e devem ser alteradas para Efetuar logon
localmente a fim de permitir logon anônimo.
Agora vamos aprender a efetuar as seguintes atividades práticas:

➥ Definir a conta para acesso anônimo no IIS.
➥ Verificar a que grupos pertence a conta IUSR_NOME_DO_SERVIDOR.
514
➥ Verificar a permissão Efetuar logon local para a conta IUSR_NOME_DO_SERVIDOR.

➥ Definir permissões NTFS para uma conta de usuário.
Estas atividades são importantes, não só para as configurações do acesso anônimo, mas para
a configuração de qualquer tipo de acesso.
DICA
Para informações mais detalhadas sobre estes itens, consulte o livro Windows 2000 Server
Curso Básico & Rápido de minha autoria, publicado pela editora Axcel Books.
Como Definir a Conta Para Acesso Anônimo no IIS 5.0

Para definir qual conta será utilizada para o acesso anônimo siga os seguintes passos:
2. Abra o Gerenciador do Internet Services: Iniciar/Programas/Ferramentas administrati-
vas/Gerenciador do Internet Services.
3. Surge a janela indicada na Figura 9.2
Figura 9.2: O Gerenciador do Internet Services.
4. Esta é a janela do console de administração do IIS 5.0.

5. Dê um clique duplo no nome do computador. No nosso exemplo o nome é Servidor.
515
7. Neste momento podemos configurar o acesso anônimo para todos os aplicativos Web
contidos no servidor ou para cada aplicativo individualmente. Inclusive podemos
configurar diferentes contas do Windows 2000 Server, para serem utilizadas para o
acesso anônimo em diferentes áreas do site. Podemos configurar uma conta a nível do
servidor Web, de cada aplicação e até mesmo para uma pasta dentro de uma aplicação.
Com isso poderíamos ter diferentes pastas, dentro de uma mesma aplicação Web (que
para o IIS é representada por uma pasta virtual, conforme descrito no capítulo ante-
rior), com diferentes contas para acesso anônimo.
8. No nosso exemplo, iremos configurar uma única conta para acesso anônimo para todo
o site. O procedimento é o mesmo quer seja para o site como um todo, para uma
aplicação Web do site ou para uma pasta dentro da aplicação Web.
9. Clique com o botão direito do mouse sobre a opção Site da Web padrão (ou na opção
correspondente, caso você tenha alterado este nome). No menu de opções que surge
dê um clique em Propriedades.
10. Será exibida a janela Propriedades de Site Web padrão, conforme indicado na Figura 9.4.
11. Dê um clique na guia Segurança de pasta. Serão exibidas as opções indicadas na Figura 9.5.
12. A primeira opção desta guia é Controle de acesso anônimo e autenticação. Dê um
clique no botão Editar, ao lado desta opção. Surge a janela Métodos de autenticação,
indicada na Figura 9.6.
13. A primeira opção desta janela é Acesso anônimo. Para que o acesso anônimo seja
permitido, esta opção deve estar marcada.
14. Para definir a conta que será utilizada para o acesso anônimo, dê um clique no botão
Editar desta opção.
15. Será exibida a janela Conta de usuário anônimo, conforme indicado na Figura 9.7.
516
Figura 9.4: Propriedades do Site Web padrão.
Figura 9.5: As opções da guia Segurança de pasta.
517
Figura 9.6: As opções para métodos de autenticação.
Figura 9.7: Definindo a conta para usuário anônimo.
16. Nesta janela você pode definir a conta que será utilizada para o acesso anônimo. Ob-
serve que por padrão é definida a conta IUSR_NOME_DO_COMPUTADOR. No exemplo
da Figura 9.7, aparece IUSR_SERVIDOR, pois o computador que estou utilizando para
escrever este livro tem o nome de SERVIDOR.
17. Caso você queira utilizar outra conta e não lembre o nome da mesma, é só clicar no
botão Procurar, que será exibida uma lista de usuários do Windows 2000.
18. A opção Permitir que o IIS controle a senha é interessante de ser comentada. Esta
opção quando selecionada permite ao IIS sincronizar automaticamente as configurações
de senha anônima com aquelas definidas no Windows 2000. Se a senha fornecida à
518
conta anônima e a senha do Windows para a conta forem diferentes, a autenticação

anônima não funcionará. Este é um dos erros mais comuns e a causa mais freqüente
de indisponibilidade de um site IIS. Por algum motivo esta opção não está marcada,
com isso é preciso digitar a senha para a conta IUSR_NOME_DO_COMPUTADOR. O
usuário digita a senha e OK.
Porém mais adiante, por algum motivo ou por solicitação do Administrador do IIS, a senha
para esta conta é alterada no Windows 2000. Como a sincronização não está ativada, o IIS
continua tentando usar a senha antiga. Como as duas senhas estão diferentes o acesso é
negado e o usuário recebe uma mensagem de acesso negado ao tentar acessar o site.
IMPORTANTE
A sincronização de senhas deve ser usada somente com contas de usuário anônimas definidas
no computador local e não com contas anônimas de computadores remotos.
19. Após ter configurado as informações para a conta de acesso anônimo, dê um clique em OK.
20. Você estará de volta à janela Métodos de autenticação, dê um clique em OK para fechá-la.
21. Você estará de volta à janela Propriedades do site da Web padrão, dê um clique em OK
para fechá-la.
22. Você estará de volta ao Gerenciador do Internet Services. Feche-o.
NOTA
Para definir uma conta de acesso anônimo diferente para uma das aplicações Web do site, ou
até mesmo para uma subpasta de uma aplicação Web, basta repetir os passos indicados.
Verificando as Configurações da Conta Para

Acesso Anônimo no Windows 2000 Server
Conforme descrito anteriormente, a conta IUSR_NOME_DO_COMPUTADOR deve ter algumas
configurações especiais (relativas a permissões e direitos), definidas no Windows 2000 Server.
Agora veremos como conferir se as configurações para esta conta estão corretas.
Vamos verificar duas configurações a respeito desta conta:

➥ A que Grupos de Usuários do Windows 2000 pertence esta conta.
➥ Se a conta possui permissão de fazer o logon localmente.
519
Para verificar a que grupos pertence a conta IUSR_NOME_DO_COMPUTADOR:

2. Abra o Console para Gerenciamento do computador: Iniciar/Programas/Ferramentas
administrativas/Gerenciador do Computador.
NOTA
Se o servidor que você estiver utilizando for um controlador de domínio, você deve abrir o
console para Gerenciamento do Active Directory. As opções que surgem podem ser um pouco
diferentes das apresentadas neste exemplo.
Figura 9.8: O console para Gerenciamento do computador.
4. Dê um clique no sinal de + ao lado da opção Ferramentas de sistema, para abri-la.

5. Nas opções que surgem, abaixo de Ferramentas de sistema, dê um clique no sinal de +
ao lado da opção Usuários e grupos locais para abri-la.
7. Dê um clique na opção Usuários. Surge, no painel da direita, uma listagem com o
nome de todos os usuários, conforme indicado na Figura 9.10.
8. Na lista de usuários, do painel da direita, localize o usuário IUSR_NOME_DO_COMPU-
TADOR e dê um clique duplo sobre o mesmo para abrir a janela de propriedades do
usuário, coforme indicado na Figura 9.11. No nosso exemplo é o usuário IUSR_SER-
VIDOR, pois conforme descrito anteriormente, o computador que estou utilizando é
chamado SERVIDOR.
520
Figura 9.9: Informações sobre os usuários e Grupos de usuário do Windows 2000.
Figura 9.10: Listagem dos usuários cadastrados.
9. Para saber a quais grupos o usuário pertence, dê um clique na guia Participante de,
com isso veremos que o usuário IUSR_SERVIDOR somente pertence ao grupo
Convidados. Se estivéssemos em um servidor que atua como controlador de domínio,
teríamos o grupo Convidados do domínio.
521
Figura 9.11: Propriedades para o usuário IUSR_SERVIDOR.
DICA
Para informações mais detalhadas sobre Controladores de domínio e Active Directory, consulte
o livro Windows 2000 Server Curso Básico & Rápido, de minha autoria, publicado pela editora
Axcel Books.
10. Quando o IIS é instalado, a conta IUSR_SERVIDOR é criada e automaticamente

adicionada ao grupo Convidados.
11. Muito cuidado ao adicionar a conta IUSR_SERVIDOR a outros grupos. Quando uma
conta de usuário é adicionada a um grupo, ela herda as permissões atribuídas ao grupo
e com isso passa a ter acesso aos recursos que o grupo tem acesso. A maior insanidade
que o administrador Web poderia cometer seria adicionar a conta IUSR_SERVIDOR ao
grupo Administradores. Com isso estaria dando permissões máximas aos usuários que
fazem acesso anônimo. Seria caso de internação do seu administrador Web.
12. Clique no botão OK para fechar a janela com as propriedades da conta IUSR_SERVIDOR.
13. Você estará de volta ao Gerenciador do computador, feche-o.
522
Agora precisamos verificar se a conta IUSR_SERVIDOR tem a permissão para efetuar logon local.
Para verificar isso:

2. Abra o Console Configurações locais de segurança/Programas/Ferramentas administrati-
vas/Diretivas de segurança local.
NOTA
Se o servidor que você estiver utilizando for um controlador de domínio, você deve abrir o
console para Gerenciamento do Active Directory. As opções que surgem podem ser um pouco
diferentes das apresentadas aqui.
Figura 9.12: Configurações locais de segurança.
4. Dê um clique no sinal de + ao lado da opção Diretivas locais, para abri-la.

5. Nas opções que surgem, abaixo de Diretivas locais, dê um clique no sinal de + ao lado
da opção Atribuição de direitos de usuário, para abri-la.
7. No painel da direita surgem as diversas permissões disponíveis.
8. Na listagem de permissões, localize Efetuar logon local, conforme indicado na Figura 9.14.
523
Figura 9.13: Atribuições de direitos para contas e Grupos de usuários.
Figura 9.14: A permissão Efetuar logon local.
9. Dê um clique duplo sobre a permissão Efetuar logon local, para exibir a janela de
configurações para esta Diretiva de segurança local. Nesta janela surge uma lista dos
usuários que possuem a permissão de Efetuar logon local, conforme indicado na Figura
9.15. O usuário IUSR_SERVIDOR deve fazer parte da lista.
10. Caso o usuário IUSR_SERVIDOR não estivesse na lista, você poderia adicioná-lo
utilizando o botão Adicionar.
524
Figura 9.15: Lista de usuários com direito a Efetuar logon local.
11. A permissão Efetuar logon local autoriza o usuário a fazer o logon no console do servidor,
isto é, localmente no servidor. A conta utilizada para acesso anônimo precisa desta
permissão, caso contrário o acesso anônimo não irá funcionar.
12. Dê um clique no botão OK para voltar ao console Configurações locais de segurança.
13. Feche-o.
Com isso já sabemos que a conta para acesso anônimo está configurada corretamente. No próximo
item vamos retirar as permissões NTFS da conta de acesso anônimo de uma das aplicações
Web do servidor. Vamos tentar acessar esta aplicação e observar os resultados obtidos.
Configurando Permissões NTFS em Pastas do Servidor Web

Uma das medidas básicas de segurança é a utilização de drives formatados com o sistema de
arquivos NTFS, ao invés de FAT e FAT32. O motivo é bastante simples, pois através da utilização
do sistema de arquivos NTFS, podemos ter um controle bastante refinado sobre o acesso às
informações, mediante a atribuição de permissões de pasta e de arquivos.
Quando estamos tratando de permissões NTFS, já estamos em um nível de segurança que é

gerenciado pelo Sistema Operacional. É através da utilização do Windows 2000 Server que
525
definimos permissões NTFS. Isso reforça o fato de que a segurança é tanto responsabilidade
do grupo de desenvolvimento, quanto do administrador da rede.
No exemplo do acesso anônimo, o usuário é identificado para o Windows 2000, como se

fosse o usuário IUSR_NOME_DO_COMPUTADOR. Este usuário somente terá acesso às pastas
e arquivos para os quais o usuário IUSR_NOME_DO_COMPUTADOR tiver permissões de
acesso e com os níveis de permissões definidos.
Antes de aprendermos a definir permissões NTFS vamos aprender um pouco mais sobre as mesmas.
Sistemas de Arquivos no Windows 2000 e Permissões NTFS

Agora vamos ver alguns detalhes sobre os sistemas de arquivos que o Windows 2000 Server
reconhece e também sobre permissões NTFS.
Um sistema de arquivos determina a maneira como o Windows 2000 Server organiza e recupera
as informações no disco rígido ou em outros tipos de mídia. O Windows 2000 Server reconhece
os seguintes sistemas de arquivos:
➥ FAT
➥ FAT32
➥ NTFS
➥ NTFS 5
O sistema FAT vem desde a época do DOS e tem sido mantido por questões de compatibilidade.
Além disso, se você tiver instalado mais de um Sistema Operacional no seu computador,
alguns sistemas mais antigos (DOS, Windows 3.x e as primeiras versões do Windows 95)
somente reconhecem o sistema FAT. Com o sistema de arquivos FAT, a única maneira de
restringir o acesso ao conteúdo de uma pasta compartilhada, é através das permissões de
compartilhamento, as quais, não tem efeito no caso de acessos pela Internet, através do IIS.
Com a utilização do sistema FAT, alguns recursos avançados, tais como compressão, criptografia
e auditoria, não estão disponíveis.
O sistema FAT32 apresenta algumas melhorias em relação ao sistema FAT. Existe um melhor
aproveitamento do espaço no disco, com conseqüente menor desperdício. Um grande
inconveniente do sistema FAT32 é que ele não é reconhecido pelo Windows NT Server 4.0.
Com o sistema de arquivos FAT32, a única maneira de restringir o acesso ao conteúdo de uma
pasta compartilhada, é através das permissões de compartilhamento. Assim como ocorre
com a utilização do FAT, no sistema FAT32, alguns recursos avançados, tais como compressão,
criptografia e auditoria, não estão disponíveis.
526
O sistema de arquivos NTFS é utilizado no Windows NT Server 4.0 e foi mantido e melhorado
no Windows 2000 Server, por questões de compatibilidade, já que uma nova versão do NTFS
foi introduzida com o Windows 2000 – NTFS 5. É um sistema bem mais eficiente do que FAT
e FAT32, além de permitir uma série de recursos avançados, tais como:
➥ Permissões a nível de arquivos e pastas.
➥ Compressão.
➥ Auditoria de acesso.
➥ Partições bem maiores do que as permitidas com FAT e FAT32.
➥ Desempenho bem superior do que com FAT e FAT32.
Uma das principais vantagens do NTFS é que o mesmo permite que sejam definidas permissões
de acesso a nível de arquivo e de pastas, isto é, posso ter arquivos em uma mesma pasta, com
permissões diferentes para usuários diferentes. Além disso, as permissões NTFS têm efeito
localmente, isto é, mesmo que o usuário faça o logon no computador onde um determinado
arquivo existe, se o usuário não tiver as permissões NTFS necessárias, ele não poderá acessar
o arquivo. Isso confere um alto grau de segurança, desde que as permissões NTFS sejam
configuradas corretamente.
No Windows 2000 Server, conforme descrito anteriormente, temos também o NTFS 5, o qual
apresenta diversas melhorias em relação ao NTFS, tais como:
➥ Criptografia de arquivos e pastas (a criptografia é uma maneira de “embaralhar” a
informação de tal forma que mesmo que um arquivo seja copiado, o mesmo se torna
ininteligível, a não ser para a pessoa que possui a “chave” para descriptografá-lo).
➥ Cotas de usuário, fazendo com que seja possível limitar o espaço em disco que cada
usuário pode utilizar.
➥ Gerenciamento e otimização melhorados.
Um inconveniente do NTFS 5 é que ele não é reconhecido pelas versões anteriores, tais como
o Windows NT Server 4.0. Caso você possua uma rede na qual estão presentes servidores
com o Windows 2000 Server e com o Windows NT Server 4.0, planeje com bastante cuidado
a utilização do NTFS 5.
Conforme descrito anteriormente, podemos definir permissões de acesso a nível da pasta ou

arquivo, mas somente em unidades formatadas com o sistema de arquivos NTFS (seja na versão
do NT Server 4.0 ou o NTFS 5 do Windows 2000 Server). Portanto, é aconselhável instalar o
Windows 2000 Server sempre em unidades formatadas com NTFS, pois isso melhora a segurança.
Com relação às permissões NTFS, temos um conjunto diferente de permissões quando tratamos
de pastas ou arquivos. Nas Tabelas 9.1 (para pastas) e 9.2 (para arquivos), são apresentadas as
permissões e o nível de acesso para cada uma delas.
527
Tabela 9.1 Permissões NTFS para pastas.
Permissão Nível de acesso

Leitura Permite ao usuário listar as pastas e arquivos
dentro da pasta; permite que sejam exibidas as
permissões, donos e atributos.
Gravar Permite ao usuário criar novos arquivos e
subpastas dentro da pasta, alterar seus
atributos e visualizar o dono e as permissões
da mesma.
Listar conteúdo de pastas Permite ao usuário ver o nome dos arquivos
e subpastas.
Ler e executar Permite ao usuário navegar através das
subpastas para chegar a outras pastas e
arquivos, mesmo que o usuário não tenha
permissão de acesso às pastas pelas quais está
navegando. Além disso, possui os mesmos
direitos que as permissões Leitura e Listar
conteúdo de pastas.
Modificar Permite ao usuário eliminar a pasta, e mais
todas as ações permitidas pelas permissões
Gravar e Ler e executar.
Controle total Permite que sejam alteradas as permissões;
permite ao usuário tornar-se dono da pasta,
eliminar subpastas e arquivos, e mais todas
as ações permitidas por todas as outras
permissões NTFS.
Tabela 9.2 Permissões NTFS para arquivos.

Leitura Permite ao usuário ler o arquivo; permite que sejam
exibidas as permissões, dono e atributos.
Gravar Permite ao usuário gravar um arquivo com o mesmo nome
sobre o arquivo, alterar seus atributos e visualizar o
dono e as permissões do mesmo.
528

Ler e executar Permite ao usuário executar aplicativos (normalmente
programas .exe, .bat ou .com) e mais todos os direitos da
permissão Leitura.
Modificar Permite ao usuário modificar e eliminar o arquivo e mais
todas as ações permitidas pela permissão Gravar e pela
permissão Ler e executar.
Controle total Permite que sejam alteradas as permissões; permite ao
usuário tornar-se dono do arquivo, e mais todas as ações
permitidas por todas as outras permissões NTFS.
Todo arquivo ou pasta em uma unidade formatada com NTFS, possui uma Lista de Controle
de Acesso (Access Control List ) – ACL. Nesta ACL ficam uma lista de todas as contas de
usuários e grupos para os quais foi garantido acesso para o recurso, bem como o nível de
acesso de cada um deles.
Existem alguns detalhes que devemos observar sobre permissões NTFS:

➥ Permissões NTFS são cumulativas, isto é, se um usuário pertence a mais de um grupo,
o qual tem diferentes níveis de permissão para um recurso, a permissão efetiva do
usuário é a soma das permissões.
➥ Permissões NTFS para um arquivo têm prioridade sobre permissões NTFS para pastas.
Por exemplo se um usuário têm permissão NTFS de escrita em uma pasta, mas somente
permissão NTFS de leitura para um arquivo dentro desta pasta, a sua permissão efetiva
será somente a de leitura, pois a permissão para o arquivo tem prioridade sobre a
permissão para a pasta.
➥ Negar uma permissão NTFS tem prioridade sobre Permitir. Por exemplo, se um usuário
pertence a dois grupos diferentes. Se para um dos grupos foi dada permissão de leitura
para um arquivo e para o outro grupo foi negada, o usuário não terá o direito de leitura,
pois Negar tem prioridade sobre Permitir.
Agora que já conhecemos um pouco mais sobre permissões NTFS, podemos aprender como
configurar estas permissões.
Definindo Permissões NTFS

Neste exemplo prático vamos fazer o seguinte:
➥ Vamos retirar as permissões NTFS do usuário IUSR_SERVIDOR da pasta de um
aplicativo Web.
529
➥ Vamos tentar acessar o aplicativo e observar a mensagem de erro que recebemos.

➥ Vamos restaurar as permissões originais e tentar acessar a página novamente.
Para acessar as permissões NTFS de uma pasta e retirar as permissões do usuário IUSR_SERVIDOR,
faça o seguinte:
1. Faça o logon com privilégios de administrador.
2. Utilizando o Windows Explorer, localize a pasta cujas permissões NTFS serão alteradas.
3. Dê um clique com o botão direito do mouse sobre a pasta. No menu de opções que
surge dê um clique em Propriedades.
Figura 9.16: Janela com as propriedades da pasta.
5. Dê um clique na guia Segurança.

530
Figura 9.17: As configurações de segurança para a pasta selecionada.
7. Observe que a conta com a descrição Conta de convidado da Internet é a conta para
acesso anônimo, que no nosso exemplo é IUSR_SERVIDOR. Somente possuem
permissão de acesso, as contas que fazem parte desta lista.
8. Dê um clique no botão Avançado. Surge a janela indicada na Figura 9.18.
9. Observe que a conta para acesso anônimo, possui permissão somente de leitura.
10. Vamos remover as permissões da conta IUSR_SERVIDOR (Conta de convidado da
Internet). Para isso dê um clique sobre a conta para marcá-la, depois dê um clique no
botão Remover.
11. A conta IUSR_SERVIDOR não aparece mais na listagem.
12. Marque a opção Redefinir opções em todos os objetos filhos e permitir a propagação
das permissões herdades. Esta opção deve ser marcada para que as alterações que
estão sendo feitas na pasta, sejam propagadas para todas as subpastas e arquivos
pertencentes a esta pasta. Esta modificação é necessária para que a permissão para o
usuário IUSR_SERVIDOR seja retirada de todos os arquivos pertencentes a pasta que
está sendo alterada.
531
Figura 9.18: A conta IUSR_SERVIDOR possui permissão somente para leitura.
13. Dê um clique no botão OK para voltar à janela de propriedades da pasta.

14. Surge uma janela pedindo confirmação. Dê um clique em Sim para continuar.
15. Você estará de volta à janela de propriedades da pasta.
16. Na lista de usuários, remova os usuários IUSR_SERVIDOR e o grupo Todos. Para isso
basta clicar no nome do usuário ou grupo e depois clicar no botão Remover.
17. A sua lista de permissões deve estar semelhante a indicada na Figura 9.19.
18. Dê um clique no botão OK para fechar esta janela.
Agora que retiramos as permissões do usuário anônimo, se alguém tentar acessar algum arquivo
que está na pasta cujas permissões foram retiradas, irá receber uma mensagem de erro,
Veja que a mensagem informa que o acesso à página solicitada foi negado. Isto acontece
porque o usuário IUSR_SERVIDOR não possui as permissões NTFS necessárias.
532
Figura 9.19: Lista de permissões, onde foi retirada a permissão de acesso para o usuário anônimo.
Figura 9.20: Mensagem de erro ao tentar acessar uma página para a qual o usuário anônimo
(conta IUSR_SERVIDOR, no nosso exemplo) não tem mais permissão de acesso.
533
IMPORTANTE
Caso você teste o acesso localmente no servidor onde a página está gravada e a autenticação
integrada esteja habilitada, você terá acesso à página. Isto acontece porque o IIS tenta primeiro
acesso com a autenticação anônima. Não obtém sucesso. Se a autenticação integrada (a qual
utiliza a conta do Windows que você utilizou para fazer o logon) estiver habilitada, o IIS tenta
utilizá-la. Caso a conta que você utilizou para fazer o logon tenha permissão de acesso à
página, o IIS libera o acesso. Isto também é válido para usuários da sua rede local que fizeram
o logon em um domínio do Windows NT Server 4.0 ou do Windows 2000 e cujas contas ou
grupos a que pertencem possuam permissão de acesso para o arquivo solicitado. Nos próximos
itens veremos mais sobre a autenticação integrada.
Agora vamos restaurar as permissões NTFS para o usuário IUSR_SERVIDOR e testar para ver
se ele voltou a ter acesso.
Para atribuir novamente as permissões NTFS para o usuário IUSR_SERVIDOR.

1. Utilizando o Windows Explorer, localize a pasta cujas permissões NTFS serão alteradas.
2. Dê um clique com o botão direito do mouse sobre a pasta. No menu de opções, que
surge, dê um clique em Propriedades.
3. Na janela de propriedades dê um clique na guia Segurança.
Figura 9.21: As configurações de segurança para a pasta selecionada.
534
5. Observe que a conta com a descrição Conta de convidado da Internet, que é a conta
para acesso anônimo (no nosso exemplo, IUSR_SERVIDOR), não aparece na lista de
usuários, portanto a mesma não possui permissões de acesso.
6. Dê um clique no botão Avançado. Observe que, na janela que surge, a conta
IUSR_SERVIDOR também não está na listagem, conforme indicado na Figura 9.22.
Figura 9.22: A conta IUSR_SERVIDOR não aparece na lista de contas.
7. Dê um clique no botão Adicionar. Surge uma janela com a listagem de usuários. Localize
o usuário IUSR_SERVIDOR e dê um clique sobre o mesmo para marcá-lo, conforme
8. Dê um clique no botão OK. Surge uma janela pedindo para que você defina as
permissões NTFS para o usuário IUSR_SERVIDOR.
9. Defina as permissões conforme indicado na Figura 9.24 e dê um clique no botão OK.
10. Você estará de volta à janela de opções avançadas. Certifique-se de que a opção –
Redefinir permissões em todos os objetos filho e permitir a propagação das permissões
herdadas – esteja marcada.
11. Dê um clique no botão OK para voltar à janela de propriedades da pasta.
535
Figura 9.23: Adicionando novamente o usuário IUSR_SERVIDOR.
Figura 9.24: Restaurando as permissões para o usuário IUSR_SERVIDOR.
12. Surge uma janela pedindo confirmação, conforme indicado na Figura 9.25. Dê um
clique em Sim para continuar.
536
Figura 9.25: Confirmando as alterações.
13. Você estará de volta a guia Segurança da janela de propriedades da pasta.

14. Vamos adicionar o usuário IUSR_SERVIDOR para que ele tenha permissões de acesso
à pasta.
15. Dê um clique no botão Adicionar. Surge a janela Selecione Usuários, Computadores
ou Grupos. Localize o usuário IUSR_SERVIDOR e dê um clique sobre o mesmo para
marcá-lo. Depois dê um clique no botão Adicionar para incluir o usuário na parte
inferior da janela, conforme indicado na Figura 9.26.
Figura 9.26: Adicionando o usuário IUSR_SERVIDOR na lista de usuários

que tem permissão de acesso à pasta selecionada.
537
16. Dê um clique no botão OK. Observe que o usuário IUSR_SERVIDOR já consta na

listagem de usuários.
17. Defina as permissões conforme indicado na Figura 9.27 e dê um clique no botão OK.
Figura 9.27: Redefinindo as permissões de acesso à pasta selecionada.
Feito isso foram reatribuídas as permissões NTFS originais e qualquer usuário volta a ter
acesso à pasta (no nosso exemplo era a pasta Capitulo6) e a todo o seu conteúdo, porém com
permissão somente para leitura.
Agora, o usuário já poderá acessar a página que não será mais retornada a mensagem de
acesso negado.
Com este exemplo, podemos constatar que o servidor IIS trabalha em sintonia com o Windows
2000, de tal forma que os recursos de segurança do Sistema Operacional podem ser utilizados
pelo IIS.
Nós detalhamos um pouco mais o primeiro tipo de acesso – Acesso anônimo –, para explicar
alguns conceitos importantes em detalhes. Agora passaremos a estudar outros tipos de
538
autenticação possíveis com o IIS. Lembrando que a autenticação com o IIS é apenas um dos
tantos níveis de segurança que podemos configurar.
Autenticação Básica
A autenticação básica é uma das mais antigas que existem, desenvolvidas desde a época dos
primeiros servidores Web como o NCSA e o Cern HTTP. Neste tipo de autenticação, o usuário
precisa fornecer um username e uma senha. O método de autenticação básica é um padrão
de mercado amplamente usado para coletar informações de nome de usuário e senha. A
autenticação básica funciona da seguinte forma:
1. O navegador exibe uma caixa de diálogo na qual o usuário pode digitar seu username
e senha de conta do Windows 2000 atribuídos anteriormente. Por isso, é um pré-
requisito da autenticação básica que o usuário já possua uma conta cadastrada no
Windows 2000.
2. O navegador tenta estabelecer uma conexão usando essas informações (a senha é
codificada com Base64 antes de ser enviada pela rede).
3. Se o servidor rejeita as informações, o navegador da Web exibe repetidamente a caixa
de diálogo até que o usuário digite um nome de usuário e uma senha válidos ou feche
a caixa de diálogo.
4. Quando o servidor Web verifica que o nome de usuário e a senha correspondem a uma
conta de usuário do Windows 2000 válida, a conexão é estabelecida e o acesso à página
solicitada é liberado.
A autenticação básica apresenta como principal requisito o fato de que o usuário deve ter
uma conta no Windows 2000. Para sites que são acessados por um grande número de usuários
pode não ser uma boa opção. Além disso, o fato do usuário ter que digitar um username e
senha não é muito “simpático”.
Uma das grandes desvantagens deste método de autenticação é o fato de que a senha não é
criptografada ao ser transmitida pela rede. A codificação que é feita é extremamente simples
de ser quebrada, por isso este método de autenticação não é dos mais seguros.
A vantagem da autenticação básica é que ela faz parte da especificação do HTTP e tem suporte
da maioria dos navegadores. A desvantagem é que, pelo fato dos navegadores que usam a
autenticação básica transmitirem senhas de forma descriptografada, ao monitorar as
comunicações na sua rede, alguém pode interceptar e decifrar facilmente essas senhas usando
ferramentas disponíveis publicamente na própria Internet. Portanto, a autenticação básica
não é recomendada, a menos que você tenha certeza que a conexão entre o usuário e seu
servidor Web é segura, como uma conexão direta via cabo ou uma linha dedicada.
539
IMPORTANTE
A autenticação integrada do Windows (que veremos logo em seguida) tem prioridade sobre a
autenticação básica. O navegador escolherá a autenticação integrada do Windows e tentará
usar as informações de logon atuais do Windows antes de solicitar ao usuário um nome e
senha. Atualmente, somente o Internet Explorer, versão 2.0 e posterior, oferece suporte à
autenticação integrada do Windows.
Autenticação Integrada do Windows

A autenticação integrada do Windows (chamada anteriormente NTLM ou autenticação de
desafio/resposta do Windows NT) é uma forma segura de autenticação pois o nome de usuário
e a senha são enviados pela rede criptografados. Quando você ativa a autenticação integrada
do Windows, o navegador do usuário verifica a validade da senha através de uma troca
criptográfica com o servidor Web.
A autenticação integrada do Windows pode usar o protocolo de autenticação Kerberos versão

5 e o seu próprio protocolo de autenticação desafio/resposta. Se os Serviços de diretório
estiverem instalados no servidor e o navegador for compatível com o protocolo de autenticação
Kerberos versão 5, os protocolos Kerberos versão 5 e desafio/resposta serão usados; caso
contrário, somente o protocolo desafio/resposta será usado.
O protocolo de autenticação Kerberos versão 5 é um recurso da arquitetura do Windows 2000

Distributed Services. Para que a autenticação deste protocolo seja bem-sucedida, o cliente e o
servidor devem ter uma conexão confiável com um Key Distribution Center (KDC) e devem
ser compatíveis com os Serviços de diretório. A situação ideal é onde o cliente utiliza o
Windows 2000 Professional.
A autenticação integrada do Windows funciona da seguinte forma:

1. Diferentemente da autenticação básica, ela não solicita inicialmente um nome de
usuário e uma senha. As informações atuais de usuário do Windows sobre o computador
cliente são usadas para a autenticação integrada do Windows.
NOTA
O Internet Explorer, versão 4.0 e posterior, pode ser configurado para solicitar inicialmente
informações do usuário, se necessário. Para obter mais informações, consulte a documentação
do Internet Explorer.
540
2. No entanto, se a troca da autenticação não consegue identificar o usuário, o navegador

solicita ao usuário um nome e uma senha de conta de usuário do Windows, que ele
processa usando a autenticação integrada do Windows.
3. O Internet Explorer continuará a solicitar ao usuário até que ele digite um nome de
usuário e uma senha válidos ou feche a caixa de diálogo de solicitação.
Embora a autenticação integrada do Windows seja segura, ela tem duas limitações:
➥ Somente o Microsoft Internet Explorer, versão 2.0 ou posterior, oferece suporte a esse
método de autenticação.
➥ A autenticação integrada do Windows não funciona em conexões feitas através de um
servidor Proxy.
Portanto, a autenticação integrada do Windows é mais adequada para um ambiente de Intranet,

no qual o usuário e o servidor Web estão no mesmo domínio e os administradores podem
garantir que todos os usuários tenham o Microsoft Internet Explorer, versão 2.0 ou posterior.
Autenticação Utilizando Certificados

Este é um dos métodos de autenticação que mais vem crescendo. Inicialmente os Certificados
Digitais foram projetados como um instrumento de autenticação segura para a Internet, porém
o seu uso apresentou tantas vantagens que hoje é bastante comum sua utilização em Intranets
e Extranets.
A tecnologia de certificados usa os recursos de segurança de Secure Sockets Layer (SSL,

camada de soquetes de segurança) do servidor Web para dois tipos de autenticação.
É possível usar um certificado de servidor para permitir que os usuários façam a autenticação do
seu site da Web antes de transmitir informações pessoais, como um número de cartão de crédito.
Além disso, você pode usar certificados de cliente para autenticar os usuários que solicitam
informações no seu site da Web. O SSL faz a autenticação, verificando o conteúdo de uma
identificação digital (Certificado Digital) criptografada, submetida pelo navegador do usuário
durante o processo de logon. (Os usuários obtêm certificados de cliente de uma organização
independente mutuamente confiável.) Os certificados de servidor contêm geralmente informações
sobre sua empresa e a organização que emitiu o certificado. Os certificados de cliente contêm
normalmente informações de identificação sobre o usuário e a organização que emitiu o certificado.
Mapeamento do Certificado Cliente

Você pode associar, ou mapear, certificados de cliente a contas de usuário do Windows no
IIS. Depois que você cria e ativa um mapa de certificado, sempre que um usuário faz logon
541
com um certificado de cliente, seu servidor Web associa automaticamente esse usuário à
conta de usuário do Windows apropriada. Dessa forma, você pode autenticar automaticamente
os usuários que fazem logon com certificados de cliente, sem exigir o uso da autenticação
básica ou integrada do Windows. É possível mapear um certificado de cliente para uma conta
de usuário do Windows ou muitos certificados de cliente para uma conta. Por exemplo, se
você tivesse vários departamentos ou empresas diferentes no seu servidor, cada uma com seu
próprio site da Web, seria possível usar o mapeamento vários-para-um para mapear todos os
certificados de cliente de cada departamento ou empresa para o próprio site da Web. Dessa
forma, cada site forneceria acesso somente aos próprios clientes.
No próximo capítulo veremos um pouco mais sobre Certificados Digitais.
O tipo de autenticação é apenas um dos aspectos que precisam ser definidos; devem ser
consideradas diversas outras questões. A seguir, algumas questões que devem ser levadas em
considerações na hora de decidir sobre o tipo de autenticação que iremos configurar no IIS,
ou se devemos configurar mais do que um tipo de autenticação.
➥ Para um site público, ou áreas de acesso público, a autenticação utilizando acesso anônimo
é a mais indicada, pois evita que o usuário tenha que fornecer um username e senha.
➥ Para acesso ao conteúdo de uma Intranet, uma das primeiras opções a serem pensadas
é a utilização da autenticação integrada do Windows. Pois sendo uma Intranet um
ambiente controlado, é possível garantir que todos os clientes satisfaçam as condições
exigidas pela autenticação integrada.
➥ Para sites que trabalham com dados sensíveis como serviços bancários pela Internet e
Comercio Eletrônico, sem dúvida que a utilização de Certificados Digitais é o mais
indicado. Em Intranets os certificados também têm sido utilizados, pois conforme
descrevemos no início do capítulo, a maioria dos ataques parte de usuários da Intranet
da empresa. Muitas vezes nos preocupamos muito com os ataques externos e
esquecemos as ameaças que vem de dentro da própria empresa.
Configurando o Tipo de Autenticação no IIS

Neste item veremos como configurar uma ou mais opções de autenticação no IIS. Lembrando
que podemos ter diferentes tipos de autenticação em diferentes partes de um site armazenado
em um servidor IIS. Por exemplo, para uma área de acesso público podemos utilizar
autenticação anônima, para uma área mais restrita podemos utilizar somente autenticação
integrada do Windows. Podemos inclusive configurar o nível de autenticação para uma página
HTML ou ASP, individualmente.
Para configurar o tipo de autenticação faça o seguinte:
542

3. É aberto o console de gerenciamento do IIS.
6. Neste momento podemos configurar o tipo de autenticação para todos os aplicativos

Web contidos no servidor ou para cada aplicativo individualmente.
7. A título de exemplo, vamos configurar o tipo de autenticação para o site Web padrão.
8. Clique com o botão direito do mouse sobre a opção Site da Web padrão (ou na opção
correspondente, caso você tenha alterado este nome). No menu de opções que surge,
dê um clique em Propriedades.
9. Será exibida a janela Propriedades de Site Web padrão.
10. Dê um clique na guia Segurança de pasta. Serão exibidas as opções indicadas na Figura 9.29.
11. A primeira opção desta guia é Controle de acesso anônimo e autenticação. Dê um
clique no botão Editar, ao lado desta opção. Surge a janela Métodos de autenticação,
indicada na Figura 9.30.
12. Observe que, por padrão, estão definidas as opções Acesso anônimo e Autenticação
integrada do Windows.
13. Nesta janela você pode definir qual ou quais tipos de autenticação que o servidor IIS
deverá suportar para o Site Web padrão. Além disso, você pode configurar qual a conta
que será utilizada para o acesso anônimo, conforme descrito anterioremente.
543
Figura 9.29: As opções da guia Segurança de pasta.
Figura 9.30: As opções para métodos de autenticação.
544
14. Selecione as opções desejadas. Se você clicar na opção Autenticação básica, o IIS emite
um aviso de que para esta opção as senhas serão transmitidas sem criptografia, conforme
Figura 9.31: Avisa de que na autenticação básica a senha é transmitida sem criptografia.
15. Dê um clique em Sim e a autenticação básica será habilitada.

16. Dê um clique no botão OK para fechar a janela de configuração dos tipos de autenticação.
17. Você estará de volta à janela de Propriedades de Site da Web padrão. Dê um clique no
botão OK para fechá-la.
18. Caso alguma aplicação Web ou pasta virtual do servidor possua uma configuração
diferente da definida para o Site da Web padrão, o IIS abre uma janela informando
qual site possui uma configuração diferente e perguntando se você deseja estender as
configurações do site Web padrão para as pastas virtuais e aplicativos Web internos,
Figura 9.32: Estendendo as configurações para as aplicações e pastas virtuais.
545
19. Para estender as configurações basta selecionar uma ou mais das opções mostradas e clicar
no botão OK. Você também pode utilizar o botão Selecionar tudo e depois clicar em OK.
Para configurar as opções para uma pasta virtual em particular, basta localizá-la abaixo da
opção Site da Web padrão, clicar com o botão direito sobre a mesma e clicar na opção
Propriedades. Depois é só seguir os passos indicados anteriormente.
Mais Configurações de Segurança do IIS

Podemos efetuar outras configurações relacionadas com segurança, no servidor IIS. Existem
algumas opções que limitam o tipo de ação que o usuário pode tomar em uma determinada
pasta virtual ou em uma página especificamente. Neste item iremos estudar diversas destas
opções. Dividiremos as mesmas em dois grupos:
➥ Opções gerais de segurança.
➥ Opções relacionadas com uma aplicação Web.
Configurando Opções Gerais de Segurança

Estas configurações são definidas, normalmente, a nível de pasta virtual. Para configurar
estas opções faça o seguinte:
5. Dê um clique no sinal de + ao lado de Site da Web padrão. Serão exibidas as diversas
pastas virtuais disponíveis no servidor.
6. A título de exemplo, vamos configurar as opções gerais de segurança para a pasta
Capitulo6, conforme indicado na Figura 9.33.
NOTA
Caso você não tenha criado uma pasta virtual Capítulo6, utilize qualquer pasta virtual
disponível no seu servidor IIS.
7. Clique com o botão direito do mouse sobre a opção Capitulo6. No menu de opções que
surge, dê um clique em Propriedades.
546
Figura 9.33: Configurando opções gerais de segurança para a pasta Capitulo6.
8. Será exibida a janela Propriedades de Capitulo6.

9. Na guia Pasta (que já deve estar sendo exibida), existem diversas opções de configuração.
Abaixo descrevemos cada uma destas opções.
➥ Acesso ao código fonte do Script: Selecione esta opção para permitir que os usuários
acessem o código fonte se a permissão de leitura ou gravação estiver definida. O
código fonte inclui Scripts nos aplicativos ASP.
➥ Leitura: Selecione esta opção para permitir que os usuários leiam ou façam o down-
load dos arquivos ou diretórios e de suas propriedades associadas.
➥ Gravação: Selecione esta opção para permitir que os usuários carreguem os arquivos
e suas propriedades associadas no diretório ativado no servidor ou alterem o
conteúdo de um arquivo ativado para gravação. A gravação só poderá ser feita com
um navegador que dê suporte ao recurso PUT do protocolo padrão HTTP 1.1.
Cuidado com esta permissão. Dificilmente você precisará habilitar permissão de
Gravação para áreas em que é permitida a autenticação com usuário anônimo.
➥ Pesquisa em Pasta: Selecione esta opção para permitir que o usuário veja uma
listagem em hipertexto dos arquivos e subdiretórios deste diretório virtual. Os
diretórios virtuais não aparecerão nas listagens de diretórios; os usuários devem
saber o alias do diretório virtual. Caso o usuário digite o endereço para o caminho
da pasta e não especifique um documento a ser carregado, será exibida uma listagem
semelhante a indicada na Figura 9.34.
547
Figura 9.34: Listagem exibida quando a opção Pesquisa em Pasta está habilitada.
Caso esta opção não esteja marcada e o usuário digite o endereço para a pasta, sem especificar
um arquivo a ser carregado, será retornada a mensagem de erro indicada na Figura 9.35.
Figura 9.35: Mensagem de erro quando a opção Pesquisa em Pasta estiver desabilitada.
548
➥ Criar log de visitantes: Selecione esta opção para registrar as visitas feitas a este
diretório em um arquivo de Log. As visitas serão registradas somente se o log estiver
ativado para este site da Web.
➥ Indexar este recurso: Para permitir que o Serviço de indexação da Microsoft (Index
Services) inclua este diretório em um índice de texto completo do site da Web,
selecione esta opção.
De uma maneira geral, recomendo que as opções Gravação e Pesquisa em pasta sejam marcadas
somente em situações especiais e para áreas que não contenham dados confidenciais.
Uma questão importante é a combinação entre as permissões definidas no IIS e as permissões

NTFS. Por exemplo, vamos supor que o usuário tenha sido autenticado como usuário anônimo
e está tentando gravar conteúdo em uma pasta virtual na qual o IIS possui permissão de
gravação, porém as permissões NTFS não permitem que o usuário anônimo faça gravações.
Como fica esta combinação?
Quando uma página é solicitada, o IIS segue a seqüência indicada na Figura 9.36.
Servidor Web
recebe requisição.
Endereço IP
permitido?
Usuário permitido?
Permissões do
servidor Web concedem
acesso?
Permissões do
NTFS concedem
acesso?
Acesso concedido. Acesso negado.
Figura 9.36: Seqüência de verificação do IIS.
549
Observe que primeiro o IIS verifica se o usuário tem permissões da Web para o recurso
solicitado. Se o usuário não tiver, a solicitação falha e o usuário recebe uma mensagem “403
Acesso proibido”. Depois, o IIS verifica as permissões do NTFS para o recurso. Se o usuário
não tiver permissões do NTFS para o recurso, a solicitação falha e o usuário recebe uma
mensagem “401 Acesso negado”.
Então a resposta para o nosso exemplo é que o usuário não conseguiria gravar o conteúdo,
pois o mesmo não teria as permissões NTFS necessárias e receberia a mensagem de erro “401
Acesso negado”.
Configuração de Segurança Para Aplicativos Web no IIS

Estas configurações são definidas, também utilizando a guia Pasta da janela de Propriedades
para a pasta virtual que representa a aplicação Web. Para configurar estas opções faça o seguinte:
5. Dê um clique no sinal de + ao lado de Site da Web padrão. Serão exibidas as diversas
pastas virtuais disponíveis no servidor.
6. A título de exemplo, vamos configurar as opções de aplicação para a pasta Capitulo6.
NOTA
Caso você não tenha criado uma pasta virtual Capítulo6, utilize qualquer pasta virtual
disponível no seu servidor IIS.
7. Clique com o botão direito do mouse sobre a pasta Capitulo6. No menu de opções que
surge dê um clique em Propriedades.
8. Será exibida a janela Propriedades de Capitulo6.
9. Certifique-se de que estão sendo exibidas as opções da guia Pasta.
10. Na parte de baixo da guia Pasta, temos um grupo de opções chamado Configurações do
aplicativo. A seguir temos uma descrição de cada uma destas opções.
Conforme descrito anteriormente, um aplicativo da Web do IIS é definido pela estrutura de
diretórios em que está localizado. Para obter mais informações, consulte o Capítulo 8 deste livro.
550
➥ Nome do aplicativo: Normalmente utilizamos o mesmo nome da pasta virtual.

➥ Botão Remover: Se clicarmos neste botão removemos todas as opções de aplicativo, e
transformamos o aplicativo Web em uma simples pasta virtual, para a qual não se
aplicam os conceitos dos objetos Application, Session e do arquivo global.asa. Para
maiores informações sobre os objetos Application, Session e o arquivo global.asa,
consulte o Capítulo 8 deste livro, bem como para informações sobre as opções do
botão Configuração.
➥ Permissões de execução: Esta opção determina o nível de execução de programa
permitido para recursos de diretórios virtuais ou deste site. Temos três opções:
◆ Nenhum: Somente arquivos estáticos, como os arquivos HTML (Hypertext Markup
Language, linguagem de marcação de hipertexto) ou os arquivos de imagem, podem
ser acessados. Não permite que scripts ASP sejam executados.
◆ Somente scripts: Somente scripts, como os scripts ASP, podem ser executados.
Este é o padrão normalmente definido.
◆ Scripts e executáveis: Todos os tipos de arquivos podem ser acessados ou executados.
Cuidado com esta configuração. Muitos dos ataques conhecidos consistem em enviar
e executar arquivos executáveis no servidor a ser atacado. Os executáveis enviados,
normalmente, abrem portas de segurança que estavam fechadas pelo administrador.
➥ Proteção do aplicativo: Temos três opções:
◆ Baixa: Selecione esta opção para que os aplicativos sejam executados no mesmo
processo que os serviços da Web (opção baixo). Neste caso se um dos aplicativos
apresentar problema e desativar o processo do servidor Web, todos os aplicativos
ficarão indisponíveis até que o servidor Web tenha sido normalizado.
◆ Média (em pool): Selecione esta opção para que a aplicação Web seja executada em
um processo em pool isolado em que outros aplicativos também são executados.
◆ Alta (isolada): Neste caso a aplicação Web será executada em seu próprio espaço de
endereçamento e se a mesma apresentar problemas, as outras aplicações Web, bem
como o servidor IIS continuam funcionando normalmente. A execução isolada
aumenta a disponibilidade do servidor Web, pois problemas em uma aplicação não
irão afetar todo o servidor, porém consome mais recursos, como memória, pois
cada aplicação é executada em seu próprio espaço de memória.
NOTA
Para determinar qual opção representa uma aplicação Web e qual é simplesmente uma pasta
virtual é só observar o ícone ao lado do nome, no Gerenciador do Internet Services. Opções que
são simplesmente uma pasta virtual são representadas por um envelope amarelo, já aplicações
Web possuem um ícone que parece uma caixa aberta, conforme indicado na Figura 9.37.
551
Figura 9.37: Ícones para uma aplicação Web e para uma pasta virtual.
Definindo Restrições de Acesso a Nível de Endereço IP

Podemos definir restrições de acesso a nível de endereço IP.
Por exemplo, vamos supor que existe uma área do site que é para desenvolvimento, e que a
mesma não deva ser acessada nem por usuários da Intranet da empresa, muito menos por
usuários da Internet. Somente os participantes do grupo de desenvolvimento é que devem ter
acesso a esta parte do site. Podemos, sem maiores problemas, limitar o acesso, de tal maneira
que somente as estações de trabalho dos desenvolvedores tenham acesso a área de
desenvolvimento do site.
Neste item aprenderemos a configurar uma aplicação Web ou uma pasta virtual do IIS, para
limitar o acesso com base no endereço IP do usuário.
Para definir restrições de acesso a nível de endereço IP faça o seguinte:

5. Nas opções que surgem, dê um clique com o botão direito do mouse sobre a opção Site
da Web padrão (ou na opção correspondente, caso você tenha alterado este nome). No
menu de opções que surge dê um clique em Propriedades.
552
6. Será exibida a janela Propriedades de Site Web padrão.

7. Dê um clique na guia Segurança de pasta.
8. O segundo grupo de opções desta guia é Restrições de nome de domínio e endereço IP. Dê
um clique no botão Editar, ao lado desta opção. Surge a janela, indicada na Figura 9.38.
Figura 9.38: Janela para configuração das restrições de nome de domínio e endereço IP.
Observe que temos duas opções para configuração, conforme descrito a seguir:
➥ Acesso permitido: Se esta opção estiver marcada, todos terão acesso ao site, com exceção
dos endereços IP que estiverem indicados na listagem Exceto os listados abaixo. Este
mecanismo é chamado de “Lista Negra”, ou seja, todo mundo tem acesso, com exceção
de quem está na lista.
➥ Acesso negado: Se esta opção estiver marcada, ninguém terá acesso ao site, com exceção
dos endereços IP que estiverem indicados na listagem Exceto os listados abaixo. Este
mecanismo é chamado de “Lista Branca”, ou seja, ninguém tem acesso, com exceção
de quem está na lista.
9. A título de exemplo, deixe marcada a opção Acesso permitido. Agora vamos negar
acesso para um computador específico.
NOTA
No exemplo do livro estarei negando acesso para o IP: 10.204.123.1, que é o endereço IP do
meu computador. Utilize o endereço IP do equipamento para o qual você quer negar acesso, a
nível de teste.
10. Dê um clique no botão Adicionar. Surge a janela indicada na Figura 9.39.
553
Figura 9.39: Definindo o alcance das restrições impostas.
Nesta janela temos três opções a serem escolhidas, conforme explicado a seguir:
➥ Um computador: Neste caso estamos negando acesso para um computador específico.
Basta digitar o endereço IP do mesmo. No nosso exemplo, utilizaremos esta opção e
iremos digitar o IP 10.204.123.1.
➥ Grupo de computadores: Se você marcar esta opção, surge, na parte de baixo da janela,
mais um campo, Máscara de sub-rede, conforme indicado na Figura 9.40. Podemos
utilizar esta opção para negar acesso a uma rede ou segmento de rede inteiro.
Figura 9.40: Negando acesso para um grupo de computadores.
Por exemplo, podemos negar acesso a qualquer computador da rede 10.204.123, para isso
preencheríamos os campos da seguinte maneira:
554
➥ Identificação da rede: 10.204.123.0

➥ Máscara de sub-rede: 255.255.255.0
Para negar acesso a todas as máquinas da rede 161.147, utilizaríamos a seguinte configuração:
➥ Identificação da rede: 161.147.0.0
➥ Máscara de sub-rede: 255.255.0.0
➥ Nome de domínio: Esta opção permite que neguemos acesso com base no nome DNS
de um grupo de computadores. Por exemplo, podemos negar acesso para setor de
contabilidade empresa, negando acesso para o domínio: contabilidade.abc.com.br. Ao
tentar utilizar esta opção, o IIS emite uma mensagem avisando que o desempenho do
servidor pode ser prejudicado pela ativação desta opção, e perguntando se você
realmente deseja ativá-la.
11. Vamos negar o acesso apenas para um computador – 10.204.123.1. Certifique-se de
que a opção Um computador esteja marcada e no campo Endereço IP, digite
10.204.123.1, conforme indicado na Figura 9.41.
Figura 9.41: Negando acesso para o computador 10.204.123.1.
12. Dê um clique no botão OK para incluir o computador com endereço IP 10.204.123.1,

na lista dos computadores com acesso negado, conforme indicado na Figura 9.42.
13. Dê um clique no botão OK e você estará de volta à janela Propriedades do Site da
Web padrão.
14. Dê um clique no botão OK para fechar a janela de propriedades.
15. Caso alguma aplicação Web ou pasta virtual do servidor possua uma configuração
diferente da definida para o site Web padrão, o IIS abre uma janela informando qual
site possui uma configuração diferente e perguntando se você deseja estender as
configurações do site Web padrão para as pastas virtuais e aplicativos Web internos.
555
Figura 9.42: O computador com endereço IP 10.204.123.1 já aparece na lista.
16. Para estender as configurações basta selecionar uma ou mais das opções mostradas e clicar
no botão OK. Você também pode utilizar o botão Selecionar tudo e depois clicar em OK.
Agora vou tentar acessar uma página do servidor IIS para qual o acesso foi negado para o IP
do meu computador – 10.204.123.1. Ao tentar fazer o acesso, recebo a mensagem indicada na
Figura 9.43.
Figura 9.43: Mensagem de que o acesso foi negado.
556
Observe que a mensagem informa que o endereço IP foi rejeitado. Para que o endereço IP
10.204.123.1 volte a ter acesso ao site, é so seguir os passos indicados anteriormente e removê-
lo da lista de endereços IP com acesso negado.
Mecanismos de Segurança do Banco de Dados

Um outro nível de segurança que pode ser configurado é no nível de banco de dados. Os
programas gerenciadores de banco de dados, como o Microsoft SQL Server, Oracle, Microsoft
Access, Sybase, etc., fornecem diversos mecanismos de segurança que, se adequadamente
configurados, aumentam bastante o nível de segurança das informações.
No Microsoft SQL Server podemos atribuir níveis de permissão para os usuários do Windows
2000, e até mesmo para o usuário utilizado para acesso anônimo.
Na Figura 9.44, temos um exemplo onde o usuário IUSR_SERVIDOR está recebendo permissão
somente para leitura na tabela Orders do banco de dados Northwind em um servidor com o
Microsoft SQL Server 2000 – Beta 2.
Figura 9.44: Definindo permissões de banco de dados no Microsoft SQL Server 2000.
557
NOTA
Para maiores informações sobre configurações de segurança no Microsoft SQL Server 2000,
consulte a documentação do produto.
Na maioria dos bancos de dados pode ser necessário o fornecimento de um username e senha
para que o acesso seja liberado. Podemos construir um formulário HTML com dois campos,
onde o usuário digita o username e a senha. Ao clicar em um botão Logon, os valores digitados
são enviados para uma página ASP que monta a String de conexão de acordo com os dados
fornecidos pelo usuário, incluindo o username e senha.
Na Listagem 9.1, temos um exemplo de formulário, onde temos dois campos: username e
senha, nos quais o usuário irá digitar as informações de logon.
Listagem 9.1 – Formulário para digitação do username e da senha – logon.htm.

1 <HTML>
2 <HEAD>
3 <TITLE>Informações de Logon!!</TITLE>
4 </HEAD>
5 <BODY>
6 <P><FONT color=navy><B>
7 Digite os dados para efetuar o logon no servidor SQL:
8 </B></FONT></P>
9 <P>
10 <FORM action=logon.asp method=post>
11 <TABLE bgColor=#fafad2 border=1 cellPadding=1 cellSpacing=1 width=“50%”>
12 <TR>
13 <TD>Username:</TD>
14 <TD><INPUT id=username maxLength=15 name=username></TD>
15 </TR>
16 <TR>
17 <TD>Senha:</TD>
18 <TD><INPUT id=senha maxLength=15 name=senha type=password></TD>
19 </TR>
558
20 <TR>
21 <TD></TD>
22 <TD><INPUT id=logon name=logon type=submit value=Logon></TD>
23 </TR>
24 </TABLE>
25 </P>
26 </FORM>
27 </BODY>
28 </HTML>
Na Figura 9.45, temos o formulário logon.htm carregado, onde o usuário digita as informações
para o logon.
Figura 9.45: Username e senha para logon no servidor SQL..
Ao clicar no botão Logon, os dados digitados pelo usuário são enviados para a página logon.asp,
a qual monta uma String de conexão, com base nos dados informados pelo usuário. Na Listagem
9.2, temos um exemplo da página logon.asp.
Listagem 9.2 – Página ASP que monta a String de conexão para o servidor SQL – logon.asp.
2 <HTML>
559
3 <HEAD>
4 </HEAD>
5 <BODY>
6 <%
11 ‘Agora defino a propriedade ConnectionString do objeto Connection
12 ‘criado anteriormente.
Data Source=SERVIDOR\SERVIDOR;Initial Catalog=Northwind;User ID=” &
Request.Form(“username”)& “;Password=” & Request.Form(“senha”)
14 conn.Open
15 %>
16 <HR>
17 <%
18 Response.Write “Conexão estabelecida com sucesso !!”
19 %>
20 <HR>
21 </BODY>
22 </HTML>
Se o usuário digitou as informações de logon corretamente, ao acessar a página logon.asp, ele

obterá o resultado indicado na Figura 9.46.
Figura 9.46: Conexão efetuada com sucesso.
560
Se o usuário cometer um erro na digitação do nome de usuário ou da senha, obteremos uma

mensagem de erro conforme indicado na Figura 9.47.
Figura 9.47: Erro no logon com o banco de dados.
Observe que a mensagem informa que houve um erro no logon do usuário sa. O ideal é que
estas situações de erro sejam tratadas e ao invés do IIS simplesmente enviar uma página com
uma mensagem de erro padrão, podemos interceptar a ocorrência do erro e enviar para o
usuário uma página mais trabalhada, onde o mesmo tenha a opção de entrar novamente com
as informações de logon. Aprenderemos a fazer o tratamento de erros no Capítulo 11.
Conclusão
Neste capítulo aprendemos sobre aspectos básicos de segurança, tais como:
➥ Tipos de autenticação.
➥ Permissões NTFS do Windows 2000.
➥ Opções de segurança do IIS.
➥ Permissões a nível de banco de dados.
Muito existe a ser tratado sobre segurança. Livros inteiros já foram escritos sobre o assunto.
Pela experiência de anos trabalhando com ambientes de Rede Locais e acesso a dados críticos
561
posso afirmar com convicção: “O primeiro passo para estabelecer um ambiente seguro é a
definição de um política de segurança e a ampla divulgação da mesma, para que todos estejam
conscientes de suas responsabilidades em relação à segurança.”
Muitas vezes cuida-se muito da segurança de acesso lógico aos dados, com a otimização das
configurações de segurança do Sistema Operacional, do servidor Web e do servidor de Banco
de dados. São gastos milhares de dólares em equipamentos e programas sofisticados para
atuarem como Firewall. Investe-se em roteadores modernos, com capacidades de filtragem
de pacotes, detecção de tentativas de invasão e assim por diante. E, muitas vezes, a segurança
física é esquecida. De que adianta toda esta segurança no acesso lógico, se um desconhecido
pode, facilmente, invadir a sala dos servidores e sair com uma meia dúzia de fitas de backup
em baixo do braço?
Obviamente que o investimento em segurança de acesso lógico aos dados é necessária, porém
o aspecto da segurança no acesso físico é igualmente importante. Pontos como estes devem
ser definidos na política de segurança da empresa, a qual deve ser continuamente revisada
para se adaptar às freqüentes mudanças no mundo da tecnologia.
No próximo capítulo veremos alguns conceitos avançados do ASP 3.0.
562
Capítulo 10 – Utilizando Componentes do IIS
Capítulo 10
Utilizando
Componentes do IIS
563
Introdução
Neste capítulo estaremos tratando de uma série de objetos do ASP e outros assuntos
importantes na construção de aplicativos Web com ASP 3.0.
Iniciaremos o capítulo por um estudo do objeto Server e dos seus diversos métodos e
propriedades. Veremos como solucionar problemas práticos, bastante comuns na construção
de aplicações Web.
Apresentaremos um exemplo prático que ilustra uma necessidade típica de aplicações Web.
No nosso exemplo, o usuário selecionará o nome de um país em uma lista de países. Ao clicar
em um botão Pesquisar, será retornada uma lista, em forma de tabela, com todos os Clientes
para o País selecionado. O nome do Cliente será um link, que ao ser clicado abrirá uma
página com as informações sobre o mesmo. Para construir esta página teremos que utilizar
alguns métodos do objeto Server.
Em seguida, passaremos ao estudo de alguns componentes ASP. Veremos com mais detalhes
o conceito de componentes. Também aprenderemos a utilizar diversos componentes que são
fornecidos juntamente com o IIS. Estudaremos os seguintes componentes:
➥ Content Link.
➥ Ad Rotator.
➥ Browser Capabilities.
➥ Page Counter.
Estes componentes são fornecidos juntamente com o IIS e oferecem uma série de
funcionalidades bastante interessantes, conforme veremos mais adiante.
O Objeto Server
O objeto Server nos fornece a possibilidade de estender as capacidades de nossas páginas
ASP, através da utilização de objetos e componentes externos. Estes objetos e componentes
fornecem funcionalidades específicas as quais são necessárias à aplicação que está sendo
desenvolvida.
A utilização de componentes externos faz parte da filosofia de desenvolvimento de aplicações

baseadas em componentes. Para o mundo Windows, os componentes devem seguir o padrão
COM (Component Object Model), que no Windows 2000 recebe a denominação de COM+
(COM Plus).
564
Já utilizamos, em diversas oportunidades neste livro, o objeto Server e o seu método

CreateObject, para criar objetos como ADODB.Connection e ADODB.RecordSet. Na maioria
dos exemplos de acesso a Banco de dados, utilizamos o método CreateObject para criar
estes objetos.
Com o objeto Server, podemos ter acesso aos componentes que são fornecidos juntamente
com o IIS, bem como a qualquer componente que tenha sido desenvolvido por uma empresa
de desenvolvimento de software. O requisito para que o componente possa ser utilizado é
que o mesmo siga o padrão COM/COM+ e tenha sido registrado no servidor Web.
Existem diversas empresas que produzem componentes e objetos para serem utilizados em
páginas ASP. Existem componentes para as mais diversas funcionalidades, tais como:
➥ Envio de e-mail a partir de páginas ASP.
➥ Impressão de bloquetos de cobrança bancária.
➥ Verificação de número de CPF, CNPJ ou cartão de crédito.
➥ Cálculo de impostos e outros acréscimos legais.
➥ Cálculos específicos para setores, como por exemplo: Recursos Humanos, Contabilidade, etc.
➥ Componentes para criação de gráficos em páginas Web.
➥ Componentes que facilitam a pesquisa em bancos de dados.
Agora passaremos ao estudo do objeto Server. Analisaremos os seus métodos e sua propriedade
(isso mesmo, propriedade no singular, pois temos uma única propriedade).
Propriedade do Objeto Server

O objeto Server possui uma única propriedade: ScriptTimeout.
Esta propriedade pode ser utilizada para definir ou retornar o número de segundos que uma
página pode ficar em execução antes que a mesma seja interrompida pelo IIS e uma mensagem
de erro seja retornada. O valor padrão é 90 segundos. Esta propriedade é importante,
principalmente em páginas que apresentam um Loop infinito, devido a erros de programação.
Neste caso, após o período definido pela propriedade ScriptTimeout, a página terá sua execução
encerrada. Com isso evita-se que a página fique consumindo recursos no servidor até causar
uma parada do mesmo.
Uma prática comum é aumentar o valor desta propriedade para determinadas páginas, como,
por exemplo, para um formulário de compras. Se a página demorar para aparecer e retornar
um erro, o usuário poderá desconfiar de que a compra foi efetivada e não irá recarregar a
página com medo de duplicar o seu pedido.
565
A sintaxe para esta propriedade é bastante simples:

<%
Server.ScriptTimeout = segundos
%>
Por exemplo:
<%
Server.ScriptTimeout = 300
%>
Este exemplo define o TimeOut da página para 5 minutos (300 segundos).
IMPORTANTE
O tempo limite definido pela propriedade ScriptTimeout não terá efeito enquanto um
componente do servidor estiver processando. Por isso, caso você esteja utilizando um
componente com defeitos, o mesmo continuará em execução independente do valor definido
por esta propriedade.
Também podemos atribuir o valor armazenado nesta propriedade a uma variável, como no
exemplo a seguir:
<%
tempo_limite = Server.ScriptTimeout
Response.Write tempo_limite
%>
Métodos do Objeto Server

Conforme descrito anteriormente, já utilizamos diversas vezes, neste livro, o método
CreateObject do objeto Server. Agora estudaremos este e os demais métodos do objeto Server.
Coincidentemente, vamos começar justamente com o método CreateObject.
O Método CreateObject
O método CreateObject é utilizado para criar uma instância de um componente ou objeto
existente no servidor. O termo “existente no servidor” significa que o objeto deve ter sido
previamente instalado e registrado no IIS. Diversos objetos e componentes fazem parte da
instalação padrão do IIS e iremos estudá-los ainda neste capítulo.
A sintaxe para o método CreateObject é a seguinte:

Set nome_objeto = Server.CreateObject(“Identificador_do_objeto”)
566
Onde temos:
➥ nome_objeto: É o nome da variável que será utilizada para fazer referência ao objeto
na página ASP onde o objeto é criado. Em diversos exemplos deste livro criamos um
objeto para conexão com banco de dados e atribuímos o mesmo a uma variável chamada
conn. O nome da variável é determinado pelo desenvolvedor; poderíamos ter utilizado
qualquer nome de variável válido.
➥ Identificador_do_objeto: Especifica o tipo de objeto a ser criado. O formato é
[Fornecedor.]Componente[.Versão]. Em diversos exemplos do livro utilizamos os
seguintes identificadores:
ADODB.Connection
ADODB.RecordSet
Este é o nome com que o componente está registrado no servidor Windows 2000. As
informações, sobre o registro do componente, ficam armazenadas na Registry do Windows
2000, conforme indicado na Figura 10.1.
Figura 10.1: Informações na Registry sobre o componente ADODB.Connection.2.5.
Por padrão, os objetos criados pelo método Server.CreateObject têm escopo de página. Isso
significa que eles são automaticamente destruídos pelo servidor quando ele termina o
processamento da página ASP atual.
Para criar um objeto com escopo de sessão ou aplicativo, você poderá usar a marca <OBJECT>
no arquivo global.asa e definir o atributo SCOPE para SESSION ou APPLICATION, ou
armazenar o objeto em uma variável de sessão ou aplicativo. No Capítulo 8, criamos um
objeto do tipo ADODB.Connection e o armazenamos em uma variável de nível da aplicação,
utilizando o objeto Application.
567
Já um objeto criado em nível de Sessão, será destruído quando a sessão for encerrada. Isto
acontece quando a sessão atinge o tempo limite ou o método Abandon é chamado. No exemplo
abaixo criamos um objeto em nível de sessão chamado Rodar. Este componente é, na verdade,
uma instância do componente AdRotator. Estudaremos o mesmo mais adiante neste capítulo.
<%
Set Session(“rodar”) = Server.CreateObject(“MSWC.AdRotator”)
%>
Podemos destruir um objeto atribuindo a variável que representa o objeto, o valor Nothing.
<%
Session(“rodar”) = Nothing
%>
NOTA
Destruir o objeto significa retirá-lo da memória, de maneira que não possa mais ser utilizado
e os recursos que o mesmo utilizava são liberados.
IMPORTANTE
Não podemos criar uma instância de objeto com o mesmo nome de um objeto interno. O
exemplo a seguir retorna um erro:
<%
Set Response = Server.CreateObject(“Response”)

%>
Não podemos criar uma instância de objeto chamada Response, uma vez que no Modelo de
Objetos do ASP já existe um objeto chamado Response, conforme estudado em capítulos anteriores.
O Método Execute(“url”)
O método Execute chama um arquivo .asp e o processa como se ele fosse parte da chamada do
script ASP. A execução da página corrente é suspensa e o controle é transferido para a página
especificada no parâmetro URL. O método Execute é similar a uma chamada de procedimento
em muitas linguagens de programação. A página, chamada utilizando o método Execute, é
processada e, após o término da execução, o controle retorna para a página que fez a chamada.
O método Execute possui a seguinte sintaxe:

Server.Execute(“url”)
568
onde URL é uma seqüência de caracteres especificando o local do arquivo .asp a ser executado.
Se um caminho absoluto for especificado para esse parâmetro, então, ele deverá ser para um
arquivo .asp dentro do mesmo espaço do aplicativo, isto é, dentro da mesma pasta virtual que
representa o aplicativo.
O método Server.Execute fornece uma maneira de dividir um aplicativo complexo em módulos

individuais. Empregando este método, você pode desenvolver uma biblioteca de arquivos
.asp que pode ser chamada quando necessário. Esse enfoque é uma alternativa para inclusões
do lado do servidor, utilizando a diretiva #include.
Depois que o IIS processa o arquivo .asp especificado no parâmetro url de Server.Execute, a
resposta é retornada ao script ASP que fez a chamada. O arquivo .asp executado pode modificar
cabeçalhos HTTP. No entanto, como em qualquer arquivo .asp, se o mesmo tentar modificar
os cabeçalhos HTTP depois que enviar uma resposta para o cliente, gerará um erro.
O parâmetro url pode ser referente a um caminho absoluto ou relativo. Se o caminho for absoluto,
ele deverá mapear para um script ASP no mesmo aplicativo do arquivo ASP que fez a chamada.
O parâmetro caminho pode conter uma seqüência de caracteres de consulta.
Exemplo
O exemplo a seguir demonstra a execução de um arquivo .asp que retorna algum texto. No
arquivo chamador.asp temos uma chamada do método Execute para o arquivo chamado.asp.
Ao encontrar esta chamada, a execução desloca-se para o arquivo chamado.asp, o qual é
executado. Ao encerrar a execução do arquivo chamado.asp, a execução continua no arquivo
chamador.asp, com a linha seguinte a que utilizou o método Execute.
Listagem 10.1 – Arquivo que utiliza o método Execute – chamador.asp.

1 <HTML>
2 <BODY>
3 <%
4 Response.Write “A próxima linha utiliza o método Execute para chamar chamado.asp
<BR>”
5 Server.Execute(“chamado.asp”)
6 Response.Write “O arquivo chamado.asp já foi executado”
7 Response.Write “Estamos de volta ao arquivo chamador.asp”
8 %>
9 </BODY>
10 </HTML>
569
Listagem 10.2 – Arquivo chamado pelo método Execute – chamado.asp.

1 <HTML>
2 <BODY>
3 <%
5 Response.Write “Executando o arquivo chamado.asp........”
7 %>
8 </BODY>
9 </HTML>
Ao carregarmos o arquivo chamador.asp, obtemos o resultado indicado na Figura 10.2.
Figura 10.2: Resultado da utilização do método Execute.
O Método GetLastError( )
O método GetLastError retorna um objeto do tipo ASPError que descreve a condição de erro
que ocorreu. Esse método só está disponível antes do arquivo .asp ter enviado algum conteúdo
para o cliente.
Sintaxe
Server.GetLastError ()
570
NOTA
Votaremos a estudar este método, com maiores detalhes, no Capítulo 11, sobre tratamentos de
erro em páginas ASP.
O Método URLEncode(“texto”)
Passamos uma String como parâmetro para o método URLEncode. Por exemplo, posso passar
o meu nome como argumento:
Júlio Cesar Fabris Battisti
O método URLEncode converte os caracteres especiais, tais como letras acentuadas, espaços
em brancos e outros sinais que não são caracteres válidos para fazerem parte de uma URL,
nos equivalentes que são válidos. O meu nome seria convertido da seguinte maneira:
J%FAlio+Cesar+Fabris+Battisti
Observe que o ú (que não é um caractere válido para fazer parte de uma URL) foi substituído
por %FA (caractere válido para fazer parte de uma URL) e cada espaço em branco foi substituído
por um sinal de +. Podemos notar esta substituição, claramente, quando os dados que
preenchemos em um formulário são enviados através do método get. Conforme descrito
anteriormente neste livro, no método get as informações que foram digitadas em um formulário,
são enviadas junto com a URL da página que está sendo chamada. Para capturar estes dados,
precisamos utilizar o método QueryString do objeto Request – Request.QueryString
(“NomeDoCampo”).
Mais adiante estaremos apresentando um exemplo prático que fará uso do método URLEncode
e também do Método HTMLEncode, que veremos ainda neste item.
Outros exemplos de conversão feitas pelo método URLEncode:
Orlando Fração é convertido para Orlando+Fra%E7%E3o
Urlândia Alta é convertido para Url%E2ndia+Alta
Boqueirão do Leão é convertido para Boqueir%E3o+do+Le%E3o
José da Silva é convertido para Jos%E9+da+Silva
Normalmente utilizamos o método URLEncode para converter um valor de texto normal em

um valor codificado que deverá fazer parte de uma URL. Os dados enviados na URL podem
ser recuperados por uma página ASP através do método Request.QueryString e utilizados
para pesquisar um banco de dados e retornar um determinado resultado.
571
Considere o exemplo a seguir, onde temos uma URL bastante longa, a qual é resultado do
envio dos dados que foram preenchidos em um formulário, utilizando o método get ao invés
do método post:
http://servidor/capitulo10/cadastro.asp?nome=Jos%E9+da+Silva&
rua=Orlando+Fra%E7%E3o&bairro=Url%E2ndia+Alta&cidade=Boqueir%E3o+do+Le%E3o&
cep=97050-010&fone=2225211&fax=2226502&cartaotipo=Visa&enviar=Enviar+dados.
Observe que os dados preenchidos no formulário são enviados junto com a URL no formato
de pares e codificados de tal maneira que os caracteres especiais são convertidos em seus
equivalentes. Por exemplo, observe o seguinte trecho da URL:
nome=Jos%E9+da+Silva
Este trecho está indicando que o campo nome foi preenchido com o valor José da Silva.
Lembre que cada espaço é substituído por um sinal de + e o “é” foi substituído por seu
equivalente válido para fazer parte de uma URL – %E9.
No trecho de código a seguir, temos um exemplo dos resultados obtidos com a utilização de
Request.QueryString:
<%
Response.Write Request.QueryString(“nome”) & “<BR>”
Response.Write Request.QueryString(“rua”) & “<BR>”
Response.Write Request.QueryString(“bairro”) & “<BR>”
Response.Write Request.QueryString(“cidade”) & “<BR>”
Response.Write Request.QueryString(“cep”) & “<BR>”
Response.Write Request.QueryString(“fone”) & “<BR>”
Response.Write Request.QueryString(“fax”) & “<BR>”
Response.Write Request.QueryString(“cartao”) & “<BR>”
%>
Este trecho de código retornaria o seguinte resultado:

José da Silva
Orlando Fração
Urlândia Alta
Boqueirão do Leão
97050-010
2225211
2226502
Visa
Observe que o método QueryString decodifica os valores especiais de volta para os valores
originais. Por exemplo, o %E9 é substituído de volta para o original “é”.
572
O Método MapPath(“url”)
O método MapPath(“url”) retorna o caminho físico no servidor, correspondente a URL passada
como parâmetro. Um caminho físico é um caminho do tipo: D:\Inetpub\wwwroot\Capitulo10.
O parâmetro URL especifica o caminho relativo ou virtual a ser mapeado para um diretório
físico. Se Caminho iniciar com uma barra simples (/) ou invertida (\), o método MapPath
retornará o caminho como se fosse um virtual completo. Se Caminho não iniciar com uma
barra, o método MapPath retornará um caminho relativo ao diretório do arquivo .asp que está
sendo processado.
Na Listagem 10.3, temos um exemplo de utilização do método MapPath.
Listagem 10.3 – Utilizando o método MapPath – exmap.asp.

2 <HTML>
3 <HEAD>
4 <TITLE>Utilizando o método MapPath.</TITLE>
5 </HEAD>
6 <BODY>
7 <HR>
8 <%
9 Response.Write Server.MapPath(“/”) & “<BR>”
10 Response.Write Server.MapPath(“Capitulo6”) & “<BR>”
11 Response.Write Server.MapPath(“/Capitulo10”) & “<BR>”
12 Response.Write Server.MapPath(“/Capitulo10/exmap.asp”) & “<BR>”
13 Response.Write Server.MapPath(“/iishelp”) & “<BR>”
14 Response.Write Server.MapPath(“\”) & “<BR>”
15 %>
16 <HR>
17 </BODY>
18 </HTML>
Na Figura 10.3 temos o resultado da página da Listagem 10.3 quando carregada no Internet
Explorer.
573
Figura 10.3: Resultado da utilização do método Server.MapPath.
Observe que tanto a barra normal (/), quanto a barra invertida (\) podem ser utilizadas como
parâmetro para que o método MapPath retorne o caminho físico para o diretório raiz do
servidor IIS.
NOTA
O método MapPath não verifica se o caminho que ele retorna é válido ou existe no servidor. Ele
apenas retorna qual seria o caminho físico para o endereço relativo que foi passado. O método
faz esta determinação com base no caminho físico do diretório raiz.
IMPORTANTE
Não podemos utilizar o método MapPath nos eventos Application_OnEnd e Session_OnEnd.
O Método Transfer(“url”)
O método Transfer(“url”) pára a execução da página atual, e transfere a execução para a
página especificada no parâmetro URL. Caso tenham sido definidas informações para o objeto
Session ou informações de transação, as mesmas serão transferidas para a nova página. Porém,
o método Transfer(“url”), após finalizar a execução da página que foi chamada, não retorna o
controle para a página original, como acontece no método Execute.
574
Quando você chama Server.Transfer, as informações sobre o estado de todos os objetos

incorporados são incluídas na transferência. Isso significa que todas as variáveis ou objetos
aos quais foi atribuído um valor no escopo da sessão ou do aplicativo serão mantidos. Além
disso, todos os conteúdos atuais das coleções Request estarão disponíveis para o arquivo .asp
que está recebendo a transferência.
Se o caminho que você especificar no parâmetro URL for de um arquivo .asp em outro
aplicativo, o arquivo .asp será executado como se estivesse no aplicativo que contém o comando
Server.Transfer. Em outras palavras, todas as variáveis e objetos, aos quais foram dados escopo
de aplicativo por outros arquivos .asp no aplicativo, ou pelo arquivo global.asa do aplicativo,
estarão disponíveis para o arquivo .asp chamado.
A seguir temos alguns exemplos de código para o método Transfer:

<%
Server.Transfer(“outra.asp”)
%>
ou podemos também utilizar:

<%
Server.Transfer(“/Capitulo10/outra.asp”)
%>
O Método HTMLEncode(“texto”)
O método HTMLEncode converte os caracteres especiais do texto, passado como parâmetro,
para caracteres reconhecidos no código HTML. Considere os exemplos:
á é substituído por á
é é substituído por é
í é substituído por í

ó é substituído por ó
ú é substituído por ú
> é substituído por >

< é substituído por <
& é substituído por &
e assim por diante.
575
Um Exemplo Prático de Utilização do Objeto Server

Neste item vamos propor a solução para o seguinte problema:
PROBLEMA
Vamos criar um exemplo que faz conexão com o banco de dados nwind.mdb. No nosso exemplo,
será apresentada uma página – principal.asp – na qual o usuário selecionará o nome de um
país em uma lista de países. Esta lista de países será montada, dinamicamente, a partir da
tabela Customers, de tal maneira que somente sejam exibidos os países para os quais existem
clientes cadastrados. Além disso a listagem será classificada em ordem alfabética. Após
selecionar o país, o usuário clica em um botão Pesquisar. Com isso será retornada uma lista,
em forma de tabela, com todos os Clientes para o País selecionado – página listaclientes.asp. O
nome do Cliente será um link, que ao ser clicado abrirá uma página com as informações sobre
o mesmo – página cliente.asp. Para construir esta página teremos que utilizar alguns métodos
do objeto Server.
Na Listagem 10.4, temos o código para a construção da página principal.asp.
Listagem 10.4 – Criando, dinamicamente, uma lista de países – principal.asp.

2 <HTML>
3 <HEAD>
4 </HEAD>
5 <TITLE>Gera uma lista de Países dinamicamente.</TITLE>
6 <BODY>
7 <%
576
15 conn.Open

17 ‘a lista de países.

20 ‘Exibo a lista de países.
21 %>
22 <P><B>Selecione um país na lista de países.</B></P>

24 <FORM action=listaclientes.asp method=post id=form1 name=form1>
26 <%

30 ‘na lista.

32 Response.Write “<OPTION value=” & Chr(34) & Paises.Fields(“ShipCountry”) & Chr(34)
33 If Paises.Fields(“ShipCountry”)= Request.Form(“listapaises”) Then

34 Response.Write “SELECTED”
35 End If
36 Response.Write “>” & Paises.Fields(“ShipCountry”)& “</OPTION>”

37 Paises.MoveNext
38 Loop
39 %>
40 </SELECT>
577
41 <HR>
43 </FORM>
44 </BODY>
45 </HTML>
A Listagem 10.4 dispensa maiores comentários. Já analisamos diversos exemplos semelhantes

no Capítulo 7.
Agora precisamos criar a página listaclientes.asp. Está página deverá fazer o seguinte:
➥ Receber o valor do país selecionado na lista.
➥ Criar um RecordSet com todos os Clientes para o país selecionado.
➥ Na hora de exibir os resultados, transformar o nome do funcionário em um link que,
ao ser clicado, chama a página cliente.asp. No próprio link será passado o Código do
Cliente junto com a URL. Este código será utilizado, pela página cliente.asp, para
localizar o registro do Cliente na tabela Customers.
➥ Para construir este link, utilizaremos o método URLEncode.
Na Listagem 10.5, temos o código para a construção da página listaclientes.asp.
Listagem 10.5 – Retornando a lista de clientes para o país selecionado – listaclientes.asp.

2 <HTML>
3 <HEAD>
4 </HEAD>
5 <TITLE>Lista de Clientes para o País selecionado.</TITLE>
6 <BODY>
7 <%


578
15 conn.Open

17 ‘a lista de países.
19 Clientes.Open “Select * from Customers where Country=’” &

Request.Form(“listapaises”) & “‘ Order By CompanyName”, conn, 3, 3
20 ‘Exibo a lista de Clientes e o País.
21 %>
22 <HR>
23 <B>Lista de Clientes para:
24 <% =Request.Form(“listapaises”) %>

25 <HR>
27 <TR>
28 <TD><B>Nome do Cliente</B></TD>
30 </TR>
31 <%
32 Clientes.MoveFirst
33 Do Until Clientes.EOF
34 %>
35 <TR>
36 <TD>
37 <FONT FACE=“Arial”>
38 <P>
39 <A HREF=“http://servidor/Capitulo10/cliente.asp?Codigo=<%
579
=server.URLEncode(Clientes.Fields(“CustomerID”))%>”>
<%=Clientes.Fields(“CompanyName”)%>
40 </A>
41 </FONT>
42 </TD>
43 <TD><% = Clientes.Fields(“Country”) %>

44 </TD>
45 </TR>
46 <%
48 Loop
49 %>
50 </TABLE>
51 <HR>
52 </BODY>
53 </HTML>
O que temos de especial na página listaclientes.asp é o seguinte trecho de código:

36 <TD>
37 <FONT FACE=“Arial”>
38 <P>
39 <A HREF=“http://servidor/capitulo10/cliente.asp?Codigo=
<% =server.URLEncode(Clientes.Fields(“CustomerID”))%>”>
40 </A>
41 </FONT>
42 </TD>
Neste trecho estamos montando a primeira coluna da tabela. Utilizamos a tag HTML <A
HREF=> </A> para construir um link. Dentro deste link, construímos a seguinte URL:
http://servidor/capitulo10/cliente.asp?Codigo=
Depois utilizamos o seguinte código ASP:

<% =server.URLEncode(Clientes.Fields(“CustomerID”))%>
580
Este código passa o campo CustomerID como parâmetro para o método URLEncode, o qual
irá converter qualquer caractere não permitido em uma URL para o equivalente permitido,
conforme descrito anteriormente. Vamos supor que o código do clientes seja JSILVA. Neste
ponto o nosso link estará assim:
http://servidor/capitulo10/cliente.asp?Codigo=JSILVA
Depois utilizamos o seguinte código ASP:

Este código simplesmente exibirá o Nome do Cliente, que é o texto que aparecerá como texto
do link. Observe que montamos o link de tal forma que o parâmetro que será passado na URL
é o Código do Cliente (CustomerID), porém o texto que será exibido na página é o Nome do
Cliente (CompanyName). Estamos passando o Código do Cliente como parâmetro, porque
este campo é uma chave primária e, portanto, não existirão dois clientes com o mesmo código.
Porém, existe a possibilidade de existirem dois clientes com o mesmo nome.
Com isso montamos, facilmente, um link no nome de cada cliente. Quando o usuário clicar
no nome do cliente, será passado, juntamente com a URL o Código do Cliente como parâmetro
de pesquisa para a página cliente.asp. O passo final da nossa aplicação é construir a página
cliente.asp e depois testar o funcionamento da mesma.
Na Listagem 10.6, temos o código para a construção da página cliente.asp.
Listagem 10.6 – Localizando o registro do cliente. – cliente.asp.

2 <HTML>
3 <HEAD>
4 <TITLE>Lista para o Cliente <% = Request.QueryString(“Codigo”) %> !!</TITLE>
5 </HEAD>
6 <BODY>
7 <%
8 ‘O primeiro passo é criar a conexão com o Banco de dados.

581
15 conn.Open

‘o Cliente.
17 Set Cliente = Server.CreateObject(“ADODB.Recordset”)

Cliente.Open “Select * from Customers where CustomerID=’” &
Request.QueryString(“codigo”) & “‘“, conn, 3, 3
18 ‘Exibo os dados do Cliente.
19 %>
20 <HR>
21 <B>REGISTRO PARA O CLIENTE:</B>

22 <% =Cliente.Fields(“CompanyName”)%>
23 <HR>
24 <A HREF=“principal.asp”>Clique aqui para selecionar outro país.</A>
25 <HR>
26 <TABLE border=1 cellPadding=1 cellSpacing=1 width=”100%”>
27 <TR>
28 <TD>Código do Cliente:</TD>
29 <TD><B><% =Cliente.Fields(“CustomerID”)%></B></TD>
30 </TR>
31 <TR>
32 <TD>Nome do Cliente:</TD>
33 <TD><B><% =Cliente.Fields(“CompanyName”)%></B></TD>
34 </TR>
35 <TR>
36 <TD> Contato:</TD>
37 <TD><B><% =Cliente.Fields(“ContactName”)%></B></TD>
582
38 </TR>
39 <TR>
40 <TD> Endereço:</TD>
41 <TD><B><% =Cliente.Fields(“Address”)%></B></TD>
42 </TR>
43 <TR>
44 <TD> Cidade: </TD>
45 <TD><B><% =Cliente.Fields(“City”)%></B></TD>
46 </TR>
47 <TR>
48 <TD> CEP:</TD>
49 <TD><B><% =Cliente.Fields(“PostalCode”)%></B></TD>
50 </TR>
51 <TR>
52 <TD> Fone:</TD>
53 <TD><B><% =Cliente.Fields(“Phone”)%></B></TD>
54 </TR>
55 <TR>
56 <TD> Fax:</TD>
57 <TD><B><% =Cliente.Fields(“Fax”)%></B></TD>
58 </TR>
59 <TR>
60 <TD> País:</TD>
61 <TD><B><% =Cliente.Fields(“Country”)%></B></TD>
62 </TR>
63 <HR>
64 </TABLE>
65 </BODY>
66 </HTML>
583
Observe que utilizamos código ASP na tag <TITLE></TITLE>, o que é possível, sem maiores
problemas.
Outro detalhe a ser observado é que utilizamos o método Request.QueryString. Isto foi feito,
porque o Código do Cliente foi passado na própria URL. É como se estivéssemos utilizando o
método get da tag <FORM>. Por isso, para recuperar o valor passado como parâmetro,
precisamos utilizar o método Request.QueryString ao invés de Request.Form.
Agora vamos ver a nossa aplicação em funcionamento.
Na Figura 10.4 vemos que foi carregada a página principal.asp e o usuário selecionou Argentina
na lista de países.
Figura 10.4: O usuário selecionou Argentina na lista de países.
Ao clicar no botão Pesquisar é chamada a página listaclientes.asp, a qual exibe uma listagem
com todos os Clientes da Argentina, conforme mostrado na Figura 10.5.
Observe que o nome de cada Cliente é um link. Se clicarmos no nome do cliente, será chamada
a página cliente.asp e será passado, na própria URL, o código do cliente. Com isso são exibidos
os dados do Cliente. Na Figura 10.6, temos o exemplo para o caso em que o usuário clicou no
link para o cliente Rancho Grande.
Observe no campo endereço, que temos a seguinte URL:

http://servidor/Capitulo10/cliente.asp?Codigo=RANCH
584
Figura 10.5: A listagem dos clientes da Argentina.
Figura 10.6: Dados do cliente Rancho Grande.
O Código do Cliente foi “passado” na própria URL.
O usuário pode clicar no link Clique aqui para selecionar outro país, para voltar à página
principal.asp e fazer uma nova pesquisa. O usuário também pode clicar no botão Voltar do
585
próprio navegador, para retornar à página listaclientes.asp, com a lista de Clientes da Argentina
e clicar em um outro Cliente para ver os dados do mesmo.
Com este exemplo prático, encerramos o estudo do objeto Server. Nos próximos itens
aprenderemos a utilizar alguns componentes que são fornecidos juntamente com o IIS.
Utilizando Componentes do Servidor em Páginas ASP

Agora passaremos ao estudo de diversos componentes que fazem parte da instalação básica
do IIS, ou seja, ao instalarmos o IIS os mesmos já estão disponíveis para serem utilizados.
Vamos estudar os chamados Active Server Componnents. São componentes que executam
no servidor IIS, retornando um determinado resultado para a página ASP, que os utiliza, ou
efetuando uma determinada operação.
Nós já utilizamos diversos componentes, principalmente ao conectar com banco de dados,

utilizando ADO – Acivex Data Objects. ADO nada mais é do que uma biblioteca de
componentes, especialmente projetada para possibilitar o acesso a fontes diversas de dados,
tanto através de OLE DB quanto de ODBC.
Além dos componentes que já são fornecidos com o IIS e o Windows 2000, podem ser
adquiridos componentes de empresas desenvolvedoras de software. Existe uma infinidade
de componentes disponíveis na Internet, inclusive, gratuitos. Quando adquirimos um
componente, junto com o mesmo recebemos a documentação sobre como instalar, quais os
métodos, propriedades, eventos e coleções que o mesmo disponibiliza. A partir do momento
que o componente foi instalado, o mesmo pode ser utilizado em qualquer página ASP do
servidor onde foi instalado.
Os componentes desenvolvidos para serem utilizados por páginas ASP, no servidor IIS, devem
seguir o padrão COM (e no Windows 2000, o COM+). Estes componentes podem ser criados
utilizando-se ambientes de desenvolvimento como o Microsoft Visual Basic 6.0 ou o Microsoft
Visual C 6.0.
Vamos aprender a utilizar os principais componentes disponibilizados pelo IIS.
O Componente Content Link

Este componente é utilizado para auxiliar no gerenciamento de links para uma série de
documentos, sendo de grande utilidade na criação de estruturas de navegação. Por exemplo,
vamos supor que você tenha uma pasta virtual onde será publicado um manual de procedimentos
para a seção onde você trabalha. Ao publicar este manual, você gostaria que, junto com cada
586
página, fosse exibido uma lista de links, de forma que o usuário pudesse se deslocar para uma
parte específica do manual e também uma barra de navegação com links para o próximo
documento, o documento anterior, para o primeiro documento e para o último documento.
Obviamente que esta estrutura de navegação pode ser criada manualmente. Porém pequenas
modificações como a inserção ou inclusão de páginas, farão com que toda a estrutura de
navegação tenha que ser alterada. Para facilitar a criação de uma estrutura de navegação
deste tipo, podemos utilizar o componente Content Link.
O objeto Content Link é fornecido através da DLL Nextlink.dll, a qual encontra-se, normalmente,
na pasta \winnt\system32\inetsrv, do drive onde está instalado o Windows 2000.
A sintaxe para criar um objeto do tipo Content Link é a seguinte:

Set meu_objeto = Server.CreateObject(“MSWC.Nextlink”)
onde MSWC.Nextlink é a identificação com que o objeto Content Link foi registrado.
Para salientar a utilização do componente Content Link, vamos criar um exemplo onde temos
um manual com cinco capítulos, além da Introdução. Queremos utilizar o componente Content
Link para exibir, em todas as páginas do manual, um índice com links para a Introdução e
para os cinco capítulos; e no final e início de cada documento, uma barra de navegação com
links para o próximo, anterior, primeiro e o último documento.
Os documentos para o nosso exemplo serão os indicados na Tabela 10.1.
Tabela 10.1 Documentos para o nosso manual de exemplo.
Documento Descrição
intro.asp Página de abertura e Introdução do manual.
cap1.asp Capítulo 1 do manual de exemplo.
O componente Content Link trabalha em conjunto com um arquivo de texto, o qual é conhecido
como “Lista de conteúdo”. Neste arquivo de texto cada linha representa um documento que
fará parte da Lista de conteúdo. Cada linha possui o seguinte formato:
URL-Página Descrição Comentário
Cada um dos elementos deve ser separado do anterior por uma tabulação.
587
Este arquivo, além de descrever quais os documentos que farão parte da Lista de conteúdo,
também define a ordem do documento nesta lista. Por exemplo, se estamos no arquivo cap3.asp
e clicamos no link próximo, será carregada a página cap4.asp. Esta seqüência é definida pela
ordem das linhas no arquivo que contém a Lista de conteúdo.
Para o nosso exemplo, teremos o seguinte arquivo de texto – conteudo.txt:
intro.asp Introdução Página inicial do manual e introdução

cap1.asp Capítulo 1 Capítulo 1 do Manual
Chamaremos este arquivo de conteudo.txt, o qual será salvo na mesma pasta que os demais
arquivos.
Uma vez criado o objeto, o próximo passo é definir qual o arquivo de texto que será utilizado
pelo componente Content Link.
A etapa final é utilizar os métodos do objeto Content Link para criar a estrutura dinâmica de
navegação.
Antes de criarmos o nosso exemplo, vamos aprender a criar um objeto associado a um

componente do tipo Content Link. Também vamos estudar os métodos deste componente.
Criando um Objeto do Tipo Content Link

Para criarmos um objeto do tipo Content Link, utilizamos a seguinte sintaxe:
Set conteudo=Server.CreateObject(“MSWC.Nextlink”)
Métodos do Objeto Content Link

Vamos fazer um estudo de cada um dos métodos do objeto Content Link.
➥ O método GetListCount: Este método retorna um número inteiro, o qual indica o número
de páginas listadas no arquivo de conteúdo que é passado como parâmetro.
588

Response.Write conteudo.GetListCount(“conteudo.txt”)
No nosso exemplo, como o arquivo conteudo.txt possui seis linhas, este comando irá retornar
o valor 6. É importante saber o número total de páginas na Lista de conteúdo, para que a
estrutura de navegação possa ser criada corretamente. A contagem dos elementos inicia com
1, e não zero como no caso de outros elementos. Assim, o primeiro elemento é o de índice 1,
o segundo é o de índice 2 e assim por diante. Se o arquivo passado como parâmetro não for
encontrado, o método GetListCount irá retornar 0.
➥ O método GetListIndex: Este método retorna o número do índice do elemento atual no
arquivo de conteúdo. A cada momento somente existe um item que é o atual. Podemos
alterar o item atual utilizando os métodos GetNextURL e GetPreviousURL, que estudaremos
mais adiante. Isto é semelhante ao conceito de registro corrente de um objeto RecordSet e
à utilização dos métodos MoveNext e MovePrevious do objeto RecordSet. O método retorna
0 se a página atual não estiver incluída no arquivo de conteúdo.

Response.Write conteudo.GetListIndex(“conteudo.txt”)
Este comando retorna o valor do índice do elemento atual.
Utilizando os métodos GetListCount e GetListIndex, podemos criar estruturas de navegação

bastante interessantes. Por exemplo, se estivermos na última página de uma Lista de conteúdo,
podemos fazer com que o link Próxima não seja exibido. Para fazer isso é só detectar se o
índice atual é igual ao valor retornado por GetListCount (número total de páginas). O código
da Listagem 10.7 ilustra como detectar se a página atual é a última da lista de conteúdo.
Na Listagem 10.7, uma preliminar da página intro.asp.
Listagem 10.7 – Utilizando os métodos GetListCount e GetListIndex.

2 <HTML>
3 <HEAD>
4 <TITLE> Utilizando o componente Content Link</TITLE>
6 </HEAD>
7 <BODY>
8 <%
9 ‘O primeiro passo é criar um objeto do tipo MSWC.Nextlink
10 Set conteudo=Server.CreateObject(“MSWC.Nextlink”)
589
11 Response.Write “Número total de páginas:” & conteudo.GetListCount(“conteudo.txt”)

& “<BR>”
12 ultimo = conteudo.GetListCount(“conteudo.txt”)
13 atual = conteudo.GetListIndex(“conteudo.txt”)
14 If atual=ultimo Then
15 Response.Write “A última página é a página atual.”
16 Else
17 Response.Write “A página atual é: ” & atual
18 End If
19 %>
20 </BODY>
21 </HTML>
➥ O método GetNextUrl: Esse método retorna a URL do próximo item especificada no

arquivo de conteúdo. Se a página atual não estiver especificada no arquivo de conteúdo,
o método GetNextURL retornará a URL da última página da lista. Por exemplo, se você
estiver na página cap3.asp do nosso exemplo, o método GetNextURL(“conteudo.txt”)
irá retornar cap4.asp, que é a próxima página, na linha logo abaixo da linha de cap3.asp.
conteudo.GetNextURL(“conteudo.txt”)
onde o único parâmetro a ser passado é o arquivo de conteúdo.

➥ O método GetNextDescription: Esse método retorna a descrição do próximo item do
arquivo de conteúdo. Se a página atual não estiver especificada no arquivo de conteúdo,
o método GetNextDescription retornará a descrição da última página da lista.

conteudo.GetNextDescription(“conteudo.txt”)

➥ O método GetNthDescription: Esse método retorna a descrição do enésimo item do
arquivo de conteúdo.
conteudo.GetNthDescription(“conteudo.txt”,3)
590
onde os parâmetros a serem passados são o arquivo de conteúdo e o índice do elemento cuja
descrição deve ser retornada.
➥ O método GetNthUrl: Esse método retorna a URL do enésimo item, especificada no
arquivo de conteúdo.
conteudo.GetNthURL(“conteudo.txt”,3)
onde os parâmetros a serem passados são o arquivo de conteúdo e o índice do elemento cuja
URL deve ser retornada.
➥ O método GetPreviousURL: Esse método retorna a URL do item anterior ao atual,
especificada no arquivo de conteúdo. Se a página atual não estiver especificada, o
método GetPreviousURL retornará a URL da primeira página da lista. Por exemplo, se
você estiver na página cap3.asp do nosso exemplo, o método GetPreviousURL
(“conteudo.txt”) irá retornar cap2.asp, que é a página anterior a cap3.asp, na linha logo
acima da linha de cap3.asp.
conteudo.GetPreviousURL(“conteudo.txt”)

➥ O método GetPreviousDescription: Esse método retorna a descrição do item anterior
ao atual, especificado no arquivo de conteúdo. Se a página atual não estiver especificada
no arquivo de conteúdo, o método GetPreviousDescription retornará a descrição da
primeira página da lista.
conteudo.GetPreviousDescription(“conteudo.txt”)
Um Exemplo que Utiliza o Componente Content Link

Então, mãos à obra. Vamos criar o nosso exemplo proposto, passo a passo. Todas as nossas
páginas terão a mesma estrutura. Na coluna da esquerda, teremos o menu de navegação
(criado dinamicamente através da utilização dos métodos do objeto Content Link), e na parte
superior e inferior da página teremos um menu com as opções de ir para a próxima, para a
anterior, para a última ou para a primeira página.
Na Listagem 10.8, temos a página inicial do manual intro.asp.
591
Listagem 10.8 – A página inicial do manual – intro.asp.

2 <HTML>
3 <HEAD>
4 <TITLE> Utilizando o componente Content Link</TITLE>
5 </HEAD>
6 <BODY>
7 <%
8 ‘O primeiro passo é criar um objeto do tipo MSWC.Nextlink
9 Set conteudo=Server.CreateObject(“MSWC.Nextlink”)
10 ultimo = conteudo.GetListCount(“conteudo.txt”)
11 primeiro = 1
12 %>
13 <TABLE bgColor=#c0c0c0 border=1 cellPadding=1 cellSpacing=1 width=“100%”>
14 <% ‘Agora construo a barra de navegação do topo da página. %>
15 <TR>
16 <TD colSpan=2>
<A HREF=“<%=conteudo.GetNthURL(“conteudo.txt”,primeiro)%>”>[Início]</A>
<A HREF=“<%=conteudo.GetPreviousURL(“conteudo.txt”)%>”>[Anterior]</A>
<A HREF=“<%=conteudo.GetNextURL(“conteudo.txt”)%>”>[Próxima]</A>
<A HREF=“<%=conteudo.GetNthURL(“conteudo.txt”,ultimo)%>”>[Última]</A>
17 </TD>
18 </TR>
19 <% ‘Agora construímos o menu de navegação na coluna da esquerda %>

20 <TR>
21 <TD width=10%>
592
22 <%
23 For i=1 to ultimo %>

24 <A HREF=“<%=conteudo.GetNthURL(“conteudo.txt”,i)%>”>
<% =conteudo.GetNthDescription(“conteudo.txt”,i)%></A>
25 <%
26 Next
27 %>
28 </TD>
29 <% ‘A próxima célula é a célula de conteúdo. %>
30 <TD width=90%>
31 <P><B>MANUAL DE PROCEDIMENTOS PARA A SEÇÃO DE ATENDIMENTO.</B></P>
32 <HR>
33 <P><I>INTRODUÇÃO</I></P>
34 <HR>
35 <P>Aqui colocaríamos o conteúdo da Introdução.</P>
36 <HR>
37 </TD>
38 </TR>
39 <% ‘Agora construo a barra de navegação do topo da página.%>
40 <TR>
41 <TD colSpan=2>
42 <A HREF=“<%=conteudo.GetNthURL(“conteudo.txt”,primeiro)%>”>[Início]</A>
43 <A HREF=“<%=conteudo.GetPreviousURL(“conteudo.txt”)%>”>[Anterior]</A>
44 <A HREF=“<%=conteudo.GetNextURL(“conteudo.txt”)%>”>[Próxima]</A>
45 <A HREF=“<%=conteudo.GetNthURL(“conteudo.txt”,ultimo)%>”>[Última]</A>
46 </TD>
47 </TR>
48 </TABLE>
49 </BODY>
50 </HTML>
593
Ao carregarmos a página intro.asp, no Internet Explorer, obtemos o resultado indicado na

Figura 10.7.
Figura 10.7: A página intro.asp.
Todos os links desta página foram construídos utilizando os métodos do objeto conteudo, o
qual é uma instância de um componente Content Link. Observe o trecho de código a seguir,
responsável pela criação do menu de navegação superior e inferior:
16 <TD colSpan=2>
<A HREF=“<%=conteudo.GetNthURL(“conteudo.txt”,primeiro)%>”>[Início]</A>
<A HREF=“<%=conteudo.GetPreviousURL(“conteudo.txt”)%>”>[Anterior]</A>
<A HREF=“<%=conteudo.GetNextURL(“conteudo.txt”)%>”>[Próxima]</A>
<A HREF=“<%=conteudo.GetNthURL(“conteudo.txt”,ultimo)%>”>[Última]</A>
17 </TD>
Observe que utilizamos os métodos GetPreviousURL, GetNextURL e GetNthURL para retornar

as respectivas URL a partir do arquivo de conteúdo. Por exemplo, estamos com a página
intro.asp carregada. O método GetNextURL retornará a URL da linha seguinte à linha de
intro.asp no arquivo de conteúdo. No nosso exemplo retornará cap1.asp, que é justamente a
próxima página do nosso manual. Também fizemos uso de duas variáveis: primeiro contém o
594
valor 1 para fazer referência à primeira URL do arquivo de conteúdo, e ultimo contém o valor
retornado pelo método GetListCount, que é o índice da última URL.
Outro detalhe importante a observar é o caso de estarmos na primeira ou na última página. Se

estivermos na primeira página, o método GetPreviousURL retorna o endereço da última página.
Se estivermos na última página, o método GetNextURL retorna o endereço da primeira página.
Também gostaria de comentar a maneira como foi montado o menu de opções da coluna da
esquerda. Neste caso, utilizamos um laço For, variando de 1 até último, para montar um
menu com links para todas as páginas do arquivo de conteúdo.
Você pode estar se perguntando: “Por que utilizar o componente Content Link, se poderia ter
criado todos estes links manualmente”?
A resposta é simples. O componente Content Link facilita a nossa vida quando precisamos
inserir ou excluir páginas que não estão no início ou no fim do conteúdo. Vamos supor que
precisássemos inserir uma nova página cap3.asp, de tal forma que a cap3.asp antiga passasse a
ser cap4.asp, a cap4.asp antiga passasse a ser cap5.asp, e assim por diante. Se tivéssemos criado
os links manualmente, teríamos que revisar todas as páginas e alterá-los. Se estivermos utilizando
o componente Content Link, a única coisa que precisa ser feita é alterar o arquivo de conteúdo,
inserindo a nova página na posição correta e renomear as demais, conforme indicado a seguir:
intro.asp Introdução Página inicial do manual e introdução

e todos os links serão, automaticamente, recalculados.
Pode parecer que não é vantagem utilizar o componente Content Link quando utilizamos um
número pequeno de páginas, porém quando o número de páginas começa a crescer (eu diria
cinco ou mais páginas) para uma determinada documentação, o componente Content Link é
um auxiliar valioso.
Na Figura 10.8, vemos o resultado quando o usuário carrega a página cap4.asp.
595
Figura 10.8: A página cap4.asp.
Se você posicionar o mouse sobre os links, sem clicar, verá que os mesmos foram
automaticamente recalculados. Por exemplo, o link [Próxima] aponta para cap5.asp, o link
[Anterior] aponta para cap3.asp e assim por diante.
As outras páginas do nosso manual somente irão diferir da página intro.asp no conteúdo que
apresentam. Para isto basta inserir o conteúdo específico de cada página, a partir do seguinte parágrafo:
35 <P>Aqui colocaríamos o conteúdo da Introdução.</P>
Com isso encerramos o estudo do componente Content Link.
O Componente Ad Rotator
O componente Ad Rotator permite que uma página ASP exiba um gráfico diferente a cada vez
em que é carregada. Sempre que um usuário abre ou recarrega a página da Web, o componente
Ad Rotator exibe um novo anúncio baseado nas informações especificadas em um arquivo de
texto, conhecido como Arquivo de Programação de Rotatória. Neste arquivo estão as diversas
informações necessárias para que o componente funcione corretamente.
596
Este componente normalmente é utilizado para exibir imagens animadas que funcionam como
anúncios e propaganda. Cada vez que o usuário carrega a página é exibido um anúncio diferente.
Além disso, é possível registrar quantos usuários clicam em cada anúncio definindo o parâmetro
URL no Arquivo de Programação de Rotatória para redirecionar os usuários para uma
determinada página, quando o usuário clicar no anúncio. Quando especificamos esse parâmetro,
cada salto para a URL de um anunciante é registrado nos logs de atividade do servidor Web.
No Arquivo de Programação de Rotatória também podemos configurar uma determinada

freqüência para cada um dos anúncios, de tal maneira que um anúncio apareça um número
maior de vezes do que os outros. Desta forma estaríamos priorizando um ou mais anúncios
em detrimento de outros.
Para utilizar este componente necessitamos dos seguintes arquivos:

➥ adrot.dll: Este é o arquivo onde está implementada a funcionalidade do componente.
Este arquivo encontra-se, normalmente, na pasta \winnt\system32\inetsrv, do drive
onde está instalado o Windows 2000.
➥ Arquivo de Programação da Rotatória: Um arquivo de texto que contém informações
sobre o arquivo e a programação de exibição de anúncios, tais como quais os anúncios
que serão exibidos e qual o percentual de vezes, em relação ao total, que cada um
deve ser exibido. Esse arquivo deve estar disponível em um caminho virtual do
servidor da Web.
➥ Arquivo de Redirecionamento: Um arquivo opcional que implementa o redirecio-
namento e permite que o componente Rotatória de anúncios registre quantos usuários
clicam em cada anúncio.
Para criar um objeto do tipo Ad Rotator, podemos utilizar a seguinte sintaxe:

Set nome_objeto = Server.CreateObject( “MSWC.AdRotator” )
onde MSWC.AdRotator é o nome com o qual o componente Ad Rotator foi registrado no

servidor onde está instalado o IIS.
Agora vamos conhecer um pouco mais sobre o Arquivo de Programação da Rotatória e o

Arquivo de Redirecionamento.
O Arquivo de Programação da Rotatória

O Arquivo de Programação de Rotatória contém informações que o componente Ad Rotator
usa para gerenciar e exibir as várias imagens de anúncios. Podemos especificar os detalhes
dos anúncios, como o tamanho do espaço do anúncio, arquivos de imagem a serem usados e
porcentagem de tempo de exibição de cada arquivo.
597
O Arquivo de Programação de Rotatória tem duas seções. A primeira seção define parâmetros
que se aplicam a todas as imagens de anúncios na programação de rotação. A segunda seção
especifica as informações sobre o arquivo e a localização de cada anúncio individual e a
porcentagem de tempo de exibição que cada anúncio deve receber. As duas seções são
separadas por uma linha que contém somente um asterisco (*).
Na primeira seção existem quatro parâmetros globais, cada um consistindo em uma palavra-
chave e um valor. Todos eles são opcionais. Se você não especificar valores para os parâmetros
globais, o componente Ad Rotator usará os valores padrão. Nesse caso, a primeira linha do
arquivo deve conter somente um asterisco (*).
Sintaxe
[REDIRECT URL]
[WIDTH Largura]
[HEIGHT Altura]
[BORDER Borda]
*
URL_anúncio
URL_home_page_anúncio
Texto
impressões
Vamos entender o que significa cada um destes parâmetros:
URL
Especifica o caminho para o arquivo dynamic link library (.dll, biblioteca de link dinâmico)
ou de aplicativo (.asp) que implementa o redirecionamento. Esse caminho pode ser
especificado por completo (http://MyServer/MyDir/redirect.asp) ou em relação ao diretório
virtual (/MyDir/redirect.asp).
Largura
Especifica a largura do anúncio na página, em pixels. O padrão são 440 pixels.
Altura
Especifica a altura do anúncio na página, em pixels. O padrão são 60 pixels.
598
Borda
Especifica a espessura da borda do link em torno do anúncio, em pixels. O padrão é uma
borda de 1 pixel. Defina esse parâmetro para 0 para um link sem borda.
Estes quatro primeiros parâmetros são opcionais e caso sejam definidos têm efeitos sobre
todos os anúncios a serem exibidos. Caso um ou mais destes parâmetros não seja definido,
serão utilizados os valores padrão. Mesmo que nenhum destes parâmetros seja definido,
devemos colocar o * em uma linha, antes de iniciarmos a segunda seção do documento.
A partir de agora veremos os parâmetros para a segunda seção do documento, após a linha
com *. Estes parâmetros definem cada um dos anúncios a serem exibidos, individualmente.
URL_anúncio
A localização do arquivo de imagem do anúncio. Por exemplo: images/anuncio1.gif.
URL_home_page_anúncio
A localização da home page do anúncio, isto é, a página que será carregada se o usuário clicar
no anúncio. Se o anúncio não tiver uma home page, coloque um hífen (-) nessa linha para
indicar que não existe qualquer link para esse anúncio.
Texto
Um texto alternativo exibido se o navegador não oferecer suporte a elementos gráficos ou se
seus recursos gráficos estiverem desativados.
Impressões
Um número entre 0 e 10000 que indica a densidade relativa do anúncio.
Por exemplo, se um Arquivo de Programação de Rotatória contém três anúncios com o parâmetro
impressões definido para 2, 3 e 5, o primeiro anúncio será exibido durante 20 % do tempo, o
segundo, durante 30 % do tempo e o terceiro, durante 50 % do tempo. Se a soma dos parâmetros de
impressão de todos os itens exceder 10000, será gerado um erro na primeira vez que o Arquivo de
Programação de Rotatória for acessado por uma chamada do método GetAdvertisement.
599
Exemplo
O script a seguir demonstra como você pode usar um Arquivo de Programação de Rotatória
para exibir vários anúncios e como incluir um arquivo de redirecionamento.
Capitulo10\rotatoria.txt
WIDTH 236
HEIGHT 56
BORDER 4
*
/capitulo10/imagens/anuncio1.gif
-
Página do Anunciante 1
20
http://servidor/capitulo10/anunciante2.htm
30
http://servidor/capitulo10/anunciante3.htm
50
Observe que quando for exibido anuncio1.gif, o mesmo não será exibido como um link.
O Arquivo de Redirecionamento
O Arquivo de Redirecionamento é um arquivo criado pelo desenvolvedor da aplicação Web.
Ele inclui geralmente um script para a análise da seqüência de caracteres da solicitação pelo
objeto Ad Rotator e para o redirecionamento do usuário para a URL associada ao anúncio no
qual o usuário clicou.
Você também pode incluir um script no Arquivo de Redirecionamento para contar o número
de usuários que clicaram em um anúncio específico e salvar essas informações em um arquivo
no servidor.
Exemplo
O exemplo a seguir redireciona o usuário para a home page do anúncio.
600
redireciona.asp
<% Response.Redirect(Request.QueryString(“url”)) %>
Observe que o parâmetro URL é passado no próprio link quando o usuário clica no anúncio.
É por isso que estamos utilizando Request.QueryString.
O nome do arquivo de imagem também é passado como parâmetro através da URL. Podemos
utilizar este parâmetro para calcular o número de vezes que cada anúncio é clicado. No
fragmento de código abaixo temos um exemplo de como calcular quantas vezes foram clicados
cada um dos anúncios do nosso exemplo:
➥ anuncio1.gif
➥ anuncio2.gif
➥ anuncio3.gif
Arquivo redireciona.asp que faz a contabilidade de cliques em cada anúncio:
<%
Select case Request.QueryString(“image”)
Case “anuncio1.gif”
count_anuncio1=count_anuncio1+1
End Select
Código para salvar o valor do contador para cada anúncio no banco de dados
...
Código para redirecionar para a página específica de cada anúncio
...
%>
Onde temos “Código para salvar o valor do contador para cada anúncio no banco de dados”,
poderíamos estabelecer uma conexão com um banco de dados e salvar o valor de cada contador
no banco de dados, pois após a página de redirecionamento ter sido abandonada, os valores
dos contadores seriam perdidos. Assim, salvando-os no banco de dados, podemos mantê-los,
que é justamente o objetivo.
Propriedades do Objeto Ad Rotator

Na Tabela 10.2, temos uma descrição das propriedades do objeto Ad Rotator.
601
Tabela 10.2 Propriedades do objeto Ad Rotator.
Border Especifica o tamanho da borda em torno do anúncio. Para
definir a borda utilizamos a sintaxe:objeto.border=tamanho.
Onde tamanho especifica a espessura da borda que circunda
o anúncio exibido. O padrão é o valor definido no cabeçalho
do Arquivo de Programação de Rotatória. Ex: objeto.border = 2.
Clickable Define se o anúncio será ou não um link para uma outra
página. Pode ter os valores True ou False. A sintaxe para esta
propriedade é a seguinte: objeto.clickable=true ou
objeto.clickable=false.
TargetFrame Esta propriedade especifica o nome do Frame onde deve ser
carregado o anúncio. Utilizamos a seguinte sintaxe:
objeto.TargetFrame=nome_do_frame.
Método do Objeto Ad Rotator

É isto mesmo: método do objeto Ad Rotator, já que o mesmo só possui um método, o
GetAdvertisement.
O método GetAdvertisement recupera o próximo anúncio do arquivo de programação de

rotatória. Sempre que o script é executado, ou quando um usuário abre ou atualiza uma
página, o método recupera o próximo anúncio programado.
Sintaxe:
GetAdvertisement(arquivo de rotatória)
O único parâmetro para este método especifica o local do arquivo de programação de rotatória
em relação ao diretório virtual. Por exemplo, se o caminho físico fosse C:\Inetpub\wwwroot\
Ads\Adrot.txt (no qual wwwroot é o diretório virtual “/”), você especificaria o caminho \Ads\
Adrot.txt. No nosso exemplo, temos a pasta Capitulo10 dentro da pasta wwwroot, a qual está
localizada em E:\Inetpub\wwwroot\Capitulo10\rotatoria.txt. Vamos especificar \Capitulo10\
rotatoria.txt.
Este método retorna o código HTML que exibe o anúncio na página atual.
Vamos a um exemplo de utilização do componente Ad Rotator.
Considere a página usaadrotator.asp da Listagem 10.9.
602
Listagem 10.9 – Utilizando o componente Ad Rotator – usaadrotator.asp.

2 <HTML>
3 <HEAD>
4 </HEAD>
5 <BODY>
6 <%
7 ‘ Cria um objeto do tipo AdRotator
8 Set conteudo=Server.CreateObject(“MSWC.AdRotator”)
9 conteudo.Clickable = True
10 %>
11 <HR>
12 <P>Clique no Banner abaixo:</P>
13 <HR>
14 <% =conteudo.GetAdvertisement(“/Capitulo10/rotatoria.txt”)
15 %>
16 <HR>
17 <P> Conteúdo da Página.</P>
18 </BODY>
19 </HTML>
Na Figura 10.9, vemos o resultado quando o usuário carrega a página usaadrotator.asp.
Se o usuário atualizar a página, será carregado um anúncio diferente, conforme indicado na

Figura 10.10.
Os anúncios serão carregados na proporção definida no arquivo rotatoria.txt que é a seguinte:

anuncio1.gif 20%
anuncio2.gif 30%
anuncio3.gif 50%
603
Figura 10.9: A página usaadrotator.asp.
Figura 10.10: Ao carregar a página foi exibido um anúnicio diferente.
Assim, em metade das vezes que a página for acessada, será exibido o anúncio 3 (50%).
604
O Componente Page Counter

O componente Page Counter pode ser utilizado para contar quantas vezes uma determinada
página é acessada pelos usuários. A informação sobre o número de acessos é salva em um
arquivo de texto, de tal forma que quando o IIS é “parado” por algum motivo, a informação
sobre o número de acessos não é perdida. O componente Page Counter cria um objeto
PageCounter que conta e exibe o número de vezes em que uma página da Web foi aberta. A
intervalos regulares, o objeto grava o número de acessos em um arquivo de texto para que, no
caso de o servidor desligar, os dados não sejam perdidos. O componente Contador de página
usa um objeto Central Management interno para registrar quantas vezes cada página do
aplicativo foi aberta.
Quando uma instância do objeto PageCounter é criada em uma página pelo método
Server.CreateObject, o objeto recupera a contagem atual de acessos à página da Web
especificada do objeto Central Management. Em seguida, o objeto pode ser manipulado com
os métodos que expõe.
O componente Contador de página usa os seguintes arquivos:

➥ Pagecnt.dll: Este é o arquivo onde está implementada a funcionalidade do componente.
Este arquivo encontra-se, normalmente, na pasta \winnt\system32\inetsrv, do drive
onde está instalado o Windows 2000.
➥ Arquivo Hit Count Data: Este é um arquivo de texto, onde periodicamente são salvas
as informações sobre o número de acessos à página. Este arquivo é gerenciado pelo
objeto Central Management, não sendo recomendada a edição desse arquivo, pois erros
na formatação do mesmo não permitirão que o objeto PageCounter carregue apropriada-
mente as informações de contagem de acessos.
Para criar um objeto Page Counter, utilizamos a seguinte sintaxe:

Set nome_objeto = Server.CreateObject( “MSWC.PageCounter” )
onde nome_objeto especifica o nome do objeto PageCounter criado pela chamada do

Server.CreateObject.
O componente Contador de página cria entradas na Registry do Windows 2000. Ele adiciona
a chave MSWC.PageCounter ao registro quando o objeto é compilado ou registrado. A chave
é adicionada abaixo de HKEY_CLASSES_ROOT e contém os seguintes valores nomeados:
➥ File_Location: Uma seqüência de caracteres que especifica o caminho e o nome do
arquivo Hit Count Data. O nome de arquivo padrão é Hitcnt.cnt. Esse arquivo está
localizado em diretório \winnt\system32\inetsrv\Data. O ideal é deixar que o próprio
IIS gerencie este arquivo.
605
➥ Save_Count: Um parâmetro, do tipo DWORD, que especifica o número de acessos antes

que a contagem de acessos seja salva no arquivo Hit Count Data. Observe que esse número
é o número total de acessos, não o número de acessos por página. O valor padrão é 25.
Abaixo temos um exemplo de criação de um objeto do tipo Page Counter:

<%
Set contador = Server.CreateObject(“MSWC.PageCounter”)
%>
Antes de apresentarmos um exemplo prático de utilização deste componente, vamos aprender

a utilizar os métodos do mesmo.
Os Métodos do Componente Page Counter

A seguir temos uma descrição dos métodos do objeto Page Counter.
➥ Método Hits: O método Hits retorna o número de vezes, que uma página da Web
especificada, foi aberta.
nome_objecto.Hits( [Info_caminho] )
contador.Hits(“/capitulo10/anuncio1.asp”)
Onde: Info_caminho é um parâmetro opcional que especifica o PATH_INFO da página da

Web usando o formato /nome_do_diretório_virtual/nome_do_arquivo.asp. Se esse parâmetro
não for especificado, a contagem de acessos para a página atual será exibida.
NOTA
O método Hits retorna um número do tipo LONG que indica o número de vezes que uma
página da Web específica foi aberta.
➥ PageHit: O método PageHit incrementa em 1 a contagem de acessos à página da Web atual.

nome_objeto.PageHit( )
contador.PageHit( )
➥ Reset: O método Reset define a contagem de acessos à uma página da Web
especificada para 0.
606

nome_objeto.Reset([Info_caminho])
Veja o exemplo:
contador.Reset(“/capitulo10/anuncio1.asp”)
Onde: Info_caminho é um parâmetro opcional que especifica o PATH_INFO da página da

Web usando o formato /nome_do_diretório_virtual/nome_do_arquivo.asp. Se esse parâmetro
não for especificado, a contagem de acessos para a página atual será redefinida.
Vamos a um exemplo de utilização do componente Page Counter.
Considere a página usapagecounter.asp da Listagem 10.10.
Listagem 10.10 – Utilizando o componente Page Counter – usapagecounter.asp.

2 <HTML>
3 <HEAD>
4 <TITLE>Página que usa o componente Page Counter.</TITLE>
5 </HEAD>
6 <BODY>
7 <HR>
8 <FONT color=#000080 size=6><B>Página da empresa ABC:</B></FONT>
9 <%
10 ‘ O primeiro passo é criar o objeto Page Counter.
11 Set contador=Server.CreateObject(“MSWC.PageCounter”)
12 %>
13 <FONT color=#000080 size=6><B>Esta página já foi acessada:
14 <%
15 contador.PageHit
16 Response.Write contador.Hits
17 %>
18 <%
19 If contador.Hits =1 Then
20 Response.Write “Vez”
607
21 Else
22 Response.Write “Vezes”
23 End If
24 %>
25 </B></FONT>
26 <HR>
27 </BODY>
28 </HTML>
Na primeira vez que esta página for acessada, obteremos o resultado indicado na Figura 10.11.
Figura 10.11: O primeiro acesso à página usapagecounter.asp.
Na segunda vez que a página for acessada o contador já estará em 2, conforme indicado na
Figura 10.12, e assim sucessivamente.
Figura 10.12: O contador é incrementado a cada acesso à página.
608
Na Figura 10.13, temos uma noção do arquivo hitcnt.cnt onde são armazenadas as informações
sobre o número de acessos.
Figura 10.13: O arquivo \winnt\system32\inetsrv\Data\hitcnt.cnt.
O Componente Browser Capabilities – Capacidades do Navegador

Um dos maiores problemas do desenvolvimento para a Web foi, e continua sendo, as
diferenças entre os principais navegadores do mercado, notadamente o Internet Explorer e
o Netscape Navigator.
Diferente do ambiente Cliente/Servidor tradicional, onde podemos controlar o aplicativo que

será instalado na máquina de cada cliente, quando desenvolvemos para a Internet não podemos
exigir que o usuário esteja utilizando um navegador específico. Claro que é inviável desenvolver
levando em consideração todos os navegadores existentes, porém, no mínimo precisamos
criar aplicações Web que rodem sem problemas no Internet Explorer e no Netscape Navigator.
Porém esta, realmente, não é uma tarefa simples. Apenas para ter uma idéia das dificuldades:
➥ Os Modelos de Objetos do Internet Explorer e do Netscape Navigator são diferentes.
➥ Existem, também, diferenças na implementação de DHTML e Java Script, que no Internet
Explorer era conhecido como JScript, agora foi definido um “padrão conhecido com
ECMA Script”, na tentativa de unificar a implementação dos dois principais navegadores.
➥ A maneira como as tags são interpretadas não é exatamente a mesma, podendo existir
diferenças na apresentação das páginas.
Isto significa que o desenvolvimento Web para a Internet é uma missão quase impossível? De
maneira alguma, esta aí o sucesso da Internet e dos sites de Comércio Eletrônico para
comprovar que o modelo Web já se estabeleceu e só tende a crescer.
Para procurar resolver os problemas de compatibilidade entre os navegadores é que foi

desenvolvido o componente Browser Capabilities. Com ele podemos detectar as diversas
609
capacidades do navegador do cliente, e com base nestas capacidades, carregar uma ou outra
versão da página, específica para cada caso.
O componente Browser Capabilities cria um objeto do tipo BrowserType, o qual disponibiliza

para o script, uma descrição dos recursos do navegador da Web do cliente.
Quando um navegador se conecta com o servidor Web, ele envia automaticamente um

cabeçalho “Agente de usuário do HTTP”. Esse cabeçalho é uma seqüência de caracteres ASCII
que identifica o navegador e seu número de versão. O objeto BrowserType compara o cabeçalho
com entradas no arquivo Browscap.ini.
Se ele encontrar uma correspondência, o objeto BrowserType assumirá as propriedades da

listagem do navegador que correspondeu ao cabeçalho Agente de usuário.
Se o objeto não encontrar uma correspondência para o cabeçalho no arquivo browscap.ini,

ele procurará a correspondência mais próxima usando os curingas * e ?. Se não for possível
encontrar uma correspondência usando os curingas, o objeto usará as configurações do
navegador padrão, se elas tiverem sido especificadas no arquivo browscap.ini. Se o objeto
não encontrar uma correspondência e as configurações do navegador padrão não tiverem
sido especificadas no arquivo browscap.ini, o objeto definirá todas as propriedades para a
seqüência de caracteres “UNKNOWN”.
Você pode adicionar propriedades ou novas definições de navegador a esse componente

simplesmente atualizando o arquivo browscap.ini.
O componente Browser Capabilities usa os seguintes arquivos:

➥ Browscap.dll: Este é o arquivo onde está implementada a funcionalidade do
componente. Este arquivo encontra-se, normalmente, na pasta \winnt\system32\inetsrv,
do drive onde está instalado o Windows 2000.
➥ Browscap.ini: É um arquivo de texto que mapeia os recursos do navegador para o
cabeçalho Agente de usuário do HTTP. Esse arquivo deve estar no mesmo diretório
que o arquivo Browscap.dll.
Utilizamos a seguinte sintaxe para criar um objeto do tipo BrowserType:

Set nome_objeto = Server.CreateObject(“MSWC.BrowserType”)
Onde temos:
➥ nome_objeto: Especifica o nome do objeto BrowserType criado pela chamada do
Server.CreateObject.
➥ MSWC.BrowserType: É o nome pelo qual o componente é identificado no servidor IIS.
610
Na Listagem 10.11, temos um pequeno exemplo retirado do Help do IIS, onde são detectadas
algumas capacidades do navegador.
Listagem 10.11 – Utilizando o componente Browser Capabilities – capacidades.asp.

2 <HTML>
3 <HEAD>
4 </HEAD>
5 <BODY>
6 <% Set bc = Server.CreateObject(“MSWC.BrowserType”) %>
7 <TABLE BORDER=1>
8 <TR>
9 <TD>Browser</TD>
10 <TD> <%= bc.browser %> </TD>
11 <TR>
12 <TD>Version</TD>
13 <TD> <%= bc.version %> </TD>
14 </TR>
15 <TR>
16 <TD>Frames</TD>
17 <TD>
18 <% if (bc.frames = TRUE) then %> TRUE
19 <% else %> FALSE
20 <% end if %>
<TD>
21 </TR>
22 <TR>
23 <TD>Tables</TD>
24 <TD>
25 <% if (bc.tables = TRUE) then %> TRUE
26 <% else %> FALSE
27 <% end if %>
28 </TD>
29 </TR>
611
30 <TR>
31 <TD>BackgroundSounds</TD>
32 <TD>
33 <% if (bc.BackgroundSounds = TRUE) then %> TRUE
34 <% else %> FALSE
35 <% end if %> </TD>
36 </TR>
37 <TR>
38 <TD>VBScript</TD>
39 <TD>
40 <% if (bc.vbscript = TRUE) then %> TRUE
41 <% else %> FALSE
42 <% end if %>
43 </TD>
44 </TR>
45 <TR>
46 <TD>JScript</TD>
47 <TD>
48 <% if (bc.javascript = TRUE) then %> TRUE
49 <% else %> FALSE
50 <% end if %>
51 </TD>
52 </TR>
53 </TABLE>
54 </BODY>
55 </HTML>
Ao carregarmos este exemplo no Internet Explorer, obtemos o resultado indicado na Figura 10.14.
Ao carregarmos este mesmo exemplo no Nestcape Navigator, obtemos o resultado indicado

na Figura 10.15.
612
Figura 10.14: O arquivo capacidades.asp carregado no Internet Explorer.
Conforme podemos observar na Listagem 10.11, utilizamos uma série de propriedades do

objeto Browser Capabilities. Na Tabela 10.3 temos uma descrição das propriedades do objeto
Browser Capabilities.
Figura 10.15: O arquivo capacidades.asp carregado no Netscape Navigator.
613
Tabela 10.3 Propriedades do objeto Browser Capabilities.
ActiveXControls Retorna True se o navegador suporta controles
ActiveX.
Backgroundsounds Retorna True se o navegador suporta sons de
fundo.
Beta Retorna True se o navegador for uma versão Beta.
Browser Retorna o nome do navegador.
Cookies Retorna True se o navegador suporta Cookies.
Frames Retorna True se o navegador suporta Frames.
JScript Retorna True se o navegador suporta JScript.
Plataform Especifica a plataforma (Sistema Operacional),
no qual roda o navegador.
Tables Retorna True se o navegador suporta Tabelas.
VBScript Retorna True se o navegador suporta VBScript.
Version Retorna a versão do navegador.
Como um exemplo final, podemos utilizar este componente para detectar se o navegador é o
Internet Explorer ou o Netscape e, com base nesta informação, redirecionar o usuário para
uma página desenvolvida especificamente para cada um dos navegadores.
Na Listagem 10.12, temos este exemplo.
Listagem 10.12 – Utilizando o componente Browser Capabilities para redirecionar o usuário.

2 <HTML>
3 <HEAD>
4 </HEAD>
5 <BODY>
6 <% Set bc = Server.CreateObject(“MSWC.BrowserType”) %>
7 <% If bc.browser=“IE” Then

8 Response.Redirect(“paginaie.asp”)
614
9 ElseIf bc.browser=“Default” Then

10 Response.Redirect(“paginanetscape.asp”)
11 Else
12 Response.Redirect(“outros.asp”)
13 End If
14 %>
15 </BODY>
16 </HTML>
Ao carregarmos esta página no Internet Explorer, o servidor redireciona o usuário para a

página paginaie.asp. Na prática, será carregada a página paginaie.asp. Com isso a página
pode ser desenvolvida para utilizar quaisquer recursos do Internet Explorer.
Ao carregarmos esta página no Netscape Navigator, o servidor redireciona o usuário para a

página paginanetscape.asp. Na prática, será carregada a página paginanetscape.asp. Com isso
a página pode ser desenvolvida para utilizar quaisquer recursos do Netscape Navigator.
Ao carregarmos esta página em qualquer outro navegador, o servidor redireciona o usuário

para a página outros.asp. Na prática, será carregada a página outros.asp. Portanto, a página
deverá ser desenvolvida utilizando somente elementos que são padrão e comuns à maioria
dos navegadores.
Conclusão
Neste capítulo estudamos, detalhadamente, alguns componentes importantes na criação de
aplicativos Web, utilizando ASP e o IIS.
Iniciamos o capítulo por um estudo completo do objeto Server. Vimos todos os métodos e a
única propriedade deste objeto. Depois, foi apresentado um exemplo prático, o qual soluciona
um problema bastante comum na criação de aplicações Web: como tornar o nome de um
usuário ou produto em um link, para o registro do funcionário ou produto no banco de dados.
Com a utilização dos métodos do objeto Server foi simples a solução deste problema.
Depois, passamos a estudar uma série de componentes do IIS. Estudamos em detalhes, cada
um dos seguintes componentes:
➥ Content Link.
➥ Ad Rotator.
➥ Page Counter.
➥ Browser Capabilities.
615
Para cada um destes componentes foram apresentados exemplos completos, que ilustraram a
utilização e as capacidades dos mesmos.
No próximo capítulo estaremos tratando de alguns tópicos avançados na criação de aplicações

Web com ASP. Até lá então.
616
Capítulo 11 – Os Objetos FileSystemObject, Drive, Folder e File
Capítulo 11
Os Objetos FileSystemObject,
Drive, Folder e File
617
Introdução
Iniciaremos o capítulo por um estudo detalhado do objeto FileSystemObject. Este objeto nos
fornece uma série de recursos para acesso ao sistema de arquivos do servidor, através de
nossas páginas ASP.
Veremos uma série de métodos e uma propriedade que fazem parte deste objeto. Com a
utilização do objeto FileSystemObject podemos criar páginas ASP para execução de funções
administrativas, como por exemplo:
➥ Verificação do espaço disponível em disco e unidades da rede.
➥ Efetuar cópia de segurança entre unidades de disco.
➥ Verificar se determinadas unidades, como gravador de CD ou ZIP Drive, estão
disponíveis para uso.
➥ Fazer um levantamento do espaço utilizado em cada drive do sistema.
O objeto FileSystemObject é, com certeza, um dos que oferece o maior número de métodos.
Vamos estudar todos, detalhadamente. Também estudaremos alguns objetos derivados do
objeto FileSystemObject. Vamos estudar o objeto Drive e suas diversas propriedades. Um
pequeno exemplo de utilização destas propriedades será apresentado. Vamos estudar também
os objetos Folder e File suas diversas propriedades e métodos. Um pequeno exemplo de
utilização das propriedades de cada objeto será apresentado.
No final do capítulo, apresentaremos um exemplo prático que utiliza os diversos objetos que
foram mostrados neste capítulo.
O Objeto FileSystemObject
O objeto FileSystemObject nos fornece uma série de recursos para acesso ao sistema de arquivos
do servidor, através de nossas páginas ASP. Com os recursos oferecidos por este objeto, podemos
manipular arquivos de texto, pastas e drives a partir do código ASP.
Para criarmos um objeto do tipo FileSystemObject, podemos utilizar a seguinte sintaxe:

Set nome_objeto = Server.CreateObject(“Scripting.FileSystemObject”)
Por exemplo, podemos criar um objeto chamado fileobj:

Set fileobj = Server.CreateObject(“Scripting.FileSystemObject”)
Agora vamos passar ao estudo da propriedade e dos métodos deste objeto.
618
Propriedade do Objeto FileSystemObject

Temos uma única propriedade que é a propriedade Drives, a qual retorna todos os drives
disponíveis no servidor IIS onde a página está gravada, inclusive drives de rede mapeados.
Considere o próximo fragmento de código:

<%
‘ O primeiro passo é a criação do objeto FileSystemObject.
Set fileobj=Server.CreateObject(“Scripting.FileSystemObject”)
For each drive in fileobj.Drives

Response.Write drive & “<BR>”
Next
%>
Este fragmento produz a saída indicada na Figura 11.1:
Figura 11.1: Resultado produzido pelo uso da propriedade Drives.
Agora vamos passar ao estudo dos métodos do objeto FileSystemObject.
619
Métodos do Objeto FileSystemObject

Este objeto apresenta uma série de métodos, os quais facilitam o trabalho com drives, pastas
e arquivos. Por isso iremos dividir a apresentação dos métodos, conforme os mesmos se
destinam: ao trabalho com drives, pastas ou arquivos.
Métodos do Objeto FileSystemObject Para Trabalho com Drives

Temos três métodos para tratar com drives:
➥ O método DriveExist: Este método retorna True se o drive passado como parâmetro
existe e False caso contrário. O parâmetro passado para este método pode ser uma letra
de drive (inclusive de um drive mapeado), uma String de texto ou o caminho completo
para uma pasta ou arquivo.
Para drives de dispositivos removíveis, como um CD-ROM ou um ZIP Drive, este método
retorna True, mesmo que não exista uma mídia no drive.
NOTA
Podemos utilizar a propriedade IsReady do objeto Drive para determinar se o mesmo está
pronto para ser acessado. No exemplo do CD-ROM, podemos utilizar a propriedade IsReady
para determinar se existe ou não um CD-ROM no drive de CD. Aprenderemos a utilizar a
propriedade IsReady quando estudarmos o objeto Drive mais adiante neste capítulo.
A seguir temos um exemplo de utilização deste método:

<%
Set fileobj = CreateObject(“Scripting.FileSystemObject”)
If fileobj.DriveExists(“X:”) Then
Response.Write “Drive X: Existe !!”
Else
Response.Write “Drive X: Não Existe !!”
End If
%>
➥ O método GetDrive: Este método retorna um objeto do tipo Drive, correspondente ao
caminho passado como parâmetro. Podemos passar como parâmetro a identificação
de um drive, como por exemplo: “d”, “d:”, “d:\” ou um caminho para um drive da rede,
no tradicional formato \\nome_do_computador\nome_do_compartilhamento.
620
NOTA
Estudaremos o objeto Drive mais adiante neste capítulo.
A seguir temos um exemplo de utilização deste método:

<%
Set drive = fileobj.GetDrive(“E:”)
‘Agora vamos calcular o espaço livre no drive E:

espaco=(drive.freespace)/(1024*1024)
Response.Write “Espaço livre em E: ” & FormatNumber(espaco,0) & “ MB”
%>
Neste exemplo utilizamos a propriedade freespace do objeto Drive e a dividimos duas vezes
por 1024 para obter o espaço livre em MB. Depois utilizamos a função FormatNumber, para
exibir o valor obtido sem as casas decimais. O resultado deste trecho de código é algo do tipo:
Espaço livre em E: 1.070 MB
➥ O método GetDriveName: Este método retorna o nome do drive que foi passado como
parâmetro.
A seguir temos um exemplo de utilização deste método.

<%

Response.Write “Nome do drive: ” & fileobj.GetDriveName(drive) & “<BR>”
Next
%>
Com isso encerramos o estudo dos métodos para tratamento de drives.
Métodos do Objeto FileSystemObject Para Trabalho com Pastas

Temos dez métodos para tratar com pastas.
➥ Método BuildPath(caminho,nome): Este método adiciona o arquivo ou pasta
especificado no parâmetro nome à pasta especificada no parâmetro caminho. Caso
seja necessário, o método adiciona o separador de pastas “\”.
621

<%
novapasta = fileobj.BuildPath(“C:\”,“pasta123")
Response.Write novapasta
%>
Este fragmento produz a seguinte saída: C:\pasta123.
É importante observar que a pasta C:\pasta123 não será criada pela utilização deste método.
Apenas estamos atribuindo à variável novapasta, o caminho C:\pasta123. Para criar uma nova
pasta, podemos utilizar o método CreateFolder, que veremos logo adiante.
➥ O método CopyFolder “fonte”,“destino”,substituir: Copia uma ou mais pastas
especificadas no parâmetro fonte. Podemos copiar mais do que um pasta, pois podemos
utilizar caracteres curinga, como por exemplo C:\documentos\*. As pastas de origem
são copiadas para a pasta especificada pelo parâmetro destino. Todos os arquivos
contidos nas pastas de origem serão copiados para o destino. O parâmetro substituir é
opcional. Ele pode conter os valores True ou False. Este parâmetro especifica se arquivos
já existentes no destino devem ou não ser sobrescritos. Se a pasta de destino já existe
e o parâmetro substituir é definido em Falso, irá ocorrer um erro. O valor padrão para
o parâmetro substituir é True.
IMPORTANTE
Somente podemos utilizar caracteres curinga na parte final do caminho. Considere o seguinte
exemplo:
FileSystemObject.CopyFolder “C:\mydocuments\letters\*”, “C:\tempfolder\”
Porém o próximo exemplo está incorreto:

FileSystemObject.CopyFolder “C:\mydocuments\*\*”, “C:\tempfolder\”
Se a pasta de destino ainda não existe, será criada, e a pasta de origem e todo o seu conteúdo
serão copiados.
Se o parâmetro de destino for o nome de um arquivo existente, ocorrerá um erro.
Se o destino for o nome de uma pasta, o método tentará copiar a pasta de origem e todo o seu
conteúdo para a pasta de destino. Se um arquivo que está sendo copiado já existir na pasta de
destino e o parâmetro substituir estiver definido como False, irá ocorrer um erro. Caso contrário,
o arquivo do diretório de origem será copiado sobre o arquivo do diretório de destino.
622
O método CopyFolder pára na ocorrência do primeiro erro. Nenhuma tentativa de reverter as

alterações que já foram feitas será efetuada, isto é, os arquivos que foram copiados antes da
ocorrência do erro não serão eliminados da pasta de destino.

fileobj.CopyFolder “C:\meus documentos”,“C:\teste”
Esta linha de código irá copiar todo o conteúdo da pasta C:\meus documentos para a pasta
C:\teste. Caso a pasta C:\teste não exista, a mesma será automaticamente criada antes que a
cópia seja efetuada.
➥ O método CreateFolder(nomepasta): Este método cria uma pasta de acordo com o
parâmetro que foi passado para o mesmo. Caso a pasta já exista, será gerado um erro.
O exemplo a seguir, cria uma pasta chamada C:\teste123:

fileobj.CreateFolder(“C:\teste123”)
Caso a pasta já exista obteremos a mensagem de erro indicada na Figura 11.2.
Figura 11.2: Erro gerado pelo método CreateFolder quando a pasta já existe.
➥ O método DeleteFolder(pastaname,force): Este método elimina a pasta especificada no

parâmetro pastaname e todo o seu conteúdo. O parâmetro force pode ser True ou
False. Este parâmetro determina se o conteúdo de uma pasta, que possui o atributo de
somente leitura, é para ser deletado ou não. O valor padrão é False.
623
Será gerado um erro se a pasta especificada pelo parâmetro pastaname não for encontrada.
Este método encerra a sua execução na ocorrência do primeiro erro, sendo que as alterações
que já foram feitas não serão desfeitas.
fileobj.DeleteFolder(“C:\teste123”)
Este comando elimina a pasta C:\teste123.
Caso a pasta a ser eliminada não exista, obteremos a mensagem de erro indicada na Figura 11.3.
Figura 11.3: Erro gerado pelo método DeleteFolder quando a pasta não existe.
➥ O método FolderExists(nomepasta): Este método retorna True se a pasta passada como

parâmetro existe e False caso contrário. O parâmetro nomepasta pode conter um
caminho absoluto ou relativo.

<%
624

caminho=fileobj.BuildPath(drive,“\meus documentos”)
If fileobj.FolderExists(caminho) then
Response.Write “<B>Este drive possui a pasta Meus documentos<B> <HR>”
Else
Response.Write “<B>Este drive não possui a pasta Meus documentos
<B><HR>”
End If
Next
%>
Este fragmento produz o resultado indicado na Figura 11.4.
Figura 11.4: Utilizando o método FolderExists.
➥ O método GetAbsolutePathName(parâmetro): Este método recebe como parâmetro o

nome de uma pasta ou outra especificação de caminho válida, e retorna o caminho
completo para esta pasta, tendo como base a pasta atual. Por exemplo, se a pasta atual
625
for C:\meus documentos e o parâmetro passado para este método for “cartas”, o valor
de retorno será C:\meus documentos\cartas.
Vamos a mais alguns exemplos para esclarecer o comportamento deste método. Vamos supor
que a pasta atual é C:\meus documentos\cartas. Na Tabela 11.1 temos alguns exemplos de
retorno deste método.
Tabela 11.1 Valores de retorno do método GetAbsolutePathName.
Parâmetro Valor de retorno

“C:” “C:\meus documentos\cartas”
“C:..” “C:\meus documentos”
“C:\\\” “C:\”
“C:*.*\abril96” “C:\meus documentos\cartas\*.*\abril96”
“filial5” “C:\meus documentos\cartas\filial5”
➥ O método GetFolder(caminhopasta): Retorna um objeto do tipo Folder, correspondente

à pasta que foi passada como parâmetro. Ocorrerá um erro se a pasta, passada como
parâmetro, não existir. Estudaremos o objeto Folder em detalhes ainda neste capítulo.
<%
Set pasta=fileobj.GetFolder(“C:\meus documentos”)
For each subpasta in pasta.subfolders

Response.Write subpasta & “<HR>”
Next
%>
O resultado deste fragmento de código é indicado na Figura 11.5.
626
Figura 11.5: Utilizando o método GetFolder.
Observe que já utilizamos a coleção subfolders do objeto Folder. Conforme citado

anteriormente, estudaremos o objeto Folder em detalhes, ainda neste capítulo.
➥ O método GetParentFolderName(pasta): Este método retorna uma String com o nome
da pasta na qual está contido pasta ou arquivo passado como parâmetro. Este método
não faz a verificação para saber se a pasta existe ou não. Se a pasta ou arquivo já
estiver na raiz do drive, será retornada uma String de tamanho zero.
pastacontem = fileobj.GetParentFolderName(“C:\meus documentos\word”)
Este comando retorna na variável pastacontem a String: C:\meus documentos.

➥ O método GetSpecialFolder(folderespvalor): Retorna um objeto do tipo Folder,
correspondente a um dos tipos especiais de pasta do Windows. Os valores possíveis
para folderespvalor são os seguintes:
0 – Pasta do Windows.
1 – Pasta de Sistema.
2 – Pasta temporária.
627
Considere o exemplo a seguir:

<%
Set temppasta=fileobj.GetSpecialFolder(2)
%>
Com este fragmento de código, criamos um objeto do tipo Folder, o qual está ligado à pasta
temporária do Windows e pode ser acessado pela variável temppasta.
➥ O método MoveFolder(origem,destino): Move a pasta especificada no parâmetro origem,
para a pasta especificada no parâmetro destino. Podemos incluir caracteres curinga na
origem, porém não no destino.
Se a origem contém caracteres curinga ou o destino termina com o caractere “\”, o método
MoveFolder considera que o destino representa o nome de uma pasta já existente, para a qual
deve ser movida a pasta de origem. Caso contrário o método assume que o parâmetro destino
especifica o nome de uma pasta que deve ser criada e para a qual deve ser movido o conteúdo
da pasta de origem. Em ambos os casos, devemos considerar o seguinte:
1. Se a pasta de destino não existe, a pasta de origem será movida, sendo que a pasta de
destino será criada antes, pelo próprio método MoveFolder.
2. Se o parâmetro destino for o nome de um arquivo, será gerado um erro.
3. Se o parâmetro destino for o nome de uma pasta que já existe, será gerado um erro.
O método MoveFolder será interrompido na ocorrência do primeiro erro. Quaisquer alterações
que tenham sido feitas não serão revertidas.
fileobj.MoveFolder “C:\teste1”, “C:\teste2”
Com isso encerramos o estudo dos métodos para tratamento de Pastas.
Métodos do Objeto FileSystemObject Para Trabalho com Arquivos

Temos onze métodos para tratar com arquivos.
➥ Método CopyFile(origem,destino,substituir): Copia um ou mais arquivos especificados
pelo parâmetro origem (podemos utilizar caracteres curinga) para a pasta especificada
no parâmetro destino.
CopyFile considera que o destino representa o nome de uma pasta já existente, para a qual
628
devem ser copiados os arquivos especificados pelo parâmetro origem. Caso contrário o método
assume que o parâmetro destino especifica o nome de um arquivo que deve ser criado. Em
ambos os casos, devemos considerar o seguinte:
1. Se a pasta de destino não existe, os arquivos especificados no parâmetro origem serão
copiados, sendo que a pasta de destino será criada antes, pelo próprio método CopyFile.
2. Se o parâmetro destino for o nome de um arquivo que já existe, será gerado um erro
caso o parâmetro substituir esteja definido como False; caso contrário o arquivo existente
será substituído.
3. Se o parâmetro destino for o nome de uma pasta, será gerado um erro.
O método CopyFile será interrompido na ocorrência do primeiro erro. Quaisquer alterações

A seguir temos um exemplo de utilização do método CopyFile:

FileSystemObject.CopyFile “c:\meus documentos\oficios\*.doc”, “e:\copia de segurança\
oficios\”
➥ O método CreateTextFile(nomearquivo,substituir,unicode): Este método cria o arquivo
de texto especificado pelo parâmetro nomearquivo e retorna um objeto do tipo
TextStream, o qual pode ser utilizado para gravar informações no arquivo e ler
informações do arquivo.
O parâmetro substituir pode assumir os valores True ou False. Quando este parâmetro tiver o
valor True, se o arquivo já existir, o mesmo será eliminado e um novo arquivo será criado. O
padrão para o parâmetro substituir é False. Este parâmetro é opcional.
O parâmetro unicode pode assumir os valores True ou False. Se este parâmetro tiver o valor
True, o texto será salvo com caracteres unicode, os quais utilizam 2 bytes por caractere, ao
invés de 1 byte por caractere como é o caso do padrão ASCII. O valor padrão para o parâmetro
unicode é False. Este parâmetro é opcional.

<%
Set arqtexto = fileobj.CreateTextFile(“c:\teste.txt”,true)

arqtexto.WriteLine(“*************************”)
arqtexto.writeline(“LINHA 1 DO TEXTO”)
arqtexto.writeline(“*************************”)
%>
629
Este fragmento de código cria um objeto do tipo TextStream, o qual é associado à variável arqtexto.
Depois utilizamos o método writeline para escrever linhas de texto no arquivo c:\teste.txt.
Na Figura 11.6 temos o conteúdo do arquivo teste.txt, após a execução do código do nosso exemplo.
Figura 11.6: Utilizando o método CreateTextFile.
➥ O método DeleteFile(arquivo,force): Este método elimina um ou mais arquivos definidos

pelo parâmetro arquivo. Podem ser utilizados caracteres curinga. O parâmetro force
pode assumir os valores True ou False. Se o parâmetro force for definido como True, o
arquivo será eliminado mesmo se tiver o atributo de Somente leitura marcado. O valor
padrão do atributo force é False.
Se o arquivo especificado não for encontrado, será gerado um erro. O método DeleteFile será
interrompido na ocorrência do primeiro erro. Quaisquer alterações que tenham sido feitas
não serão revertidas.
fileobj.DeleteFile(“C:\meus documentos\oficio.doc”,true)
➥ O método FileExists(arquivo): Este método retorna True se o arquivo passado como
parâmetro existe, caso contrário o método irá retornar False.

<%
If fileobj.FileExists(“C:\meus documentos\relatorio.doc”) Then
Response.Write “O arquivo com o relatório já foi salvo na pasta Meus
documentos”
Else
Response.Write “O arquivo com o relatório ainda não foi salvo na pasta Meus
documentos”
End If
%>
630
➥ O método GetBaseName(arquivo): Este método retorna apenas o nome do arquivo

passado como parâmetro, sem a extensão ou qualquer informação de caminho.
<%
Response.Write fileobj.GetBaseName(“C:\meus documentos\vendas.xls”)
%>
Este comando retorna apenas vendas.

➥ O método GetExtensionName(arquivo): Este método retorna apenas a extensão do
arquivo passado como parâmetro. Uma String de tamanho zero “ ” será retornada se
o arquivo passado como parâmetro não for encontrado.
<%
Response.Write fileobj.GetExtensionName(“C:\meus documentos\vendas.xls”)
%>
Este comando irá retornar apenas xls.

➥ O método GetFile(arquivo): Este método retorna um objeto do tipo File e ligado ao
arquivo passado como parâmetro. Se o arquivo passado como parâmetro não existir,
será gerado um erro.
NOTA
Iremos estudar o objeto File em detalhes, ainda neste capítulo.
<%
Set arquivo=fileobj.GetFile(“C:\autoexec.bat”)
Response.Write “Caminho do arquivo: ” & arquivo.path & “<HR>”
Response.Write “Data de criação: ” & arquivo.DateCreated & “<HR>”
Response.Write “Data último acesso: ” & arquivo.DateLastAccessed & “<HR>”
%>
O resultado deste fragmento de código é indicado na Figura 11.7.
631
Figura 11.7: Utilizando o método GetFile.
NOTA
Observe que já utilizamos algumas propriedades do objeto File. Conforme descrito
anteriormente, iremos estudar este objeto ainda neste capítulo.
➥ O método GetFileName(caminho): Retorna o nome do último arquivo ou pasta que foi

especificado no parâmetro caminho. Por exemplo, se passarmos C:\meus
documentos\clientes.mdb como parâmetro será retornado clientes.mdb. Já se passarmos
C:\meus documentos, será retornado meus documentos. Se o parâmetro passado não
terminar com o nome de uma pasta ou arquivo, o método GetFileName retornará uma
String de tamanho zero “ ”.
NOTA
Este método não verifica se o caminho passado como parâmetro existe ou não.
➥ O método GetTempName( ): Retorna o nome de um arquivo ou pasta, nome este que é

gerado randomicamente. Este arquivo ou pasta pode ser utilizado para operações que
necessitam de um local de armazenamento temporário.
Este método não cria um arquivo temporário. Ele apenas gera um nome que pode ser utilizado
pelo método CreateTextFile, o qual pode ser usado para criar o arquivo.
<%
632
tempname=fileobj.GetTempName
Set txttemp=fileobj.CreateTextFile(tempname)
%>
➥ O método MoveFile(origem, destino): Este método pode ser utilizado para mover o
arquivo passado no parâmetro origem para a localização especificada no parâmetro
destino. Podemos utilizar caracteres curinga na origem, porém não no destino.
MoveFile considera que o destino representa o nome de uma pasta já existente, para a qual
deve ser movido o arquivo de origem. Caso contrário, o método assume que o parâmetro
destino especifica o nome de uma pasta e arquivo para o qual deve ser movido o arquivo de
origem. Em ambos os casos, devemos considerar o seguinte:
1. Se o destino não existe, o arquivo de origem será movido, sendo que a pasta de destino
será criada antes, pelo próprio método MoveFile.
2. Se o parâmetro destino for o nome de um arquivo existente, será gerado um erro.
3. Se o parâmetro destino for o nome de uma pasta, será gerado um erro.
O método MoveFile será interrompido na ocorrência do primeiro erro. Quaisquer alterações
<%
fileobj.MoveFile “C:\teste.txt”, “D:\documentos\teste.txt”
%>
➥ O método OpenTextFile(arquivo,iomode,create,format): Cria um arquivo com o nome
passado no parâmetro arquivo ou abre um arquivo existente. Este método retorna um
objeto do tipo TextStream que faz referência ao arquivo especificado pelo parâmetro arquivo.
O parâmetro iomode determina o tipo de acesso que teremos ao arquivo. Os valores permitidos
para este parâmetro são os seguintes:
1 – ForReading: Somente para leitura. Este é o valor padrão.
2 – ForWriting: Somente para escrita. Não podemos ler o conteúdo já existente.
8 – ForAppending: Abre o arquivo e grava informações no final do mesmo.
Se o parâmetro create for definido como True quando tentarmos escrever ou adicionar
(Appending) conteúdo a um arquivo que não existe, um novo arquivo será criado. O valor
padrão para este parâmetro é False.
633
O parâmetro format pode assumir os seguintes valores:

0 – TristateFalse: Abre o arquivo como sendo ASCII. É o valor padrão.
-1 – TristateTrue: Abre o arquivo como sendo Unicode.
-2 – TristateUseDefault: Abre o arquivo utilizando o formato padrão do sistema.
<%
Set arquivo = fileobj.OpenTextFile(“C:\testfile.txt”, ForWriting, True)
%>
Com isso finalizamos o estudo dos métodos relacionados com arquivos e também o estudo
do objeto FileSystemObject. Agora iniciaremos o estudo dos objetos Drive, Folder e File.
O Objeto Drive
Para criar um objeto do tipo Drive, utilizamos o método GetDrive do objeto FileSystemObject,
conforme descrito anteriormente.
No exemplo a seguir, criamos um objeto do tipo Drive, chamado driveobj:

<%
Set driveobj = fileobj.GetDrive(“D:”)
%>
Agora podemos ter acesso a todas as propriedades do objeto driveobj. Então vamos ao estudo
destas propriedades.
Propriedades do Objeto Drive

Na Tabela 11.2 temos uma descrição das propriedades do objeto Drive.
Tabela 11.2 Propriedades do objeto Drive.
AvailableSpace Retorna a quantidade de espaço livre, disponível no drive
para o usuário. Esta propriedade leva em consideração a
definição de quotas de disco e outras restrições que podem
634
ser impostas pelo Windows 2000. O valor retornado é
em bytes. Caso não existam definição de quotas ou
outras restrições, esta propriedade retornará o mesmo
valor que a propriedade FreeSpace.
DriveLetter Retorna a letra do drive.
DriveType Retorna o tipo do drive. Os valores de retorno são os
seguintes: Desconhecido (0), Removível (1), Fixo (2),
Rede (3), CD-Rom (4) e RamDisk (5). Esta propriedade
retorna o valor numérico, isto é, 0, 1, 2, 3, 4 ou 5.
FileSystem Retorna o tipo de sistema de arquivo que está sendo
utilizado. Os valores possíveis são: FAT, FAT32, NTFS
ou CDFS.
FreeSpace Retorna a quantidade total de espaço livre, disponível
no drive. O valor retornado é em bytes.
IsReady Retorna True se o drive está pronto para ser usado e False
em caso contrário. Por exemplo, se um drive de CD-Rom
estiver sem CD esta propriedade irá retornar False.
Path Retorna o caminho para o drive, no seguinte formato C:,
D:, etc.
RootFolder Retorna um objeto do tipo Folder, o qual representa a
pasta raiz do drive.
SerialNumber Retorna um número serial, utilizado para identificar de
maneira única o drive.
ShareName Retorna o nome do compartilhamento de rede para o
drive, se o mesmo for um drive de rede.
TotalSize Retorna o tamanho total do drive em bytes.
VolumeName Pode ser utilizado para definir ou retornar o Label do
drive.
Na Listagem 11.1, podemos ver um exemplo de utilização das propriedades do objeto Drive.
635
Listagem 11.1 – Utilizando as propriedades do objeto Drive.

2 <HTML>
3 <HEAD>
4 <TITLE>Utilizando o objeto Drive. </TITLE>
5 </HEAD>
6 <BODY>
7 <%
8 ‘ O primeiro passo é a criação do objeto FileSystemObject.

9 Set fileobj=Server.CreateObject(“Scripting.FileSystemObject”)
10 <HR>
11 <%
12 Set objdrive=fileobj.GetDrive(“D:”)
13 Response.Write “Espaço disponível em D para o usuário atual:<B> ” & objdrive.
AvailableSpace & “</B><BR>”
14 Response.Write “Letra do drive D:<B> ” & objdrive.DriveLetter & “</B><BR>”
15 Response.Write “Tipo do drive D: <B>” & objdrive.DriveType & “</B><BR>”
16 Response.Write “Sistema de arquivos do drive D:<B> ” & objdrive.FileSystem &
“</B><BR>”
17 Response.Write “Espaço livre em D:<B> “ & objdrive.FreeSpace & “</B><BR>”
18 Response.Write “O drive D: pode ser usado? <B>” & objdrive.IsReady & “</B><BR>”
19 Response.Write “Caminho para o drive D: —><B>” & objdrive.Path & “</B><BR>”
20 Response.Write “Pasta raiz para o drive D: <B>” & objdrive.RootFolder & “</B><BR>”
21 Response.Write “Número Serial do drive D: <B>” & objdrive.SerialNumber & “</B><BR>”
22 Response.Write “Espaço total do drive D: <B>” & objdrive.TotalSize & “ bytes</B><BR>”
23 Response.Write “Nome do drive D: <B>” & objdrive.VolumeName & “</B><BR>”
24 %>
25 <HR>
26 </BODY>
27 </HTML>
Ao carregarmos esta página, obteremos os resultados indicados na Figura 11.8.
636
Figura 11.8: Utilizando as propriedades do objeto Drive.
Com isso encerramos o estudo do objeto Drive. Agora vamos ao estudo do objeto Folder.
O Objeto Folder
Para criar um objeto do tipo Folder, utilizamos o método GetFolder ou o método
GetSpecialFolder do objeto FileSystemObject, conforme descrito anteriormente. Um objeto
do tipo Folder também é retornado pela propriedade RootFolder do objeto Drive.
No exemplo a seguir, criamos um objeto do tipo Folder, chamado folderobj:

<%
Set folderobj = fileobj.GetFolder(“D:\meus documentos”)
%>
Agora podemos ter acesso a todas as propriedades e métodos do objeto folderobj. Então vamos
ao estudo destas propriedades e métodos.
637
Propriedades do Objeto Folder

Na Tabela 11.3, temos uma descrição das propriedades do objeto Folder.
Tabela 11.3 Propriedades do objeto Folder.
Attributes Pode ser utilizada para definir ou retornar os atributos
para a pasta. Os valores possíveis são os seguintes:
0 - Arquivo normal, sem nenhum atributo definido;
1 - Somente leitura; 2- Arquivo oculto; 4 - Arquivo de
sistema; 8 - Label do drive; 16 - Pasta ou subpasta;
32 - Indica se o arquivo foi alterado desde o último
backup; 64 - Link ou atalho e 128 - Arquivo compactado.
DateCreated Retorna a data e a hora de criação da pasta.
DateLastAccessed Retorna a data e a hora da última vez que a pasta foi
acessada.
DateLastModified Retorna a data e a hora da última vez que a pasta foi
modificada.
Drive Retorna a letra do drive onde está a pasta.
Files Retorna uma coleção, a qual contém todos os arquivos
existentes no objeto Folder.
IsRootFolder Retorna True se a pasta for a raiz do drive e False caso
contrário.
Name Pode ser utilizada para definir ou retornar o nome da pasta.
ParentFolder Retorna um objeto Folder que é o objeto de nível
superior para a pasta, isto é, é a pasta dentro da qual a
pasta atual encontra-se. Por exemplo, para a pasta
C:\documentos\cartas, a pasta de nível superior é
C:\documentos. Em inglês o termo é conhecido como
“Parent Folder”.
Path Retorna o caminho completo para a pasta, inclusive
utilizando nomes longos.
ShortName Retorna o nome no formato antigo 8.3 da época do DOS.
638
ShortPath Retorna o caminho completo no formato antigo da
época do DOS, sem a utilização de nomes longos.
Size Retorna o tamanho total da pasta, incluindo todos os
seus arquivos e subpastas.
SubFolders Retorna uma coleção, a qual contém todas as subpastas,
inclusive as subpastas ocultas e de sistema.
Type Retorna uma String que é a descrição do tipo da pasta.
No exemplo da Listagem 11.2, podemos ver um exemplo de utilização das propriedades do

objeto Folder.
Listagem 11.2 – Utilizando as propriedades do objeto Folder.

2 <HTML>
3 <HEAD>
4 <TITLE>Utilizando o objeto Folder. </TITLE>
5 </HEAD>
6 <BODY>
7 <%
10 %>
11 <HR>
12 <%
13 Set objfolder=fileobj.GetFolder(“C:\meus documentos”)
14 Response.Write “Atributos de C:\Meus documentos:<B> ” & objfolder.Attributes &
“</B><BR>”
15 Response.Write “Data e hora de criação de C:\Meus documentos:<B> ” & objfolder.
DateCreated & “</B><BR>”
16 Response.Write “Data e hora do último acesso à C:\Meus documentos:<B> ” &objfolder.
DateLastAccessed & “</B><BR>”
17 Response.Write “Data e hora da última modificação em C:\Meus documentos:<B> ” &
objfolder.DateLastModified & “</B><BR>”
639
18 Response.Write “A pasta C:\Meus documentos está no drive:<B> ” & objfolder.Drive

& “</B><BR>”
19 Response.Write “A pasta C:\Meus documentos é raiz? <B> ” & objfolder.
IsRootFolder & “</B><BR>”
20 Response.Write “Nome da pasta C:\Meus documentos:<B> ” & objfolder.Name & “</B>
<BR>”
21 Response.Write “Parent Folder de C:\Meus documentos:<B> ” & objfolder.
ParentFolder & “</B><BR>”
22 Response.Write “Path de C:\Meus documentos:<B> ” & objfolder.Path & “</B><BR>”
23 Response.Write “Nome curto de C:\Meus documentos:<B> ” & objfolder.ShortName & “</B>
<BR>”
24 Response.Write “Nome curto do caminho de C:\Meus documentos:<B> ” & objfolder.
ShortPath & “</B><BR>”
25 Response.Write “Tamanho total de C:\Meus documentos:<B> ” & objfolder.Size & “
bytes</B><BR>”
26 Response.Write “Tipo de C:\Meus documentos:<B> ” & objfolder.Type & “</B><BR>”
28 Response.Write “SUBPASTAS DA PASTA C:\MEUS DOCUMENTOS <HR>”
29 For each pasta in objfolder.subfolders

30 Response.Write “Pasta de C:\meus documentos: <B><I>” & pasta & “</B></I><BR>”
31 Next
33 Response.Write “ARQUIVOS DA PASTA C:\MEUS DOCUMENTOS <HR>”
34 For each arquivo in objfolder.Files

35 Response.Write “Arquivo de C:\meus documentos: <B><I>” & arquivo &
“</B></I><BR>”
36 Next
37 %>
38 </BODY>
39 </HTML>
A Figura 11.9 mostra a parte inicial do resultado desta página ao ser carregada no Internet
Explorer.
640
Figura 11.9: Utilizando as propriedades do objeto Drive.
Na Figura 11.10 vemos uma parte do resultado, onde são exibidos os elementos da coleção Files.
Figura 11.10: A coleção Files do objeto Folder.
641
Métodos do Objeto Folder

O objeto Folder possui quatro métodos.
➥ Método Copy(destino,substituir): Este método copia o objeto Folder atual, para o local
especificado no parâmetro destino.
Se o destino termina com o caractere “\”, o método Copy considera que o destino representa
o nome de uma pasta já existente, para a qual deve ser copiada a pasta representada pelo
objeto Folder. Caso contrário o método assume que o parâmetro destino especifica o nome
completo de uma nova pasta que deve ser criada.
O parâmetro substituir pode assumir os valores True ou False. O valor padrão é True. Se a
pasta especificada no parâmetro destino já existe e o parâmetro substituir estiver definido em
False, ocorrerá um erro.
<%
Set folderobj = fileobj.GetFolder(“D:\meus documentos”)
folderobj.copy(“E:\meus documentos”,true)
%>
➥ O método CreateTextFile(nomearquivo,substituir,unicode): Este método cria o arquivo
de texto especificado pelo parâmetro nomearquivo e retorna um objeto do tipo
TextStream, o qual pode ser utilizado para gravar informações no arquivo e ler
informações do arquivo.
O parâmetro substituir pode assumir os valores True ou False. Quando este parâmetro tiver o
valor True, se o arquivo já existir o mesmo será eliminado e um novo arquivo será criado. O
padrão para o parâmetro substituir é False. Este parâmetro é opcional.
O parâmetro unicode pode assumir os valores True ou False. Se este parâmetro tiver o valor
True, o texto será salvo com caracteres unicode, os quais utilizam 2 bytes por caractere, ao
invés de 1 byte por caractere como é o caso do padrão ASCII. O valor padrão para o parâmetro
unicode é False. Este parâmetro é opcional.

<%
Set folder=fileobj.GetFolder(“C:\”)
Set arqtexto = folder.CreateTextFile(“C:\teste.txt”,true)
arqtexto.WriteLine(“*************************”)
642
arqtexto.writeline(“*************************”)
%>
Este fragmento de código cria um objeto do tipo TextStream, o qual é associado à variável
arqtexto. Depois utilizamos o método writeline para escrever linhas de texto no arquivo
C:\teste.txt.
Na Figura 11.11 temos o conteúdo do arquivo teste.txt, após a execução do código do nosso
exemplo.
Figura 11.11: Utilizando o método CreateTextFile do objeto Folder.
➥ O método Delete(force): Este método elimina a pasta associada com o objeto Folder e
todo o seu conteúdo, isto é, arquivos e subpastas. O parâmetro force pode assumir os
valores True ou False. Se o parâmetro force for definido como True, a pasta será
eliminada mesmo se a mesma ou qualquer um de seus arquivos ou subpastas, tiver o
atributo de Somente leitura marcado. O valor padrão do atributo force é False.
folderobj.Delete(True)
➥ O método Move destino: Move a pasta e todo o seu conteúdo, para a pasta especificada
no parâmetro destino.
Se o destino termina com o caractere “\”, o método Move considera que o destino representa
o nome de uma pasta já existente, para a qual deve ser movida a pasta. Caso contrário o
método assume que o parâmetro destino especifica o nome de uma nova pasta que deve ser
criada e para a qual deve ser movido o conteúdo da pasta de origem.
Caso a pasta de destino já exista, ocorrerá um erro.
643
folderobj.Move “C:\copia de seguranca\documentos”
Com isso, encerramos o estudo do objeto Folder. Agora vamos ao estudo do objeto File.
O Objeto File
Para criar um objeto do tipo File, utilizamos o método GetFile do objeto FileSystemObject,
conforme descrito anteriormente.
No exemplo a seguir, criamos um objeto do tipo File, chamado arqobj:

<%
Set arqobj = fileobj.Getfile(“C:\meus documentos\nwind.mdb”)
%>
Agora podemos ter acesso a todas as propriedades e métodos do objeto arqobj. Então vamos
ao estudo destas propriedades e métodos.
Propriedades do Objeto File

Na Tabela 11.4 temos uma descrição das propriedades do objeto File.
Tabela 11.4 Propriedades do objeto File.
Attributes Pode ser utilizada para definir ou retornar os atributos
para o arquivo. Os valores possíveis são os seguintes:
0 - Arquivo normal, sem nenhum atributo definido;
1 - Somente leitura; 2- Arquivo oculto; 4 - Arquivo de
sistema; 16 - Pasta ou subpasta; 32 - Indica se o arquivo
foi alterado desde o último backup; 1024 - Link ou
atalho e 2048 - Arquivo compactado.
DateCreated Retorna a data e a hora de criação do arquivo.
DateLastAccessed Retorna a data e a hora da última vez que o arquivo foi
acessado.
DateLastModified Retorna a data e a hora da última vez que o arquivo foi
modificado.
644
Drive Retorna a letra do drive onde está o arquivo.
Name Pode ser utilizada para definir ou retornar o nome do
arquivo.
ParentFolder Retorna um objeto Folder que é o objeto de nível
superior para o arquivo, ou seja, é a pasta dentro da
qual o arquivo encontra-se. Por exemplo, para o arquivo
C:\documentos\nwind.mdb, a pasta de nível superior é
C:\documentos. Em inglês o termo é conhecido como
“Parent Folder”.
Path Retorna o caminho completo para o arquivo, inclusive
utilizando nomes longos.
ShortName Retorna o nome no formato antigo 8.3 da época do DOS.
ShortPath Retorna o caminho completo no formato antigo da
época do DOS, sem a utilização de nomes longos.
Size Retorna o tamanho total do arquivo em bytes.
Type Retorna uma String que é a descrição do tipo do arquivo,
como por exemplo Documento do Word para um
arquivo .doc.
No exemplo da Listagem 11.3, podemos ver um exemplo de utilização das propriedades do

objeto File.
Listagem 11.3 – Utilizando as propriedades do objeto File.

2 <HTML>
3 <HEAD>
4 <TITLE>Utilizando o objeto File. </TITLE>
5 </HEAD>
6 <BODY>
7 <%

645
10 %>
11 <HR>
12 <%
13 Set arqobj=fileobj.GetFile(“C:\meus documentos\nwind.mdb”)
14 Response.Write “Atributos de nwind.mdb:<B> ” & arqobj.Attributes & “</B><BR>”

15 Response.Write “Data e hora de criação de nwind.mdb:<B> ” & arqobj.DateCreated &
“</B><BR>”
16 Response.Write “Data e hora do último acesso a nwind.mdb:<B> ” &
arqobj.DateLastAccessed & “</B><BR>”
17 Response.Write “Data e hora da última modificação em nwind.mdb:<B> ” &
arqobj.DateLastModified & “</B><BR>”
18 Response.Write “O arquivo nwind.mdb está no drive:<B> ” & arqobj.Drive &
“</B><BR>”
19 Response.Write “Nome do arquivo nwind.mdb:<B> ” & arqobj.Name & “</B><BR>”
20 Response.Write “Parent Folder do arquivo nwind.mdb:<B> ” & arqobj.ParentFolder &
“</B><BR>”
21 Response.Write “Path do arquivo nwind.mdb:<B> ” & arqobj.Path & “</B><BR>”
22 Response.Write “Nome curto do arquivo nwind.mdb:<B> ” & arqobj.ShortName &
“</B><BR>”
23 Response.Write “Nome curto do caminho de C:\Meus documentos\nwind.mdb:<B> ” &
arqobj.ShortPath & “</B><BR>”
24 Response.Write “Tamanho total do arquivo nwind.mdb:<B> ” & arqobj.Size &
“bytes</B><BR>”
25 Response.Write “Tipo do arquivo nwind.mdb:<B> ” & arqobj.Type & “</B><BR>”
27 %>
28 </BODY>
29 </HTML>
A Figura 11.12 mostra a página da Listagem 11.3 carregada no Internet Explorer.
646
Figura 11.12: Utilizando as propriedades do objeto File.
Métodos do Objeto File

O objeto File possui quatro métodos.
➥ Método Copy(destino,substituir): Este método copia o objeto File atual, para o local
especificado no parâmetro destino.
Se o destino termina com o caractere “\”, o método Copy considera que o destino representa
o nome de uma pasta já existente, para a qual deve ser copiado o arquivo representado pelo
objeto File. Caso contrário o método assume que o parâmetro destino especifica o nome
completo de um novo arquivo a ser criado.
O parâmetro substituir pode assumir os valores True ou False. O valor padrão é True. Se o
arquivo especificado no parâmetro destino já existe e o parâmetro substituir estiver definido
em False, ocorrerá um erro.
<%
Set arqobj = fileobj.GetFile(“C:\meus documentos\nwind.mdb”)
arqobj.copy(“E:\backup\nwind.mdb”,true)
%>
647
➥ O método Delete(force): Este método elimina o arquivo associado com o objeto File. O
parâmetro force pode assumir os valores True ou False. Se o parâmetro force for definido
como True, o arquivo será eliminado mesmo que tenha o atributo de Somente leitura.
O valor padrão do atributo force é False.
arqobj.Delete(True)
➥ O método Move destino: Move o arquivo para a pasta especificada no parâmetro destino.
Se o destino termina com o caractere “\”, o método Move considera que o destino representa o
nome de uma pasta já existente, para a qual deve ser movido o arquivo. Caso contrário o método
assume que o parâmetro destino especifica o nome de um novo arquivo que deve ser criado.
Caso o arquivo especificado pela parâmetro destino já exista, ocorrerá um erro.
arqobj.Move “C:\copia de seguranca\”
➥ O método OpenAsTextStream (iomode,format): Abre o arquivo associado ao objeto
File. Este método retorna um objeto do tipo TextStream que faz referência ao arquivo
ligado ao objeto File.
O parâmetro iomode determina o tipo de acesso que teremos ao arquivo. Os valores permitidos
para este parâmetro são os seguintes:
1 – ForReading: Somente para leitura. Este é o valor padrão.
2 – ForWriting: Somente para escrita. Não podemos ler o conteúdo já existente.
8 – ForAppending: Abre o arquivo e grava informações no final do mesmo.
O parâmetro format pode assumir os seguintes valores:

0 – TristateFalse: Abre o arquivo como sendo ASCII. É o valor padrão.
-1 – TristateTrue: Abre o arquivo como sendo Unicode.
-2 – TristateUseDefault: Abre o arquivo utilizando o formato padrão do sistema.
<%
Set arqobj = fileobj.GetFile(“C:\testfile.txt”)
arqobj.OpenAsTextStream(1,0)
%>
Este exemplo abre o arquivo C:\testfile.txt como somente leitura e no formato ASCII.
648
Com isso encerramos o estudo do objeto File. Agora vamos a um exemplo prático de aplicação
do que nos aprendemos neste capítulo.
Exemplo Prático
Neste exemplo vamos considerar o problema a seguir.
Temos uma pasta virtual no servidor IIS chamada informativos. Dentro desta pasta colocamos
diariamente informativos, que são numerados: inf01.htm, inf02.htm e assim por diante. Dentro
da pasta informativos existe, também, um arquivo index.asp que apresenta uma tabela com
todos os informativos disponíveis. Porém não queremos atualizar esta tabela manualmente.
Desejamos que cada vez que um novo arquivo seja salvo na pasta informativos, o mesmo,
automaticamente apareça na tabela de informativos do arquivo index.asp. O nosso trabalho
será construir a página index.asp, de tal maneira que a mesma seja capaz de ler e identificar
os arquivos inf01.htm, inf02.htm, etc. existentes, e criar uma tabela com um link para todos
estes arquivos. Além disso esta tabela deve exibir um máximo de seis colunas. Então, mãos à
obra, vamos pôr os objetos que aprendemos neste capítulo para funcionar.
Na Listagem 11.4, temos a solução para o problema proposto.
Listagem 11.4 – Gerando uma tabela de conteúdo automaticamente.

2 <HTML>
3 <HEAD>
4 </HEAD>
5 <BODY>
6 <P align=center><FONT size=4><B>INFORMATIVOS da Empresa ABC Ltda.

7 </B></FONT>
8 </P>
9 <HR>
10 <%
11 ‘Crio um objeto do tipo FileSystemObject.
13 ‘Crio um objeto do tipo Folder, utilizando o método GetFolder.

14 Set informativos = fileobj.GetFolder(“E:\inetpub\wwwroot\informativos”)
649
15 ‘Agora posso utilizar a coleção files do objeto

16 ‘Folder para percorrer todos os arquivos da pasta
17 ‘E:\inetpub\wwwroot\informativos
18 linha=0
19 Response.Write “<TABLE border=1>”
20 For each arquivo in informativos.Files
21 If arquivo.name<>“index.asp” then
22 If linha=0 Then
24 End If
25 Response.Write “<TD><A HREF=http://servidor/informativos/” & arquivo.name
& “>” & Left(arquivo.name,5) & “</TD>”
26 linha=linha+1
27 If linha=6 Then
28 Response.Write “</TR>”
29 linha=0
30 End If
31 End If
32 Next
33 Response.Write “</TABLE>”
34 %>
35 </BODY>
36 </HTML>
Neste exemplo criamos um objeto do tipo FileSystemObject, depois utilizamos o método

GetFile para obter um objeto do tipo Folder. O nosso objeto Folder está ligado à pasta
E:\inetpub\wwwroot\informativos, que é justamente onde estão os informativos do nosso
problema.
Depois, utilizamos a coleção Files do objeto Folder, para acessar todos os arquivos desta pasta.
Também fizemos uso de uma variável auxiliar – linha. Está variável é utilizada para que possamos
exibir seis links por linha. Além disso fizemos uso da propriedade nome para cada um dos
arquivos, de tal maneira que sejam exibidos apenas os nomes dos arquivos, e não o caminho
completo. Por exemplo, ao invés de exibirmos E:\inetpub\wwwroot\informativos\inf01.htm,
650
utilizando a propriedade name, exibimos apenas inf01.htm. Mas, além disso, fizemos uso da
função Left(arquivo.nome,5), de tal maneira que fosse exibido apenas o nome do arquivo (cinco
primeiros caracteres), sem a extensão. Desta forma é exibido apenas inf01.
Conforme podemos ver na Figura 11.13, existem 20 informativos na pasta E:\inetpub\

wwwroot\informativos.
Figura 11.13: Existem 20 informativos na pasta de informativos.
Na Figura 11.14, vemos o resultado ao carregar o arquivo index.asp.
Figura 11.14: O arquivo index.asp monta a tabela de links automaticamente.
651
Agora toda vez que um novo informativo for gravado na pasta informativos, o usuário, ao
carregar a página index.asp, já verá o link para o novo informativo. Por exemplo, vamos
supor que foram adicionados os informativos inf21.htm e inf22.htm. Bastaria recarregar a
página index.asp que o link para os dois novos informativos já seriam, automaticamente,
exibidos, conforme indicado na Figura 11.15.
Figura 11.15: Exibindo os links para os novos informativos.
Conclusão
Neste capítulo fizemos um estudo completo do objeto FileSystemObject e de seus derivados,
tais como os objetos Drive, Folder e File.
Com o entendimento destes objetos podemos construir aplicações bastante interessantes

utilizando ASP. Desde funções administrativas, tais como gravar informações em um arquivo
de Log, monitorar a ocupação de espaço de diversos drives, até a criação dinâmica de links
conforme o exemplo mostrado no item anterior.
Com certeza o objeto FileSystemObject é um dos mais complexos devido ao grande número
de métodos e objetos derivados que o mesmo apresenta. Porém, conforme podemos constatar
no decorrer deste capítulo, é extremamente simples sua utilização.
652
Alguns cuidados devem ser tomados, principalmente, com métodos que movem ou eliminam
arquivos, pois se ocorrem erros, o método terá a execução suspensa na ocorrência do primeiro
erro e modificações que já tenham sido feitas não serão revertidas.
Por exemplo, se estivermos movendo uma pasta e todas as suas subpastas de uma localização
para outra e ocorrer um erro no meio do processo, alguns arquivos terão sido movidos e outros
não. Aqueles que foram movidos não serão restaurados ao local de origem. Por isso, sempre é
uma boa idéia testar a página ASP que utiliza estes métodos em um ambiente de testes, para
somente depois colocá-las em produção. Aliás, ter um ambiente específico para testes é uma
excelente idéia não só no desenvolvimento para a Web, mas em qualquer tipo de desenvolvimento
de software.
No capítulo final deste livro estudaremos uma série de técnicas adicionais que auxiliam e
facilitam a criação e a padronização no desenvolvimento de páginas ASP.
653
Capítulo 12 – Tratamento de Erros, Transações e Outros Assuntos
Capítulo 12
Tratamento de Erros,
Transações e Outros Assuntos
655
No início deste capítulo aprenderemos um pouco sobre tratamento de erro em ASP.

Apresentaremos o objeto ASPError, bem como algumas dicas e técnicas para o tratamento de
erros em páginas ASP.
O tratamento de erros é uma das partes mais importantes de qualquer aplicação. Porém,
muitas vezes, é simplesmente ignorado, ou não é feito como deveria ser. Sem um tratamento
de erro adequado, a aplicação retorna mensagens pouco elucidativas, ou simplesmente pára
de funcionar. Com o tratamento de erros, tratamos situações de exceção, procurando prever o
maior número possível de casos que podem gerar erros. Além de prever estas situações,
escrevemos código para tratá-las adequadamente.
Um dos exemplos clássicos de tratamento de erro é o de validação dos dados de um formulário.

Vamos supor que tenhamos criado um formulário para cadastro de clientes. Este formulário
irá gravar um registro em uma tabela de um banco de dados do Microsoft Access. Vamos
supor que os campos Nome e CPF tenham sido definidos como obrigatórios no banco de
dados, isto é, o Microsoft Access não irá aceitar que estes campos sejam deixados em branco.
Se não fizermos a validação dos dados do formulário, antes de tentar gravar o registro no
banco de dados, pode acontecer de o usuário ter deixado um dos campos obrigatórios em
branco. Neste caso, ao tentar gravar o registro no banco de dados, será retornada uma página
com uma mensagem de erro técnica do tipo: Erro Driver ODBC 840c..... Para usuário comum,
esta mensagem de erro é “grego”. O ideal é escrevermos código para verificar se todos os
campos obrigatórios foram digitados. Caso algum campo obrigatório não tenha sido preenchido,
devolvemos o formulário para o usuário, indicando qual o campo obrigatório que está faltando
e mantendo os demais valores já digitados. Com isso o usuário pode preencher o valor que
está faltando e salvar o registro sem maiores problemas.
NOTA
Implementamos esta técnica de validação de campos em um formulário, em um exemplo do
Capítulo 6.
Com isso podemos notar que um correto tratamento de erros torna os nossos aplicativos Web
mais “amigáveis” e fáceis de trabalhar. Sempre que possível devemos evitar situações onde o
usuário recebe mensagens de erro técnicas, enviadas pelo servidor. Sempre que possível
devemos introduzir código para tratamento destes erros, de tal forma que os mesmos possam
ser interceptados e, se não corrigidos a tempo, pelo menos possamos enviar uma mensagem
mais “amigável”, para que o usuário saiba onde está o problema.
Na seqüência aprenderemos sobre o conceito de transações e o Microsoft Transaction Services.

Veremos que a utilização do conceito de transações garante que nossas aplicações Web tenham
acesso a dados mais depurados e livres de erros.
656
Na parte final do capítulo estaremos tratando de assuntos diversos, tais como a utilização da
diretiva #include e também o uso de diretivas como @CODEPAGE e @TRANSACTION.
O Objeto ASPError
O objeto ASPError é uma das novidades da versão 3.0 do ASP. Para obtermos um objeto do
tipo ASPError, utilizamos o método GetLastError do objeto Server. O objeto ASPError, através
de suas diversas propriedades, nos fornece uma série de informações a respeito do último
erro ocorrido em nossa aplicação Web.
NOTA
Quando o IIS encontrar um erro ao compilar ou executar um arquivo .asp, ele gerará um erro
personalizado 500;100. Por padrão, todos os aplicativos e sites da Web irão transferir o
processamento de um erro personalizado 500;100 para o arquivo .asp padrão. Após a geração
de um erro personalizado 500;100, o IIS também criará uma instância do objeto ASPError que
descreverá a condição de erro.
Antes de apresentarmos um exemplo de utilização, vamos estudar as propriedades do objeto ASPError.
Propriedades do Objeto ASPError

Para utilizar as propriedades do objeto ASPError, utilizamos a sintaxe padrão para acesso às
propriedades, conforme indicado a seguir:
nome_objeto.Nome_propriedade
Na Tabela 12.1, temos a descrição de todas as propriedades do objeto ASPError.
Tabela 12.1 Propriedades do objeto ASPError.
ASPCode Retorna um número inteiro, correspondente ao número do
erro gerado pelo IIS.
ASPDescription Retorna uma descrição mais detalhada a respeito do erro.
Category Retorna a origem do erro. Por exemplo, se foi o código ASP,
a linguagem de Script ou um determinado objeto.
Column Retorna a coluna exata onde ocorreu o erro, na linha
do erro.
657
Description Retorna uma descrição resumida do erro.
File Retorna o nome do arquivo que estava sendo processado
quando ocorreu o erro.
Line Retorna um número inteiro indicando a linha de
ocorrência do erro.
Number Retorna um código de erro do padrão COM.
Source Retorna, quando possível, o código da linha que causou
o erro.
No fragmento de código a seguir, utilizamos as diversas propriedades do objeto ASPError.

<%
Set objerro=Server.GetLastError
Response.Write “DESCRIÇÃO DO ÚLTIMO ERRO:<HR>”
Response.Write objerro.ASPCode & “<BR>”
Response.Write objerro.ASPDescription & “<BR>”
Response.Write objerro.Category & “<BR>”
Response.Write objerro.Column & “<BR>”
Response.Write objerro.Description & “<BR>”
Response.Write objerro.File & “<BR>”
Response.Write objerro.Line & “<BR>”
Response.Write objerro.Number & “<BR>”
Response.Write objerro.Source & “<BR>”
%>
Algumas Dicas Para Minimizar Erros

Além do tratamento de erros que é fundamental para qualquer aplicação, devemos levar em
consideração algumas técnicas que podem minimizar a geração de erros. Neste item daremos
algumas sugestões que podem ajudar na redução e tratamento de erros.
Antes vamos descrever os tipos de erro mais comuns.
Erros de Sintaxe
Este é um dos tipos de erro mais comuns. Considere o comando a seguir:
Response.Write “Informativos da empresa ABC Ltda!
658
Observe que nesta linha o desenvolvedor esqueceu de fechar aspas. Este pequeno engano é
suficiente para gerar o erro indicado na Figura 12.1.
Figura 12.1: Mensagem de erro causado por um erro de sintaxe.
Observe que na própria mensagem de erro já existe um indicativo da linha e do comando que
está gerando o erro. Estas informações facilitam enormemente a correção do problema. Sem
a menor sombra de dúvida, os erros de sintaxe são os mais fáceis de corrigir, principalmente
pelo fato que a página simplesmente não é carregada se houverem erros de sintaxe.
Para corrigir o nosso problema, bastaria fechar aspas, conforme indicado a seguir:
Response.Write “Informativos da empresa ABC Ltda!”
Erros de Semântica ou de Tempo de Execução

Este tipo de erro é mais difícil de detectar do que os erros de sintaxe, pois normalmente só se
manifestam na hora que tentamos carregar a página e não são tão evidentes como um simples
fechar de aspas.
No fragmento de código a seguir temos um típico exemplo:

<%
‘Crio um array para armazenar 10 elementos
‘Lembre que o índice de um array começa com 0.
659
Dim arrayinteiros(9)
arrayinteiros(10)=25
%>
Neste exemplo estamos criando um array com 10 elementos: índice 0 até o índice 9, porém
estamos tentando utilizar o índice 10. Este código irá gerar um erro em tempo de execução,
Figura 12.2: Erro gerado pela utilização indevida de um array.
Observe que a mensagem de erro informa que existe um índice fora do intervalo permitido.
Também devemos salientar que a detecção deste tipo de erro é mais difícil do que os erros de
sintaxe. Muitas vezes o erro pode estar ainda mais disfarçado, como no exemplo a seguir:
<%
Dim arrayinteiros(9)
For i=1 to 10
arrayinteiros(i)=5*i+10
Next
%>
Este fragmento irá gerar a mensagem de erro indicada na Figura 12.3.
660
Figura 12.3: Erro gerado pela utilização indevida de um array.
Observe que agora a mensagem não é tão indicativa de onde está o problema. Agora imagine
em aplicações maiores. Se o programador não for disciplinado, pode ser gerado código de
difícil depuração.
Erros Lógicos
Este, com certeza, é o pior tipo de erro. O código executa aparentemente sem problemas, a
página é carregada, porém os resultados obtidos não são os esperados. Este tipo de erro acontece
porque o programador utilizou um algoritmo incorreto.
Por exemplo, ao pesquisar em um banco de dados, na tabela Pedidos. Se quisermos somente

os pedidos para o Brasil ou para a Argentina, devemos utilizar a seguinte instrução SQL:
Select * from Pedidos where Pais=‘Brazil’ Or Pais=‘Argentina’
Se o programador simplesmente trocar o Or por um And, não irá retornar nenhum registro, pois
cada pedido é somente para um país. Porém, este tipo de erro ainda não seria dos piores, pois em
não retornando nenhum registro o desenvolvedor irá “desconfiar” de que algo está errado.
O pior tipo de erro lógico é aquele que retorna um resultado, porém um resultado incorreto.
661
Vamos supor que você queira calcular os valores de uma aplicação utilizando a seguinte fórmula:
Total= Empréstimo multiplicado pelos juros mais adicional de risco e tudo isso
dividido por 1.33.
Um erro comum é construir a fórmula da seguinte maneira:

Total=emp*juros+risco/1.33
Esta fórmula irá efetuar os cálculos porém de maneira incorreta. Primeiro o empréstimo será
multiplicado pelos juros. Depois o risco dividido por 1.33 e os dois resultados somados.
Porém não é isso que queremos. Para fazer com que a fórmula seja calculada corretamente,
podemos fazer o uso de parênteses, conforme indicado a seguir:
Total =((emp*juros)+risco)/(1.33)
Desta maneira garantimos a ordem correta das operações e deixamos o código mais fácil de ler.
Este é apenas um pequeno exemplo de erro lógico. Existe uma infinidade de armadilhas e
situações possíveis de ocorrência de erros lógicos. Em muitas delas é difícil a detecção do erro
se o programador não for disciplinado e o processo como um todo não estiver bem documentado.
Algumas Dicas Para Reduzir a Ocorrência de Erros

Aqui colocamos algumas dicas bem conhecidas, mas que sempre vale a pena repetir:
➥ Não despreze a possibilidade e os problemas causados pelos erros: Muitas vezes devido
a prazos cada vez menores e pressões da administração, a verificação de erros acaba
sendo deixada em segundo plano. A menos que o presidente da empresa esteja na sua
sala de arma na mão, não faça isso. Leve em consideração a possibilidade de ocorrência
de erros e as conseqüências que os mesmos podem causar. Está mais do que comprovado
que quanto mais cedo for descoberto um erro mais fácil e barato será para corrigi-lo.
➥ Crie e mantenha um ambiente de testes capaz de realizar um número massivo de testes
em sua aplicação. Considere a hipótese de adquirir um software capaz de gerar entradas
para a sua aplicação e simular o acesso de diversos usuários simultaneamente. Estes
programas são úteis não só para a detecção de erros como também para a determinação
do limite prático em termos de desempenho da sua aplicação Web e do servidor onde a
mesma reside. Muitas aplicações são desenvolvidas e testadas em ambientes muito
diferentes de onde serão utilizadas. Com o uso de um software para testes podemos
simular da maneira mais próxima possível o ambiente de produção.
➥ Crie um padrão para o nome de variáveis e objetos que você irá utilizar em seu código
ASP. Por exemplo, o nome de todo objeto do tipo RecordSet começa com RS, o nome de
todo objeto do tipo Connection começa com CN e assim por diante. Manter um padrão
para o nome de variáveis e objetos ajuda bastante na hora de fazer a depuração do código.
662
➥ Use indentação do código. Isto facilita muito a leitura do código e demonstra quais
linhas de código pertencem a cada estrutura de controle. Observe o exemplo a seguir:
<%
If criar=“Sim” Then
total = total+juros
Response.Write “Valor devido: ” & total
Else
total = total-juros
Response.Write “Valor devido: ” & total
End If
%>
A indentação deixa o código mais legível e facilita na hora de procurar e corrigir erros.
➥ Se você tiver uma determinada rotina de cálculo ou acesso a banco de dados, que é
utilizada em diversos locais na sua aplicação, pense em escrevê-la e salvá-la em um
arquivo separado e depois utilizar a diretiva #include para incluir este código nos
locais onde o mesmo é necessário. Isto evita que você tenha que escrever o mesmo
código em diversos locais e principalmente que o escreva de maneira diferente. Além
disso se forem necessárias modificações, basta fazê-las no arquivo original e não em
diversos lugares. Isto minimiza a possibilidade de estar utilizando algoritmos diferentes
para a mesma rotina.
NOTA
Estaremos aprendendo a utilizar a diretiva #include ainda neste capítulo.
➥ Documentar, documentar e documentar. Este é um dos princípios básicos para o desen-

volvimento de aplicações. Mas infelizmente poucos o levam muito a sério. Documentar
detalhadamente a sua aplicação não é perda de tempo; muito pelo contrário. Quando
surgem problemas ou são necessárias modificações na aplicação, a documentação é o
auxiliar mais valioso que podemos ter à mão. Não despreze este aspecto.
O Conceito de Transações e a Utilização

de Transações em Páginas ASP
Neste tópico teremos uma introdução ao conceito de transação bem como sobre a utilização
de transações em páginas ASP.
663
O Conceito de Transação
Na era da Internet e do Comércio Eletrônico temos questões bastante complexas a serem
tratadas no desenvolvimento de aplicações Web. Uma destas questões é sobre a integridade
das bases de dados. Existem determinadas operações que envolvem entrada e atualização de
informações em diversas tabelas ou até mesmo em diversos bancos de dados.
Para que possamos entender exatamente o conceito de transação, vamos fazer uso de um
exemplo clássico: “O usuário que utiliza o site do seu banco na Internet para fazer uma
transferência entre contas correntes.”
Para que a transferência ocorra com sucesso, as seguintes ações devem ser executadas:
➥ Debitar da conta do usuário o valor a ser transferido.
➥ Creditar o valor que está sendo transferido na conta do destinatário.
Estas duas operações devem ser finalizadas com sucesso e de maneira única, ou seja, ou as
duas operações são executadas com sucesso ou nenhuma delas. Por exemplo, se a operação
de debitar da conta do usuário aconteceu com sucesso e na hora de creditar na conta do
destinatário houve algum problema, a operação de débito da conta do usuário deve ser
revertida, ou seja, a conta do usuário deve ter creditado o valor anteriormente debitado.
Neste caso a operação falha como um todo e as duas contas continuam com o saldo que
tinham antes da operação.
Este exemplo serve para que possamos definir exatamente o que é uma transação.
“Uma transação é um conjunto de uma ou mais operações que devem acontecer como um
todo, ou seja, ou todas as operações são realizadas com sucesso ou nenhuma das operações é
realizada. Se ocorrer algum problema depois que algumas operações já foram efetuadas, as
mesmas deverão ser revertidas, de tal maneira que a situação dos dados retorne ao seu estado
original antes das modificações efetuadas pela transação.”
À medida que as aplicações tornam-se mais e mais complexas, a utilização de transações é

um requisito obrigatório.
Durante algum tempo, o próprio desenvolvedor precisou codificar a funcionalidade de

transações, de tal maneira que a integridade dos dados fosse garantida. Hoje, a funcionalidade
de transações está embutida nos chamados servidores de Aplicação. Com isso, o desenvolvedor
não precisa escrever o código para transações, ao invés disso podem ser utilizadas as
funcionalidades oferecidas pelo servidor de Aplicação. No caso do IIS 5.0 no Windows 2000,
podemos utilizar as funcionalidades do Microsoft Transaction Services. No Windows NT
4.0, com IIS 4.0, tínhamos o Microsoft Transaction Server, o qual fazia parte do pacote de
software conhecido como Option Pack 4.0.
664
Uma transação deve apresentar as características conhecidas como ACID, onde temos o
seguinte: A – Atomicidade; C – Consistência; I – Isolamento; D – Durabilidade.
➥ Atomicidade: Esta propriedade define que a transação deve acontecer como um todo, ou
seja, todas as ações embutidas na transação devem ocorrer com sucesso ou falhar como
um todo. Se algum erro acontecer, o sistema deve retornar ao seu estado anterior à transação.
➥ Consistência: Esta propriedade garante que ao final da transação o sistema estará em
um estado consistente. Se todas as ações da transação forem executadas com sucesso,
as alterações serão salvas no banco de dados e o sistema estará disponível para uso. Se
ocorrer algum problema as alterações serão desfeitas e o sistema também estará
disponível para uso.
➥ Isolamento: Esta propriedade muitas vezes é conhecida como Serialização. Cada transação
é executada como se não houvesse outras transações. Isso é feito para que, quando a
transação estiver executando, a mesma não acesse dados inconsistentes, isto é, dados
que estão sendo alterados por outra transação. Com isso é garantido que o sistema estará
em um estado consistente e pronto para ser utilizado ao final de cada transação.
➥ Durabilidade: Este princípio garante que, uma vez completada a transação, as alterações
que a mesma efetuou serão permanentemente gravadas no banco de dados, mesmo
que aconteça alguma falha no sistema. No exemplo da transferência entre contas, temos
que garantir que o valor será realmente debitado da conta do usuário e creditado na
conta do destinatário.
Colocando uma Página ASP no Contexto de uma Transação

Podemos definir que uma página ASP deve ocorrer no contexto de uma transação. Para isso
podemos colocar a seguinte diretiva na primeira linha de código da página:
<%@ TRANSACTION =required %>
Usando os métodos Server.Transfer e Server.Execute, uma transação pode ocupar várias

páginas ASP. Se um script contiver a diretiva @TRANSACTION, com o valor especificado
como Required (Necessário), e o script for chamado pelo método Server.Transfer ou
Server.Execute, ele continuará a transação do arquivo .asp que chama, caso esse arquivo
tenha sido transacionado. Se o arquivo .asp que chama não tiver sido transacionado, o arquivo
.asp chamado criará automaticamente uma nova transação.
Por exemplo, o script a seguir inicia uma transação:

<%@ TRANSACTION=Required %>
<HTML>
<BODY>
665
<%
.
‘End transaction.
Server.Transfer(“/Capitulo10/segunda.asp”)
%>
No entanto, o script abaixo chama um outro script que também inicializa uma transação:
<%
‘Instancia um componente do Microsoft Transaction Services.
Set objVendas = Server.CreateObject(“VendasTransacted.Complete”)

.
.
.
%>
No entanto, a interação entre os dois scripts constituiria em uma transação única.
Estabelecendo um Script Transacional

Quando você declarar uma página como sendo transacional, quaisquer comandos de script e
objetos utilizados na página serão executados no mesmo contexto de transação. Os Serviços
de componente controlam os detalhes da criação da transação e determinam se a transação
foi bem-sucedida (confirma) ou falhou (anula). Para declarar uma página transacional, adicione
a diretiva @TRANSACTION ao topo da página:
<%@ TRANSACTION = valor %>
Onde o parâmetro valor pode assumir um dos seguintes valores:

➥ Required: O script inicia uma nova transação.
➥ Requires_New: O script inicia uma nova transação.
➥ Supported: O script não inicia uma nova transação.
➥ Not_Supported: O script não inicia uma nova transação.
A diretiva @TRANSACTION deverá estar na primeira linha da página; caso contrário, será
gerado um erro. Você deve adicionar a diretiva a cada página a ser executada em uma transação.
A transação atual é finalizada quando o processamento do script termina.
A maioria dos aplicativos requer o contexto de transação somente para determinadas operações.
Por exemplo, o site de uma companhia aérea pode usar scripts transacionais para operações de
666
compra de passagem e reserva de assento. Todos os demais scripts podem ser executados de
maneira segura sem um contexto de transação.
IMPORTANTE
Visto que as transações devem ser utilizadas apenas para páginas que necessitam de
processamento de transação, você não pode declarar o arquivo global.asa de um aplicativo
como transacional.
Se uma transação for anulada, os Serviços de componente (COM+) reverterão quaisquer

alterações efetuadas nos recursos que oferecem suporte a transações. No momento, somente
os servidores de Banco de dados dão suporte integral a transações, pois esses dados são os
mais importantes para os aplicativos de empresa. Os Serviços de componente não revertem
alterações efetuadas em um disco rígido, em uma sessão ASP e em variáveis ou coleções de
aplicativos. No entanto, você pode gravar scripts que restauram variáveis e coleções através
da gravação de eventos de transação, conforme descrito mais adiante neste tópico. Seu script
também poderá confirmar ou anular explicitamente uma transação em caso de falha de uma
operação como, por exemplo, a gravação de dados em um arquivo.
Restabelecendo ou Abortando um Script

Como os Serviços de componente controlam o processamento de transações, eles determinam
se uma transação foi concluída com êxito ou se falhou. Um script pode declarar explicitamente
que está anulando uma transação através da chamada de ObjectContext.SetAbort. Por exemplo,
o seu script poderá anular uma transação se receber um erro de um componente, se uma
regra comercial for violada (por exemplo, se o saldo da conta ficar negativo) ou se uma operação
não transacional, como a leitura ou gravação de um arquivo, falhar.
IMPORTANTE
A transação também será anulada se a página exceder o tempo limite antes da conclusão da
transação.
Gravando Eventos de Transação

O próprio script não pode determinar se uma transação obteve êxito ou falhou. No entanto,
você pode gravar eventos que serão chamados quando a transação for confirmada ou anulada.
Por exemplo, suponha que você tenha um script que efetua créditos em uma conta bancária
667
e deseje retornar páginas diferentes ao usuário, dependendo do status da transação. Você

pode usar os eventos OnTransactionCommit e OnTransactionAbort para gravar diferentes
respostas para o usuário.
NOTA
Observe o exemplo a seguir, retirado da documentação do IIS 5.0. Nele estamos utilizando um
componente chamado MyExample.BankComponent. Este é um componente que foi registrado
e pode ser gerenciado através do Microsoft Transaction Services. Existe uma infinidade de
componentes comerciais que podem ser adquiridos e instalados de tal forma que os mesmos
possam ser utilizados em nossas páginas ASP.

<%
Response.Buffer = True
%>
<HTML>
<BODY>
<H1>Bem-vindo ao serviço bancário on-line</H1>
<%
Set BankAction = Server.CreateObject(“MyExample.BankComponent”)
BankAction.Deposit(Request(“AcctNum”))
%>
<P>Obrigado. A sua transação está sendo processada.</P>
</BODY>
</HTML>
<%
‘Mostra esta página em caso de sucesso da transação.
Sub OnTransactionCommit()
%>
<HTML>
<BODY>
Obrigada. A sua conta foi creditada.
</BODY>
</HTML>
<%
Response.Flush()
668
End Sub
%>
<%
‘Mostra esta página se a transação falhar.
Sub OnTransactionAbort()
Response.Clear()
%>
<HTML>
<BODY>
Não foi possível concluir a transação.
</BODY>
</HTML>
<%
Response.Flush()
End Sub
%>
Registrando um Componente no Gerenciador de Serviços de Componente

Para participar de uma transação, um componente deve estar registrado em um aplicativo
COM+, e deve estar configurado para requerer uma transação. Por exemplo, se o seu script
processar pedidos chamando um componente que atualiza um banco de dados de inventário
e um componente que atualiza um banco de dados de pagamento, você desejará que os dois
componentes sejam executados em um contexto de transação. Os Serviços de componente
garantem que, se um dos componentes falhar, o pedido inteiro será revertido e nenhum banco
de dados será atualizado. Alguns componentes não exigem transações; por exemplo, o
componente AdRotator não precisa de transações.
Utilize o Gerenciador de serviços de componente (Iniciar/Programas/Ferramentas administra-

tivas/Serviços de componentes) para registrar e configurar um componente transacional. Os
componentes devem ser registrados em um aplicativo COM+. Não coloque os seus
componentes no aplicativo COM+ em processo do IIS; em vez disso, crie o seu próprio
aplicativo COM+. Normalmente, você deve colocar todos os seus componentes em um
aplicativo de biblioteca. Os componentes de aplicativos de biblioteca podem ser usados por
vários aplicativos ASP e são executados no processo do aplicativo ASP.
669
Você também pode registrar componentes transacionais em um aplicativo do servidor, um

aplicativo COM+ que sempre é executado em um processo separado no servidor. Utilize os
aplicativos do servidor para os componentes transacionais, a fim de utilizar segurança baseada
em função, ou para que o acesso aos componentes seja possível a partir de aplicativos em
computadores remotos.
Para que você possa usar o Gerenciador de serviços de componente, é necessário que os
Serviços de componente estejam instalados.
Para acessar o Serviço de componentes faça o seguinte:

1. Faça o logon com permissões de administrador.
2. Selecione Iniciar/Programas/Ferramentas Administrativas/Serviços de componentes.
3. Surge o Snap-in indicado na Figura 12.4.
Figura 12.4: O Snap-in para gerenciamento do Serviço de componentes.
4. Dê um clique no sinal de + ao lado de Serviços de componente.

5. Nas opções que surgem, dê um clique no sinal de + ao lado de Computadores.
6. Nas opções que surgem, dê um clique no sinal de + ao lado de Meu computador.
7. Nas opções que surgem, dê um clique no sinal de + ao lado de Aplicativos do COM+.
9. Para instalar um novo componente COM+, clique com o botão direito na opção
Aplicativos do COM+, aponte para a opção Novo e dê um clique sobre Aplicativo.
670
Figura 12.5: Os componentes COM+ disponíveis neste computador.
10. Será aberto o Assistente de instalação de aplicativos do COM, conforme indicado na

Figura 12.6.
Figura 12.6: O assistente para instalação de aplicativos COM.
11. Agora é só seguir os passos do assistente.
671
NOTA
Para maiores informações sobre a instalação de Aplicativos e componentes COM, consulte a
ajuda do Windows 2000.
Escopo de Objeto
Normalmente, você não deve armazenar objetos criados a partir de um componente do COM
nos objetos ASP Application ou Session. Os objetos COM serão desativados quando a transação
for concluída. Como os objetos Session e Application se destinam a instâncias de objeto que
podem ser utilizadas em múltiplas páginas ASP, você não deverá utilizá-los para manter
objetos que serão liberados ao final de uma transação.
Um script ASP é a raiz, ou o início, de uma transação declarada. Qualquer objeto COM utilizado
em uma página ASP transacional será considerado parte da transação. Quando a transação
estiver concluída, os objetos COM utilizados na página serão desativados, incluindo objetos
armazenados no objeto Session ou Application. Tentativas posteriores de chamar o objeto
com o escopo Session ou Application de outra página transacional falharão.
Colocando Transações em Fila

Atualizações em um banco de dados de um servidor remoto podem atrasar ou anular a
conclusão de uma transação devido a falhas na rede. Visto que todas as partes de uma transação
devem ser confirmadas, o aplicativo poderá ficar aguardando a mensagem de confirmação ou
anulação do servidor remoto, ou poderá anular uma transação porque a atualização do banco
de dados não pôde ser enviada dentro do tempo de TimeOut.
No caso de atualizações que devem ser concluídas simultaneamente, é aconselhável anular

ou mesmo atrasar a conclusão da transação até que todos os participantes da transação possam
ser confirmados. Por exemplo, um aplicativo de compra de passagens de uma companhia
aérea deve concluir simultaneamente o débito na conta corrente do cliente e o crédito na
conta corrente da companhia aérea. Caso uma atualização seja essencial para uma transação,
mas possa ocorrer depois das outras atualizações, talvez seja preferível não fazer o cliente
aguardar a conclusão da atualização. Por exemplo, uma transação para solicitar uma passagem
aérea também poderia enviar uma solicitação de refeição especial a um fornecedor de serviços
alimentícios ou atualizar a milhagem do cliente. Essas atividades devem ser concluídas, mas
isso poderá ser feito posteriormente.
O enfileiramento de mensagens permite que você agrupe uma atualização ou um conjunto de

atualizações em uma mensagem transacional, que é enviada a um servidor remoto. Garante
672
que as atualizações sejam enviadas ao servidor remoto, mesmo que a rede não esteja disponível
no momento. O seu aplicativo receberá uma mensagem de confirmação e poderá continuar a
transação. Para o enfileiramento de mensagens podemos utilizar o Microsoft Queue Server.
NOTA
Para maiores detalhes sobre o Microsoft Queue Server consulte a ajudo do Windows 2000 ou o
site da Microsoft (www.microsoft.com).
Utilizando a Diretiva #include

Existem trechos de código que precisam ser utilizados em diversas páginas ASP da mesma
aplicação, ou até mesmo de aplicações diferentes. Uma abordagem seria criar o código em
cada uma das páginas no qual o mesmo seja necessário. Porém, este procedimento traz alguns
inconvenientes, dentro os quais podemos destacar:
➥ Necessidade de atualizar o código em diversos locais quando forem necessárias
modificações.
➥ Maior probabilidade de introdução de erros, uma vez que o código terá que ser digitado
diversas vezes.
Para solucionar este tipo de problema, podemos colocar o código que deve ser utilizado por
diversas páginas em um arquivo com a extensão .inc e depois utilizar a diretiva #include
para inserir este código nos diversos locais onde ele seja necessário.
A diretiva #include possui o seguinte formato:

<—! #include file=“arquivo.inc” —>
Por exemplo:
<—! #include file=“conexao.inc” —>
Ao encontrar esta diretiva em uma página ASP, o IIS substitui a diretiva pelo texto do arquivo
conexao.inc. É como se o código do arquivo conexao.inc tivesse sido digitado diretamente na
página ASP. Somente depois que a substituição é feita, é que o script é executado.
Por exemplo, o nosso arquivo conexao.inc poderia conter o código necessário para estabelecer
uma conexão com o banco de dados nwind.mdb. Com isso teríamos o seguinte código no
arquivo conexao.inc:
<%
‘O primeiro passo é criar a conexão com o banco de dados
‘Para isto crio um objeto do tipo Connection
‘Cria um objeto do tipo ADODB.Connection
673
Set conn=Server.CreateObject(“ADODB.Connection”)
‘Agora abro uma conexão com a fonte ODBC “nwind”
‘criada anteriormente.
conn.ConnectionString = “PROVIDER=MICROSOFT.JET.OLEDB.4.0;
conn.Open
%>
Cada vez que uma página precisasse estabelecer uma conexao com o banco de dados Nwind
é só incluir a diretiva a seguir, na primeira linha, logo abaixo da tag <BODY>:
<—! #include file=“conexao.inc” —>
Se por algum motivo o arquivo nwind.mdb tivesse que ser movido para outro drive, a string
de conexão teria que ser reconfigurada. Utilizando a diretiva #include, somente precisaríamos
alterar em um único lugar: no arquivo conexao.inc. A partir deste momento, todas as páginas
que acessam o arquivo conexao.inc passarão a ter acesso às modificações efetuadas no arquivo
conexao.inc. Veja o quanto esta técnica facilita a manutenção de nossas páginas ASP, evitando
que uma mudança simples como esta, tivesse que ser feita em dezenas de páginas.
IMPORTANTE
A conta com a qual o usuário está fazendo acesso ao site deve ter permissões para acessar o
arquivo .inc. Caso contrário ocorrerá um erro. Por exemplo, se o usuário está autenticado
como usuário anônimo, a conta IUSR_NOME_DO_COMPUTADOR deve ter permissões NTFS
sobre os arquivos que forem acessados via diretiva #include, caso contrário o usuário receberá
uma mensagem de erro.
Vamos dar uma olhada na sintaxe da diretiva #include.
A sintaxe completa para a diretiva include é a seguinte:

<!— #include Tipo_de_caminho = Nome_do_arquivo —>
Onde temos os seguintes parâmetros:

➥ Tipo_de_caminho: Especifica o tipo do caminho. O tipo de caminho pode ter um dos
seguintes valores:
♦ File: O nome de arquivo é um caminho relativo do diretório que contém o documento
com a diretiva #include. O arquivo incluído pode estar no mesmo diretório ou em um
subdiretório; ele não pode estar em um diretório acima da página com a diretiva #in-
clude. Por exemplo, se a página .asp está no diretório wwwroot/Capitulo12 e o arquivo
conexao.inc está no diretório wwwroot/Capitulo12/padroes, usaremos a seguinte diretiva:
<—! #include file=“padroes/conexao.inc” —>
674
♦ Virtual O nome de arquivo é um caminho completo virtual de um diretório virtual

em seu site da Web.
➥ Nome de arquivo: Especifica o nome do arquivo a ser incluído. Nome_do_arquivo
deve conter a extensão de nome de arquivo e deverá estar entre aspas (“). Geralmente
utilizamos a extensão .inc. Porém também podem ser utilizadas outras extensões.
Os arquivos incluídos podem ter qualquer extensão de nome de arquivo, mas recomenda-se
fornecer a extensão .inc.
Exemplos:
<!—O arquivo incluído está no mesmo diretório que o arquivo pai. —>
<!— #include file = “meu_arquivo.inc” —>
<!— O arquivo incluído está no diretório virtual Scripts. —>
<!— #include virtual = “/scripts/tools/global.inc” —>
As Diretivas @
Nesta seção aprenderemos um pouco mais sobre as chamadas Diretivas de processamento ou
diretivas @. Utilizamos as Diretivas de processamento @ em scripts para enviar informações
ao IIS sobre como processar um arquivo .asp. Por exemplo, o script a seguir usa a Diretiva de
processamento @LANGUAGE para definir a linguagem de script como VBScript.
<%@LANGUAGE=VBScript %>
IMPORTANTE
Estas diretivas devem aparecer na primeira linha do arquivo .asp, antes que qualquer entrada
tenha sido enviada para o navegador do cliente.
No IIS 5.0, temos acesso a cinco diretivas:

➥ @CODEPAGE
➥ @ENABLESESSIONSTATE
➥ @LANGUAGE
➥ @LCID
➥ @TRANSACTION
675
A Diretiva de Processamento @CODEPAGE

Você pode usar a diretiva @CODEPAGE para definir a página de código a ser usada para o
arquivo .asp. Uma página de código é um conjunto de caracteres, que pode incluir números,
marcas de pontuação e outros símbolos. Diferentes idiomas e locais podem usar diferentes
páginas de código.
Por exemplo, a página de código ANSI 1252 é usada para o inglês americano e a maioria dos
idiomas europeus; a página de código OEM 932 é usada para o Kanji japonês.
Uma página de código pode ser representada em uma tabela como um mapeamento de
caracteres para valores de byte único ou valores de vários bytes. Por exemplo, quando
utilizamos caracteres Unicode, cada caractere utiliza 2 bytes.
Também podemos substituir a página de código definida pela diretiva @CODEPAGE com a
propriedade Session.CodePage, conforme aprendemos no Capítulo 8. No entanto, essa ação
se aplicará somente a scripts em execução dentro do escopo da sessão.
Sintaxe:
<%@ CODEPAGE = página_de_código%>
Onde: página_de_código é um número inteiro que representa uma página de código válida
para o sistema que está executando o interpretador ASP.
Na Tabela 12.2, temos o valor para alguns dos principais Códigos de Página.
Tabela 12.2 Valores de Códigos de Página.
Código Descrição Alias

1200 Alfabeto Universal unicode
1201 Alfabeto Universal (Big-Indiano) unicodeFEFF
1250 Alfabeto da Europa Central (Windows) windows-1250
1251 Alfabeto Cirylico (Windows) windows-1251
1252 Alfabeto Oeste Ocidental iso-8859-1
1253 Alfabeto Grego (Windows) windows-1253
1254 Alfabeto Turco iso-8859-9
1255 Alfabeto Hebreu (Windows) iso-8859-8
676
Código Descrição Alias

1256 Alfabeto Arábico (Windows) windows-1256
1257 Alfabeto Báltico (Windows) windows-1257
1258 Alfabeto Vietnamita (Windows) windows-1258
20866 Alfabeto Cirylico (KOI8-R) koi8-r
21866 Alfabeto Ucraniano (KOI8-RU) koi8-ru
28592 Alfabeto Europa Central (ISO) iso-8859-2
28593 Alfabeto Latino 3 (ISO) iso-8859-3
28594 Alfabeto Báltico (ISO) iso-8859-4
28595 Alfabeto Cirylico (ISO) iso-8859-5
28596 Alfabeto Arábico (ISO) iso-8859-6
28597 Alfabeto Grego (ISO) iso-8859-7
50220 Japonês (JIS) iso2022-jp
50225 Coreano (ISO) iso-2022-cr
51949 Coreano (EUC) euc-cr
852 Europa Central (DOS) ibm852
866 Alfabeto Cirylico (DOS) cp866
936 Alfabeto Chinês Simplificado gb2312
949 Coreano ks_c_5601-1987
950 Chinês Tradicional (big5) big5
A Diretiva de Processamento @ENABLESESSIONSTATE

Utilizamos a diretiva @ENABLESESSIONSTATE para desativar o controle de sessões de uma
página. O controle de sessões mantém informações sobre um conjunto de solicitações emitidas
por um único cliente. Se sua página não depende de informações de sessão, a desativação
deste controle pode reduzir o tempo que o IIS demora para processar o script.

<%@ ENABLESESSIONSSTATE = True ou False %>
677
True: Ativa o controle de sessão.
False: Desativa o controle de sessão.
A Diretiva de Processamento @LANGUAGE

É possível usar a diretiva @LANGUAGE para definir a linguagem que será usada para interpretar
os comandos em um script. Você pode definir sua linguagem de Script para qualquer
interpretador instalado no IIS. A linguagem padrão é VBScript, portanto, se você não incluir
uma diretiva @LANGUAGE no seu script, o mesmo será interpretado pelo interpretador
VBScript.
Sintaxe:
<%@ LANGUAGE = nome_interpretador %>
Onde: nome_interpretador é o nome do interpretador que deve executar o script. O IIS é

fornecido com dois interpretadores, o VBScript e o JScript. Também é possível instalar outros
interpretadores, como por exemplo, o interpretador para a linguagem Perl.
A Diretiva de Processamento @LCID

Podemos usar a diretiva @LCID para definir o Identificador de Local (LCID, identificador de
local) para um script. O LCID é um parâmetro do tipo DWORD que contém o identificador de
linguagem na palavra inferior e um valor reservado na palavra superior. O identificador
fornecido em um LCID é uma abreviação numérica internacional padrão. Esse LCID tem os
componentes necessários para identificar com exclusividade um dos locais definidos pelo
sistema instalado. Existem dois valores de LCID predefinidos. LOCALE_SYSTEM_DEFAULT
é o local padrão do sistema, e LOCALE_USER_DEFAULT é o local do usuário atual.
Sintaxe
<%@ LCID = identificador_de_local %>
O identificador de local define, dentre outros, os seguintes aspectos:

➥ Símbolo da moeda.
➥ Formato para a data e a hora.
➥ Se o relógio é de 12 ou de 24 horas.
➥ Número de casas a usar depois da vírgula; tanto para números como para valores de
moeda.
678
Em muitas tabelas com a relação dos LCIDs, o valor é fornecido em hexadecimal. Por exemplo,
o valor de LCID para o Brasil é fornecido como 0416. Na verdade este valor deve ser convertido
para decimal. Convertendo 0416 de hexadecimal para decimal, obteremos 1046. Aí podemos
utilizar o seguinte comando:
<% @LCID=1046 %>
para definir o código de localidade para o Brasil.
NOTA
Também podemos alterar o código LCID utilizando a propriedade LCID do objeto Session,
conforme descrito no Capítulo 8.
A Diretiva de Processamento @TRANSACTION

Podemos usar a diretiva @TRANSACTION para indicar que o script deve ser tratado como
uma transação. Se um script for tratado como uma transação, os Serviços de componente
(COM) criarão uma transação para coordenar a atualização de recursos.

<%@ TRANSACTION = valor %>
Onde:
Valor é uma cadeia de caracteres que indica o tipo de suporte de transação. Os valores possíveis são:
➥ Required – O script iniciará uma transação.
➥ Requires_New – O script iniciará uma transação.
➥ Supported – O script não iniciará uma transação.
➥ Not_Supported – O script não iniciará uma transação.
Se um script contiver a diretiva @TRANSACTION, ela deverá ser a primeira linha do arquivo .asp,
caso contrário, será gerado um erro. Você deve adicionar a diretiva a cada página a ser executada em
uma transação. A transação atual é finalizada quando o processamento do script termina.
Se o script que contém a diretiva @TRANSACTION foi chamado pelo método Server.Transfer
ou Server.Execute e o valor foi especificado como Required, o mesmo continuará a transação
do arquivo .asp de chamada, se essa transação tiver sido criada. Se a transação do arquivo
.asp de chamada não tiver sido criada, o arquivo .asp chamado criará uma nova transação.
679
Por exemplo, os dois scripts a seguir seriam considerados uma transação:
ASP1
<%
Server.Transfer(“asp2.asp”)
%>
ASP2
<%@ TRANSACTION=Required%>
<%
Server.CreateObject(“MeuComponente.Closeout”)
%>
Conclusão
Neste capítulo analisamos uma miscelânea de assuntos a respeito de ASP.
Iniciamos o capítulo falando sobre o objeto ASPError e sobre a importância do tratamento de

erros em nossas aplicações Web. Também foram dadas algumas sugestões para reduzir a
ocorrência de erros e gerar código de melhor qualidade.
Depois passamos ao conceito de transações. Vimos o que significa cada uma das letras da
sigla ACID. Aprendemos a utilizar a diretiva @TRANSACTION para inserir uma página ASP
no contexto de uma transação.
Na seqüência, passamos ao estudo da diretiva #include, a qual facilita a padronização e

manutenção do código, uma vez que podemos escrever código que é comum a muitas páginas
em um único arquivos, e depois inserir este arquivo, onde for necessário, utilizando a diretiva
#include.
Para finalizar o capítulo tratamos das diretivas @, conhecidas como Diretivas de

processamento. Estas diretivas orientam o servidor IIS sobre como o mesmo deve processar
cada página. Através destas diretivas podemos definir qual o interpretador que deve ser usado,
qual o código de localidade e assim por diante.
Com isso, estamos encerrando este trabalho. Procurei colocar informações úteis para usuários
desde o iniciante até o usuário mais experiente. Obviamente que este trabalho não esgota o
assunto, pois o mesmo é muito extenso.
680
Apêndice – Referência Rápida da Linguagem VBScript
Apêndice
Referência Rápida
da Linguagem VBScript
681
Neste anexo apresentaremos um guia de referência rápida para a Linguagem VBScript.
Lembrando que nos diversos exemplos apresentados neste livro, estivemos utilizando a
linguagem VBScript. Optamos pela utilização deesta linguagem devido a facilidade de
aprendizagem aliada a sua versatilidade e poder. Mesmo sendo uma linguagem de Script, é
incrível o número de recursos que a mesma oferece. Além disso, por ser derivada do Visual
Basic, sendo classificada inclusive como um subconjunto do Visual Basic, é de fácil assimilação
para quem já trabalha com Visual Basic ou VBA – Visual Basic for Applications.
Podemos ter código VBScript que roda no cliente ou que roda no servidor.
Para declarar um bloco de código que roda no cliente, utilizamos a seguinte sintaxe:
<!—
Comando1
Comando2
...
Comandon
—>
</SCRIPT>
Para declarar um bloco de código que roda no servidor, utilizamos a seguinte sintaxe:
<SCRIPT LANGUAGE=vbscript RUNAT=Server>
Comando1
Comando2
...
Comandon
</SCRIPT>
Também podemos utilizar o VBScript dentro de qualquer trecho de código ASP. Nos exemplos
deste livro, sempre utilizamos a diretiva @LANGUAGE, para definir que o interpretador
VBScript é que devia ser utilizado para executar os comandos dentro dos trechos de código
ASP. Para definir que o VBScript deve ser utilizado, podemos usar o seguinte comando:
<%@ Language=VBScript %>
NOTA
Lembre que as diretivas de processamento (diretivas @) devem ser o primeiro comando da
página, antes que tenha sido enviada qualquer saída para o navegador do cliente.
682
Outra opção que teríamos seria a utilização de Java Script, que na versão da Microsoft é
conhecido como JScript. Conforme descrito anteriormente, optamos pela utilização de
VBScript, que no ponto de vista deste autor parece ser a escolha mais indicada quando
trabalhamos com páginas ASP.
Declarando Variáveis com VBScript

Para declarar variáveis com o VBScript, utilizamos o comando Dim. Observe os exemplos.
Dim a,b,c
Dim nomes(20)
O primeiro comando declara três variáveis sem tipo definido, ou melhor, do tipo Variant. No
VBScript, diferente do Visual Basic nós não declaramos o tipo da variável. Por padrão, todas
as variáveis são do tipo Variant, isto é, podem conter qualquer valor. Para que possamos ter
um tratamento mais refinado em relação as variáveis são definidos os chamados subtipos de
Variant, os quais estão descritos na Tabela A.1.
Na Tabela A.1, temos a descrição para os subtipos do tipo Variant.
Tabela A.1 Subtipos do tipo Variant.
Subtipo Descrição
Empty É uma variável não inicializada.
NULL A variável intencionalmente não contém um valor válido.
Boolean Pode conter True ou False.
Byte Pode conter um inteiro de 0 a 250.
Integer Pode conter um inteiro entre –32.768 e 32.767.
Currency de –922.337.203.685.477,5808 até 922.337.203.685.447,5807.
Long Pode conter um inteiro de –2.147.483.648 até 2.147.483.647.
Single Pode conter um número de precisão simples, na faixa de
–3,402823E38 até –1,402398E-45 para valores negativos e
1.401298E-45 até 3.402823E38 para valores positivos.
Double Pode conter um número de precisão dupla na faixa de
–1,79769313486232E308 até –4,94065645841247E-324 para
valores negativos e de 4,94065645841247E-324 até
1,79769313486232E308 para valores positivos.
683
Subtipo Descrição
Date(Time) Contém um número, o qual representa a data entre 01 de
Janeiro do ano 100 e 31 de Dezembro de 9999.
String Contém uma String de tamanho variável com no máximo 2
bilhões de caracteres.
Object Contém um objeto.
Error Contém um número de erro.
O segundo comando – Dim nomes(20), declara um array com 21 elementos. Isto mesmo, são
21 e não 20 elementos. Não esqueça que o primeiro elemento é o de índice 0 (zero) e não o de
índice 1 (um).
Mais adiante veremos sobre as funções para conversão de tipos.
IMPORTANTE
Embora não seja obrigatória a declaração das variáveis em VBScript, sempre é uma boa prática
de programação declarar e comentar todas as variáveis que utilizamos em nosso código.
Também podemos criar arrays dinâmicos, utilizando a seguinte declaração:

Dim nomes( ).
ou até mesmo arrays de múltiplas dimensões. Por exemplo, podemos criar uma Matriz-array
de duas dimensões, utilizando o seguinte comando:
Dim produção(4,10).
Operadores
Para realizar desde operações bastante simples, até operações mais complexas, VBScript nos
disponibiliza uma série de operadores, os quais estão descritos na Tabela A.2.
Na Tabela A.2, temos a descrição dos operadores do VBScript.
Tabela A.2 Operadores do VBScript.
Operador Descrição
+ Adição
- Subtração
684
* Multiplicação
/ Divisão
& Operador And em expressões lógicas e também
operador de concatenação de Strings.
^ Exponenciação
\ Retorna o valor inteiro da divisão de dois números.
MOD Retorna o resto da divisão entre dois números.
OR Operador lógico OU.
Temos também os operadores de comparação, descritos na Tabela A.3.
Tabela A.3 Operadores de comparação do VBScript.
> Maior do que.
< Menor do que.
>= Maior ou igual à.
<= Menor ou igual à.
<> Diferente de.
Estruturas de Decisão e Laços de Controle em VBScript

No VBScript temos acesso às estruturas de decisão e laços de controle mais comuns, existentes
na maioria das linguagens.
Estrutura de Decisão If Then Else

If teste_lógico Then
Comandos se o teste lógico for verdadeiro.
Else
Comandos se o teste lógico for falso.
End If
685
Estrutura de decisão If Then ElseIf

If teste_lógico1 Then
Comandos se o teste lógico 1 for verdadeiro.
ElseIf teste_lógico2 Then
Comandos se o teste lógico 2 for verdadeiro.
Else
Comandos se nenhum dos testes anteriores for verdadeiro.
End If.
Neste caso, assim que um dos testes lógicos for verdadeiro, os comandos respectivos são
executados e a estrutura é abandonada. Por exemplo, se o teste_lógico1 for verdadeiro, os
comandos respectivos serão executados e os demais testes nem sequer serão avaliados.
O Laço For...Next
Este laço executa um bloco de código um número determinado de vezes.
For i=1 to 10
i=i+1
msgbox i
Next
O Laço For Each...Next

Este laço repete um bloco de código para cada elemento de um array ou coleção.
<%
For each campo in Request.Form
Response.Write “O nome do campo é:” & campo
Next
%>
A Estrutura Select Case...End Select

Esta estrutura pode ser utilizada em substituição a uma série de instruções If Then... Else.
Select Case Month(Date())
Case 1
MsgBox “Estamos no mês de Janeiro”
Case 2
MsgBox “Estamos no mês de Fevereiro”
Case 3
686
MsgBox “Estamos no mês de Março”

Case 4
MsgBox “Estamos no mês de Abril”
Case 5
MsgBox “Estamos no mês de Maio”
Case 6
MsgBox “Estamos no mês de Junho”
Case 7
MsgBox “Estamos no mês de Julho”
Case 8
MsgBox “Estamos no mês de Agosto”
Case 9
MsgBox “Estamos no mês de Setembro”
Case 10
MsgBox “Estamos no mês de Outubro”
Case 11
MsgBox “Estamos no mês de Novembro”
Case 12
MsgBox “Estamos no mês de Dezembro”
End Select.
A Estrutura Do While Condição...Loop

Neste caso, estamos utilizando o operador condicional While, no início do laço. O formato
Do While condição
‘Comando1
‘Comando2
...
Comandon
Loop
Nesta estrutura, enquanto a condição for Verdadeira, o código dentro do laço é executado.
Quando a condição tornar-se Falsa, o primeiro comando após o final do laço será executado.
Neste caso, se a condição for Falsa já na primeira vez, o laço não será executado nenhuma vez.
687
IMPORTANTE
pois caso contrário a condição será sempre Verdadeira, e os comandos dentro do laço ficarão
erros de programação, é uma causa comum de erros e travamentos.
<!—
Dim x
x=10
Contador=1
Soma=0
‘ Faz a soma dos 10 primeiros números maiores do que zero
Do While Contador <= x

Soma = Soma + Contador
Contador = Contador + 1
Loop
—>
</SCRIPT>
A Estrutura Do... Loop While Condição

o código dentro do laço, será executado, pelo menos uma vez, pois o teste somente é feito no
final, e continuará sendo executado, enquanto a condição for Verdadeira. O formato geral,
neste caso é o seguinte:
Do
‘Comando1
‘Comando2
...
Comandon
Loop While condição
688
Nesta estrutura, enquanto a condição for Verdadeira, o código dentro do laço é executado.
Quando a condição tornar-se Falsa, o primeiro comando após o final do laço será executado.
Neste caso, se a condição for Falsa já na primeira vez, o laço será executado uma única vez.
IMPORTANTE
pois caso contrário a condição será sempre Verdadeira, e os comandos dentro do laço ficarão
erros de programação, é uma causa comum de erros e travamentos.
<!—
Dim x
x=10
Contador=1
Soma=0
Do
Loop While Contador <= x
MsgBox “Valor da Soma = ” & Soma
—>
</SCRIPT>
A Estrutura Do Until Condição...Loop

Neste caso, estamos utilizando o operador condicional Until, no início do laço. O formato
Do Until condição
‘Comando1
‘Comando2
...
Comandon
Loop
689
caso, se a condição for Verdadeira, já na primeira vez, o laço não será executado nenhuma vez.
IMPORTANTE
de programação, é uma causa comum de travamentos e erros.
<!—
Dim x
x=10
Contador=1
Soma=0
Do Until Contador > x

Loop

—>
</SCRIPT>
A Estrutura Do... Loop Until Condição

o código dentro do laço será executado, pelo menos uma vez, pois o teste somente é feito no
final, e continuará sendo executado, enquanto a condição for Falsa. O formato geral, neste
caso é o seguinte:
Do
‘Comando1
‘Comando2
690
...
Comandon
Loop Until condição
caso, se a condição for Verdadeira, já na primeira vez, o laço será executado uma única vez.
IMPORTANTE
de programação, é uma causa comum de erros e travamentos.
<!—
Dim x
x=10
Contador=1
Soma=0
Do
Loop Until Contador > x
—>
</SCRIPT>
Comentários em VBScript
Em blocos de código VBScript podemos utilizar a palavra Rem para criar uma linha de
comentário:
Rem Esta linha é um comentário.
691
Já em blocos de código ASP podemos utilizar o apóstrofe para criar uma linha de comentário.
<%
‘Esta linha é de comentário.
%>
Funções no VBScript
A linguagem VBScript nos oferece uma grande quantidade de funções. Temos funções para
conversão de tipos de valores, outras para trabalhar com datas, com Strings para formatação
de números e assim por diante.
Vamos apresentar um resumo das principais funções do VBScript, divididas em Categorias.
Funções Para Conversão de Valores

Estas funções são utilizadas para converter valores de um subtipo para outro subtipo.
Na seqüência, temos a apresentação das principais funções desta categoria.
ASC(String)
Retorna o valor numérico do código ANSI para o primeiro caractere da String passada como
parâmetro.
Asc(“G”)
Retorna: 71
Chr(número)
Retorna o caractere ASCII correspondente ao número passado como parâmetro.
Chr(65)
Retorna: A
CBool(expressão)
Retorna Verdadeiro ou Falso, dependendo da expressão que foi passada como parâmetro.
Cbool(2>3)
Retorna: False (Falso)
692
Cbool(2<3)
Retorna: True (Verdadeiro)
CByte(expressão)
Converte a expressão passada como parâmetro para um Variant do subtipo Byte.
Cbyte(20)
Retorna: 20
Cbyte(300)
Retorna: Um erro
Tipo de erro:
Erro de tempo de execução do Microsoft VBScript (0x800A0006)
Sobrecarga: ‘Cbyte’
Pois o subtipo Byte só admite valores até 250.
CCur(expressão)
Converte a expressão passada como parâmetro para um Variant do subtipo Currency.
Observe o exemplo:
Valor = 543.214588
Response.Write valor*2
Retorna: 1086,429176
Agora vamos utilizar a função CCur:

Valor = 543.214588
Response.Write CCur(valor*2)
Retorna: 1086,4292
CDate(data)
Converte a data passada como parâmetro para um Variant do subtipo Date. Onde data é
qualquer expressão de data válida.
CDate(“Novembro 10,1991”)
Retorna: 10/11/1991
693
CDbl(data)
Converte a expressão passada como parâmetro para um Variant do subtipo Double.
Observe o exemplo:
Dim Moeda, ValorDouble
Moeda = CCur(234.456784) ‘ Moeda é igual a Currency (234.4567).
ValorDouble = CDbl(CCurr * 8.2 * 0.01) ‘ Converte o resultado para Double
(19.2254576).
CInt(expressão)
Converte a expressão passada como parâmetro para um Variant do subtipo Integer.
CInt(30/7)
Retorna: 4
CLng(expressão)
Converte a expressão passada como parâmetro para um Variant do subtipo Long.
Dim MyVal1, MyVal2, MyLong1, MyLong2
MyVal1 = 25427.45
MyVal2 = 25427.55 ‘ MyVal1, MyVal2 são do tipo Double
MyLong1 = CLng(MyVal1) ‘ MyLong1 contém 25427.
MyLong2 = CLng(MyVal2) ‘ MyLong2 contém 25428.
CSng(expressão)
Converte a expressão passada como parâmetro para um Variant do subtipo Single.
Dim MyDouble1, MyDouble2, MySingle1, MySingle2
‘ MyDouble1, MyDouble2 conterão valores do tipo Double.
MyDouble1 = 75.3421115
MyDouble2 = 75.3421555
MySingle1 = CSng(MyDouble1) ‘ MySingle1 contém 75.34211.
MySingle2 = CSng(MyDouble2) ‘ MySingle2 contém 75.34216.
694
CStr(expressão)
Converte a expressão passada como parâmetro para um Variant do subtipo String.
CStr(233)
Retorna a String: 233
Fix(expressão)
Retorna a parte inteira do número.
Fix(30/7)
Retorna: 4
Hex(expressão)
Retorna uma String representando o valor hexadecimal do número.
Hex(1562)
Retorna: 61A
Int(expressão)
Converte a expressão passada como parâmetro para um Variant do subtipo Integer.
Int(30/7)
Retorna: 4
Oct(expressão)
Retorna uma String representando o valor octal do número.
Oct(1562)
Retorna: 3032
Round(expressão,numcasasdecimais)
Retorna um número com a quantidade de casas decimais definidas pelo parâmetro
numcasasdecimais.
Round(235.3658,2)
Retorna: 235,37
695
Sgn(expressão)
Retorna um número inteiro indicando o sinal do número.
Sgn(-23)
Retorna: -1
Sgn(23)
Retorna: 1
Funções Para Trabalho com Datas

Estas funções são utilizadas para facilitar o trabalho com datas e horas.
Na seqüência temos a apresentação das principais funções desta categoria.
Date( )
Esta função retorna a data do sistema.
Date ( )
Retorna: 21/08/2000.
DateAdd(intervalo,numerodeintervalos,data)
Esta função é utilizada para retornar uma data a partir de um intervalo que foi adicionado.
DateAdd(intervalo,numerodeintervalos,data)
onde, o parâmetro intervalo especifica o tipo de intervalo que deve ser adicionado. Na Tabela
A.3 temos os valores possíveis para este parâmetro.
Tabela A.3 Valores possíveis para o parâmetro intervalo.
Valor Descrição
yyyy Ano
q Trimestre
m Mês
d Dias
696
Valor Descrição
w Dia de semana
ww Semanas
h Horas
m Minutos
s Segundos
Por exemplo, para saber que data teremos contados 10000 dias a partir da data atual,
podemos utilizar:
DateAdd(“d”,10000,Date())
Retorna algo do tipo: 19/12/2027.
Para saber em que data terá transcorrido um milhão de dias após 01/01/1900, podemos utilizar
o seguinte comando:
DateAdd(“d”,1000000,01/01/1900)
Retornará: 26/11/4637 00:00:45

DateDiff(intervalo,data1,data2)
Esta função é utilizada para calcular a diferença entre duas datas. Esta diferença pode ser
calculada em intervalos de tempo conforme definido pelo parâmetro intervalo. Os valores
possíveis para o parâmetro intervalo estão indicados na tabela A.3.
Por exemplo, para saber o número de dias entre a data atual e a data do Descobrimento do
Brasil, podemos utilizar o seguinte comando:
DateDiff(“d”,22/04/1500,Date())
Retorna algo do tipo: 36740.
DatePart(intervalo,data)
Esta função retorna apenas uma parte da data. A parte que será retornada é definida pelo parâmetro
intervalo. Os valores possíveis para o parâmetro intervalo estão indicados na tabela A.3.
DatePart (“yyyy”,“01/05/2000”)
Retorna: 2000.
697
DateSerial(ano,mês,dia)
Esta função retorna uma variante do subtipo Data.
DateSerial (1990+10,12-4,31)
Retorna: 31/08/2000.
DateValue(String)
Esta função retorna uma variante do subtipo Data. A String deve conter um formato de data válida.
DateValue (“Novembro 23,1997”)
Retorna: 23/11/1997.
Day(data)
Retorna apenas o dia da data que foi passada como parâmetro.
Day(“25/02/2000”)
Retorna: 25.
Hour(tempo)
Retorna apenas a hora do tempo passado como parâmetro.
Hour(“18:22:31”)
Retorna: 18.
Minute(tempo)
Retorna apenas os minutos do tempo passado como parâmetro.
Minute(“18:22:31”)
Retorna: 22.
Month(data)
Retorna apenas o mês da data que foi passada como parâmetro.
Month(“25/02/2000”)
Retorna: 02.
698
MonthName(data)
Retorna uma String referente ao mês da data.
MonthName(02)
Retorna: fevereiro.
Para receber o nome do mês abreviado utilize a seguinte sintaxe:

MonthName(02,True)
Retorna: fev.
Now( )
Esta função retorna a data e a hora do sistema.
Now ()
Retorna algo do tipo: 2/8/2000 05:08:51.
Second(tempo)
Retorna apenas os segundos do tempo passado como parâmetro.
Second(“18:22:31”)
Retorna: 31.
Time( )
Esta função retorna um Variant do subtipo Date, a qual indica a hora do sistema.
Time ( )
Retorna algo do tipo: 05:08:51.
TimeSerial(hora,minuto,segundo)
Esta função retorna um Variant do subtipo Date, a qual representa os parâmetros passados.
TimeSerial (12+3,23,45-8)
Retorna: 15:23:37.
699
TimeValue(String)
Esta função retorna um Variant do subtipo Date, de acordo com a String passada como
parâmetro. A String deve ser um formato de hora válido.
TimeValue(“12:23:45”)
Retorna: 12:23:45.
WeekDay(data)
Retorna um número indicativo do dia da semana.
WeekDay(“21/08/2000”)
Retorna: 2 (indicando segunda-feira).
WeekDayName(número)
Retorna uma String com o nome do dia da semana.
WeekDayName(2)
Retorna: segunda-feira.
WeekDayName(4)
Retorna: quarta-feira.
WeekDayName(2,true)
Retorna: seg.
O True como segundo parâmetro indica que é para retornar o nome abreviado.
Year(data)
Retorna apenas o ano da data que foi passada como parâmetro.
Year(“25/02/2000”)
Retorna: 2000.
Funções Matemáticas
Estas funções são utilizadas para facilitar os cálculos matemáticos.
700
Atn(número)
Esta função retorna Arco tangente de um número. O número representa um valor em radianos.
Atn(3.14)
Retorna: 1,26248066459947.
Cos(número)
Esta função retorna o coseno de um número. O número representa um valor em radianos.
Cos(3.14)
Retorna: -1.
Exp(número)
Retorna o logaritmo neperiano e elevado ao número passado como parâmetro.
Exp(1)
Retorna: 2,71828182845905.
Log(número)
Esta função retorna o logaritmo natural do número passado como parâmetro. É o logaritmo
na base e.
Log(1000)
Retorna: 6,90775527898214.
Randomize( )
Inicializa o gerador de números aleatórios.
Randomize( )
Rnd(número)
Esta função gera um número aleatório entre 0 e 1.
Randomize
Rnd(100)
Pode retornar qualquer valor entre 0 e 1.
701
Sin(número)
Esta função retorna o seno de um número. O número representa um valor em radianos.
Sin(3.14)
Retorna: 0.
Sqr(número)
Esta função retorna a raiz quadrada do número passado como parâmetro.
Sqr(25)
Retorna: 5.
Tan(número)
Esta função retorna a tangente de um número. O número representa um valor em radianos.
Tan(3.14)
Retorna: 0.
Funções Para Manipulação de Strings

Estas funções são utilizadas para facilitar o tratamento de Strings de texto.
FormatCurrency(expressão)
Retorna uma String formatada com o símbolo de Moeda definido nas Opções regionais do
Painel de controle.
FormatCurrency(1000.25)
Retorna: R$ 1.000,25
FormatDateTime(expressão,opção)
Retorna uma String formatada como data e hora. O parâmetro opção não é obrigatório. Este
parâmetro pode conter os valores 0, 1, 2, 3 ou 4 e é utilizado para definir o formato de retorno,
conforme indicado pelos exemplos a seguir:
702
FormatDateTime(“10-01-2000 3:12:45”,0) & “<BR>”
Retorna: 10/1/2000 03:12:45.

Retorna: segunda-feira, 10 de janeiro de 2000.

Retorna: 10/1/2000.
Retorna: 03:12:45.
Retorna: 03:12.
FormatNumber(expressão,numdigitos)
Retorna o resultado da expressão com uma String, com o número de casas decimais definidos
pelo parâmetro numdigitos.
FormatNumber(1235.36258,3)
Retorna: 1235,362.
FormatPercent(expressão,numdigitos)
Retorna o resultado da expressão com uma String formatada como porcentagem (multiplicada
por 100) e com o sinal de %, com o número de casas decimais definidos pelo parâmetro
numdigitos.
FormatPercent(25.32/100,2)
Retorna: 25,32%.
InStr(String1,String2)
Retorna a posição da primeira ocorrência de String2 em String1.
InStr(“Antônio Cândido da Silva”,“Silva”)
Retorna: 20.
703
LCase(string)
Converte uma String para minúsculas.
LCase(“José da Silva”)
Retorna: josé da silva.
Left(string,número)
Retorna um número especificado de caracteres a partir do início da String. Espaços em branco
também contam como caractere.
Left(“José da Silva”,4)
Retorna: José.
Left(“José da Silva”,7)
Retorna: José da.
Len(string)
Retorna o tamanho da String ou o número de bytes necessários para armazenar a variável.
Len(“José da Silva”)
Retorna: 13.
LTrim(string)
Retorna uma cópia da String sem espaços em branco à esquerda da String.
LTrim(“ José da Silva”)
Retorna: José da Silva.
Mid(string,start,número)
Retorna um número especificado de caracteres (número) de uma String, a partir de uma
posição especificada (start).
Mid(“José da Silva”,6,8)
Retorna: da Silva.
704
Replace(string,ocorrência,substituição)
Retorna uma String onde uma determinada String (definida pelo parâmetro ocorrência) foi
substituída por outra (definida pelo parâmetro substituição).
Replace(“Jose da Silva”,“e”,“é”)

Replace(“Jose da Silva”,“da Silva”,“da Costa”)
Retorna: José da Costa.
Right(string,número)
Retorna um número especificado de caracteres a partir do final da String. Espaços em branco
também contam como caractere.
Right(“José da Silva”,5)
Retorna: Silva.
Right(“José da Silva”,8)
Retorna: da Silva.
RTrim(string)
Retorna uma cópia da String sem espaços em branco à direita da String.
RTrim(“José da Silva ”)
Space(número)
Retorna uma String com o número de espaços em branco especificados pelo parâmetro numero.
Space(10)
Retorna 10 espaços em branco.
StrComp(String1,String2)
Retorna o resultado da comparação de duas Strings. O resultado pode ser um dos seguintes valores:
➥ String1 é menor do que String2: -1
➥ String1 é igual a String2: 0
705
➥ String1 é maior do que String2: 1

➥ String1 ou String2 é Null: Null
StrComp(“Jose”,”Jose”)
Retorna: 0.
StrComp(“Jose”,”Zeze”)
Retorna: -1.
StrComp(“Zeze”,”Jose”)
Retorna: 1.
StrComp(“Zeze”,Null)
Retorna: Null.
String(número,caractere)
Retorna uma String formada pelo caractere definido no parâmetro caractere, tantas vezes
quantas definidas pelo parâmetro numero.
String(30,”*”)
Retorna: ******************************
StrReverse(string)
Retorna uma String em ordem reversa da original.
StrReverse(“José da Silva)
Retorna: avliS ad ésoJ.
Trim(string)
Retorna uma cópia da String sem espaços em branco, nem à direita, nem à esquerda da String.
Trim(“ José da Silva ”)
UCase(string)
Converte uma String para maiúsculas.
UCase(“José da Silva”)
Retorna: JOSÉ DA SILVA.
706
Índice Remissivo
Índice
Remissivo
707
#include, 673 Quatro Camadas, 33

%>, 46 Apresentação, 33
@CODEPAGE, 675 Cliente, 33
@ENABLESESSIONSTATE, 675 Dados, 34
@LANGUAGE, 675 Lógica, 34
@LCID, 675 Modelo, 33
@TRANSACTION, 675 Outras questões, 34
<%, 46 Segurança, 550
Proteção, 551
A Restrições a nível de IP, 552
Servidor, 29
ADO
Camada de apresentação, 30
Arquitetura, 288
Lógica do Negócio, 31
Conceito, 288
Problemas, 30-31
Conexões, 323
Três Camadas, 31
Banco de dados, 324
Apresentação, 32
Nome do arquivo, 323
Dados, 32
Nome do usuário, 323
Lógica, 32
Provedor, 323
Modelo, 32
Senha, 323
Outras questões, 34
Servidor, 324
ASP
Modelo de Objetos do, 290-291
Entendendo, 170
OLE DB
IIS 5.0, 36
Visão geral, 275
Modelo de Objetos, 176
Aplicações
Application, 177
Aplicação Web no IIS, 457
ASPError, 177
Configurar Propriedades, 458
Collections, 177
Depuração de aplicativo, 464
Events, 177
Mapeamentos de aplicativo, 461
Métodos, 177
Opções de Aplicativo, 462
Properties, 177
O que é?, 457
Request, 177
Duas Camadas, 29
Response, 177
Cliente, 29
Server, 177
Modelo, 29
Session, 177
Global.asa, 465
Visão geral do, 178
Novo Paradigma, 456
Onde é processado, 171
O que é uma?, 454
O que é ?, 36
Para a Web, 29
Outros servidores, 36
708
Índice Remissivo
Personal Web Server, 37 Tables, 614

Requisitos para criar, 175 VBScript, 614
Retorna para o navegador, 172 Version, 614
Componente Content Link, 586
C Métodos
GetListCount, 588
Comércio Eletrônico, 23
GetListIndex, 589
B2B, 24-26-27
GetNextDescription, 590
B2C, 24
GetNextURL, 590
Código de retorno, 47
GetNthURL, 591
CRM, 25
GetPreviousDescription, 591
Componente Ad Rotator, 596
GetPreviousURL, 591
Arquivo de Redirecionamento, 600
Componente Page Counter, 605
Arquivo de Rotatória, 597
Exemplo, 607
Altura, 598
File_Location, 605
Borda, 599
Métodos
Impressões, 599
Hits, 606
Largura, 598
PageHit, 606
Texto, 599
Reset, 606
URL, 598
Save_Count, 606
URL_anúncio, 599
Componentes
URL_home_page_anúncio, 599
Ad Rotator, 564
Exemplo, 603
Browser Capabilities, 564
Método GetAdvertisement, 602
Content Link, 564
Propriedades
Page Counter, 564
Border, 602
Clickable, 602
TargetFrame, 602 D
Componente Browser Capabilities, 609 Diretivas
Exemplo, 611 #include, 673
Propriedades @CODEPAGE, 675
ActiveXControls, 614 @ENABLESESSIONSTATE, 675
BackGroundsounds, 614 @LANGUAGE, 675
Beta, 614 @LCID, 675
Browser, 614 @TRANSACTION, 675
Cookies, 614
Frames, 614 E
JScript, 614
Erros
Plataform, 614
De semântica, 659
709
De sintaxe, 658 Log, 149

Lógicos, 661 Rnd, 149
Minimizar, 658-662 Sgn, 149
Estrutura For Each, 184 Sin, 150
Exemplos de aplicação Sqr, 150
Cálculo de Imposto, 239 Tan, 150
Conectando com o Access, 296 Conversão de tipos, 127
Consultas parametrizadas com ASP, 403 Cbool, 127
Editando registros, 361 Cbyte, 128
Excluindo registros, 375 CCur, 129
Formulário de pesquisa, 311 Cdate, 130
Formulário genérico para pesquisas, 437 CDbl, 131
Funções de agregação, 427 CInt, 132
Inserindo dados no Access, 348 CLng, 133
Nome do Cliente como link, 576 CSng, 134
O objeto Content Link, 591 CStr, 135
Pesquisando com o operador Like, 419 Fix, 135
Pesquisas com múltiplos critérios, 425 Int, 135
Utilizando a propriedade Filter, 380 Data e Hora, 140
Utilizando o objeto Connection, 306 Date, 140
Validação de dados, 227 DateAdd, 145
Exemplos de conexões OLE DB DateDiff, 144
Access, 325-326 Day, 141
ORACLE, 331 Hour, 143
SQL Server, 326 Month, 142
Exemplos práticos MonthName, 143
“Hello World”, 44 Now, 142
Data automática, 48 Time, 141
WeekDay, 147
F WeekDayName, 148
Year, 147
FAT, 526
Tipos de dados, 112
FAT32, 526
Is Array, 113
Funções
Is Date, 118
Cálculos matemáticos, 149
IsEmpty, 121
Abs, 149
IsNull, 122
Atn, 149
IsNumeric, 124
Cos, 149
IsObject, 125
Exp, 149
VarType, 115
710
Índice Remissivo
Tratamento de String, 136 IIS 5.0, 2-3

Asc, 136 Configuração para Aplicativos Web, 550
Chr, 136 Configurações gerais de Segurança, 546
LCase, 137 Configurando autenticação, 542
Left, 138 Conta IUSR_NOME_DO_COMPUTADOR
Len, 137 Configurando, 515
Mid, 139 Grupos a que pertence, 521
Right, 138 Sincronizando, 518
String, 140 Verificando Propriedades, 519
UCase, 138 Formação de endereços, 42-43
Lógica de, 44
G-H Instalando, 4
Melhorias, 10
Gerenciador de Serviços de Componentes, 669
Novidades, 10
HTML
Administração e Serviços, 11
Estrutura de um documento, 56
Desenvolvimento de aplicações, 12
Formulários, 60
Permissões NTFS
<FORM></FORM>, 60
Configurando, 525
Botão “Reset”, 75
Preparando para os exemplos, 37
Botão “Submit”, 75
Estrutura de pastas, 37
Caixa de combinação, 72
Pastas virtuais, 38
Caixa de Texto, 62
Seqüência de verificação, 549
Campo para senhas, 64
Testando, 9
Campos Memo, 70
Internet
Check Box, 66
ARPANET, 16
O atributo action, 61
Conteúdo dinâmico, 19
Radio Buttons, 68
ASP, 20
Revisão rápida, 56
Banco de dados, 21
Tags
CGI, 20
<BODY></BODY>, 58
Perl, 20
<FONT></FONT>, 58
SQL Server, 20
<HEAD>, 57
Conteúdo estático, 16
<HTML>, 57
Elementos da, 17
<TABLE></TABLE>, 58
Internet, 18
<TD></TD>, 58
Servidor Web, 18
<TR></TR>, 58
Usuário, 18
FTP, 16
I gopher, 16
IIS 4.0, 2-3
711
História, 16 Integridade Referencial, 256

HTML, 17 Normalização de tabelas, 257
HTTP, 17 Primeira Forma Normal, 258
Visão geral, 17 Segunda Forma Normal, 259
Internet Explorer 4.x, 4 Terceira Forma Normal, 260
Internet Explorer 5.0 Projeto do banco de dados, 261
Ajuda, 161 Relacionamentos, 253
Um para Um, 254
J-L Um para Vários, 255
Vários para Vários, 255
Java Script, 12
Laços de controle
Case, 49 N
Linguagem SQL Netscape Navigator 4.x, 4
Funções de agregação, 426 NTFS, 5, 526
AVG, 427 Auditoria, 527
Count, 427 Compressão, 527
Max, 427 Cotas de usuários, 527
Min, 427 Desempenho, 527
Sum, 427 Gerenciamento, 527
Instruções Partições maiores, 527
DELETE, 274 Permissões, 527
INSERT, 273 Sistema de arquivos, 526
SELECT, 264
UPDATE, 272 O
Introdução, 263
Objeto Application
Pesquisas
Coleções
Caracteres coringa, 421
Contents, 479
Faixa de valores, 422
StaticObjects, 479
Múltiplos critérios, 423
Definição, 468
Operador And, 423
Definindo objetos a nível de aplicação, 474
Operador Like, 418
Eventos
Operador Or, 424
Definindo variáveis, 471
OnEnd, 469
M OnStart, 469
Modelo Relacional Métodos
Chave Primária, 252 Lock, 484
Entidades e Atributos, 251 Remove, 483
712
Índice Remissivo
RemoveAll, 483 Disconnect, 295

Unlock, 484 ExecuteComplete, 295
Usando variáveis, 472 InfoMessage, 295
Objeto ASPError, 657 RollBackTransComplete, 295
Propriedades WillConnect, 295
ASPCode, 657 WillExecute, 295
ASPDescription, 657 Exemplo, 295
Category, 657 Métodos
Column, 657 BeginTrans, 293
Description, 658 Cancel, 293
File, 658 Close, 293-333
Line, 658 CommitTrans, 293
Number, 658 Execute, 293
Source, 658 Open, 293
Objeto Command OpenSchema, 293
Introdução, 389 RoolbackTrans, 293
Métodos Pool de conexões, 334
Cancel, 393 Propriedades
CreateParameter, 393 Attributes, 293
Execute, 393 CommandTimeout, 293
Objeto Parameter, 402 ConnectionString, 294-324
Propriedades, 393 ConnectionTimeout, 294
ActiveConnection, 394 CursorLocation, 294
CommandText, 394 DefaultDatabase, 294
CommandTimeout, 394 Errors, 294
CommandType, 394 IsolationLevel, 294
CommandType Valores de, 395 Mode, 294
Consultas Parametrizadas, 397 Properties, 294
Name, 394 Provider, 294
Parameters, 394 State, 294
Prepared, 394 Version, 294
Properties, 394 Objeto Drive, 634
State, 394 Propriedades
Objeto Connection, 292 AvailableSpace, 634
Eventos DriveLetter, 635
BeginTransComplete, 295 DriveType, 635
CommitTransComplete, 295 FileSystem, 635
ConnectComplete, 295 FreeSpace, 635
713
IsReady, 635 FolderExists, 624

Path, 635 GetAbsolutePathName, 625
RootFolder, 635 GetBaseName, 631
SerialNumber, 635 GetDrive, 620
ShareName, 635 GetExtensionName, 631
TotalSize, 635 GetFile, 631
VolumeName, 635 GetFileName, 632
Objeto File, 644 GetParentFolderName, 627
Exemplo, 649 GetTempName, 632
Métodos MoveFile, 633
Copy, 647 MoveFolder, 628
Delete, 648 OpenTextFile, 633
Move, 648 Propriedade drives, 619
OpenAsTextStream, 648 Objeto Folder, 637
Propriedades Métodos
Attributes, 644 Copy, 642
DateCreated, 644 CreateTextFile, 642
DateLastAcessed, 644 Delete, 643
DateLastModified, 644 Move, 643
Drive, 645 Propriedades
Name, 645 Attributes, 638
ParentFolder, 645 DateCreated, 638
Path, 645 DateLastAcessed, 638
ShortName, 645 DateLastModified, 638
ShortPath, 645 Drive, 638
Size, 645 Files, 638
Type, 645 IsRootFolder, 638
Objeto FileSystemObject, 618 Name, 638
Métodos ParentFolder, 638
BuildPath, 621 Path, 638
CopyFile, 628 ShortName, 638
CopyFolder, 622 ShortPath, 639
CreateFolder, 623 Size, 639
CreateTextFile, 629 SubFolders, 639
DeleteFile, 630 Type, 639
DeleteFolder, 623 Objeto Parameter, 402
DriveExist, 620 Exemplo de aplicação, 403
FileExists, 630 Propriedades
714
Índice Remissivo
Attributes, 402 AbsolutePage, 343

Direction, 402 AbsolutePosition, 343
Name, 402 ActiveCommand, 344
NumericScale, 402 BOF, 344
Precision, 403 BookMark, 344
Size, 403 CacheSize, 344
Type, 403 CursorType, 344
Valores da propriedade Direction, 412 CursorLocation, 344
Value, 403 EditMode, 344
Objeto RecordSet EOF, 344
Cursores, 336 Filter, 345
Localização, 339 LockType, 345
Tipos de, 337 MaxRecords, 345
Definição, 335 PageCount, 345
Lock de Registros, 341 PageSize, 345
Tipos de, 341-342 RecordCount, 345
Métodos Sort, 345
AddNew, 346 Source, 345
Cancel, 346 State, 345
CancelBatch, 346 Objeto Request
CancelUpdate, 346 Coleção Cookies, 199
Clone, 346 Exemplo, 200
Close, 346 Coleção Form, 179
Delete, 346 Exemplo, 182
Find, 346 Método post, 182
GetRows, 346 Coleção Query String, 186
GetString, 346 Exemplo, 189
Move, 346 Método get, 186
MoveFirst, 346 Coleção Server Variables, 193
MoveLast, 346 Exemplo, 194-196
MoveNext, 346 Variáveis de ambiente, 193
MovePrevious, 346 Métodos
Open, 346 BinaryRead, 204
Requery, 346 Propriedades
Resynk, 347 TotalBytes, 203
Save, 347 Objeto Response
Update, 347 Coleção Cookies, 206
Propriedades Exemplo, 207
715
Métodos Métodos
AddHeader, 220 Abandon, 501
AppendToLog, 220 Remove, 502
BinaryWrite, 221 RemoveAll, 502
Clear, 222 Propriedades
End, 223 CodePage, 503
Flush, 224 LCID, 504
Redirect, 225 SessionID, 504
Write, 226 TimeOut, 504
Propriedades Usando variáveis, 490
Buffer, 211 ODBC
CacheControl, 212 Criando uma fonte
CharSet, 213 Microsoft Access, 276
ContentType, 214 SQL Server, 282
Expires, 215 File DSN, 277
Expires Absolute, 216 System DSN, 277
IsClientConnected, 217 User DSN, 277
PICS, 218
Objeto Server, 564 P
Métodos
Permissões NTFS
CreateObject, 566
Arquivos
Execute, 568
Controle total, 529
GetLastError, 570
Gravar, 528
HTMLEncode, 575
Leitura, 528
MapPath, 573
Ler e executar, 529
Transfer, 574
Modificar, 529
URLEncode, 571
Avançadas, 531-532
Propriedade ScriptTimeOut, 565
Definindo, 529
Objeto Session
Pastas
Coleções
Controle total, 528
Contents, 496
Gravar, 528
StaticObjects, 497
Leitura, 528
Definição, 486
Ler e executar, 528
Definindo objetos a nível de Sessão, 492
Listar conteúdo de pastas, 528
Eventos
Modificar, 528
Definindo Variáveis, 489
Plug-in, 55
OnEnd, 488
OnStart, 487
716
Índice Remissivo
R-S If Then, 96
If Then Else, 96
Registrando componentes, 669 If Then ElseIf Else, 97
Segurança Select Case, 99
Autenticação de usuários, 512 Eventos no, 157
Acesso anônimo, 512 Do objeto Documento, 162
Autenticação básica, 539 Do objeto Element, 164
Integrada do Windows, 540 Do objeto Form, 163
Utilizando Certificados, 541 Do objeto Windows, 159
Banco de dados, 557 Principais eventos,
Introdução, 510 Funções de conversão de tipos, 127
Funções de Data e Hora,140
T Funções de Tipo de dados, 112
Transações Funções de Tratamento de String, 136
Abortando Script, 667 Funções para cálculos matemáticos, 149
Conceito, 28-663 Inserindo Código, 78
Eventos de, 667 Operadores de comparação, 87
Fila de, 672 Resultados de, 91
Microsoft Transaction Services – MTS, 28 Operadores matemáticos, 83
Páginas como Transações, 665 O que é?, 54
Procedimentos e Funções, 151
V Referência, 681
Visual Basic, 54
VBA, 54
VPN, 3
VBScript, 12
Criando Funções, 154
Criando Sub-rotinas, 151
W-X
Declarando Variáveis, 78 Windows 2000 Server, 2-3-4
Declaração obrigatória, 81 XML, 12
Escopo de, 91
Subtipos, 82
Tipo de uma variável, 79
Estruturas de Controle, 95
Do Loop Until, 107
Do Loop While, 103
Do Until Loop, 106
Do While Loop, 102
For Next, 100
717

Asp3 PDF

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Asp3 PDF

Enviado por

Direitos autorais:

Formatos disponíveis

Sumário

Copyright © 2000 by Júlio Battisti

Nenhuma parte desta publicação poderá ser reproduzida sem autorização

Editora de Produção: Gisella Narcisi

Criando Sites Dinâmicos com ASP 3.0

Suporte Técnico ao Leitor

Axcel Books do Brasil Editora

Criando um Conjunto de “Radio Buttons” – a tag <INPUT TYPE=“RADIO”> ............ 68

Função CSng ................................................................................................................... 134

Alguns Campos que Merecem Considerações Especiais .............................................. 189

Etapas na Estruturação de um Banco de Dados ............................................................ 261

A Página ASP Para Excluir o Produto Selecionado – Exclui.asp ......................................... 375

A Coleção Contents ........................................................................................................ 497

URL ..................................................................................................................................... 598

Colocando uma Página ASP no Contexto de uma Transação .............................................. 665

Oct(expressão) ................................................................................................................ 695

String(número,caractere) ............................................................................................... 706

O trabalho de criar sites e aplicações para Intranet/Internet tornou-se bastante complexo. O

Equipamento e Software Necessário

A configuração mínima necessária depende de uma série de fatores.

estimados. Alguns sites famosos já enfrentaram problemas de crescimento além do

Instalando e Testando o IIS 5.0

Para instalar o IIS 5.0:

Figura I.1: Janela Adicionar ou remover programas.

5. No lado esquerdo da janela, dê um clique na opção Adicionar ou remover componentes

Figura I.2: Janela para alterar a instalação do Windows.

7. Dê um clique no botão Componentes.

Figura I.3: Janela Assistente de componentes do Windows.

9. Utilizando o Assistente de componentes do Windows podemos adicionar novos

Figura I.4: O serviço Internet Information Services (IIS).

11. Clique no botão Detalhes.

Figura I.5: Indicação do espaço necessário no disco rígido.

14. Dê um clique em OK. Você estará de volta ao Assistente de componentes do Windows.

Figura I.6: Progresso da instalação do IIS 5.0.

Figura I.7: Mensagem solicitando o CD de instalação do Windows.

Para testar se o IIS 5.0 foi instalado com sucesso:

Deve surgir uma janela conforme indicado na Figura 1.8.

Figura I.8: A página padrão do IIS 5.0, logo após a instalação.

Novidades e Melhorias do IIS 5.0

➥ Administração e serviços (FTP e HTTP).

Desenvolvimento de Aplicações Internet/Intranet

Em todos os exemplos, estou utilizando a linguagem VBScript, devido a sua funcionalidade

Visão Geral dos Capítulos do Livro

Então, “Mãos à obra”

Então, mãos à obra, vamos aprender ASP 3.0.

Era uma Vez uma Internet com Conteúdo Estático

Um Começo Quase sem Querer

Uma Visão Geral da Internet e de Seus Elementos

Figura 1.1: Uma visão geral da Internet, com conteúdo estático.

Na Figura 1.1, representamos a primeira geração de conteúdo da Internet. Conforme indicado

Conteúdo Dinâmico na Internet

A conexão de páginas HTML com

Usuário Servidor Web Servidor de Banco de Dados

Figura 1.2: Conectando páginas HTML com bancos de dados.

Para enviar informações, o usuário preenche os campos de um formulário (o qual é criado

Os primeiros programas, capazes de realizar esta tarefa, seguiam a especificação conhecida

A conexão de página HTML com bancos

Agora o usuário pode enviar e

Figura 1.3: Pesquisa em um banco de dados, através da Internet.

Figura 1.4: Digitando os critérios de pesquisa em um formulário criado com HTML.

Figura 1.5: Resultados obtidos a partir de um banco de dados do CEP.

Veja que ao mesmo tempo em que aumentaram as possibilidades de desenvolvimento, também

A Era do Comércio Eletrônico