Partager via


Tableaux en Visual Basic

Un tableau est un ensemble de valeurs, qui sont appelées éléments, qui sont logiquement liés les uns aux autres. Par exemple, un tableau peut être constitué du nombre d’élèves de chaque année d’une école de grammaire ; chaque élément du tableau est le nombre d’étudiants d’une seule année. De même, un tableau peut se composer des notes d’un étudiant pour une classe ; chaque élément du tableau est une classe unique.

Il est possible d’utiliser des variables individuelles pour stocker chacun de nos éléments de données. Par exemple, si notre application analyse les notes des étudiants, nous pouvons utiliser une variable distincte pour la note de chaque étudiant, telle que englishGrade1, englishGrade2etc. Cette approche présente trois limitations majeures :

  • Nous devons savoir au moment du design exactement combien de notes nous devons gérer.
  • La gestion d’un grand nombre de notes devient rapidement difficile. Cela rend une application beaucoup plus susceptible d’avoir des bogues sérieux.
  • Il est difficile de maintenir. Chaque nouvelle classe que nous ajoutons nécessite que l’application soit modifiée, recompilée et redéployée.

À l’aide d’un tableau, vous pouvez faire référence à ces valeurs associées par le même nom et utiliser un nombre appelé index ou indice pour identifier un élément individuel en fonction de sa position dans le tableau. Les index d’un tableau sont compris entre 0 et un inférieur au nombre total d’éléments du tableau. Lorsque vous utilisez la syntaxe Visual Basic pour définir la taille d’un tableau, vous spécifiez son index le plus élevé, et non le nombre total d’éléments dans le tableau. Vous pouvez utiliser le tableau en tant qu’unité et la possibilité d’itérer ses éléments vous permet de savoir exactement le nombre d’éléments qu’il contient au moment du design.

Voici quelques exemples rapides avant l’explication :

' Declare a single-dimension array of 5 numbers.
Dim numbers(4) As Integer

' Declare a single-dimension array and set its 4 values.
Dim numbers = New Integer() {1, 2, 4, 8}

' Change the size of an existing array to 16 elements and retain the current values.
ReDim Preserve numbers(15)

' Redefine the size of an existing array and reset the values.
ReDim numbers(15)

' Declare a 6 x 6 multidimensional array.
Dim matrix(5, 5) As Double

' Declare a 4 x 3 multidimensional array and set array element values.
Dim matrix = New Integer(,) {{1, 2, 3}, {2, 3, 4}, {3, 4, 5}, {4, 5, 6}}

' Declare a jagged array
Dim sales()() As Double = New Double(11)() {}

Éléments de tableau dans un tableau simple

Nous allons créer un tableau nommé students pour stocker le nombre d’étudiants de chaque année dans une école de grammaire. Les index des éléments sont comprises entre 0 et 6. L’utilisation de ce tableau est plus simple que la déclaration de sept variables.

L’illustration suivante montre le students tableau. Pour chaque élément du tableau :

  • L’index de l’élément représente la note (l’index 0 représente la maternelle).

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

Diagramme montrant un tableau des nombres d’étudiants

L’exemple suivant contient le code Visual Basic qui crée et utilise le tableau :


Module SimpleArray
   Public Sub Main()
      ' Declare an array with 7 elements.
      Dim students(6) As Integer

      ' Assign values to each element.
      students(0) = 23
      students(1) = 19
      students(2) = 21
      students(3) = 17
      students(4) = 19
      students(5) = 20
      students(6) = 22
      
      ' Display the value of each element.
      For ctr As Integer = 0 To 6
         Dim grade As String = If(ctr = 0, "kindergarten", $"grade {ctr}")
         Console.WriteLine($"Students in {grade}: {students(ctr)}")
      Next
   End Sub
End Module
' The example displays the following output:
'     Students in kindergarten: 23
'     Students in grade 1: 19
'     Students in grade 2: 21
'     Students in grade 3: 17
'     Students in grade 4: 19
'     Students in grade 5: 20
'     Students in grade 6: 22

L’exemple effectue trois opérations :

  • Il déclare un students tableau avec sept éléments. Le nombre 6 dans la déclaration de tableau indique le dernier index du tableau ; il s’agit d’un nombre inférieur au nombre d’éléments du tableau.
  • Il affecte des valeurs à chaque élément du tableau. Les éléments de tableau sont accessibles à l’aide du nom du tableau et y compris l’index de l’élément individuel entre parenthèses.
  • Elle répertorie chaque valeur du tableau. L’exemple utilise une For instruction pour accéder à chaque élément du tableau par son numéro d’index.

