Do básico ao intermediário: Comando FOR

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 SWITCH, foi explicado e demonstrado o comando switch em seu modo mais básico e simples de utilização. É muito importante que você consiga e tente compreender como cada um daqueles comando, visto até o momento funcionam. Não de forma a decorar a coisa, mas sim a ponto de conseguir pensar forma de utilizar cada um dos comandos e conhecimento mostrado até este momento.

Sei que muitos de vocês podem estar achando tudo isto muito simples e sem muito critério. Já que poderíamos estar vendo um material mais avançado. Porém, pela experiência que tive ao longo de anos programando, percebi que se conceitos básicos forem bem assimilados. Coisas mais elaboradas e complexas, se tornam muito mais simples de serem compreendidas. Mesmo em um primeiro contato. E é justamente isto que estou tentando fazer nestes artigos. Quero que você, meu caro leitor, consiga entender como cada coisa funciona em seu nível mais simples e básico. Para quando vier a ser mostrado um material um pouco mais avançado. Você consiga compreende-lo de maneira bem mais rápida. Sem grandes dificuldades.

Muito bem, entre todos os comandos existentes no MQL5, cujo objetivo é o controle do fluxo de execução de uma aplicação. Somente falta falar de um, que neste caso é o último comando que existe para tal proposito dentro do MQL5. E sim, estou falando do comando FOR. Porém, como você muito provavelmente deve ter notado. Gosto sempre de começar a falar das coisas, em tópicos diferentes. Assim fica mais fácil de acompanhar e separar as explicações que precisam ser dadas. Sendo assim, vamos iniciar um novo tópico.

Premissas do comando FOR

Apesar de muitos iniciantes, imaginarem que existe uma enormidade de comandos a serem vistos. Grande parte das linguagens de programação, contam apenas com poucos comandos. Isto quando estamos falando em comandos de controle de fluxo de execução. Não confunda isto, com chamadas de biblioteca, ou palavras reservadas. Pois uma coisa nada tem a ver com a outra. Comandos de controle de fluxo, normalmente são bem poucos mesmo. Já chamadas de biblioteca, palavras reservadas, assim como funções e procedimentos auxiliares. Estes podem chegar a uma ordem de grandeza que muitas vezes ultrapassam os milhares. Isto em uma mesma linguagem de programação. Como por exemplo no C/C++. A quantidade de comandos de controle de fluxo é pequena. Porém se você for observar a quantidade de funções e procedimentos auxiliares, que existem, isto sem contar as chamadas de biblioteca. Você irá notar que é praticamente impossível, alguém dominar completamente a linguagem. O que acontece de fato, é que o programador se especializa em um determinado ramo de atividade. Mas como ele compreende e tem uma base bastante sólida na linguagem. Ele, programador, consegue lidar com qualquer problema. Desde que lhe seja dado tempo suficiente para que ele adapte seu conhecimento, ao que seja necessário para resolver o problema a ele apresentado.

Por conta disto, que mesmo programadores com uma vasta carga de conhecimento, estão sempre estudando. Eles nunca param de estudar e procurar se atualizar, a respeito de novas e possíveis tendência. Diferente do que muitos pensam quando começam a estudar programação. Pois muitos imaginam que, o fato de conhecer algumas coisas, já os tornam programadores. Quando na verdade não é bem assim. É preciso sempre estar estudando e tentando aprimorar antigas técnicas. Somente assim você alcançará um nível de excelência digna de dizer: EU SOU UM PROGRAMADOR.

Ok, e por que estou dizendo estas palavras? O motivo para isto, é muito simples meu caro leitor. Com tudo que foi visto até este momento. Você, se procurar estudar e se aprofundar apenas no que já foi mostrado, conseguirá lidar com praticamente qualquer problema de programação. Isto por que o comando FOR é na verdade um comando de laço. Porém já vimos como trabalhar com laços usando o comando WHILE e o casal DO WHILE. Por que então, necessitaríamos de um outro comando para trabalhar e construir laços? Isto não faz muito sentido, não é mesmo?

