Discussion :

[Oparion]

Bonjour à toutes, à tous et au forum.

Aujourd'hui, j'aimerai discuter avec vous pour obtenir des avis et des conseils concernant la pérennisation d'un code VBA.

1 - Contexte

Je réalise actuellement une formation en alternance dans laquelle, lors de ma période en entreprise, je réalise des fichiers EXCEL à l'aide de macro VBA. Ce qui est ressorti lors de ma soutenance c'est : Comment allez-vous réussir à pérenniser vos codes, vos fichiers EXCEL, pour qu'ils soient durables mais aussi qu'ils puissent être repris.
Ma première réponse, a été : Je vais réaliser des commentaires sur chacune des lignes de mon code.
Mon jury m'a répondu que c'était une bonne démarche mais que ce n'était pas suffisant.

2 - Problématique

Comment pérenniser un fichier EXCEL comprenant des MACROS via VBA ?

- Commenter le code VBA
- Etablir un fichier WORD dans lequel il faudrait noter chacune des variables, à quoi elles correspondent, et les différentes formules mathématiques utilisées dans la MACRO.

Voici actuellement mes 2 pistes pour pérenniser un fichier EXCEL, je cherche donc des avis d'amateurs, d'intermédiaires et d'experts d'EXCEL et de VBAn pour me donner de nouvelles pistes sur ma problématique.

Cordialement !

[unparia]

Bonjour
Il y a un peu d'antinomie entre "pérenniser" et "reprendre" dans :

pérenniser vos codes, vos fichiers EXCEL, pour qu'ils soient durables mais aussi qu'ils puissent être repris