Le students tableau de l’exemple précédent est un tableau unidimensionnel, car il utilise un index. Un tableau qui utilise plusieurs index ou indices est appelé multidimensionnel. Pour plus d’informations, consultez le reste de cet article et les dimensions de tableau en Visual Basic.

Création d’un tableau

Vous pouvez définir la taille d’un tableau de plusieurs façons :

  • Vous pouvez spécifier la taille lorsque le tableau est déclaré :

    ' Declare an array with 10 elements.
    Dim cargoWeights(9) As Double               
    ' Declare a 24 x 2 array.
    Dim hourlyTemperatures(23, 1) As Integer
    ' Declare a jagged array with 31 elements.
    Dim januaryInquiries(30)() As String
    
  • Vous pouvez utiliser une New clause pour fournir la taille d’un tableau lors de sa création :

    ' Declare an array with 10 elements.
    Dim cargoWeights() As Double = New Double(9) {}
    ' Declare a 24 x 2 array.
    Dim hourlyTemperatures(,) As Integer = New Integer(23, 1) {}
    ' Declare a jagged array with 31 elements. 
    Dim januaryInquiries()() As String = New String(30)() {}
    

Si vous avez un tableau existant, vous pouvez redéfinir sa taille à l’aide de l’instruction ReDim . Vous pouvez spécifier que l’instruction ReDim conserve les valeurs qui se trouvent dans le tableau, ou vous pouvez spécifier qu’elle crée un tableau vide. L’exemple suivant montre différentes utilisations de l’instruction ReDim pour modifier la taille d’un tableau existant.

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

Pour plus d’informations, consultez l’instruction ReDim.

Stockage de valeurs dans un tableau

Vous pouvez accéder à chaque emplacement d’un tableau à l’aide d’un index de type Integer. Vous pouvez stocker et récupérer des valeurs dans un tableau en référençant chaque emplacement de tableau à l’aide de son index placé entre parenthèses. Les index des tableaux multidimensionnels sont séparés par des virgules (,). Vous avez besoin d’un index pour chaque dimension de tableau.

L’exemple suivant montre certaines instructions qui stockent et récupèrent des valeurs dans des tableaux.


Module Example
   Public Sub Main()
      ' Create a 10-element integer array.
      Dim numbers(9) As Integer
      Dim value As Integer = 2
        
      ' Write values to it.
      For ctr As Integer = 0 To 9
         numbers(ctr) = value
         value *= 2
      Next
        
      ' Read and sum the array values.  
      Dim sum As Integer
      For ctr As Integer = 0 To 9
         sum += numbers(ctr)
      Next
      Console.WriteLine($"The sum of the values is {sum:N0}")
    End Sub
End Module
' The example displays the following output:
'     The sum of the values is 2,046

Remplissage d’un tableau avec des littéraux de tableau

En utilisant un littéral de tableau, vous pouvez remplir un tableau avec un ensemble initial de valeurs en même temps que vous le créez. Un littéral de tableau se compose d’une liste de valeurs séparées par des virgules placées entre accolades ({}).

Lorsque vous créez un tableau à l’aide d’un littéral de tableau, vous pouvez fournir le type de tableau ou utiliser l’inférence de type pour déterminer le type de tableau. L’exemple suivant montre les deux options.

' Array literals with explicit type definition.
Dim numbers = New Integer() {1, 2, 4, 8}
' Array literals with type inference.
Dim doubles = {1.5, 2, 9.9, 18}
' Array literals with explicit type definition.
Dim articles() As String = { "the", "a", "an" }

' Array literals with explicit widening type definition.
Dim values() As Double = { 1, 2, 3, 4, 5 }

Lorsque vous utilisez l’inférence de type, le type du tableau est déterminé par le type dominant dans la liste des valeurs littérales. Le type dominant est le type auquel tous les autres types du tableau peuvent s’élargir. Si ce type unique ne peut pas être déterminé, le type dominant est le type unique auquel tous les autres types du tableau peuvent être étroits. Si aucun de ces types uniques ne peut être déterminé, le type dominant est Object. Par exemple, si la liste des valeurs fournies au littéral du tableau contient des valeurs de type Integer, Longet Doubleque le tableau obtenu est de type Double. Étant donné que Integer et Long s’élargir uniquement à Double, Double est le type dominant. Pour plus d’informations, consultez Widening and Narrowing Conversions.

Remarque

Vous pouvez utiliser l’inférence de type uniquement pour les tableaux définis comme variables locales dans un membre de type. Si une définition de type explicite est absente, les tableaux définis avec des littéraux de tableau au niveau de la classe sont de type Object[]. Pour plus d’informations, consultez l’inférence de type local.