Bem, na verdade, existe sim um motivo para que o comando FOR exista junto com os comandos WHILE e o casal DO WHILE. E o motivo para isto é simples. Existem situações em que o comando WHILE ou mesmo o casal DO WHILE, não são adequados. Sei que parece um pouco estranho falar este tipo de coisa. Mas sim. Existem situações em que é preferível utilizar o comando FOR, ou invés do comando WHILE ou mesmo do casal DO WHILE. E muitas destas situações tem a ver com o uso ou não do comando CONTINUE dentro do laço.

Porém, e é importante que se entenda muito bem este porém. O comando FOR é de longe o comando queridinho dos programadores. Isto por que, um mesmo código usando-o, é mais claro e legível que o mesmo laço escrito de tal forma a usar o comando WHILE ou DO WHILE. Mas por que? O motivo é que o comando FOR geralmente, e isto também é importante ser frisado, tem todos os passos envolvidos no controle do laço, em seu corpo de declaração. Enquanto os comandos WHILE e DO WHILE, o controle fica, meio que jogado em algum ponto da rotina do laço. Este simples fato faz com que os programadores prefiram o comando FOR, já que para corrigir, modificar e até mesmo entender o laço. Bastará observar o próprio comando FOR. O que é muito mais simples do que procurar dentro da rotina do laço, os pontos que estão controlando o próprio laço.

Mas espere um pouco aí. Se você sabe que o comando FOR é mais simples que os demais, para controlar um laço. Por que só agora você está falando dele? Não seria melhor ter mostrando-o antes? Esta é uma questão, um tanto quanto controvérsia meu caro leitor. Isto por que, apesar do comando FOR ser de fato mais simples. E isto a princípio. Existem algumas características nele que podem tornar ele bem complexo. Devido a isto, decidi mostrar primeiramente os comandos WHILE e DO WHILE, e deixar o comando FOR como sendo o último a ser mostrando.

Mesmo que aqui, inicialmente, iremos ver o comando na sua forma mais simples e básica. Será muito mais fácil para mim, e para você, desde que você tenha estudado os comandos anteriores. Explicar como o comando FOR trabalha. Talvez eu devesse adiar um pouco mais esta explicação. Isto por conta que ainda não falei sobre regras de precedência de operadores. E estas regras tem um impacto muito profundo na atividade de programação em si. No entanto, mesmo sem ter explicado tais regras. Ainda assim podemos fazer algumas coisas utilizando os comandos de controle de fluxo. Isto de fato, me permite criar um material voltado para um nível de leitor, que realmente está tendo os primeiros contatos com a programação, se baseando nestes artigos, e na própria documentação do MQL5. Este seria o cenário ideal. Mas como sei que muitos já tem algum contato com a programação, mesmo sem de fato a entender direito. Consigo produzir algo que ficaria em um meio termo. Nivelando assim todos para o que será visto em um outro momento.

Muito bem, mas agora chegou a hora de ver este comando FOR em ação. Mas vamos separar as coisas em um outro tópico. Pois quero que este primeiro contato, seja agradável a todos.

Comando FOR

Como a maneira mais simples de apresentar um comando novo, é apresentar ele usando algo já visto. Vamos fazer o seguinte: Iremos neste primeiro momento, usar os scripts que foram vistos no artigo onde foi explicado o comando WHILE e o casal DO WHILE. Assim, a transição será mais suave e sem causar espanto ou medo em ninguém. Assim sendo, entenda este primeiro contato, como se fosse uma tradução daqueles códigos, em outros. Porém desta vez usando somente o comando FOR.

Vamos começar pelo código mais simples de todos e este é mostrado logo 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 01

Sendo este o código mais simples de todos. Antes de vermos a tradução deste código para usar o comando FOR, é necessário que você tenha conhecimentos sobre tempo de vida de uma variável, assim como a diferença entre uma variável global e uma variável local. Estes conceitos e conhecimento foi passado nos primeiros artigos desta sequência. Então, se você não sabe a diferença entre variáveis globais e locais, volte nos primeiros artigos para que você consiga acompanhar o que será explicado aqui. Comece por este Do básico ao intermediário: Variáveis (I).

