Condividi tramite

3. Concetti di base

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. Quel documento di Word è stato convertito per essere mostrato qui su 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.

3.1 Fornitori e unità

Un provider consente l'accesso a dati e componenti che altrimenti non sarebbero facilmente accessibili dalla riga di comando. I dati vengono presentati in un formato coerente simile a un'unità di sistema dei file.

I dati esposti da un provider vengono visualizzati in un'unità e i dati sono accessibili tramite un percorso proprio come con un'unità disco. I cmdlet predefiniti per ogni provider gestiscono i dati sul disco del provider.

PowerShell include il set seguente di provider predefiniti per accedere ai diversi tipi di archivi dati:

provider Nome Unità Descrizione Rif.
Pseudonimo Alias: Alias di PowerShell §3.1.1
Ambiente Env: Variabili di ambiente §3.1.2
File System A:, B:, C:, ... Unità disco rigido, cartelle e file §3.1.3
Funzione Funzione: Funzioni di PowerShell §3.1.4
Variabile Variabile: Variabili di PowerShell §3.1.5

Windows PowerShell:

provider Nome Unità Descrizione
Certificato Certificazione Certificati x509 per le firme digitali
Registro HKLM: (HKEY_LOCAL_MACHINE), HKCU: (HKEY_CURRENT_USER) Registro di sistema di Windows
WSMan WSMan: WS-Management informazioni sulla configurazione

I cmdlet seguenti si occupano di provider e dischi:

Il tipo di un oggetto che rappresenta un provider è descritto in §4.5.1. Il tipo di oggetto che rappresenta un disco è descritto in §4.5.2.

3.1.1 Alias (or 3.1.1 Pseudonimi)

Un alias è un nome alternativo per un comando. Un comando può avere più alias e il nome originale e tutti i relativi alias possono essere usati in modo intercambiabile. È possibile riassegnare un alias. Un alias è un elemento (§3.3).

Un alias può essere assegnato a un altro alias; Tuttavia, il nuovo alias non è un alias del comando originale.

L'Alias del provider è uno spazio dei nomi piatto che contiene solo oggetti che rappresentano gli alias. Le variabili non hanno elementi figli.

PowerShell include un set di alias predefiniti.

I cmdlet seguenti gestiscono gli alias:

  • nuovo alias: crea un alias
  • Set-Alias: crea o modifica uno o più alias
  • Get-Alias : ottiene informazioni su uno o più alias
  • Export-Alias: esporta uno o più alias in un file

Quando viene creato un alias per un comando usando New-Alias, i parametri di tale comando non possono essere inclusi in tale alias. Tuttavia, l'assegnazione diretta a una variabile nello spazio dei nomi Alias: consente l'inclusione dei parametri.

Nota

È tuttavia una questione semplice creare una funzione che non faccia altro che contenere la chiamata di tale comando con tutti i parametri desiderati e assegnare un alias a tale funzione.

Il tipo di un oggetto che rappresenta un alias è descritto in §4.5.4.

Gli oggetti alias vengono archiviati sull'unità Alias: (§3.1).

3.1.2 Variabili di ambiente

Il provider di ambiente PowerShell consente di recuperare, aggiungere, modificare, cancellare ed eliminare variabili di ambiente del sistema operativo.

L'ambiente del provider è uno spazio dei nomi flat che contiene solo oggetti che rappresentano le variabili di ambiente. Le variabili non hanno elementi figli.

Il nome di una variabile di ambiente non può includere il segno di uguale (=).

Le modifiche apportate alle variabili di ambiente influiscono solo sulla sessione corrente.

Una variabile di ambiente è un elemento (§3.3).

Il tipo di un oggetto che rappresenta una variabile di ambiente è descritto in §4.5.6.

Le variabili d'ambiente vengono memorizzate nell'unità Env: (§3.1).

3.1.3 File System

Il provider FileSystem di PowerShell consente la creazione, l'apertura, la modifica e l'eliminazione di directory e file.

Il provider FileSystem è uno spazio dei nomi gerarchico che contiene oggetti che rappresentano il file system sottostante.

I file vengono archiviati in unità con nomi come A:, B:, C:e così via (§3.1). È possibile accedere alle directory e ai file usando la notazione del percorso (§3.4).

Una directory o un file è un elemento (§3.3).

3.1.4 Funzioni

Il provider di funzioni di PowerShell consente di recuperare, aggiungere, modificare, cancellare ed eliminare le funzioni (§8.10.1) e i filtri (§8.10.1).

La funzione provider è uno spazio dei nomi flat che contiene solo la funzione e gli oggetti filtro. Né le funzioni né i filtri hanno elementi figli.

Le modifiche apportate alle funzioni influiscono solo sulla sessione corrente.

Una funzione è un elemento (§3.3).

Il tipo di un oggetto che rappresenta una funzione è descritto in §4.5.10. Il tipo di un oggetto che rappresenta un filtro è descritto in §4.5.11.

Gli oggetti funzione vengono archiviati nell'unità disco Function: (§3.1).

3.1.5 Variabili

Le variabili possono essere definite e modificate direttamente nel linguaggio di PowerShell.

Il provider Variable è uno spazio dei nomi piatto che contiene solo oggetti che rappresentano le variabili. Le variabili non hanno elementi figli.

I cmdlet seguenti gestiscono anche le variabili:

Poiché una variabile è un elemento (§3.3), può essere modificato dalla maggior parte dei cmdlet correlati all'elemento.

Il tipo di un oggetto che rappresenta una variabile è descritto in §4.5.3.

Gli oggetti variabile vengono archiviati nell'unità Variabile: (§3.1).

3.2 Posizioni di lavoro

La posizione di lavoro corrente è la posizione predefinita a cui puntano i comandi. Si tratta della posizione utilizzata se non viene specificato un percorso esplicito (§3.4) quando viene richiamato un comando. Questo luogo include l'unità corrente .

