about_Arrays

  • Articolo

Descrizione breve

Vengono descritte le matrici, ovvero strutture di dati progettate per archiviare raccolte di elementi.

Descrizione lunga

Una matrice è una struttura di dati progettata per archiviare una raccolta di elementi. Gli elementi possono essere dello stesso tipo o tipi diversi.

A partire da Windows PowerShell 3.0, una raccolta di zero o un oggetto ha alcune proprietà delle matrici.

Creazione e inizializzazione di una matrice

Per creare e inizializzare una matrice, assegnare più valori a una variabile. I valori archiviati nella matrice sono delimitati da una virgola e separati dal nome della variabile dall'operatore di assegnazione (=).

Ad esempio, per creare una matrice denominata $A che contiene i sette valori numerici (integer) di 22, 5, 10, 8, 12, 9 e 80, digitare:

$A = 22,5,10,8,12,9,80

La virgola può essere usata anche per inizializzare una singola matrice di elementi posizionando la virgola prima del singolo elemento.

Ad esempio, per creare una singola matrice di elementi denominata $B contenente il singolo valore 7, digitare:

$B = ,7

È anche possibile creare e inizializzare una matrice usando l'operatore range (..). Nell'esempio seguente viene creata una matrice contenente i valori da 5 a 8.

$C = 5..8

Di conseguenza, $C contiene quattro valori: 5, 6, 7 e 8.

Quando non viene specificato alcun tipo di dati, PowerShell crea ogni matrice come matrice di oggetti (System.Object[]). Per determinare il tipo di dati di una matrice, usare il GetType() metodo . Ad esempio:

$A.GetType()

Per creare una matrice fortemente tipizzata, ovvero una matrice che può contenere solo valori di un particolare tipo, eseguire il cast della variabile come tipo di matrice, ad esempio string[], long[]o int32[]. Per eseguire il cast di una matrice, precedere il nome della variabile con un tipo di matrice racchiuso tra parentesi quadre. Ad esempio:

[int32[]]$ia = 1500, 2230, 3350, 4000

Di conseguenza, la $ia matrice può contenere solo numeri interi.

È possibile creare matrici di cui viene eseguito il cast in qualsiasi tipo supportato in .NET. Ad esempio, gli oggetti recuperati Get-Process per rappresentare i processi sono del tipo System.Diagnostics.Process . Per creare una matrice fortemente tipizzata di oggetti processo, immettere il comando seguente:

[Diagnostics.Process[]]$zz = Get-Process

Operatore di sottoespressione della matrice

L'operatore di sottoespressione della matrice crea una matrice dalle istruzioni al suo interno. Indipendentemente dall'istruzione all'interno dell'operatore, l'operatore lo inserisce in una matrice. Anche se è presente zero o un oggetto.

La sintassi dell'operatore di matrice è la seguente:

@( ... )

È possibile usare l'operatore di matrice per creare una matrice di zero o un oggetto. Ad esempio:

$a = @("Hello World")
$a.Count

1

$b = @()
$b.Count

0

L'operatore di matrice è utile negli script quando si ottengono oggetti, ma non si sa quanti si aspettano. Ad esempio:

$p = @(Get-Process Notepad)

Per altre informazioni sull'operatore di sottoespressione della matrice, vedere about_Operators.

Accesso e uso di elementi di matrice

Lettura di una matrice

È possibile fare riferimento a una matrice usando il nome della variabile. Per visualizzare tutti gli elementi nella matrice, richiamare il nome della matrice. Ad esempio, $a è una matrice di numeri da 0 a 9:

$a

0
1
2
3
4
5
6
7
8
9

È possibile fare riferimento agli elementi di una matrice usando un indice. Racchiudere il numero di indice tra parentesi quadre. I valori di indice iniziano da 0. Ad esempio, per visualizzare il primo elemento nella $a matrice, digitare:

$a[0]

0

Per visualizzare il terzo elemento nella $a matrice, digitare:

$a[2]

2

