Tableaux dans Visual Basic

Un tableau est un ensemble de valeurs liées de manière logique, telles que le nombre d'étudiants de chaque niveau scolaire dans un lycée.

À l'aide d'un tableau, vous pouvez faire référence à ces valeurs associées par le même nom, puis utilisez un nombre qui est appelé index ou indice à leur dire à part.Les valeurs individuelles portent le nom d'éléments du tableau.Ils sont contigus de l'index 0 à la valeur d'index la plus élevée.

Contrairement à un tableau, une variable contenant une valeur unique est appelée une variable scalaire .

Dans cette rubrique

• Éléments de tableau dans un tableau simple

• Création d'un tableau

• Déclaration d'un tableau

• Stockage de valeurs dans un tableau

• Remplissage d'un tableau avec des valeurs initiales

  • Littéraux de tableaux imbriqués

• Itération dans un tableau

• Tableaux comme valeurs de retour et paramètres

• Tableaux en escalier

• Tableaux de longueur zéro

• Taille de tableau

• Types tableau et autres types

• Les collections en tant qu'alternative aux tableaux

Éléments de tableau dans un tableau simple

L'exemple suivant déclare une variable tableau devant contenir le nombre d'étudiants de chaque niveau scolaire dans un lycée.

Dim students(6) As Integer

Le tableau students dans l'exemple précédent contient sept éléments.Les index des éléments varient de 0 à 6.Avoir ce tableau est plus simple que la déclaration sept variables.

L'illustration suivante représente le tableau students.Pour chaque élément du tableau :

• l'index de l'élément représente le niveau scolaire (l'index 0 représente le jardin d'enfants) ;

• La valeur contenue dans l'élément représente le nombre d'étudiants de cette note.

Éléments du tableau « students »

L'exemple suivant montre comment faire référence aux premier, deuxième et dernier éléments du tableau students.

Dim kindergarten As Integer = students(0)
Dim firstGrade As Integer = students(1)
Dim sixthGrade As Integer = students(6)
MsgBox("Students in kindergarten = " & CStr(kindergarten))
MsgBox("Students in first grade = " & CStr(firstGrade))
MsgBox("Students in sixth grade = " & CStr(sixthGrade))

Vous pouvez faire référence au tableau dans son ensemble en utilisant uniquement le nom de variable tableau sans index.

Le tableau students dans l'exemple précédent utilise un index et on dit est unidimensionnel.Un tableau qui utilise plusieurs index ou indices est multidimensionnel.Pour plus d'informations, consultez le reste de cette rubrique et Dimensions du tableau dans Visual Basic.

Création d'un tableau

Vous pouvez définir la taille d'un tableau plusieurs façons.Vous pouvez spécifier la taille lorsque le tableau est déclaré, comme indiqué dans l'exemple suivant.

Dim cargoWeights(10) As Double
Dim atmospherePressures(2, 2, 4, 10) As Short
Dim inquiriesByYearMonthDay(20)()() As Byte

Vous pouvez également utiliser une clause d' New pour spécifier la taille d'un tableau lorsqu'elle a créée, comme indiqué dans l'exemple suivant.

cargoWeights = New Double(10) {}
atmospherePressures = New Short(2, 2, 4, 10) {}
inquiriesByYearMonthDay = New Byte(20)()() {}

Si vous disposez déjà d'un tableau, vous pouvez redéfinir sa taille à l'aide de l'instruction Redim.Vous pouvez spécifier que l'instruction d' Redim doit conserver les valeurs qui sont dans le tableau, ou vous pouvez spécifier qu'elle crée un tableau vide.L'exemple suivant illustre différentes façons d'utiliser l'instruction Redim pour modifier la taille d'un tableau existant.

' Assign a new array size and retain the current element values.
ReDim Preserve cargoWeights(20)
' Assign a new array size and retain only the first five element values.
ReDim Preserve cargoWeights(4)
' Assign a new array size and discard all current element values.
ReDim cargoWeights(15)

