Dictionnaire VBA.txt

Source principale : t.ly/uPPA

Activer la tab développeur : File > Options > Customize Ribbon > Cocher Developer
Basculer entre l'interface VBA et le classeur : Alt + F11
Afficher les coordonnées des cellules en chiffre : bit.ly/3ynGEZO

VBA ne fait pas attention à la casse (majuscules et minuscules)

______________________________
Syntaxes de base
------------------------------
Caractère de fin d'instruction : :          //on ne le met pas généralement mais peut être utile pour avoir plusieurs instructions sur la même ligne 
Caractère de commentaire : ' 

Afficher une variable dans une fenêtre : Call MsgBox(variable)           //bloque l'execution du reste du code tant que nous n'avons pas cliqué sur OK
Demander une entrée à l'utilisateur dans une fenêtre : InputBox("Message à afficher")     //retourne un string

Déclarer une variable explicitement : Dim ma_variable_explicite [As type] [, ...]   //pour un nombre, il est possible de déclarer par ex de cette façon : Dim ma_variable% 
Assigner à une variable : ma_variable_explicite = valeur        //fonctionne même sans déclarer la variable avec Dim. Dans ce cas, la variable aura par défaut un type variant
Empêcher une déclaration implicite pour un module : Option Explicit        //écrire cette ligne tout en haut du module 

### Types de déclaration
Publique : permet à la fonction d'être accessible dans tous les modules de l'application. Aussi, elles feront partie de la liste des macros que l'on peut attribuer sur une feuille de calcul.
Privé : Accessibles seulement dans leur propre module       // écrire Private avant la déclaration de la fonction  (ex: Private Sub  ou Private Function)
Au niveau du module : Déclaration régulière mais tout en haut du module
Au niveau global (tout le programme y aura accès) : Global ma_variable_globale [As type]         //écrire au début de nimporte quel module 
Variable avec valeur préservée même après que le programme se termine : Static ma_variable [As type]
Procédure statique : Static Sub procedure       //toute les variables déclarées dans la procédure seront aussi statiques
Constante : Const VARIABLE = valeur     //ex : Const NOM_CHEMIN = "D:\Utilisateur\"
Assignation d'une réference Objet à une variable  : Set variable = reference_objet   //ex: Dim c As Workbook: Set c = Workbooks("classeur1")

Vérifier si une valeur a été assignée à une variable : IsEmpty(ma_variable)

Syntaxe pour utiliser plusieurs fois la même référence à un objet : With ... End With    //exemple ↓
................
Selection.Font.Size = 14
Selection.Font.Name = "Euclid"
Selection.Font.Underline = xlUnderlineStyleSingle
Selection.Font.Bold = true

' peut être reécrit :

With Selection.Font
    .Size = 14
    .Name = "Euclid"
    .Underline = xlUnderlineStyleSingle
    .Bold = true
End With
................

______________________________
Opérateurs
------------------------------

### Opérateurs booléens

=                         : égal à
<>                        : différent de
Not(condition)            : négation 
condition1 Xor condition2 : retourne true si l'une des condition est true mais pas les deux
Objet1 Is Objet2          : retourne true si les deux objets sont de la même référence
string1 Like string2      : comparaison de string
AND                       : et
OR                        : ou

### Autre opérateurs

Modulo : number1 Mod number2
Typeof : TypeOf refInteger Is Integer       //retourne un booléen.   Autre ex: TypeOf refForm Is System.Windows.Forms.Form
Division entière : num1 \ num2
Division régulière : num1 / num2
Ternaire : iif(condition, resultatVrai, resultatFaux)
Racine carrée : Sqr(nombre)
Puissance : nombre ^ exposant

______________________________
Conditions
------------------------------
If ↓
................
    If age >= 18 Then
        MsgBox "Vous êtes un adulte"
        
    ElseIf age < 8 Then
        MsgBox "Vous êtes un surdoué pour être ici à votre âge !"
        
    Else
        MsgBox "Vous êtes encore mineur"
        
    End If
................

    
    
Select  ↓      //ressemble au switch
................
    Select Case (note)
        Case 1
        MsgBox "La note est de 1"
        
        Case 2, 3
        MsgBox "La note est de 2 ou 3"
        
    Case 4 To 6
        MsgBox "La note est de 4, 5 ou 6"
        
        Case Is > 6
        MsgBox "La note est supérieure à 6"
        
        Case Else
        MsgBox "La note est inférieure à 1"
        
    End Select
