Excel 20xx Initiation au VBA
Transcript of Excel 20xx Initiation au VBA
Excel 20xx Initiation au VBA
Copyright © 2021 All Rights Reserved
Joël Lambert
Pour Bruxelles Formation Rue de Stalle, 67 1180 Bruxelles 02/371.73.50
MICROSOFT EXCEL
Initiation à Visual Basic pour Applications : références de cellules, macros, fonctions, variables, instructions de contrôle (if, case), de boucles (for, do loop) – Niveau avancé
1
JOËL LAMBERT
INITIATION À VISUAL BASIC POUR APPLICATIONS
INTRODUCTION 2
UTILISATION DE PROCÉDURES 3
LES MACROS 3 LES FONCTIONS 6 INSTRUCTION CONDITIONNELLE : IF .. THEN .. ELSE 9
LES VARIABLES 10
DECLARATIONS DES VARIABLES 14 DÉBOGAGE DU CODE VBA 15 PORTÉE DES VARIABLES 16 APPLICATIONS 18
UTILISATION D’INSTRUCTIONS DE CONTRÔLES (IF, FOR, DO LOOP …) 19
IF … THEN … ELSE, SELECT CASE 19 LES BOUCLES 20 BOUCLES « FOR » 20 BOUCLES « DO LOOP » 21
TABLEAU DE VARIABLES 23
2
JOËL LAMBERT
INTRODUCTION
VBA est un langage de programmation proche de Visual Basic. Ce langage (VBA) a la particularité d’être associé aux applications de MS Office (Word, Excel, Access, Outlook, …) et permet d’automatiser ou de personnaliser des tâches d’utilisation de ces programmes. L’automatisation de tâche peut se faire sans connaître ‘VBA’ via les macros mais ce n’est bien souvent pas suffisant. Il faut dès lors être capable de pouvoir créer ses propres procédures ‘VBA’, ou du moins pouvoir modifier les macros créées via les générateurs de macros des applications. Dans un premier temps, les différentes notions ‘VBA’ (Visual Basic pour Applications) seront étudiées en Excel. Les principes de base restent les mêmes qu’elles que soit l’application utilisée. Certaines fonctionnalités sont propres à l’application comme, par exemple, les notions de références de cellules sous Excel ou les événements associés aux formulaires sous Access. Ici seront traitées les fonctionnalités du code VBA sous Excel. Ce cours traitera des matières suivantes :
- Type de procédures, création et utilisation des procédures. - Notions et utilisation de variables. - Tableaux de variables. - Instructions de contrôle et de traitement des données :
o If .. Then .. Else o For i = 1 to n o Do loop o …
Une seconde partie à ce cours traitera de la conception de formulaires et sera étudiée lors de la formation « Excel 20xx : VBA – Formulaires ». Cette formation mettra en évidence la création de formulaire en Excel et l’utilisation des éléments suivants :
- Utilisation des contrôles de formulaire : zone de texte, bouton, case à cocher, liste, …
3
JOËL LAMBERT
UTILISATION DE PROCÉDURES
Les macros et procédures sont utilisables uniquement si le contenu (code VBA) est activé.
Afin d’avoir la barre de message permettant d’activer le contenu, il faut le paramétrer dans les options d’Excel .. Centre de gestion de la confidentialité.
Pour créer des macros et définir toutes les actions à ce niveau, il faut afficher le ruban ‘Développeur’. Ceci se fait via les options d’Excel .. Personnaliser le ruban.
LES MACROS
1- Enregistrement de macros : Ruban développeur .. Enregistrer une macro
Les instructions à enregistrer sont les suivantes : Début de l’enregistrement Se positionner dans la cellule où sera effectué le calcul Effectuez le calcul (=phtva + phtva * 21%) Valider (Enter) Fin de l’enregistrement
2- Exécution de la macro :
▪ Via « Ruban développeur .. macros .. sélection de la macro .. exécuter la
macro sélectionnée » ▪ Via le raccourci clavier prévu lors du début de l’enregistrement. Si ça n’a
pas été fait, celui-ci est modifiable via « Ruban développeur .. macros .. sélection de la macro .. option de la macro sélectionnée »
▪ Via un bouton de contrôle de formulaires
▪ Via un bouton de contrôle ActiveX
Un classeur « Vba.xlsm » sera utilisé afin de réaliser les manipulations suivantes. Les solutions et manipulations se trouvent dans un classeur « Vba_solution.xlsm »
A partir d’une feuille ‘Procédures1’ de « Vba.xlsm », créez une macro permettant de calculer le prix Tvac (taux = 21 %) à partir d’un prix hors Tva
4
JOËL LAMBERT
3- Code Visual Basic de la macro :
Lorsque la macro est enregistrée, un code ‘VBA’ est généré et se présente comme ceci :
Sub NomMacro ( ) Instructions de la macro End Sub
Le code ‘VBA’ de la macro est accessible via l’éditeur VBA (Ruban développeur .. Visual basic)
ou via « Macros .. Sélection de la macro .. modifier) :
Les macros peuvent être attachées à une feuille (feuil4.addition) ou à un module (tva). Ces 2
éléments font partie du classeur mais il est souhaitable de placer la macro dans un module car si une feuille est supprimée, les macros de la feuille le sont aussi. Lorsque nous utilisons l’enregistreur de macros, celles-ci sont placées dans un module.
Les options de la macro permettent notamment de définir le raccourci permettant
l’exécution de la macro :
5
JOËL LAMBERT
L’éditeur VBA (Ruban développeur .. Visual basic)
Lorsque vous programmez en VBA, voici les éléments principaux à afficher :
o Affichage .. Code (1) o Affichage .. Explorateur de projet (2)
▪ Feuilles, « This Workbook », Modules du projet o Affichage .. Fenêtre propriétés (3)
▪ Permet de renommer un module o Affichage .. Fenêtre Exécution (4)
▪ Permet d’afficher les résultats intermédiaires d’une macro ou fonction o Affichage .. Barre d’outils .. Edition (5)
▪ Contient notamment des boutons qui permettent de basculer en commentaire et vice-versa
o Affichage .. Barre d’outils .. Standard (6) ▪ Contient notamment des boutons qui permettent d’exécuter les procédures
(1)
(6)
(5)
(4)
(3)
(2)
6
JOËL LAMBERT
LES FONCTIONS
Nous avons l’habitude d’utiliser des
fonctions sous Excel. Une série de fonctions existe déjà mais il est possible de créer ses propres fonctions. Les fonctions créées par l’utilisateur se retrouvent dans la rubrique des fonctions personnalisées pour autant qu’elles aient été créées dans un module.
Le code ‘VBA’ d’une fonction a cette structure :
Function NomFonction (arg1 as Type, arg2 as type) as type NomFonction = calcul utilisant les arguments de la fonction End Function
1- Création de la fonction :
Le calcul que doit effectuer la fonction est le suivant : Ptvac = phtva + phtva * 21% Le résultat attendu (ptvac représente la fonction elle-même, c’est le nom de la fonction). Les valeurs à utiliser afin de calculer le résultat (phtva) sont les arguments de la fonction. En VBA, la fonction est celle-ci : Function Ptvac (phtva) Ptvac = phtva + phtva * 21/100 End function
7
JOËL LAMBERT
2- Encodage de la fonction en VBA :
▪ Se placer dans un module (« Ruban développeur .. Visual basic »)
3- Utilisation de la fonction (« Insertion .. fonction »)
Ici, seul le prix hors Tva peut être encodé lorsque la fonction est utilisée. Etant donné que plusieurs taux de Tva existent, nous pourrions aussi définir le taux de Tva comme argument de la fonction
La fonction devient :
Function Ptvac2 (phtva, taux) Ptvac = phtva + phtva * taux End function
Créez une fonction Ptvac2 de façon à permettre à l’utilisateur de définir lui-même le taux de Tva à utiliser
Cellule contenant le prix hors Tva
8
JOËL LAMBERT
4- Type de données des fonctions et de leurs arguments : Chaque élément utilisé dans une fonction, que ce soit le résultat (la fonction elle-même) ou les arguments correspondent à un type de données. Les principaux types de données sont les suivants : Chaîne de caractère String Numérique entier Integer ou Long (entier court ou entier long) Numérique réel Single ou Double (réel court ou réel long) Date Date Oui/non Boolean Monétaire Currency NB : la distinction entre les courts et les longs est une vieille notion. Les ‘courts’ occupent moins de place sur le disque mais sont limités du point de vue de la gamme des valeurs disponibles. Anciennement, l’espace disque était une denrée rare et chère. Maintenant, ça a moins d’importance et, si vous avez des doutes quant au type à utiliser, utilisez sans trop réfléchir les ‘longs’. Par contre, si vous êtes sûr que les valeurs que vous utilisez seront toujours petites et que peu de décimales doivent être utilisées, vous pouvez utiliser les ‘courts’.
Les types de données des fonctions se définissent de cette façon :
NB : Si les types ne sont pas spécifiés, chaque donnée sera de type variant. Ce type ne permet pas de contrôle et occupe beaucoup d’espace disque.
5- Personnalisation de la fonction : une définition de la fonction et une explication des arguments peut être fourni en exécutant la procédure suivante :
Sub AddPtvac2ToMaCategorie()
Application.MacroOptions Macro:="ptvac2", Description:="Calcul ptvac2", _ Category:="MaCategorie", argumentdescriptions:=Array("Argument phtva = monétaire", _ "Argument Taux = taux de tva")
End Sub
Le prix hors tva est un réel long
Le taux est un réel long
Le résultat de la fonction est de type réel long (ou double)
9
JOËL LAMBERT
INSTRUCTION CONDITIONNELLE : IF .. THEN .. ELSE
Sur une feuille ‘Procédures2’, à l'aide d'une fonction "tva_cat", calculez les prix tva comprise des produits suivants selon le code catégorie et le prix hors tva.
NB : En commentaire, vous disposez du code de l’instruction conditionnelle ‘Select Case’
10
JOËL LAMBERT
LES VARIABLES
Une variable est une zone de mémoire nommée permettant de stocker des valeurs qui seront utilisées dans d’autres traitements ou procédures. Sur une nouvelle feuille ‘Procédures3’ de « Vba.xlsm », créez les macros et fonctions décrites ci-dessous :
Macro TitreSub (en référence de type rc) :
Sub TitreSub() 'Sauver le contenu de la cellule à gauche dans une "variable", ici le nom de la variable est ‘sexe’
ActiveCell.Formula = "=rc[-1]" sexe = ActiveCell.Value ‘msgbox sexe => permet de visualiser le contenu de la variable
'Ecrire "Madame" ou "Monsieur" dans la cellule active
If sexe = "f" Then
ActiveCell.Formula = "Madame" Else
ActiveCell.Formula = "Monsieur" End If
End Sub
11
JOËL LAMBERT
Macro TitreSub2 (en référence de type cells(row,column)) Row et column sont des entiers (integer) Sub titresub2()
'Sauver le contenu de la cellule à gauche dans une "variable". Ici 3 variables sont utilisées : ‘ligne’ et ‘colonne’ qui vont nous permettre de récupérer les numéros des lignes et colonnes courantes et ‘sexe’ qui nous permet de récupérer le contenu de la cellule à gauche
ligne = ActiveCell.row colonne = ActiveCell.column sexe = cells(ligne,colonne-1).Value
'Ecrire "Madame" ou "Monsieur" dans la cellule active
If sexe = "f" Then ActiveCell.Formula = "Madame"
Else ActiveCell.Formula = "Monsieur"
End If
End Sub
Fonction TitreFct :
Function TitreFct(sexe As String) As String
If sexe = "f" Then TitreFct = "Madame"
Else TitreFct = "Monsieur"
End If
End Function
Fonction TitreFct2 :
Function titrefct2(sexe As String, ec As String) As String
If sexe = "f" And ec = "célibataire" Then titrefct2 = "Mademoiselle"
Else If sexe = "f" And (ec = "marié" Or ec = "divorcé") Then
titrefct2 = "Madame" Else
titrefct2 = "Monsieur" End If
End If End Function
12
JOËL LAMBERT
NB1 : VBA est sensible à la casse (f <> F) : Les arguments seront convertis en minuscule (par l’utilisation de la fonction LCase(String) et comparé avec des minuscules :
NB2 : Regardons le code de la fonction ci-dessus de plus prêt et essayons d’en simplifier
l’écriture :
Function TitreFct2(sexe As String, ec As String) As String If LCase(sexe) = ..................................................................................................... TitreFct2 = “ ....................................................................................... Else ......................................................................................................................... If ........................................................................................................ TitreFct2 = “ ....................................................................... Else TitreFct2 = “ ....................................................................... End If ...............................................................................................................................
End Function
NB3: Une (bonne) alternative est d’écrire les 3 ‘If’ sur 1 seule ligne
Function TitreFct2(sexe As String, ec As String) As String If LCase(sexe) = "f" And LCase(ec) = "marié" Then TitreFct2= "Madame" If LCase(sexe) = "m" then TitreFct2 = "Monsieur" If LCase(sexe) = "f" And LCase(ec) = "célibataire" Or LCase(ec) = "divorcé") Then _
TitreFct2 = "Mademoiselle" End Function
13
JOËL LAMBERT
NB4: Une autre alternative est l’utilisation des Select Case imbriqués
Function TitreFct2(sexe As String, ec As String) As String ‘Transformation des arguments en minuscule :
sexeEnMinuscule = LCase(sexe) ecEnMinuscule = LCase(ec)
‘Selon le contenu de l’argument sexe (mis en minuscule)
Select Case sexeEnMinuscule
‘Dans le cas où c’est un "f"
Case "f" ‘Dans le cas du "f", ça dépend aussi de l’état civil. Selon le contenu de l’argument ec (mis en minuscule) Select Case ecEnMinuscule
‘Dans le cas où c’est le mot "célibataire"
Case "célibataire"
TitreFct2 = "Mademoiselle"
Dans le cas où c’est le mot marié ou divorcé
Case "marié", "divorcé"
TitreFct2 = "Madame"
End Select
Case "m"
TitreFct2 = "Monsieur"
Case Else
TitreFct2 = "Erreur"
End Select
End Function
14
JOËL LAMBERT
DECLARATIONS DES VARIABLES
Créez un nouveau module ‘vérification’. Dans ce module, recopiez les procédures ‘TitreFct’ et ‘TitreSub2’. Changez le nom de ces procédures en ‘TitreFctVérif’ et ‘TitreSub2Vérif’
Dans le code de la fonction, faites une faute à un nom de cette fonction. Cette faute peut
être détectée si nous ajoutons ‘Option explicit’ en première ligne du module. Le compilateur (débogage .. compiler VBAProject) s’arrêtera à l’endroit de la faute :
Après correction, il faut relancer le compilateur pour continuer la correction. Celui-ci s’arrête alors sur la variable ‘ligne’. Lorsque ‘Option explicit’ est utilisée, il faut déclarer toutes les variables : leur donner un nom et un type de données.
L’utilisation complète des variables se fait en 3 étapes :
o Déclaration de la variable via l’instruction Dim o Affectation d’une valeur à la variable o Utilisation de la variable
15
JOËL LAMBERT
DÉBOGAGE DU CODE VBA
Dans le code de la procédure, ajoutez les instructions ‘debug.print’ (ou msgbox) de façon à
visualiser les résultats intermédiaires.
Dans le cas de l’utilisation de debug.print, ces résultats intermédiaires sont vus via la fenêtre d’exécution (affichage .. fenêtre d’exécution).
Dans le cas de l’utilisation d’une msgbox, ces résultats sont affichés à l’écran dans une fenêtre type ‘popup’.
NB : L’option explicit peut être déjà indiquée à la création d’un nouveau module si l’option de rendre la déclaration des variables obligatoire est cochée via ‘Outils .. option’ de l’éditeur VBA.
16
JOËL LAMBERT
PORTÉE DES VARIABLES
Sur une feuille ‘Variables1’ créez une sub de type macro qui permet d'afficher le contenu d'une cellule dans une msgbox, le contenu de la cellule active sera passé à la boîte à message via une variable
Le code de la macro est le suivant :
Sub bjr() Dim strsalut As String strsalut = ActiveCell.Value MsgBox strsalut
End Sub
L’exécution de la macro via un bouton donne ceci :
Une autre macro permettant de récupérer le contenu de la variable strsalut est la suivante :
Sub bjrbis() MsgBox strsalut
End Sub
Le contenu de la cellule active apparaît dans la boîte à message
Le contenu de la cellule active n’apparaît pas
17
JOËL LAMBERT
Les variables ont une portée (sont utilisables) qui dépend de l’endroit où elles sont définies. Ici, la variable est définie (dim strsalut) dans la première macro, elle ne peut donc pas être utilisée dans la deuxième. La variable définie ici est locale de niveau procédure. Afin de pouvoir l’utiliser ailleurs, il aurait fallu créer une variable locale de niveau module. Ceci se fait en la déclarant dans la zone de déclarations de la feuille ou d’un module.
Le contenu de la cellule active apparaît alors lorsque vous exécutez ‘bjr’ puis ‘bjrbis’
Dans le code d’une feuille ‘variables2’, recopiez la macro ‘bjrbis’. Exécutez ‘bjr’ de la feuille ‘variables1’ puis ‘bjrbis’ de la feuille ‘variables2’.
Afin qu’une variable
puisse être utilisée n’importe où dans un classeur, elle doit avoir une portée globale. Il faut la déclarer dans un module via le mot clé ‘public’.
NB1 : Les variables publiques doivent porter des noms différents.
NB2 : Si une variable est déclarée publiquement et qu’une variable de même nom est déclarée localement, elle perd sa portée globale. N’oubliez pas alors d’enlever les déclarations locales si vous avez besoin d’utiliser une variable globale.
Lorsque vous exécutez ‘bjr’ de la feuille ‘variables1’ puis ‘bjrbis’ de la feuille ‘variables2’, le
contenu de ‘strsalut’ apparaît maintenant dans toutes les boîtes à message.
18
JOËL LAMBERT
APPLICATIONS
Créez une SUB de type macro qui permet d'additionner les 2 valeurs qui se trouvent dans les cellules situées à gauche de la cellule active
Code VBA : Sub addition()
Dim valeur1, valeur2 As Double Dim résultat As Double ActiveCell.Formula = "=rc[-2]" valeur1 = ActiveCell.Value MsgBox valeur1 ActiveCell.Formula = "=rc[-1]" valeur2 = ActiveCell.Value MsgBox valeur2 résultat = valeur1 + valeur2 MsgBox résultat ActiveCell.Formula = résultat
End Sub
Créez une SUB permettant de faire la même chose que la procédure précédente mais cette fois en utilisant les références de cellules de type Cells(row,column)
Code VBA : Sub Addition2() ................................................................................. ................................................................................. ................................................................................. ................................................................................. End Sub
Créez une SUB de type macro qui permet d'additionner les 2 valeurs encodées via des boîtes de dialogue (InputBox). Le résultat sera écrit dans la cellule C11 de la feuille ‘Variables3’
Code VBA : Sub Addition3() ................................................................................. ................................................................................. ................................................................................. ................................................................................. End Sub
Utilisez la fonction InputBox : encodage = InputBox (« Encodez une valeur svp »)
19
JOËL LAMBERT
UTILISATION D’INSTRUCTIONS DE CONTRÔLES (IF, FOR, DO LOOP …)
IF … THEN … ELSE, SELECT CASE
Cf. Précédemment, « Applications sur les procédures » NB : Du point de vue de la syntaxe :
• Lors de l’utilisation de « If .. Then .. Else », « Then » doit être placé sur la même ligne que « If »
• Toute instruction « If » doit se terminer par « End if », sauf si toute l’instruction est sur la ligne. Par exemple, « If code_cat = "b" then tva_cat = phtva + 6 / 100 * phtva »
• Toute instruction « Select Case … » doit se terminer par « End Select »
Sur une feuille ‘Boucles’, créez un bouton permettant à l’utilisateur d’encoder son nom via une boîte de saisie (InputBox). Si l’utilisateur n’encode rien, un message dira « Vous deviez encoder votre nom » et le classeur sera fermé, si l’utilisateur encode ‘quelque chose’, un texte reprenant « Vous êtes ‘quelque chose’, il est 11:14 » sera placé en A1 (11:14 étant l’heure du pc)
20
JOËL LAMBERT
LES BOUCLES
Boucles « For »
Exemple : La boucle suivante permet d’encoder 3 valeurs dans des boîtes de saisie. Quand la boucle est terminée, la somme de ces valeurs apparaît dans une boîte à message : Sub bouton_click( )
Dim valeur as Integer Dim résultat as Integer Dim compteur as integer compteur = 1 résultat = 0 For compteur = 1 to 3 step 1 (pas nécessaire sauf si le pas est différent de 1) valeur = InputBox("Valeur "&compteur) résultat = résultat + valeur Next compteur MsgBox résultat
End Sub
Notes : ......................................................................................................................................................... ......................................................................................................................................................... ......................................................................................................................................................... ......................................................................................................................................................... ......................................................................................................................................................... ......................................................................................................................................................... .........................................................................................................................................................
Créez une procédure associée à un click sur un bouton laissant à l’utilisateur 3 tentatives d’encodage de son nom. Lorsque l’utilisateur a encodé un nom, celui-ci apparaît en A1. Si, après 3 tentatives aucun nom n’est encodé, le classeur se ferme.
21
JOËL LAMBERT
Boucles « Do Loop »
Exemple : La boucle suivante permet d’encoder 3 valeurs dans des boîtes de saisie. Quand la boucle est terminée, la somme de ces valeurs apparaît dans une boîte à message :
Utilisation de « Do Until Loop »
Private Sub CommandButton4_Click()
Dim compteur As Integer Dim valeur, résultat As Integer compteur = 0 Do Until compteur = 3
compteur = compteur + 1 valeur = InputBox("Valeur " & compteur) résultat = résultat + valeur If MsgBox("Voulez-vous sortir", vbYesNo) = vbYes Then Exit Do
Loop MsgBox résultat
End Sub
Utilisation de « Do While Loop »
Private Sub CommandButton4_Click()
Dim compteur As Integer Dim valeur, résultat As Integer compteur = 0 Do While compteur <= 3
compteur = compteur + 1 valeur = InputBox("Valeur " & compteur) résultat = résultat + valeur If MsgBox("Voulez-vous sortir", vbYesNo) = vbYes Then Exit Do
Loop MsgBox résultat
End Sub
22
JOËL LAMBERT
Version « Do Until Loop » : ...................................................................................................................................................... ...................................................................................................................................................... ...................................................................................................................................................... ...................................................................................................................................................... ...................................................................................................................................................... ...................................................................................................................................................... ...................................................................................................................................................... ...................................................................................................................................................... ...................................................................................................................................................... ......................................................................................................................................................
Version « Do While Loop » : ...................................................................................................................................................... ...................................................................................................................................................... ...................................................................................................................................................... ...................................................................................................................................................... ...................................................................................................................................................... ...................................................................................................................................................... ...................................................................................................................................................... ...................................................................................................................................................... ...................................................................................................................................................... ......................................................................................................................................................
Créez une procédure permettant de saisir des valeurs via une boîte de saisie. La somme de ces valeurs sera calculée dans une boucle et le résultat sera affiché dès qu’il sera supérieur à 100. Une instruction permettra de sortir de la boucle après l’encodage de 4 valeurs (si le résultat n’atteint pas 100).
23
JOËL LAMBERT
TABLEAU DE VARIABLES
1- Déclaration du tableau :
'tableau comportant 1 ligne et 3 colonnes Dim utilisateurstbl(0, 2) As String
2- Affectation des variables :
utilisateurstbl(0, 0) = "Alice" utilisateurstbl(0, 1) = "Bob" utilisateurstbl(0, 2) = "Caroline"
3- Utilisation d’un tableau (par exemple, parcours via une boucle « For » et affichage des
variables via MsgBox)
For i = 0 to 2 Msgbox utilisateurstbl(0,i) If MsgBox ("Vous êtes-vous reconnu ?",VbYesNo) = VbYes then Exit For Next i
Notes : ...................................................................................................................................................... ...................................................................................................................................................... ...................................................................................................................................................... ...................................................................................................................................................... ...................................................................................................................................................... ...................................................................................................................................................... ......................................................................................................................................................
Créez une procédure permettant à l’utilisateur d’encoder son nom via une boîte de saisie. L’utilisateur a droit à 3 tentatives. Si l’utilisateur n’est pas connu parmi 3 utilisateurs déclarés après les 3 tentatives, le classeur se ferme. Sinon, un message de bienvenue lui est adressé.
24
JOËL LAMBERT
Notes : ...................................................................................................................................................... ...................................................................................................................................................... ...................................................................................................................................................... ...................................................................................................................................................... ...................................................................................................................................................... ...................................................................................................................................................... ......................................................................................................................................................
Créez une fonction permettant de calculer le prix Tvac de produits. Le taux de Tva dépend du code catégorie du produit. Les codes catégorie entrés en argument de la fonction seront utilisés afin d’aller chercher le taux de Tva correspondant dans un tableau de variables.