Répartition et présentation d'un code (formalisme, conventions vb)

Soyez le premier à donner votre avis sur cette source.

Snippet vu 6 275 fois - Téléchargée 43 fois

Contenu du snippet

Liste et exemples des conventions d'écriture du code en VB. Ces conventions sont nécessaire si on veux que sa source soit compréhensible. Il faut eviter à tout prix les "pavé de ligne de code" où il est difficile de trouver kifékoi.

Niveau requis : qqun qui souhaite rendre public un code source (programmeur ou non)

Objectif : réaliser des code bien présenté et ordonnés, ce qui optimise souvent la vitesse et la compatibilité, et améliore la portabilité - et sa compréhension.

CONCEPT 1 : Niveau de code

Ce qui est appelé "niveau de code" représente la position du code exécuté par rapport à l'utilisateur.
On en distingue 3 :
- le code noyau
- le code e/s noyau-interface
- le code interface

(ps: rien à voir avec les niveaux de vbfrance)

Principe : on souhaite réaliser une opération. L'opération en elle-même se traduit par un algorithme. Pour utiliser cette algorithme, l'utilisateur doit entrer un ou des paramètres. Il faut donc un code pour gérer l'entrée de ces paramètres, un code pour tester la validité des paramètres ou faire des conversions (utilisé pour éviter les plantages), et enfin le code de l'algorithme faisant l'opération souhaité. Ces trois codes sont souvent incluent dans le même sub. Il convient alors de les séparer dans 3 subs distinct.

Méthode : distinguer les 3 niveaux de code dans un sub donné, ou dans votre représentation mémoire de votre programme, et en faire 3 subs qui s'exécuteront "en cascade".

Exemple : en vb, un programme reçois une chaine de caractères, et la renvoie dans l'ordre inversé de ses caractère :
(voir zone de code)

Le code noyau réalise l'opération d'inversement de l'ordre des caractères,
Le code d'e/s vérifie qu'il n'y ai pas d'erreur pouvant faire planter le programme (cas d'une chaine vide) ou s'il n'y a pas lieu de la retourner (chaine de longueur 1)
Le code d'interface s'occupe de récupérer la chaine de caractères à inverser et demande au code e/s de l'inverser, ou alors annule l'opération si l'utilisateur annule sa demande ("2")

Pourquoi séparer en 3 fonctions distinctes un code qui tiendrai dans un seul sub?
- Réutilisation du noyau : plutôt que de réécrire la fonction chaque fois que vous en avez besoin, vous ne l'appelez qu'une fois.
- Economie de code : dans le cas où le noyau est appelé par l'utilisateur, il faut procéder à un test de validité (code e/s), mais si le code noyau est appelé par un autre code noyau, il est alors inutile de faire des tests de validité (surtout s'ils ont été déjà fait par le code e/s de cet autre code noyau).

Bilan : économie d'écriture de code et de lignes de code dans le programme, vitesse d'éxecution amélioré, fonctionnalités réutilisable.
Il est fortement recommandé de placer tout les subs de noyau dans un module de votre programme (fichier .bas), qui sera ainsi la "bibliothèque de fonctions universelles". Elle pourra être réutilisé à la demande, et dans d'autres projets.

CONCEPT 2 : Lisibilité

La lisibilité d'un code, c'est simplement la disposition des lignes de façon séparer les blocs fonctionnels. Par bloc fonctionnel, il y a par exemple :
- les tests vrai/faux
- les boucles
- les sélections

Cela n'apporte rien à la vitesse d'exécution du code, mais en simplifie grandement la compréhension. Ainsi, il est plus facile de déboguer, qui dans ce cas aide à la vitesse d'exécution du code...

