Do básico ao intermediário: Comando WHILE e DO WHILE

Introdução

O conteúdo exposto aqui, visa e tem como objetivo, pura e simplesmente a didática. De modo algum deve ser encarado como uma aplicação final, onde o objetivo não seja o estudo dos conceitos aqui mostrados.

No artigo anterior Do básico ao intermediário: Comando IF ELSE, foi explicado como estudar um código afim de conseguir implementar um controle de fluxo condicional. Isto para que dependendo da expressão que viesse a ser analisada. Pudéssemos escolher se uma ou outra rotina seria executada.

Apesar do comando IF em conjunto com seu aliado ELSE, serem bastante uteis a ponto de conseguirmos implementar qualquer código usando somente os dois. Isto na prática não seria muito prudente. Já que tornaria diversos pontos do código, algo um tanto quanto complicado de ser compreendido de maneira rápida e sem grandes agravantes.

Justamente por conta disto, é que linguagens de programação, não fazem uso apenas deste casal IF ELSE. As linguagens, para tornar o código mais simples e fácil de ser compreendido, implementam um número maior de instruções. Entre elas instruções de laço.

As instruções de laço, em termos gerais, e sem querer fazer com que você entre em pânico, meu caro leitor. É, e talvez será por um longo tempo, as instruções de controle de fluxo, mais perigosas que existe. Isto por que, qualquer falha mínima durante a programação, ou implementação de um laço, pronto. Já era. Seu código entrará em um loop infinito. O que é algo temeroso. Sendo a causa de diversas desistências, por parte de iniciantes. Fazendo com que eles fiquem completamente apavorados, quando precisam implementar um laço, em seus códigos.

Existem basicamente duas formas de se criar um laço, em um código. A primeira é fazendo uso de funções e procedimentos fora da rotina principal, onde o laço seria implementado. A segunda é utilizando algum comando de controle de fluxo.

Como o uso de comandos é algo mais simples. Iremos fazer isto neste momento. Porém, conforme formos avançando, irei mostrar como criar laços usando funções e procedimentos para isto. Diferente do que muitos possam imaginar. Existe sim um motivo para se usar uma função ou mesmo um procedimento, para se criar um laço. Isto ao invés de usar um comando como veremos daqui a pouco. Mas explicar o motivo para isto, será tema para um outro artigo, em um momento mais oportuno.

Existe um pré-requisito para conseguir acompanhar este artigo. O mesmo é compreender sobre variáveis e constantes. E já falamos sobre isto. No entanto, muito mais do que saber sobre variáveis e constantes. A coisa mais importante aqui, é entender o que a largura de bits faz com os valores. E como o tipo da variável pode afetar o valor da mesma.

Se você não faz ideia do que estou falando, veja Do básico ao intermediário: Operadores, ali explico algumas coisas referentes a esta questão. Apesar do conteúdo ali ser básico. Ele já será suficiente para que você consiga acompanhar o que será explicado aqui. No entanto, não deixe de ver os outros artigos, para uma melhor compreensão de tudo que será apresentado neste artigo.

Ok. Neste momento tenho um pequeno dilema para me decidir. Apesar do comando FOR, ser virtualmente mais simples, para criação de laços, sendo em muitos casos o queridinho dos programadores. Ele contém alguns agravantes nele. Porém os demais comandos que tornam possível a criação de laços, são um pouco mais perigosos que o comando FOR. Então estou pensando qual mostrar primeiro. Muito bem, até que eu me decida, vamos fazer o seguinte: Vamos iniciar um novo tópico para que eu possa explicar algumas coisas importantes sobre este assunto.

Por que usar laços

Muitos programadores tem pavor, literalmente, quando precisam criar um laço em seus códigos. Outros evitam ao máximo, e só fazem isto, quando são obrigados a tal coisa. Mas porque todo este medo de usar laços? O motivo para isto é simples. Laços são um risco assumido. Toda vez que você entra em um, fica a mercê do seu código. Precisando para isto tomar algum tipo de medida a fim de encerrar o laço quando necessário. Isto porque, muitas vezes um laço pode entrar em um loop infinito, e você sem perceber, acha que o computador está demorando demais para fatorar algo. Quando na verdade, o que aconteceu foi que o código entrou em um laço infinito.