Un host di PowerShell può avere più unità, nel qual caso ogni unità ha la propria posizione corrente.

Quando un nome di unità viene specificato senza una directory, è implicito il percorso corrente dell'unità.

La posizione di lavoro corrente può essere salvata in uno stack e quindi impostata su una nuova posizione. Successivamente, la posizione salvata può essere ripristinata da tale stack e impostata come posizione di lavoro corrente. Esistono due tipi di stack di posizioni: lo stack di posizioni di lavoro predefinito e uno o più stack di posizioni di lavoro definiti dall'utente e denominati . All'avvio di una sessione, lo stack di posizioni di lavoro predefinito è anche lo stack di posizioni di lavoro corrente . Tuttavia, qualsiasi stack di posizione di lavoro nominato può diventare lo stack di posizione di lavoro corrente.

I seguenti cmdlet gestiscono i percorsi:

  • Set-Location: Stabilisce la posizione di lavoro corrente
  • Get-Location: determina la posizione di lavoro corrente per le unità specificate o le posizioni di lavoro per gli stack specificati
  • Push-Location: Archivia la posizione di lavoro corrente in cima a uno stack di posizioni specificato
  • Pop-Location: ripristina la posizione di lavoro corrente dalla cima di uno stack di posizioni specificato

I tipi di oggetto che rappresentano una posizione di lavoro e uno stack di posizioni di lavoro sono descritti in §4.5.5.

3.3 Elementi

Un elemento è un alias (§3.1.1), una variabile (§3.1.5), una funzione (§3 1.4), una variabile di ambiente (§3.1.2) o un file o una directory in un file system (§3.1.3).

