Instructions dans Visual Basic

Article
08/10/2011

En Visual Basic, une instruction est une entité complète. Elle contient des mots clés, des opérateurs, des variables, des constantes et des expressions. Chaque instruction appartient à l'une des catégories suivantes :

instructions de déclaration qui nomment une variable, une constante ou une procédure et qui peuvent également spécifier un type de données ;
instructions exécutables qui initient des actions. Ces instructions peuvent appeler une méthode ou une fonction, et peuvent parcourir ou créer des branches de blocs de code. Les instructions exécutables contiennent des instructions d'assignation, qui assignent une valeur ou une expression à une variable ou à une constante.

Cette rubrique décrit chaque catégorie. Elle montre également comment combiner plusieurs instructions sur une ligne et comment continuer une instruction sur plusieurs lignes.

Instructions de déclaration

Les instructions de déclaration permettent de nommer et de définir des procédures, des variables, des propriétés, des tableaux et des constantes. Lorsque vous déclarez un élément de programmation, vous pouvez également définir son type de données, son niveau d'accès et sa portée. Pour plus d'informations, consultez Caractéristiques d'éléments déclarés (Visual Basic).

L'exemple suivant contient trois déclarations.

Public Sub applyFormat()
    Const limit As Integer = 33
    Dim thisWidget As New widget
    ' Insert code to implement the procedure.
End Sub

La première déclaration est l'instruction Sub. Associée à son instruction End Sub correspondante, elle déclare une procédure nommée applyFormat. Elle spécifie également que applyFormat a la valeur Public, ce qui signifie qu'un code qui peut y faire référence peut l'appeler.

La deuxième déclaration est l'instruction Const qui déclare la constante limit, en spécifiant le type de données Integer et la valeur 33.

La troisième déclaration est l'instruction Dim, qui déclare la variable thisWidget. Le type de données est un objet spécifique, à savoir un objet créé à partir de la classe Widget. Vous pouvez déclarer une variable comme étant d'un type de données élémentaire ou d'un type d'objet exposé dans l'application utilisée.

Valeurs initiales

Lorsque le code contenant une instruction de déclaration s'exécute, Visual Basic réserve la mémoire requise pour l'élément déclaré. Si l'élément contient une valeur, Visual Basic l'initialise à la valeur par défaut de son type de données. Pour plus d'informations, consultez « Comportement » dans Dim, instruction (Visual Basic).

Vous pouvez assigner une valeur initiale à une variable dans le cadre de sa déclaration, comme l'exemple suivant l'illustre.

Dim m As Integer = 45
' The preceding declaration creates m and assigns the value 45 to it.

Si votre variable est une variable objet, vous pouvez explicitement créer une instance de sa classe lorsque vous la déclarez à l'aide du mot clé New, opérateur (Visual Basic), comme indiqué dans l'exemple suivant

Dim f As New System.Windows.Forms.Form()

Notez que la valeur initiale que vous spécifiez dans une instruction de déclaration n'est pas assignée à une variable tant que l'exécution n'atteint pas son instruction de déclaration. Jusqu'à ce moment, la variable contient la valeur par défaut de son type de données.

Instructions exécutables

Une instruction exécutable effectue une action. Elle peut appeler une procédure, effectuer un branchement vers un autre emplacement du code, parcourir plusieurs instructions ou évaluer une expression. Une instruction d'assignation est un cas spécial d'une instruction exécutable.

L'exemple suivant utilise une structure de contrôle If...Then...Else pour exécuter divers blocs de code selon la valeur d'une variable. Une boucle For...Next s'exécute un certain nombre de fois dans chaque bloc de code.

Public Sub startWidget(ByVal aWidget As widget,
    ByVal clockwise As Boolean, ByVal revolutions As Integer)
    Dim counter As Integer
    If clockwise = True Then
        For counter = 1 To revolutions
            aWidget.spinClockwise()
        Next counter
    Else
        For counter = 1 To revolutions
            aWidget.spinCounterClockwise()
        Next counter
    End If
End Sub

L'instruction Ifde l'exemple précédent vérifie la valeur du paramètre clockwise. Si la valeur est True, elle appelle la méthode spinClockwise de aWidget. Si la valeur est False, elle appelle la méthode spinCounterClockwise de aWidget. La structure de contrôle If...Then...Else se termine par End If.

La boucle For...Next à l'intérieur de chaque bloc appelle la méthode appropriée autant de fois que la valeur du paramètre revolutions.

Instructions d'assignation