È possibile recuperare parte della matrice usando un operatore di intervallo per l'indice. Ad esempio, per recuperare il secondo al quinto elemento della matrice, digitare:

$a[1..4]

1
2
3
4

Numero di numeri negativi dalla fine della matrice. Ad esempio, -1 fa riferimento all'ultimo elemento della matrice. Per visualizzare gli ultimi tre elementi della matrice, in ordine crescente di indice, digitare:

$a = 0 .. 9
$a[-3..-1]

7
8
9

Se si digitano indici negativi in ordine decrescente, l'output cambia.

$a = 0 .. 9
$a[-1..-3]

9
8
7

Tuttavia, prestare attenzione quando si usa questa notazione. I cicli di notazione dal limite finale all'inizio della matrice.

$a = 0 .. 9
$a[2..-2]

2
1
0
9
8

Inoltre, un errore comune consiste nel presupporre $a[0..-2] che faccia riferimento a tutti gli elementi della matrice, ad eccezione dell'ultimo. Fa riferimento al primo, all'ultimo e all'ultimo elemento nella matrice.

È possibile usare l'operatore più (+) per combinare un intervallo con un elenco di elementi in una matrice. Ad esempio, per visualizzare gli elementi in corrispondenza delle posizioni di indice da 0, 2 e 4 a 6, digitare:

$a = 0 .. 9
$a[0,2+4..6]

0
2
4
5
6

Inoltre, per elencare più intervalli e singoli elementi è possibile usare l'operatore plus. Ad esempio, per elencare gli elementi da zero a due, da quattro a sei e l'elemento all'ottavo tipo posizionale:

$a = 0..9
$a[+0..2+4..6+8]

0
1
2
4
5
6
8

Iterazioni sugli elementi della matrice

È anche possibile usare costrutti di ciclo, ad esempio foreach, fore , per while fare riferimento agli elementi in una matrice. Ad esempio, per usare un foreach ciclo per visualizzare gli elementi nella $a matrice, digitare:

$a = 0..9
foreach ($element in $a) {
  $element
}

0
1
2
3
4
5
6
7
8
9

Il foreach ciclo scorre la matrice e restituisce ogni valore nella matrice fino a raggiungere la fine della matrice.

Il for ciclo è utile quando si incrementano i contatori durante l'analisi degli elementi in una matrice. Ad esempio, per usare un for ciclo per restituire ogni altro valore in una matrice, digitare:

$a = 0..9
for ($i = 0; $i -le ($a.length - 1); $i += 2) {
  $a[$i]
}

0
2
4
6
8

È possibile usare un while ciclo per visualizzare gli elementi in una matrice fino a quando una condizione definita non è più true. Ad esempio, per visualizzare gli elementi nella $a matrice mentre l'indice della matrice è minore di 4, digitare:

$a = 0..9
$i=0
while($i -lt 4) {
  $a[$i]
  $i++
}

0
1
2
3

Proprietà delle matrici

Count o Length o LongLength

Per determinare il numero di elementi in una matrice, usare la proprietà o il Length relativo Count alias. Longlength è utile se la matrice contiene più di 2.147.483.647 elementi.

$a = 0..9
$a.Count
$a.Length

10
10

Rank

Restituisce il numero di dimensioni nella matrice. La maggior parte delle matrici in PowerShell ha una sola dimensione. Anche quando si ritiene di creare una matrice multidimensionale come nell'esempio seguente:

$a = @(
  @(0,1),
  @("b", "c"),
  @(Get-Process)
)

"`$a rank: $($a.Rank)"
"`$a length: $($a.Length)"
"`$a[2] length: $($a[2].Length)"
"Process `$a[2][1]: $($a[2][1].ProcessName)"

In questo esempio si crea una matrice unidimensionale che contiene altre matrici. Questo è noto anche come matrice frastagliata. La Rank proprietà ha dimostrato che questo è unidimensionale. Per accedere agli elementi in una matrice irregolare, gli indici devono essere racchiusi tra parentesi quadre separate ([]).