Considerando que você já tenha o conhecimento necessário, vamos traduzir o código 01 para usarmos o comando FOR. Como existem diversas formas de se fazer isto. E cada uma adiciona ou modifica algo no código. Vamos começar aplicando uma que irá fazer o código se parecer muito com o código 01. Esta pode ser observada logo 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.     for( ; 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 02

Este código 02, mostra a primeira forma de se trabalhar com o comando FOR. Note que mudamos apenas a linha dez. No entanto o resultado é o mesmo. Tanto para o código 01, quanto para o código 02. E ele pode ser observado na imagem que se vê na sequência.

Imagem 01

Mas olhando este código 02, você talvez esteja um tanto quanto confuso. Isto por que, se você já viu outros comandos FOR. Este mostrado na linha dez é muito diferente do que normalmente se encontra na maioria dos códigos. Justamente por conta disto, que é necessário que você, meu caro leitor, procure assimilar o conhecimento que foi mostrado nos artigos anteriores. O comando FOR, não é um comando qualquer. Ele na verdade é dividido em três partes. Sendo que cada uma tem um objetivo bastante claro e que precisa ser muito bem compreendido. Antes de falarmos em como esta divisão é feita. Vamos ver uma segunda alternativa para este mesmo código 01. E esta alternativa é vista logo 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.     for( ; info; info = info - 1)
11.         Print(__FUNCTION__, " : ", info);
12. 
13.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
14. }
15. //+------------------------------------------------------------------+

Código 03

Agora preste atenção, meu caro leitor. Isto que você pode observar no código 03, NÃO É A MESMA COISA DE ANTES. Isto por que, o valor da variável info, NÃO SERÁ MODIFICADA, como você esperaria. Ela será sim modificada, mas o resultado será diferente. Então quando você executar o código 03, irá na verdade obter o resultado visto logo abaixo.

Imagem 02

Mas por que o resultado ficou diferente? Isto parece ser algo um tanto quanto estranho. Será que neste caso não poderíamos utilizar o comando FOR, para criar o laço? Bem, meu caro leitor, vamos por partes. Primeiro, podemos sim utilizar o comando FOR para este laço que estamos fazendo. Isto a fim de manter o resultado como é visto na imagem 01. Porém, e é neste momento que muitas coisas podem ficar confusa para muitos. Será preciso entender qual é a importância da variável info. Pois tudo dependerá dela, e não necessariamente do laço FOR. E por que estou dizendo isto? Por que dependendo do caso, precisamos usar um ou outro método para que o comando FOR visto no código 03, tenha o mesmo resultado apresentado pelo código 02. Por conta disto, você não deve tentar decorar a forma de trabalhar do comando. Mas sim entender como o comando funciona.

É neste momento que as coisas ficam confusas, e muitos desistem de tentar aprender como usar o comando. Porém vou tentar mostrar isto de uma maneira o mais simples possível. Vamos supor que a variável info, precise de fato ser declarada na linha seis. O motivo, não importa, apenas queremos que ela seja definida na linha seis. Segundo ponto, queremos que a variável info, seja modificada pelo laço. De forma que seu valor final será o valor que a fizer sair do laço. No entanto, neste momento existe um pequeno problema aqui. Mas não vamos nos preocupar com isto neste instante. Vamos manter as suposições neste momento. Se você verificar o valor da variável info, no código 01, depois que ela passar pelo laço, irá ver que este valor é igual a zero. A mesma coisa acontece no código 02. No entanto, no código 03, o valor será igual a um. Porém, como você pode observar na imagem 02, o primeiro valor é dez, e não nove como seria o esperado.

Você então pensa, e se mudarmos o valor da declaração vista na linha seis de dez para nove? O que será que ocorreria? Bem, meu caro leitor, isto eu vou deixar como curiosidade para que você mesmo analise o resultado. No entanto, você precisa entender e pensar outra coisa. Ao modificar o valor na linha seis, pode ser que algum cálculo, ou teste que esteja sendo executado usando a variável info, venha a ser comprometido. Por isto não é bom fazer as coisas, sem entender antes o que está ocorrendo no código. A ideia aqui, não é mexer em qualquer ponto do código. Mas sim mexer apenas no que está sendo feito na linha dez.

