Sdílet prostřednictvím


Pole v jazyce Visual Basic

Pole je sada hodnot, které se označují jako elementy, které jsou logicky vzájemně spojené. Například pole se může skládat z počtu studentů v každé třídě v gramatické škole; každý prvek pole je počet studentů v jedné známce. Podobně může pole obsahovat známky studenta pro třídu; každý prvek pole je jedna známka.

Jednotlivé proměnné je možné použít k ukládání jednotlivých datových položek. Pokud například naše aplikace analyzuje známky studentů, můžeme použít samostatnou proměnnou pro známky každého studenta, například englishGrade1, atd englishGrade2. Tento přístup má tři hlavní omezení:

  • V době návrhu musíme přesně vědět, kolik známek musíme zvládnout.
  • Zpracování velkého počtu známek se rychle stává nepraktným. To zase znamená, že aplikace bude mít mnohem větší pravděpodobnost, že bude mít vážné chyby.
  • Je obtížné udržovat. Každá nová známka, kterou přidáme, vyžaduje, aby byla aplikace upravena, rekompilována a znovu nasazena.

Pomocí pole můžete odkazovat na tyto související hodnoty 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 maticového rozsahu od 0 do jednoho menšího než celkový počet prvků v matici. Pokud použijete syntaxi Visual Basic k definování velikosti pole, zadáte jeho nejvyšší index, ne celkový počet prvků v poli. Můžete pracovat s polem jako jednotkou a možnost iterovat její prvky bez nutnosti přesně zjistit, kolik prvků obsahuje v době návrhu.