Um outro motivo pelo qual muitos temem o uso de laços, é que muitas das vezes é difícil analisar o que este acontecendo ali dentro. Isto pelo simples motivo, que em situações reais, um laço precisará ser executado milhares ou milhões de vezes antes de terminar. E dependendo do tipo de fatoração que esteja sendo feita ali. Isto pode demorar horas para que a aplicação entregue o resultado final. Sei que para muitos isto parece ser algo inconcebível. Como assim um programa irá demorar horas para que execute uma tarefa? Mas sim, meu caro leitor. Existem situações em que de fato o tempo necessário para que uma tarefa seja cumprida, pode chegar na ordem de horas. Porém aqui, como o objetivo é a didática, e na maior parte das vezes, os laços que muitos de vocês irão criar, serão laços pequenos, com ordem de grandeza de milhares de interações. Isto normalmente faz com que a aplicação demore segundos, ou poucos minutos para ser finalizada. Com por exemplo aplicações visando treinamento de uma rede neural.

No meu outro perfil, estou mostrando como implementar este tipo de coisa. Uma rede neural, completamente escrita em MQL5 puro. Aquele tipo de aplicação, ao meu ver, é uma do nível intermediário. Já que você apenas precisa de um bom conhecimento em MQL5 e também da matemática envolvida. O resto é fácil e simples de fazer.

Ok. No entanto, ainda não respondi à pergunta do título deste tópico: Por que usar laços? O motivo é simplicidade para o seu código. O uso de laços, irá permitir que você venha a controlar quantas vezes algo deverá ser feito. Isto sem precisar digitar, ou usar de CTRL+C e CTRL+V para controlar algo. Vamos pensar no seguinte objetivo. Lá no começo, mostrei um código bem simples, cujo objetivo seria apresentar o valor fatorial de um número qualquer. O código em si, é muito simples como você deve se lembrar. Para quem não viu, ele é mostrado logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     uchar counter = 0;
07.     ulong value = 1;
08. 
09.     Print("Factorial of ", counter, " => ", value);
10.     counter = counter + 1;
11.     value = value * counter;
12.     Print("Factorial of ", counter, " => ", value);
13.     counter = counter + 1;
14.     value = value * counter;
15.     Print("Factorial of ", counter, " => ", value);
16.     counter = counter + 1;
17.     value = value * counter;
18.     Print("Factorial of ", counter, " => ", value);
19.     counter = counter + 1;
20.     value = value * counter;
21.     Print("Factorial of ", counter, " => ", value);
22. }
23. //+------------------------------------------------------------------+

Código 01

Este código 01, para números pequenos, até que pode ser aceitável. Porém conforme os números vão crescendo a coisa começa a ficar um pouco complicada. Mesmo para um fatorial de 20, já seria algo muito complicado de ajustar. Além da enorme possibilidade de erros no momento de implementar o código. Mesmo usando CTRL+C e CTRL+V. Assim no mesmo artigo em que este código 01 surge, montamos um outro, este pode ser visto logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     Factorial();
07.     Factorial();
08.     Factorial();
09.     Factorial();
10.     Factorial();
11. }
12. //+------------------------------------------------------------------+
13. void Factorial(void)
14. {
15.     static uchar counter = 0;
16.     static ulong value = 1;
17. 
18.     Print("Factorial of ", counter, " => ", value);    
19.     counter = counter + 1;
20.     value = value * counter;
21. }
22. //+------------------------------------------------------------------+

Código 02

Aqui, você já passa a notar que temos um código um pouco mais enxuto. Tornando assim um pouco mais fácil usar CTRL+C e CTRL+V para fatorações pequenas. Porém, e se você precisar fatorar um número um pouco maior, como seria? Bem, se você não estourasse o limite superior de 64 bits, do valor ulong. Você precisaria colar e copiar as camadas Factorial diversas vezes. Isto fora todo o trabalho para ajustar o código a cada mudança, onde um novo fatorial precisaria ser calculado. Definitivamente algo muito mais trabalhoso do que prazeroso. Sendo assim, o uso de um laço torna o código muito mais simples de ser trabalhado. E esta seria a explicação do porquê usar laços.

Tendo isto sido entendido e explicado, podemos começar a falar dos comandos a serem usados. E apesar do laço FOR, ser o queridinho entre grande parte dos programadores. Inclusive este que vós escreveis. Vamos começar com um outro comando. Que tem duas formas de ser utilizado. Porém é mais simples de ser explicado, e por consequência compreendido, do que o laço FOR, que tem alguns detalhes que me fez decidir em começar por outro comando.

Comando WHILE DO WHILE

