about_Script_Blocks

  • Articolo

Descrizione breve

Definisce che cos'è un blocco di script e spiega come usare blocchi di script nel linguaggio di programmazione di PowerShell.

Descrizione lunga

Nel linguaggio di programmazione di PowerShell un blocco di script è una raccolta di istruzioni o espressioni che possono essere usate come singola unità. La raccolta di istruzioni può essere racchiusa tra parentesi graffe ({}), definita come funzione o salvata in un file di script. Un blocco di script può restituire valori e accettare parametri e argomenti.

Sintatticamente, un blocco di script è un elenco di istruzioni tra parentesi graffe, come illustrato nella sintassi seguente:

{<statement list>}

Un blocco di script restituisce l'output di tutti i comandi nel blocco di script, come singolo oggetto o come matrice.

È anche possibile specificare un valore restituito usando la return parola chiave . La return parola chiave non influisce o elimina altri output restituiti dal blocco di script. Tuttavia, la return parola chiave esce dal blocco di script in corrispondenza di tale riga. Per altre informazioni, vedere about_Return.

Come le funzioni, un blocco di script può includere parametri. Usare la parola chiave Param per assegnare parametri denominati, come illustrato nella sintassi seguente:

{
    Param([type]$Parameter1 [,[type]$Parameter2])
    <statement list>
}

Nota

In un blocco di script, a differenza di una funzione, non è possibile specificare parametri all'esterno delle parentesi graffe.

Analogamente alle funzioni, i blocchi di script possono includere le DynamicParamparole chiave , BeginProcess, e End . Per altre informazioni, vedere about_Functions e about_Functions_Advanced.

Uso di blocchi di script

Un blocco di script è un'istanza di un tipo System.Management.Automation.ScriptBlockMicrosoft .NET Framework. I comandi possono avere valori dei parametri del blocco di script. Ad esempio, il Invoke-Command cmdlet ha un parametro che accetta un ScriptBlock valore di blocco di script, come illustrato in questo esempio:

Invoke-Command -ScriptBlock { Get-Process }

Handles  NPM(K)    PM(K)     WS(K) VM(M)   CPU(s)     Id ProcessName
-------  ------    -----     ----- -----   ------     -- -----------
999          28    39100     45020   262    15.88   1844 communicator
721          28    32696     36536   222    20.84   4028 explorer
...

Invoke-Command può anche eseguire blocchi di script con blocchi di parametri. I parametri vengono assegnati in base alla posizione usando il parametro ArgumentList .

Invoke-Command -ScriptBlock { param($p1, $p2)
"p1: $p1"
"p2: $p2"
} -ArgumentList "First", "Second"

p1: First
p2: Second

Il blocco di script nell'esempio precedente usa la param parola chiave per creare parametri $p1 e $p2. La stringa "First" è associata al primo parametro ($p1) e "Second" è associata a ($p2).

Per altre informazioni sul comportamento di ArgumentList, vedere about_Splatting.

È possibile usare le variabili per archiviare ed eseguire blocchi di script. L'esempio seguente archivia un blocco di script in una variabile e lo passa a Invoke-Command.

$a = { Get-Service BITS }
Invoke-Command -ScriptBlock $a

Status   Name               DisplayName
------   ----               -----------
Running  BITS               Background Intelligent Transfer Ser...

L'operatore di chiamata è un altro modo per eseguire blocchi di script archiviati in una variabile. Analogamente Invoke-Commanda , l'operatore di chiamata esegue il blocco di script in un ambito figlio. L'operatore di chiamata può semplificare l'uso dei parametri con i blocchi di script.

$a ={ param($p1, $p2)
"p1: $p1"
"p2: $p2"
}
&$a -p2 "First" -p1 "Second"

p1: Second
p2: First

È possibile archiviare l'output dei blocchi di script in una variabile usando l'assegnazione.

PS>  $a = { 1 + 1}
PS>  $b = &$a
PS>  $b
2

PS>  $a = { 1 + 1}
PS>  $b = Invoke-Command $a
PS>  $b
2

Per altre informazioni sull'operatore di chiamata, vedere about_Operators.

Uso di blocchi di script di associazione ritardata con parametri

Un parametro tipizzato che accetta l'input della pipeline consente l'uso di blocchi di script di associazione ritardata nel parametro . È possibile usare blocchi di script delay-bind come sintassi abbreviata per definire i parametri per un cmdlet con pipeline prima di eseguirlo.

All'interno del blocco di script di associazione ritardata è possibile fare riferimento all'oggetto inviato tramite pipe usando la variabile $_della pipeline .

# Both examples rename config.log to old_config.log
# Without delay-binding
dir config.log | ForEach-Object -Process {
  Rename-Item -Path $_ -NewName "old_$($_.Name)"
}
# With delay-binding
dir config.log | Rename-Item -NewName { "old_$($_.Name)" }

Nei cmdlet più complessi, i blocchi di script di associazione ritardata consentono il riutilizzo di un oggetto inviato tramite pipe nell'oggetto per popolare altri parametri.

Note sui blocchi di script di associazione ritardata come parametri:

  • È necessario specificare in modo esplicito i nomi dei parametri usati con blocchi di script di associazione ritardata.

  • Il parametro non deve essere tipizzato e il tipo del parametro non può essere [scriptblock] o [object].

  • Viene visualizzato un errore se si usa un blocco di script di associazione ritardata senza fornire l'input della pipeline.

    Rename-Item -NewName {$_.Name + ".old"}

    Rename-Item : Cannot evaluate parameter 'NewName' because its argument is
specified as a script block and there is no input. A script block cannot
be evaluated without input.
At line:1 char:23
+  Rename-Item -NewName {$_.Name + ".old"}
+                       ~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : MetadataError: (:) [Rename-Item],
      ParameterBindingException
    + FullyQualifiedErrorId : ScriptBlockArgumentNoInput,
      Microsoft.PowerShell.Commands.RenameItemCommand

Vedi anche