Pole v jazyce Visual Basic

Pole je sada hodnot, které jsou výrazy, které jsou logicky vzájemně propojené. Pole může například sestávat z počtu studentů v každé třídě v gramatické škole; Každý prvek pole je počet studentů v jedné třídě. Podobně může pole sestávat ze tříd studenta pro třídu; Každý prvek pole je jednou ze stupňů.

Je možné použít jednotlivé proměnné pro uložení každé z našich datových položek. Například pokud naše aplikace analyzuje třídy studenta, můžeme použít samostatnou proměnnou pro každou třídu studenta, jako englishGrade1 je například, englishGrade2 atd. Tento přístup má tři hlavní omezení:

• V době návrhu musíme přesně zjistit, kolik stupňů potřebujeme zpracovat.
• Rychlé zpracování velkého počtu druhů se nepraktický. Tím dojde k tomu, že aplikace bude mnohem pravděpodobnější, že bude mít vážné chyby.
• Údržbu je obtížné. Každou novou třídu, kterou přidáváme, vyžaduje, aby se aplikace upravila, znovu zkompiluje a znovu nasadila.

Pomocí pole můžete odkazovat na tyto související hodnoty se stejným názvem a použít číslo, které se nazývá index nebo dolní index k identifikaci jednotlivého prvku na základě jeho pozice v poli. Indexy rozsahu pole od 0 do jednoho menšího než celkový počet prvků v poli. použijete-li syntaxi Visual Basic k definování velikosti pole, určíte jeho nejvyšší index, nikoli celkový počet prvků v poli. S polem můžete pracovat jako s jednotkou a možnost iterovat své prvky je nepotřebné k tomu, abyste přesně věděli, kolik prvků obsahuje v době návrhu.

Některé rychlé příklady před vysvětlením:

' 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(3, 2) {{1, 2, 3}, {2, 3, 4}, {3, 4, 5}, {4, 5, 6}}

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

Prvky pole v jednoduchém poli

Pojďme vytvořit pole s názvem students pro uložení počtu studentů v každé třídě v gramatické škole. Indexy prvků jsou v rozsahu od 0 do 6. Použití tohoto pole je jednodušší než deklarace sedmi proměnných.

Následující ilustrace znázorňuje students pole. Pro každý prvek pole:

• Index elementu reprezentuje třídu (index 0 představuje kindergarten).

• Hodnota, která je obsažena v elementu, představuje počet studentů v této třídě.

následující příklad obsahuje kód Visual Basic, který vytváří a používá pole:

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

Příklad provádí tři věci:

• Deklaruje students pole s sedmi prvky. Číslo 6 v deklaraci pole označuje poslední index v poli, je menší než počet prvků v poli.
• Přiřadí hodnoty každému prvku v poli. K prvkům pole se dostanete pomocí názvu pole a zahrnutím indexu jednotlivého prvku do závorek.
• Obsahuje seznam všech hodnot pole. V příkladu se používá For příkaz pro přístup k jednotlivým prvkům pole podle jeho čísla indexu.

studentsPole v předchozím příkladu je jednorozměrné pole, protože používá jeden index. Pole, které používá více než jeden index nebo dolní index, je označováno jako multidimenzionální. Další informace najdete v tématu zbývající část tohoto článku a rozměry pole v Visual Basic.

Vytvoření pole

Velikost pole můžete definovat několika způsoby:

• Můžete určit velikost při deklaraci pole:

  ' 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
  

• Můžete použít New klauzuli k poskytnutí velikosti pole při jeho vytvoření:

  ' 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)() {}
  

Máte-li existující pole, lze jeho velikost změnit pomocí ReDim příkazu. Můžete určit, že ReDim příkaz zachová hodnoty, které jsou v poli, nebo můžete určit, že vytvoří prázdné pole. Následující příklad ukazuje různá použití ReDim příkazu pro úpravu velikosti existujícího pole.

' 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)

Další informace naleznete v příkazu ReDim.

Ukládání hodnot do pole

Ke každému umístění v poli můžete přistupovat pomocí indexu typu Integer . Můžete uložit a načíst hodnoty v poli odkazem na každé umístění pole pomocí jeho indexu uzavřeného v závorkách. Indexy multidimenzionálních polí jsou odděleny čárkami (,). Pro každou dimenzi pole potřebujete jeden index.

Následující příklad ukazuje některé příkazy, které ukládají a načítají hodnoty v polích.

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

Naplnění pole pomocí literálů pole

