Apprenez à programmer en VB .NET

Apprenez à programmer en VB .NET

Mis à jour le lundi 24 juin 2013

Une fonction répète une action bien précise. Nous en connaissons déjà, par exemple BEEP ou IsNumeric(), qui vérifie que la valeur d'une variable est bien un nombre. Vous voyez, des programmeurs ont déjà créé et intégré des fonctions dans les bibliothèques, d'énormes fichiers qui les rassemblent toutes et que vous possédez sur votre ordinateur dès lors que vous avez installé Visual Basic Express. Nous allons donc à notre tour programmer une fonction et apprendre à l'utiliser.

Créons notre première fonction !

Nous allons donc créer notre première fonction, la plus basique qui soit : sans argument, sans retour. Mais on va tout de même lui faire faire quelque chose… Pourquoi, par exemple, ne pas additionner deux nombres que l'on saisit à l'écran ?

Vous vous rappelez certainement le TP avec l'addition. Eh bien, on va factoriser l'addition avec la demande des nombres (« factoriser » signifie mettre sous forme de fonction).

Module Module1

    Sub Main()
        Addition()
    End Sub

    Sub Addition()
        Dim ValeurEntree As String = ""
        Dim Valeur1 As Integer = 0
        Dim Valeur2 As Integer = 0

        Console.WriteLine("- Addition de deux nombres -")
        'Récupération du premier nombre
        Do
            Console.WriteLine("Entrez la première valeur")
            ValeurEntree = Console.ReadLine()
            'Tourne tant que ce n'est pas un nombre
        Loop Until IsNumeric(ValeurEntree)
        'Écriture de la valeur dans un integer
        Valeur1 = ValeurEntree

        'Récupération du second nombre
        Do
            Console.WriteLine("Entrez la seconde valeur")
            ValeurEntree = Console.ReadLine()
            'Tourne tant que ce n'est pas un nombre
        Loop Until IsNumeric(ValeurEntree)
        'Écriture de la valeur dans un integer
        Valeur2 = ValeurEntree

        'Addition
        Console.WriteLine(Valeur1 & " + " & Valeur2 & " = " & Valeur1 + Valeur2)

        'Pause factice
        Console.Read()
    End Sub
End Module

Il n'y a plus rien dans le Main() : cela ne va plus marcher !

Bien au contraire : j'ai placé dans le Main() l'appel de la fonction.

Lorsque vous créez une fonction, ce n'est pas comme le Main(), elle ne se lance pas toute seule ; si je n'avais pas ajouté cet appel, le programme n'aurait rien fait !

La ligne Addition() appelle donc la fonction, mais pourquoi ? Avez-vous remarqué le Sub que j'ai placé en dessous du Main() ?

C'est pour cela que j'ai écrit Sub Addition(), et non Function Addition() (Function étant le mot-clé déclarant une fonction). Et donc, dans ce Sub, j'ai copié-collé exactement le code de notre TP sur l'addition.

Vous pouvez tester : ça fonctionne !

Ajout d'arguments et de valeur de retour

Vous avez vu comment créer une fonction que je qualifierais d'« indépendante », ce qui signifie que cette dernière n'influera pas sur le reste du programme, et exécutera toujours la même chose : demander des valeurs, les additionner et afficher le résultat.

Cependant, ce style de raisonnement va vite nous limiter. Heureusement, les créateurs des langages de programmation ont pensé à quelque chose de génial : les arguments et le retour.

Les arguments

Vous savez déjà ce qu'est un argument. Par exemple, dans la fonction Write(), l'argument est la valeur placée entre parenthèses, et cette fonction effectue « Affiche-moi cette valeur ! ».

Vous l'avez donc sûrement compris, les arguments sont mis entre parenthèses… « les », oui, exactement, parce qu'il peut y en avoir plusieurs ! Et vous l'avez déjà remarqué : lorsque nous avons étudié le BEEP, les arguments étaient la fréquence et la durée. Et tous deux séparés par… une virgule (« , ») !

Dans une fonction, les différents arguments sont séparés par une virgule. Vous savez donc comment passer des arguments à une fonction, mais comment créer une fonction qui les reçoive ?

La ligne se présente sous la forme suivante :

Sub Addition(ByVal Valeur1 As Integer, ByVal Valeur2 As Integer)

Vous remarquez bien les ByVal Valeur1 As Integer ; cette syntaxe est à utiliser pour chaque argument : le mot ByVal, le nom de la variable, le mot As, et le type de la variable.

Ce qui nous donne, dans un cas comme notre addition :