Exemple : opération conditionnelle : si le signe est positif, on fait un sinus, si le signe est négatif, on fait une boucle de cosinus ... (aucun interêt, sauf pour l'exemple)
(voir zone de code)

Ainsi on voix immédiatement que la ligne Trigo = Trigo + Cos(i) n'est exécuter que si le signe est négatif. On sais que le signe est négatif s'il y a eu 2 tests. Etc...
Même si du point de vue machine, le résultat est le même, pour un autre utilisateur ce code est beaucoup plus facile à comprendre présenté de cette façon.

L'autre partie dans la lisibilité, est dans le nom des variables : une variable peut avoir n'importe quelle noms, si possible se rapprochant de sa fonction (cnt, cmpt, ... pour une variable de compteur...) etc, etc...
Une constante aura un nom tout en majuscule, pour qu'elle se distingue rapidement dans le code. (const PI = 3.1415926 au lieu de const pi =.... )
D'une façon générale pour les variables ou constantes, on évite d'utiliser un nom anonyme pour simplifié la lisibilité.

Pensez également à identer le code : la touche Tabulation permet de rapidement espacer le code par rapport à la marge de gauche. Il s'agit de hiérarchiser le code : plus la ligne est "primordiale", plus elle est à gauche.
Vous pouvez sélectionner plusieurs lignes de code et les tabuler simultanément
Utiliser la combinaison Maj+Tab pour supprimer des tabulations excessive.

Bref, AEREZ votre code!

CONCEPT 3 : Les annotations et commentaires.

Expliquer le fonctionnement du code permet à n'importe qui de comprendre ce que vous vouliez faire. A n'importe qui, donc à vous aussi! En effet, si vous oubliez ce code quelques mois et que soudainement vous voulez le réutiliser, vous ne perderez pas de temps à reconstruire le mécanisme de votre algorithme.

Il n'y a aucun avantage pour le code, mais un grand avantage pour le programmeur.

Dans quels cas placer un commentaire ?
- devant chaque déclaration de variables, pour savoir à quoi elles vont servir
- avant les tests, pour savoir ce qui est testé dans un contexte global (savoir ce que ce test apporte comme infos au programme)
- devant une ligne conditionnelle (if ... then) dans un contexte global (contexte global? Exemple : if len(app.path) = 3 then 'si la longueur de app.path est égal à 3 < c'est un contexte local. If len(app.path) = 3 then 'si le chemin d'accès au programme n'a que 3 caractères, c'est qu'il est dans la racine, alors... < contexte global )
- Dans chaque sub ou function, l'objectif de la fonction codé, ainsi que les paramètres en entrée et en sortie
- Devant chaque boucle (for next, do loop)
- Partout où le code n'est pas explicite de lui-même

Exemple : reprenons le code noyau inversant l'ordre des caractères, en y ajoutant les commentaires
(voir zone de code)

Ce code est simple, mais pour une personne ne connaissant pas la fonction Mid(), elle en comprendra tout de suite la fonctionnalité.


CONCEPT 4 : (merci pour le commentaire)

Vous utilisez beaucoup de variables ? Il et nécessaire de savoir de quel type est la variable tout au long du code. On utilise alors l'astuce de mettre une lettre minuscule au début du nom de la variable, cette lettre indiquant le type :
- b pour Boolean
- i pour Integer
- l pour Long
- s pour String
- r pout les réel (virgule flottante : Single et Double)
etc ...

Néanmoins ce concept est variable, parfois équivoque, car on peut également utiliser :
- b pour Boolean, b pour Byte
- s pour Single, s pour String
- d pour Double

Rappel : terminaison des variables non déclaré :
Interger : %
Long : &
Single : !
Double : #
String : $
Array (tableau) : ()

Source / Exemple :


'CONCEPT 1 : Exemple
'Le code noyau est celui-ci :
Function RetourneC(Origine As String) As String
Dim i as Long

  RetourneC = ""

  For i = Len(Origine) to 1 Step -1
    RetourneC = RetourneC & Mid(Origine,i,1)
  Next i

End Function

'Le code e/s est celui-ci
Function Inverse(LaChaine As String) As String

  If Len(LaChaine) = 1 Then
    Inverse = LaChaine
    Exit Function

  Else
    Inverse = RetourneC(LaChaine)

  End If

End Function

'Le code d'interface est celui-ci :
Sub Command1_Click()
Dim MaChaine As String

  MaChaine = IntputBox("Entrez la chaine à inverser:")

  If MaChaine = 2 Then

  Else
    MsgBox Inverse(MaChaine)
  End If

End Sub

'CONCEPT 2 : Exemple
'Voici un bloc de code
Function Trigo(Valeur As Double) As Double
If Sgn(Valeur) = 1 Then
Trigo = Sin(Valeur)
Else
If Sgn(Valeur) = -1 Then
For i = Valeur To 0 Step 0.2
Trigo = Trigo + Cos(i)
Next i
End If
End If
End Function

'Bien distingué et identé par bloc, cela donne :
Function Trigo(Valeur As Double) As Double
  If Sgn(Valeur) = 1 Then
    Trigo = Sin(Valeur)
  Else
    If Sgn(Valeur) = -1 Then
      For i = Valeur To 0 Step 0.2
        Trigo = Trigo + Cos(i)
      Next i
    End If
  End If
End Function

'Le tout aéré donne :Function Trigo(Valeur As Double) As Double
Function Trigo(Valeur As Double) As Double

  If Sgn(Valeur) = 1 Then
    Trigo = Sin(Valeur)

  Else
    If Sgn(Valeur) = -1 Then
      
      For i = Valeur To 0 Step 0.2
        Trigo = Trigo + Cos(i)
      Next i

    End If

  End If

End Function

'CONCEPT 3 : Exemple
'commenter un code
Function RetourneC(Origine As String) As String
'inverse l'ordre des caractères dans Origine vers RetourneC

  RetourneC = ""  'purge de la variable

  'inversion caractère par caractère
  For i = Len(Origine) to 1 Step -1
    RetourneC = RetourneC & Mid(Origine,i,1)   'on prend un caratère de Origine pour le cumuler dans RetourneC
  Next i

End Function

'CONCEPT 4 :
'Nommage des variable

'Les variables d'itérations (très célèbre) :
Dim i as Long, j as Long, k as Long

'Les variables du débogueur :) (type Variant ou Long généralement)
Dim titi, tata, toto, temp, tmp, overflow

'Les "préfixes" identifiant le type de variable
Dim bMaVar1 As Byte
Dim iMaVar2 As Integer
Dim lMaVar3 As Long
Dim sTexto As String
Dim aTablo() 'As Integer
Dim oBarre As ProgressBar 'As Object
Dim dFlottant as Double

Conclusion :


Je n'attend pas de notes ni d'éloges/insultes, mais des codes sources bien présentés! ;)
Eventuellement si vous connaissez d'autres formalisme en VB, rajoutez-les dans les commentaires!

A voir également

Ajouter un commentaire Commentaires
Messages postés
7
Date d'inscription
vendredi 26 juillet 2002
Statut
Membre
Dernière intervention
28 juillet 2002

tu a marqué :
Objectif : réaliser des code bien présenté et ordonnés, ce qui optimise souvent la vitesse et la compatibilité, et améliore la portabilité - et sa compréhension.

augmente la vitesse et la compatibilité ..... hum ttes sur car moi les retour et les espace je croit que le prog une fois compilé ya pas de diff...jsuis pas sur @+
Messages postés
1221
Date d'inscription
jeudi 23 août 2001
Statut
Membre
Dernière intervention
9 septembre 2018

Ouais, pour la lisisbilité il faut respecter l'indentation (les tabulations) mais aussi les conventions de nommage des variables, cela évite pas mal de bug lorsque tu dois reprendre un prog.
Par exemple, moi j'utilise en premier caractère du nom de la variable :
' b pour Boolean (booléen vrai ou faux)
' i pour Integer : %
' l pour Long : &
' r pour nombre Réel (Single ou Double) : ! ou #
' a pour Array (tableau) : ()
' o pour Object (objet ou classe)
' m_ pour variable Membre de la classe
Messages postés
259
Date d'inscription
dimanche 14 juillet 2002
Statut
Membre
Dernière intervention
17 août 2012

Se petti court de programation est tres interessant. Bien qu'il serait encore mieux de créuer un prog qui aprend a programmer . Mais lidé de montrer les fonction(plusieur mete toute dun tat) est vraiment bonne 10/10

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.