9. Tömbök

  • Cikk

9.1 Bevezetés

A PowerShell egy vagy több dimenzióból áll, és minden dimenziónak nulla vagy több eleme van. A dimenziók elemeinek számozása nullától kezdődően növekvő egész számokkal kezdődik. Minden egyes elem elérhető a tömb alsó indexének operátorával [] (").7.1.4). A tömbben a dimenziók számát rangsorolásnak nevezzük.

Egy elem bármilyen típusú értéket tartalmazhat, beleértve a tömbtípust is. Egy olyan tömböt, amelynek egy vagy több olyan eleme van, amelynek értéke bármilyen tömbtípusba esik, szaggatott tömbnek nevezzük. A többdimenziós tömbök több dimenzióval rendelkeznek, ebben az esetben a dimenziók egyes sorában lévő elemek száma megegyezik. Egy szaggatott tömb egy eleme tartalmazhat egy többdimenziós tömböt, és fordítva.

A többdimenziós tömbök sor-főrendben vannak tárolva. A tömb elemeinek számát ennek a tömbnek a hosszának nevezzük , amely a tömb létrehozásakor rögzített. Ezért az egydimenziós A tömb N hosszúságú elemei a következő kifejezésekkel érhetők el (például alsó indexbenA[0], A[1], ..., A[N-1]). A kétdimenziós B tömb M sorokkal rendelkező elemei, amelyek minden sorában N oszlop van, a következő kifejezésekkel érhetők el: 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]. És így tovább a három vagy több dimenziót tartalmazó tömböknél.

Alapértelmezés szerint a tömb polimorf; Vagyis az elemeinek nem kell mindnek ugyanaz a típusa. Példa:

$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

Az 1 type[]dimenziós tömb típussal rendelkezik, a kétdimenziós type[,]tömb típussal rendelkezik, egy 3 dimenziós type[,,]tömb típussal rendelkezik, és így tovább, ahol a típus egy nem korlátozott típusú tömb objektuma, vagy egy korlátozott tömb korlátozott típusa (").9.4).

Minden tömbtípus a Tömb típusból származik (").4.3.2).

9.2 Tömb létrehozása

A tömböt egy tömb-létrehozási kifejezéssel lehet létrehozni, amelynek formája a következő: unáris vessző operátor (;7.2.1), tömb-kifejezés (;7.1.7), bináris vessző operátor (érér 7.3), tartomány operátor (automatikusan 7.4) vagy New-Object parancsmag.

Íme néhány példa a tömbök létrehozására és használatára:

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

A folyamat a következőt írja be:

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

10
False
red
10.50

A explicit módon nem inicializált elemek alapértelmezett kezdeti értéke az elem típusának alapértelmezett értéke (, $false, nulla vagy $null).

9.3 Tömbök össze concatenációja

A és + += az operátorral tetszőleges típusú és hosszúságú tömbök összecsukhatóak, ami mindkettő egy új, nem korlátozott 1 dimenziós tömb létrehozását eredményezi. A meglévő tömbök változatlanok. See §7.7.3 for more information, and §9.4 for a discussion of adding to an array of constrained type.

9.4 Elemtípusok korlátozása

Egy 1 dimenziós tömb úgy is létre lehet hozva, hogy típuskorlátos legyen a tömb-létrehozási kifejezés előtaggal és egy tömbtípus-cast előtaggal. Példa:

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

A többdimenziós tömbök létrehozásának szintaxisához meg kell adni egy típust, és ez a típus lesz az adott tömb korlátozástípusa. A típus megadásával object[]azonban valójában nincs korlátozás, mivel bármilyen típusú érték hozzárendelhető egy ilyen típusú tömb elemhez.

Két tömb összecsatolása (*7.7.3) mindig egy új tömböt hoz létre, amely nem korlátozott, még akkor is, ha mindkét tömböt ugyanaz a típus korlátozza. Példa:

$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 Tömb referenciák típusaként

Mivel a tömbtípusok referenciák, a tömböt megtervező változók bármely rangsorolási, hosszúsági és elemtípusú tömbre hivatkozni tudnak. Példa:

$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

A tömbök hozzárendelése egy kis másolatból is beletartozik; Ez azt jelenti, hogy a változó, amelyhez hozzá van rendelve, ugyanannak a tömbnek a kiosztása nem készül másolatban. Példa:

$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

A folyamat a következőt írja be:

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

9.6 Tömbök tömbelemekként

A tömbök bármelyik eleme lehet tömb. Példa:

$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])<"

A folyamat a következőt írja be:

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

$list[1] A egy 1 elemet tartalmazó tömbre, a 7 egész számra vonatkozik, $list[1][0]amely a segítségével érhető el, ahogy az ábrán látható. Hasonlítsa össze ezt az alábbi kis- és kis- és nagy különböziketekkel:

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

Itt a $list[1] egy skaláris számra, a 7-es egész számra vonatkozik, amely a segítségével érhető el $list[1].

Vegyük példaként a következőt:

$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 Negatív előirat

Ezt a következő cikk tárgyalja: .7.1.4.1.

9.8 Határellenőrzés

Ezt a következő cikk tárgyalja: .7.1.4.1.

9.9 Tömbszeletek

A tömbszelet egy nem korlátozott 1dimenziós tömb, amelynek elemei egy gyűjtemény nulla vagy több elemének másolatai. A tömbszeleteket az indexelő [] operátor (a 7.1.4.5) használatával lehet létrehozni.

9.10 Tömb másolása

Az elemek egy összefüggő halmaza az metódussal másolható egyik tömbből a másikba [Array]::Copy. Példa:

$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 Enumerálás tömbben

Bár az összes elemét a subscript operátorral el lehet férni egy tömbhöz, a foreach utasítással enumerálhatja a tömb elemeit. Többdimenziós tömbökben az elemeket sor-fő sorrendben kell feldolgozni. Példa:

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

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

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

9.12 Többdimenziós tömbök simítása

Some operations on a multidimensional array (such as replication (§7.6.3) and concatenation (§7.7.3)) require that array to be flattened; that is, to be turned into a 1-dimensional array of unconstrained type. Az eredményül kapott tömb sor-főrendben veszi fel az összes elemet.

Tekintse meg a következő példát:

$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

A által kijelölt tömb $c a "red", a , a 10, $truea 20, a 30 és a 40 elemeket tartalmazza.