Tableaux dans Visual Basic
Un tableau est un ensemble de valeurs, appelées éléments, qui sont logiquement liées les unes aux autres. Par exemple, un tableau peut être constitué du nombre d’élèves dans chaque classe d’une école secondaire; chaque élément du tableau est le nombre d’étudiants dans une seule note. De même, un tableau peut être constitué des notes d’un élève pour une classe ; chaque élément du tableau est un seul grade.
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, englishGrade2, etc. Cette approche présente trois limitations majeures :
- Nous devons savoir au moment de la conception exactement combien de notes nous devons gérer.
- La gestion d’un grand nombre de notes devient rapidement difficile. Cela rend à son tour une application beaucoup plus susceptible d’avoir des bogues graves.
- Il est difficile à maintenir. Chaque nouvelle classe que nous ajoutons nécessite que l’application soit modifiée, recompilée et redéployée.
Un tableau vous permet de faire référence à ces valeurs connexes avec un même nom à l’aide d’un nombre appelé index ou indice afin d’identifier un élément individuel selon sa position dans le tableau. Les index d’un tableau sont compris entre 0 et un de moins que le nombre total d’éléments dans le 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 combien d’éléments il contient au moment de la conception.
Voici quelques exemples sommaires avant d’entrer dans les détails :
' 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
Créons un tableau s’appelant students pour stocker le nombre d’étudiants de chaque année dans une école de grammaire. Les index des éléments s’échelonnent de 0 à 6. Il est plus simple d’utiliser ce tableau que de déclarer sept variables.
L’illustration suivante pré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 niveau maternelle).
La valeur contenue dans l’élément représente le nombre d’élèves de cette catégorie.
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
studentstableau avec sept éléments. Le nombre6dans la déclaration de tableau indique le dernier index du tableau ; il est 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 en incluant l’index de l’élément individuel entre parenthèses.
- Il répertorie chaque valeur du tableau. L’exemple utilise une
Forinstruction 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 dit multidimensionnel. Pour plus d’informations, consultez la suite de cet article, ainsi que la page Array Dimensions in Visual Basic.
Création d’un tableau
Vous pouvez définir la taille d’un tableau de différentes manières :
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 StringVous pouvez utiliser une clause
Newpour indiquer la taille d’un tableau au moment de le créer :' 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 disposez déjà d’un tableau, vous pouvez redéfinir sa taille à l’aide de l’instruction ReDim . Vous pouvez faire en sorte que l’instruction ReDim garde les valeurs qui se trouvent dans le tableau ou qu’elle crée un tableau vide. L’exemple suivant montre les différentes utilisations possibles 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 en utilisant un index de type Integer. Vous pouvez stocker des valeurs dans un tableau et les récupérer par la suite en référençant chaque emplacement du tableau en utilisant son index entre parenthèses. Dans le cas des tableaux multidimensionnels, les index sont séparés par des virgules (,). Vous avez besoin d’un index pour chaque dimension de tableau.
Dans l’exemple suivant, des instructions 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 mise entre accolades ({}).
Quand vous créez un tableau en utilisant un littéral de tableau, vous pouvez soit indiquer le type du tableau, soit utiliser l’inférence de type pour déterminer le type du tableau. L’exemple suivant montre 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 }
Quand vous utilisez l’inférence de type, le type du tableau est déterminé par le type dominant dans la liste de valeurs littérales. Le type dominant est le type auquel tous les autres types de tableau peuvent s’étendre. 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 se réduire. Si aucun de ces types uniques ne peut être déterminé, le type dominant est Object. Par exemple, si la liste de valeurs fournie au littéral de tableau contient des valeurs de type Integer, Longet Double, le tableau qui en résulte est de type Double. Étant donné que Integer et Long s’étendent uniquement à Double, Double est le type dominant. Pour plus d’informations, consultez Widening and Narrowing Conversions.
Notes
Vous pouvez utiliser l’inférence de type uniquement pour les tableaux qui sont définis en tant que 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 Inférence de type de variable locale.
Notez que l’exemple précédent définit values comme un 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 de tableau peuvent s’élargir aux Double valeurs.
Vous pouvez également créer et remplir un tableau multidimensionnel en utilisant des littéraux de tableau imbriqués. Les littéraux de tableau imbriqués doivent avoir une un nombre de dimensions qui soient en cohérence avec le tableau obtenu. L’exemple suivant crée un tableau d’entiers à deux dimensions en utilisant un littéral de tableau imbriqué.
' 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 que la variable de tableau a un nombre de dimensions différent de celui des littéraux de tableau.
Tout comme 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 contenues dans les littéraux de tableau pour tout les niveaux d’imbrication. Dans l’exemple suivant, un tableau à deux dimensions de type Double[,] est créé à 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 Comment : initialiser une variable tableau en Visual Basic.
Itération au sein d’un tableau
Quand vous itérez au sein d’un tableau, vous accédez à chaque élément du tableau de l’index le plus bas jusqu’au plus haut ou depuis le plus haut jusqu’au plus bas. En règle générale, utilisez l’option For... Next Statement ou For Each... Next Instruction 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 égale à 0, vous pouvez appeler la Array.GetLowerBound méthode pour obtenir la valeur la plus basse de l’index.
L’exemple suivant itère au sein d’un tableau unidimensionnel en utilisant 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 au sein d’un tableau multidimensionnel en utilisant une instruction For...Next . La méthode GetUpperBound dispose d’un paramètre qui spécifie la dimension. GetUpperBound(0) retourne l’index la plus haute pour la première dimension et GetUpperBound(1) retourne la valeur d’index la plus haute pour la deuxième.
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... Next Instructionpour 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 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 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
Notes
Cette description de la taille du tableau ne s’applique pas aux tableaux déchiquetés. Pour plus d’informations sur les tableaux déchiquetés et sur la détermination de la taille d’un tableau déchiqueté, consultez la section Tableaux déchiquetés .
Vous pouvez trouver la taille d’un tableau en utilisant la propriété Array.Length. Vous pouvez trouver la longueur de chaque dimension d’un tableau multidimensionnel en utilisant la méthode Array.GetLength .
Vous pouvez redimensionner une variable tableau en lui assignant un nouvel objet tableau ou en utilisant l’instruction ReDim Instruction. L’exemple suivant utilise l’instruction ReDim pour remplacer un tableau de 100 éléments par un 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 points à prendre en compte en ce qui concerne la taille d’un tableau.
| Notes | |
|---|---|
| Longueur de dimension | L’index de chaque dimension est basé sur 0, ce qui signifie qu’il varie de 0 à sa limite supérieure. Par conséquent, la longueur d’une dimension donnée est supérieure de un à la limite supérieure déclarée pour cette dimension. |
| Limites de longueur | La longueur de chaque dimension d’un tableau est limitée à la valeur maximale du type de données Integer, à savoir Int32.MaxValue ou (2 ^ 31) - 1. Cependant, la taille totale d’un tableau est aussi limitée par la mémoire disponible sur votre système. Si vous essayez d’initialiser un tableau qui dépasse la quantité de mémoire runtime disponible lève une OutOfMemoryException. |
| Taille et taille d’é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 occupent dans la mémoire. |
| Consommation de mémoire | Il est déconseillé de faire des hypothèses sur la façon dont un tableau est stocké en mémoire. Le stockage varie selon la largeur de données de la plateforme. Par exemple, un même tableau utilise plus de mémoire sur un système 64 bits que sur un système 32 bits. Selon la configuration du système au moment de l’initialisation d’un tableau, le Common Language Runtime (CLR) peut assigner du stockage de façon à regrouper les éléments aussi près que possible les uns des autres ou pour tous les adapter aux limites matérielles naturelles. De même, un tableau nécessite un supplément de stockage pour ses informations de contrôle, un supplément qui augmente d’autant à chaque dimension ajoutée. |
Le type de tableau
À chaque tableau correspond un type de données, et celui-ci se distingue du type de données de ses éléments. Le type de données varie d’un tableau à un autre. En effet, le type de données d’un tableau est déterminé par le nombre de dimensions (ou rang) qu’il possède et par le type de données de ses éléments. Deux variables tableau sont au même type de données que si elles ont le même rang et si leurs éléments ont le même type de données. Les longueurs des dimensions d’un tableau n’influent pas sur le type de données du tableau.
Chaque tableau hérite de la classe System.Array 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 est 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[]
De même, l’instruction ReDim ne peut pas opérer sur une variable déclarée comme étant du type Array. Pour ces raisons et au titre de la cohérence des types, il est recommandé de déclarer chaque tableau en tant que type spécifique.
Vous pouvez déterminer le type de données d’un tableau ou de ses éléments de plusieurs façons.
- Vous pouvez appeler la méthode GetType sur la variable pour avoir un objet Type représentant le type au moment de l’exécution de la variable. 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 avoir un
Stringavec le nom du type au moment de l’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 de retour et paramètres
Pour retourner un tableau à partir d’une procédure Function, spécifiez le type de données du tableau et le nombre de dimensions en tant que type de retour de l’instruction Function. Dans la fonction, déclarez une variable tableau locale avec le même type de données et le même nombre de dimensions. Dans l’instruction Return, incluez la variable tableau locale sans parenthèses.
Pour spécifier un tableau en tant que paramètre d’une procédure Sub ou Function , 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 de la procédure, faire passer une variable 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(), un tableau unidimensionnel de type Integer. La procédure ShowNumbers accepte un argument Integer() .
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(,), un tableau duo-dimensionnel de type Integer. La procédure ShowNumbersMultiDim accepte un argument Integer(,) .
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 d’un mois n’est pas uniforme. Un tableau déchiqueté, également appelé tableau de tableaux, est conçu pour de tels scénarios. Un tableau en escalier est un tableau dont les éléments sont également des tableaux. Un tableau en escalier et chaque élément qu’il contient 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 déchiqueté, car différents mois ont des nombres de jours différents. L’exemple montre comment créer un tableau déchiqueté, lui attribuer des valeurs et 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 déchiqueté sur une base é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 déchiqueté à 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 l’erreur du compilateur BC30568. Pour corriger l’erreur, placez les littéraux du tableau interne entre parenthèses. Les parenthèses forcent l’évaluation de l’expression de littéral de tableau, et les valeurs obtenues 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 escalier est un tableau unidimensionnel avec ces éléments contenant 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èvent un IndexOutOfRangeException , car un tableau déchiqueté n’est pas multidimensionnel. Vous déterminez le nombre d’éléments dans chaque sous-liste 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 déchiqueté.
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 zéro
Visual Basic fait la distinction entre un tableau non initialisé (un tableau dont la valeur est Nothing) et un tableau de longueur nulle ou vide (un tableau qui n’a aucun élément).) Un tableau non initialisé est un tableau qui n’a pas été dimensionné ou auquel des valeurs lui ont été affecté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 pouvez être amené à créer un tableau de longueur zéro dans les cas suivants :
Sans risquer une exception NullReferenceException , votre code doit accéder aux membres de la classe Array , tels que Length ou Rank, ou appeler une fonction Visual Basic , telle que UBound.
Vous tenez à ce que votre code reste simple en n’ayant pas à vérifier la présence de
Nothingcomme un cas particulier.Votre code interagit avec une interface de programmation d’applications (API) qui vous oblige à passer un tableau de longueur zéro à une ou plusieurs procédures ou qui retourne un tableau de longueur zéro à partir 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 ou les points auxquels le tableau doit être fractionné, puis de le cracher en deux tableaux distincts ou plus.
Notes
Cette section ne traite pas de la division d’une chaîne unique en un tableau de chaînes basé sur 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 d’un nombre spécifié d’éléments en un nombre d’éléments à peu près égal. À cette fin, vous pouvez utiliser la valeur retournée par la Array.Length méthode ou Array.GetLength .
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 Array.FindIndex méthodes et Array.FindLastIndex .
Une fois que vous avez déterminé l’index ou les index auxquels le tableau doit être fractionné, vous pouvez créer les tableaux individuels en appelant la Array.Copy méthode .
L’exemple suivant divise un tableau en deux tableaux de taille approximativement égale. (Si le nombre total d’éléments de tableau est impair, le premier tableau a un élément de plus que le deuxième.)
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 divise 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 méthode Array.Copy.
Notes
Cette section ne traite pas de la jonction d’un tableau de chaînes en 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 le faire de deux façons :
- Utilisez l’instruction
ReDim Preservepour 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 grand tableau, puis ajoutez-y les éléments de chaque tableau source.
L’exemple suivant utilise la deuxième approche pour ajouter quatre tableaux de 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 y ajoutons les éléments de chaque nouveau tableau. L’exemple suivant effectue cette opération.
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.
Les collections comme alternative aux tableaux
Les tableaux s’avèrent particulièrement utiles pour créer et utiliser un nombre fixe d’objets fortement typés. Les collections offrent plus de souplesse quand il s’agit d’utiliser des groupes d’objets. Contrairement aux tableaux, qui nécessitent de modifier explicitement la taille d’un tableau avec l’instruction, les ReDim Instructioncollections augmentent et se réduisent 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 change régulièrement ou si vous ne pouvez pas prédire le nombre maximal d’éléments dont vous avez besoin, une collection vous procureras habituellement de meilleures performances.
Pour certaines collections, vous pouvez assigner une clé à un objet que vous placez dans la collection pour vous permettre de 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 une des classes dans l’espace de noms System.Collections.Generic. Une collection générique applique la cohérence des types pour éviter qu’un autre type puisse y être ajouté.
Pour plus d’informations sur les collections, consultez Collections.
Rubriques connexes
| Terme | Définition |
|---|---|
| Array Dimensions in Visual Basic | Explique le rang et les dimensions des tableaux. |
| Comment : initialiser une variable tableau en Visual Basic | Explique comment remplir les tableaux de valeurs initiales. |
| Comment : trier un tableau dans Visual Basic | Montre comment trier les éléments d’un tableau par ordre alphabétique. |
| Comment : assigner un tableau à un autre tableau | Décrit les règles et les étapes à suivre pour assigner un tableau à une autre variable tableau. |
| Résolution des problèmes de tableaux | Décrit des problèmes courants qui surviennent dans le cadre de l’utilisation de tableaux. |
Voir aussi
Commentaires
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour