Júlio Battisti Livros e Cursosa sua sala de aula na internet

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 locais, 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 nossos programas. Imagine, por exemplo, quando fosse necessário alterar a maneira de realizar os cálculos. Teríamos que repassar todos os módulos de código,  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 de código, e facilita a manutenção, além de reduzir a possibilidade de erros.

Agora é chegada a hora de aprendermos a criar funções e sub-rotinas. Estes procedimentos/funções são criados em módulos separados, isto é, não ligados a nenhum formulário/relatório. Quando uma destas funções/procedimentos for necessária, basta chamar a respectiva função/procedimento que o Microsoft Access 2007 se encarrega de localizar a função/procedimento, passar os parâmetros necessários (se for o caso) e receber os resultados retornados, caso seja uma função.

NOTA: Vamos falar um pouco mais sobre o termo Procedimento. Um procedimento é um grupo de instruções que pode ser chamado pelo nome atribuído ao procedimento. Neste contexto, funções e sub-rotinas, são tipos de procedimentos.

10.5.1 - 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 uma sub-rotina é chamada, a execução desloca-se para dentro da Sub-rotina, depois de executados todos os comandos dentro da Sub-rotina, a execução do código 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

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 da Sub-rotina. 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 rotina chamada Calcula_imposto, a qual espera receber 3 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 da Sub-rotina, 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

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.

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 a seguir   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 anterior.

Listagem– A Sub-rotina exibe_data_hora:

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

Exercício: Crie um novo módulo chamado Utilitários. Dentro deste módulo crie o procedimento exibe_data_hora. Salve o módulo. Abra o formulário Teste no modo estrutura. Crie um botão chamado ExSupProc. Associe o seguinte código ao evento Ao clicar deste botão:

Call exibe_data_hora

Teste o funcionamento do botão.

10.5.2 - 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çao. Podemos passar um ou mais argumentos para uma Função. Quando uma Função é chamada, a execução desloca-se para dentro da Função, depois de executados todos os comandos dentro da Função, a execução do código continua, com o comando seguinte ao que chamou a Função. A diferença da Função para a Sub-rotina, é que a Função sempre retorna um ou mais valores 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

Uma Função pode, ou não, conter argumentos. Caso sejam necessários argumentos, estes 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:

Função 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 2 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 abaixo:

Function Nome_da_Função

            Comando1
            Comando2
            ...
            Comandon
End Function
           
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 utilizaremos a função dentro de um laço For...Next, para exibir o valor em radianos, para os ângulos de 0 à 20 graus.

No exemplo a seguir temos o código 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 à 20 graus.

Observe que dentro da função, atribuímos a variável CRad um determinado valor. É isso que caracteriza uma função. Dentro do código da função, 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.

Cabe salientar o uso da função FormatNumber, dentro do laço For. A função FormatNumber é 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 5 casas depois da vírgula.

Em cada "passada" do laço For...Next, chamamos a função CRad(i), 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 5 casas decimais.

Funções que serão utilizadas em vários Formulários/Relatórios, devem ser criadas em um Módulo separado. Depois é só chamar a função onde esta for necessária.

Exercício: Crie uma função chamada ValorImpostoPF. Esta função deve receber os seguintes parâmetros:

• Total de rendimentos                 - TotRed.
• Total de deduções                     - TotDed.
• Imposto retido na fonte              - ImpRet.

Com base na tabela oficial do IR, a função calcula o imposto devido e informa se existe imposto a restituir ou a pagar e qual o respectivo valor. Criar um formulário chamado CalcIRPF, no qual temos três campos, um para cada parâmetro da função. O usuário preenche os valores deste campo e clica em um botão Calcular. O evento Ao clicar chama a função ValorImpostoPF e exibe o resultado dos cálculos.