Les instructions d'assignation exécutent des opérations d'assignation qui consistent à prendre la valeur située à droite de l'opérateur d'assignation (=) et à la stocker dans l'élément situé à gauche, comme dans l'exemple suivant.

v = 42

Dans l'exemple précédent, l'instruction d'assignation stocke la valeur littérale 42 dans la variable v.

Éléments de programmation admissibles

L'élément de programmation situé à gauche de l'opérateur d'assignation doit être en mesure d'accepter et de stocker une valeur. En d'autres termes, il doit être une variable ou une propriété qui n'est pas ReadOnly (Visual Basic), ou encore il doit être un élément de tableau. Dans le contexte d'une instruction d'assignation, un tel élément est parfois appelé lvalue, pour « valeur de gauche ».

La valeur située à droite de l'opérateur d'assignation est générée par une expression qui peut être composée de n'importe quelle combinaison de littéraux, de constantes, de variables, de propriétés, d'éléments de tableau, d'autres expressions ou d'appels de fonctions. L'exemple suivant illustre ce comportement.

x = y + z + findResult(3)

L'exemple précédent ajoute la valeur contenue dans la variable y à celle qui est contenue dans la variable zvariable, puis ajoute la valeur retournée par l'appel à la fonction findResult. La valeur totale de cette expression est ensuite stockée dans la variable x.

Types de données dans les instructions d'assignation

Outre les valeurs numériques, l'opérateur d'assignation peut également assigner des valeurs String, comme le montre l'exemple suivant.

Dim a, b As String
a = "String variable assignment"
b = "Con" & "cat" & "enation"
' The preceding statement assigns the value "Concatenation" to b.

Vous pouvez également assigner des valeurs Boolean à l'aide d'un littéral Boolean ou d'une expression Boolean, comme le montre l'exemple suivant.

Dim r, s, t As Boolean
r = True
s = 45 > 1003
t = 45 > 1003 Or 45 > 17
' The preceding statements assign False to s and True to t.

De même, vous pouvez assigner des valeurs appropriées aux éléments de programmation du type de données Char, Date ou Object. Vous pouvez également assigner une instance d'objet à un élément a déclaré pour faire partie de la classe dans laquelle cette instance est créée.

Instructions d'assignation composée

Les instructions d'assignation composée exécutent en premier lieu une opération sur une expression avant de l'assigner à un élément de programmation. L'exemple suivant illustre l'un de ces opérateurs, +=, qui incrémente la valeur de la variable située à gauche de l'opérateur par la valeur de l'expression de droite.

n += 1

L'exemple précédent ajoute 1 à la valeur de n, puis stocke cette nouvelle valeur dans n. C'est l'équivalent abrégé de l'instruction suivante :

n = n + 1

Les opérateurs de ce type permettent d'effectuer de nombreuses opérations d'assignation composées. Pour obtenir la liste de ces opérateurs et en savoir davantage sur eux, consultez Opérateurs d'assignation (Visual Basic).

Enfin, l'opérateur d'assignation de concaténation (&=) est utile pour ajouter une chaîne à la fin de chaînes déjà existantes, comme le montre l'exemple suivant :

Dim q As String = "Sample "
q &= "String"
' q now contains "Sample String".

Conversions de types dans les instructions d'assignation

La valeur que vous assignez à une variable, une propriété ou un élément de tableau doit être un type de données approprié pour cet élément de destination. En général, vous devez essayer de générer une valeur du même type de données que celui de l'élément de destination. Toutefois, certains types peuvent être convertis en d'autres types au cours de l'assignation.

Pour plus d'informations sur la conversion entre types de données, consultez Conversions de type en Visual Basic. En résumé, Visual Basic convertit automatiquement une valeur d'un type donné en un autre type auquel elle s'étend. Une conversion étendue réussit toujours au moment de l'exécution et ne perd pas de données. Par exemple, Visual Basic convertit une valeur Integer en Double, le cas échéant, car Integer s'étend à Double. Pour plus d'informations, consultez Conversions étendues et restrictives (Visual Basic).

Les conversions restrictives (celles qui ne sont pas étendues) courent un risque d'échec au moment de l'exécution, ou de perte de données. Vous pouvez effectuer explicitement une conversion restrictive en utilisant une fonction de conversion de type, ou encore demander au compilateur d'effectuer implicitement toutes les conversions en définissant Option Strict Off. Pour plus d'informations, consultez Conversions implicites et explicites (Visual Basic).

Placement de plusieurs instructions sur une seule ligne

Plusieurs instructions peuvent figurer sur une seule ligne, séparées par le signe deux-points (:). L'exemple suivant illustre ce comportement.

