O Procedimento Exit


Todos os programadores Pascal conhecem o procedimento Exit() desde as primeiras versões dos compiladores. Mas será que todos sabem utilizá-lo corretamente?

Unsplash image Photo by Kev Seto on Unsplash

O procedimento Exit() é utilizado quando queremos sair de um escopo em execução. Esse escopo pode ser uma função, procedimento, método ou até mesmo o próprio programa.

Vamos dizer que um programa console chame um procedimento Execute:

procedure Execute;
begin
  Writeln('1. Passing on this line...');
  Exit;
  Writeln('2. It will not pass here');
end;

No exemplo acima, somente a informação do primeiro Writeln será mostrado no console.

Ao sair de um escopo, o programa retorna imediatamente para o escopo anterior (outra função/procedimento/método ou o próprio programa). A única exceção a essa regra é quando há blocos try-finally. Se Exit() for chamado dentro de um bloco try-finally o compilador irá executar o código dentro do finally-end antes de sair do escopo.

Aqui está outro exemplo:

procedure Execute;
begin
  try
    Writeln('1. Passing on this line...');
    Exit;
  finally
    Writeln('2. I am still here!');
  end;
  Writeln('3. It will not pass here');
end;

Os textos #1 e #2 serão mostrados no console. Mesmo que Exit() tenha sido chamado antes da impressão do texto #2, ainda sim o código é executado devido ao try-finally.

Outro exemplo de uso do Exit() é quando fazemos validações. Se uma validação ou checagem não retornar verdadeiro, utilizamos o Exit() para parar a execução do escopo atual.

Suponha que queremos somar dois números inteiros, mas só queremos números maiores que zero:

function Sum(A, B: Integer): string;
begin
  Result := 'Invalid result';
  if (A < 0) or (B < 0) then
    Exit;
  Result := Format('The result is %d', [A + B]);
end;

No exemplo acima, o retorno da função Sum é inicializado com um valor inválido e depois há uma validação para saber se os valores são menores que 0. Se o teste falhar, o programa irá retornar para o escopo anterior à chamada da função Sum com o resultado inválido. Mas se o teste não falhar, o resultado da função será a soma de A e B.

Há aqueles que são adeptos da programação estruturada e preferem não “quebrar” a execução do programa com uma “saída antecipada”, ou seja, não fazem uso do Exit() por acreditarem que o código ficaria mais simples.

Então vamos reescrever o exemplo anterior:

function Sum(A, B: Integer): string;
begin
  if (A > 0) and (B > 0) then
    Result := Format('The result is %d', [A + B]);
  else
    Result := 'Invalid result';
end;

Parece mais simples? Bem, nesse exemplo eu diria que sim. Porém para exemplos com mais condicionais, eu diria que não (vamos ver isso mais abaixo).

E se quiséssemos dizer ao usuário que seus dados não estão corretos?

function Sum(A, B: Integer): string;
begin
  Result := 'Invalid result';
  if (A > 0) then
  begin
    if (B > 0) then
      Result := Format('The result is %d', [A + B]);
    else
      Writeln('B should be greater than zero');
  end
  else
    Writeln('A should be greater than zero');
end;

Nesse exemplo não utilizamos Exit() e eu acho que o código está bem confuso. Os testes estão “separados” do retorno de aviso para o usuário (Writeln).

Kent Beck , Martin Fowler afirmaram categoricamente que “um ponto de saída não é realmente uma regra útil. A clareza é o princípio chave: se o método for mais claro com um ponto de saída, use um ponto de saída, caso contrário, não”

Então vamos reescrever o exemplo anterior com o uso de Exit():

function Sum(A, B: Integer): string;
begin
  Result := 'Invalid result';
  if (A < 0) then
  begin
    Writeln('A should be greater than zero');
    Exit;
  end;
  if (B < 0) then
  begin
    Writeln('B should be greater than zero');
    Exit;
  end;
  Result := Format('The result is %d', [A + B]);
end;

O código ficou um pouco maior, é verdade, porém os testes e avisos para o usuário ficaram mais simples, na minha opinião. Você não precisa acompanhar todos os if-else aninhados. A cada teste que falhar, o aviso está logo abaixo e o escopo será abortado com o uso do Exit(). Se todos os testes não falharem, a função irá retornar a soma de A e B.

No Delphi, a partir da versão 2009, o procedimento Exit() ganhou uma melhoria: Exit() pode ter um parâmetro especificando um resultado. O parâmetro deve ser do mesmo tipo que o resultado da função.

O FPC também tem a mesma definição, porém não sei quem implementou essa nova feature primeiro.

Então vamos reescrever o exemplo anterior:

function Sum(A, B: Integer): string;
begin
  if (A < 0) then
    Exit('A should be greater than zero');
  if (B < 0) then
    Exit('B should be greater than zero');
  Result := Format('The result is %d', [A + B]);
end;

Simples e limpo.

Exit() pode receber como parâmetro qualquer tipo de retorno, até mesmo instâncias de Interfaces. Utilizando esse parâmetro, é como se ganhássemos o mesmo comportamento da palavra reservada return, em Java. No entanto, Exit() em conjunto com Result nos dá ainda mais possibilidades de retorno para as funções.

Até logo.

Posts Relacionados

  • fpWeb: Verificando Vazamentos de Memória

  • Construindo uma Aplicação Básica com fpWeb

  • Desenvolvimento Web com fpWeb Framework

  • Encapsulamento

  • Classes Amigas

  • A Declaração WITH-DO Perfeita

  • A função Supports pode ser traiçoeira

  • Assertions é uma boa prática

  • Construtores Virtuais

  • Listas Genéricas, sem Generics