S'il s'agit de pérenniser (jusqu'à nouvelle version) la dernière retenue --->> on détermine des numéros de versions et on fait un modèle de la dernière "retenue" ou on l'utilise (au niveau utilisateur) en travaillant sur son "miroir".
(L'expression est importante)

EDIT :

Je réalise actuellement une formation

tu "réalises" ou tu "suis" (cette formation) ?

[Philippe Tulliez]

Bonjour,

tu "réalises" ou tu "suis" (cette formation) ?

[Pierre Fauconnier]

Salut.

Si tes utilisateurs doivent manger une pomme et que ton appli doit leur préparer la pomme, tu auras un seul bouton manger une pomme.

Mais toi, tu sais que pour qu'ils mangent la pomme, il faut la rincer, l'éplucher, ... Donc tu vas découper ton code en fonction de la responsabilitéde chaque fonction dans le traitement. La fonction de nettoyage doit rincer la pomme et l'essuyer, pas l'éplucher... Et la fonction Manger la pomme à la responsabilité de chaîner les actions qui permettront à l'utilisateur de la manger.

Ton code va donc avoir le look suivant et tu stockeras ces procédures dans le module Pomme:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
sub MangerLaPomme() ' Procédure appelée par clic sur le bouton
RincerLaPomme
EplucherLaPomme
OffirLaPomme
End Sub
 
Sub RincerLaPomme()
...
End Sub
 
sub EplucherLaPomme()
...
...
End Sub
 
Sub OffrirLaPomme()
...
...
End Sub

[Oparion]

@Jean-Philippe André :

Non du tout, je n'utilise pas d'UserForm, pour mon cas, je n'en vois pas l'utilité.
Même si ça fait plus joli, mon code est à 95% du tri, organisation et traitement de données.
Il n'y a donc rien à faire apparaître à l'utilisateur à part quelques Inputbox pour renommer les graphiques ou choses du genre.

@Pierre Fauconnier :

Bonjour Pierre, j'ai compris ta remarque mais je ne vois pas comment je peux appeler à l'aide d'un bouton un module... ?
D'après ton exemple ce serait :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
' Je place le programme nommé : "Manger une pomme" dans le Module 1 qui est renommé : Pomme
' Puis j'intègres les différents programmes : 
 
Sub Manger une pomme
Acheter une pomme
Rincer une pomme
Eplucher une pomme
End Sub
 
'JUSTE AU DESSUS, je ne vois pas comment je peux appeler mes différents Sub qui se trouvent EN DESSOUS, pour que "Sub Manger une pomme" réalise l'ensemble des étapes et donc que je relie un seul bouton à ce Sub là.
 
 
Sub Acheter une pomme
Code ..... 
End Sub
 
Sub Rincer une pomme
Code ..... 
End Sub
 
Sub Eplucher une pomme
Code ..... 
End Sub

[Invité]

Pour appeler un sub, il suffit d'utilise un Call

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
 
Sub Manger une pomme
Call Acheter une pomme
Call Rincer une pomme
Call Eplucher une pomme
End Sub
 
Sub Acheter une pomme
Code ..... 
End Sub
 
Sub Rincer une pomme
Code ..... 
End Sub
 
Sub Eplucher une pomme
Code ..... 
End Sub

[Oparion]

Bonjour unparia et merci de ta réponse.

Ce serait pour au cas où, quelqu'un voudrait reprendre mon fichier EXCEL et le modifier.
OU si un jour ce que j'ai fait sous fichier EXCEL passe sur un autre logiciel via un autre langage de programmation.

Je suis, je suis en cours si tu préfères
Ca change pas le fait que j'ai eu suivi 0 formations / cours sur le VBA.

[JahExodus]

Bonjour,

je ne suis pas sûr d'avoir bien compris ton problème, mais voila ce que je ferais en tant que débutant en VBA (je suis étudiant aussi):

Ce que je fais actuellement et ce que tu peux faire (je ne sais pas si ca répond a ton problème mais ca peut t'aider), c'est créer un framework de tes applications, ou des fonctions génériques qui seront réutilisable dans tes futures applications.
Par exemple en ce moment je dev une application qui utilise un framework, et ce framework gère la connexion a la BDD, la gestion des erreurs etc..
Ce qui me donne globalement un code plus propre et structuré, mais surtout un developpement plus rapide pour les applications futures.

Bonne journée

[Oparion]

Bonjour Philippe Tulliez,

Merci de ton commentaire

Bonjour JahExodus,

Aurais-tu un exemple de FrameWork que tu as réalisé ?
Je ne connais absolument pas, et après recherche, cela peut m'intéresser.
Mais je ne souhaite pas non plus passer le reste de ma période d'entreprise à réaliser un FrameWork.
Ce n'est pas du tout mon sujet principal ^^

[JahExodus]

Salut,

Alors je ne peux pas t'envoyer le code ou le fichier car c'est interne à mon entreprise et donc confidentiel mais si tu as des questions sur le principe de fonctionnement n'hésites pas.
Il s'agit en gros de modules de classes qui sont des outils, que je peux utiliser dans chacune des mes applications si besoin est

[Pierre Fauconnier]

Tu n'appelles pas le module. Tu appelles la fonction MangerLaPomme qui elle-même appelle les fonctions qui préparent le fruit dans un ordre logique.

L'intérêt est que tu peux concentrer tes tests sur chaque fonction spécifique. Par exemple, tu testes la fonction NettoyerLaPomme en lui passant différents arguments:

• Tu passes une pomme saine;
• Tu ne passes pas de pomme;
• Tu passes une pomme pourrie;
• Tu passes une poire;
• Tu passes deux pommes;
• Tu passes de la compote;
• ...

Et tu regardes comment cette "petite" fonction spécifique se comporte... Normalement, seul le fait de passer une pomme saine devrait te valoir un test spécifique. L'avantage est que si demain le processus de nettoyage d'une pomme doit être modifié, tu ne modifies que cette fonction puis tu refais ta batterie de tests pour être certain que les modifs dans cette fonction n'ont pas dégrader le processus général. Ta modification est donc circonscrite aux seules lignes de code concernées et suite aux tests, ton appli générale reste stable. C'est, en d'autres mots et de façon imagée, ce que te disait el_slapper.

Pour appeler un sub, il suffit d'utilise un Call [...]

Les Call ne sont pas nécessaires

[Pierre Fauconnier]

Salut.

Je suis assez d'accord avec Marc. Ca dépend fort du jury. Mais cela dépend aussi de ta façon de défendre ton "style" de code.

Tu parles de commenter chaque ligne de code. STOP. Ca ne sert à rien. J'ai eu un prof qui nous obligeait à commenter toutes nos fonctions avec une structure de commentaires très détaillée (Nom, explication de ce que fait la fonction, type, nom et explication de chaque paramètre, type de valeur de retour)... Pour moi, en tant que commentaire, cela ne sert à rien du tout. Ca peut au mieux servir à créer de la documentation en automatique.

Exemple

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
'''
' @Comment Lit un contact en DB sur base de son ID
' @Returns    Contact, objet contact contenant les informations récupérées
' @Param      ID, long, Clé primaire du contact en DB
'''
function ReadContact(ID as long) as Contact

A quoi sert le commentaire? A rien du tout, selon moi. Le nom de la fonction et de l'argument parlent d'eux-mêmes. Il n'y a aucune plus-value dans ces "commentaires". Les commentaires, les vrais, devraient être parcimonieusement utilisés pour expliquer le pourquoi d'un code un peu complexe...

Pour pérenniser du code VBA (je reprends des idées qui ont déjà été émises et j'ajoute les miennes, sans exhaustivité aucune):

• Ecrire des fonctions et des procédures qui n'ont qu'une seule responsabilité;
• Eviter les variables globales et les utiliser uniquement pour des variables d'environnement et d'application;
• Ecrire du code en réduisant, voire en annulant, la dépendance d'une fonction par rapport à une autre (complément de la règle précédente) et donc privilégier les paramètres de fonction aux variables globales;
• Typer systématiquement tes variables;
• Supprimer le hardcoding (écriture de données métier directement dans le code);
• Etre systématique dans ta façon de coder;
• Etre systématique dans ta façon de nommer;
• ...

[Jean-Philippe André]

Salut,

je peux completer ce qu'a dit Pierre en te proposant ceci :
- atomiser le code en modules de telle sorte que le code que chaque module contient un code qui ne depend pas des autres modules
- faire en sorte que ta nomenclature de nommage soit propre sans etre trop lourde pour le developpement de nouvelles fonctionnalites
- t'affranchir des variables applicatives (Access.Application, Outlook.Application, etc.) et leur preferer un type Object avec un CreateObject()/GetObject() en consequence pour ne plus te sourcier des multiples versions Office qui tournent sur les postes utilisateurs.
- passer par des fichiers .ini pour stocker des variables qui peuvent evoluer (donc non hardcodees dans le code, mais lues a la volee)

[Oparion]

Wahouu je suis vraiment content de toutes ces réponses !
Je vois et reconnais même des grosses têtes du forum, ça fait plaisir ^^

Alors tout d'abord, Bonjour Marc-L, Pierre Fauconnier et Jean-Philippe André et merci de vos réponses.

@Marc-L :

Actuellement le jury n'a aucune influence sur ce que je dois produire et/ou faire et je ne vais pas leur en rendre compte étant donné que ma deuxième soutenance sera porté sur un sujet bien loin du code VBA.
Mais ! Lors de ma première soutenance, il a été évoqué cette "pérennisation du code", ce qui a mis la puce à l'oreille de mon tuteur et il c'est fait la réflexion suivante :
C'est vrai qu'il faudrait pouvoir pérenniser les codes VBA que tu créés. Ils nous sont très utile, mais Demain tu ne seras plus là et mon équipe composé de 4 techniciens (âgés de 45 ans minimum), n'ont pas les connaissances requises pour pouvoir l'exploiter. Il faut donc trouver un moyen pour que ton "savoir" soit transmis à un futur nouvel alternant si il y a besoin de retoucher au fichier.

Du coup, à l'heure actuelle, mon fichier fonctionne, le code est bon, pas perfectionné, mais il fonctionne.
Mon objectif est de laisser une trace permettant à mon éventuel remplaçant de toucher le code si besoin...


@Pierre Fauconnier :

Je comprend tout à fait ce que tu me dis. Mais est-ce que commenter mon code comme cela pourra permettre à un débutant de se l'approprier et donc de pouvoir le modifier ? Je pense que oui, mais après tout donnes moi ton avis.
Suite à ton message, j'ai différentes questions :

- Qu'est-ce qu'une fonction ou procédure à une seule responsabilité ?
- Qu'est-ce qu'une variable d'environnement et d'applications ?
- Qu'est-ce que le hardcoding ?
- Qu'entends-tu par systématique ?

Et oui, tu l'as remarqué, je n'ai presque rien compris


@Jean-Philippe André :

Lorsque tu me dis :

- "atomiser le code en modules" => Tu entends : "Séparer le code en fonction de chaque petite action qu'il réalise" ? Du style : A - Prendre les données puis [Code] puis B - Traiter les données puis [Code] puis C - Créer un graphique puis [Code] etc.
- Ma nomenclature de constante et de variable est... Dégoûtante je pense.
- Les variables applicatives je pense ne pas en avoir.
- QU'est-ce qu'un fichier .ini


Suite à ce message je vais mettre une partie de mon code, enfin 1 de mes 2 gros codes. S'il vous plaît, soyez tolérant sur ce que vous allez voir.
C'est le travail de plusieurs semaines en partant de 0 avec le peu de connaissance que j'ai.
Si vous avez des remarques / suggestions sur comment commenter / expliquer / pérenniser ce code, alors je suis preneur !

Cordialement
Oparion

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
Sub Création_des_Graphiques()
 
Dim Lig     As Long
Dim NumLig  As Long
 
Dim Lig2     As Long
Dim NumLig2  As Long
 
Dim Lig3     As Long
Dim NumLig3  As Long
 
Dim Col     As Long
Dim NumCol  As Long
 
Dim Col2     As Long
Dim NumCol2  As Long
 
Dim Diff1 As Double
Dim Diff2 As Double
 
Dim a As Long
Dim b As Long
Dim c As Long
Dim d As Long
 
Dim r As Integer
Dim Cpt As Integer
Dim CptSh As Integer
 
'###### CREATION DE L'ONGLET : DONNEES D'EXPERIMENTATIONS ######
 
    Sheets.Add After:=Sheets(Sheets.Count - 2)
    ActiveSheet.Name = ("Données d'expérimentations")
 
'###### DEPLACER LES DONNEES DE L'ONGLET DONNEES BRUTES A ANALYSE DES DONNEES ######
 
    Sheets("Données Brutes").Select
    Sheets("Données Brutes").Copy Before:=Sheets("Graphique")
    Sheets("Données Brutes (2)").Select
    Sheets("Données Brutes (2)").Name = "Analyse des données"
 
'###### SEPARER LES DONNEES D'EXPERIMENTATIONS ET RELEVE DE MESURES ######
 
 
Sheets("Données d'expérimentations").Activate
Cells.Select
Selection.ClearContents
 
Sheets("Analyse des données").Activate
NumLig = 0
Lig = 1
    While Cells(Lig, 1).Value <> "Balayage"
      NumLig = NumLig + 1
      Lig = Lig + 1
    Wend
range(Cells(1, 1), Cells(NumLig, 50)).Copy
Sheets("Données d'expérimentations").Activate
range("A1").PasteSpecial
Sheets("Analyse des données").Activate
range(Cells(1, 1), Cells(NumLig, 50)).Delete
 
Sheets("Données d'expérimentations").Activate
    With Selection
        .HorizontalAlignment = xlCenter
        .VerticalAlignment = xlBottom
        .WrapText = False
        .Orientation = 0
        .AddIndent = False
        .IndentLevel = 0
        .ShrinkToFit = False
        .ReadingOrder = xlContext
        .MergeCells = False
    End With
    Selection.Borders(xlDiagonalDown).LineStyle = xlNone
    Selection.Borders(xlDiagonalUp).LineStyle = xlNone
    With Selection.Borders(xlEdgeLeft)
        .LineStyle = xlContinuous
        .ColorIndex = 0
        .TintAndShade = 0
        .Weight = xlThin
    End With
    With Selection.Borders(xlEdgeTop)
        .LineStyle = xlContinuous
        .ColorIndex = 0
        .TintAndShade = 0
        .Weight = xlThin
    End With
    With Selection.Borders(xlEdgeBottom)
        .LineStyle = xlContinuous
        .ColorIndex = 0
        .TintAndShade = 0
        .Weight = xlThin
    End With
    With Selection.Borders(xlEdgeRight)
        .LineStyle = xlContinuous
        .ColorIndex = 0
        .TintAndShade = 0
        .Weight = xlThin
    End With
    With Selection.Borders(xlInsideVertical)
        .LineStyle = xlContinuous
        .ColorIndex = 0
        .TintAndShade = 0
        .Weight = xlThin
    End With
    With Selection.Borders(xlInsideHorizontal)
        .LineStyle = xlContinuous
        .ColorIndex = 0
        .TintAndShade = 0
        .Weight = xlThin
    End With
    Columns("A:A").EntireColumn.AutoFit
    Columns("B:B").EntireColumn.AutoFit
    Columns("C:C").EntireColumn.AutoFit
    Columns("D:D").EntireColumn.AutoFit
    Columns("E:E").EntireColumn.AutoFit
    Columns("F:F").EntireColumn.AutoFit
    Columns("G:G").EntireColumn.AutoFit
    Columns("H:H").EntireColumn.AutoFit
    Columns("I:I").EntireColumn.AutoFit
    Columns("J:J").EntireColumn.AutoFit
    Columns("K:K").EntireColumn.AutoFit
    Columns("L:L").EntireColumn.AutoFit
    Columns("M:M").EntireColumn.AutoFit
    Columns("N:N").EntireColumn.AutoFit
    Columns("O:O").EntireColumn.AutoFit
    Columns("Q:Q").EntireColumn.AutoFit
    Columns("R:R").EntireColumn.AutoFit
    Columns("S:S").EntireColumn.AutoFit
    Columns("T:T").EntireColumn.AutoFit
 
 
Sheets("Analyse des données").Activate
 
'##################### SUPPRESSION DES COLONNES INUTILES #####################
 
For a = 5 To 20
    range(Cells(1, a), Cells(65530, a)).Select
    Selection.Delete Shift:=xlToLeft
Next
 
'##################### CALCUL NOMBRE DE LIGNES ET COLONNES #####################
Col = 1
While Cells(2, Col).Value <> ""
    NumCol = NumCol + 1
    Col = Col + 1
Wend
 
Lig2 = 1
While Cells(Lig2, 1).Value <> ""
    NumLig2 = NumLig2 + 1
    Lig2 = Lig2 + 1
Wend
 
'##################### REMISE A ZERO DES TITRES DES COLONNES #####################
 
range("A1:ZZ1").Select
Selection.ClearContents
range("A1") = "Balayage"
range("B1") = "Date"
range("C1") = "Heure"
NumCapteur = 101
For b = 4 To NumCol
    Cells(1, b) = NumCapteur
    NumCapteur = NumCapteur + 1
Next
 
'##################### MISE EN FORME #####################
 
range(Cells(1, 1), Cells(NumLig2, NumCol)).Select
 
    With Selection
        .HorizontalAlignment = xlCenter
        .VerticalAlignment = xlBottom
        .WrapText = False
        .Orientation = 0
        .AddIndent = False
        .IndentLevel = 0
        .ShrinkToFit = False
        .ReadingOrder = xlContext
        .MergeCells = False
    End With
    Selection.Borders(xlDiagonalDown).LineStyle = xlNone
    Selection.Borders(xlDiagonalUp).LineStyle = xlNone
    With Selection.Borders(xlEdgeLeft)
        .LineStyle = xlContinuous
        .ColorIndex = 0
        .TintAndShade = 0
        .Weight = xlThin
    End With
    With Selection.Borders(xlEdgeTop)
        .LineStyle = xlContinuous
        .ColorIndex = 0
        .TintAndShade = 0
        .Weight = xlThin
    End With
    With Selection.Borders(xlEdgeBottom)
        .LineStyle = xlContinuous
        .ColorIndex = 0
        .TintAndShade = 0
        .Weight = xlThin
    End With
    With Selection.Borders(xlEdgeRight)
        .LineStyle = xlContinuous
        .ColorIndex = 0
        .TintAndShade = 0
        .Weight = xlThin
    End With
    With Selection.Borders(xlInsideVertical)
        .LineStyle = xlContinuous
        .ColorIndex = 0
        .TintAndShade = 0
        .Weight = xlThin
    End With
    With Selection.Borders(xlInsideHorizontal)
        .LineStyle = xlContinuous
        .ColorIndex = 0
        .TintAndShade = 0
        .Weight = xlThin
    End With
 
'######### CREATION DE L'ONGLET : ANALYSE DES DONNEES ET DE LA COLONNE TEMPS(H) #########
 
Sheets("Analyse des données").Activate
    Columns("D:D").EntireColumn.Select
    Selection.Insert Shift:=xlToRight, CopyOrigin:=xlFormatFromLeftOrAbove
    ActiveCell.Select
 
'########### TITRE ET FORMULE COLONNE TEMPS(H) ###########
 
range("D1") = "Temps (h)"
 
range("D2").FormulaLocal = "=GAUCHE(C2;8)"
range("D2").Select
Selection.AutoFill Destination:=ActiveCell.range(Cells(1, 1), Cells(NumLig2 - 1, 1))
ActiveCell.range(Cells(1, 1), Cells(NumLig2 - 1, 1)).Select
range("D2").Select
 
'######### CREATION DE LA COLONNE TEMPS REFERENCE (s) #########
 
Sheets("Analyse des données").Activate
    Columns("E:E").EntireColumn.Select
    Selection.Insert Shift:=xlToRight, CopyOrigin:=xlFormatFromLeftOrAbove
    ActiveCell.Select
 
'########## TITRE ET FORMULE COLONNE TEMPS REFERENCE (s) #########
 
range("E1") = "Temps référence (s)"
 
range("E2").FormulaLocal = "=ARRONDI((D2-$D$2)*(24*60*60);0)"
range("E3").FormulaLocal = "=ARRONDI((D3-$D$2)*(24*60*60);0)"
range("E4").FormulaLocal = "=ARRONDI((D4-$D$2)*(24*60*60);0)"
 
Diff1 = Cells(3, 5).Value - Cells(2, 5).Value
Diff2 = Cells(4, 5).Value - Cells(3, 5).Value
 
If Diff1 = Diff2 Then
    c = Cells(3, 5).Value
End If
 
For d = 5 To NumLig2
    Cells(d, 5) = Cells(d - 1, 5) + c
Next
 
Col2 = 1
While Cells(2, Col2).Value <> ""
    NumCol2 = NumCol2 + 1
    Col2 = Col2 + 1
Wend
 
Lig3 = 1
While Cells(Lig3, 1).Value <> ""
    NumLig3 = NumLig3 + 1
    Lig3 = Lig3 + 1
Wend
 
'####### REMPLACE LES POINTS PAR DES VIRGULES DANS LES COLONNES DE MESURES (A PARTIR DE F) ######
 
Sheets("Analyse des données").range(Cells(2, 6), Cells(NumLig3, NumCol2)).Replace What:=".", Replacement:=".", LookAt:=xlPart, SearchOrder _
:=xlByRows, MatchCase:=False
 
'##################### CREATION DES GRAPHIQUES #####################
 
NumCol2 = NumCol2 - 5
Worksheets("Graphique").Visible = 1
 
For i = 1 To NumCol2
 
 
    Sheets.Add After:=Sheets(Sheets.Count)
    ActiveSheet.Name = ("Graphique " & i)
    s = Sheets.Count - 1
 
        For E = 1 To s
            Sheets("Graphique " & i).Select
            Sheets("Graphique " & i).Move After:=Sheets(E)
        Next E
 
    Sheets("Analyse des données").Select
    range(Cells(2, 5 + i), Cells(NumLig3, 5 + i)).Select
    ActiveSheet.Shapes.AddChart.Select
    ActiveChart.ChartType = xlXYScatter
    ActiveChart.PlotArea.Select
 
    ActiveChart.SeriesCollection(1).Name = "='Analyse des données'!$" & ColLetter(Cells(1, 5 + i)) & "$1"
    ActiveChart.SeriesCollection(1).XValues = "='Analyse des données'!$E$2:$E$" & NumLig3
    ActiveChart.SeriesCollection(1).Values = "='Analyse des données'!$" & ColLetter(Cells(1, 5 + i)) & "$2:$" & ColLetter(Cells(1, 5 + i)) & "$" & NumLig3
 
        With ActiveChart
            .HasTitle = False
            .Axes(xlCategory, xlPrimary).HasTitle = False
            .Axes(xlValue, xlPrimary).HasTitle = False
        End With
 
 
    ActiveChart.Parent.Cut
    Sheets("Graphique " & i).Select
    range("C6").Select
    ActiveSheet.Paste
    Sheets("Analyse des données").Select
 
'##################### AGRANDISSEMENT DES GRAPHIQUES #####################
 
    Sheets("Graphique " & i).Select
    ActiveSheet.ChartObjects("Graphique 1").Activate
    ActiveSheet.Shapes("Graphique 1").IncrementLeft -87.75
    ActiveSheet.Shapes("Graphique 1").IncrementTop -57
    ActiveSheet.ChartObjects("Graphique 1").Activate
    ActiveSheet.Shapes("Graphique 1").ScaleWidth 2.1270833333, msoFalse, _
        msoScaleFromTopLeft
    ActiveSheet.Shapes("Graphique 1").ScaleHeight 1.9444444444, msoFalse, _
        msoScaleFromTopLeft
 
Next i
Worksheets("Graphique").Visible = 0
 
'##################### RENOMMER LES AXES DES GRAPHIQUES #####################
 
f = InputBox("Quel est le titre de l'axe des abscisses ?")
g = InputBox("Quel est le titre de l'axe des ordonnées ?")
 
For i = 1 To NumCol2
 
Sheets("Graphique " & i).Select
 
    ActiveSheet.ChartObjects("Graphique 1").Activate
    ActiveChart.ApplyLayout (1)
    ActiveSheet.ChartObjects("Graphique 1").Activate
    ActiveChart.Axes(xlCategory).AxisTitle.Select
    ActiveChart.Axes(xlValue, xlPrimary).AxisTitle.Text = f
    Selection.Format.TextFrame2.TextRange.Characters.Text = f
    With Selection.Format.TextFrame2.TextRange.ParagraphFormat
        .TextDirection = msoTextDirectionLeftToRight
        .Alignment = msoAlignCenter
    End With
    With Selection.Format.TextFrame2.TextRange.Font
        .BaselineOffset = 0
        .Bold = msoTrue
        .NameComplexScript = "+mn-cs"
        .NameFarEast = "+mn-ea"
        .Fill.Visible = msoTrue
        .Fill.ForeColor.RGB = RGB(0, 0, 0)
        .Fill.Transparency = 0
        .Fill.Solid
        .Size = 10
        .Italic = msoFalse
        .Kerning = 12
        .Name = "+mn-lt"
        .UnderlineStyle = msoNoUnderline
        .Strike = msoNoStrike
    End With
    ActiveChart.Axes(xlValue).AxisTitle.Select
    ActiveChart.Axes(xlValue, xlPrimary).AxisTitle.Text = g
    Selection.Format.TextFrame2.TextRange.Characters.Text = g
    With Selection.Format.TextFrame2.TextRange.ParagraphFormat
        .TextDirection = msoTextDirectionLeftToRight
        .Alignment = msoAlignCenter
    End With
    With Selection.Format.TextFrame2.TextRange.Font
        .BaselineOffset = 0
        .Bold = msoTrue
        .NameComplexScript = "+mn-cs"
        .NameFarEast = "+mn-ea"
        .Fill.Visible = msoTrue
        .Fill.ForeColor.RGB = RGB(0, 0, 0)
        .Fill.Transparency = 0
        .Fill.Solid
        .Size = 10
        .Italic = msoFalse
        .Kerning = 12
        .Name = "+mn-lt"
        .UnderlineStyle = msoNoUnderline
        .Strike = msoNoStrike
    End With
    ActiveChart.ChartArea.Select
    ActiveChart.ChartTitle.Select
    ActiveChart.ChartTitle.Text = "Canal 10" & i
    Selection.Format.TextFrame2.TextRange.Characters.Text = "Canal 10" & i
    With Selection.Format.TextFrame2.TextRange.ParagraphFormat
        .TextDirection = msoTextDirectionLeftToRight
        .Alignment = msoAlignCenter
    End With
    With Selection.Format.TextFrame2.TextRange.Font
        .BaselineOffset = 0
        .Bold = msoTrue
        .NameComplexScript = "+mn-cs"
        .NameFarEast = "+mn-ea"
        .Fill.Visible = msoTrue
        .Fill.ForeColor.RGB = RGB(0, 0, 0)
        .Fill.Transparency = 0
        .Fill.Solid
        .Size = 18
        .Italic = msoFalse
        .Kerning = 12
        .Name = "+mn-lt"
        .UnderlineStyle = msoNoUnderline
        .Strike = msoNoStrike
    End With
    ActiveChart.ChartArea.Select
 
Next i
 
'##################### CREATION DE L'ONGLET DONNEES CIBLEES #####################
 
x = InputBox("Combien avez-vous de palier(s) d'étalonnage(s) ?")
 
For i = 1 To x
    Sheets.Add After:=Sheets(Sheets.Count)
    Sheets(Sheets.Count).Name = "Données ciblées " & i
    Sheets("Analyse des données").Select
    Rows("1:1").Select
    Selection.Copy
    Sheets("Données ciblées " & i).Select
    ActiveSheet.Paste
Next
 
End Sub

[Jean-Philippe André]

Je laisserai mes camarades repondre quant a leurs parties

@Jean-Philippe André :

Lorsque tu me dis :

- "atomiser le code en modules" => Tu entends : "Séparer le code en fonction de chaque petite action qu'il réalise" ? Du style : A - Prendre les données puis [Code] puis B - Traiter les données puis [Code] puis C - Créer un graphique puis [Code] etc.
- Ma nomenclature de constante et de variable est... Dégoûtante je pense.
- Les variables applicatives je pense ne pas en avoir.
- QU'est-ce qu'un fichier .ini

Si par exemple tu as une application qui :
- genere un graphique
- enregistre une plage de donnees au format pdf
- envoie un mail avec un document en PJ

=> 3 modules = mChart pour les graphes, mPDF pour les exports sous format PDF, mMail pour tout ce qui aura trait aux mails

Pour ta nomenclature, un peu de lecture : http://argyronet.developpez.com/office/vba/convention/

Les fichiers ini https://vb.developpez.com/faq/?page=Systeme#ini

[Pierre Fauconnier]

Comme je l'ai dit, je pense qu'il ne sert à rien de commenter ton code comme je l'ai illustré, sauf si tu souhaites générer une documentation en automatique. Il me semble que bien nommer ses fonctions et ses variables est plus important que de les nommer n'importe comment puis de les commenter pour les expliquer.

Fonction à une seule responsabilité: Une fonction, ça sert à une et une seule chose. Exemple: récupération des données d'un contact dans une feuille de calcul et affichage dans un userform pour modification, vérification puis transfert dans une feuille de calcul. Tu verras trop souvent tout le code dans le userform (initialize et bouton valider). C'est une erreur. Crée plutôt:
une fonction dont la seule responsabilité est de te dire si c'est ok ou pas;
Une fonction qui transfère les données dans un objet Contact dont tu auras créé la classe;
Une fonction qui transfère les données d'un contact dans les contrôles du userform;
un bouton validate qui appelle la fonction de vérification puis, si c'est ok, la fonction de chargement de l'objet Contact puis qui ferme le formulaire (aucun transfert en DB à ce stade);
une fonction, dans un module que j'appelle souvent DAL (Data Access Layer), qui transfère un objet Contact en DB (dans la feuille);
une fonction, dans ce module DAL, qui lit un contact en DB et charge l'objet Contact au départ de la feuille;

Le code qui gère tout cela est situé hors userform et :
charge le contact via la DAL;
charge le userform;
passe l'objet Contact au userform (propriété perso du userform qui appellera la fonction de chargement des contrôles);
Affichage du userform;
Après fermeture par le bouton valider, transfert des données dans la feuille via la fonction de la DAL.

Dans cet exemple, chaque fonction ne fait qu'une seule chose: Charger un objet, transfert en DB ou de la DB, vérification, ... C'est cela n'avoir qu'une responsabilité.

Les variables (et constantes) d'environnement sont des données dont tu as besoin un peu partout dans ton code. Ce sont en général des variables globales ou publiques qui vont créer un couplage fort entre tes fonctions, ce qui rend ton code plus fragile.

Hardcoder, c'est mettre des données en dur dans le code. Avec Excel, ll est simple de stocker la valeur dans une cellule nommée et d'utiliser cette valeur.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Path = "c:\Données\Fichier.xlsx"

C'est du hardcoding. Il vaut mieux mettre le nom du fichier dans une cellule nommée Path et utiliser

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

path = range("Path").Value

Etre systématique: Faire toujours la même chose. Si, pour un userform, tu
charges le UF;
le configures;
récupères les données après fermeture.

Alors, procède ainsi pour tous tes userforms.

Si tu nommes une fonction ReadContact, alors nomme une fonction ReadCity et pas GetCity, ... Si pour un objet, tu nommes son identifiant ID, n'appelle pas l'identifiant d'un autre objet Key ou Nummer, appelle-le ID, ...

Et n'hésite jamais à créer des modules pour regrouper tes fonctions.

[Oparion]

@Jean-Philippe André :

D'accord, avec ces exemples je comprend où tu voulais en venir dans l'expression "atomiser le code en module".
C'est vrai que moi, je fais tout l'inverse... J'aime quand c'est tout dans le même module ! Ca m'évite de naviguer dans différent module, mais ça manque clairement de clarté etc...
Je vais appliquer ce que tu viens de me dire !

@Pierre Fauconnier :

Je n'utilise aucun UserForm dans mon fichier Excel, peut-être que cela va te réorienter sur d'autres possibilités de réponses ?

Au niveau des variables, j'ai compris que tu attribues une variable à une tâche.

Je n'ai pas de liaison ou de chemin comme celui que tu m'as présenté.
Mais j'ai des Range... est-ce que ça en fait partie ?

Concernant être systématique, je ne pratique pas sur de UserForm mais je pense l'appliquer sur mon code. Essayer de structurer mieux mon programme.

[clementmarcotte]

Bonjour,

Comme je l'ai dit, je pense qu'il ne sert à rien de commenter ton code comme je l'ai illustré, sauf si tu souhaites générer une documentation en automatique. Il me semble que bien nommer ses fonctions et ses variables est plus important que de les nommer n'importe comment puis de les commenter pour les expliquer.

L'éternel débat, ou, comment dire, l'évolution du commentaire, du codage et de la programmation en général.

Cela ne nous rajeunit pas personne, mais je me souviens qu'avec les variables à 6 caractères du Fortran, ou même à deux caractères des premiers BASIC; l'obligation de commenter en détail les noms de variables, prenait tout son sens. Et l'omniprésence du GOTO, n'ajoutait rien à la clarté du code, et nécessitait des commentaires.

Je suis bien d'accord avec le fait que VBA, autorise, et même oblige, de morceler le code, et la possibilité d'allonger les noms de variables, rendent les commentaires beaucoup moins nécessaires.

Malgré. tout, en tenant compte de la question de unparia, que je salue au passage, il me semble que l'on ne peut pas échapper aux commentaires, surtout pour les trucs et astuces personnels, les passes géniales, ou méconnus, l'algorithme utilisé, et pourquoi.

Je dirais aussi une explication succincte du but d'une procédure. Et cela me semble aussi un bonne idée de rappeler pourquoi on rappelle tel sous-programme, surtout quand le nom du sous-programme n'est pas aussi explicite qu'il le faudrait.

[unparia]

De bon matin, donc, pour que l'on comprenne moins mal tout le sens de ma question antérieure.
S'il s'agit de pérenniser non le CODE, mais l'APPLICATION dans sa totalité, il en va comme il en va dans de nombreux autres domaines : on ne protège pas, on ne pérennise pas, on ne modifie pas, etc ... ce qui n'est pas établi. La 1ère des conditions à réunir, par exemple, pour divorcer est ... d'être marié.


---->> nécessité n° 1, donc : --->>>

- savoir au moins à quelles spécifications fonctionnelles (à ne pas confondre, à ce niveau, avec les spécifications techniques) correspond l'appli.
Une appli dont on ne connait pas avec précision les tenants et aboutissants est une appli qui finit généralement aux oubliettes.
Ces spécifications fonctionnelles sont en général consignées sur un cahier des charges clair, précis et parfaitement rédigé (niveau M.O.A, donc)

Ce n'est là que la toute première nécessité.... (car la liste va devenir très longue, vous verrez ...)

[Oparion]

@el_slapper :

Concernant les test unitaires, ce que j'ai compris c'est qu'il faut venir tester les fonctions une à une et vérifier qu'elles fonctionnent bien toutes. Mais si ma macro globale fonctionne c'est que toutes les fonctions présentes fonctionnent... ? Peut-être que je me trompe.

@unparia :

Aucune question n'est idiote, sinon je ne serai pas là
Tu dis : Je fais personnellement un distinguo important entre CODE et APPLICATION.
Pour ma part, je ne vois pas la différence.

Pour nous permettre de nous aiguiller, voici les grandes étapes que réalise mon fichier :
1 - L'opérateur vient coller une série de données dans un onglet.
2 - Il clique sur le premier bouton qui vient :
2a - Séparer les données de l'expérimentations et les mesures
2b - Trier les mesures
2c - Réaliser les graphiques avec un nombre de graphique équivalent au nombre de sondes
2d - Créer un nombre d'onglet égal au nombre de sondes
3 - Il clique sur un deuxième bouton qui vient :
3a - Créer de nouveaux graphiques avec des tolérances, moyenne, consigne.
4 - Fin du programme.

Ce qui est à pérenniser c'est le code (je pense) faire qu'il soit explicite et qu'il puisse être repris par quelqu'un d'autre.
Ce fichier Excel sera utilisé par le service métrologie de mon entreprise, pour le moment il n'est pas étendu à d'autres services ou autre entités du groupe, il sera donc utilisé par 2 - 3 techniciens métrologues pour la vérification d'étuves, fours, bâtis...
Il n'y a pas de cahier des charges, de consignes, rien de rédigé. C'est moi qui ai pris l'initiative de ce fichier pour améliorer les PV (Procès Verbaux) lors de vérifications d'étuves, fours, bâtis.


Si je n'ai pas répondu à ta question, n'hésite pas de me demander...


@clementmarcotte :

Tout d'abord Bonjour clementmarcotte, bienvenue sur ce fil de discussion et merci de ta réponse.
D'après ce que tu as dis et des réponses des autres contributeurs, voici ce que j'en ressort :

1 - Séparer le gros code en plusieurs modules
2 - Rédiger une partie procédure expliquant ce que réalise le code du module
3 - Ne pas tout commenter, mais seulement les parties intéressantes : astuces, algorithme, formule mathématique.