Notez que l’exemple précédent définit values comme tableau de type Double même si tous les littéraux de tableau sont de type Integer. Vous pouvez créer ce tableau, car les valeurs du littéral du tableau peuvent s’élargir aux Double valeurs.

Vous pouvez également créer et remplir un tableau multidimensionnel à l’aide de littéraux de tableau imbriqués. Les littéraux de tableau imbriqués doivent avoir un certain nombre de dimensions cohérentes avec le tableau résultant. L’exemple suivant crée un tableau à deux dimensions d’entiers à l’aide de littéraux de tableau imbriqués.

' Create and populate a 2 x 2 array.
Dim grid1 = {{1, 2}, {3, 4}}
' Create and populate a 2 x 2 array with 3 elements.
Dim grid2(,) = {{1, 2}, {3, 4}, {5, 6}}

Lorsque vous utilisez des littéraux de tableau imbriqués pour créer et remplir un tableau, une erreur se produit si le nombre d’éléments dans les littéraux de tableau imbriqués ne correspond pas. Une erreur se produit également si vous déclarez explicitement la variable de tableau pour avoir un nombre différent de dimensions que les littéraux du tableau.

Tout comme vous pouvez pour les tableaux unidimensionnels, vous pouvez vous appuyer sur l’inférence de type lors de la création d’un tableau multidimensionnel avec des littéraux de tableau imbriqués. Le type déduit est le type dominant pour toutes les valeurs de tous les littéraux de tableau pour tout niveau d’imbrication. L’exemple suivant crée un tableau à deux dimensions de type Double[,] à partir de valeurs de type Integer et Double.

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

Pour obtenir des exemples supplémentaires, consultez Guide pratique pour initialiser une variable de tableau en Visual Basic.

Itération dans un tableau

Lorsque vous effectuez une itération au sein d’un tableau, vous accédez à chaque élément du tableau de l’index le plus bas vers le plus élevé ou du plus élevé au plus bas. En règle générale, utilisez l’une ou l’autre des options For... Instruction suivante ou For Each... Instruction suivante pour itérer au sein des éléments d’un tableau. Lorsque vous ne connaissez pas les limites supérieures du tableau, vous pouvez appeler la Array.GetUpperBound méthode pour obtenir la valeur la plus élevée de l’index. Bien que la valeur d’index la plus basse soit presque toujours 0, vous pouvez appeler la Array.GetLowerBound méthode pour obtenir la valeur la plus basse de l’index.

L’exemple suivant itère dans un tableau unidimensionnel à l’aide de l’instruction For...Next .


Module IterateArray
   Public Sub Main()
      Dim numbers = {10, 20, 30}

      For index = 0 To numbers.GetUpperBound(0)
         Console.WriteLine(numbers(index))
      Next
   End Sub
End Module
' The example displays the following output:
'  10
'  20
'  30

L’exemple suivant itère dans un tableau multidimensionnel à l’aide d’une For...Next instruction. La GetUpperBound méthode a un paramètre qui spécifie la dimension. GetUpperBound(0) retourne l’index le plus élevé de la première dimension et GetUpperBound(1) retourne l’index le plus élevé de la deuxième dimension.


Module IterateArray
   Public Sub Main()
      Dim numbers = {{1, 2}, {3, 4}, {5, 6}}

      For index0 = 0 To numbers.GetUpperBound(0)
         For index1 = 0 To numbers.GetUpperBound(1)
            Console.Write($"{numbers(index0, index1)} ")
         Next
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output:
' Output 
'  1 2 
'  3 4 
'  5 6

L’exemple suivant utilise un For Each... Instruction suivantepour itérer au sein d’un tableau unidimensionnel et d’un tableau à deux dimensions.


Module IterateWithForEach
   Public Sub Main()
      ' Declare and iterate through a one-dimensional array.
      Dim numbers1 = {10, 20, 30}
      
      For Each number In numbers1
         Console.WriteLine(number)
      Next
      Console.WriteLine()
      
      Dim numbers = {{1, 2}, {3, 4}, {5, 6}}

      For Each number In numbers
         Console.WriteLine(number)
      Next
   End Sub
End Module
' The example displays the following output:
'  10
'  20
'  30
'
'  1
'  2
'  3
'  4
'  5
'  6

Taille du tableau