$a rank: 1
$a length: 3
$a[2] length: 348
Process $a[2][1]: AcroRd32

Le matrici multidimensionali vengono archiviate in ordine principale di riga. Nell'esempio seguente viene illustrato come creare una matrice realmente multidimensionale.

[string[,]]$rank2 = [string[,]]::New(3,2)
$rank2.rank
$rank2.Length
$rank2[0,0] = 'a'
$rank2[0,1] = 'b'
$rank2[1,0] = 'c'
$rank2[1,1] = 'd'
$rank2[2,0] = 'e'
$rank2[2,1] = 'f'
$rank2[1,1]

2
6
d

Per accedere agli elementi in una matrice multidimensionale, separare gli indici usando una virgola (,) all'interno di un singolo set di parentesi quadre ([]).

Alcune operazioni su una matrice multidimensionale, ad esempio la replica e la concatenazione, richiedono che tale matrice venga appiattita. L'appiattimento trasforma la matrice 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
$a.GetType().Name
$b.GetType().Name
$c.GetType().Name
$c

L'output mostra che $c è una matrice 1-dimensionale contenente gli elementi da $a e $b in ordine principale di riga.

Object[]
Int32[,]
Object[]
red
True
10
20
30
40

Metodi di matrici

Clear

Imposta tutti i valori degli elementi sul valore predefinito del tipo di elemento della matrice. Il Clear() metodo non reimposta le dimensioni della matrice.

Nell'esempio $a seguente è una matrice di oggetti .

$a = 1, 2, 3
$a.Clear()
$a | % { $null -eq $_ }

True
True
True

In questo esempio viene $intA digitato in modo esplicito per contenere numeri interi.

[int[]] $intA = 1, 2, 3
$intA.Clear()
$intA

0
0
0

ForEach()

Consente di scorrere tutti gli elementi nella matrice ed eseguire un'operazione specifica per ogni elemento della matrice.

Il ForEach() metodo dispone di diversi overload che eseguono operazioni diverse.

ForEach(scriptblock expression)
ForEach(scriptblock expression, object[] arguments)
ForEach(type convertToType)
ForEach(string propertyName)
ForEach(string propertyName, object[] newValue)
ForEach(string methodName)
ForEach(string methodName, object[] arguments)

ForEach(espressione scriptblock)

ForEach(espressione scriptblock, argomenti object[] )

Questo metodo è stato aggiunto in PowerShell v4.

Nota

La sintassi richiede l'utilizzo di un blocco di script. Le parentesi sono facoltative se lo scriptblock è l'unico parametro. Inoltre, non deve esistere uno spazio tra il metodo e la parentesi graffa di apertura.

Nell'esempio seguente viene illustrato come usare il ForEach() metodo . In questo caso, la finalità consiste nel generare il valore quadrato degli elementi nella matrice.

$a = @(0 .. 3)
$a.ForEach({ $_ * $_})

0
1
4
9

Proprio come il parametro ArgumentList di ForEach-Object, il arguments parametro consente il passaggio di una matrice di argomenti a un blocco di script configurato per accettarli.

Per altre informazioni sul comportamento di ArgumentList, vedere about_Splatting.

ForEach(type convertToType)

Il metodo può essere utilizzato per eseguire il cast degli elementi in un tipo diverso. Nell'esempio ForEach() seguente viene illustrato come convertire un elenco di date stringa in [DateTime] un tipo.

("1/1/2017", "2/1/2017", "3/1/2017").ForEach([datetime])


Sunday, January 1, 2017 12:00:00 AM
Wednesday, February 1, 2017 12:00:00 AM
Wednesday, March 1, 2017 12:00:00 AM

ForEach(string propertyName)

ForEach(string propertyName, object[] newValue)

Il ForEach() metodo può essere utilizzato anche per recuperare o impostare i valori delle proprietà per ogni elemento dell'insieme.