................

______________________________
Types de base
------------------------------

+----------+-----------------------------------------------------------+-------------------------------------------------+--------------------------+
| Nom      | Description                                               | Plage                                           | Caractère de déclaration |
+==========+===========================================================+=================================================+==========================+
| Byte     | Contient un nombre entier (sans partie décimale = nombre  | 0 à 255                                         | Aucun                    |
|          | après la virgule) sur 1 octet                             |                                                 |                          |
+----------+-----------------------------------------------------------+-------------------------------------------------+--------------------------+
| Integer  | Contient un nombre entier sur 2 octets                    | -32 768 à 32 767                                | %                        |
+----------+-----------------------------------------------------------+-------------------------------------------------+--------------------------+
| Long     | Idem Integer sur 4 octets                                 | - 2 147 483 648 à 2 147 483 647                 | &                        |
+----------+-----------------------------------------------------------+-------------------------------------------------+--------------------------+
| Single   | Contient un nombre en virgule flottant (partie            | -3,402823E38 à 1,401298E-45 (valeurs négatives) | !                        |
|          | décimale variable) sur 4 octets                           |                                                 |                          |
|          |                                                           | 1,401298E-45 à 3,402823E38 (valeurs positives)  |                          |
+----------+-----------------------------------------------------------+-------------------------------------------------+--------------------------+
| Double   | Idem Single sur 8 octets                                  | ...                                             | #                        |
+----------+-----------------------------------------------------------+-------------------------------------------------+--------------------------+
| Currency | Nombre sur 8 octets avec une partie décimale fixe         | -922337203685477,5808 à 922337203685477,5807    | @                        |
+----------+-----------------------------------------------------------+-------------------------------------------------+--------------------------+
| String   | Fixe : max 65500 char, Variable : max 2000 000 char       | ...                                             | $                        |
+----------+-----------------------------------------------------------+-------------------------------------------------+--------------------------+

Numéro des types
0: Empty            //variable sans valeur assignée
1: Null
2: Integer
3: Long
4: Single
5: Double
6: Currency
7: Date/Time
8: String
0: Objet
11: Boolean
17: Byte

Valeurs par défaut
| Type                                 | Test                            | Test2
| Numeric (Long, Integer, Double etc.) | If obj.Property = 0 Then        | 
| Boolean (True/False)                 | If Not obj.Property Then        | If obj.Property = False Then
| Object                               | If obj.Property Is Nothing Then |
| String                               | If obj.Property = "" Then       | If LenB(obj.Property) = 0 Then
| Variant                              | If obj.Property = Empty Then    |

Obtenir type d'une variable : VarType(ma_variable)          //retourne le numéro du type
Obtenir nom du type d'une variable : TypeName(v)      // ex: pourrait retourner "String"

Vérifier si une valeur est null : IsNull(ma_variable)       //il existe aussi pour les autres types, ex : IsDate(var)  isNumeric(var)  ...

### Types personnalisés

Définir un nouveau type ↓
................
    Type joueur
        tribu As String
        vies As Byte
        points As Integer
    End Type
................

Utilisation d'un nouveau type ↓
................
    Dim bat538 As joueur

    bat538.tribu = "Zér0"
    bat538.vies = 5
    bat538.points = 0
................

______________________________
Chaines de caractère
------------------------------
Fixer la longueur dun string : Dim du_texte As String * longueur     // Si < à la longueur, comblé avec des espaces, sinon, coupé après la longueur.
Obtenir la longeur d'un string : Len(string)

Obtenir char à partir de son nombre sur la table ASCII : Chr(nombre)        //A = Chr(65)
Obtenir code ASCII à partir de char : Asc(char)
Transformer un String en Nombre : Val(string)
Caractère de retour à la ligne : Vbcrlf
Concaténer une chaîne de caractère : utliser &   //ex : "Cette phrase affiche la valeur de ma variable : " & ma_variable

Changer la casse d'un string : UCase|LCase(string)
Extraire une partie d'un string à partir des extrémités : Left|Right(string, nbChar)
Extraire une partie d'un string à partir d'une position : Mid(string, start, [length])    //si length est omis ou supérieur au reste, continue jusqu'à la fin
Enlever les caractères blancs à gauche et à droite de la chaine : Trim(string)
Cherche une chaine dans une autre : Instr(SearchString, SearchChar)     //renvoie la position si trouvé, sinon renvoie 0 

