9. Matrici

Nota editoriale

Importante

La specifica del linguaggio Windows PowerShell 3.0 è stata pubblicata nel dicembre 2012 ed è basata su Windows PowerShell 3.0. Questa specifica non riflette lo stato corrente di PowerShell. Non è previsto l'aggiornamento di questa documentazione per riflettere lo stato corrente. Questa documentazione è presentata qui per riferimento cronologico.

Il documento di specifica è disponibile come documento di Microsoft Word dall'Area download Microsoft all'indirizzo: https://www.microsoft.com/download/details.aspx?id=36389 Il documento di Word è stato convertito per la presentazione qui in Microsoft Learn. Durante la conversione sono state apportate alcune modifiche editoriali per supportare la formattazione per la piattaforma Docs. Sono stati corretti alcuni errori di digitazioni e errori secondari.

9.1 Introduzione

PowerShell supporta matrici di una o più dimensioni, ciascuna con zero o più elementi . All'interno di una dimensione, gli elementi vengono numerati in ordine intero crescente a partire da zero. È possibile accedere a qualsiasi singolo elemento tramite l'operatore di sottoscrittura di matrice [] (§7.1.4). Il numero di dimensioni in una matrice viene chiamato rango.

Un elemento può contenere un valore di qualsiasi tipo, incluso un tipo di matrice. Una matrice con uno o più elementi i cui valori sono di qualsiasi tipo di array viene chiamata array irregolare. Una matrice multidimensionale ha più dimensioni, nel qual caso il numero di elementi in ogni riga di una dimensione è lo stesso. Un elemento di una matrice frastagliata può contenere una matrice multidimensionale e viceversa.

Le matrici multidimensionali vengono archiviate in ordine principale di riga. Il numero di elementi in una matrice viene chiamato lunghezza della matrice, che è fisso quando viene creata la matrice. Di conseguenza, è possibile accedere agli elementi in una matrice a 1 dimensione di lunghezza N (cioè, indicizzata ) usando le espressioni A[0], A[1], ..., A[N-1]. È possibile accedere agli elementi di una matrice bidimensionale B con righe M, con ogni riga con colonne N, usando le espressioni 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]. E così via per le matrici con tre o più dimensioni.

Per impostazione predefinita, una matrice è polimorfica; cioè, i suoi elementi non devono avere tutti lo stesso tipo. Per esempio

$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

Un array unidimensionale ha tipo type[], un array bidimensionale ha tipo type[,], un array tridimensionale ha tipo type[,,]e così via, dove il tipo è oggetto per un array di tipo non vincolato o il tipo vincolato per un array vincolato (§9.4).

Tutti i tipi di matrice sono derivati dal tipo Array (§4.3.2).

9.2 Creazione di matrici

Una matrice viene creata tramite un'espressione di creazione di matrice , che presenta le forme seguenti: operatore virgola unaria (§7.2.1), espressione di matrice (§7.1.7), operatore binario virgola (§7.3), operatore di intervallo (§7.4) o New-Object cmdlet .

Ecco alcuni esempi di creazione e utilizzo di matrici:

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

Nella pipeline viene scritto quanto segue:

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

10
False
red
10.50

Il valore iniziale predefinito di qualsiasi elemento non inizializzato in modo esplicito è il valore predefinito per il tipo dell'elemento, ovvero $false, zero o $null.

9.3 Concatenazione di matrici

Le matrici di tipo e lunghezza arbitrarie possono essere concatenate tramite gli operatori + e +=, che comportano entrambi la creazione di una nuova matrice un-dimensionale non vincolata. Le matrici esistenti sono invariate. Per altre informazioni, vedere §7.7.3 e §9.4 per una discussione sull'aggiunta a una matrice di tipi vincolati.

9.4 Vincolare i tipi di elemento

È possibile creare una matrice unidimensionale in modo che sia vincolata a un tipo, anteponendo all'espressione di creazione della matrice un cast di tipo matrice. Per esempio

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

La sintassi per la creazione di una matrice multidimensionale richiede la specifica di un tipo e tale tipo diventa il tipo di vincolo per tale matrice. Tuttavia, specificando il tipo object[], non esiste effettivamente alcun vincolo come valore di qualsiasi tipo può essere assegnato a un elemento di una matrice di tale tipo.

Concatenando due matrici (§7.7.3) viene sempre restituita una nuova matrice non vincolata anche se entrambe le matrici sono vincolate dallo stesso tipo. Per esempio

$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 Matrici come tipi di riferimento

Poiché i tipi di matrice sono tipi di riferimento, è possibile creare una variabile che faccia riferimento a qualsiasi matrice di qualsiasi grado, lunghezza e tipo di elementi. Per esempio

$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

L'assegnazione di una matrice comporta una copia superficiale; ovvero, la variabile a cui viene assegnata fa riferimento alla stessa matrice, quindi non viene creata una nuova copia della matrice. Per esempio

$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

Nella pipeline viene scritto quanto segue:

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

9.6 Matrici come elementi di matrice

Qualsiasi elemento di una matrice può essere una matrice. Per esempio

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

Nella pipeline viene scritto quanto segue:

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

$list[1] fa riferimento a una matrice di 1 elemento, l'intero 7, accessibile tramite $list[1][0], come illustrato. Confrontarlo con il seguente caso leggermente diverso:

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

In questo caso, $list[1] fa riferimento a un valore scalare, l'intero 7, a cui si accede tramite $list[1].

Si consideri l'esempio seguente:

$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 Pedice negativo

Questo argomento è illustrato in §7.1.4.1.

Controllo dei limiti 9.8

Questo argomento è illustrato in §7.1.4.1.

9.9 Sezioni di matrici

Una sezione di matrice è una matrice unidimensionale senza vincoli i cui elementi sono copie di zero o più elementi di una raccolta. Una sottosequenza di array viene creata tramite l'operatore di sottoindice [] (§7.1.4.5).

9.10 Copia di una matrice

È possibile copiare un set contiguo di elementi da una matrice a un'altra usando il metodo [array]::Copy. Per esempio

$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 Enumerazione su una matrice

Sebbene sia possibile scorrere un array per accedere a ognuno dei suoi elementi tramite l'operatore di indicizzazione, possiamo enumerare gli elementi dell'array usando l'istruzione foreach. Per una matrice multidimensionale, gli elementi vengono elaborati in ordine principale di riga. Per esempio

$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 Appiattimento di matrici multidimensionali

Alcune operazioni su una matrice multidimensionale (ad esempio la replica (§7.6.3) e la concatenazione (§7.7.3)) richiedono che tale matrice sia appiattita; ovvero, per essere trasformata in una matrice 1-dimensionale di tipo non vincolato. La matrice risultante accetta tutti gli elementi nell'ordine principale della riga.

Si consideri l'esempio seguente:

$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

La matrice designata da $c contiene gli elementi "rosso", $true, 10, 20, 30 e 40.