9 Arrays

Redaktionelle Notiz

Wichtig

Die Windows PowerShell Language Specification 3.0 wurde im Dezember 2012 veröffentlicht und basiert auf Windows PowerShell 3.0. Diese Spezifikation spiegelt nicht den aktuellen Status von PowerShell wider. Es ist nicht geplant, diese Dokumentation zu aktualisieren, um den aktuellen Zustand widerzuspiegeln. Diese Dokumentation wird hier zur historischen Referenz vorgestellt.

Das Spezifikationsdokument steht als Microsoft Word-Dokument im Microsoft Download Center unter: https://www.microsoft.com/download/details.aspx?id=36389 zur Verfügung. Dieses Word-Dokument wurde für die Darstellung hier auf Microsoft Learn umgewandelt. Während der Konvertierung wurden einige redaktionelle Änderungen vorgenommen, um die Formatierung für die Docs-Plattform zu berücksichtigen. Einige Tippfehler und kleinere Fehler wurden korrigiert.

9.1 Einführung

PowerShell unterstützt Arrays mit einer oder mehreren Dimensionen, wobei jede Dimension null oder mehr Elemente aufweisen kann. Innerhalb einer Dimension werden Elemente in aufsteigender ganzzahliger Reihenfolge nummeriert, beginnend bei Null. Auf jedes einzelne Element kann über den Array-Subscript-Operator [] zugegriffen werden (§7.1.4). Die Anzahl der Dimensionen in einem Array wird als Rang bezeichnet.

Ein Element kann einen Wert eines beliebigen Typs enthalten, einschließlich eines Arraytyps. Ein Array mit einem oder mehreren Elementen, deren Werte einen beliebigen Arraytyp aufweisen, wird als Jagged Array bezeichnet. Ein multidimensionales Array hat mehrere Dimensionen, in diesem Fall ist die Anzahl der Elemente in jeder Zeile einer Dimension identisch. Ein Element eines Jagged Array kann ein mehrdimensionales Array enthalten und umgekehrt.

Mehrdimensionale Arrays werden in zeilengerichteter Reihenfolge gespeichert. Die Anzahl der Elemente in einem Array wird als die Länge des Arraysbezeichnet, die beim Erstellen des Arrays festgelegt ist. Auf die Elemente im eindimensionalen Array A mit der Länge N kann zugegriffen (d. h. indiziert) werden, indem A[0], A[1], ..., A[N-1]-Ausdrücke verwendet werden. Auf die Elemente im zweidimensionalen Array B mit M Zeilen, die jeweils N Spalten enthalten, kann mit B[0,0], B[0,1], ..., B[0,N-1], B[1,0], B[1,1], ..., B[1,N-1], ..., B[M-1,0], B[M-1,1], ..., B[M-1,N-1]-Ausdrücken zugegriffen werden. Für Arrays mit drei oder mehr Dimensionen gilt Entsprechendes.

Standardmäßig ist ein Array polymorph; d. h., die Elemente müssen nicht alle denselben Typ haben. Beispiel:

$items = 10,"blue",12.54e3,16.30D # 1-D array of length 4
$items[1] = -2.345
$items[2] = "green"

$a = New-Object 'object[,]' 2,2 # 2-D array of length 4
$a[0,0] = 10
$a[0,1] = $false
$a[1,0] = "red"
$a[1,1] = $null

Ein eindimensionales Array hat den Typ type[], ein zweidimensionales Array den Typ type[,], ein dreidimensionales Array hat den Typ type[,,] und so weiter. Hierbei steht type für ein nicht eingeschränktes Typarray oder den eingeschränkten Typ für ein eingeschränktes Array (§9.4).

Alle Arraytypen werden vom Typ Array abgeleitet (§4.3.2).

9.2 Array-Erstellung

Ein Array wird mit einem Arrayerstellungsausdruck erstellt, der die folgende Formate aufweist: unärer Kommaoperator, (§7.2.1) ,Arrayausdruck (§7.1.7), binärer Kommaoperator (§7.3), Bereichsoperator (§7.4) oder das Cmdlet New-Object.