# Set all LastAccessTime properties of files to the current date.
(dir 'C:\Temp').ForEach('LastAccessTime', (Get-Date))
# View the newly set LastAccessTime of all items, and find Unique entries.
(dir 'C:\Temp').ForEach('LastAccessTime') | Get-Unique

Wednesday, June 20, 2018 9:21:57 AM

ForEach(string methodName)

ForEach(string methodName, object[] arguments)

Lastly, ForEach() i metodi possono essere utilizzati per eseguire un metodo su ogni elemento della raccolta.

("one", "two", "three").ForEach("ToUpper")

ONE
TWO
THREE

Proprio come il parametro ArgumentList di ForEach-Object, il arguments parametro consente il passaggio di una matrice di valori a un blocco di script configurato per accettarli.

Nota

A partire da Windows PowerShell 3.0, è possibile recuperare le proprietà ed eseguire metodi per ogni elemento di una raccolta usando anche "Metodi di oggetti e raccolte scalari". Per altre informazioni, vedere qui about_Methods.

Where()

Consente di filtrare o selezionare gli elementi della matrice. Lo script deve restituire valori diversi da zero (0), stringa $false vuota o $null per visualizzare l'elemento dopo .Where() Per altre informazioni sulla valutazione booleana, vedere about_Booleans.

Esiste una definizione per il Where() metodo .

Where(scriptblock expression[, WhereOperatorSelectionMode mode
                            [, int numberToReturn]])

Nota

La sintassi richiede l'utilizzo di un blocco di script. Le parentesi sono facoltative se lo scriptblock è l'unico parametro. Inoltre, non deve esistere uno spazio tra il metodo e la parentesi graffa di apertura.

Expression è un blocco di script necessario per il filtro, l'argomento mode facoltativo consente funzionalità di selezione aggiuntive e l'argomento numberToReturn facoltativo consente di limitare il numero di elementi restituiti dal filtro.

Il valore di mode deve essere un valore enumerazione WhereOperatorSelectionMode :

  • Default (0) - Restituisce tutti gli elementi
  • First (1) - Restituisce il primo elemento
  • Last (2) - Restituisce l'ultimo elemento
  • SkipUntil (3) - Ignorare gli elementi finché la condizione non è true, restituire tutti gli elementi rimanenti (incluso il primo elemento per il quale la condizione è true)
  • Until (4) - Restituisce tutti gli elementi fino a quando la condizione non è true
  • Split (5) - Restituisce una matrice di due elementi
    • Il primo elemento contiene elementi corrispondenti
    • Il secondo elemento contiene gli elementi rimanenti

Nell'esempio seguente viene illustrato come selezionare tutti i numeri dispari dalla matrice.

(0..9).Where{ $_ % 2 }

1
3
5
7
9

In questo esempio viene illustrato come selezionare le stringhe che non sono vuote.

('hi', '', 'there').Where({$_.Length})

hi
there

Default

La Default modalità filtra gli elementi usando scriptblock Expression .

Se viene specificato un numberToReturn oggetto , specifica il numero massimo di elementi da restituire.

# Get the zip files in the current users profile, sorted by LastAccessTime
$Zips = dir $env:userprofile -Recurse '*.zip' | Sort-Object LastAccessTime
# Get the least accessed file over 100MB
$Zips.Where({$_.Length -gt 100MB}, 'Default', 1)

Nota

Sia la modalità che la Default modalità First restituiscono i primi elementi (numberToReturn) e possono essere usati in modo intercambiabile.

Last

$h = (Get-Date).AddHours(-1)
$logs = dir 'C:\' -Recurse '*.log' | Sort-Object CreationTime
# Find the last 5 log files created in the past hour
$logs.Where({$_.CreationTime -gt $h}, 'Last', 5)

SkipUntil

La SkipUntil modalità ignora tutti gli oggetti di un insieme fino a quando un oggetto non supera il filtro dell'espressione del blocco di script. Restituisce quindi TUTTI gli elementi rimanenti della raccolta senza testarli. Viene testato un solo elemento passing.

Ciò significa che la raccolta restituita contiene sia elementi passatiche non superati.

