Structures de contrôle par steven007

Soyez le premier à donner votre avis sur cette source.

Snippet vu 5 804 fois - Téléchargée 40 fois

Contenu du snippet

v'la de la théorie pour les fénéant.

Les fonction les + utilisée en détaille rien que pour vous

Ca sert toujours de revoir un peu

A+ et bonne progz

Source / Exemple :


'*************************************
'************THEORIE SUR**************
'**********LES INSTRUCTIONS***********
'**********If...Then...Else***********
'**DO...LOOP*FOR EACH...NEXT*WITH*****
'*************For...Next**************
'*******FONCTIONS DE SELECTION********
'**********LA FONCTION SWITCH*********
'*********LA FONCTION CHOOSE**********
'********** par steven007 ************
'******** 26/06/2002 12h53 ***********
'******* steven007@caramail.com*******
'******** www.steven007.fr.st*********
'*************************************

'Instruction If...Then...Else

'UN PEU DE THEORIE POUR CEUX QUI NE SAVENT PAS UTILISER LES INSTRUCTIONS
'LES PLUS CLASIQUES DE VB6, MEME POUR CEUX QUI ONT UN BON NIVEAU C EST TOUJOURS
'BON A LIRE ( je sais que c 'est long mais si vous voules piger quelque chose,
'faut lire.

NIX N EFFACE PAS CA S IL TE PLAIT, J AI MIS DU TEMPS A LE FAIRE ET C EST TOUJOURS
INSTRUCTIF A N IMPORTE QUI !!!!!! (même à toi) lol

'FONCTION DE SELECTION

'Visual Basic dispose de deux structures de décision:

If...Then...Else,
Select Case.

'Elles permettent de dérouter l'exécution du programme vers un bloc défini
'd'instructions en fonction d'une expression booléenne.

'Instruction If...Then...Else

'La forme la plus simple de cette instruction est représentée par sa syntaxe sur une seule ligne:
' If Condition Then Instructions1 [Else Instructions]

'L'argument Condition est une expression dont la valeur peut être évaluée à True
'ou à False
'par Visual Basic. La valeur numérique 0 correspond à False, toutes les autres
'valeurs à True. Si le résultat
'de l'évaluation est True, c'est la partie Then qui est exécutée (Instructions1],
'sinon c'est la partie Else [Instruction2].
'Il peut s'agir d'une seule instruction, ou de plusieurs instructions, qui doivent
'être séparées par un deux-points et être incluses dans une même ligne.

If sngnombre > 0 Then strText = "positif"
If sngnombre > 0 Then strText = "positif" _
  Else strText = "négatif"
If sngnombre > 5 Then intA = intA + 1: _
  dblB = sngnombre ^ 2: lngC = lngC + 10

'Cette forme monoligne est adaptée à des choix simples. si plusieurs instructions doivent être exécutées,
'le code devient moins lisible, comme dans la dernière ligne de l'exemple. Des conditions
'complexes, qui ne peuvent être réalisées que par des structures If imbriquées, aboutissent à un code difficile
'à suivre. La forme en bloc de l'instruction If...Then...Else suit la syntaxe définie ci-après:

If Condition1 Then
..[Instruction1]
[ElseIf condition2 Then [Instruction2]] ...
[Else
[InstructionsN]]
End If

'Cette forme présente généralement des avantages par rapport à la forme sur une seule ligne:
' Elle présente mieux la logique de la structure du programme,
' des conditions plus complexes et très différentes peuvent être contrôlées,
'une meilleur flexibilité

'Dans le cas le plus simple, la forme en bloc présente un mode d'écriture différent de celui d'une
'instruction sur une ligne:

If sngnombre > 0 Then
strText = "positif"
End If

'Le code suivant teste la variable vntX, il représente un nombre entier inférieur à 9,
'pour déterminer s'il est pair ou impair,
'le résultat du test est transmis à une variable String strMessage. Les conditions
'de la branche If et de la première branche
'elseif sont constituées de conditions isolées, réunies par l'opérateur Or, des
'expressions simples sont testées dans les autres lignes ElseIf, et
'la branche Else vérifie enfin que le nombre est compris dans le domaine autorisé,
'mais qu'il n'est pas entier.

If vntX = 1 Or vntX = 3 Or vntX = 5 Or vntX = 7 _
  Or vntX = 9 Then
  strmessage = "Le nombre est impair."