I cmdlet seguenti gestiscono gli elementi:

  • nuovo elemento: crea un nuovo elemento
  • Set-Item- modifica il valore di uno o più elementi
  • get-item: ottiene gli elementi nella posizione specificata
  • Get-ChildItem: Ottiene gli elementi e i loro elementi figlio nella posizione specificata
  • Copia-elemento: copia uno o più elementi da una posizione a un'altra
  • Move-Item : sposta uno o più elementi da una posizione a un'altra
  • rename-item: Rinomina un elemento
  • Invoke-Item: esegue l'azione predefinita su uno o più elementi
  • Clear-Item: elimina il contenuto di uno o più elementi, ma non elimina gli elementi (vedere
  • Remove-Item: elimina gli elementi specificati

I cmdlet seguenti gestiscono il contenuto degli elementi:

Il tipo di un oggetto che rappresenta una directory è descritto in §4.5.17. Il tipo di un oggetto che rappresenta un file è descritto in §4.5.18.

3.4 Nomi di percorso

Tutti gli elementi in un archivio dati accessibili tramite un provider di PowerShell possono essere identificati in modo univoco in base ai relativi nomi di percorso. Un nome di percorso è una combinazione del nome dell'elemento, del contenitore e dei sottocontenitori in cui si trova l'elemento e dell'unità PowerShell tramite cui si accede ai contenitori.

I nomi dei percorsi si dividono in due tipi: completi e relativi. Un nome di percorso completo è costituito da tutti gli elementi che costituiscono un percorso. La sintassi seguente mostra gli elementi in un nome di percorso completamente qualificato:

Suggerimento

La notazione ~opt~ nelle definizioni della sintassi indica che l'entità lessicale è facoltativa nella sintassi.

path:
    provider~opt~   drive~opt~   containers~opt~   item

provider:
    module~opt~   provider   ::

module:
    module-name   \

drive:
    drive-name   :

containers:
    container   \
    containers container   \

nome modulo si riferisce al modulo padre.

provider fa riferimento al provider PowerShell tramite cui si accede all'archivio dati.

drive si riferisce all'unità PowerShell supportata da un determinato provider PowerShell.

Un contenitore può contenere altri contenitori, che possono contenere altri contenitori e così via, con il contenitore finale che contiene un elemento . I contenitori devono essere specificati nell'ordine gerarchico in cui sono presenti nell'archivio dati.

Di seguito è riportato un esempio di nome di percorso:

E:\Accounting\InvoiceSystem\Production\MasterAccount\MasterFile.dat

Se l'elemento finale in un percorso contiene altri elementi, è un elemento contenitore ; in caso contrario, si tratta di un elemento foglia .

In alcuni casi, non è necessario un nome di percorso completo; sarà sufficiente un nome di percorso relativo. Un nome di percorso relativo si basa sulla posizione di lavoro attuale. PowerShell consente di identificare un elemento in base alla relativa posizione rispetto alla posizione di lavoro corrente. Un nome di percorso relativo prevede l'uso di alcuni caratteri speciali. Nella tabella seguente vengono descritti ognuno di questi caratteri e vengono forniti esempi di nomi di percorso relativi e nomi di percorso completi. Gli esempi nella tabella si basano sulla directory di lavoro corrente impostata su C:\Windows:

simbolo Descrizione percorso relativo percorso completo
. Posizione di lavoro corrente .\System C:\Windows\System
.. Padre della posizione di lavoro corrente ..\Program Files C:\Program Files
\ Radice del disco della posizione corrente \Program Files C:\Program Files
nessuno Nessun carattere speciale System C:\Windows\System

Per usare un nome di percorso in un comando, immettere tale nome come nome completo o relativo del percorso.

I cmdlet seguenti gestiscono i percorsi:

  • Convert-Path : converte un percorso da un percorso di PowerShell a un percorso del provider di PowerShell
  • Join-Path: Combina un percorso e un percorso figlio in un unico percorso
  • Resolve-Path: Risolve i caratteri jolly in un percorso
  • Split-Path: restituisce la parte specificata di un percorso
  • test-path: determina se gli elementi di un percorso esistono o se un percorso è ben formato

Alcuni cmdlet, ad esempio add-content e Copy-Item usano filtri di file. Un filtro file è un meccanismo per definire i criteri di selezione da un insieme di percorsi.

Il tipo di oggetto che rappresenta un percorso risolto è descritto in §4.5.5. I percorsi vengono spesso manipolati come stringhe.

3.5 Ambiti

3.5.1 Introduzione

Un nome può indicare una variabile, una funzione, un alias, una variabile di ambiente o un'unità. Lo stesso nome può indicare elementi diversi in posizioni diverse in uno script. Per ogni diverso elemento che un nome indica, tale nome è visibile solo all'interno della regione del codice chiamata ambito. Gli elementi diversi indicati con lo stesso nome hanno ambiti diversi o si trovano in spazi dei nomi differenti.

Gli ambiti possono annidarsi, nel qual caso, un ambito esterno viene definito ambito padre , ed eventuali ambiti annidati sono ambiti figlio di tale ambito padre. L'ambito di un nome è l'ambito in cui è definito e tutti gli ambiti discendenti, a meno che non sia reso privato. All'interno di un ambito figlio, un nome definito nasconde qualsiasi elemento definito con lo stesso nome negli ambiti padre.

A meno che non venga usata la notazione dot source (§3.5.5), ognuna delle seguenti crea un nuovo ambito:

  • Un file di script
  • Blocco di script
  • Funzione o filtro

Si consideri l'esempio seguente:

# Start of script
$x = 2; $y = 3
Get-Power $x $y

# Function defined in script
function Get-Power([int]$x, [int]$y) {
    if ($y -gt 0) {
        return $x * (Get-Power $x (--$y))
    } else {
        return 1
    }
}
# End of script

L'ambito delle variabili $x e $y creato nello script è il corpo dello script, inclusa la funzione definita al suo interno. La funzione Get-Power definisce due parametri con gli stessi nomi. Poiché ogni funzione ha un proprio ambito, queste variabili sono diverse da quelle definite nell'ambito padre e le nascondono dall'ambito padre. L'ambito della funzione è annidato all'interno dell'ambito dello script.

Si noti che la funzione si chiama in modo ricorsivo. Ogni volta che lo fa, crea un altro ambito annidato, ciascuno con le proprie variabili $x e $y.

Ecco un esempio più complesso, che mostra anche ambiti annidati e riutilizzo dei nomi:

# start of script scope
$x = 2              # top-level script-scope $x created
                    # $x is 2
F1                  # create nested scope with call to function F1
                    # $x is 2
F3                  # create nested scope with call to function F3
                    # $x is 2

function F1 {       # start of function scope
                    # $x is 2
    $x = $true      # function-scope $x created
                    # $x is $true

    & {             # create nested scope with script block
                    # $x is $true
        $x = 12.345 # scriptblock-scope $x created
                    # $x is 12.345
    }               # end of scriptblock scope, local $x goes away

                    # $x is $true
    F2              # create nested scope with call to function F2
                    # $x is $true
}                   # end of function scope, local $x goes away

function F2 {       # start of function scope
                    # $x is $true
    $x = "red"      # function-scope $x created
                    # $x is "red"
}                   # end of function scope, local $x goes away

function F3 {       # start of function scope
                    # $x is 2
    if ($x -gt 0) {
                    # $x is 2
        $x = "green"
                    # $x is "green"
    }               # end of block, but not end of any scope
                    # $x is still "green"
}                   # end of function scope, local $x goes away
# end of script scope

3.5.2 Nomi e numeri di ambito

PowerShell supporta gli ambiti seguenti:

  • Globale: Questo è l'ambito di livello più alto. Tutte le variabili automatiche e di preferenza sono definite in questo ambito. L'ambito globale è l'ambito padre di tutti gli altri ambiti e tutti gli altri ambiti sono ambiti figlio dell'ambito globale.

  • Locale: Questo è l'ambito corrente in qualsiasi punto di esecuzione all'interno di uno script, di un blocco di script o di una funzione. Qualsiasi ambito può essere l'ambito locale.

  • Script: questo ambito esiste per ogni file di script eseguito. L'ambito dello script è l'ambito padre di tutti gli ambiti creati da esso. Un blocco di script non ha un proprio ambito di script; l'ambito è invece quello del file di script antenato più vicino. Anche se l'ambito del modulo non esiste, l'ambito dello script fornisce l'equivalente.

I nomi possono essere dichiarati privati, nel qual caso non sono visibili all'esterno dell'ambito padre, non anche agli ambiti figlio. Il concetto di private non è un ambito separato; è un alias per l'ambito locale con l'aggiunta che, se utilizzato come destinazione di scrittura, il nome viene nascosto.

Gli ambiti possono essere indicati da un numero, che descrive la posizione relativa di un ambito a un altro. L'ambito 0 indica l'ambito locale, l'ambito 1 indica un ambito predecessore di 1 generazione, l'ambito 2 indica un ambito predecessore di 2 generazione e così via. I numeri di ambito vengono usati dai cmdlet che modificano le variabili.

3.5.3 Ambito del nome della variabile

Come illustrato nella produzione seguente, si può specificare un nome di variabile con uno dei sei ambiti diversi:

variable-scope:
    Global:
    Local:
    Private:
    Script:
    Using:
    Workflow:
    variable-namespace

L'ambito è facoltativo. Nella tabella seguente viene illustrato il significato di ognuno in tutti i contesti possibili. Mostra anche l'ambito quando non viene specificato alcun ambito in modo esplicito:

Modificatore dell'Ambito all'interno di un file di script all'interno di un blocco di script all'interno di una funzione
Generale Ambito globale Ambito globale Ambito globale
Script Ambito del file di script predecessore più vicino o Globale se non è presente alcun file di script predecessore più vicino Ambito del file di script predecessore più vicino o Globale se non è presente alcun file di script predecessore più vicino Ambito del file di script predecessore più vicino o Globale se non è presente alcun file di script predecessore più vicino
Privato Ambito globale/script/locale Ambito locale Ambito locale
Locale Ambito globale/script/locale Ambito locale Ambito locale
Usando Implementazione definita Implementazione definita Implementazione definita
Flusso di lavoro Implementazione definita Implementazione definita Implementazione definita
Nessuno Ambito globale/script/locale Ambito locale Ambito locale

Le informazioni sull'ambito delle variabili possono essere specificate anche quando si usa la famiglia di cmdlet elencati in (§3.1.5). In particolare, fare riferimento al parametro Scopee ai parametri Option Private e Option AllScope per altre informazioni.

Il Using: modificatore di ambito viene usato per accedere alle variabili definite in un altro ambito durante l'esecuzione di script tramite cmdlet come Start-Job, Invoke-Commando all'interno di un'istruzione inlinescript. Per esempio:

$a = 42
Invoke-Command --ComputerName RemoteServer { $Using:a } # returns 42
workflow foo
{
    $b = "Hello"
    inlinescript { $Using:b }
}
foo # returns "Hello"

Il flusso di lavoro dell'ambito viene utilizzato con un'istruzione parallela o un'istruzione di sequenza per accedere a una variabile definita nel flusso di lavoro.

3.5.4 Ambito del nome della funzione

Un nome di funzione può anche avere uno dei quattro ambiti diversi e la visibilità di tale nome è uguale a quella delle variabili (§3.5.3).

3.5.5 Notazione sorgente punto

Quando un file di script, un blocco di script o una funzione viene eseguita dall'interno di un altro file di script, blocco di script o funzione, il file di script eseguito crea un nuovo ambito annidato. Per esempio

Script1.ps1
& "Script1.ps1"
& { ... }
FunctionA

Tuttavia, quando si usa notazione di origine punto, non viene creato alcun nuovo ambito prima dell'esecuzione del comando, quindi aggiunte/modifiche apportate al proprio ambito locale vengono apportate all'ambito corrente. Per esempio

. Script2.ps1
. "Script2.ps1"
. { ... }
. FunctionA

Moduli 3.5.6

Proprio come un file di script di primo livello è alla radice di un albero dell'ambito gerarchicamente annidato, così lo è anche ogni modulo (§3.14). Tuttavia, per impostazione predefinita, solo i nomi esportati da un modulo sono disponibili per nome all'interno del contesto di importazione. Il parametro Global del cmdlet Import-Module consente ai nomi esportati di avere una maggiore visibilità.

3.6 Proprietà ReadOnly e Costanti

Le variabili e gli alias sono descritti dagli oggetti che contengono una serie di proprietà. Queste proprietà vengono impostate e modificate da due famiglie di cmdlet (§3.1.5, §3.1.1). Una di queste proprietà è Options, che può essere impostata su ReadOnly o Constant (usando il parametro Option). È possibile rimuovere una variabile o un alias contrassegnato come ReadOnly e le relative proprietà possono essere modificate a condizione che venga specificato il parametro Force. Tuttavia, non è possibile rimuovere una variabile o un alias contrassegnato come Costante né modificarne le proprietà.

3.7 Sovraccarico del metodo e risoluzione delle chiamate

3.7.1 Introduzione

Come indicato in §1, una procedura esterna resa disponibile dall'ambiente di esecuzione (e scritta in un linguaggio diverso da PowerShell) viene chiamata metodo .

Il nome di un metodo insieme al numero e ai tipi dei relativi parametri viene chiamato collettivamente firma del metodo. Si noti che la firma non include il tipo restituito del metodo. L'ambiente di esecuzione può consentire a un tipo di avere più metodi con lo stesso nome fornito ognuno con una firma diversa. Quando vengono definite più versioni di un metodo, questo metodo viene detto sovraccarico. Ad esempio, il tipo Math (§4.3.8) contiene un set di metodi denominati Abs, che calcola il valore assoluto di un numero specificato, in cui il numero specificato può avere uno dei diversi tipi. I metodi in tale set hanno le firme seguenti:

Abs(decimal)
Abs(float)
Abs(double)
Abs(int)
Abs(long)
Abs(SByte)
Abs(Int16)

In questo caso, tutti i metodi hanno lo stesso numero di argomenti; le firme differiscono solo per tipo di argomento.

Un altro esempio riguarda il tipo Array (§4.3.2), che contiene un set di metodi denominato Copy che copia un intervallo di elementi da una matrice a un'altra, a partire dall'inizio di ogni matrice (per impostazione predefinita) o da un elemento designato. I metodi in tale set hanno le firme seguenti:

Copy(Array, Array, int)
Copy(Array, Array, long)
Copy(Array, int, Array, int, int)
Copy(Array, long, Array, long, long)

In questo caso, le firme differiscono in base al tipo di argomento e, in alcuni casi, anche al numero di argomento.

Nella maggior parte delle chiamate ai metodi sovraccarichi, il numero e il tipo degli argomenti passati corrispondono esattamente a uno dei sovraccarichi e il metodo selezionato è chiaro. Tuttavia, se non è così, è necessario un modo per risolvere quale versione sovraccaricata chiamare, se esiste. Per esempio

[Math]::Abs([byte]10) # no overload takes type byte
[array]::Copy($source, 3, $dest, 5L, 4) # both int and long indexes

Altri esempi includono il tipo stringa (ad esempio, System.String), che presenta numerosi metodi sovraccaricati.

Anche se PowerShell dispone di regole per la risoluzione delle chiamate ai metodi che non corrispondono esattamente a una firma sovraccaricata, PowerShell non offre un modo per definire metodi sovraccarichi.

Nota

Nota dell'editor: PowerShell 5.0 ha aggiunto la possibilità di definire classi basate su script. Queste classi possono contenere metodi sovraccaricati.

3.7.2 Risoluzione dell'overload del metodo

Data una chiamata al metodo (§7.1.3) con un elenco di espressioni di argomento e un set di metodo candidatos (ovvero i metodi che potrebbero essere chiamati), il meccanismo per la selezione del metodo migliore viene chiamato risoluzione dell'overload.

Dato il set di metodi candidati applicabili (§3.7.3), viene selezionato il metodo migliore in tale set. Se il set contiene un solo metodo, tale metodo è il metodo migliore. In caso contrario, il metodo migliore è quello migliore di tutti gli altri metodi rispetto all'elenco di argomenti specificato usando le regole illustrate in §3.7.4. Se non esiste esattamente un metodo migliore di tutti gli altri metodi, la chiamata al metodo è ambigua e viene segnalato un errore.

Il metodo migliore deve essere accessibile nel contesto in cui viene chiamato. Ad esempio, uno script di PowerShell non può chiamare un metodo privato o protetto.

Il metodo migliore per una chiamata a un metodo statico deve essere un metodo statico e il metodo migliore per una chiamata a un metodo di istanza deve essere un metodo di istanza.

3.7.3 Metodo applicabile

Si dice che un metodo sia applicabile rispetto a un elenco di argomenti A quando una delle condizioni seguenti è vera:

  • Il numero di argomenti in A è identico al numero di parametri accettati dal metodo.
  • Il metodo ha parametri obbligatori M e N parametri facoltativi e il numero di argomenti in A è maggiore o uguale a M, ma minore di N.
  • Il metodo accetta un numero variabile di argomenti e il numero di argomenti in A è maggiore del numero di parametri accettati dal metodo.

Oltre a avere un numero appropriato di argomenti, ogni argomento in A deve corrispondere alla modalità di passaggio dei parametri dell'argomento e il tipo di argomento deve corrispondere al tipo di parametro oppure deve essere presente una conversione dal tipo di argomento al tipo di parametro.

Se il tipo di argomento è ref (§4.3.6), anche il parametro corrispondente deve essere ref e il tipo di argomento a scopo di conversione è il tipo della proprietà Value dell'argomento ref.

Se il tipo di argomento è ref, il parametro corrispondente potrebbe essere out anziché ref.

Se il metodo accetta un numero variabile di argomenti, il metodo può essere applicabile sia in forma normale sia in forma espansa. Se il numero di argomenti in A è identico al numero di parametri accettati dal metodo e l'ultimo parametro è una matrice, il modulo dipende dal rango di una delle due conversioni possibili:

  • Classificazione della conversione dal tipo dell'ultimo argomento in A al tipo di matrice per l'ultimo parametro.
  • Grado della conversione dal tipo dell'ultimo argomento in A al tipo dell'elemento dell'array per il parametro finale.

Se la prima conversione (nel tipo di matrice) è migliore della seconda conversione (al tipo di elemento della matrice), il metodo è applicabile in forma normale, altrimenti è applicabile in formato espanso.

Se sono presenti più argomenti rispetto ai parametri, il metodo può essere applicabile solo in formato espanso. Per essere applicabile in formato espanso, l'ultimo parametro deve avere un tipo di matrice. Il metodo viene sostituito con un metodo equivalente con l'ultimo parametro sostituito con parametri sufficienti per tenere conto di ogni argomento non corrispondente in A. Ogni tipo di parametro aggiuntivo è il tipo di elemento del tipo di matrice per l'ultimo parametro nel metodo originale. Le regole precedenti per un metodo applicabile vengono applicate a questo nuovo metodo e all'elenco di argomenti A.

3.7.4 Metodo Migliore

Dato un elenco di argomenti A con un set di espressioni di argomento { E~1~, E~2~, ..., E~N~ } e due metodi dell'applicazione M~P~ e M~Q~ con tipi di parametro { P~1~, P~2~, ..., P~N~ } e { Q~1~, Q~2~, ..., Q~N~ }, M~P~ è definito un metodo migliore di M~Q~ se la classificazione cumulativa delle conversioni per M~P~ è migliore di quella per M~Q~.

La classificazione cumulativa delle conversioni viene calcolata nel modo seguente. Ogni conversione vale un valore diverso a seconda del numero di parametri, con la conversione di E~1~ che vale N, E~2~ che vale N-1, fino a E~N~ che vale 1. Se la conversione da E~X~ a P~X~ è migliore rispetto a quella da E~X~ a Q~X~, il M~P~ accumula N-X+1; in caso contrario, M~Q~ accumula N-X+1. Se M~P~ e M~Q~ hanno lo stesso valore, vengono applicate in ordine le seguenti regole di spareggio:

  • La classificazione cumulativa delle conversioni tra tipi di parametro (ignorando i tipi di argomento) viene calcolata in modo simile alla classificazione precedente, pertanto P~1~ viene confrontata con Q~1~, P~2~ rispetto a Q~2~, ...e P~N~ rispetto a Q~N~. Il confronto viene ignorato se l'argomento è stato $nullo se i tipi di parametro non sono tipi numerici. Il confronto viene ignorato anche se la conversione dell'argomento E~X~ perde informazioni quando viene convertita in P~X~ ma non perde informazioni quando viene convertita in Q~X~o viceversa. Se vengono confrontati i tipi di conversione dei parametri, se la conversione da P~X~ a Q~X~ è migliore rispetto a quella da Q~X~ a P~X~, l'M~P~ accumula N-X+1; in caso contrario, M~Q~ accumula N-X+1. Questa regola di spareggio è destinata a preferire il metodo più specifico (ovvero, il metodo con i parametri con i tipi di dati più piccoli) se non vengono perse informazioni nelle conversioni, o a preferire il metodo più generale (ovvero, il metodo con i parametri con i tipi di dati più grandi) se le conversioni comportano la perdita di informazioni.
  • Se entrambi i metodi usano il formato espanso, il metodo con più parametri è il metodo migliore.
  • Se un metodo utilizza il form espanso e l'altro usa il formato normale, il metodo che usa la forma normale è il metodo migliore.

3.7.5 Conversione migliore

Il testo seguente contrassegnato come questo è specifico di Windows PowerShell.

Le conversioni vengono classificate nel modo seguente, dal più basso al più alto:

  • T~1~[] a T~2~[] in cui non esiste alcuna conversione assegnabile tra T~1~ e T~2~
  • Da T a una stringa in cui T può essere di qualsiasi tipo
  • T~1~ a T~2~ in cui T~1~ o T~2~ definiscono una conversione personalizzata in modo definito dall'implementazione
  • T~1~ a T~2~ in cui T~1~ implementa IConvertible
  • T~1~ a T~2~ in cui T~1~ o T~2~ implementa il metodo T~2~ op_Implicit(T1)
  • T~1~ a T~2~ in cui T~1~ o T~2~ implementa il metodo T~2~ op_Explicit(T1)
  • T~1~ a T~2~ in cui T~2~ implementa un costruttore che accetta un singolo argomento di tipo T~1~
  • Una delle conversioni seguenti:
    • stringa per T in cui T implementa un metodo statico T Parse(string) o T Parse(string, IFormatProvider)
    • T~1~ a T~2~ in cui T~2~ è qualsiasi enumerazione e T~1~ è una stringa o una raccolta di oggetti che possono essere convertiti in stringa
  • T a PSObject dove T è qualsiasi tipo
  • Una delle conversioni seguenti: Language
    • Da T a bool dove T è qualsiasi tipo numerico
    • Stringa per T in cui T è regex, wmisearcher, wmi, wmiclass, adsi, adsisearcheroppure type
    • T a bool
    • T~1~ per Nullable[T~2~] dove esiste una conversione da T~1~ a T~2~
    • T annullare
    • T~1~[] a T~2~[] in cui esiste una conversione assegnabile tra T~1~ e T~2~
    • da T~1~ a T~2~[] dove T~1~ è una raccolta
    • IDictionary a Hashtable
    • T a ref
    • T a xml
    • scriptblock a delegate
    • T~1~ a T~2~ dove T~1~ è un tipo intero e T~2~ è enumerazione
  • $null a T dove T è qualsiasi tipo di valore
  • $null a T dove T è qualsiasi tipo di riferimento
  • Una delle conversioni seguenti:

    • byte verso T in cui T è SByte

    • UInt16 T in cui T è SByte, byteo Int16

    • Int16 T in cui T è SByte o byte

    • UInt32 T in cui T è SByte, byte, Int16, UInt16o int

    • int T in cui T è SByte, byte, Int16o UInt16

    • UInt64 T in cui T è SByte, byte, Int16, UInt16, int, UInt32o long

    • long a T in cui T è SByte, byte, Int16, UInt16, into UInt32

    • float a T dove T è qualsiasi tipo integer o decimal

    • double a T dove T è qualsiasi tipo integer o decimal

    • decimal a T dove T è qualsiasi tipo integer

  • Una delle conversioni seguenti:
    • SByte T in cui T è byte, uint6, UInt32o UInt64
    • Int16 T in cui T è UInt16, UInt32o UInt64
    • int T in cui T è UInt32 o UInt64
    • long a UInt64
    • decimal T in cui T è float o double
  • Una delle conversioni seguenti:
    • T a string dove T è qualsiasi tipo numerico
    • T a char dove T è qualsiasi tipo numerico
    • string a T dove T è qualsiasi tipo numerico
  • Qualsiasi delle seguenti conversioni viene considerata una conversione assegnabile:
    • byte T in cui T è Int16, UInt16, int, UInt32, long, UInt64, single, doubleo decimal
    • SByte T in cui T è Int16, UInt16, int, UInt32, long, UInt64, single, doubleo decimal
    • UInt16 T in cui T è int, UInt32, longo UInt64, single, doubleo decimal
    • Int16 T in cui T è int, UInt32, longo UInt64, single, doubleo decimal
    • UInt32 T in cui T è longo UInt64, single, doubleo decimal
    • int T in cui T è long, UInt64, single, doubleo decimal
    • single a double
  • T~1~ a T~2~ in cui T~2~ è una classe o un'interfaccia di base di T~1~. Questa conversione è considerata una conversione assegnabile.
  • string a char[]
  • T a T: questa conversione viene considerata una conversione assegnabile.

Per ogni conversione del modulo T~1~ in T~2~[] in cui T~1~ non è una matrice e non si applica alcuna altra conversione, se è presente una conversione da T~1~ a T~2~, il rango della conversione è peggiore della conversione da T~1~ a T~2~, ma meglio di qualsiasi conversione classificata meno della conversione da T~1~ a T~2~

3.8 Ricerca nome

È possibile avere comandi di tipi diversi con lo stesso nome. L'ordine in cui la ricerca del nome viene eseguita in questo caso è alias, funzione, cmdlet e comando esterno.

3.9 Ricerca del nome del tipo

§7.1.10 contiene l'istruzione "Un tipo letterale è rappresentato in un'implementazione da un tipo sottostante non specificato. Di conseguenza, un nome di tipo è un sinonimo del tipo sottostante." Esempi di tipi sono int, double, long[]e Hashtable.

I nomi dei tipi vengono confrontati come segue: confrontare un nome di tipo specificato con l'elenco di acceleratori di tipi predefiniti , ad esempio int, long, double. Se viene trovata una corrispondenza, quello è il tipo. In caso contrario, supponi che il nome del tipo sia completamente qualificato e verifica se tale tipo esiste nel sistema host. Se viene trovata una corrispondenza, quello è il tipo. Nel caso contrario, aggiungere il prefisso dello spazio dei nomi System.. Se viene trovata una corrispondenza, quello è il tipo. In caso contrario, il nome del tipo contiene un errore. Questo algoritmo viene applicato per ogni argomento di tipo per i tipi generici. Non è tuttavia necessario specificare l'arità (il numero di argomenti o operandi presi da una funzione o un operatore).

3.10 Gestione automatica della memoria

Vari operatori e cmdlet comportano l'allocazione della memoria per oggetti di tipo riferimento, ad esempio stringhe e matrici. L'allocazione e la liberazione di questa memoria vengono gestite dal sistema di runtime di PowerShell. Ovvero, PowerShell fornisce il garbage collection automatico.

3.11 Ordine di esecuzione

Un effetto collaterale è una modifica nello stato dell'ambiente di esecuzione di un comando. Una modifica al valore di una variabile (tramite gli operatori di assegnazione o gli operatori di pre- e post-incremento e decremento) è un effetto collaterale, così come lo è una modifica ai contenuti di un file.

Se non specificato diversamente, le istruzioni vengono eseguite in ordine lessicale.

Ad eccezione di quanto specificato per alcuni operatori, l'ordine di valutazione dei termini in un'espressione e l'ordine in cui si verificano gli effetti collaterali sono entrambi non specificati.

Un'espressione che richiama un comando implica l'espressione che definisce il comando e zero o più espressioni che designano gli argomenti i cui valori devono essere passati a tale comando. L'ordine in cui queste espressioni vengono valutate l'una rispetto all'altra non è specificata.

3.12 Gestione degli errori

Quando un comando non riesce, viene considerato un errore e le informazioni su quell'errore vengono registrate in un record di errore , il cui tipo non è specificato (§4.5.15); tuttavia, questo tipo supporta la sottoscrizione.

Un errore rientra in una delle due categorie. Termina l'operazione (un errore irreversibile) oppure no (un errore non irreversibile). Con un errore fatale, viene registrato l'errore e l'operazione viene arrestata. Con un errore non terminante, viene registrato l'errore e l'operazione continua.

Gli errori non terminanti vengono scritti nel flusso di errori. Anche se tali informazioni possono essere reindirizzate a un file, gli oggetti di errore vengono prima convertiti in stringhe e informazioni importanti in tali oggetti non vengono acquisiti rendendo difficile la diagnosi, se non impossibile. Al contrario, il testo dell'errore può essere reindirizzato (§7.12) e l'oggetto errore salvato in una variabile, come in $Error1 = command 2>&1.

La variabile automatica $Error contiene una raccolta di record di errore che rappresentano errori recenti e l'errore più recente si trova in $Error[0]. Questa raccolta viene mantenuta in un buffer in modo che i record precedenti vengano eliminati man mano che vengono aggiunti nuovi record. La variabile automatica $MaximumErrorCount controlla il numero di record che è possibile archiviare.

$Error contiene tutti gli errori di tutti i comandi combinati in un'unica raccolta. Per raccogliere gli errori da un comando specifico, usare il parametro comune ErrorVariable, che consente di specificare una variabile definita dall'utente per contenere la raccolta.

3.13 Le Pipeline

Una pipeline è una serie composta da uno o più comandi, ciascuno separato dall'operatore pipe | (U+007C). Ogni comando riceve l'input dal predecessore e scrive l'output al successore. A meno che l'output alla fine della pipeline non venga rimosso o reindirizzato a un file, viene inviato all'ambiente host, che può scegliere di scriverlo nell'output standard. I comandi in una pipeline possono anche ricevere input dai parametri. Si consideri ad esempio l'uso seguente di comandi Get-ChildItem, Sort-Objecte Process-File, che creano un elenco di nomi di file in una determinata directory del file system, ordinano un set di record di testo ed eseguono alcune elaborazioni rispettivamente su un record di testo:

Get-ChildItem
Get-ChildItem E:*.txt | Sort-Object -CaseSensitive | Process-File >results.txt

Nel primo caso, Get-ChildItem crea una raccolta di nomi dei file nella directory corrente/predefinita. Tale raccolta viene inviata all'ambiente host, che, per impostazione predefinita, scrive il valore di ogni elemento nell'output standard.

Nel secondo caso, Get-ChildItem crea una raccolta di nomi dei file nella directory specificata, usando l'argomento E:*.txt. Tale raccolta viene scritta nel comando Sort-Object, che, per impostazione predefinita, li ordina in ordine crescente, con distinzione tra maiuscole e minuscole (in virtù dell'argomento CaseSensitive). La raccolta risultante viene quindi scritta nel comando Process-File, che esegue un'elaborazione (sconosciuta). L'output di tale comando viene quindi reindirizzato al file results.txt.

