Compreendendo e usando loops na programação Delphi

O loop é um elemento comum em todas as linguagens de programação. Delphi tem três estruturas de controle que executam blocos de código repetidamente: for, repita... até e enquanto... Faz.

Suponha que precisamos repetir uma operação um número fixo de vezes.

// mostra 1,2,3,4,5 caixas de mensagem
var j: inteiro;
início
para j: = 1 para 5 Faz
início
ShowMessage ('Caixa:' + IntToStr (j));
fim;
fim;

O valor de uma variável de controle (j), que é realmente apenas um contador, determina quantas vezes uma instrução for é executada. A palavra-chave para configura um contador. No exemplo anterior, o valor inicial do contador é definido como 1. O valor final é definido como 5.
Quando a instrução for começa a ser executada, a variável do contador é definida como o valor inicial. Delphi than verifica se o valor do contador é menor que o valor final. Se o valor for maior, nada será feito (a execução do programa salta para a linha de código imediatamente após o bloco de código do loop for). Se o valor inicial for menor que o valor final, o corpo do loop é executado (aqui: a caixa de mensagem é exibida). Finalmente, o Delphi adiciona 1 ao contador e inicia o processo novamente.

Às vezes é necessário contar para trás. o até A palavra-chave especifica que o valor de um contador deve ser diminuído em um a cada vez que o loop é executado (não é possível especificar um incremento / decréscimo que não seja um). Um exemplo de um loop for que conta para trás.

var j: inteiro;
início
para j: = 5 até 1 Faz
início
ShowMessage ('T menos' + IntToStr (j) + 'segundos');
fim;
ShowMessage ('Para sequência executada!');
fim;

Nota: é importante que você nunca mude o valor da variável de controle no meio do loop. Fazer isso causará erros.

Escrever um loop for dentro de outro loop for (looping de aninhamento) é muito útil quando você deseja preencher / exibir dados em uma tabela ou grade.

var k, j: inteiro;
início
// este loop duplo é executado 4x4 = 16 vezes
para k: = 1 para 4 Faz
para j: = 4 até 1 Faz
ShowMessage ('Caixa:' + IntToStr (k) + ',' + IntToStr (j));
fim;

A regra para aninhar os loops seguintes é simples: o loop interno (contador j) deve ser concluído antes que a próxima instrução do loop externo seja encontrada (contador k). Podemos ter loops triplos ou quadruplicados, ou até mais.

Nota: Geralmente, as palavras-chave de início e fim não são estritamente necessárias, como você pode ver. Se begin e end não forem utilizados, a instrução imediatamente após a instrução for será considerada o corpo do loop.

Se você possui o Delphi 2005 ou qualquer versão mais recente, pode usar a "nova" iteração de estilo para elemento na coleção sobre contêineres. O exemplo a seguir demonstra iteração sobre expressões de cadeia: para cada caractere na sequência, verifique se o caractere é 'a' ou 'e' ou 'i'.

const
s = 'Sobre a programação Delphi';
var
c: char;
início
para c dentro s Faz
início
E se c dentro ['a', 'e', ​​'i'] então
início
// faça alguma coisa
fim;
fim;
fim;

Às vezes, não saberemos exatamente quantas vezes um ciclo deve circular. E se quisermos repetir uma operação até atingirmos uma meta específica?

A diferença mais importante entre o loop while-do e o loop de repetição até é que o código do repetir declaração é sempre executado pelo menos uma vez.

O padrão geral quando escrevemos um tipo de loop de repetição (e while) no Delphi é o seguinte:

repetir
início
afirmações;
fim;
até condição = verdadeiro

enquanto condição = verdadeiro Faz
início
afirmações;
fim;

Aqui está o código para mostrar 5 caixas de mensagens sucessivas usando repetir até:

var
j: inteiro;
início
j: = 0;
repetir
início
j: = j + 1;
ShowMessage ('Caixa:' + IntToStr (j));
fim;
até j> 5;
fim;

Como você pode ver, a instrução repeat avalia uma condição no final do loop (portanto, o loop de repetição é executado com certeza pelo menos uma vez).

A instrução while, por outro lado, avalia uma condição no início do loop. Como o teste está sendo realizado na parte superior, geralmente precisamos garantir que a condição faça sentido antes do processamento do loop, se isso não for verdade. compilador pode decidir remover o loop do código.

var j: inteiro;
início
j: = 0;
enquanto j <5 Faz
início
j: = j + 1;
ShowMessage ('Caixa:' + IntToStr (j));
fim;
fim;

Os procedimentos de interrupção e continuação podem ser usados ​​para controlar o fluxo de instruções repetitivas: O procedimento faz com que o fluxo de controle saia de uma instrução for, while ou repita e continue na próxima declaração seguindo o loop declaração. Continuar permite que o fluxo de controle prossiga para a próxima iteração de operação repetida.