|
Si l’utilisateur ne définit pas explicitement une variables, Visual Basic lui affecte automatiquement le type Variant.
Il est toutefois préférable de déclarer les variables pour les raisons suivantes :
• rapidité des calculs : La taille du type Variant dépend des données stockées par la variable. Il gère les valeurs allant jusqu'au Double et aux chaînes de 65 535 caractères. Les conversions requises par des données aussi différentes sont effectuées en interne, ce qui est agréable pour le développeur mais prend du temps de calcul est ralentit l'exécution du programme.
• moindre encombrement de la mémoire:
• Compatibilité : à l'exception de VB, aucun dialecte Basic ne connaît le type Variant. Si vous envisagez d'exporter une application VB vers un autre Basic, renoncez à l'usage de Variant.
Attribuer un type à une variable consiste à lui associer une taille mémoire et surtout une plage de valeurs.
| Type de donnée | Taille d'enregistrement | Plage |
| Byte | 1 octet | 0 à255 |
| Boolean | 2 octets | Vrai ou Faux. |
| Integer | 2 octets | -32 768 à 32 767. |
| Long (entier long) | 4 octets | -2 147 483 648 à 2 147 483 647 |
| Single (valeur à virgule flottante en simple précision) | 4 octets | -3,402823E38 à -1,401298E-45 pour les valeurs négatives; 1,401298E-45 à 3,402823E38 pour les valeurs positives. |
| Double (valeur à virgule flottante en double précision) | 8 octets | -1,79769313486232E308 à -4,94065645841247E-324 pour les valeurs négatives; 4,94065645841247E-324 à 1,79769313486232E308 pour les valeurs positives. |
| Currency | 8 octets | -922 337 203 685 477,5808 à 922 337 203 685 477,5807. |
| Date | 8 octets | 1er janvier 100 au 31 décembre 9999. |
| Object | 4 octets | Toute référence à des données de type Objet. |
| String | 1 octet par caractère | 0 à environ 2 milliards (environ 65 535 pour Microsoft Windows versions 3.1 et antérieures). |
| Variant | 16 octets + 1 octet pour chaque caractère | N'importe quelle valeur numérique dans la plage d'une valeur de type Double ou n'importe quel texte de caractères. |
C’est le mot-clé Dim qui permet de déclarer les variables.
Dim Adresse As String ..................................déclare une variable de texte de longueur variable
Dim Adresse As String *50 chaîne compte toujours 50 caractères
Dim Nombre As Integer.................................déclare explicitement une variable de type Entier. Dim AutreVar;Choix As Boolean;DateNaissance As Date déclarations multiples sur une même ligne. La variable AutreVar est de type Variant puisque son type n'est pas spécifié.
Attention !!! Dans une liste de variables de même type, il faut répéter le type pour chaque variable.Exemple :
Dim Lig , Col As Integer
Dim Alig, ACol As Integer
Dim numéro As Integer
Dim Ordre, reste As Integer Dim Msg, Title, Default As String
Opérateurs arithmétiques
| Opérateur Basic | Description | Ordre de priorité |
| ^ * / \ Mod + - | élévation à la puissance 2^3 =2*2*2=8 multiplication division division entière 38\5 = 7 Reste de la division entière 38 Mod 5 = 3 addition soustraction | 1 2 2 3 4 5 5 |
Opérateurs de comparaison
| < | Inférieur à |
| <= | Inférieur ou égal à |
| > | Supérieur à |
| >= | Supérieur ou égal à |
| = | Egal à |
| <> | Différent de |
Opérateurs de concaténation
| & | Concaténation de chaînes |
Opérateurs logiques
| And | Conjonction |
| Eqv | Equivalence |
| Imp | Implication |
| Not | Négation |
| Or | Disjonction (Ou inclusif) |
| Xor | Exclusion (Ou exclusif) |
Titre de la boite
Message destiné à l’utilisateur
Valeur par défaut
Pour afficher cette boite de dialogue, il faut écrire les instructions suivantes : prompt = "Entrer un nombre impair" ' Définit le message.
Title = "Ordre du Carré" ' Définit le titre de la boite.Default = "3" ‘ Définit la valeur par défaut. xpos = 4000 ypos = 4000
Ordre = InputBox(prompt, Title, Default,xpos,ypos) ' Affiche le message, le titre et la valeur par défaut.
On pourrait également tout concentrer en une seule instruction, mais ce serait au détriment de la lisibilité.
Ordre = InputBox( "Entrer un nombre impair", "Ordre du Carré", "3",4000,4000)
Pour connaître la syntaxe des instructions ou fonctions de Visual Basic, il faut appeler l’aide à partir de l’éditeur de Code.
Appuyez sur les touches Alt + F11 puis sur le point d’interrogation.
prompt = "Entrer un nombre impair".
Dans le message affiché précédemment, il faut vérifier que l’utilisateur entre bien un nombre impair. Si tel n’est pas le cas, il faut afficher à nouveau la boite de dialogue.
L’affichage du message doit être répétitif tant que le nombre introduit n’est pas impair.
Tel que nous venons de le formuler, une boucle « tant Que » semble s’imposer ! Mais en recherchant les cardinalités d’affichage du message, on s’aperçoit qu’il doit au moins être affiché une fois et réaffiché plusieurs fois selon le comportement de l’utilisateur. La cardinalité est 1,n.
La boucle Répéter… Jusqu’à s’impose donc.
Le raisonnement devient :
Répéter
Afficher la boite de dialogue
Jusqu’à ce que le nombre frappé par l’utilisateur soit impair
| Syntaxe | Exemple |
|
Do [instruction] [Exit Do] [instruction] Loop [Until condition] | Do Ordre = InputBox(prompt, Title, Default, xpos, ypos) reste = Ordre Mod 2 Loop Until reste = 1 |
Un nombre impair est un nombre dont le reste de la division entière par 2 est 1. L’opérateur « division entière » dite aussi « division Euclidienne » est MOD, abréviation de MODULO.
Si l’utilisateur frappe le nombre 6, la variable Ordre contiendra la valeur 6.
Ordre6 2
Reste0 3
Reste vaudra 0. Le programme remontera jusqu’à l’ordre Do et réaffichera la boite de dialogue.
Dans le calcul d’un carré magique, il faut après avoir introduit l’ordre qui nous donne la taille du carré, remplir toute les cellules de 0
Nous allons donc balayer toutes les lignes et toutes les colonnes concernées et affecter un 0 à chaque cellule.
Si l’utilisateur frappe la valeur 5, l’Ordre du carré sera de 5, c’est à dire que ce carré possèdera Ordre * Ordre cellules. Il faudra balayer ordre colonnes sur ordre lignes.
La cardinalité, c’est à dire le nombre d’itérations (ou d’opérations) est connu à l’avance. La boucle POUR s’impose !
| Syntaxe | Exemple |
| For MonIndice = 15 to 75 Step 5 Instructions [Exit For] Instructions Next MonIndice | For Lig = 1 To Ordre For Col = 1 To Ordre Cells(Lig, Col).Select ActiveCell.FormulaR1C1 = 0 Next Col Next Lig |
| Step est le pas, on dit l’incrément. La première valeur de MonIndice sera 15, la suivante 15 + 5, soit20, puis 25, 30…jusqu’à 75. Si la valeur Step n’est pas précisée , elle est implicitement égale à 1. Exit For , permet de sortir de la boucle avant la dernière valeur atteinte. Exit for est généralement mentionnée dans une condition. | La boucle extérieur, joue sur les numéros de ligne, alors que la boucle interne, passe en revue toutes les cellules d’une ligne. La ligne Cells(Lig, Col).Select, rend active la cellule de coordonnée lig, col. La ligne ActiveCell.FormulaR1C1 = 0, affecte la valeur 0 à la cellule active. |
Après avoir initialisé le carré, il faut écrire la valeur 1 dans la case médiane de la première ligne.
Lig = 1 ' position de la ligne Col = Fix(Ordre / 2) + 1 ' position de la colonne numero = 1 ‘ numero de la case
Cells(Lig, Col).Select ' position du pointeur de cellule
ActiveCell.FormulaR1C1 = numero ' numerotation de la cellule
Col = Fix(Ordre / 2) + 1, la fonction Fix correspond à la valeur entière. Ainsi si Ordre vaut 3, Col prendra la valeur partie entière (3 / 2) soit partie entière (1,5) donne 1. Donc 1+1 donne 2. C’est bien la case médiane de la première ligne d’un carré d’ordre 3.
Ce premier calcul correspond à l’amorce de la boucle suivante qui peut éventuellement ne pas être exécutée si l’utilisateur demande un carré d’ordre 1. La cardinalité de la boucle est 0, N.
La boucle Tant Que s’impose. On l’utilisera tant que le numéro de la cellule à numéroter est inférieure au carré de l’ordre.
Tant que numero < ordre2
Numéroter la case suivante
Fin tant Que
Compteur = 0 ' Initialise la variable.
Do While Compteur < 20 ' Vérifie la valeur de Compteur. Compteur = Compteur + 1 ' Incrémente Compteur.
Loop ‘ plancher de boucle
Exemple
Vérifier = Vrai
Compteur = 0 ' Initialise les variables.
Do. ' Boucle externe.
Do While Compteur < 20 ‘ Boucle interne.
Compteur = Compteur + 1 ' Incrémente le compteur.
If Compteur = 10 Then ' Si la condition est vraie.
Vérifier = Faux. ' Affecte la valeur Faux à l'indicateur. Exit Do ' Sort de la boucle interne.
End If
Loop ‘ plancher de la boucle TantQue
Loop Until Vérifier = Faux ' Sort immédiatement de la boucle externe. Dans cet exemple, l'instruction Do incrémente une variable de compteur.
Les instructions incluses dans la boucle sont exécutées tant que la condition est vraie.
Pour la numérotation des cellules du carré magique, trois cas d’exception peuvent se présenter :
1. Le numéro de la ligne est égal à 0, il faut alors lui donner la valeur de l’ordre ;
2. Le numéro de colonne est égal à ordre + 1, il prendra alors la valeur zéro ;
3. La cellule à numéroter l’est déjà, il faut donc revenir à la cellule précédente.
Ces trois situations peuvent être gérées par un raisonnement alternatif : Si Alors Sinon.
VBA supporte les 4 syntaxes suivantes :
| Syntaxe 1 : une seule ligne If condition Then, InstructionsVrai | Syntaxe 2 : If condition Then Instructions End If |
| Syntaxe3 If condition Then Instructions Else Instructions End If | Syntaxe 4 : If condition1 Then Instructions1 Elseif condition2 Then Instructions2 Else InstructionsAutres End If |
| Lig = Lig - 1 Col = Col + 1 numero = numero + 1 | Ces deux lignes calculent le déplacement en diagonale. Le pointeur remonte d’une ligne et se déplace d’une colonne. On calcule ainsi le numéro de la prochaine case. |
| If Lig = 0 Then Lig = Ordre End If | Le déplacement précédent peut avoir généré un indice de ligne = 0. On est donc sorti du carré « par le haut ». Il faut alors donner au numéro de ligne la valeur de l’ordre du carré |
| If Col = Ordre + 1 Then Col = 1 | Le déplacement précédent peut avoir généré un indice de colonne égal à ordre + 1. On est sorti par la droite du carré. Il faut revenir en colonne 1. |
End If
Le programme complet du carré magique devient :
Les lignes oranges correspondent au programme, les lignes vertes aux commentaires acceptés par l’interpréteur, les lignes bleus aux commentaires de l’auteur.
| Algorithme | Programme VBA | |||
| Variable carre(21, 21) : numérique '----------------------------------------------------- ' Introduire l'ordre du Carré et vérifier l'imparité '----------------------------------------------------- Répéter Introduire ordre Jusqu’à ce que reste(ordre/2) =1 '----------------------------------------------------- ' Initialisation du carré '---------------------------------------------------- Pour ligne de 1 à ordre Pour colonne de 1 à ordre carre(ligne, colonne) <- 0 Fin Pour Fin Pour '----------------------------------------------------- ' Numérotation de la case 1 '----------------------------------------------------- ligne <- 1 colonne <- Entier(ordre / 2) + 1 numéro_case <- 1 carre(ligne, colonne) <- numéro_case '----------------------------------------------------- ' Numérotation des autres cases jusqu'à ordre*ordre '----------------------------------------------------- Tant que numéro_case <= ordre * ordre '----------------------------------------------------- ' Mémorisation des anciennes coordonnées '---------------------------------------------------- anc_ligne <- ligne anc_colonne <- colonne '----------------------------------------------------- ' Déplacement en diagonale '---------------------------------------------------- ligne <- ligne - 1 colonne <- colonne + 1 numéro_case <- numéro_case + 1 '----------------------------------------------------- ' Si sortie par le haut '----------------------------------------------------- Si ligne = 0 Alors ligne <- ordre Fin Si '----------------------------------------------------- ' Si sortie à droite '----------------------------------------------------- Si colonne = ordre + 1 Alors colonne <- 1 Fin Si '----------------------------------------------------- ' Si après déplacement la case est déjà numérotée on ' se place sous la dernière case numérotée '---------------------------------------------------- | ' Carré_magique ' ' Touche de raccourci du clavier: Ctrl+c ' Sub Carré_magique() Dim Lig As Integer Dim Col As Integer Dim Alig As Integer Dim ACol As Integer Dim numero As Integer Dim reste, Ordre, xpos, ypos As Integer Dim prompt, Title, Default As String prompt = "Entrer un nombre impair" Title = "Ordre du Carré". Default = "3" xpos = 4000 ypos = 4000 Do Ordre = InputBox(prompt, Title, Default, xpos, ypos) reste = Ordre Mod 2 Loop Until reste = 1 Sheets("Carré").Select Sheets("Carré").Cells.Select Selection.ClearContents ' Initialisation du carré For Lig = 1 To Ordre For Col = 1 To Ordre Cells(Lig, Col).Select ActiveCell.FormulaR1C1 = 0 Next Col Next Lig (Now + TimeValue("0:00:01")) Lig = 1 Col = Fix(Ordre / 2) + 1 numero = 1 Cells(Lig, Col).Select Debug.Print "i-lig = "; Lig, "col ="; Col ActiveCell.FormulaR1C1 = numero Do While numero < Ordre * Ordre Alig = Lig ACol = Col Lig = Lig - 1 Col = Col + 1 Debug.Print "0-lig = "; Lig, "col ="; Col numero = numero + 1 If Lig = 0 Then Lig = Ordre Debug.Print "1-lig = "; Lig, "col ="; Col End If If Col = Ordre + 1 Then Col = 1 Debug.Print "2-lig = "; Lig, "col ="; Col End If | |||
| Si carre(ligne, colonne) <> 0 Alors ligne <- anc_ligne + 1 colonne <- anc_colonne Fin Si carre(ligne, colonne) <- numéro_case Fin Tant Que '----------------------------------------------------- ' Affichage du carré magique '----------------------------------------------------- Pour ligne de 1 à ordre Pour colonne de 1 à ordre Ecrire(carre(ligne, colonne ) Fin Pour Fin Pour '----------------------------------------------------- 'Calcul de la valeur magique '---------------------------------------------------- magie <? 0 Pour compteur de 1 à ordre magie <? magie + carre(1, compteur) Fin Pour Ecrire " Valeur magique = ", magie Fin | If Cells(Lig, Col) <> 0 Then Lig = Alig + 1 Col = ACol Debug.Print "3-lig = "; Lig, "col ="; Col End If Cells(Lig, Col).Select Debug.Print "4-lig = "; Lig, "col ="; Col ActiveCell.FormulaR1C1 = numero Loop L’affichage du carré n’est pas nécessaire dans Excel. L’instruction ActiveCell.FormulaR1C1 = numero, qui affecte une valeur à la cellule active implique automatiquement l’affichage de cette valeur. C’est une particularité du Tableur. End Sub | |||
Le caractère apostrophe, indique à l’interpréteur du langage, un début de commentaire. Tout caractère compris entre une apostrophe et un retour à la ligne sera considéré comme du texte libre.
Vous pouvez dès lors consacrer des lignes entières aux commentaires, ou insérer un commentaire en fin de ligne.
Dans l’Editeur VBA, les commentaires apparaissent en vert
' Touche de raccourci du clavier: Ctrl+c
| ' Sub Carré_magique() Dim Lig As Integer Dim Col As Integer | ' n° de la ligne en cours ' n° de la colonne en cours |
Pour vérifier le bon fonctionnement de son programme et vérifier la valeur prise par les variables calculées, il est possible d’ajouter une instruction Debug.print, dont le but est d’afficher des valeurs dans la fenêtre d’exécution du programme.
Debug.Print "3-lig = "; Lig, "col ="; Col
Le texte entre guillemets est reproduit tel quel, alors que les variables sont remplacées par la valeur calculée.
| Debug.Print | “ 3-lig =” | ; | Lig | “col=” | ; | Col |
| Imprimer dans la fenêtre d’exécution | Reproduire tel quel | tabulation | Valeur de la variable Lig | Reproduire tel quel | tabulation | Valeur de la variable Col |
La fenêtre d’exécution est accessible à partir du menu de commande Affichage.
(Now + TimeValue("0:00:01")) est une instruction qui permet de générer un e attente dans l’exécution d’un programme.
Dans l’exemple précédent le temps d’attente est de une seconde.
Nous l’utilisons dans le carré magique pour permettre à l’utilisateur de voir le résultat de la phase d’initialisation.