### Comparaison de string

Activer : Option Compare Binary|Text        //à ajouter tout en haut du module. Binary:fait une différence entre majuscule et minuscule  Text:ne fait pas de différence
Jokers
? : Remplace un seul caractère
* : Remplace zéro ou plusieurs caractères
# : Remplace un chiffre (de 0 à 9)
[Liste_de_caractères] : Remplace un caractère présent dans la liste  // possibilité d'utiliser - pour un intervalle   ex: [A-D] est pareil à [ABCD]
[!Liste_de_caractères] : Un seul caractère absent de la liste.

Exemple ↓
................
    "Site du 0" Like "site du [!5-9]"              ' Cette ligne renvoie True car 0 n'est pas compris entre 5 et 9 compris.
    "site du zéro" Like "site du *"                ' Cette ligne renvoie True
................

______________________________
Date
------------------------------
Assignation d'une valeur date : la_date = "23-07-2010"          //sera converti en timestamp du nombre de jours écoulés depuis le 31 décembre 1899  (nombre flottant)

Retourner le jour du mois pour une date : Day(objetDate)
Retourner le jour de la semaine pour une date : WeekDay(objetDate)   //Dimanche vaut 1 et Samedi vaut 7

______________________________
Tableaux
------------------------------
Déclarer un tableau : Dim tableau(longueur - 1) [As type] [, ...]    //va de la position 0 jusqu'à la position (longueur - 1) incluse //ex: Dim variable(30) va de 0 à 30 donc 31 éléments
Initialiser un tableau d'une seule ligne : Dim myarray As Variant : myarray = Array("Cat", 5, "Rabbit")     //fonctionne seulement pour le type variant
Initialiser un tableau de string d'une seule ligne : Dim arr() As String : arr = Split("Value1,Value2,Value3", ",")     //les arrays de split commencent toujours par 0 même avec Option Base 1
Modifier élément du tableau : tableau(position) = valeur
Faire en sorte que tous les tableaux commencent par la position 1 : Option Base 1       //écrire cela tout en haut du module
Déclarer un tableau et ses intervales de position : Dim mon_tableau(pos1 To pos2) [as type]     //ex : Dim mon_tableau(1 To 15) as String
Déclarer un tableau à plusieurs dimensions : ex pour deux dimensions : Dim mon_tableau(col, lignes) [As type]   //s'étends à plus de dimensions de la même façon (1,2,3..)

Obtenir taille de tableau ↓
................
    Public Function arrLength(a) As Integer
    arrLength = iif(IsEmpty(a), 0, UBound(a) - LBound(a) + 1)
    End Function
................

Tableaux dynamiques ↓
................
    Dim tableau() As Variant
    ReDim tableau(6)        ' il faut lui donner une dimension temporaire avant de pouvoir l'utiliser
    tableau(3) = "Hey"
    ReDim Preserve tableau(10)  ' utiliser Preserve pour redimensionner en préservant l'ancien contenu
................


______________________________
Boucles
------------------------------

While ↓
................
    While condition
        …
    Wend

    Do
        …
    Loop While condition
................

Until ↓
................
    Do Until condition
        …
    Loop

    Do
        …
    Loop Until condition
................

For ↓
................
    For i = 5 To 1 Step -1
        Call MsgBox(i)
    Next compteur

    Dim cellule As Range
    For Each cellule In Range("A1:A9")
        cellule.value = 0
    Next cellule
................


______________________________
Procédures
------------------------------

### Sous-routine
Créer une sous-routine ↓
................
    Sub ma_routine(args)
        …
    End Sub
................

Appeler une sous routine : Call sous_routine(args)          // ou sous_routine args

### Fonction
Créer une fonction ↓
................
Function ma_fonction(args) As Type      ' Il est possible de l'utiliser aussi dans une cellule excel
    …
    ma_fonction = valeur_de_retour
End Function
................

Appeler une fonction : ma_fonction(args)

### Arguments
Syntaxe à la définition : ex: ByVal nombre1, nombre2 As Double, Optional nombre3
Syntaxe à l'appel : (arg1, arg2, ...)   ou  (arg2 := x, arg1 := y, ...)

Options
arg As Type : obliger un certain type
Optional arg: argument optionel
ByVal arg : la variable donnée en argument est une copie
ByRef arg : la variable donnée en argument est la vraie référence (utilisé par défaut) 

