Déclarer des variables public type cells.Value

Bonjour !

J'ai tout un module avec différents sub qui reprennent des mêmes variables.

Je souhaiterais donc déclarer ces variables en haut du module pour qu'elles soient utilisées dans chaque sub.

Cependant, ces variables sont de types Sheets(Feuil1).Range("A1").Value (car c'est un fichier excel à remplir par des personnes tierces)

Et je n'arrive pas à les déclarer..... (J'avoue que je ne déclare jamais mes variables d'habitude (petites macro personnelles) donc je suis un peu larguée)

Merci àvous!

Bonjour,

il faudra nous montrer ton code et ce qui ne fonctionne pas

Cependant, ces variables sont de types Sheets(Feuil1).Range("A1").Value (car c'est un fichier excel à remplir par des personnes tierces)

il n'existe pas de variable de type "Sheets(Feuil1).Range("A1").Value" et je ne comprends pas le lien avec des personnes tierces.

Le fichier excel est un document type qui doit être rempli par des personnes, et mes codes reprennent les éléments qu'ils ont remplis dans les cases correspondantes pour faire certaines actions. Les macros permettent à automatiser certaines actions qu'ils n'auront pas à faire manuellement.

Pour mes macros, j'affecte à des variables la valeur de ces cellules de la façon suivante :

NB_PERSONNES=Range("A1").Value

Qui fonctionne relativement bien.

Je voulais juste pousser le truc et les déclarer au préalable afin que je puisse juste utiliser "NB_PERSONNE" dans mes Sub, sans rajouter NB_PERSONNES=Range("A1").Value au début de chaque Sub

Edit : Ou peut-etre que j'utilise le mauvais terme en disant Variable ?!

Bonjour SoJa,

En A1, le nombre de personnes ; exemple : 42

Dans Module1 :

Option Explicit

Dim NB_PERSONNES As Integer

Sub Init()
  NB_PERSONNES = Worksheets("Feuil1").[A1]
End Sub

Dans ThisWorkbook :

Private Sub Workbook_Open()
  Init
End Sub

Ainsi, à l'ouverture du fichier, la sub Workbook_Open appelle la sub Init()

et affecte correctement 42 à ta variable globale NB_PERSONNES.

NB : Init est une abréviation courante de Initialisation

Cordialement

Ooh... Je vois !!

Je vais finir mon code d'abord, puis j'essayerai ta méthode.

Je reviens ici plus tard pour fermer le sujet si ça a marché !

Merci bcp en tout cas

Bonjour,

Seulement, si la valeur est changée après l'ouverture, ce changement ne sera pas pris en compte (jusqu'à la prochaine ouverture) donc, il est important de prendre ça en compte !

La déclaration systématique des variables est très fortement conseillé !

Oui en effet, je m'étais faite cette réflexion

Je sais bien.. Mais j'ai appris VBA en farfouillant sur internet , au début je ne saisissais pas toute la logique et mes premiers codes fonctionnait sans rien déclarer, donc j'ai prit le pli à force de faire sans vu qu'ils fonctionnaient toujours à la fin et que j'arrivais toujours à retrouver les erreurs

Mais là vu que je me lance dans un fichier complet avec plusieurs macros , et que ce fichier sera utilisé par des personnes n'ayant pas accès au code, déclarer ses variables est un plus non négligeable pour la gestion des erreurs

Donc autre question : si les variables ne correspondent pas au type saisi, on peut donc faire un On error go to ? Ou comment les gérer ?

On error go to

⚠ le « go to » est en un seul mot : GoTo

On Error GoTo permet de mettre en place une gestion d'erreur ; si par exemple tu as déclaré une variable de type entier et qu'à l'exécution ça tente d'y mettre un nombre fractionnaire : erreur d'exécution ➯ l'exécution du code se poursuivra à la ligne du label de branchement (étiquette en début de ligne), mais tu pourras juste afficher un message d'erreur : ton nombre fractionnaire ne sera toujours pas pris en compte, et ce sera toujours impossible de le mettre dans une variable de type entier.

La gestion d'erreur est plutôt à utiliser pour d'autres traitements plus techniques ; pour la saisie utilisateur d'un nombre, le mettre dans une variable de type String, puis utiliser Val() et le tester ; je te laisse regarder la doc en ligne pour plus d'infos sur la gestion d'erreurs.

Cordialement,

dhany

Bonsoir,

Salut à tous !

Et je n'arrive pas à les déclarer..... (J'avoue que je ne déclare jamais mes variables d'habitude (petites macro personnelles) donc je suis un peu larguée)

Sans revenir sur tout ce qui a déjà été dit, déclarer ses varaibles, c'est une habitude à prendre ! Tu peux utiliser l'option Explicit pour t'y contraindre... Pour ma part je n'aime pas utiliser cette option, mais je déclare toujours toutes les variables, y compris si je tape un bout de code test d'une ligne que j'effacerai ensuite.

Pourquoi déclarer les variables ?

Il convient de les déclarer en tête de module pour les variables de niveau module et en tête de procédure pour les variables locales, afin de tirer tout le bénéfice de la déclaration. Lorsqu'il rencontre des déclarations de variables, VBA réserve l'espace mémoire qui leur est destiné, s'il peut commencer par cela, cela lui permettra ensuite d'accéder plus rapidement aux variables...

Il convient aussi autant que possible de les typer, afin d'optimiser l'utilisation de la mémoire... une variables non typée sera de type Variant, c'est à dire qu'elle pourra accueillir tout type de donnée, mais elle occupera plus de mémoire en général et son accès sera moins rapide. Mais on peut avoir intérêt à laisser des variables de type Variant si le type de données accueillies peut varier ou si l'on a à leur appliquer certains tests qui ne fonctionneront pas sur des variables d'un autre type (par exemple la valeur Empty est propre aux variables de type Variant, de même les arguments de procédures (assimilables à des variables) optionnels dont on veut tester la présence avec IsMissing doivent être de type Variant...).

Et je dirai aussi que je laisse le plus souvent en Variant les variables destinées à accueillir des dates, car la manipulation de dates peut conduire à jongler simultanément avec des données de type Date ou String ou Long...

Il est souhaitable aussi en ce qui concerne les variables objet de les typer du type d'objet qu'elle doivent représenter (plutôt que du type Object générique). L'avantage immédiat en est la reconnaissance par VBA qui te proposera d'emblée dès que tu tapes un point à la suite tous les membres de l'objet concerné, ce qui te permet d'éviter bien des erreurs de syntaxe...

Il y a des cas cependant où l'on ne peut typer, certains objets étant quelque peu volatils. Tu pourras notamment rencontrer ce type d'écueil avec des images ou avec des formes de type forme libre...

Je te conseillerais volontiers de prendre le temps d'étudier les chapitres consacrés au variables et procédures et leur portée, dans un cours VBA. Tu ne sauras pas tout sur le sujet (mais il y a toujours des choses à apprendre...) mais cela te fournira une ossature sur laquelle ser grefferont plus rapidement les cas atypiques que tu rencontreras au fil de tes programmes.

Cordialement.

Bonjour,

Hello MFerrand, tu dis :

Tu peux utiliser l'option Explicit pour t'y contraindre... Pour ma part je n'aime pas utiliser cette option

Dans ce cas et dans un code assez long, il faut bien faire attention aux fautes de frappe car ça peut générer des résultats inattendus et donc des heures de recherche avant de s'apercevoir que le compilateur a créé une nouvelle variable issue de cette faute de frappe. Pour ma part, j'utilise systématiquement Option Explicit mais bien sûr, chacun programme à sa façon

Bonjour,

pour compléter ce qui vient d'être dit tu peux cocher dans les options VBE 'Déclaration obligatoire des variables. Option explicit se mettra sur tous les modules créés.

Et pour ta question tu peux aussi nommer la cellule et l'utiliser ainsi dans le code :

a=[NB_PERSONNES]

pas tout à fait équivalent car lue sur la feuille à chaque utilisation. A éviter dans une boucle de 10000 fois donc.

eric

Salut Theze !

Cela m'est bien sûr déjà arrivé ! Mais tout compte fait pas très souvent sur cet aspect et je n'ai pas eu à chercher longtemps... Je trouve insupportable le couinement de VBA dans ces cas-là d'un côté et d'autre part mon vieux fond anar me fait percevoir ce type d'instruction comme des chaînes, atteinte à ma liberté... C'est un peu tordu me diras-tu mais je ne prétendrai pas ne pas l'être... C'est un peu travailler sans filet tant que le risque ne dépasse pas un seuil où cela deviendrait suicidaire...

Ce qui m'arrive par contre plus fréquemment, c'est de louper des rectifications d'utilisation de variables de même type et toutes déclarées, bien sûr, genre : j'ai besoin de 3 variables en utilisation simultanée et chemin faisant je vois qu'il m'en faut en fait 4, j'en ajoute donc une, mais à ce moment je modifie l'utilisation de toutes pour rerépartir le travail en fonction de mes schémas mentaux ou inclinations (qui me permettent d'interpréter plus vite mon code...), j'opère donc quelques substitutions sur le code déjà écrit et... je loupe les corrections en certains endroits. Là, il arrive que le résultat soit tout à fait inattendu...

Bonne journée.