Se un comando scrive un singolo oggetto, il successore riceve tale oggetto e quindi termina dopo aver scritto i propri oggetti al suo successore. Se, tuttavia, un comando scrive più oggetti, vengono recapitati uno alla volta al comando successore, che viene eseguito una volta per ogni oggetto. Questo comportamento viene chiamato streaming. Nella elaborazione del flusso, gli oggetti vengono scritti lungo la pipeline non appena sono disponibili, anziché attendere che sia prodotta l'intera raccolta.

Quando si elabora una raccolta, è possibile scrivere un comando in modo che possa eseguire un'elaborazione speciale prima dell'elemento iniziale e dopo l'elemento finale.

3.14 Moduli

Un modulo è un'unità riutilizzabile autonoma che consente il partizionamento, l'organizzazione e l'astrazione del codice di PowerShell. Un modulo può contenere comandi (ad esempio cmdlet e funzioni) e elementi (ad esempio variabili e alias) che possono essere usati come singola unità.

Dopo aver creato un modulo, deve essere importato in una sessione prima che sia possibile usare i comandi e gli elementi all'interno di esso. Dopo l'importazione, i comandi e gli elementi si comportano come se fossero stati definiti localmente. Un modulo viene importato in modo esplicito con il comando Import-Module. Un modulo può anche essere importato automaticamente come determinato in modo definito dall'implementazione.