La taille d’un tableau est le produit des longueurs de toutes ses dimensions. Il représente le nombre total d’éléments actuellement contenus dans le tableau. Par exemple, l’exemple suivant déclare un tableau 2 dimensions avec quatre éléments dans chaque dimension. Comme le montre la sortie de l’exemple, la taille du tableau est de 16 (ou (3 + 1) * (3 + 1).


Module Example
   Public Sub Main()
      Dim arr(3, 3) As Integer
      Console.WriteLine(arr.Length)     
   End Sub
End Module
' The example displays the following output:
'     16

Remarque

Cette discussion sur la taille du tableau ne s’applique pas aux tableaux en jaquet. Pour plus d’informations sur les tableaux en jaquet et sur la détermination de la taille d’un tableau en jagué, consultez la section Tableaux jagged .

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

Vous pouvez redimensionner une variable de tableau en lui attribuant un nouvel objet de tableau ou en utilisant l’instruction ReDim . L’exemple suivant utilise l’instruction ReDim pour modifier un tableau de 100 éléments en tableau de 51 éléments.


Module Example
   Public Sub Main()
      Dim arr(99) As Integer
      Console.WriteLine(arr.Length)
      
      Redim arr(50)
      Console.WriteLine(arr.Length)
   End Sub
End Module
' The example displays the following output:
'     100
'     51

 

Il y a plusieurs choses à garder à l’esprit lorsque vous traitez de la taille d’un tableau.

Remarques
Longueur de dimension L’index de chaque dimension est basé sur 0, ce qui signifie qu’il passe de 0 à sa limite supérieure. Par conséquent, la longueur d’une dimension donnée est supérieure à la limite supérieure déclarée de cette dimension.
Limites de longueur La longueur de chaque dimension d’un tableau est limitée à la valeur maximale du Integer type de données, qui est Int32.MaxValue ou (2 ^ 31) - 1. Toutefois, la taille totale d’un tableau est également limitée par la mémoire disponible sur votre système. Si vous tentez d’initialiser un tableau qui dépasse la quantité de mémoire disponible, le runtime lève un OutOfMemoryException.
Taille et taille de l’élément La taille d’un tableau est indépendante du type de données de ses éléments. La taille représente toujours le nombre total d’éléments, et non le nombre d’octets qu’ils consomment en mémoire.
Consommation de mémoire Il n’est pas sûr de faire des hypothèses concernant la façon dont un tableau est stocké en mémoire. Le stockage varie selon les plateformes de différentes largeurs de données, de sorte que le même tableau peut consommer plus de mémoire sur un système 64 bits que sur un système 32 bits. Selon la configuration du système lorsque vous initialisez un tableau, le Common Language Runtime (CLR) peut affecter le stockage aux éléments pack aussi proches que possible, ou pour les aligner sur les limites matérielles naturelles. En outre, un tableau nécessite une surcharge de stockage pour ses informations de contrôle, et cette surcharge augmente avec chaque dimension ajoutée.

Type de tableau

Chaque tableau a un type de données, qui diffère du type de données de ses éléments. Il n’existe aucun 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 de classement du tableau et le type de données des éléments du tableau. Deux variables de tableau sont du même type de données uniquement lorsqu’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 System.Array classe et vous pouvez déclarer une variable de type Array, mais vous ne pouvez pas créer un tableau de type Array. Par exemple, bien que le code suivant déclare que la arr variable doit être de type Array et appelle la Array.CreateInstance méthode pour instancier le tableau, le type du tableau s’avère être Object[].


Module Example
   Public Sub Main()
      Dim arr As Array = Array.CreateInstance(GetType(Object), 19)
      Console.WriteLine(arr.Length)
      Console.WriteLine(arr.GetType().Name)
   End Sub
End Module
' The example displays the following output:
'     19
'     Object[]

En outre, l’instruction ReDim ne peut pas fonctionner sur une variable déclarée comme type Array. Pour ces raisons, et pour la sécurité des types, il est conseillé de déclarer chaque tableau comme un type spécifique.

Vous pouvez trouver le type de données d’un tableau ou de ses éléments de plusieurs façons.

  • Vous pouvez appeler la GetType méthode sur la variable pour obtenir un Type objet qui représente le type d’exécution de la variable. L’objet Type contient des informations détaillées dans ses propriétés et méthodes.
  • Vous pouvez passer la variable à la TypeName fonction pour obtenir un String nom de type d’exécution.

L’exemple suivant appelle la GetType méthode et la TypeName fonction pour déterminer le type d’un tableau. Le type de tableau est Byte(,). Notez que la Type.BaseType propriété indique également que le type de base du tableau d’octets est la Array classe.


Module Example
   Public Sub Main()
      Dim bytes(9,9) As Byte
      Console.WriteLine($"Type of {nameof(bytes)} array: {bytes.GetType().Name}")
      Console.WriteLine($"Base class of {nameof(bytes)}: {bytes.GetType().BaseType.Name}")
      Console.WriteLine()
      Console.WriteLine($"Type of {nameof(bytes)} array: {TypeName(bytes)}")
   End Sub
End Module
' The example displays the following output:
' Type of bytes array: Byte[,]
' Base class of bytes: Array
' 
' Type of bytes array: Byte(,)


Tableaux en tant que valeurs et paramètres de retour

Pour renvoyer un tableau à partir d’une Function procédure, spécifiez le type de données de tableau et le nombre de dimensions comme type de retour de l’instruction de fonction. Dans la fonction, déclarez une variable de tableau locale avec le même type de données et le même nombre de dimensions. Dans l’instruction Return, incluez la variable de tableau locale sans parenthèses.

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

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


Module ReturnValuesAndParams
   Public Sub Main()
      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)
         Console.WriteLine($"{numbers(index)} ")
      Next
   End Sub