Apesar da brincadeira no título deste tópico. Este laço é muito simples de ser compreendido. Já que ele segue os mesmos princípios do comando IF. Porém precisamos tomar alguns cuidados aqui. Isto por que, não é raro você acabar se enrolando ao utilizar este comando. E o motivo é simples: ESQUECIMENTO. Muitos programadores se esquecem de ajustar, ou corrigir a condição que faz com que este laço encerre. Por incrível que pareça, mesmo programadores bem experientes cometem este erro. Então já fica o alerta. Cuidado ao implementar um código que utilize este comando.

A diferença entre o comando WHILE e o casal DO WHILE é bem simples. WHILE as vezes não executa a rotina interna. Já DO WHILE irá executar a rotina pelo menos uma vez. Basicamente é isto. Simples não é mesmo? Porém, isto não diminui os riscos envolvidos. Então vamos começar com o mais simples deles. O comando WHILE. Este tem um fluxo de execução que pode ser visto na imagem abaixo.

Imagem 01

Observe que parece muito com o que foi visto no comando IF no artigo anterior. Tanto que a questão referente a expressão, tem o mesmo significado e princípio de uso aqui também. Ou seja, o laço somente executará a rotina definida nele. Se e somente se, a expressão for verdadeira. Ou seja, a expressão precisa ser diferente de zero. Por isto que o primeiro comando que expliquei foi o comando IF. Entender aquele comando é muito importante, para todo aquele que deseja se tornar um bom programador. Ou mesmo quem deseja criar programas de maneira ocasional. Só por diversão.

Maravilha. Como temos algo muito parecido com o comando IF. E espero que você, meu caro leitor, tenha feito o dever de casa, que seria estudar o comando IF. Aqui iremos ser um pouco mais diretos no assunto.

Primeiro vamos fazer um código muito simples. Apenas para que você coloque seus pés, no que seria um laço. Não para tomar um capote. Mas sim para ver como ele funciona na prática. Para isto, vamos analisar o código abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     char info = 10;
07. 
08.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
09. 
10.     while (info)
11.     {
12.         info = info - 1;
13.         Print(__FUNCTION__, " : ", info);
14.     }
15. 
16.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
17. }
18. //+------------------------------------------------------------------+

Código 03

Este código 03 ilustra muito bem, como um comando WHILE funciona. Então quando você o executar ele irá apresentar o seguinte resultado mostrado logo abaixo.

Imagem 02

A região marcada nesta imagem 02, é justamente a região que foi criada pelo laço. Sendo desta maneira a rotina executada pelo laço WHILE. Agora vamos dar uma rápida olhada e entender com isto ocorreu. E por que a contagem regressiva iniciou em nove e terminou em zero. Para isto, você precisa observar duas coisas. A primeira é o fato de que na linha seis, iniciamos a variável com o valor dez. Quando o comando WHILE testa a expressão, que no caso é o valor da variável definida na linha seis. E percebe que este valor é verdadeiro, o laço irá ser iniciado. Contudo, e este é o segundo ponto a ser observado. Antes de apresentar o valor no terminal. Isto na linha 13. Usamos a linha 12 a fim de diminuiu em uma unidade o valor da variável info. Por isto a contagem vai de nove até zero. E ela finaliza em zero, por que o valor zero é considerado um valor que representa o estado booleano falso.

Mas o que aconteceria se ao invés de subtrair uma unidade da variável info, na linha 12. Fizéssemos o incremento de uma unidade? Será que o laço entraria em um loop infinito? Bem, meu caro leitor, esta é uma dúvida muito boa e que você mesmo poderá experimentar para saber o que acontecerá. Mas antes de fazer isto, que tão entender por que o laço não entrará em um loop infinito. Neste caso especifico.

Diferente do que seria o senso comum. Onde vamos de menos infinito até mais infinito. Em computação as coisas não são bem assim. Existe um limite para qualquer valor que um computador poderá expressar. Este limite é definido pela largura de bits presente no tipo da variável utilizada. Já falamos sobre isto em outro artigo. Justamente por conta desta limitação, e que fique claro que existem linguagem que esta limitação não existe. Mas não vem ao nosso caso, pois estamos lidando com uma linguagem tipada. Se a mudança do valor for feita de forma que em algum momento ele irá atingir o valor zero. Isto implicará, que em algum momento o laço será encerrado. Não importa o tempo que venha a demorar. Em algum momento o laço será encerrado. Porém existem alguns problemas, justamente e especificamente aqui. Neste comando WHILE. Mas para não lhe confundir neste exato momento. Vamos deixar para ver isto, em outra oportunidade. Muito provavelmente irei falar sobre isto no próximo artigo.