Ok. Podemos simplesmente usar o código 02 e pronto. Já que ele funciona. Ou mesmo usar o código 01, que também funciona. Mas será que ainda assim não teria um outro jeito de usar o comando FOR, para resolver o nosso problema? Na verdade, existe sim uma maneira. Mas ela é um pouco mais avançada do que o material que pretendo mostrar neste primeiro momento. De qualquer forma, posso mostrar uma outra coisa, que pelo menos fará com que o resultado seja mais próximo do esperado e visto na imagem 01.

Assim levando em consideração todas as suposições anteriores, podemos usar um código parecido com o visto logo 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.     for(info = info - 1; info; info = info - 1)
11.         Print(__FUNCTION__, " : ", info);
12. 
13.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
14. }
15. //+------------------------------------------------------------------+

Código 04

Este código 04, ainda está dentro do que considero ser um material básico. Se bem que aqui começamos a entrar em outras questões. Mas mesmo assim, é uma forma básica de utilizar o comando FOR. Isto para que o fluxograma que veremos em breve faça sentido. Ao executar este código, você irá ver o seguinte resultado, mostrado na sequência.

Imagem 03

Não entendi. Agora começamos a contagem em nove, assim como pode ser isto na imagem 01. No entanto, a contagem parou em um, assim como na imagem 02. Por que? Será que o valor da variável info, depois de ter passado pelo laço é diferente do valor que seria encontrado nos demais código. Principalmente no código 01? Não meu caro leitor. O valor da variável info, em todos estes códigos, depois de ter passado pelo laço. É e continua sendo igual a zero. Porém o problema aqui é outro. O valor que estamos imprimindo não é o valor real da variável info. Mas sim o valor da variável durante aquela interação com o laço FOR. Isto parece um tanto quanto confuso. Mas é isto mesmo que está ocorrendo. Para você entender isto, precisamos recorrer a um código um pouco diferente. Mas antes de fazer isto, vamos ver como seria o fluxo de execução dentro do comando FOR. Então vamos a um novo tópico.

Fluxo de execução

O fluxo de execução do comando FOR, é um pouco mais confuso à primeira vista, que os demais vistos anteriormente. Porém uma vez que você o entenda, ele tornará bem mais claro, compreender por que tivemos valores tão diferentes, nas saídas vistas no tópico anterior. O fluxograma pode ser visto logo abaixo.

Imagem 04

Aqui, usei cores diferentes nas setas para poder explicar em detalhes como o comando FOR funciona. Você pode estar estranhando a presença do comando IF aqui neste fluxograma. Porém ao colocar este comando IF, fica consideravelmente mais simples explicar o que está acontecendo aqui.

Ok, vamos por partes. A primeira parte é a palavra reservada for, propriamente dita. Isto inicia o que será o corpo do laço. Logo em seguida temos a expressão 01. Está pode ser muitas coisas. Mas observe que ela é executada somente uma única vez. Normalmente a usamos para inicializar o que seria as variáveis locais dentro do laço. Mas também podemos usar esta expressão 01, para ajustar algum valor global. Como foi feito no código 04. Aqui vale destacar que também podemos ter esta expressão sendo do tipo vazia. Quando fazemos isto, como ocorreu nos códigos 02 e 03. O compilador, passa direto. Não tendo assim nenhum outro trabalho, seja para ajustar ou mesmo declarar alguma variável ou valor. Existem alguns cuidados, ao se declarar variáveis aqui. Mas neste momento, vamos ficar somente no básico da coisa. Então iremos usar variáveis globais, ou uma expressão vazia.