End Module
' The example displays the following output:
'   10
'   20
'   30
    

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


Module Example
   Public Sub Main()
      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)
            Console.Write($"{numbers(index0, index1)} ")
         Next
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output:
'     1 2
'     3 4
'     5 6

Tableaux en escalier

Parfois, la structure de données de votre application est à deux dimensions, mais pas rectangulaire. Par exemple, vous pouvez utiliser un tableau pour stocker des données sur la température élevée de chaque jour du mois. La première dimension du tableau représente le mois, mais la deuxième dimension représente le nombre de jours et le nombre de jours dans un mois n’est pas uniforme. Un tableau en jaquet, également appelé tableau de tableaux, est conçu pour de tels scénarios. Un tableau en jaquet est un tableau dont les éléments sont également des tableaux. Un tableau en jaquet et chaque élément d’un tableau en jaquet peut avoir une ou plusieurs dimensions.

L’exemple suivant utilise un tableau de mois, dont chaque élément est un tableau de jours. L’exemple utilise un tableau en jaquet, car différents mois ont différents nombres de jours. L’exemple montre comment créer un tableau en jaquet, lui attribuer des valeurs, puis récupérer et afficher ses valeurs.

Imports System.Globalization

Module JaggedArray
   Public Sub Main()
      ' Declare the jagged array of 12 elements. Each element is an array of Double.
      Dim sales(11)() As Double
      ' Set each element of the sales array to a Double array of the appropriate size.
      For month As Integer = 0 To 11
         ' The number of days in the month determines the appropriate size.
         Dim daysInMonth As Integer =
            DateTime.DaysInMonth(Year(Now), month + 1)
         sales(month) = New Double(daysInMonth - 1) {}
      Next 

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

      ' Retrieve and display the array values.
      Dim monthNames = DateTimeFormatInfo.CurrentInfo.AbbreviatedMonthNames
      ' Display the month names.
      Console.Write("    ")
      For ctr = 0 To sales.GetUpperBound(0)
         Console.Write($" {monthNames(ctr)}   ")
      Next   
      Console.WriteLine()
      ' Display data for each day in each month.
      For dayInMonth = 0 To 30
         Console.Write($"{dayInMonth + 1,2}.  ")
         For monthNumber = 0 To sales.GetUpperBound(0)
            If dayInMonth > sales(monthNumber).GetUpperBound(0) Then 
               Console.Write("       ")
            Else
               Console.Write($"{sales(monthNumber)(dayInMonth),-5}  ")
            End If
         Next   
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output:
'      Jan    Feb    Mar    Apr    May    Jun    Jul    Aug    Sep    Oct    Nov    Dec
'  1.  0      100    200    300    400    500    600    700    800    900    1000   1100
'  2.  1      101    201    301    401    501    601    701    801    901    1001   1101
'  3.  2      102    202    302    402    502    602    702    802    902    1002   1102
'  4.  3      103    203    303    403    503    603    703    803    903    1003   1103
'  5.  4      104    204    304    404    504    604    704    804    904    1004   1104
'  6.  5      105    205    305    405    505    605    705    805    905    1005   1105
'  7.  6      106    206    306    406    506    606    706    806    906    1006   1106
'  8.  7      107    207    307    407    507    607    707    807    907    1007   1107
'  9.  8      108    208    308    408    508    608    708    808    908    1008   1108
' 10.  9      109    209    309    409    509    609    709    809    909    1009   1109
' 11.  10     110    210    310    410    510    610    710    810    910    1010   1110
' 12.  11     111    211    311    411    511    611    711    811    911    1011   1111
' 13.  12     112    212    312    412    512    612    712    812    912    1012   1112
' 14.  13     113    213    313    413    513    613    713    813    913    1013   1113
' 15.  14     114    214    314    414    514    614    714    814    914    1014   1114
' 16.  15     115    215    315    415    515    615    715    815    915    1015   1115
' 17.  16     116    216    316    416    516    616    716    816    916    1016   1116
' 18.  17     117    217    317    417    517    617    717    817    917    1017   1117
' 19.  18     118    218    318    418    518    618    718    818    918    1018   1118
' 20.  19     119    219    319    419    519    619    719    819    919    1019   1119
' 21.  20     120    220    320    420    520    620    720    820    920    1020   1120
' 22.  21     121    221    321    421    521    621    721    821    921    1021   1121
' 23.  22     122    222    322    422    522    622    722    822    922    1022   1122
' 24.  23     123    223    323    423    523    623    723    823    923    1023   1123
' 25.  24     124    224    324    424    524    624    724    824    924    1024   1124
' 26.  25     125    225    325    425    525    625    725    825    925    1025   1125
' 27.  26     126    226    326    426    526    626    726    826    926    1026   1126
' 28.  27     127    227    327    427    527    627    727    827    927    1027   1127
' 29.  28            228    328    428    528    628    728    828    928    1028   1128
' 30.  29            229    329    429    529    629    729    829    929    1029   1129
' 31.  30            230           430           630    730           930           1130