Sub Addition(ByVal Valeur1 As Integer, ByVal Valeur2 As Integer)
        'Addition des deux arguments
        Console.WriteLine(Valeur1 & " + " & Valeur2 & " = " & Valeur1 + Valeur2)

        'Pause factice
        Console.Read()
End Sub

Voilà par exemple le Sub que j'ai écrit, et qui additionne deux valeurs passées en arguments.

Pourquoi n'as-tu pas déclaré les variables Valeur1 et Valeur2 ?

Elles ont été automatiquement déclarées dans la ligne de création de fonction.

Si vous souhaitez appeler cette fonction, comment faut-il procéder ?

Addition(Valeur1, Valeur2)

Vous avez bien compris ?

Vous avez dû le remarquer, il faut obligatoirement utiliser tous les arguments lors de l'appel de la fonction, sauf une petite exception que je vous présenterai plus tard.

Valeur de retour

Imaginez que vous ayez envie d'une fonction qui effectue un calcul très compliqué ou qui modifie votre valeur d'une certaine manière. Vous voudriez sans doute récupérer la valeur ? C'est ce qu'on appelle le retour :

Function Addition(ByVal Valeur1 As Integer, ByVal Valeur2 As Integer) As Integer

C'est le morceau du bout (As Integer) qui nous intéresse : c'est cette partie qui indiquera à la fonction le type de valeur qu'elle doit renvoyer. Dans le cas présent, il s'agit d'un type numérique, mais j'aurais très bien pu écrire As String.

Hop hop hop ! pourquoi as-tu écrit Function au début et non plus Sub ?

Je vous l'ai dit tout en haut : les Sub ne renvoient rien, il faut donc passer par les fonctions si on veut une valeur de retour.

Function Addition(ByVal Valeur1 As Integer, ByVal Valeur2 As Integer) As Integer
        Dim Resultat As Integer
        'Addition des deux arguments
        Resultat = Valeur1 + Valeur2

        'Renvoie le résultat
        Return Resultat
End Function

Cette fonction additionne donc les deux nombres passés en arguments et renvoie le résultat.

La ligne Return Resultat est très importante, car c'est elle qui détermine le retour : si vous n'écrivez pas cette ligne, aucun retour ne se fera.

Maintenant, comment appeler cette fonction ? La forme Addition(Valeur1, Valeur2) aurait pu fonctionner, mais où va la valeur de retour ? Il faut donc récupérer cette valeur avec un « = ».

Resultat = Addition(Valeur1, Valeur2)

Une fois cet appel écrit dans le code, ce dernier additionne les deux valeurs. Je suis conscient que cette démarche est assez laborieuse et qu'un simple Resultat = Valeur1 + Valeur2 aurait été plus simple, mais c'était pour vous faire découvrir le principe.

Cette fonction peut être directement appelée dans une autre, comme ceci par exemple :

Console.WriteLine(Addition(Valeur1, Valeur2))

Sachez que les fonctions vont vous être très utiles. J'espère qu'à présent vous savez les utiliser. :p

Petits plus sur les fonctions

Les arguments facultatifs

Tout d'abord, une petite astuce que je vais vous expliquer : l'utilisation des arguments facultatifs. Je vous ai dit que tous les arguments étaient indispensables, sauf exception ; eh bien, voici l'exception.

Les arguments facultatifs sont des arguments pour lesquels on peut choisir d'attribuer une valeur ou non au moment de l'appel de la fonction. Pour les déclarer, tapez Optional ByVal Valeur3 As Integer = 0.

Le mot-clé Optional est là pour dire qu'il s'agit d'un argument facultatif, le reste de la syntaxe étant la même que pour les autres fonctions.

Function Operation(ByVal Valeur1 As Integer, ByVal Valeur2 As Integer, Optional ByVal Valeur3 As Integer = 0) As Integer
        Return Valeur1 + Valeur2 + Valeur3
End Function

Voilà donc la nouvelle fonction. Dans l'appel de cette fonction, je peux maintenant écrire Operation(1, 5), ce qui me renverra 6, ou alors Operation(10, 15, 3) qui me renverra 28. Les deux appels sont valides.

Commenter sa fonction

Je vous ai déjà résumé la marche à suivre pour commenter des lignes. Mais voilà, comment faire pour commenter des fonctions entières ?
Placez-vous sur la ligne juste avant la fonction.

Function Operation(ByVal Valeur1 As Integer, ByVal Valeur2 As Integer, Optional ByVal Valeur3 As Integer = 0) As Integer
        Return Valeur1 + Valeur2 + Valeur3
End Function