Il numero di elementi restituiti può essere limitato passando un valore all'argomento numberToReturn .

$computers = "Server01", "Server02", "Server03", "localhost", "Server04"
# Find the first available online server.
$computers.Where({ Test-Connection $_ }, 'SkipUntil', 1)

localhost

Until

La Until modalità inverte la SkipUntil modalità. Restituisce TUTTI gli elementi di una raccolta fino a quando un elemento non passa l'espressione del blocco di script. Quando un elemento passa l'espressione scriptblock, il metodo interrompe l'elaborazione Where() degli elementi.

Ciò significa che si riceve il primo set di elementi non passati dal Where() metodo . Dopo il passaggio di un elemento, il resto non viene testato o restituito.

Il numero di elementi restituiti può essere limitato passando un valore all'argomento numberToReturn .

# Retrieve the first set of numbers less than or equal to 10.
(1..50).Where({$_ -gt 10}, 'Until')
# This would perform the same operation.
(1..50).Where({$_ -le 10})

1
2
3
4
5
6
7
8
9
10

Nota

Sia Until che SkipUntil operano in base al presupposto di NON testare un batch di elementi.

Until restituisce gli elementi PRIMA del primo PASSAGGIO. SkipUntil restituisce tutti gli elementi AFTER il primo passaggio, incluso il primo elemento passato.

Split

La Split modalità divide o raggruppa gli elementi della raccolta in due raccolte separate. Quelli che passano l'espressione scriptblock e quelli che non lo fanno.

Se viene specificato un numberToReturn oggetto , la prima raccolta contiene gli elementi passati , non per superare il valore specificato.

Gli oggetti rimanenti, anche quelli che passano il filtro di espressione, vengono restituiti nella seconda raccolta.

$running, $stopped = (Get-Service).Where({$_.Status -eq 'Running'}, 'Split')
$running

Status   Name               DisplayName
------   ----               -----------
Running  Appinfo            Application Information
Running  AudioEndpointBu... Windows Audio Endpoint Builder
Running  Audiosrv           Windows Audio
...

$stopped

Status   Name               DisplayName
------   ----               -----------
Stopped  AJRouter           AllJoyn Router Service
Stopped  ALG                Application Layer Gateway Service
Stopped  AppIDSvc           Application Identity
...

Nota

Entrambi i ForEach() metodi e Where() sono membri intrinseci. Per altre informazioni sui membri intrinseci, vedere about_Instrinsic_Members.

Ottenere i membri di una matrice

Per ottenere le proprietà e i metodi di una matrice, ad esempio la Length proprietà e il metodo SetValue , utilizzare il parametro InputObject del Get-Member cmdlet .

Quando si invia tramite pipe una matrice a Get-Member, PowerShell invia gli elementi uno alla volta e Get-Member restituisce il tipo di ogni elemento nella matrice (ignorando i duplicati).

Quando si usa il parametro InputObject , Get-Member restituisce i membri della matrice.

Ad esempio, il comando seguente ottiene i membri della variabile di $a matrice.

Get-Member -InputObject $a

È anche possibile ottenere i membri di una matrice digitando una virgola (,) prima del valore inviato tramite pipe al Get-Member cmdlet. La virgola rende la matrice il secondo elemento in una matrice di matrici. PowerShell invia tramite pipe le matrici una alla volta e Get-Member restituisce i membri della matrice. Come i due esempi successivi.

,$a | Get-Member

,(1,2,3) | Get-Member

Modifica di una matrice

È possibile modificare gli elementi in una matrice, aggiungere un elemento a una matrice e combinare i valori di due matrici in una terza matrice.

Per modificare il valore di un particolare elemento in una matrice, specificare il nome della matrice e l'indice dell'elemento da modificare e quindi usare l'operatore di assegnazione (=) per specificare un nuovo valore per l'elemento. Ad esempio, per modificare il valore del secondo elemento nella $a matrice (posizione di indice 1) su 10, digitare:

$a[1] = 10