Muito bem, sobre o comando WHILE, basicamente temos este tipo de coisa a ser falado. No entanto, existe um pequeno detalhe aqui, que talvez seja interessante ser explicado neste momento. Normalmente, quando queremos que um código funcione de maneira controlada. E isto falando especialmente de laços. Além da condição, normal de saída do laço. Adicionamos uma segunda condição. Esta condição, é apenas uma válvula de escape, onde podemos forçar um laço a ser encerrado, a fim de que o código continue a sua execução normal.

Como o MQL5, é uma linguagem baseada em eventos. E no futuro iremos falar mais sobre isto. Não é muito comum, criamos laços que venham a esperar que um ou outro evento ocorra. Isto é mais comum em linguagens como no caso do C / C++ onde a linguagem não é baseada em eventos.

Assim criamos laços, para gerar uma parada controlada da aplicação. E está parada irá permanecer ativa, por um tempo predeterminado, ou até que algum evento, também predeterminado ocorra. No entanto, não é muito comum fazer isto usando o laço WHILE diretamente. Isto por que ele apenas irá executar, pelo menos uma vez, se a expressão for verdadeira. E em muitos casos, não é isto que desejamos. Porém, no caso de uma saída emergencial. Este laço WHILE é uma melhor escolha. Já que se a expressão, for falsa, logo no início, não teremos a execução da rotina do laço WHILE. E muitas das vezes esta rotina, pode vir a influenciar o encerramento ou não do laço, baseado em certos critérios que iremos ver em breve, quando formos tratar do laço DO WHILE.

Mas vamos fazer o seguinte: Vamos de maneira PROPOSITAL, criar um laço que em teste será infinito. Porém, iremos criar uma condição para que ele seja encerrado. Este tipo de coisa pode ser visto logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     char info = 5;
07. 
08.     Print("Press ESC to finish counting...");
09. 
10.     while (!TerminalInfoInteger(TERMINAL_KEYSTATE_ESCAPE))
11.     {
12.         info = info - 1;
13.         Sleep(200);
14.         Print(__FUNCTION__, " : ", info);
15.     }
16. 
17.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
18. }
19. //+------------------------------------------------------------------+

Código 04

Aqui em código 04, temos um laço na linha dez, que em tese, iria executar para todo o sempre. Porém, ele não fará isto, caso o usuário venha a pressionar a tecla ESC. Mas observe que este alerta somente é dado uma única vez, e antes que o laço se inicie. Caso o usuário, venha a perder esta mensagem que será impressa no terminal a coisa pode ficar um tanto quanto problemática. No terminal você verá algo do tipo mostrado logo abaixo.

Imagem 03

Atenção ao fato, de que desta vez o valor da variável info, passou pelo zero. E mesmo assim, o laço continuou. Isto por que a expressão que diz quando o laço irá terminar, agora está ligada a condição de que a tecla ESC seja pressionada. Ou seja, estamos esperando um evento, para que o código possa continuar. Um outro teste que também podemos fazer. E este é bem mais comum de ser colocado em código MQL5. E o de checar se o código foi ou não interrompido. Para verificar isto, bastará mudar a linha dez do código 04, para a linha que é vista logo abaixo.

    while ((!TerminalInfoInteger(TERMINAL_KEYSTATE_ESCAPE)) && (!IsStopped()))

Esta simples mudança, permitirá que o laço no código 04, seja encerrado, tanto pressionando a tecla ESC. Quanto sendo encerrado pelo usuário, ao remover o script do gráfico. Algo muito simples, não é mesmo meu caro leitor? Por isto não faz sentido ficar com medo de laços. Porém, ainda temos o problema da mensagem da linha oito ficar perdida em alguma execução. Fazendo com que o usuário, não saiba, que pressionado ESC, também seria possível encerrar a aplicação.

Uma forma de resolver isto, é colocando a linha oito dentro do laço. Mas vamos fazer isto, usando a variação do comando WHILE. E esta é quando usamos o comando DO antes do comando WHILE. Mas para separar devidamente as coisas. Vamos a um novo tópico.

Comando DO...WHILE