Uma vez que esta expressão 01 tenha sido executada, teremos o que vemos no fluxograma como sendo um comando IF. Neste momento estaremos testando a expressão 02. De certa forma, o correto aqui, não seria colocar um IF, mas sim um WHILE. No entanto, como o comando WHILE é um comando de laço. Acho que ficaria muito confuso entender que estamos lidando com um comando FOR e não com um comando WHILE. De qualquer maneira, se a expressão 02 for falsa, o laço FOR será encerrado. Caso a expressão 02 se mostre verdadeira, iremos ter a execução da rotina contida no corpo do laço. Isto no caso poderia ser a linha 11 nos códigos 03 e 04, ou o bloco entre as linhas 11 e 14 no código 02. Em qualquer caso, quando a rotina estiver sido executada, teremos a execução da expressão 03. Este tipo de coisa é bem interessante em diversos casos. Como veremos em breve. Isto por que, dependendo de como o laço seja pensado, e do objetivo que iremos impor a ele. Podemos ter diversas construções levemente diferentes aqui. E por conta que esta expressão 03, caso exista algo ali, a ser executado. Torna mais seguro o laço FOR do que os demais tipos de laços. Isto pelo simples motivo, de que não correríamos o risco de esquecer de mudar o valor da variável que será testada na expressão 02.

Sinceramente, na prática, este fluxograma é bem mais simples de ser entendido do que nesta imagem. Mas você pode notar que estou utilizando algumas setas em verde. Estas setas indicam justamente como o laço é efetuado. Já as setas em vermelho mostram como o laço será encerrado.

Sendo assim, se você observar, a analisar com calma, notará que faz sentido que a variável info, depois de passado pelo laço tenha o valor zero. Mas também faz sentido, o fato de olharmos e notarmos que o valor mostrado no terminal, ser sempre info + 1. Isto olhando o código 03. Em todos os outros casos, o valor é bem diferente do esperado inicialmente.

Legal. Acho que estou começando a entender este comando FOR. Parece de fato ser algo simples de se trabalhar. Apesar de ser um tanto quanto confuso as vezes. Mas cá entre nós. Você mencionou que o IF presente no fluxograma deveria ser um comando WHILE. Como assim? Não entendi muito bem esta parte. Poderia explicar melhor esta questão. Esta questão, pelo menos é assim que a considero, é relativamente simples de compreender. Isto sem entrar em outros detalhes sobre o laço FOR. Pois existem sim, alguns detalhes aqui, que o torna bastante complicado para iniciantes. Mas se você quer entender por que menciono que o IF no fluxograma deveria ser substituído por um comando WHILE, é só olhar o código 01 e o comparar com o código 02. Como a expressão 01, assim como a expressão 03 estão vazias. A única coisa que temos aqui seria algo que poderia ser substituído por um comando WHILE. Por isto, mencionei que este comando IF visto no fluxograma, deveria ser na verdade um comando WHILE.

Não sei se você, meu caro leitor, notou. Mas estou evitando ao máximo entrar em um modelo mais avançado do comando FOR. Isto por que, não quero tornar este primeiro contato que você está tendo com este comando, em algo que venha a lhe desanimar de entender as coisas. Porém, como não quero que você fique imaginando que o comando FOR, não precisaria existir. E que ele poderia ser substituído sem problema, por algum tipo de construção que se utiliza comandos WHILE ou mesmo o casal DO WHILE. Vou mostrar um caso em que isto não poderia ser feito. Mas vamos ver isto em um outro tópico.

Comando FOR vazio

O que será visto aqui, deverá ser tratado, mais como sendo uma curiosidade do que propriamente algo que você, deva utilizar na prática. Na verdade, poucas vezes o que será mostrado, de fato é feito na prática. Eu mesmo em todos estes anos como programador, utilizei o que será mostrado, muitas poucas vezes. Mas mesmo assim, pode acontecer, de em algum momento você se deparar com um comando FOR, muito exótico. Mas quem de fato funciona. E como muito provavelmente venhamos a demorar para falar de certas coisas, e você pode ser esbarrar com algo do tipo. Preciso mostrar isto agora, caso contrário, acabarei me esquecendo de falar sobre isto depois. Para explicar do que se trata, vamos usar um código bem simples. Onde tomaremos o cuidado de evitar problemas. Pois bem, quando falamos do comando WHILE, usamos um código visto 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

