VB.NET - Conhecendo as estruturas de controle de fluxo

Para construir um programa de computador que seja interativo e que responda de forma diferente dependendo das informações fornecidas pelo usuário vamos precisar usar um tipo de instrução chamada de instrução de controle. Neste artigo irei abordar as duas categorias de instruções de controle : instruções condicionais e instruções de laço.

O VB.NET suporta as seguintes estruturas ou instruções de controle :

If ... Then ... Else Select / Case For ... Next
Do ... While While ... End While Do ... Loop
Do .. Until    

If... Then ... Else

É utilizada para avaliar uma determinada expressão e definir se um bloco de código deve ou não ser executado. A sintaxe de sua estrutura completa é a seguinte:

if  <condição #1 > Then - Na estrutura básica If Then Else ao lado temos:

- condição - É a condição a ser avaliada ; pode usar os operadores de comparação ( = , < , > , <> , >= , <=). Se uma condição satisfazer a avaliação o bloco de código associado ao if ou ao ElseIf será executado e sairemos da estrutura.

- Else - O bloco de código associado a esta instrução somente será executado se nenhuma das condições em If ou ElseIf for satisfeita.

- End If - Indica o fim da estrutura de controle.

          [ código #2 ]
ElseIf <condição #2> Then
          [ código #2 ]
ElseIf <condição #3> Then
            [ código #3 ]
......
Else
          [ código #n ]
End If

Podemos ter as seguintes variações:

a estrutura na forma mais simples

Avaliando uma condição com duas possibilidades de execução.

  Aninhando duas instruções - If ... Then... Else

if <condição #1> then
      [ codigo #1]
End If
If  <condição #1> then
        [ codigo #1 ]
Else
        [ codigo #2]
End If
if <condição #1> then
        [ código #1]
else
       if <condição #2> then
              [ código #2]
       End If
End If

Além da forma de bloco acima exibida podemos também expressar uma instrução If em uma única linha. Assim :

Instruções If em sequência na mesma linha
a-  If < condição #1 > then  [ código #1 ]       Ex: If x=0 then Valor = 100
 
b-  if < condição #1 > then  [ código #2 ]  Else [ código #3 ]   Ex: If hora > 12 then msg="Boa Tarde" Else msg="Bom dia"
 
c- if < condição #1 > then  [ código #2 ] : [ codigo #3 ]  Else [ código #4 ]
Ex:  Ex: If hora > 12 then msg="Boa Tarde" : msg2=" >12"  Else msg="Bom dia"

Nota: Embora as instruções em uma única linha as vezes possam dar ao código uma melhor aparência (caso a) você dever considerar se a leitura do código não vai ficar mais difícil.

Existe ainda a instrução IIF que pode ser aplicada em situações em que existam apenas duas ações , uma verdadeira e outra falsa. Sua sintaxe é :

iif ( <condição #1> , < código executado se a instrução for verdadeira> , <código se a instrução for falsa>)

Ex:

Function Verifica (ByVal Teste As Integer) As String
   Verifica = IIf(Teste > 1000, "Grande", "Pequeno")
End Function

Operadores de comparação

Geralmente nas condições usamos expressões de comparação onde duas expressões não booleanas utilizam um operador para realizar uma comparação. Os operadores disponíveis são :

   >  maior que
   <  menor que
   =  igual a
   <>  diferente de
   >=  maior ou igual a
   <=  menor ou igual a
   Like   verifica correspondência de padrões entre strings

Estes operadores são usados com strings e com valores numéricos.

No caso do operador especial Like podemos comparar uma variável de string com padrões que usam caracteres especiais e comuns. Estes caracteres podem ser:

  *  indica a quantidade de caracteres adicionais
  ?  repesenta um único caractere
  #  representa um dígito {0-9}
  intervalos [a-z] , [j-k] , etc.  especifica que qualquer caractere dentro do intervalo dever ser considerado uma correspondência

Ex:  if  "Macoratti"  Like  "M*tti" then [código]

Operadores Lógicos

Os operadores lógicos trabalham com expressões ou valores booleanos e retornam um resultado booleano ( Verdadeiro / Falso , Sim / Não ). Nesta categoria temos os seguintes operadores :

AND  Usando este operador entre dois valores/expressões só obtemos um resultado igual a verdadeiro SE os dois forem verdadeiros.
OR  Com este operador se um dos valores/expressões for verdadeiro o resultado será verdadeiro
XOR  Gera um resultado verdadeiro  se um dos valores/expressão for verdadeiro e o outro for Falso.
NOT  Operador de negação e retorna o oposto a qualquer valor que for usado com ele.

A seguir temos um tabela com algumas combinações possíveis entre os operadores lógicos.

 TRUE AND TRUE  TRUE
 FALSE AND TRUE  FALSE
 TRUE AND FALSE  FALSE
 FALSE AND FALSE  FALSE
 TRUE OR TRUE  TRUE
 TRUE XOR FALSE  TRUE
 NOT TRUE  FALSE
 NOT FALSE  TRUE

A estrutura Select Case : múltiplas possibilidades

A estrutura Select Case é usada quando temos que verificar muitas condições , neste caso , embora você ainda possa usar a estrutura If.. Then ... Else ela poderia se tornar muito complexa e difícil de tratar.  Sua sintaxe é a seguinte:

Select Case < expressão > - <expressão> é a variável ou expressão que esta sendo comparada

- <condicao> é a condição lógica a ser avaliada

- Case Else -  executa o bloco de código associado se nenhuma condição anterior for verdadeira.

        Case < condicao #1>
                  [ codigo #1]
        Case < condicao #2>
                  [ codigo #2]
 .....
        Case Else
                  [ código #3]
End Select

A utilização da instrução Select Case pode simplificar muito o código,  abaixo as possibilidades :

Select Case  quantidade  
     Case 1  
         call rotina1()           
     Case 2,4 - podemos trabalhar com mais de uma opção para a condição :  Case x,y
         call rotina2()  
     Case 5 to 9 podemos definir uma faixa de valores  : Case x to y
         call rotina3()  
     Case else  
         call rotina4()  
End Select  

Laços

Quando você precisar executar um bloco de código mais de uma vez deverá usar o tipo de instrução laço (loop). Vejamos os principais:

For ... Next

Repete o mesmo bloco de código um determinado número de vezes independente de qualquer condição lógica: Sua sintaxe é :

For <contador = valorinicial > To <valorfinal> [step]

 - contador :  variável númerica que controla o número de vezes que  o código será executado.

- ValorInicial - Valor inicial atribuído ao contador

- Valorfinal - valor final que o contador irá assumir antes de encerrar a execução do laço.

- Step - especifica o valor de incremento do contador.O valor padrão é de uma unidade.

- Exit For - interrompe a execução do laço

      [ código #1]
      exit for
Next [contador]

Abaixo um exemplo de utilização de For / Next:

For x=1 to 100 step 2

        x = x+10

        if x > 68 then

           exit for

       endif

Next      

Você usa o laço for/next quando sabe exatamente quantas vezes o bloco de código deverá ser executado.

Para percorrer vetores ou objetos com um número determinado de elementos podemos usar o laço For Each/Next:

O laço For Each...Next é idêntico ao laço For...Next mas executa o bloco de código para cada elemento em uma coleção , ou invés de executar um determinado número de vezes. Sua sintaxe é :

 

For Each elemento In coleção
   '[código a ser executado para cada valor do elemento]
Next [ elemento ]

 

Os elementos da coleção podem ser qualquer tipo de dados. Para cada interação no laço o VB.NET define a variável elemento para um dos elementos na coleção e executa o código.

While ... End While

Este laço é mais flexível que o laço for/next . Ele executa o bloco de código enquanto uma expressão booleana for verdadeira.

While < expressão booleana >

      [ código #1]

End While

 

 - Você pode usar qualquer expressão booleana

Nota: No visual basic 6 havia a instrução While/Wend , no VB.NET a instrução Wend foi substituida por End While.

Ex:

While contador  < 10 And valor = 5

        contador = contador + 1

End While

Do ... Loop

Este laço além de ser simples é um dos mais flexíveis , ele executa o bloco de código enquanto uma condição for verdadeira. A sintaxe é a seguinte :

Do [ {While | Until} <expressão >

    [bloco de código]

    [Exit Do]

Loop

- <expressão> - qualquer expressão numérica ou de string avaliada pelo laço

- Exit Do - interrompe a execução do laço.

Temos então as seguintes estruturas possíveis:

Do While <condição >

     [ código ]

Loop

Do Until <condição >

     [ código ]

Loop

Faça enquanto a expressão for verdadeira Faça até que a expressão torne-se verdadeira

A diferença entre Do While e Do Until é o modo como a estrutura avalia a expressão lógica. Para o Until o bloco será executado enquanto o valor da expressão for Falsa.

Ao escolher entre um laço While e Until use o laço que não precisar de uma negação na expressão condicional.

Tenha cuidado a posicionar a sua instrução condicional. Se você colocar a condição no início do laço , o código no interior do laço nunca será executado se a condição não for atendida.

Você pode colocar a condição de saída no final do laço ,  assim :

Do

     [Código #1}

Loop Until <condição #1>

Nota: se a expressão da condição for Null o VB.NET tratará a condição como False.

Você deve tomar cuidado com o seu código dentro dos laços pois isto pode afeta o desempenho de sua aplicação. Abaixo algumas dicas para ajudar a você ter um código rápido:

Laço Infinito - Um laço infinito é um laço que executa o código no seu interior e não tem condição de saída , ou seja, o código será executado infinita vezes...

Dica: Se por um erro de lógica seu código entrar em um laço infinito use as teclas CTRL+Break para encerrá-lo. Abaixo um exemplo de um laço infinito:

Dim i as integer = 0

 While i < 100

       Console.Writeline(i)

End While

Adivinhe por que o laço ao lado é infinito ????

Para evitar um laço infinito procure adotar os seguintes procedimentos:

Recursão

É claro que os laços nem sempre são a melhor solução para todos os problemas. Em alguns casos você pode usar a recursão como uma alternativa aos laços.  A recursão ocorre quando um programa ou rotina chama a ele próprio. Um exemplo clássico para mostrar como a recursão funciona é o cálculo do um fatorial.

A fórmula para calcular um fatorial de um valor n  é = n! onde fazemos n ! = (n -1)(n-2)...(n-(n-1))(1). Assim para o fatorial para o número 5 seria : 5! = 5x4x3x2x1 = 120 . A fórmula geral para calcular o fatorial pode ser então expressa como :  n * (n-1) ! ( n multiplicado pelo fatorial de n menos 1).

A seguir temos o código que usa a recursão ao invés de laços para calcular o fatorial de um número inteiro.

Public Class Fatorial

 

Shared Sub Main()

 

   Dim entrada As String

   Dim numero As Integer

   Dim contador As Integer

 

   Console.Write(" >>> Calculo do Fatorial <<< ")

   Console.WriteLine("")

   Console.WriteLine("Informe o número para calcular o fatorial ")

 

   entrada = Console.ReadLine()

   numero = CInt(entrada)

   Console.Write("")

   Console.Write(" O valor do fatorial para " & numero & " é : ")

   Console.WriteLine(Fatorial(numero))

   Console.ReadLine()

 

End Sub

Shared Function Fatorial(ByVal n As Integer) As Integer

 

  If n = 1 Then

      Return 1

  Else

      Return n * Fatorial(n - 1)

  End If

End Function

 

End Class

Embora sejam conceitos básicos é de suma importância que você compreenda bem as estruturas de controle de fluxo para criar um código robusto e legível.


José Carlos Macoratti