È anche possibile usare il metodo SetValue di una matrice per modificare un valore. Nell'esempio seguente il secondo valore (posizione di indice 1) della $a matrice viene modificato in 500:

$a.SetValue(500,1)

È possibile usare l'operatore += per aggiungere un elemento a una matrice. Nell'esempio seguente viene illustrato come aggiungere un elemento alla $a matrice.

$a = @(0..4)
$a += 5

Nota

Quando si usa l'operatore += , PowerShell crea effettivamente una nuova matrice con i valori della matrice originale e il valore aggiunto. Ciò può causare problemi di prestazioni se l'operazione viene ripetuta più volte o le dimensioni della matrice sono troppo grandi.

Non è facile eliminare elementi da una matrice, ma è possibile creare una nuova matrice contenente solo elementi selezionati di una matrice esistente. Ad esempio, per creare la $t matrice con tutti gli elementi nella $a matrice, ad eccezione del valore in corrispondenza della posizione di indice 2, digitare:

$t = $a[0,1 + 3..($a.length - 1)]

Per combinare due matrici in una singola matrice, usare l'operatore più (+). L'esempio seguente crea due matrici, le combina e quindi visualizza la matrice combinata risultante.

$x = 1,3
$y = 5,9
$z = $x + $y

Di conseguenza, la $z matrice contiene 1, 3, 5 e 9.

Per eliminare una matrice, assegnare un valore alla $null matrice. Il comando seguente elimina la matrice nella $a variabile .

$a = $null

È anche possibile usare il Remove-Item cmdlet , ma l'assegnazione di un valore è $null più veloce, soprattutto per le matrici di grandi dimensioni.

Matrici pari a zero o uno

A partire da Windows PowerShell 3.0, una raccolta di zero o un oggetto ha le Count proprietà e Length . È anche possibile indicizzare in una matrice di un oggetto. Questa funzionalità consente di evitare errori di scripting che si verificano quando un comando che prevede che una raccolta ottenga meno di due elementi.

Nell'esempio seguente viene illustrato che una variabile che non contiene oggetti ha e CountLength 0.

PS> $a = $null
PS> $a.Count
0
PS> $a.Length
0

Nell'esempio seguente viene illustrato che una variabile che contiene un oggetto ha e CountLength 1. È anche possibile usare l'indicizzazione di matrici per accedere al valore dell'oggetto .

PS> $a = 4
PS> $a.Count
1
PS> $a.Length
1
PS> $a[0]
4
PS> $a[-1]
4

Quando si esegue un comando che potrebbe restituire una raccolta o un singolo oggetto, è possibile utilizzare l'indicizzazione di matrici per accedere al valore dell'oggetto senza dover testare le Count proprietà o Length . Tuttavia, se il risultato è un singolo oggetto (singleton) e tale oggetto ha una Count proprietà o Length , il valore di tali proprietà appartiene all'oggetto singleton e non rappresenta il numero di elementi nell'insieme.

Nell'esempio seguente il comando restituisce un singolo oggetto stringa. L'oggetto Length di tale stringa è 4.

PS> $result = 'one','two','three','four' | Where-Object {$_ -like 'f*'}
PS> $result.GetType().FullName
System.String
PS> $result
four
PS> $result.Count
1
PS❯ $result.Length
4

Se si vuole $result essere una matrice di stringhe, è necessario dichiarare la variabile come matrice.

In questo esempio è $result una matrice di stringhe. e CountLength della matrice è 1e il Length del primo elemento è 4.

PS> [string[]]$result = 'one','two','three','four' |
    Where-Object {$_ -like 'f*'}
PS> $result.GetType().FullName
System.String[]
PS> $result
four
PS> $result.Count
1
PS> $result.Length
1
PS> $result[0].Length
4

Supporto dell'indicizzazione per System.Tuple Oggetti

PowerShell 6.1 ha aggiunto il supporto per l'accesso indicizzato degli Tuple oggetti, simile alle matrici. Ad esempio:

PS> $tuple = [Tuple]::Create(1, 'test')
PS> $tuple[0]
1
PS> $tuple[1]
test
PS> $tuple[0..1]
1
test
PS> $tuple[-1]
test

A differenza delle matrici e di altri oggetti della raccolta, Tuple gli oggetti vengono considerati come un singolo oggetto quando vengono passati attraverso la pipeline o da parametri che supportano matrici di oggetti.

Per altre informazioni, vedere System.Tuple.

Indicizzazione di tipi .NET che implementano IDictionary<TKey, TValue>

PowerShell non chiama l'indicizzatore vero di un tipo per i tipi che implementano l'interfaccia generica IDictionary<TKey, TValue> . Quando viene specificata una chiave, PowerShell verifica invece l'esistenza della chiave usando TryGetValue(), che restituisce $null quando la chiave non esiste.

Al contrario, se si chiama l'indicizzatore true del tipo usando Item(<key>), il metodo genera un'eccezione quando la chiave non esiste.

Nell'esempio che segue viene illustrata la differenza.

PS> [Collections.Generic.Dictionary[string, int]]::new()['nosuchkey']
# No output ($null)

PS> [Collections.Generic.Dictionary[string, int]]::new().Item('nosuchkey')
GetValueInvocationException: Exception getting "Item": "The given key 'nosuchkey'
 was not present in the dictionary."

Enumerazione member-access

A partire da PowerShell 3.0, quando si usa l'operatore di accesso ai membri per accedere a un membro che non esiste in una raccolta di elenchi, PowerShell enumera automaticamente gli elementi nella raccolta e tenta di accedere al membro specificato in ogni elemento. Per altre informazioni, vedere about_Member-Access_Enumeration.

Esempi

Nell'esempio seguente vengono creati due nuovi file e vengono archiviati gli oggetti risultanti nella variabile $filesdi matrice . Poiché l'oggetto matrice non ha il Lastmembro WriteTime, il valore diLast WriteTime viene restituito per ogni elemento nella matrice.

$files = (New-Item -Type File -Force '/temp/t1.txt'),
         (New-Item -Force -Type File '/temp/t2.txt')
$files.LastWriteTime

Friday, June 25, 2021 1:21:17 PM
Friday, June 25, 2021 1:21:17 PM

L'enumerazione di accesso ai membri consente di ottenere valori dagli elementi di una raccolta, ma non di impostare valori sugli elementi di una raccolta. Ad esempio:

$files.LastWriteTime = (Get-Date).AddDays(-1)

InvalidOperation: The property 'LastWriteTime' cannot be found on this object.
Verify that the property exists and can be set.

Per impostare i valori è necessario utilizzare un metodo .

$files.set_LastWriteTime((Get-Date).AddDays(-1))
$files.LastWriteTime

Thursday, June 24, 2021 1:23:30 PM
Thursday, June 24, 2021 1:23:30 PM

Il set_LastWriteTime() metodo è un membro nascosto dell'oggetto FileInfo . Nell'esempio seguente viene illustrato come trovare i membri che dispongono di un metodo nascostoset .

$files | Get-Member | Where-Object Definition -like '*set;*'

   TypeName: System.IO.FileInfo

Name              MemberType Definition
----              ---------- ----------
Attributes        Property   System.IO.FileAttributes Attributes {get;set;}
CreationTime      Property   datetime CreationTime {get;set;}
CreationTimeUtc   Property   datetime CreationTimeUtc {get;set;}
IsReadOnly        Property   bool IsReadOnly {get;set;}
LastAccessTime    Property   datetime LastAccessTime {get;set;}
LastAccessTimeUtc Property   datetime LastAccessTimeUtc {get;set;}
LastWriteTime     Property   datetime LastWriteTime {get;set;}
LastWriteTimeUtc  Property   datetime LastWriteTimeUtc {get;set;}

Attenzione

Poiché il metodo viene eseguito per ogni elemento della raccolta, è necessario prestare attenzione quando si chiamano i metodi usando l'enumerazione dei membri.

Vedi anche