Několik rychlých příkladů 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(,) {{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é známce v gramatické škole. Indexy prvků jsou od 0 do 6. Použití tohoto pole je jednodušší než deklarování sedmi proměnných.

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

  • Index prvku představuje známku (index 0 představuje mateřské školy).

  • Hodnota obsažená v prvku představuje počet studentů v dané známce.

Diagram showing an array of the numbers of students

Následující příklad obsahuje Visual Basic kód, který vytvoří 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 dělá tři věci:

  • Deklaruje students pole se sedmi prvky. Číslo 6 v deklaraci pole označuje poslední index v matici. Jedná se o jeden menší než počet prvků v poli.
  • Přiřadí hodnoty každému prvku v poli. K prvkům pole se přistupuje pomocí názvu pole a včetně indexu jednotlivých prvků v závorkách.
  • Vypíše každou hodnotu pole. Příklad používá For příkaz pro přístup ke každému prvku pole podle jeho indexového čísla.

Pole students v předchozím příkladu je jednorozměrné pole, protože používá jeden index. Pole, které používá více indexů nebo dolních indexů, se nazývá multidimenzionální. Další informace najdete v ostatních článcích a dimenzích polí v Visual Basic.

Vytvoření pole

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

  • Velikost můžete určit, když je pole deklarováno:

    ' 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
    
  • Klauzuli New můžete použít k zadání 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)() {}
    

Pokud máte existující pole, můžete jeho velikost znovu definovat 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 k úpravě 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 najdete v příkazu ReDim.

Ukládání hodnot v poli

Ke každému umístění v poli můžete přistupovat pomocí indexu typu Integer. Hodnoty v poli můžete uložit a načíst tak, že na každé umístění pole odkazujete pomocí jeho indexu uzavřeného v závorkách. Indexy pro multidimenzionální pole jsou oddělené čá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 literály pole

Pomocí literálu pole můžete matici naplnit počáteční sadou hodnot současně, kterou vytvoříte. Literál pole se skládá ze seznamu hodnot oddělených čárkami, které jsou uzavřeny do závorek ({}).

Při vytváření pole pomocí literálu pole můžete 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ý se můžou 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 zúžit všechny ostatní typy v poli. Pokud nelze určit žádný z těchto jedinečných typů, je Objectdominantní typ . Pokud například seznam hodnot zadaných do literálu pole obsahuje hodnoty typu Integer, Longa Doublevýsledná matice je typu Double. Protože Integer a Long rozšířit pouze na Double, Double je dominantní typ. Další informace najdete v tématu Rozšíření a zúžení převodů.

Poznámka

Odvozování typů můžete použít pouze pro pole, která jsou definována jako místní proměnné v členu typu. Pokud chybí explicitní definice typu, pole definovaná pomocí literálů pole na úrovni třídy jsou typu Object[]. Další informace najdete v tématu Odvozování místního typu.

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

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

' 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í vnořených maticových literálů k vytvoření a naplnění pole dojde k chybě, pokud počet prvků v vnořených maticových literálů neodpovídá. K chybě dojde také v případě, že explicitně deklarujete proměnnou pole, aby měla jiný počet dimenzí než literály pole.

Stejně jako u jednorozměrných polí můžete při vytváření multidimenzionálního pole s vnořenými maticovými literály spoléhat na odvozování typů. Odvozený typ je dominantním typem pro všechny hodnoty ve všech maticových literálech pro všechny vnořené úrovně. Následující příklad vytvoří dvojrozmě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 najdete v tématu Postupy: Inicializace proměnné pole v Visual Basic.

Iterace prostřednictvím pole

Při iteraci pole přistupujete ke každému prvku v matici z nejnižšího indexu na nejvyšší nebo od nejvyššího po nejnižší. Obvykle použijte buď for... Další příkaz nebo příkaz For Each... Další příkaz , který iteruje prvky pole. Pokud neznáte horní hranice pole, můžete metodu volat Array.GetUpperBound , abyste získali nejvyšší hodnotu indexu. I když nejnižší hodnota indexu je téměř vždy 0, můžete metodu Array.GetLowerBound volat, abyste získali nejnižší hodnotu indexu.

Následující příklad iteruje jednosměrným polem 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 iteruje prostřednictvím multidimenzionálního pole pomocí For...Next příkazu. Metoda GetUpperBound má parametr, který určuje dimenzi. GetUpperBound(0) vrátí nejvyšší index první dimenze 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ý... Next Statementto iterate prostřednictvím 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čin délky všech jeho dimenzí. 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

Poznámka

Tato diskuze o velikosti pole se nevztahuje na župací pole. Informace o rozsaděných polích a určení velikosti zabílaného pole najdete v části Jagged arrays .

Velikost pole můžete najít pomocí Array.Length vlastnosti. Délku jednotlivých dimenzí multidimenzionálního pole můžete najít pomocí Array.GetLength metody.

Proměnnou pole můžete změnit přiřazením nového objektu ReDim pole nebo příkazem Příkaz. Následující příklad používá ReDim příkaz ke změně pole elementu 100-element na 51-element matice.


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í.

Poznámky
Délka rozměru Index každé dimenze je založen na 0, což znamená, že se pohybuje od 0 do horní hranice. Délka dané dimenze je tedy jedna větší než deklarovaná horní mez dané dimenze.
Limity délky Délka každé dimenze pole je omezena na maximální hodnotu datového Integer typu, tj Int32.MaxValue . (2 ^ 31) - 1. Celková velikost pole je ale omezená také pamětí dostupnou v systému. Pokud se pokusíte inicializovat pole, které překračuje množství dostupné paměti, modul runtime vyvolá OutOfMemoryExceptionhodnotu .
Velikost a velikost elementu Velikost pole je nezávislá na datovém typu jejích prvků. Velikost vždy představuje celkový počet prvků, nikoli počet bajtů, které spotřebovávají v paměti.
Spotřeba paměti Není bezpečné provést žádné předpoklady týkající se toho, jak je pole uloženo v paměti. Storage se liší na platformách různých šířek dat, takže stejné pole může spotřebovávat více paměti v 64bitovém systému než v 32bitovém systému. V závislosti na konfiguraci systému při inicializaci pole může modul CLR (Common Language Runtime) přiřazovat úložiště buď k prvkům balíčku co nejblíže, nebo je zarovnat všechny na hranice přirozeného hardwaru. Pole také vyžaduje režii úložiště pro informace o ovládacím prvku a tato režie se zvyšuje s každou přidanou dimenzí.

Typ pole

Každé pole má datový typ, který se liší od datového typu jeho prvků. Pro všechna pole neexistuje žádný datový typ. Datový typ pole je místo toho určen počtem dimenzí nebo pořadím pole a datovým typem prvků v matici. Dvě proměnné pole jsou stejného datového typu, pouze pokud mají stejné pořadí a jejich prvky mají stejný datový typ. Délky dimenzí pole nemají vliv na datový typ pole.

Každé pole dědí z System.Array třídy a můžete deklarovat proměnnou typu Array, ale nelze vytvořit pole typu Array. I když například následující kód deklaruje arr proměnnou jako typ Array a volá metodu Array.CreateInstance pro vytvoření instance pole, typ pole se prokáže jako 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[]

Příkaz ReDim také nemůže pracovat s proměnnou deklarovanou jako typ Array. Z těchto důvodů a z bezpečnostních důvodů je vhodné deklarovat každou matici jako konkrétní typ.

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

  • Metodu GetType proměnné můžete volat, abyste získali Type objekt, který představuje typ běhu proměnné. Objekt Type obsahuje rozsáhlé informace o svých vlastnostech a metodách.
  • Proměnnou TypeName můžete funkci předat, abyste získali String název typu run-time.

Následující příklad volá metodu GetType i TypeName funkci k určení typu pole. Typ pole je Byte(,). Všimněte si, že Type.BaseType vlastnost také označuje, že základní typ pole bajtů 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 matici z Function procedury, zadejte datový typ pole a počet dimenzí jako návratový typ příkazu function. V rámci funkce deklarujte místní proměnnou pole se stejným datovým typem a počtem dimenzí. V příkazu Return zahrňte místní proměnnou pole bez závorek.

Chcete-li zadat pole jako parametr Sub nebo Function proceduru, definujte parametr jako pole se zadaným datovým typem a počtem dimenzí. Ve 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 vrátí Integer()funkce jednorozměrné pole typu Integer. Procedura ShowNumbersInteger() přijímá 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 vrátí Integer(,)funkce dvojrozměrné pole typu Integer. Procedura ShowNumbersMultiDimInteger(,) přijímá 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

Jagged arrays

Někdy je datová struktura v aplikaci dvojrozměrná, ale ne obdélníková. Můžete například použít pole k ukládání dat o vysoké teplotě každého dne v měsíci. První dimenze pole představuje měsíc, ale druhá dimenze představuje počet dní a počet dní v měsíci není jednotný. Pro takové scénáře je navržená župavá matice, která se také označuje jako pole polí. Jagged array je pole, jehož prvky jsou také matice. Jagged array a každý prvek v jagged array může mít jednu nebo více dimenzí.

Následující příklad používá pole měsíců, z nichž každý je pole dnů. V příkladu se používá zubaté pole, protože různé měsíce mají různá čísla dnů. Příklad ukazuje, jak vytvořit zubaté 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 k jagged array na základě element-by-element pomocí smyčky For...Next . Hodnoty můžete také přiřadit k prvkům zmajděného pole pomocí vnořených maticových literálů. Pokus o použití vnořených maticových literálů (například Dim valuesjagged = {{1, 2}, {2, 3, 4}}) však generuje chybu kompilátoru BC30568. Pokud chcete chybu opravit, uzavřete vnitřní maticové literály do závorek. Závorky vynucují vyhodnocení výrazu literálu pole a výsledné hodnoty se používají s literálem vnějšího 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

Jagged array je jednorozměrné pole, jehož prvky obsahují pole. Array.Length Proto vlastnost a Array.GetLength(0) metoda vrátí počet prvků v jednorozměrném poli a Array.GetLength(1) vyvoláIndexOutOfRangeException, protože zubatá matice není multidimenzionální. Počet prvků v jednotlivých dílčích polích určíte načtením hodnoty vlastnosti jednotlivých dílčích polí Array.Length . Následující příklad ukazuje, jak určit počet prvků v zubatých polích.


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 nulové délky

Visual Basic rozlišovat mezi neinicializovaným polem (polem, jehož hodnota jeNothing) a polem s nulovou délkou nebo prázdným polem (matice, která neobsahuje žádné prvky.) Neinicializované pole je pole, které nebylo kótováno nebo má přiřazené žádné hodnoty. Příklad:

Dim arr() As String

Pole nulové délky je deklarováno s dimenzí -1. Příklad:

Dim arrZ(-1) As String

Za následujících okolností možná budete muset vytvořit pole nulové délky:

  • Bez rizika NullReferenceException výjimky musí váš kód přistupovat ke členům Array třídy, například Length nebo Rank, nebo volat Visual Basic funkci, například UBound.

  • Chcete zachovat jednoduchý kód tím, že nemusíte kontrolovat Nothing jako zvláštní případ.

  • Kód komunikuje s aplikačním programovacím rozhraním (API), které vyžaduje předání pole nulové délky do jednoho nebo více procedur nebo vrácení pole nulové délky z jednoho nebo více procedur.

Rozdělení pole

V některých případech možná budete muset rozdělit jedno pole na více polí. To zahrnuje identifikaci bodu nebo bodů, ve kterých má být pole rozděleno, a následné spitting matici do dvou nebo více samostatných polí.

Poznámka

Tato část se nezabírá rozdělení jednoho řetězce na pole řetězců na základě některého oddělovače. Informace o rozdělení řetězce najdete v String.Split metodě.

Nejběžnějšími kritérii rozdělení pole jsou:

  • Počet prvků v poli. Můžete například chtít rozdělit pole s více než zadaným počtem prvků na počet přibližně stejných částí. K tomuto účelu můžete použít hodnotu vrácenou metodou Array.Length nebo Array.GetLength metodou.

  • 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 a Array.FindLastIndex metodami.

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

Následující příklad rozdělí pole na dvě pole s přibližně stejnou velikostí. (Pokud je celkový počet prvků matice lichý, první matice má jeden více prvků 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ů na dvě pole na základě přítomnosti prvku, jehož hodnota je "zzz", která slouží jako oddělovač pole. Nová pole nezahrnují prvek, 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í

Můžete také zkombinovat několik polí do jednoho většího pole. K tomu použijete také metodu Array.Copy .

Poznámka

Tato část nepojednává o spojování pole řetězců do jednoho řetězce. Informace o spojování pole řetězců naleznete v String.Join metodě.

Před zkopírováním prvků každého pole do nového pole je nutné nejprve ověřit, že jste pole inicializovali tak, aby bylo dostatečně velké, aby vyhovovalo novému poli. Toto lze provést jedním ze dvou způsobů:

  • ReDim Preserve Příkaz použijte k dynamickému rozšíření pole před přidáním nových prvků do něj. To je nejjednodušší technika, ale může vést ke snížení výkonu a nadměrné spotřebě paměti při kopírování velkých polí.
  • Vypočítejte celkový počet prvků potřebných pro nové velké pole a přidejte do něj prvky jednotlivých zdrojových polí.

Následující příklad používá druhý přístup k přidání čtyř polí s deseti prvky každého 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 do ní dynamicky rozšířit také prvky jednotlivých nových polí. Následující příklad to dělá.

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í a práci s pevným počtem objektů silného typu. Kolekce poskytují flexibilnější způsob práce se skupinami objektů. Na rozdíl od polí, která vyžadují explicitní změnu velikosti pole pomocí ReDim příkazu, se kolekce dynamicky zvětšují a zmenšují podle potřeb aplikace.

Když použijete ReDim k opětovnému vytvoření matice, Visual Basic vytvoří nové pole a uvolní předchozí pole. To trvá dobu provádění. Pokud tedy počet položek, se kterými pracujete často, nebo nemůžete předpovědět maximální počet položek, které potřebujete, obvykle dosáhnete lepšího výkonu pomocí kolekce.

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

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

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

Pojem Definice
Rozměry pole v jazyce Visual Basic Vysvětluje pořadí a dimenze v polích.
Postupy: Inicializace proměnné pole v jazyce Visual Basic Popisuje, jak naplnit pole počátečními hodnotami.
Postupy: Řazení pole v jazyce Visual Basic Ukazuje, jak seřadit prvky pole abecedně.
Postupy: Přiřazení jednoho pole ke druhému Popisuje pravidla a kroky pro přiřazení pole k jiné maticové proměnné.
Řešení potíží s poli Popisuje některé běžné problémy, ke kterým dochází při práci s poli.

Viz také