L’exemple précédent affecte des valeurs au tableau en jaquet sur une base d’élément par élément à l’aide d’une For...Next boucle. Vous pouvez également affecter des valeurs aux éléments d’un tableau en jagué à l’aide de littéraux de tableau imbriqués. Toutefois, la tentative d’utilisation de littéraux de tableau imbriqués (par exemple) Dim valuesjagged = {{1, 2}, {2, 3, 4}}génère une erreur du compilateur BC30568. Pour corriger l’erreur, placez les littéraux de tableau interne entre parenthèses. Les parenthèses forcent l’expression littérale du tableau à évaluer et les valeurs résultantes sont utilisées avec le littéral de tableau externe, comme l’illustre l’exemple suivant.


Module Example
   Public Sub Main()
      Dim values1d = { 1, 2, 3 }
      Dim values2d = {{1, 2}, {2, 3}, {3, 4}}
      Dim valuesjagged = {({1, 2}), ({2, 3, 4})}
   End Sub
End Module

Un tableau en jaquet est un tableau unidimensionnel dont les éléments contiennent des tableaux. Par conséquent, la Array.Length propriété et la Array.GetLength(0) méthode retournent le nombre d’éléments dans le tableau unidimensionnel et Array.GetLength(1) lève un IndexOutOfRangeException car un tableau en jaquet n’est pas multidimensionnel. Vous déterminez le nombre d’éléments dans chaque sous-tableau en récupérant la valeur de la propriété de Array.Length chaque sous-tableau. L’exemple suivant montre comment déterminer le nombre d’éléments dans un tableau en jaquet.


Module Example
   Public Sub Main()
      Dim jagged = { ({1, 2}), ({2, 3, 4}), ({5, 6}), ({7, 8, 9, 10}) }
      Console.WriteLine($"The value of jagged.Length: {jagged.Length}.")
      Dim total = jagged.Length
      For ctr As Integer = 0 To jagged.GetUpperBound(0)
         Console.WriteLine($"Element {ctr + 1} has {jagged(ctr).Length} elements.") 
         total += jagged(ctr).Length 
      Next
      Console.WriteLine($"The total number of elements in the jagged array: {total}")
   End Sub
End Module
' The example displays the following output:
'     The value of jagged.Length: 4.
'     Element 1 has 2 elements.
'     Element 2 has 3 elements.
'     Element 3 has 2 elements.
'     Element 4 has 4 elements.
'     The total number of elements in the jagged array: 15

Tableaux de longueur nulle

Visual Basic différencie un tableau non initialisé (tableau dont la valeur est Nothing) et un tableau de longueur nulle ou vide (tableau qui n’a aucun élément).) Un tableau non initialisé est un tableau qui n’a pas été dimensionné ou qui a eu des valeurs qui lui ont été attribuées. Par exemple:

Dim arr() As String

Un tableau de longueur nulle est déclaré avec une dimension de -1. Par exemple:

Dim arrZ(-1) As String

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

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

  • Vous souhaitez simplifier votre code en n’ayant pas à vérifier Nothing comme cas particulier.

  • Votre code interagit avec une interface de programmation d’application (API) qui vous oblige à passer un tableau de longueur nulle à une ou plusieurs procédures ou retourne un tableau de longueur nulle d’une ou plusieurs procédures.

Fractionnement d’un tableau

Dans certains cas, vous devrez peut-être fractionner un tableau unique en plusieurs tableaux. Cela implique d’identifier le point ou les points à partir desquels le tableau doit être fractionné, puis de cracher le tableau en deux ou plusieurs tableaux distincts.

Remarque

Cette section ne traite pas du fractionnement d’une seule chaîne en tableau de chaînes en fonction d’un délimiteur. Pour plus d’informations sur le fractionnement d’une chaîne, consultez la String.Split méthode.

Les critères les plus courants pour fractionner un tableau sont les suivants :

  • Nombre d’éléments dans le tableau. Par exemple, vous pouvez fractionner un tableau de plus qu’un nombre spécifié d’éléments en un certain nombre de parties approximativement égales. À cet effet, vous pouvez utiliser la valeur retournée par la ou Array.GetLength la Array.Length méthode.

  • Valeur d’un élément, qui sert de délimiteur qui indique où le tableau doit être fractionné. Vous pouvez rechercher une valeur spécifique en appelant les méthodes et Array.FindLastIndex les Array.FindIndex méthodes.

Une fois que vous avez déterminé l’index ou les index auxquels le tableau doit être fractionné, vous pouvez ensuite créer les tableaux individuels en appelant la Array.Copy méthode.

L’exemple suivant fractionne un tableau en deux tableaux d’une taille approximativement égale. (Si le nombre total d’éléments de tableau est impair, le premier tableau a un élément plus que le second.)


Module Example
   Public Sub Main()
      ' Create an array of 100 elements.
      Dim arr(99) As Integer
      ' Populate the array.
      Dim rnd As new Random()
      For ctr = 0 To arr.GetUpperBound(0)
         arr(ctr) = rnd.Next()
      Next
      
      ' Determine how many elements should be in each array.
      Dim divisor = 2
      Dim remainder As Integer
      Dim boundary = Math.DivRem(arr.GetLength(0), divisor, remainder)
            
      ' Copy the array.
      Dim arr1(boundary - 1 + remainder), arr2(boundary - 1) as Integer
      Array.Copy(arr, 0, arr1, 0, boundary + remainder)
      Array.Copy(arr, boundary + remainder, arr2, 0, arr.Length - boundary) 
   End Sub
End Module

L’exemple suivant fractionne un tableau de chaînes en deux tableaux en fonction de la présence d’un élément dont la valeur est « zzz », qui sert de délimiteur de tableau. Les nouveaux tableaux n’incluent pas l’élément qui contient le délimiteur.


Module Example
   Public Sub Main()
      Dim rnd As New Random()
      
      ' Create an array of 100 elements.
      Dim arr(99) As String
      ' Populate each element with an arbitrary ASCII character.
      For ctr = 0 To arr.GetUpperBound(0)
         arr(ctr) = ChrW(Rnd.Next(&h21, &h7F))
      Next
      ' Get a random number that will represent the point to insert the delimiter.
      arr(rnd.Next(0, arr.GetUpperBound(0))) = "zzz"

      ' Find the delimiter.
      Dim location = Array.FindIndex(arr, Function(x) x = "zzz")

      ' Create the arrays.
      Dim arr1(location - 1) As String
      Dim arr2(arr.GetUpperBound(0) - location - 1) As String
      
      ' Populate the two arrays.
      Array.Copy(arr, 0, arr1, 0, location)
      Array.Copy(arr, location + 1, arr2, 0, arr.GetUpperBound(0) - location)
   End Sub
End Module

Jointure de tableaux

Vous pouvez également combiner un certain nombre de tableaux en un seul tableau plus grand. Pour ce faire, vous utilisez également la Array.Copy méthode.

Remarque

Cette section ne traite pas de la jointure d’un tableau de chaînes dans une seule chaîne. Pour plus d’informations sur la jointure d’un tableau de chaînes, consultez la String.Join méthode.

Avant de copier les éléments de chaque tableau dans le nouveau tableau, vous devez d’abord vous assurer que vous avez initialisé le tableau afin qu’il soit suffisamment grand pour prendre en charge le nouveau tableau. Vous pouvez effectuer cette opération de deux manières :

  • Utilisez l’instruction ReDim Preserve pour développer dynamiquement le tableau avant d’y ajouter de nouveaux éléments. Il s’agit de la technique la plus simple, mais elle peut entraîner une dégradation des performances et une consommation excessive de mémoire lorsque vous copiez de grands tableaux.
  • Calculez le nombre total d’éléments nécessaires pour le nouveau tableau volumineux, puis ajoutez-y les éléments de chaque tableau source.