Pomocí literálu pole lze naplnit pole počáteční sadou hodnot ve stejnou dobu, kterou vytvoříte. Literál pole se skládá ze seznamu hodnot oddělených čárkami, které jsou uzavřeny ve složených závorkách ( {} ).

Při vytváření pole pomocí literálu pole můžete buď zadat typ pole nebo použít odvození typu k určení typu pole. Následující příklad ukazuje obě možnosti.

' 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 }

Při použití odvození typu je typ pole určen dominantním typem v seznamu hodnot literálů. Dominantní typ je typ, na který lze rozšířit všechny ostatní typy v poli. Pokud tento jedinečný typ nelze určit, dominantní typ je jedinečný typ, na který mohou být zúženy všechny ostatní typy v poli. Pokud ani jeden z těchto jedinečných typů nelze určit, dominantní typ je Object . Například pokud seznam hodnot, které jsou zadány do literálu pole, obsahuje hodnoty typu Integer , Long , a Double výsledné pole je typu Double . Protože Integer a Long rozšíření pouze na Double , Double je dominantní typ. Další informace najdete v tématu rozšiřování a zúžení převodů.

Všimněte si, že předchozí příklad definuje values jako pole typu, Double i když všechny literály pole jsou typu Integer . Toto pole lze vytvořit, protože hodnoty v literálu pole lze rozšířit na Double hodnoty.

Můžete také vytvořit a naplnit multidimenzionální pole pomocí literálů vnořeného pole. Literály vnořeného pole musí obsahovat řadu dimenzí, které jsou konzistentní s výsledným polem. Následující příklad vytvoří dvojrozměrné pole celých čísel pomocí literálů vnořeného pole.

' 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}}

Při použití literálů vnořeného pole k vytvoření a naplnění pole dojde k chybě, pokud se počet prvků v literálech vnořeného pole neshoduje. K chybě dojde také v případě, že explicitně deklarujete proměnnou pole tak, aby měla jiný počet rozměrů než literály pole.

Stejně jako u jednorozměrného pole lze při vytváření multidimenzionálního pole s literály vnořeného pole spoléhat na odvození typu. Odvozený typ je dominantní typ pro všechny hodnoty ve všech literálech pole pro všechny úrovně vnoření. Následující příklad vytvoří dvourozměrné pole typu Double[,] z hodnot, které jsou typu Integer a Double .

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

Další příklady naleznete v tématu How to: Initialize a Array Variable in Visual Basic.

Iterace prostřednictvím pole

Při iteraci přes pole přistupujete ke každému prvku v poli z nejnižší index na nejvyšší nebo od nejvyšších po nejnižší. Obvykle použijte buď pro... Další příkaz nebo pro každý... Další příkaz pro iteraci prvky pole. Pokud neznáte horní meze pole, můžete zavolat Array.GetUpperBound metodu pro získání nejvyšší hodnoty indexu. I když nejnižší hodnota indexu je skoro vždycky 0, můžete zavolat Array.GetLowerBound metodu, abyste získali nejnižší hodnotu indexu.

Následující příklad projde jednorozměrné pole pomocí For...Next příkazu.

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

Následující příklad provede iteraci multidimenzionálního pole pomocí For...Next příkazu. GetUpperBoundMetoda má parametr, který určuje dimenzi. GetUpperBound(0) Vrátí nejvyšší index prvního rozměru a GetUpperBound(1) vrátí nejvyšší index druhé dimenze.

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

Následující příklad používá pro každý... Další příkazpro iterování pomocí jednorozměrného pole a dvojrozměrného pole.

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

Velikost pole