Verifier si un argument optionnel est manquant : IsMissing(arg)   //retourne un booléen

Patron pour fonction avec overload ↓
................
  Public Function Morph(ParamArray Args())

      Select Case UBound(Args)
      Case -1 '' nothing supplied
          Morph = Morph_NoParams()
      Case 0
          Morph = Morph_One_Param(Args(0))
      Case 1
          Morph = Two_Param_Morph(Args(0), Args(1))
      Case Else
          Morph = CVErr(xlErrRef)
      End Select

  End Function

  Private Function Morph_NoParams()
      Morph_NoParams = "I'm parameterless"
  End Function

  Private Function Morph_One_Param(arg)
      Morph_One_Param = "I has a parameter, it's " & arg
  End Function

  Private Function Two_Param_Morph(arg0, arg1)
      Two_Param_Morph = "I is in 2-params and they is " & arg0 & "," & arg1
  End Function
................

______________________________
Types définis
------------------------------
Exemple d'utlisation ↓
................
    Type mon_type
        champ1 As Integer
        champ2() As Double
        champ3 As String
    End Type

    Sub test_type()
        Dim type1 as mon_type

        type1.champ1 = 5
        ReDim type1.champ2(5)
        type1.champ2(4) = 4.5
        type1.champ3 = "allo"
    End Sub
................


Enum ↓
................
    Enum Mobiles
        Samsung = 15000
        VIVO = 18000
        Redmi = 8500
        Oppo = 18500
    End Enum

    Sub Enum_Example1()
        Mobiles.Samsung
    End Sub
................



______________________________
Classeurs
------------------------------

Objets
Application : l'application active
Workbooks : les classeurs ouverts.      //est dans application      //ex: Workbooks(1)  ou Workbooks("classeur1")  ou  ActiveWorkbook  ou ThisWorkbook
Worksheets : les feuilles du classeur actif     //est dans workbooks
Range : groupe de cellule //ex : Application.Workbooks("classeur1").Worksheets("feuil1").Range("A1") //ex: Range(Cells(2, 2), Cells(10, 5))  //ex:Range("CELLULE_NOMME")
Cells : cellule         //syntaxe : Cells(ligne, colonne)    donc    Cells(3, 5).Select est équivalent à  Range("E3").Select
ActiveCell : cellule active 
Offset : cellule décalée par rapport à une autre  //ex :  ActiveCell.Offset(-1, -3) réfère à une cellule 1 ligne plus haut et 3 cols vers la gaunche par rapport à celle active
Rows : groupe de lignes de la feuille (peut être une seule)  //ex: sélection de la ligne 2 à 5 : Rows("2:5").Select  //si discontinues, utiliser Range : Range("2:2, 5:5, 6:8").Select
Columns : groupe de colonnes (peut être une seule)  //fonctionne de la même manière que Rows  //autre exemple utilisation : Call plage.Range(plage.Columns(1), plage.Columns(5)).Select
Selection : ce qui est sélectionné
Font : contient les attributs et méthodes des textes
    Name : attribut correspondant au nom de la police // ex : "arial"
    Size : attribut correspondant à la taille de la police // ex : 12
    underline : attribut correspondant au type de soulignement de la police //ex: xlUnderlineStyleSingle, xlUnderlineStyleDouble
    Bold : attribut booléen correspondant à si la police est en gras ou non


Opérateurs de séléction :
"C5, D4, F8:F12" : Séléctionne chacune de ces cellules de manière individuelle
"B2:E8" : Séléctionne la plage inclusive entre B2 et E8

Compter le nombre de cellules pleines pour une colonne/ligne : WorksheetFunction.CountA(Application.Workbooks("classeur1").Worksheets("feuil1").Range("A:A"))

Donner le focus à un élément : méthode Activate  //ex : Worksheets("Arrivée").Activate
Séléctionner des cellules : méthode Select de Range ou Cells   //ex : Range("nom_de_grp_de_cullule").Select
Décaler une séléction 

Exemple transfert d'information d'un formulaire : Cells(emptyRow, 1).Value = NameTextBox.Value          //plus d'info : bit.ly/3qTlWkx

### Attributs Application
Propriété           Description
ActiveCell          Représente la cellule présentement active.
ActiveSheet         Représente la feuille (de calcul ou graphique) présentement active.
ActiveWindow        Représente la fenêtre présentement active.
ActiveWorkbook      Représente le classeur présentement actif.
DisplayAlerts       Indique si les avertissements ("Voulez-vous sauver?") doivent être affichés.
Name                Le nom de l'application.
Selection           Représente la sélection de cellules courante.
Version             Contient la version de Microsoft Excel.
Workbooks           La collection de tous les classeurs ouverts à l'intérieur d'Excel.
WorksheetFunction   Permet d'utiliser des fonctions d'Excel à l'intérieur des programmes VBA.

Méthode
Intersect           Retourne une plage de cellules résultant de l'intersection de plusieurs plages.
Quit                Commande la fermeture de l'application Excel.
Union               Retourne une plage de cellules résultant de l'union de plusieurs plages.
Wait                Pause l'exécution d'un programme (et de toute l'application Excel).


### Attributs Range
Propriété           Description
Address             La référence de la plage dans la feuille (p. ex "$A$1").
Count               Le nombre de cellules dans la plage.
Font                Renvoie un objet Font qui correspond à la police de la cellule spécifiée.
Formula             Retourne la formule dans la cellule spécifiée.
Value               La valeur de la cellule.
Interior            Peut être utilisé pour modifier l'interieur des cellules (ex: Interior.Color = xlNone)

Méthode
ClearContents       Efface les formules dans la plage.
ClearFormats        Efface le formatage de la plage.
Select              Sélectionne la plage.
CurrentRegion       Zone délimitée par des lignes et colonnes vides


### Attributs Workbook
Propriété           Description
ActiveSheet         Représente la feuille (de calcul ou graphique) présentement active.
FullName            Indique le nom complet du fichier contenant le classeur (Path & Name).
Name                Indique le nom du classeur.
Path                Le chemin d'accès au fichier contenant le classeur.
Saved               Indique si les modifications au classeur ont été sauvegardées.
Sheets              La collection de toutes les feuilles (de calcul ou graphique) du classeur.
Worksheets          La collection de toutes les feuilles de calcul du classeur.
[Workbooks]Count    le nombre de classeurs ouverts
[Workbooks]Item     Permet d'accéder à un classeur //ex: Item(2) permet d'accéder au 2e classeur ouvert  //item est facultatif car Workbooks(2) fait la même chose

Méthode
Activate            Active le classeur.
Close               Ferme le classeur.
Save                Sauvegarde le classeur.
SaveAs              Sauvegarde le classeur sous un autre nom.
[Workbooks]Add      crée un nouveau classeur et l'ajoute à la collection Workbooks
[Workbooks]Open     Ouvre un classeur à partir d'un fichier.


### Attributs Worksheets
Propriété           Description
Count               le nombre de feuilles de calcul dans un classeur
Item                permet d'accéder à une certaine feuille de calcul   //ex: .Item(2)  ou  .Item("Données")

Méthode
Add                 crée une nouvelle feuille de calcul et l'ajoute à la collection Worksheets


### Attributs Worksheet
Propriété           Description
Cells               Permet d'accéder aux cellules.
Columns             Permet d'accéder aux colonnes.
Index               Indique la position de la feuille.
Name                Indique le nom de la feuille.
Names               La collection de toutes les plages de cellules nommées dans la feuille.
Range               Permet d'accéder à une cellule ou à une plage de cellules.
Rows                Permet d'accéder aux rangées.
Visible             Indique si la feuille est visible ou non.

Méthode
Activate            Active la feuille.
Copy                Copie la feuille.
Delete              Efface la feuille.
Move                Déplace la feuille.
PrintOut            Imprime la feuille.
Select              Sélectionne la feuille.


______________________________
Formulaires
------------------------------

### Évènements 
_Click() : Permet de faire exécuter du code lorsque l’on clique sur l’objet.
_Change() : Permet de faire exécuter du code lorsque la valeur de l’objet change (n’est pas toujours disponible).
_AfterUpdate() : Permet de faire exécuter du code lorsque la valeur de l’objet est mise à jour (n’est pas toujours disponible).
_Activate() : Permet de faire exécuter du code lorsque l’objet devient actif.

Afficher formulaire : formulaire.Show
Fermer le formulaire : Unload Me        // à l'intérieur d'une fonction de formulaire.  Peut être qu'une façon générale serait Unload formulaire

//TODO https://www.youtube.com/watch?v=TxQU8qj4K_Y