Pour plus d'informations, consultez ReDim, instruction (Visual Basic).

Déclaration d'un tableau

Vous pouvez déclarer des variables tableau de la même façon que les autres variables, à l'aide de l'instruction Dim.Vous suivez le type ou le nom de variable avec une ou plusieurs paires de parenthèses pour indiquer qu'il contiendra un tableau au lieu d'une variable scalaire, qui est une variable qui contient une valeur unique.

Une fois que vous déclariez tableau, vous pouvez définir sa taille à l'aide de ReDim, instruction (Visual Basic).

L'exemple suivant déclare une variable tableau unidimensionnel en ajoutant une paire de parenthèses après le type.L'exemple indique également les dimensions du tableau à l'aide de ReDim, instruction (Visual Basic).

' Declare a one-dimensional array.
Dim cargoWeights As Double()

' Dimension the array.
ReDim cargoWeights(15)

L'exemple suivant déclare une variable tableau multidimensionnel en ajoutant une paire de parenthèses après le type et en définissant des virgules dans les parenthèses pour séparer les dimensions.L'exemple indique également les dimensions du tableau à l'aide de ReDim, instruction (Visual Basic).

' Declare a multidimensional array.
Dim atmospherePressures As Short(,,,)

' Dimension the array.
ReDim atmospherePressures(1, 2, 3, 4)

Pour déclarer une variable tableau en escalier, ajoutez une paire de parenthèses après le nom de variable pour chaque niveau de tableau imbriquée.

Dim inquiriesByYearMonthDay()()() As Byte

Les exemples précédents déclarent des variables tableau mais ne leur assignent pas des tableaux.Vous devez encore créer un tableau, l'initialiser et l'assigner à la variable.

Stockage de valeurs dans un tableau

Dans un tableau, vous pouvez accéder à chaque emplacement à l'aide d'un index de type Integer.Vous pouvez stocker des valeurs dans un tableau et en récupérer en référençant chaque emplacement de tableau à l'aide de son index, placé entre parenthèses.Les index pour les tableaux multidimensionnels sont séparés par des virgules (,).Vous avez besoin d'un index pour chaque dimension de tableau.L'exemple suivant montre quelques instructions qui stockent des valeurs dans des tableaux.

Dim i = 4
Dim j = 2

Dim numbers(10) As Integer
Dim matrix(5, 5) As Double

numbers(i + 1) = 0
matrix(3, j * 2) = j

L'exemple suivant montre des instructions qui obtiennent des valeurs à partir de tableaux.

Dim v = 2
Dim i = 1
Dim j = 1
Dim k = 1
Dim wTotal As Double = 0.0
Dim sortedValues(5), rawValues(5), estimates(2, 2, 2) As Double
Dim lowestValue = sortedValues(0)
wTotal += (rawValues(v) ^ 2)
Dim firstGuess = estimates(i, j, k)

Remplissage d'un tableau avec des valeurs initiales

À l'aide d'un littéral de tableau, vous pouvez créer un tableau qui contient un ensemble initial de valeurs.Un littéral de tableau se compose d'une liste de valeurs séparées par des virgules et placées entre accolades ({}).

Lorsque vous créez un tableau à l'aide d'un littéral de tableau, vous pouvez indiquer le type de tableau ou le déterminer au moyen de l'inférence de type.Le code suivant présente les deux options.

Dim numbers = New Integer() {1, 2, 4, 8}
Dim doubles = {1.5, 2, 9.9, 18}

