|
» Adiciona Favoritos
|
|
| Funções e Classes em ASP |
Organizar aplicações complexas na forma de scripts não é tarefa fácil. É necessário garantir que as mesmas regras, a mesma lógica, sejam aplicadas em diversos locais da aplicação.
Com certeza você já conhece o INCLUDE, que permite você criar trechos genéricos de código e inclui-los onde precisar. O problema do uso do INCLUDE é que quando utilizado em excesso o código pode se tornar totalmente ilegível. O INCLUDE pode ter um efeito semelhante ao velho GOTO da linguagem BASIC.
Além disso, o simples uso do INCLUDE gera perda de performance. A tendencia é que você coloque no arquivo de INCLUDE todo código que precise ser repetido em mais de uma página. O problema é que todas as páginas que possuirem o INCLUDE farão esse processamento, muitas vezes desnecessário.
O primeiro problema então é fazer com que os trechos de código existentes sejam executados apenas quando realmente necessário. Cada trecho de código então ganhará um nome para, quando necessário, ser chamado.
Esses trechos de código são chamados de SUBs e/ou funções. A diferença entre uma sub e uma função é que a função realiza um calculo ou uma checagem e devolve um valor de resultado, enquanto que a sub apenas realiza uma tarefa sem devolver resultado algum.
Veja exemplos de uma sub e uma função :
Sub Imprimir
Response.write "Hello World From Sub"
End Sub
Function Calcular
Dim Res
Res=10*2
Calcular=Res
End Function
É interessante observar que a última linha da função realiza o retorno do valor, atribuindo o resultado ao nome da função. Toda função deve ter uma linha equivalente para retornar um valor.
Veja como a Sub será disparada :
Imprimir
E a função :
x=Calcular()
Observem que ao chamar a função devemos fazer algo com o valor que ela retornará como resultado. No exemplo acima o valor retornado pela função está sendo guardado na variável x. Poderíamos chama-la de outras formas, por exemplo, imprimindo o resultado da função no HTML. Neste caso o código ficaria assim :
Response.Write(Calcular())
Para tornar a tarefa realizada pela SUB ou pela função genérica é muito comum que elas precisem receber parâmetros do ponto em que elas forem chamadas. Digamos que a SUB precise receber o nome de uma pessoa e a função um número para realizar o cálculo. Veja como fica o código :
Sub Imprimir(Nome)
Response.write "Hello World From Sub " & nome
End Sub
Function Calcular(numero)
Dim Res
Res=10 * numero
Calcular=Res
End Function
Veja agora a forma de chamar as duas :
Imprimir("João)
x=Calcular(20)
Com esses recursos já é possível utilizar INCLUDEs sem perder muita performance, pois os trechos de código no INCLUDE apenas serão chamados quando necessário. Mas existe ainda um problema a mais : O volume de linhas no arquivo influencia a performance, pelo fato do ASP ser interpretado. Assim sendo, mesmo melhorando um pouco a performance em relação aos exemplos iniciais, ter um excesso de funções dentro de arquivos de include ainda gera uma degradação de performance.
Isso significa que será necessário dividir as funções e subs em vários arquivos diferentes, minimizando a existencia de funções e subs não utilizadas pela página na qual são incluidas. Para manter a ordem desta divisão o melhor método é utilizarmos um recurso de orientação a objetos existente no ASP, mas que poucos conhecem : A criação de classes.
Uma classe pode ser vista como um conjunto de funções e subs que tem um determinado objetivo único. Não pretendo aqui entrar em muitos detalhes da orientação a objetos, definirei apenas de forma básica para sua utilização em ASP.
As classes podem ser "reproduzidas" dentro do código. Quando precisa-se utilizar uma classe coloca-se a classe dentro de uma variável para que ela seja utilizada. Esse processo é chamado de instanciar a classe e a variável gerada é chamada de uma instância da classe ou um objeto que tem como tipo a classe.
O agrupamento de subs e funções é realizado com base na analogia a objetos reais. Por exemplo, quais são as atividades feitas por uma faca ? Ela pode cortar carne, fatiar queijo, picar cebola, entre outras coisas. Assim sendo, cada uma das tarefas realizadas por uma faca pode ser vista como uma sub ou função e tais subs/funções seriam agrupadas dentro de uma classe.
A criação de uma classe é muito simples. Tendo as subs e funções, basta agrupa-las em uma classe. Veja :
Class MinhaClasse
Sub Imprimir(Nome)
Response.write "Hello World From Sub " & nome
End Sub
Function Calcular(numero)
Dim Res
Res=10 * numero
Calcular=Res
End Function
End Class
Feito isso essa classe já pode ser utilizada dentro do código. Para utiliza-la precisaremos instancia-la e a partir de sua instância chamar os métodos existentes. Veja :
Dim X
Set X=New MinhaClasse
x.Imprimir("João")
Response.Write(X.Calcular(10))
Set X=nothing
Assim sendo, definimos uma variável X que irá conter a instância e logo em seguida criamos a instância (Set X=New MinhaClasse). A partir dai passamos a utilizar as subs e funções existentes dentro da classe. A única diferença de utilização é a necessidade de se referir ao nome da instância. Todas as funções e SUBs contidas em uma classe são chamadas de métodos.
Por fim, a última instrução destroi a instancia da classe.
Vale mencionar ainda que uma classe pode conter, além de subs/funções, informações que venham a ser utilizadas pelo código da classe. Assim sendo uma instancia da classe contém código e informação. Neste exemplo, podemos fazer com que o nome e o valor a ser calculado sejam guardados dentro da classe. Veja como fica o código da classe :
Class MinhaClasse
Public Nome
Public Numero
Sub Imprimir
Response.write "Hello World From Sub " & nome
End Sub
Function Calcular
Dim Res
Res=10 * numero
Calcular=Res
End Function
End Class
A instrução PUBLIC é equivalente a DIM. Só que uma variável de classe definida como PUBLIC pode ser manipulada fora da classe, quando definida com DIM não. Veja agora o código que utilizará essa classe :
Dim X
Set X=New MinhaClasse
x.Nome="Joao"
x.Numero=10
x.Imprimir
Response.Write(X.Calcular)
Set X=nothing
Logo após instanciar a classe os valores são armazenados dentro dela. Poderiam ficar guardados dentro da classe durante todo o código, conforme se fizer necessário. Não é mais preciso passar as informações para o método Imprimir e o Calcular, eles utilizarão as informações que estão dentro da classe.
Seguindo a orientação a objetos, o ASP também permite a definição de propriedades dentro da classe, para um melhor encapsulamento da classe. A definição de propriedades segue a mesma síntaxe do VB. Não entrarei em detalhes sobre isso.
Desta forma, utilizando classes pode-se facilmente agrupar as funções e subs. Pode-se então criar um arquivo .ASP para cada classe e depois inclui-lo em todas as páginas em que aquela classe for necessária. Você sempre saberá onde está a função/sub que você precisa, pois elas estarão agrupadas de forma lógica. Recomendo ainda que o nome do arquivo que conterá a classe seja montado com o prefixo "CL_" + o nome da classe. Assim sendo, apenas de olhar para o nome do arquivo você já saberá o que ele contém
|
| Dennes Torres |
| MCSD,MCSE,MCDBA |
|
Voltar |
|
|
| Frase |
| Não sabendo que era impossível, ele foi lá e fez. |
| Jean Cocteau |
|
|
English version
1544 membros