Velikost pole je součinem délek všech jeho rozměrů. Představuje celkový počet prvků, které jsou aktuálně obsaženy v poli. Například následující příklad deklaruje dvojrozměrné pole se čtyřmi prvky v každé dimenzi. Jak ukazuje výstup z příkladu, je velikost pole 16 (nebo (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

Velikost pole můžete najít pomocí Array.Length Vlastnosti. Délku každé dimenze multidimenzionálního pole lze najít pomocí Array.GetLength metody.

Můžete změnit velikost proměnné pole přiřazením nového objektu Array k poli nebo pomocí příkazu ReDim příkazu . Následující příklad používá ReDim příkaz ke změně pole 100 elementu na pole 51-element.

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

 

Při práci s velikostí pole je potřeba mít na paměti několik věcí.

Typ pole

Každé pole má datový typ, který se liší od datového typu jeho prvků. Pro všechna pole není k dispozici žádný jediný datový typ. Místo toho se datový typ pole určuje podle počtu rozměrů nebo pořadí, pole a datového typu prvků v poli. Dvě proměnné pole jsou stejného datového typu pouze v případě, že mají stejný rozsah a jejich prvky mají stejný datový typ. Délky rozměrů pole neovlivňují datový typ pole.

Každé pole dědí z System.Array třídy a můžete deklarovat proměnnou, která má být typu Array , ale nelze vytvořit pole typu Array . Například Přestože následující kód deklaruje arr proměnnou jako typ Array a volá Array.CreateInstance metodu pro vytvoření instance pole, typ pole se projeví jako objekt [].

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[]

Příkaz ReDim nelze také použít pro proměnnou deklarovanou jako typ Array . Z těchto důvodů a pro bezpečnost typů je vhodné deklarovat každé pole jako konkrétní typ.

Datový typ pole nebo jeho prvků můžete zjistit několika způsoby.

• Můžete zavolat GetType metodu na proměnnou a získat tak Type objekt, který představuje běhový typ proměnné. TypeObjekt obsahuje rozsáhlé informace o vlastnostech a metodách.
• Proměnnou můžete předat do TypeName funkce a získat tak String název typu za běhu.

Následující příklad volá jak GetType metodu, tak TypeName funkci pro určení typu pole. Typ pole je Byte(,) . Všimněte si, že Type.BaseType vlastnost také označuje, že základní typ bajtového pole je Array Třída.

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(,)

Pole jako návratové hodnoty a parametry

Chcete-li vrátit pole z Function procedury, zadejte datový typ Array a počet dimenzí jako návratový typ příkazu funkce. V rámci funkce deklarujte místní proměnnou pole se stejným datovým typem a počtem rozměrů. V příkazu returnzahrňte proměnnou místního pole bez závorek.

Chcete-li určit pole jako parametr pro Sub Function proceduru nebo, definujte parametr jako pole se zadaným datovým typem a počtem dimenzí. V volání procedury předejte proměnnou pole se stejným datovým typem a počtem dimenzí.

V následujícím příkladu GetNumbers funkce vrací jednorozměrné Integer() pole typu Integer . ShowNumbersProcedura přijímá 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
    

V následujícím příkladu GetNumbersMultiDim funkce vrací dvojrozměrné Integer(,) pole typu Integer . ShowNumbersMultiDimProcedura přijímá 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

Vícenásobná pole

V některých případech je struktura dat ve vaší aplikaci dvourozměrná, ale ne pravoúhlá. Například můžete použít pole k ukládání dat o vysoké teplotě každého dne v měsíci. První rozměr pole představuje měsíc, ale druhá dimenze představuje počet dní a počet dní v měsíci není stejnorodý. Vícenásobné pole, které se označuje také jako pole polí, je navrženo pro tyto scénáře. Vícenásobné pole je pole, jehož prvky jsou také pole. Vícenásobné pole a každý prvek ve vícenásobném poli může mít jednu nebo více dimenzí.

Následující příklad používá pole měsíců, přičemž každý prvek je pole dnů. V příkladu se používá vícenásobné pole, protože různé měsíce mají různý počet dnů. Tento příklad ukazuje, jak vytvořit vícenásobné pole, přiřadit k němu hodnoty a načíst a zobrazit jeho hodnoty.

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

Předchozí příklad přiřadí hodnoty vícenásobnému poli na základě prvku pomocí For...Next smyčky. Můžete také přiřadit hodnoty prvkům vícenásobného pole pomocí literálů vnořeného pole. Pokus o použití literálů vnořeného pole (například Dim valuesjagged = {{1, 2}, {2, 3, 4}} ) vygeneruje chybu kompilátoru BC30568. Chcete-li chybu opravit, vložte literály vnitřních polí do závorek. Závorky přinutí vyhodnotit výraz literálu pole a výsledné hodnoty jsou použity s vnějším literálem pole, jak ukazuje následující příklad.

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

Vícenásobné pole je jednorozměrné pole, jehož prvky obsahují pole. Proto Array.Length vlastnost a Array.GetLength(0) Metoda vrátí počet prvků v jednorozměrném poli a Array.GetLength(1) vyvolá výjimku, IndexOutOfRangeException protože vícenásobné pole není vícerozměrné. Určíte počet prvků v každém podpoli načtením hodnoty vlastnosti každého podpole Array.Length . Následující příklad ukazuje, jak určit počet prvků ve vícenásobném poli.

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

Pole s nulovou délkou

Visual Basic rozlišuje mezi neinicializovaným polem (polem, jehož hodnota je Nothing ) a polem s nulovou délkou nebo prázdným polem (pole, které neobsahuje žádné prvky.) Neinicializovaný objekt Array je ten, který nemá vytvořenou dimenzi nebo k němu byly přiřazeny nějaké hodnoty. Příklad:

Dim arr() As String

Pole s nulovou délkou je deklarováno s rozměrem-1. Příklad:

Dim arrZ(-1) As String

Pole s nulovou délkou možná budete muset vytvořit za následujících okolností:

• aniž by došlo k NullReferenceException výjimce, váš kód musí mít přístup ke členům třídy, jako je například Array Length nebo Rank , nebo volat funkci Visual Basic, jako je například UBound .

• Chcete, aby byl kód jednoduchý, nemusíte ho kontrolovat Nothing jako zvláštní případ.

• Váš kód komunikuje s rozhraním API (Application Programming Interface), které vyžaduje, abyste předávali pole nulové délky k jednomu nebo více procedurám nebo v jednom nebo více postupech vrátili pole s nulovou délkou.

Rozdělení pole

V některých případech může být nutné rozdělit jedno pole do více polí. To zahrnuje identifikaci bodu nebo bodů, ve kterých má být pole rozděleno, a pak Spitting pole do dvou nebo více samostatných polí.

Nejběžnější kritéria pro rozdělení pole jsou:

• Počet prvků v poli. Například můžete chtít rozdělit pole více než zadaný počet prvků na číslo přibližně stejné části. Pro účely tohoto účelu můžete použít hodnotu vrácenou Array.Length Array.GetLength metodou nebo.

• Hodnota prvku, který slouží jako oddělovač, který označuje, kde má být pole rozděleno. Konkrétní hodnotu můžete vyhledat voláním Array.FindIndex Array.FindLastIndex metod a.

Jakmile určíte index nebo indexy, u kterých má být pole rozděleno, můžete vytvořit jednotlivá pole voláním Array.Copy metody.

Následující příklad rozdělí pole do dvou polí přibližně stejné velikosti. (Pokud celkový počet elementů pole je lichý, první pole má jeden další prvek než druhý.)

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

Následující příklad rozdělí pole řetězců do dvou polí na základě přítomnosti elementu, jehož hodnota je "ZZZ", která slouží jako oddělovač pole. Nová pole neobsahují element, který obsahuje oddělovač.

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

Spojování polí

V jednom větším poli můžete také zkombinovat několik polí. K tomu můžete použít také Array.Copy metodu.

Před zkopírováním prvků každého pole do nového pole je nutné nejprve zajistit, aby bylo pole inicializováno tak, aby bylo dostatečně velké, aby bylo možné přizpůsobit novému poli. Toto lze provést jedním ze dvou způsobů:

• Použijte ReDim Preserve příkaz k dynamickému rozbalení pole před přidáním nových prvků do něj. Toto je nejjednodušší postup, ale může způsobit snížení výkonu a nadměrné využití paměti při kopírování velkých polí.
• Vypočítá celkový počet prvků potřebných pro nové velké pole a potom do něj přidejte prvky každého zdrojového pole.

Následující příklad používá druhý přístup pro přidání čtyř polí s deseti prvky každý do jednoho pole.

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.

Vzhledem k tomu, že v tomto případě jsou zdrojová pole malá, můžeme také dynamicky rozšířit pole, protože do něj přidáte prvky každého nového pole. V následujícím příkladu je to.

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.

Kolekce jako alternativa k polím

Pole jsou nejužitečnější pro vytváření objektů silného typu a práci s ním. Kolekce nabízejí flexibilnější způsob práce se skupinami objektů. Na rozdíl od polí, která vyžadují explicitní změnu velikosti pole pomocí příkazu ReDim ,kolekce se dynamicky zvětšují a zmenšují podle potřeb aplikace.

Když použijete k redimenzi pole, Visual Basic vytvoří nové pole a uvolní ReDim předchozí pole. To trvá dlouho. Proto pokud počet položek, se kterou pracujete často, nebo nemůžete predikovat maximální počet položek, které potřebujete, obvykle získáte lepší výkon pomocí kolekce.

U některých kolekcí můžete klíč přiřadit libovolnému objektu, který jste vložili do kolekce, abyste ho mohli rychle načíst pomocí klíče.

Pokud vaše kolekce obsahuje prvky pouze jednoho datového typu, můžete použít jednu z tříd v oboru System.Collections.Generic názvů . Obecná kolekce vynucuje bezpečnost typů, aby do ní nebyl možné přidat žádný jiný datový typ.

Další informace o kolekcích najdete v tématu Kolekce.

Související témata

Viz také

• System.Array
• Dim – příkaz
• ReDim – příkaz