Estrutura de loop
As estruturas de loop permitem que uma ou várias linhas de código sejam executadas repetidamente. As estruturas de loop suportadas pelo Visual Basic são:
1. Faça... Loop
2.Para...Próximo
3.ForEach...Próximo
Faça... Loop
Use um loop Do para executar repetidamente um bloco de instruções por um número variável de vezes. Existem diversas variações da instrução Do...Loop, mas cada uma avalia uma condição numérica para decidir se deve continuar a execução. Como If...Thencondition deve ser um valor numérico ou uma expressão cujo valor seja True (diferente de zero) ou False (zero). No seguinte loop Do...Loop, as instruções são executadas desde que a condição seja True.
DoWhilecondição
declarações
Laço
Quando o Visual Basic executa esse loop Do, ele primeiro testa a condição. Se a condição for Falsa (zero), todas as instruções serão ignoradas. Se a condição for True (diferente de zero), o Visual Basic executa a instrução e, em seguida, recorre à instrução DoWhile para testar a condição novamente.
Portanto, o loop pode ser executado quantas vezes desejar, desde que a condição seja Verdadeira ou diferente de zero. Se a condição for Falsa desde o início, a instrução não será executada. Por exemplo, o procedimento a seguir contará o número de vezes que uma string de destino aparece em outra string e fará um loop sempre que a string de destino for encontrada:
FunctionCountStrings(longstring,alvo)
Dimposição, contagem
posição=1
DoWhileInStr(posição,string longa,alvo)
posição=InStr(posição,string longa,alvo)_
1
contagem = contagem 1
Laço
CountStrings = contagem
Função Final
Se a string alvo não aparecer em outra string, InStr retornará 0 e o loop não será mais executado.
Outra variação da instrução Do...Loop é executar a instrução primeiro e depois testar a condição após cada execução. Este formulário garante que as instruções sejam executadas pelo menos uma vez:
Fazer
declarações
LoopWhilecondição
As outras duas variações são semelhantes às duas primeiras, exceto que executam o loop sempre que a condição for False em vez de True.
Para...próximo000
Quando você não sabe quantas vezes a instrução precisa ser executada no loop, é apropriado usar um loop Do. No entanto, quando você sabe quantas vezes deseja executar, é melhor usar um loop For...Next. Ao contrário do loop Do, o loop For usa uma variável chamada contador. Cada vez que o loop é repetido, o valor da variável do contador aumenta ou diminui. A sintaxe do loop For é a seguinte:
Forcounter=startToend[Stepincrement]
declarações
Próximo[contador]
Os parâmetros Contador, Início, fim e incremento são todos numéricos.
Observe que o parâmetro de incremento pode ser positivo ou negativo. Se o incremento for positivo, Start deverá ser menor ou igual a end, caso contrário a instrução dentro do loop não poderá ser executada. Se o incremento for negativo, Start deverá ser maior ou igual a end para que o corpo do loop possa ser executado. Se Step não estiver definido, o valor padrão de incremento será 1.
Ao executar um loop For, Visual Basic
1. Defina o contador igual ao início.
2. Teste se o contador é maior que o final. Nesse caso, o Visual Basic sai do loop. (Se o incremento for negativo, o Visual Basic testa se o contador é menor que o fim.)
3. Execute a instrução.
4. O contador aumenta em um ou incrementa (se especificado).
5. Repita as etapas 2 a 4.
O código a seguir imprime todos os nomes de fontes de tela válidos:
PRivateSubForm_Click()
DimIAsInteger
Fori=0ToScreen.FontCount
PrintScreen.Fonts(i)
Próximo
Fim Sub
No aplicativo de exemplo VCR, o procedimento HighlightButton usa um loop For...Next para percorrer a coleção de controles do formulário VCR e exibir o controle Shape apropriado:
SubHighlightButton (MyControlAsVariant)
DimiAsInteger
Fori=0TofrmVCR.Controls.Count-1
IfTypeOffrmVCR.Controls(i)IsShapeThen
IffrmVCR.Controls(i).Name=MyControlThen
frmVCR.Controls(i).Visible=True
Outro
frmVCR.Controls(i).Visible=Falso
FimSe
FimSe
Próximo
Fim Sub
Para cada...Próximo
O loop ForEach...Next é semelhante ao loop For...Next, mas repete um conjunto de instruções para cada elemento em uma matriz ou coleção de objetos, em vez de repetir as instruções um certo número de vezes. O loop ForEach...Next é útil se você não sabe quantos elementos uma coleção possui.
A sintaxe do loop ForEach...Next é a seguinte:
ForEachelementIngroup
declarações
Próximo elemento
Por exemplo, a sub-rotina a seguir abre Biblio.mdb e adiciona o nome de cada tabela a uma caixa de listagem.
SubListTableDefs()
DimobjDbAsDatabase
DimMyTableDefasTableDef
SetobjDb=OpenDatabase(c:/vb/biblio.mdb,_
Verdadeiro, Falso)
ForEachMyTableDefInobjDb.TableDefs()
List1.AddItemMyTableDef.Nome
PróximoMyTableDef
Fim Sub
Tenha em mente algumas limitações ao usar ForEach...Próximo:
1. Para coleções, o elemento só pode ser uma variável Variant, uma variável Object geral ou um objeto listado no "Navegador de Objetos".
2. Para matrizes, o elemento só pode ser uma variável Variant.
3.ForEach...Next não pode ser usado com matrizes de tipos definidos pelo usuário, porque Variant não pode conter tipos definidos pelo usuário.
Use estruturas de controle
Estruturas de controle aninhadas colocam uma estrutura de controle dentro de outra estrutura de controle (como um bloco If...Then em um loop For...Next). Uma estrutura de controle contendo outra estrutura de controle é chamada de ninho. No Visual Basic, não há limite para o número de níveis aninhados de estruturas de controle. Como regra geral, para tornar as estruturas de julgamento e as estruturas de loop mais legíveis, o texto das estruturas de julgamento ou dos loops é sempre escrito com recuo.
Por exemplo, o processo a seguir imprime todos os nomes de fontes comuns à impressora e à tela:
PrivateSubForm_Click()
DimSFont,PFont
ForEachSFontInScreen.Fonts()
ForEachPFontInPrinter.Fonts()
IfSFont=PFontThen
ImprimirFonte
FimSe
PróximoPFont
PróximoSFont
Fim Sub
Observe que o primeiro Next fecha o loop For interno e o último For fecha o loop For externo. Da mesma forma, em instruções If aninhadas, a instrução EndIf é automaticamente emparelhada com a instrução If anterior mais próxima. As estruturas Do...Loop aninhadas funcionam da mesma maneira, com a instrução Loop mais interna correspondendo à instrução Do mais interna.
estrutura de controle de saída
Use a instrução Exit para sair diretamente do loop For, loop Do, subprocesso ou processo de função. A sintaxe da instrução Exit é muito simples: não há limite para o número de vezes que ExitFor pode aparecer no loop For e não há limite para o número de vezes que ExitDo pode aparecer no loop Do.
Forcounter = inícioToend
[Incremento gradual]
[bloco de declaração]
[SairPara]
[bloco de declaração]
Próximo[contador[,contador][,...]]
Faça[{Enquanto|Até}condição]
[bloco de declaração]
[SairDo]
[bloco de declaração]
Laço
A instrução ExitDo pode ser usada em todas as versões da sintaxe do loop Do.
ExitFor e ExitDo são úteis porque às vezes é apropriado sair de um loop imediatamente sem executar quaisquer iterações ou instruções adicionais dentro do loop. Por exemplo, no exemplo anterior de uma fonte compartilhada entre a tela de impressão e a impressora, o programa continuou comparando a fonte da impressora com uma determinada fonte da tela, mesmo depois de ter encontrado uma fonte de máquina de escrever correspondente. Existe uma versão mais eficiente desta função que sai do loop assim que uma fonte correspondente é encontrada:
PrivateSubForm_Click()
DimSFont,PFont
ForEachSFontInScreen.Fonts()
ForEachPFontInPrinter.Fonts()
IfSFont=PFontThen
PrintSfont
ExitFor 'Sai do loop interno.
FimSe
PróximoPFont
PróximoSFont
Fim Sub
Como este exemplo ilustra, as instruções Exit quase sempre aparecem dentro de instruções If ou instruções SelectCase, que estão aninhadas em loops.
Quando um loop é interrompido com uma instrução Exit, o valor da variável contador será diferente dependendo de como o loop foi encerrado:
1. Quando o ciclo é concluído, o valor do contador é igual ao valor limite superior mais o valor do passo.
2. Ao sair antecipadamente do loop, a variável contadora mantém o seu valor, sujeito às regras gerais relativas aos intervalos de valores.
3. Ao iterar fora da coleção, se a variável do contador for do tipo Object, seu valor será Nothing; se a variável do contador for do tipo Variant, seu valor será Vazio;
Sair de uma sub-rotina ou procedimento de função
Um procedimento também pode ser encerrado dentro de uma estrutura de controle. A sintaxe de ExitSub e ExitFunction é semelhante a ExitFor e ExitDo na seção anterior "Estrutura de controle de saída". ExitSub pode aparecer em qualquer lugar do corpo do subprocesso, quantas vezes forem necessárias.
ExitSub e ExitFunction são úteis quando o procedimento concluiu cada tarefa e pode retornar diretamente. Por exemplo, se você quiser alterar o exemplo anterior para que apenas a primeira fonte encontrada para a impressora e tela seja impressa, você pode usar ExitSub:
PrivateSubForm_Click()
DimSFont,PFont
ForEachSFontInScreen.Fonts()
ForEachPFontInPrinter.Fonts()
IfSFont=PFontThen
PrintSfont
ExitSub 'Sai do processo.
FimSe
PróximoPFont
PróximoSFont
Fim Sub
->