Il tipo di un oggetto che rappresenta un modulo è descritto in §4.5.12.

I moduli sono descritti in dettaglio in §11.

3.15 Espressioni con caratteri jolly

Un'espressione con caratteri jolly può contenere zero o più elementi seguenti:

Elemento Descrizione
Carattere diverso da *, ? o [ Corrisponde a quel singolo carattere
* Corrisponde a zero o più caratteri. Per abbinare un carattere *, usa [*].
? Corrisponde a un solo carattere. Per trovare una corrispondenza con un oggetto ? carattere: usare [?].
[imposta]

Corrisponde a qualsiasi carattere singolo dal set , che non può essere vuoto.

Se il set inizia con ], quella parentesi quadra destra viene considerata parte del set e la successiva parentesi quadra destra termina il set; altrimenti, la prima parentesi quadra destra termina il set.

Se il set inizia o termina con -, quel trattino meno viene considerato parte del set ; in caso contrario, indica un intervallo di punti di codice Unicode consecutivi, con i caratteri su entrambi i lati del trattino meno come delimitatori di intervallo inclusivo. Ad esempio, A-Z indica le 26 lettere maiuscole in inglese e 0-9 indica le 10 cifre decimali.

Nota

Altre informazioni sono disponibili in «The Open Group Base Specifications: Pattern Matching», IEEE Std 1003.1, 2004 Edition.. Tuttavia, in PowerShell, il carattere di escape è il backtick, non la barra rovesciata.