Dim sampleString As String = "Hello World" : MsgBox(sampleString)

Ce type de syntaxe rend souvent la lecture et la gestion du code difficiles. Il est donc recommandé de conserver une instruction sur une ligne.

Suite d'une instruction sur plusieurs lignes

Une instruction figure généralement dans une seule ligne, mais lorsqu'elle est trop longue, vous pouvez la poursuivre sur la ligne suivante en utilisant une séquence de continuation de ligne, composée respectivement d'un espace, d'un trait de soulignement (_) et d'un retour chariot. Dans l'exemple suivant, l'instruction exécutable MsgBox se poursuit sur deux lignes.

Public Sub demoBox()
    Dim nameVar As String
    nameVar = "John"
    MsgBox("Hello " & nameVar _
        & ". How are you?")
End Sub

Continuation de ligne implicite

Dans de nombreux cas, vous pouvez continuer une instruction sur la ligne consécutive suivante sans utiliser le trait de soulignement (_). Le tableau suivant répertorie les éléments de syntaxe qui continuent implicitement l'instruction sur la ligne de code suivante.

Élément de syntaxe	Exemple
Après une virgule (,).	`Public Function GetUsername(ByVal username As String, ByVal delimiter As Char, ByVal position As Integer) As String Return username.Split(delimiter)(position) End Function`
Après une parenthèse ouvrante (() ou avant une parenthèse fermante ()).	`Dim username = GetUsername( Security.Principal.WindowsIdentity.GetCurrent().Name, CChar("\"), 1 )`
Après une accolade ouvrante ({) ou avant une accolade fermante (}).	`Dim customer = New Customer With { .Name = "Terry Adams", .Company = "Adventure Works", .Email = "terry@www.adventure-works.com" }` Pour plus d'informations, consultez Initialiseurs d'objets : types nommés et anonymes (Visual Basic) ou Vue d'ensemble des initialiseurs de collections (Visual Basic).
Après une expression incorporée ouvrante (<%=) ou avant une expression incorporée fermante (%>) dans un littéral XML.	`Dim customerXml = <Customer> <Name> <%= customer.Name %> </Name> <Email> <%= customer.Email %> </Email> </Customer>` Pour plus d'informations, consultez Expressions incorporées en XML (Visual Basic).
Après l'opérateur de concaténation (&).	`cmd.CommandText = "SELECT * FROM Titles JOIN Publishers " & "ON Publishers.PubId = Titles.PubID " & "WHERE Publishers.State = 'CA'"` Pour plus d'informations, consultez Opérateurs répertoriés par fonctionnalité (Visual Basic).
Après les opérateurs d'assignation (=, &=, :=, +=, -=, *=, /=, \=, ^=, <<=, >>=).	`Dim fileStream = My.Computer.FileSystem. OpenTextFileReader(filePath)` Pour plus d'informations, consultez Opérateurs répertoriés par fonctionnalité (Visual Basic).
Après les opérateurs binaires (+, -, /, *, Mod, <>, <, >, <=, >=, ^, >>, <<, And, AndAlso, Or, OrElse, Like, Xor) dans une expression.	`Dim memoryInUse = My.Computer.Info.TotalPhysicalMemory + My.Computer.Info.TotalVirtualMemory - My.Computer.Info.AvailablePhysicalMemory - My.Computer.Info.AvailableVirtualMemory` Pour plus d'informations, consultez Opérateurs répertoriés par fonctionnalité (Visual Basic).
Après les opérateurs Is et IsNot.	`If TypeOf inStream Is IO.FileStream AndAlso inStream IsNot Nothing Then ReadFile(inStream) End If` Pour plus d'informations, consultez Opérateurs répertoriés par fonctionnalité (Visual Basic).
Après un caractère de qualificateur de membre (.) et avant le nom de membre. Toutefois, vous devez inclure un caractère de continuation de ligne (_) après un caractère de qualificateur de membre lorsque vous utilisez l'instruction With ou que vous indiquez des valeurs dans la liste d'initialisation d'un type. Arrêtez la ligne après l'opérateur d'assignation (par exemple, =) lorsque vous utilisez des instructions With ou des listes d'initialisation d'objets.	`Dim fileStream = My.Computer.FileSystem. OpenTextFileReader(filePath) ... ' Not allowed: ' Dim aType = New With { . ' PropertyName = "Value" ' Allowed: Dim aType = New With {.PropertyName = "Value"} Dim log As New EventLog() ' Not allowed: ' With log ' . ' Source = "Application" ' End With ' Allowed: With log .Source = "Application" End With` Pour plus d'informations, consultez With...End With, instruction (Visual Basic) ou Initialiseurs d'objets : types nommés et anonymes (Visual Basic).
Après un qualificateur de propriété d'axe XML (. ou .@ ou ...). Toutefois, vous devez inclure un caractère de continuation de ligne (_) lorsque vous spécifiez un qualificateur de membre, si vous utilisez le mot clé With.	`Dim customerName = customerXml. <Name>.Value Dim customerEmail = customerXml... <Email>.Value` Pour plus d'informations, consultez Propriétés d'axe XML (Visual Basic).
Après un signe inférieur à (<) ou avant un signe supérieur à (>) lorsque vous spécifiez un attribut. Également après un signe supérieur à (>) lorsque vous spécifiez un attribut. Toutefois, vous devez inclure un caractère de continuation de ligne (_) lorsque vous spécifiez des attributs au niveau de l'assembly ou du module.	`< Serializable() > Public Class Customer Public Property Name As String Public Property Company As String Public Property Email As String End Class` Pour plus d'informations, consultez Attributs (C# et Visual Basic).
Avant et après les opérateurs de requête (Aggregate, Distinct, From, Group By, Group Join, Join, Let, Order By, Select, Skip, Skip While, Take, Take While, Where, In, Into, On, Ascending et Descending). Vous ne pouvez pas interrompre une ligne entre les mots clés des opérateurs de requête qui sont composés de plusieurs mots clés (Order By, Group Join, Take While et Skip While).	`Dim vsProcesses = From proc In Process.GetProcesses Where proc.MainWindowTitle.Contains("Visual Studio") Select proc.ProcessName, proc.Id, proc.MainWindowTitle` Pour plus d'informations, consultez Requêtes (Visual Basic).
Après le mot clé In dans une instruction For Each.	`For Each p In vsProcesses Console.WriteLine("{0}" & vbTab & "{1}" & vbTab & "{2}", p.ProcessName, p.Id, p.MainWindowTitle) Next` Pour plus d'informations, consultez For Each...Next, instruction (Visual Basic).
Après le mot clé From dans un initialiseur de collection.	`Dim days = New List(Of String) From { "Mo", "Tu", "We", "Th", "F", "Sa", "Su" }` Pour plus d'informations, consultez Vue d'ensemble des initialiseurs de collections (Visual Basic).

Ajout de commentaires

Le code source n'est pas toujours explicatif, même pour le programmeur qui l'a écrit. Pour simplifier la documentation de leur code, la majorité des programmeurs utilisent donc de nombreux commentaires incorporés. Les commentaires présents dans le code peuvent expliquer une procédure ou une instruction particulière à n'importe quelle personne qui la lit ou l'utilise ultérieurement. Visual Basic ignore les commentaires pendant la compilation de telle sorte qu'ils n'affectent pas le code compilé.

Les lignes des commentaires commencent par une apostrophe (') ou par REM suivi d'un espace. Ils peuvent être ajoutés n'importe où dans le code, sauf dans une chaîne. Pour ajouter un commentaire à une instruction, insérez une apostrophe ou REM après l'instruction, suivie du commentaire. Les commentaires peuvent également figurer sur leur propre ligne distincte. L'exemple de code suivant illustre ces possibilités.

' This is a comment on a separate code line.
REM This is another comment on a separate code line.
x += a(i) * b(i) ' Add this amount to total.
MsgBox(statusMessage) REM Inform operator of status.

Vérification des erreurs de compilation

Si après avoir tapé une ligne de code, la ligne est affichée avec un soulignement ondulant (un message d'erreur peut également être affiché), l'instruction comporte une erreur de syntaxe. Vous devez localiser le problème de l'instruction (en recherchant dans la liste des tâches ou en plaçant le pointeur de la souris sur l'erreur pour lire le message d'erreur) et le corriger. Votre programme ne sera pas correctement compilé si vous ne corrigez pas toutes les erreurs de syntaxe dans votre code.

Rubriques connexes

Terme	Définition
Opérateurs d'assignation (Visual Basic)	Fournit des liens vers des pages de référence du langage qui décrivent les opérateurs d'assignation, tels que =, *= et &=.
Opérateurs et expressions en Visual Basic	Explique comment combiner des éléments avec des opérateurs pour retourner de nouvelles valeurs.
Comment : diviser et combiner des instructions dans le code (Visual Basic)	Indique comment répartir une instruction unique sur plusieurs lignes et comment placer plusieurs instructions sur une même ligne.
Comment : étiqueter des instructions (Visual Basic)	Montre comment étiqueter une ligne de code.