Novamente não resisti a brincadeira no título deste tópico. Porém esta brincadeira, é quase que a descrição do comando DO WHILE. Isto por que, apesar de ser um comando, ele é na verdade um casal. Assim como acontece no casal IF ELSE. No entanto, aqui a coisa funciona de uma maneira um pouco diferente.

Acredito que você deve ter compreendido que comando WHILE, visto no tópico anterior. Apenas será executado, pelo menos uma única vez, se a condição da expressão for verdadeira. Entretanto, devido, justamente ao fato de termos um comando DO, que significar literalmente, FAÇA, antes do comando WHILE, que significa literalmente, ENQUANTO. Termos a execução da rotina dentro do laço, pelo menos uma vez. Este tipo de coisa, em muitos cenários é algo interessante e até mesmo bastante desejável. Isto por que, podemos modelar melhor como certas rotinas irão trabalhar. Quando elas precisam ser executadas, pelo menos uma única vez.

Para exemplificar, vamos pegar o código 04, e o modificar de uma forma a fazer com que a mensagem da linha oito, apareça de tempos em tempos. Sei que poderíamos fazer isto diretamente no código 04. Mas vamos fazer de conta que não seria possível fazer isto, sem duplicar a linha oito. Porém, e o mais importante, é que queremos o laço executado pelo menos uma vez. Independentemente do que tenha ocorrido antes de ele ser executado.

Assim sendo, temos o código que é mostrado logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     char info = 10;
07. 
08.     do
09.     {
10.         if (((info / 5) * 5) == info) Print("Press ESC to finish counting...");
11.         info = info - 1;
12.         Sleep(200);
13.         Print(__FUNCTION__, " : ", info);
14.     }while (!TerminalInfoInteger(TERMINAL_KEYSTATE_ESCAPE));
15. 
16.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
17. }
18. //+------------------------------------------------------------------+

Código 05

Ao executar este código você verá algo parecido com o que é mostrado abaixo.

Imagem 04

Aqui temos algumas coisas sendo feitas, que são de certa forma bastante interessantes de serem compreendidas. Isto porque, algumas das coisas feitas neste código 05, podem não fazer muito sentido. Mas se você tem prestado atenção e vem estudando com calma os artigos que tenho postado. Conseguirá entender as coisas de maneira bem rápida.

Ok, vamos entender o que está ocorrendo aqui, e por que agora temos a mensagem dizendo para pressionar ESC sendo mostrada de tempos em tempos. Como você pode notar, devido ao fato de que agora o teste para seguir ou não executando a rotina dentro do laço, está sendo feita, lá na linha 14. Temos todo o corpo da rotina interna ao laço, sendo executada pelo menos uma vez. Agora você irá entender porque existe o comando DO neste casamento com o comando WHILE.

Agora preste muita atenção ao que irei explicar, pois é muito importante. A ideia aqui é a mesma do comando WHILE. Ou seja, o laço será executado até que a expressão no comando WHILE seja falsa. Porém como você poderia saber onde o laço começa? Se você remover a linha oito, você não saberia onde, de fato o laço começa. E pior, a rotina que deveria estar presente no laço, e que vai da linha dez até a linha treze. NÃO SERIA vista como rotina. Mas sim como um código simples. Já o comando WHILE presente na linha 14, este sim seria um laço. Porém, toda via e, entretanto, teria como rotina, uma rotina vazia. Já que nenhum outro comando seria executado dentro do laço. Ele apenas iria ficar ali esperando para que a tecla ESC fosse pressionada a fim de que seja encerrado.

No entanto, justamente por conta do casamento entre o comando DO e o comando WHILE, é que o compilador, assim como outros programadores, saberá que o laço se inicia na linha 8 e vai até a linha 14. Parece um pouco confuso, tentar entender isto logo de cara. Mas fica muito simples se você remover o comando DO da linha oito. Fazendo com que o código fique como mostrado logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     char info = 10;
07. 
08. 
09.     {
10.         if (((info / 5) * 5) == info) Print("Press ESC to finish counting...");
11.         info = info - 1;
12.         Sleep(200);
13.         Print(__FUNCTION__, " : ", info);
14.     }while (!TerminalInfoInteger(TERMINAL_KEYSTATE_ESCAPE));
15. 
16.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
17. }
18. //+------------------------------------------------------------------+

Código 06

Entretanto, devido a esta pequena mudança no código, algo que passa totalmente desapercebido. O resultado é completamente diferente. Devido a isto, para tornar mais claro, não usarei uma imagem, mas sim uma animação para mostrar o que acontece. Esta pode ser vista logo abaixo.