3.16 Espressioni regolari

Un'espressione regolare può contenere zero o più elementi seguenti:

Elemento Descrizione
Carattere diverso da ., [, ^, *, $, o \ Corrisponde a quel singolo carattere
. Corrisponde a un solo carattere. Per trovare una corrispondenza con un oggetto . carattere, usa \..
[imposta]
[^configura]

La forma [insieme] corrisponde a un qualsiasi carattere da un insieme di caratteri insieme. La forma [^set] non contiene caratteri di set. impostato non può essere vuoto.

Se il set inizia con ] o ^], tale parentesi quadra chiusa viene considerata parte del set e la successiva parentesi quadra chiusa termina il set; altrimenti, la prima parentesi quadra chiusa termina il set.

Se l'insieme inizia con - o ^-, o termina con -, tale segno meno viene considerato parte dell'insieme ; in caso contrario, indica un intervallo di punti di codice Unicode consecutivi, con i caratteri ai due lati del trattino meno che fungono da delimitatori inclusivi dell'intervallo. Ad esempio, A-Z indica le 26 lettere maiuscole in inglese e 0-9 indica le 10 cifre decimali.
* Corrisponde a zero o più occorrenze dell'elemento che precede.
+ Corrisponde ad una o più occorrenze dell'elemento precedente.
? Corrisponde a zero di una occorrenza dell'elemento precedente.
^ Corrisponde all'inizio della stringa. Per trovare una corrispondenza con il carattere ^, utilizzare \^.
$ Corrisponde alla fine della stringa. Per trovare la corrispondenza con un carattere $, utilizzare $.
\ c Fa l'escape del carattere c, quindi non viene riconosciuto come elemento di espressione regolare.