Ajoutez ensuite trois quotes : « ''' ».
Des lignes vont s'afficher :

''' <summary>
''' 
''' </summary>
''' <param name="Valeur1"></param>
''' <param name="Valeur2"></param>
''' <param name="Valeur3"></param>
''' <returns></returns>
''' <remarks></remarks>

Ces lignes permettent de commenter la fonction : dans summary, expliquez brièvement le rôle de la fonction ; dans les paramètres, précisez à quoi ils correspondent ; et dans la valeur de retour, indiquez ce que la fonction retourne.

Par exemple, j'ai commenté ma fonction comme ceci :

''' <summary>
''' Additionne les valeurs passées en argument
''' </summary>
''' <param name="Valeur1">Première valeur à additionner</param>
''' <param name="Valeur2">Seconde valeur à additionner</param>
''' <param name="Valeur3">Troisième valeur à additionner, Optionnel</param>
''' <returns>L'addition des arguments</returns>
''' <remarks></remarks>

Cliquez ensuite sur cette petite flèche pour « replier » cette zone, comme à la figure suivante.

Cliquez sur la flèche pour « replier » la zone
Cliquez sur la flèche pour « replier » la zone

À présent, à chaque endroit où vous allez écrire cette fonction, un cadre s'affichera vous indiquant ce qu'il faut lui donner comme arguments, comme à la figure suivante.

Un cadre s'affiche
Un cadre s'affiche

Cela est très utile lorsque vous avez beaucoup de fonctions.

Petit exercice

Pour clore ce chapitre, je vous propose un petit exercice.

Je vais vous demander de remplir un tableau de dix cases et d'additionner les valeurs, la récupération de ces valeurs devant se faire en toute sécurité, comme dans notre TP sur l'addition.
La partie qui demande la valeur et qui vérifie s'il s'agit d'un nombre devra être écrite dans une fonction séparée.

À vos claviers !

Module Module1

    Sub Main()
        Dim TableauDeValeurs(9) As Integer
        Dim Resultat As Integer = 0

        'Demande les valeurs en passant par la fonction
        For i As Integer = 0 To TableauDeValeurs.Length - 1
            TableauDeValeurs(i) = DemandeValeur(i)
        Next

        'Additionne les valeurs
        For i As Integer = 0 To TableauDeValeurs.Length - 1
            Resultat = Resultat + TableauDeValeurs(i)
        Next

        'Affiche le résultat
        Console.WriteLine(Resultat)

        'Pause
        Console.Read()
    End Sub

    Function DemandeValeur(ByVal Numero As Integer) As Integer
        Dim ValeurEntree As String

        'Demande la valeur
        Do
            Console.WriteLine("Entrez valeur " & Numero + 1)
            ValeurEntree = Console.ReadLine()
            'Tourne tant que ce n'est pas un nombre
        Loop Until IsNumeric(ValeurEntree)

        'Convertit la valeur en integer et la renvoie
        Return CInt(ValeurEntree)
    End Function
End Module

Clarifions un peu ce code.

J'entre dans une boucle dans laquelle j'appelle la fonction, en passant comme paramètre le numéro de la boucle. Mais pourquoi ?
Allons faire un tour du côté de la fonction : ce paramètre me permet de dire à l'utilisateur quel est le numéro qu'il entre (Console.WriteLine("Entrez valeur " & Numero + 1) ; j'ajoute « 1 » pour ne pas avoir de Entrez valeur 0).

Cette fonction, vous la connaissez : c'est la même que pour l'addition ; sauf que… la ligne Return CInt(ValeurEntree) vous inquiète…

J'explique : ce que je viens de faire s'appelle un cast, c'est-à-dire que l'on convertit un type en un autre.
Cette ligne fait appel à la fonction CInt(), qui permet de convertir une variable de type string, par exemple, en integer. Pourquoi ai-je fait cela ?

Parce que je renvoie un integer, et que la variable est pour le moment un string. Je peux le faire en toute sécurité puisque je vérifie que mon string contient bien une valeur numérique ; s'il avait contenu, par exemple, un mot, il y aurait eu une erreur.

Vous auriez très bien pu passer par une variable intermédiaire, comme on l'a vu précédemment.

Voilà qui clôt notre chapitre sur les fonctions.

  • Si l'on commence la déclaration de la fonction avec le mot-clé Sub, elle ne retournera pas de valeur, ce sera alors une méthode.

  • Une fois l'instruction contenant return exécutée, la fonction ne continue pas son exécution.

  • Vous utilisez des centaines de fonctions déjà écrites dans le framework de Visual Basic .NET, vous pouvez en créer autant que vous le voulez.

  • Les arguments optionnels sont définis avec le mot-clé Optionnal.

Exemple de certificat de réussite
Exemple de certificat de réussite