Lorsque vous utilisez l'inférence de type, le type du tableau est déterminé par le type dominant dans la liste de valeurs qui est fournie pour le littéral de tableau.Le type dominant est un type unique auquel tous les autres types dans le littéral de tableau peut s'étendre.Si ce type unique ne peut pas être déterminé, le type dominant est le type unique auquel tous les autres types dans le tableau peut limiter.Si aucun de ces types uniques ne peut être déterminé, le type dominant est Object.Par exemple, si la liste de valeurs qui est fournie au littéral de tableau contient des valeurs de type Integer, Long, et Double, le tableau résultant est de type Double.Integer et Long s'étendent à Double.Par conséquent, Double est le type dominant.Pour plus d'informations, consultez Conversions étendues et restrictives (Visual Basic).Ces règles d'inférence s'appliquent aux types qui sont déduits pour les tableaux qui sont des variables locales définies dans un membre de classe.Bien que vous puissiez utiliser des littéraux de tableaux lorsque vous créez des variables au niveau de la classe, vous ne pouvez pas utiliser l'inférence de type au niveau de la classe.Par conséquent, les littéraux de tableaux spécifiés au niveau de la classe déduisent les valeurs fournies pour le littéral de tableau comme type Object.

Vous pouvez spécifier explicitement le type des éléments dans un tableau qui est créée à l'aide d'un littéral de tableau.Dans ce cas, les valeurs présentes dans le littéral de tableau doivent s'étendre au type des éléments du tableau.L'exemple de code suivant permet de créer un tableau de type Double à partir d'une liste d'entiers.

Dim values As Double() = {1, 2, 3, 4, 5, 6}

Littéraux de tableaux imbriqués

Vous pouvez créer un tableau multidimensionnel à l'aide des littéraux de tableaux imbriqués.Les littéraux de tableaux imbriqués doivent avoir une dimension et un nombre de dimensions, ou rang, qui est compatible avec le tableau résultant.L'exemple de code suivant permet de créer un tableau d'entiers à deux dimensions à l'aide d'un littéral de tableau.

Dim grid = {{1, 2}, {3, 4}}

Dans l'exemple précédent, une erreur se produit si le nombre d'éléments dans les littéraux de tableaux imbriqués ne s'assortissait pas.Une erreur se produit également si vous déclariez explicitement la variable tableau pour être différent à deux dimensions.

[!REMARQUE]

Vous pouvez éviter une erreur lorsque vous indiquez des littéraux de tableaux imbriqués de dimensions différentes en plaçant les littéraux de tableaux internes entre parenthèses.Les parenthèses forcent l'expression de littéral de tableau à évaluer, et les valeurs résultantes sont utilisées avec le littéral de tableau externe, comme l'illustre le code suivant.

Dim values = {({1, 2}), ({3, 4, 5})}

Lorsque vous créez un tableau multidimensionnel à l'aide des littéraux de tableaux imbriqués, vous pouvez utiliser l'inférence de type.Lorsque vous employez l'inférence de type, le type déduit est le type dominant pour l'ensemble des valeurs de tous les littéraux de tableaux d'un niveau d'imbrication.L'exemple de code suivant permet de créer un tableau à deux dimensions de type Double à partir de valeurs de types Integer et Double.

Dim a = {{1, 2.0}, {3, 4}, {5, 6}, {7, 8}}

Pour obtenir d'autres exemples, consultez Comment : initialiser une variable tableau en Visual Basic.

Itération dans un tableau

Lorsque vous itérez au sein d'un tableau, vous pouvez accéder à chaque élément du tableau de l'index le plus élevé à l'index le plus élevé.

L'exemple suivant effectue une itération au sein d'un tableau unidimensionnel à l'aide de For...Next, instruction (Visual Basic).La méthode d' GetUpperBound retourne la valeur la plus élevée que l'index peut avoir.La valeur d'index la plus basse est toujours 0.

Dim numbers = {10, 20, 30}

For index = 0 To numbers.GetUpperBound(0)
    Debug.WriteLine(numbers(index))
Next
' Output:
'  10
'  20
'  30

L'exemple suivant effectue une itération au sein d'un tableau multidimensionnel à l'aide d'une instruction d' For...Next .La méthode d' GetUpperBound a un paramètre qui spécifie la dimension.GetUpperBound(0) retourne la valeur d'index la plus élevée pour la première dimension, et retourne d' GetUpperBound(1) la valeur d'index la plus élevée pour la deuxième dimension.