L’exemple suivant utilise la deuxième approche pour ajouter quatre tableaux avec dix éléments chacun à un tableau unique.

Imports System.Collections.Generic
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim tasks As New List(Of Task(Of Integer()))
      ' Generate four arrays.
      For ctr = 0 To 3
         Dim value = ctr
         tasks.Add(Task.Run(Function()
                               Dim arr(9) As Integer
                               For ndx = 0 To arr.GetUpperBound(0)
                                  arr(ndx) = value
                               Next
                               Return arr
                            End Function))   
       Next
       Task.WaitAll(tasks.ToArray())
       ' Compute the number of elements in all arrays.
       Dim elements = 0
       For Each task In tasks
          elements += task.Result.Length
       Next
       Dim newArray(elements - 1) As Integer
       Dim index = 0
       For Each task In tasks
          Dim n = task.Result.Length
          Array.Copy(task.Result, 0, newArray, index, n)
          index += n
       Next 
      Console.WriteLine($"The new array has {newArray.Length} elements.")
   End Sub
End Module
' The example displays the following output:
'     The new array has 40 elements.

Étant donné que dans ce cas, les tableaux sources sont tous petits, nous pouvons également développer dynamiquement le tableau à mesure que nous ajoutons les éléments de chaque nouveau tableau à celui-ci. L’exemple suivant le fait.

Imports System.Collections.Generic
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim tasks As New List(Of Task(Of Integer()))
      ' Generate four arrays.
      For ctr = 0 To 3
         Dim value = ctr
         tasks.Add(Task.Run(Function()
                               Dim arr(9) As Integer
                               For ndx = 0 To arr.GetUpperBound(0)
                                  arr(ndx) = value
                               Next
                               Return arr
                            End Function))   
       Next
       Task.WaitAll(tasks.ToArray())

       ' Dimension the target array and copy each element of each source array to it.
       Dim newArray() As Integer = {}
       ' Define the next position to copy to in newArray.
       Dim index = 0
       For Each task In tasks
          Dim n = Task.Result.Length
          ReDim Preserve newArray(newArray.GetUpperBound(0) + n)
          Array.Copy(task.Result, 0, newArray, index, n)
          index += n
       Next 
      Console.WriteLine($"The new array has {newArray.Length} elements.")
   End Sub
End Module
' The example displays the following output:
'     The new array has 40 elements.

Collections comme alternative aux tableaux

Les tableaux sont les plus utiles pour créer et utiliser un nombre fixe d’objets fortement typés. Les collections offrent un moyen plus flexible d’utiliser des groupes d’objets. Contrairement aux tableaux, qui nécessitent de modifier explicitement la taille d’un tableau avec l’instructionReDim, les collections augmentent et diminuent dynamiquement à mesure que les besoins d’une application changent.

Lorsque vous utilisez ReDim pour redimensionner un tableau, Visual Basic crée un tableau et libère le tableau précédent. Cela prend du temps d’exécution. Par conséquent, si le nombre d’éléments que vous utilisez avec des modifications fréquemment ou si vous ne pouvez pas prédire le nombre maximal d’éléments dont vous avez besoin, vous obtiendrez généralement de meilleures performances à l’aide d’une collection.

Pour certaines collections, vous pouvez affecter une clé à n’importe quel objet que vous avez placé dans la collection afin de pouvoir récupérer rapidement l’objet à l’aide de la clé.

Si votre collection contient des éléments d’un seul type de données, vous pouvez utiliser l’une des classes de l’espace System.Collections.Generic de noms. Une collection générique applique la sécurité des types afin qu’aucun autre type de données ne puisse être ajouté à celui-ci.

Pour plus d’informations sur les regroupements, consultez Collections.

Terme Définition
Dimensions de tableau en Visual Basic Explique le classement et les dimensions dans les tableaux.
Guide pratique pour initialiser une variable de tableau en Visual Basic Décrit comment remplir des tableaux avec des valeurs initiales.
Procédure : trier un tableau en Visual Basic Montre comment trier les éléments d’un tableau par ordre alphabétique.
Guide pratique pour affecter un tableau à un autre tableau Décrit les règles et les étapes d’affectation d’un tableau à une autre variable de tableau.
Résolution des problèmes liés aux tableaux Décrit certains problèmes courants qui surviennent lors de l’utilisation de tableaux.

Voir aussi