Este tinha como objetivo, criar o que seria um tipo de laço infinito. Mas com uma saída bem definida. Que seria o uso da tecla ESC. Beleza. No entanto, existe, ou melhor dizendo, é possível usar um comando FOR completamente vazio para tal objetivo. Ou seja, criar um laço infinito. Para demonstrar isto, usaremos o código visto logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     char info = 10;
07. 
08.     for (; ; )
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.         if (TerminalInfoInteger(TERMINAL_KEYSTATE_ESCAPE)) break;
15.     }
16. 
17.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
18. }
19. //+------------------------------------------------------------------+

Código 06

Agora preste muita, mais muita atenção mesmo meu caro leitor. Pois não irei falar isto novamente. Ao olhar os códigos anteriores neste artigo, você viu que todos, tinham alguma informação no que seria a expressão 02. Isto tornaria possível, que em algum momento o laço FOR fosse encerrado. Porém, pode acontecer, de você precisar que o laço FOR NÃO SEJA ENCERRADO. Não por alguma condição, demonstrada no corpo do comando. Neste caso você poderia usar uma expressão 02 vazia. Quando isto acontecer, NÃO TEREMOS O LAÇO SENDO ENCERRADO. Pelo menos não por conta de alguma condição mostrada no comando. Esta condição, caso exista, ocorrerá dentro da rotina do laço. Como você pode observar no código 06. Onde a condição que encerra o laço é definida na linha 14. Mas diferente do que muitos podem imaginar, de que seria preciso declarar alguma expressão em um laço FOR. Ele pode muito bem ser declarado como mostrado no código 06. Isto na linha oito. Ao fazer isto, o compilador entenderá que o laço é do tipo infinito. E qualquer programador, também conseguirá entender a mesma coisa.

Por isto, quando falei de laços lá no comando WHILE. Mencionei que laços são um tipo de coisa, que precisamos tomar cuidado. Se você vacilar, irá ter um potencial problema nas mãos. Então fique atento, sempre que for criar laços em seus códigos.

Para provar que de fato este código 06, funciona e não irá entrar em um loop infinito. O resultado da execução do mesmo, pode ser visto na animação logo abaixo.

Animação 01

Porém, toda via e, entretanto, estou mencionando isto, para que caso você venha a esbarrar em algum código, com um comando FOR vazio. Não fique desesperado sem saber o que irá acontecer. Pois agora, acredito que você já sabe o que acontecerá e como o laço será encerrado. Caso ele de fato venha a ser encerrado.

Considerações finais

Neste artigo falamos o básico, do básico sobre o comando FOR. Tudo que foi visto aqui, precisa de fato ser muito bem assimilado e compreendido. Diferente do que acontecia com os demais comandos. Este comando FOR tem algumas peculiaridades, que o torna muito complexo de maneira muito rápida. Então meu caro leitor, não deixe este tipo de material se acumular. Comece a estudar e praticar o que foi visto neste artigo. Para isto, use os códigos vistos nos artigos anteriores, e tente modificar os mesmos, a fim de usar o comando FOR em cada um deles. Isto onde houver a presença de laços.

Como este era o último comando a ser visto. Tudo que vier a ser mostrado e visto, de agora em diante, irá utilizar a combinação destes conceitos básicos, mostrados até este artigo. No entanto, ainda não podemos falar de conceitos intermediários. Isto por que, falta falar de outros conceitos básicos. Que são tão importantes quanto o que foi mostrado até aqui. Porém, agora, já me sinto um pouco mais livre, para começar a mostrar formas um pouco mais avançadas de implementação de código. Isto a fim de que os conceitos básicos, que ainda precisam ser mostrados, sejam devidamente apresentados. Sem toda aquela limitação que havia sendo imposta até este momento.

Então estude com bastante atenção os materiais vistos em todos anexos até este momento, e nos vemos no próximo artigo. Um forte abraço e bons estudos e até breve.