ElseIf vntX = 2 Or vntX = 4 Or vntX = 6 Or vntX = 8 Then
strmessage = "Le nombre est pair."
'Cette instruction n'est jamais exécutée
ElseIf vntX = 5 Then
  strmessage = "le nombre est 5."
ElseIf vntX <= 0 Then
  strmessage = "Le nombre est trop petit."
ElseIf vntX > 9 Then
  strmessage = "Le nombre est trop grand."
Else
  strmessage = "Le nombre doit être entier!."
End If

'ATTENTION

'La première condition est la bonne
'Si des conditions sont remplies dans plusieurs branches Elseif, seules les instructions de la première
'condition vérifiée sont exécutées. Dans notre exemple, le message "le nombre est 5. "ne s'affiche jamais, car
'la condition vntx = 5 est déjà traitée dans la branche If.

'Instruction Select Case

'L'instruction Select Case constitue une alternative à la forme en bloc If...Then...ElseIf et permet
'de formuler de manière plus simple la sélection de groupes d'instructions. Sa syntaxe est la suivante:

Select Case ExpressionTest
[Case ListeExpression1
..[instruction1]]
[Case ListeExpressions2
 [Instruction2]] ...
[Case Else
 [InstructionsN]]
End Select

'L'instruction Select Case n'utilise qu'une seule expression de test, qui est évaluée
'au début de la structure. Sa valeur est ensuite comparée dans l'ordre aux valeurs de la
'liste d'expressions. Dès la 1ere correspondance, le bloc d'instructions est exécuté, puis
'le programme passe à la première instruction qui suit la structure. La branche
'optionnelle Case Else n'entre en jeu que si aucun équivalent n'a été trouvé pour l'expression
'de test dans la liste des expressions.

'Des expressions séparées par des virgules peuvent être utilisées dans les listes d'expressions.

'Expression1[, Expression2]...'Liste de plusieurs valeurs
'Expression1 to Expression2'Valeurs comprises entre un minimum et un maximum
'Is Opérateur_de_Comparaison Expression: 'Plage de valeurs

'L'exemple précédent peut ainsi être transcrit à l'aide de la structure Select Case:

Select Case vntX
Case 1, 3, 5, 7, 9
  strmessage = "Le nombre est impair."
Case 2, 4, 6, 8
  strmessage = "Le nombre est pair."
'Cette instruction n'est jamais exécutée
Case 5
  strmessage = "Le nombre est 5."
Case Is <= 0
  strmessage = "le nombre est trop petit."
Case Is > 9
  strmessage = "Le nombre est trop grand."
Case Else
  strmessage = "le nombre doit être entier!."
End Select
  
'Le programme est devenu plus lisible, car l'expression à tester n'est pas répétée à
'chaque test ni groupée par des opérateurs logiques.

'l'instruction

  strmessage = "Le nombre est 5."
  
'n'est pas non plus exécutée, car la comparaison avec la valeur 5 est déjà réalisée
'dans la première branche Case.

'NOTE : LA STRUCTURE SELECT CASE EST PREFERABLE
'       LA STRUCTURE IF EST PARFOIS INCONTOURNABLE

'Donc à vous de choisir, cela dépend du cas devant lequel vous vous trouver...

'FONCTIONS DE SELECTION

'bien que les fonctions de sélection ne fassent pas partie des structures de décision,
'je vais les présenter brièvement car elles constituent des outils de décision qui peuvent
'être utilisés sous forme de fonction.

'La fonction IIf, dont la syntaxe est:

IIf(condition,ExpressionTrue, ExpressionFalse

'renvoie la valeur de la 1ere expression si la condition est True, sinon celle de la
'2ème expression si la condition est False.

  strmessage = IIf(vntX >= 0, "positif", "négatif")
  
'Sa fonction est facile à restituer à l'aide d'une simple structure if...Then...Else

'NOTE: LES DEUX EXPRESSIONS SONT EVALUEES

'Lors de la mise en oeuvre de la fonction IIf, les deux expressions sont évaluées. Si
'une division par 0 intervient lors du calcul de l'expression False, une erreur est
'signalée, même si la condition détient la valeur True.

' LA FONCTION SWITCH

  Switch(Condition1, Expression1[, condition2, Expression2]...)

'évalue une liste de conditions et revoie la valeur ou l'expression correspondant à la 1ere
'condition remplie.

strMonnaie = Switch(strPays = "Angleterre", "£", _
  strPays = "Allemagne", "DM", _
  strPays = "France", "Franc")
  
'Cette fonctin peut également être imitée par une instruction Select Case.

'LA FONCTION CHOOSE

  Choose(Index, Expression1[, Expression2]...)
  
'choisit dans une liste la valeur dont laposition correspond à la valeur d'un index entier.

  strTaille = Choose(intIndex, "petit", "moyen", "gros")
  
'Une fonction équivalente peut ici encore être réalisée à l'aide d'une structure Select Case.

'STRUCTURES DE BOUCLES

'Visual Basic comporte les structures de boucles suivantes:

'- Do...Loop,
'- For...Next,
'- For Each...Next.

'Le nombre de répétitions d'un bloc d'instructions(le corps de la boucle) est définie
'par la valeur d'une expression logique(la conditin de boucle) ou par la valeur
'd'une expression numérique (le compteur de boucle).

'INSTRUCTION DO...LOOP

'L'instruction Do...Loop est une structure de boucle qui permet d'exécuter un bloc
'd'instructions ausi souvent que cela s'avère nécessaire. Elle existe sous deux
'variantes syntaxiques. La 1ere présente l'aspect suivant:

Do [{While|until} Condition]
..[Instructions]
[Exit Do]
  [INSTRUCTIONS]
Loop

'Dans cette structure, la condition est testée au début et la boucle exécutée tant que cette
'condition est vraie (While) ou jusqu'à ce qu'elle le devienne (Until). L'exécution
'du programme se poursuit alors par l'instruction qui suit la structure de contrôle.

'contrôlez un mot de passe enregistré dans la constante cstrMotDePasse de la manière suivante:

Do While InputBox("Entrez votre mot de pass:") <> cstrMotDePasse
...
Loop

'ou comme suit:

Do Until InputBox("tapez votre mot de passe:") = cstrMotDePasse
...
Loop

'La fonction inputBox affiche une boîte de dialogue qui contient notamment
'une zone de texte, lequel renvoie son contenu lors de la fermeture de la
'bôite de dialogue.

'les deux éléments de code donnent le même résultat, car les conditions Until
'et While-Not sont équivalentes en logique, car l'opérateur Not est rendu dans
'mon exemple par <>.

'Il peut arriver que la boucle Do ne soit pas exécutée, car le test est évalué
'au début de la boucle. La deuxième variante qui évalue le test à la fin
'de la boucle l'exécute au moins une fois.

Do
..[Instructions]
..[Exit Do]
  [INSTRUCTIONS]
Loop [{While|until}Condition]

'Les lignes de l'exemple cité plus haut peuvent être traduites par la syntaxe suivante:

Do While InputBox("Entrez votre mot de passe : ") <> cstrMotDePasse
  ...
Loop While InputBox("Entrez votre mot de passe : ") <> cstrMotDePasse

'ou par:

Do Until InputBox("Entrez votre mot de passe :") = cstrMotDePasse
...
Loop While InputBox("Entrez votre mot de passe : ") = cstrMotDePasse

'L'instruction Exit, ici avec le mot clé Do, permet de tester une condition de sortie
'à l'intérieur de la boucle pour quitter celle-ci prématurément. Elle permet de
'quitter les structures For, Function, Property ou Sub en l'associant au mot clé
'correspondant.

'INSTRUCTION For...Next

'S'il n'est pas possible de savoir à l'avance le nombre de boucles à réaliser, il faut utiliser
'une structure Do.

'Si ce nombre est connu, la boucle For...Next peut être mise en oeuvre.

For Compteur = Début To Fin [Step Incrément]
..[Instructions]
..[Exit For]
  [INSTRUCTIONS]
Next [Compteur]

'La variable numérique compteur, qui peut être un élément d'un type de données
'personnalisé, est modifiée à chaque boucle par la valeur de la variable Incrément.
'si le mot clé optionnel Step, assicié à l'argument Incrément, est omis, la
'variable Compteur est incrémentée de 1 chaque fois qu'elle rencontre l'instruction
'Next. Dans le cas contraire, le compteur de boucles est augmenté ou diminué de la
'valeur incrément à chaque boucle.

'Lors du lancement de cette instruction, Compteur est positionnné à la valeur Début.
'visual basic compare alors la valeur de Compteur à Fin. si la valeur de compteur
'est supérieure à Fin dans le cas d'un incrément positif, ou inférieure à Fin dans
'le cas d'un incrément négatif, la boucle est interrompue. Si ce n'est pas le cas,
'les instructions sont exécutées jusqu'à l'instruction Next, puis Compteur est
'modifié comme cela est indiqué ci-dessus, puis testé à nouveau. La boucle For
'revient alors au début.

Private Sub comRemplir_click()
  Dim i As Integer
  
  For i = 15 To 1 Step -2
    lstCarrés.AddItem i * i
  Next
End Sub

'NOTE: LA STRUCTURE FOR...NEXT est préférable

'Si vous connaissez le nombre de répétitions, il vaut mieux utiliser l'instruction
'For...Next que l'instruction Do...Loop. L'économie en temps et en espace
'mémoire est maximale en utilisant des arguments numériques entiers pour la
'structure des boucles.

'NOTE: NE PAS MODIFIER LA VARIABLE DE COMPTAGE

'Il faut éviter de modifier la variable de comptage d'une instruction For...Next
'pendant l'exécution de la boucle, car le déroulement du programme se complique
'alors inutilement et risque de provoquer des erreurs.

'INSTRUCTION FOR EACH...NEXT

'L'instruction For Each...Next est construite de manière similaire à l'instruction
'For...Next.

For Each Elément In groupe
..[Instructions]
..[Exit For]
  [INSTRUCTIONS]
Next [Elément]

'Cette boucle répète les instructions pour tous les éléments d'un tableau
'de type Variant ou d'un énumération. la variable Elément doit être de type Variant
'ou Object ou correspondre à un objet spécifique d'un catalogue d'objets.

'le nombre des boucles est donné dans le cas d'une structure For...Next, alors
'qu'il est déterminé implicitement par visual basic pour une boucle For Each...Next.

'Pour pouvoir essayer le code suivant, définissez une zone de texte dans une feuille,
'attribuez-lui le nom txtTest et mettez sa propriété Index à 0. Insérez alors les
'lignes suivantes dans la procédure click de la feuille.

Private Sub form_click()
  Dim i As Integer
  Dim vntElément As Variant
  
  'Crée des zones de texte lors de l'exécution
  For i = 1 To 4
    Load txtTest(i)
    txtTest(i).Top = txtTest(i - 1).Top + 600
  Next
  
  'pour chaque élément du groupe de contrôles
  For Each vntElément In txtTest
    vntElément.Visible = True
    vntElément.Text = "Ceci est une zone de texte " & vntElément.Index
  Next
End Sub

'Lors d'un clic sur la feuille, quatre zones de texte supplémentaires sont créées
'dans une boucle for...Next et placées les unes au-dessus des autres. Jusqu'à
'ce que la structure For Each...Next les rende visibles et qu'elles reçoivent le
'texte à afficher. L'accès aux composants du groupe de contrôles est effectué à
'l'aide de la variable vntElément.

'INSTRUCTIONS WITH

'Cette instruction ne réalise qu'une seule boucle, mais peut également être
'assimilée à une structure de ce type.

With objet
..[Instructions]
End With

'Elle exécute une série d'instructions pour un objet unique ou un type de données
'personnalisé. vous avez surement déjà vu l'instruction With dans un de mes projets
'afficher sur vbfrance.

'NOTE: LA BOUCLE WHILE..WEND

'la boucle while...Wend des anciennes versons de Visual basic est toujours
'supportée, mais elle devrait être remplacée dans les nouveaux projets par la
'structure de contrôle Do...Loop, qui est plus performante.

'Les structures de contrôle peuvent être imbriquées dans d'autres structures
'de contrôle, comme dans des structures de même type. Il faut cependant veiller
'à ce que chaque structure se termine correctement par l'instruction adéquate,
'par exemple end If ou Next.

'voila c'est fini pour les explications, j'espère que vous aurez au moins compris
'quelque chose. même si les débutants ne comprennent pas toujours tout, il faut
'à force de persévéré comprendre ce super language que Microsof met à notre
'disposition... (VIVE MICROSOFT et l'trafic) lol.

'Désolé si y a des fautes d'orthographe, j'ai pas vérifié en tappant.

'BONNE PROG A TOUZZZ

Conclusion :


http://www.steven007.fr.st

A voir également

Ajouter un commentaire

Commentaires

Commenter la réponse de PtitJeoJeo

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.