Nota

Altre informazioni sono disponibili in, The Open Group Base Specifications: Regular Expressions, IEEE Std 1003.1, 2004 Edition..

Windows PowerShell: le classi di caratteri disponibili nelle espressioni regolari di Microsoft .NET Framework sono supportate, come indicato di seguito:

Elemento Descrizione
\p{name} Corrisponde a qualsiasi carattere nella classe di caratteri denominata specificata da nome. I nomi supportati sono gruppi Unicode e intervalli di blocchi, ad esempio Ll, Nd, Z, IsGreek e IsBoxDrawing.
\P{name} Corrisponde al testo che non è incluso nei gruppi e negli intervalli di blocchi specificati in nome.
\w Trova la corrispondenza con qualsiasi carattere di parola. Equivalente alle categorie di caratteri Unicode [\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}]. Se si specifica un comportamento conforme a ECMAScript con l'opzione ECMAScript, \w equivale a [a-zA-Z_0-9].
\W Trova qualsiasi carattere che non sia una parola. Equivalente alle categorie Unicode [\^\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}].
\s Corrisponde a qualsiasi carattere di spazio bianco. Equivalente alle categorie di caratteri Unicode [\f\n\r\t\v\x85\p{Z}].
\S Corrisponde a qualsiasi carattere che non è uno spazio bianco. Equivalente alle categorie di caratteri Unicode [\^\f\n\r\t\v\x85\p{Z}].
\d Trova la corrispondenza con qualsiasi cifra decimale. Equivale a \p{Nd} per Unicode e [0-9] per il comportamento non Unicode.
\D Trova la corrispondenza con qualsiasi carattere non numerico. Equivale a \P{Nd} per Unicode e [\^0-9] per il comportamento non Unicode.

I quantificatori disponibili nelle espressioni regolari di Microsoft .NET Framework sono supportati, come indicato di seguito:

Elemento Descrizione
* Specifica zero o più corrispondenze. Ad esempio, \w* o (abc)*. equivale a {0,}.
+ Corrisponde a istanze ripetute dei caratteri precedenti.
? Specifica zero o una corrispondenze; ad esempio \w? o (abc)?. Equivalente a {0,1}.
{n} Specifica esattamente n corrispondenze; ad esempio, (pizza){2}.
{n,} Specifica almeno n corrispondenze; ad esempio, (abc){2,}.
{n,m} Specifica almeno n, ma non più di m, corrisponde.
  • Last updated on