Animação 01

Aqui é onde mora um dos perigos de criar laços sem prestar a devida atenção. Note que não temos mais o mesmo comportamento visto na imagem 04. Aqui o que seria o corpo do laço, foi executado como se fosse uma sequência de código comum. No entanto, parou ali, e o código entrou no laço que é mostrado na linha 14. Devido a isto, se a condição de encerramento do laço, estivesse ligada a algo que seria feito na rotina do laço. Este algo jamais ocorreria e por consequência um laço que funcionaria e teria um ponto para ser encerrado. Jamais seria encerrado, entrando assim no temido laço infinito.

Mas então, vamos entender como e por que a mensagem da linha 10 está sendo impressa, de tempos em tempos. Para isto, é necessário entender a expressão presente no comando IF da linha dez. Esta expressão, que para humanos não faz sentido, para um computador faz todo sentido. Isto se estivermos usando uma linguagem tipada, assim como acontece no MQL5.

Já foi mencionado em outro artigo, a respeito de cálculos matemáticos em linguagem de programação. Sendo assim, esta expressão, aparentemente idiota e sem sentido, que é dividir o valor da variável info, por um número e logo depois multiplicar o resultado por este mesmo número. Parece uma pura besteira. Porém, volto a enfatizar, que você procure ler os artigos anteriores, caso esteja começando a pensar em programação. Isto por que, ao fazer esta conta que estamos fazendo aqui. O resultado pode ou não ser igual ao que existia na variável info. Se for igual, a mensagem será impressa. Se for diferente ela não será impressa.

Como este código estará no anexo, você pode estudar isto como mais calma. O único cuidado a ser tomado é usar o mesmo valor tanto na divisão, quanto na multiplicação. E sempre dividir antes de multiplicar. Mas tome cuidado para usar valores inteiros. Usar valores do tipo ponto flutuante não irá funcionar. Isto devido a algumas questões que iremos ver em outro momento.

Para finalizar este tópico. Vamos ver o que seria o esquema do fluxo de execução do casal DO WHILE. Este pode ser visto logo abaixo.

Imagem 05

Note que não é tal complicado quanto parece ser, antes de vermos tudo em ação. Entender este fluxo de execução, é muito mais importante do que decorar comandos e sintaxe dos mesmos. Pois entendendo como o fluxo de execução funciona, você conseguirá pensar de maneira mais clara. Assim conforme for praticando e estudando o que cada pequena decisão tomada durante a execução do fluxo, influência no resultado final. Você acabará se tornando um programador, mesmo que nas horas vagas. Muito bom e capaz inclusive de aprender outras linguagens de programação. Não ficando apenas restrito a esta ou aquela linguagem.

Considerações finais

Muito bem, neste artigo, tentei da maneira a mais didática e simples possível. Apresentar algo que muitos consideram ser um pesadelo. Sendo quase que o bicho papão de muitos programadores iniciantes. Porém, acredito ter mostrado que, se você tiver paciência. Calma e principalmente atenção ao que está sendo implementado. Seja por você, seja por outro programador, cujo código você pretende estudar e compreender. Poderá fazer diversas coisas bem interessantes. Algumas delas, de maneira muito mais simples e sem desperdiçar seu tempo com bobagens.

Isto por que, laços, se bem utilizados e implementados da maneira correta. Podem lhe poupar muito tempo, tentando entender ou pensando em forma de criar certas condições. Tanto que os códigos visto no começo deste artigo, onde mostrei a fatoração de números, usando não laços, mas sim chamadas sequenciais, pode ser escrito de uma forma muito mais compacta e por consequência, muito mais interessante. Isto é mostrado logo abaixo. Apenas para demonstrar que podemos fazer muitas coisas legais com laços.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     uchar counter = 0;
07.     ulong value = 1;
08. 
09.     while (counter < 5)
10.     {
11.         counter = counter + 1;
12.         value = value * counter;
13.     }
14. 
15.     Print("Factorial of ", counter, " => ", value);
16. }
17. //+------------------------------------------------------------------+

Código 07

Experimente modificar o código 02 para usar um laço no lugar daquelas chamadas sequenciais, que estão entre as linhas seis e dez. Se você não conseguir, bolar nenhuma forma de fazer isto. Não tem problema. No próximo artigo iremos voltar a falar sobre laços. Pois ainda não foi explicado tudo sobre eles. Então comece a praticar, antes de que seja tarde demais.