about_Splatting
Aggiornamento: maggio 2014
Si applica a: Windows PowerShell 2.0, Windows PowerShell 3.0, Windows PowerShell 4.0, Windows PowerShell 5.0
ARGOMENTO
about_Splatting
DESCRIZIONE BREVE
In questo argomento viene spiegato come usare lo splatting per passare i parametri ai comandi di Windows PowerShell®.
DESCRIZIONE LUNGA
[Questo argomento è stato redatto da Rohn Edwards di Gulfport, Mississippi, amministratore di sistema e vincitore di Advanced Division per l'edizione 2012 degli Scripting Games. Rivisto per Windows PowerShell 3.0.]
Lo splatting rappresenta un metodo per trasferire una raccolta di valori di parametro al comando come unità. Windows PowerShell associa ogni valore della raccolta a un parametro del comando. I valori di parametro "splatted" vengono archiviati nelle variabili di splatting denominate, simili a variabili standard, ma che iniziano con il simbolo @ anziché con il simbolo del dollaro ($). Il simbolo @ indica a Windows PowerShell che l'utente sta trasferendo una raccolta di valori invece di un singolo valore.
Lo splatting abbrevia i comandi e ne facilita la lettura. È possibile riutilizzare i valori di splatting in diverse chiamate del comando e usare lo splatting per trasferire i valori dei parametri dalla varabile $PSBoundParameters ad altri script e funzioni.
A partire da Windows PowerShell 3.0, è possibile usare lo splatting anche per rappresentare tutti i parametri di un comando.
SINTASSI
<CommandName> <optional parameters> @<HashTable> <optional parameters>
<CommandName> <optional parameters> @<Array> <optional parameters>
Per fornire i valori per i parametri posizionali, che non richiedono nomi, usare la sintassi di matrice. Per fornire le coppie nome parametro/valore, usare la sintassi di tabella hash. Il valore "splatted" può essere visualizzato in qualsiasi punto dell'elenco di parametri.
Durante l'esecuzione dello splatting, non è necessario usare una tabella hash o un array per trasferire tutti i parametri. È possibile trasferire alcuni parametri usando lo splatting e altri in base alla posizione o al nome del parametro. È anche possibile eseguire lo splatting di più oggetti in un comando unico per trasferire soltanto un valore per ogni parametro.
SPLATTING CON LE TABELLE HASH
Usare una tabella hash per eseguire lo splatting della coppia nome/valore del parametro. È possibile usare questo formato per tutti i tipi di parametro, compresi quelli posizionali, denominati e opzionali.
Negli esempi seguenti vengono confrontati i comandi Copy-Item che consentono di copiare il file Test.txt nel file Test2.txt presente nella stessa directory.
Nel primo esempio viene usato il formato tradizionale, nel quale sono inclusi i nomi dei parametri.
Copy-Item -Path "test.txt" -Destination "test2.txt" -WhatIf
Nel secondo esempio viene usato lo spatting della tabella hash. Il primo comando crea una tabella hash delle coppie parametro-nome e parametro-valore e la archivia nella variabile $HashArguments. Il secondo comando usa la variabile $HashArguments in un comando con splatting. Il simbolo della a commerciale (@HashArguments) sostituisce il segno del dollaro ($HashArguments) nel comando.
Per fornire un valore per il parametro opzionale WhatIf, usare $True o $False.
PS C:\>$HashArguments = @{ Path = "test.txt"; Destination = "test2.txt"; WhatIf = $true }
PS C:\>Copy-Item @HashArguments
Nota: Nel primo comando, il simbolo @ indica una tabella hash e non un valore "splatted". La sintassi per le tabelle hash in Windows PowerShell è: @{ <nome>=<valore>; <nome>=<valore>; …}
SPLATTING CON ARRAY
Usare un array per eseguire lo splatting di parametri posizionali, che non richiedono nomi. I valori devono trovarsi nell'ordine posizione-numero all'interno dell'array.
Negli esempi seguenti vengono confrontati i comandi Copy-Item che consentono di copiare il file Test.txt nel file Test2.txt presente nella stessa directory.
Nel primo esempio viene usato il formato tradizionale, nel quale vengono omessi i nomi dei parametri. I valori dei parametri vengono visualizzati in ordine di posizione nel comando.
Copy-Item "test.txt" "test2.txt" -WhatIf
Il secondo esempio usa lo splatting di array. Il primo comando crea un array di valori dei parametri e lo archivia nella variabile $ArrayArguments. I valori sono disposti in ordine di posizione nell'array. Il secondo comando usa la variabile $ArrayArguments in un comando con splatting. Il simbolo della a commerciale (@ArrayArguments) sostituisce il segno del dollaro ($ArrayArguments) nel comando.
PS C:\>$ArrayArguments = "test.txt", "test2.txt"
PS C:\>Copy-Item @ArrayArguments -WhatIf
ESEMPI
In questo esempio viene illustrato come riutilizzare i valori di splatting in comandi diversi. I comandi dell'esempio usano il cmdlet Write-Host per scrivere messaggi nella console del programma host. Usa lo splatting per specificare i colori di primo piano e quelli di sfondo.
Per modificare i colori di tutti i comandi, è sufficiente modificare il valore della variabile $Colors.
Il primo comando crea una tabella hash dei valori dei parametri e la archivia nella variabile $Colors.
$Colors = @{ForegroundColor = "black"
BackgroundColor = "white"}
Il secondo e il terzo comando usano la variabile $Colors per eseguire lo splatting in un comando Write-Host. Per usare la variabile $Colors, sostituire il simbolo del dollaro ($Colors) con quello della a commerciale (@Colors).
# Write a message with the colors in $Colors
Write-Host "This is a test." @Colors
# Write second message with same colors.
# The position of splatted hash table does not matter.
Write-Host @Colors "This is another test."
In questo esempio viene illustrato come inoltrare i parametri ad altri comandi usando lo splatting e la variabile $PSBoundParameters automatica.
La variabile automatica $PSBoundParameters consiste in un dizionario (System.Collections.Generic.Dictionary) che contiene tutti i nomi e i valori dei parametri usati durante l'esecuzione di uno script o di una funzione.
Nell'esempio seguente, viene usata la variabile $PSBoundParameters per inoltrare i valori dei parametri trasmessi a uno script o a una funzione dalla funzione Test2 alla funzione Test1. Entrambe le chiamate alla funzione Test1 da Test2 usano lo splatting.
function Test1
{
param($a, $b, $c)
$a
$b
$c
}
function Test2
{
param($a, $b, $c)
# Call the Test1 function with $a, $b, and $c.
Test1 @PsBoundParameters
# Call the Test1 function with $b and $c, but not with $a
$LimitedParameters = $PSBoundParameters
$LimitedParameters.Remove("a") | Out-Null
Test1 @LimitedParameters
}
PS C:\> Test2 -a 1 -b 2 -c 3
1
2
3
2
3
PARAMETRI DEL COMANDO SPLATTING
È possibile usare lo splatting per rappresentare i parametri di un comando. Questa tecnica è utile quando si crea una funzione di proxy, ovvero una funzione che chiama un altro comando. Questa funzionalità è stata introdotta in Windows PowerShell 3.0.
Per eseguire lo splatting dei parametri di un comando, usare @Args per rappresentare i parametri del comando. Questa tecnica è più facile del conteggio dei parametri del comando e può essere usata senza revisione anche se cambiano i paramenti del comando chiamato.
La funzionalità usa la variabile automatica $Args, che include tutti i valori dei parametri non assegnati. Inserire corpo del testo qui.
Ad esempio, la funzione seguente consente di chiamare il cmdlet Get-Process. In questa funzione @Args rappresenta tutti i parametri del cmdlet Get-Process.
function Get-MyProcess { Get-Process @Args }
Quando si usa la funzione Get-MyProcess, tutti i parametri non assegnati e i loro valori vengono trasferiti ad @Args, come mostrato nei comandi seguenti.
PS C:\> Get-MyProcess -Name PowerShell
Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName
------- ------ ----- ----- ----- ------ -- -----------
463 46 225484 237196 719 15.86 3228 powershell
PS C:\> Get-MyProcess -Name PowerShell_Ise -FileVersionInfo
ProductVersion FileVersion FileName
-------------- ----------- --------
6.2.9200.16384 6.2.9200.1638... C:\Windows\system32\WindowsPowerShell\v1.0\PowerShell_ISE.exe
È possibile usare @Args in una funzione che ha dichiarato in modo esplicito i parametri. È possibile usarlo più volte in una funzione, ma tutti i parametri immessi vengono trasferiti alle istanze di @Args, come mostrato nell'esempio seguente.
function Get-MyCommand
{
Param ([switch]$P, [switch]$C)
if ($P) { Get-Process @Args }
if ($C) { Get-Command @Args }
}
PS C:\> Get-MyCommand -P -C -Name PowerShell
Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName
------- ------ ----- ----- ----- ------ -- -----------
408 28 75568 83176 620 1.33 1692 powershell
Path : C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe
Extension : .exe
Definition : C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe
Visibility : Public
OutputType : {System.String}
Name : powershell.exe
CommandType : Application
ModuleName :
Module :
RemotingCapability : PowerShell
Parameters :
ParameterSets :
HelpUri :
FileVersionInfo : File: C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe
VEDERE ANCHE
about_Arrays
about_Automatic_Variables
about_Hash_Tables
about_Parameters