Dim numbers = {{1, 2}, {3, 4}, {5, 6}}

For index0 = 0 To numbers.GetUpperBound(0)
    For index1 = 0 To numbers.GetUpperBound(1)
        Debug.Write(numbers(index0, index1).ToString & " ")
    Next
    Debug.WriteLine("")
Next
' Output 
'  1 2 
'  3 4 
'  5 6

L'exemple suivant effectue une itération au sein d'un tableau unidimensionnel à l'aide de For Each...Next, instruction (Visual Basic).

Dim numbers = {10, 20, 30}

For Each number In numbers
    Debug.WriteLine(number)
Next
' Output:
'  10
'  20
'  30

L'exemple suivant effectue une itération au sein d'un tableau multidimensionnel à l'aide d'une instruction d' For Each...Next .Toutefois, vous avez plus de contrôle sur les éléments d'un tableau multidimensionnel si vous utilisez une instruction imbriquée d' For…Next, comme dans l'exemple précédent, au lieu d'une instruction d' For Each…Next .

Dim numbers = {{1, 2}, {3, 4}, {5, 6}}

For Each number In numbers
    Debug.WriteLine(number)
Next
' Output:
'  1
'  2
'  3
'  4
'  5
'  6

Tableaux comme valeurs de retour et paramètres

Pour retourner un tableau d'une procédure d' Function, spécifiez le type de données tableau et le nombre de dimensions comme type de retour de Function, instruction (Visual Basic).Dans la fonction, déclarez une variable tableau locale avec les mêmes type de données et nombre de dimensions.Dans Return, instruction (Visual Basic), incluez cette variable tableau locale sans parenthèses.

Pour spécifier un tableau comme paramètre à une procédure d' Sub ou d' Function, définissez le paramètre comme tableau avec un type de données et un nombre spécifié de dimensions.Dans l'appel à la procédure, envoyez une variable tableau avec le même type de données et nombre de dimensions.

Dans l'exemple suivant, la fonction d' GetNumbers retourne Integer().Ce type de tableau est un tableau unidimensionnel de type Integer.La procédure d' ShowNumbers accepte un argument d' Integer() .

Public Sub Process()
    Dim numbers As Integer() = GetNumbers()
    ShowNumbers(numbers)
End Sub

Private Function GetNumbers() As Integer()
    Dim numbers As Integer() = {10, 20, 30}
    Return numbers
End Function

Private Sub ShowNumbers(numbers As Integer())
    For index = 0 To numbers.GetUpperBound(0)
        Debug.WriteLine(numbers(index) & " ")
    Next
End Sub

' Output:
'   10
'   20
'   30

Dans l'exemple suivant, la fonction d' GetNumbersMultiDim retourne Integer(,).Ce type de tableau est un tableau à deux dimensions de type Integer.La procédure d' ShowNumbersMultiDim accepte un argument d' Integer(,) .

Public Sub ProcessMultidim()
    Dim numbers As Integer(,) = GetNumbersMultidim()
    ShowNumbersMultidim(numbers)
End Sub

Private Function GetNumbersMultidim() As Integer(,)
    Dim numbers As Integer(,) = {{1, 2}, {3, 4}, {5, 6}}
    Return numbers
End Function

Private Sub ShowNumbersMultidim(numbers As Integer(,))
    For index0 = 0 To numbers.GetUpperBound(0)
        For index1 = 0 To numbers.GetUpperBound(1)
            Debug.Write(numbers(index0, index1).ToString & " ")
        Next
        Debug.WriteLine("")
    Next
End Sub

' Output  
'  1 2  
'  3 4  
'  5 6

Tableaux en escalier