Hier sind einige Beispiele für die Erstellung und Verwendung von Arrays:

$values = 10, 20, 30
for ($i = 0; $i -lt $values.Length; ++$i) {
    "`$values[$i] = $($values[$i])"
}

$x = , 10                         # x refers to an array of length 1
$x = @(10)                        # x refers to an array of length 1
$x = @()                          # x refers to an array of length 0

$a = New-Object 'object[,]' 2, 2  # create a 2x2 array of anything
$a[0, 0] = 10                     # set to an int value
$a[0, 1] = $false                 # set to a boolean value
$a[1, 0] = "red"                  # set to a string value
$a[1, 1] = 10.50D                 # set to a decimal value
foreach ($e in $a) {              # enumerate over the whole array
    $e
}

Folgendes wird in die Pipeline geschrieben:

$values[0] = 10
$values[1] = 20
$values[2] = 30

10
False
red
10.50

Der Standardwert eines Elements, das nicht explizit initialisiert wird, ist der Standardwert für den Typ dieses Elements (d. a. $false, Null oder $null).

9.3 Arrayverkettung

Arrays beliebiger Art und Länge können über die Operatoren + und += verkettet werden, wobei beide zur Erstellung eines neuen, nicht eingeschränkten 1-dimensionalen Arrays führen. Die vorhandenen Arrays werden nicht verändert. Weitere Informationen finden Sie unter §7.7.3, und unter §9.4 wird das Hinzufügen zu einem Array mit eingeschränktem Typ erörtert.

9.4 Einschränken von Elementtypen

Ein eindimensionales Array kann typbeschränkt erstellt werden, indem dem Arrayerstellungsausdruck eine Arraytypumwandlung vorangestellt wird. Beispiel:

$a = [int[]](1,2,3,4)   # constrained to int
$a[1] = "abc"           # implementation-defined behavior
$a += 1.23              # new array is unconstrained

Die Syntax zum Erstellen eines multidimensionalen Arrays erfordert die Spezifikation eines Typs, und dieser Typ wird zum Einschränkungstyp für dieses Array. Wenn Sie jedoch den Typ object[]angeben, existieren tatsächlich keine Einschränkungen, da einem Element eines Arrays dieses Typs ein Wert irgendeines Typs zugewiesen werden kann.

Das Verketten von zwei Arrays (§7.7.3) führt immer zu einem neuen Array, das nicht eingeschränkt ist, auch wenn beide Arrays durch denselben Typ eingeschränkt sind. Beispiel:

$a = [int[]](1,2,3)    # constrained to int
$b = [int[]](10,20)    # constrained to int
$c = $a + $b           # constraint not preserved
$c = [int[]]($a + $b)  # result explicitly constrained to int

9.5 Arrays als Verweistypen

Da Arraytypen Referenztypen sind, kann eine Variable, die ein Array angibt, auf ein beliebiges Array eines beliebigen Rangs, einer beliebigen Länge und eines Elementtyps verweisen. Beispiel:

$a = 10,20                     # $a refers to an array of length 2
$a = 10,20,30                  # $a refers to a different array, of length 3
$a = "red",10.6                # $a refers to a different array, of length 2
$a = New-Object 'int[,]' 2,3   # $a refers to an array of rank 2

Bei der Zuweisung eines Arrays beinhaltet eine flache Kopie. Das bedeutet, dass die Variable, für die die Zuweisung erfolgt, auf dasselbe Array verweist, aber keine Kopie des Arrays erstellt wird. Beispiel:

$a = 10,20,30
">$a<"
$b = $a         # make $b refer to the same array as $a
">$b<"

$a[0] = 6       # change value of [0] via $a
">$a<"
">$b<"          # change is reflected in $b

$b += 40        # make $b refer to a new array
$a[0] = 8       # change value of [0] via $a
">$a<"
">$b<"          # change is not reflected in $b

Folgendes wird in die Pipeline geschrieben:

>10 20 30<
>10 20 30<
>6 20 30<
>6 20 30<
>8 20 30<
>6 20 30 40<

9.6 Arrays als Arrayelemente

Jedes Element eines Arrays kann selbst ein Array sein. Beispiel:

$colors = "red", "blue", "green"
$list = $colors, (,7), (1.2, "yes") # parens in (,7) are redundant; they
                                    # are intended to aid readability
"`$list refers to an array of length $($list.Length)"
">$($list[1][0])<"
">$($list[2][1])<"

Folgendes wird in die Pipeline geschrieben:

$list refers to an array of length 3
>7<
>yes<

Wie gezeigt, bezieht sich $list[1] auf ein Array mit einem Element, der ganzen Zahl 7, auf die über $list[1][0]zugegriffen wird. Vergleichen Sie dies mit dem folgenden subtil unterschiedlichen Fall:

$list = $colors, 7, (1.2, "yes") # 7 has no prefix comma
">$($list[1])<"

Hier bezieht sich $list[1] auf einen Skalar, die ganze Zahl 7, auf die über $list[1]zugegriffen wird.

Betrachten Sie das folgende Beispiel:

$x = [string[]]("red","green")
$y = 12.5, $true, "blue"
$a = New-Object 'object[,]' 2,2
$a[0,0] = $x               # element is an array of 2 strings
$a[0,1] = 20               # element is an int
$a[1,0] = $y               # element is an array of 3 objects
$a[1,1] = [int[]](92,93)   # element is an array of 2 ints

9.7 Negative Indizierung

Dies wird in §7.1.4.1erläutert.

9.8 Überprüfen von Arraygrenzen

Dies wird in §7.1.4.1erläutert.

9.9 Arrayslices

Ein Arrayslice ist ein nicht eingeschränktes eindimensionales Array, dessen Elemente Kopien von null oder mehr Elementen aus einer Sammlung sind. Ein Arrayslice wird über den Indexoperator [] (§7.1.4.5) erstellt.

9.10 Kopieren eines Arrays

Ein zusammenhängender Satz von Elementen kann mithilfe der Methode [array]::Copyaus einem Array in ein anderes kopiert werden. Beispiel:

$a = [int[]](10,20,30)
$b = [int[]](0,1,2,3,4,5)
[array]::Copy($a, $b, 2)        # $a[0]->$b[0],
$a[1]->$b[1]
[array]::Copy($a, 1, $b, 3, 2)  # $a[1]->$b[3],
$a[2]->$b[4]

9.11 Auflisten der Elemente eines Arrays

Es ist zwar mit dem Indexoperator möglich, ein Array in einer Schleife zu durchlaufen und auf die einzelnen Elemente zuzugreifen, doch Sie können die Elemente des Arrays auch mit der foreach-Anweisung auflisten. Bei einem mehrdimensionalen Array werden die Elemente in zeilengerichteter Reihenfolge verarbeitet. Beispiel:

$a = 10, 53, 16, -43
foreach ($elem in $a) {
    # do something with element via $elem
}

foreach ($elem in -5..5) {
    # do something with element via $elem
}

$a = New-Object 'int[,]' 3, 2
foreach ($elem in $a) {
    # do something with element via $elem
}

9.12 Vereinfachung mehrdimensionaler Arrays

Für manche Vorgänge in mehrdimensionalen Arrays (zum Beispiel Replikation (§7.6.3) und Verkettung (§7.7.3)) muss das Array vereinfacht werden, also in ein eindimensionales Array mit nicht eingeschränktem Typ umgewandelt werden. Das resultierende Array übernimmt alle Elemente in zeilengerichteter Reihenfolge.

Betrachten Sie das folgende Beispiel:

$a = "red",$true
$b = (New-Object 'int[,]' 2,2)
$b[0,0] = 10
$b[0,1] = 20
$b[1,0] = 30
$b[1,1] = 40
$c = $a + $b

Das von $c bezeichnete Array enthält die Elemente "red", $true, 10, 20, 30 und 40.