Un tableau qui contient d'autres tableaux en tant qu'éléments est appelé un tableau de tableaux ou un tableau en escalier.Un tableau en escalier et chaque élément dans un tableau en escalier peut avoir un ou plusieurs dimensions.La structure de données de votre application est parfois à deux dimensions, mais pas rectangulaire.

L'exemple suivant présente un tableau de mois, chaque élément qui est un tableau des jours.Étant donné que les différents mois ont plusieurs nombres de jours, les éléments ne constituent pas un tableau rectangulaire à deux dimensions.Par conséquent, un tableau en escalier est utilisé au lieu d'un tableau multidimensionnel.

' Declare the jagged array.
' The New clause sets the array variable to a 12-element
' array. Each element is an array of Double elements.
Dim sales()() As Double = New Double(11)() {}

' Set each element of the sales array to a Double
' array of the appropriate size.
For month As Integer = 0 To 11
    Dim days As Integer =
        DateTime.DaysInMonth(Year(Now), month + 1)
    sales(month) = New Double(days - 1) {}
Next month

' Store values in each element.
For month As Integer = 0 To 11
    Dim upper = sales(month).GetUpperBound(0)
    For day = 0 To upper
        sales(month)(day) = (month * 100) + day
    Next
Next

Tableaux de longueur zéro

Un tableau qui ne contient aucun élément est également appelée un tableau de longueur zéro.Une variable qui contient un tableau de longueur zéro n'a pas la valeur Nothing.Pour créer un tableau qui ne contient pas d'élément, déclarez une des dimensions du tableau comme étant -1, comme le montre l'exemple suivant.

Dim twoDimensionalStrings(-1, 3) As String

Vous devrez peut-être créer un tableau de longueur zéro dans les circonstances suivantes :

• Sans risquer une exception d' NullReferenceException, votre code doit accéder aux membres de la classe d' Array, tels qu' Length ou Rank, ou appelez une fonction d' Visual Basic telle qu' UBound.

• Vous devez veiller à une plus grande simplification du code utilisateur sans avoir à vérifier Nothing comme un cas particulier.

• Votre code interagit avec une interface de programmation d'applications (API) qui requiert que vous passiez un tableau de longueur zéro à un ou plusieurs procédures ou retourne un tableau de longueur zéro d'une ou plusieurs procédures.

Taille de tableau

La taille d'un tableau est le produit des longueurs de toutes ses dimensions.Elle représente le nombre total d'éléments contenus actuellement dans le tableau.

L'exemple suivant déclare un tableau à trois dimensions.

Dim prices(3, 4, 5) As Long

La taille globale du tableau dans la variable prices est (3 + 1) x (4 + 1) x (5 + 1) = 120.

Vous pouvez rechercher la taille d'un tableau à l'aide de la propriété Length.Vous pouvez rechercher la longueur de chaque dimension d'un tableau multidimensionnel à l'aide de la méthode GetLength.

Vous pouvez redimensionner une variable tableau en lui assignant un nouvel objet tableau ou en utilisant l'instruction ReDim.

Il convient de prendre en compte les facteurs suivants.

Types tableau et autres types

Chaque tableau comporte un type de données, qui diffère du type de données de ses éléments.Il n'existe pas de type de données unique pour tous les tableaux.Au lieu de cela, le type de données d'un tableau est déterminé par le nombre de dimensions, ou rang, du tableau, et le type de données des éléments du tableau.Deux variables tableau sont considérées comme correspondant au même type de données uniquement si elles ont le même rang et que leurs éléments ont le même type de données.Les longueurs des dimensions d'un tableau n'influencent pas le type de données du tableau.

Chaque tableau hérite de la classe System.Array et vous pouvez déclarer une variable comme étant de type Array, mais vous ne pouvez pas créer de tableau de type Array.De plus, l'ReDim, instruction (Visual Basic) ne peut pas fonctionner sur une variable déclarée comme type Array.Pour ces raisons, et pour la sécurité de type, il est recommandé de déclarer chaque tableau en tant que type spécifique, tel que Integer dans l'exemple précédent.

Vous pouvez déterminer le type de données d'un tableau ou de ses éléments de plusieurs manières.

• Vous pouvez appeler la méthode Object.GetType sur la variable de façon à recevoir un objet Type pour le type de la variable à l'exécution.L'objet Type contient des informations complètes dans ses propriétés et méthodes.

• Vous pouvez passer la variable à la fonction TypeName pour recevoir un élément String contenant le nom du type à l'exécution.

• Vous pouvez passer la variable à la fonction VarType pour recevoir une valeur VariantType représentant la classification de type de la variable.

L'exemple suivant appelle la fonction TypeName pour déterminer le type du tableau et celui de ses éléments.Le type du tableau est Integer(,) et le type de ses éléments est Integer.

Dim thisTwoDimArray(,) As Integer = New Integer(9, 9) {}
MsgBox("Type of thisTwoDimArray is " & TypeName(thisTwoDimArray))
MsgBox("Type of thisTwoDimArray(0, 0) is " & TypeName(thisTwoDimArray(0, 0)))

Les collections en tant qu'alternative aux tableaux

Les tableaux sont très utiles pour créer et utiliser un nombre fixe d'objets fortement typés.Les collections offrent plus de souplesse pour utiliser des groupes d'objets.Contrairement aux tableaux, le groupe d'objets que vous utilisez la boîte développer et réduire dynamiquement comme besoins de la modification d'application.

Si vous devez modifier la taille d'un tableau, vous devez utiliser l'ReDim, instruction (Visual Basic).Dans ce cas, Visual Basic crée un tableau et libère le tableau précédent pour qu'il soit supprimé.Cela nécessite un temps d'exécution.Par conséquent, si le nombre d'éléments avec lesquels vous travaillez change fréquemment ou si vous ne pouvez pas prévoir le nombre maximal d'éléments dont vous aurez besoin, vous pourriez obtenir des performances supérieures en utilisant une collection.

Pour certaines collections, vous pouvez assigner une clé à tout objet que vous placez dans la collection afin que vous puissiez rapidement récupérer l'objet à l'aide de la clé.

Si votre collection se limite à des éléments d'un seul type de données, vous pouvez utiliser l'une des classes de l'espace de noms System.Collections.Generic.Une collection générique met en vigueur la sécurité de type afin qu'aucun autre type de données ne puisse lui être ajouté.Lorsque vous récupérez un élément à partir d'une collection générique, il n'est pas nécessaire de déterminer son type de données ni de le convertir.

Pour plus d'informations sur les collections, consultez Collections (C# et Visual Basic).

Exemple

L'exemple suivant montre comment utiliser la classe générique System.Collections.Generic.List<T> du .NET Framework pour créer une collection de listes d'objets Customer.

' Define the class for a customer.
Public Class Customer
    Public Property Name As String
    ' Insert code for other members of customer structure.
End Class

' Create a module-level collection that can hold 200 elements.
Public CustomerList As New List(Of Customer)(200)

' Add a specified customer to the collection.
Private Sub AddNewCustomer(ByVal newCust As Customer)
    ' Insert code to perform validity check on newCust.
    CustomerList.Add(newCust)
End Sub

' Display the list of customers in the Debug window.
Private Sub PrintCustomers()
    For Each cust As Customer In CustomerList
        Debug.WriteLine(cust)
    Next cust
End Sub

La déclaration de la collection CustomerFile spécifie qu'elle peut contenir uniquement des éléments de type Customer.Elle prévoit également une capacité initiale de 200 éléments.La procédure AddNewCustomer vérifie que le nouvel élément est valide, puis elle l'ajoute à la collection.La procédure PrintCustomers utilise une boucle For Each pour parcourir la collection et afficher ses éléments.

Rubriques connexes

Voir aussi

Référence

Dim, instruction (Visual Basic)

ReDim, instruction (Visual Basic)

Array