about_Command_Precedence

Articolo
03/07/2024

Descrizione breve

Descrive in che modo PowerShell determina il comando da eseguire.

Descrizione lunga

La precedenza dei comandi descrive in che modo PowerShell determina il comando da eseguire quando una sessione contiene più di un comando con lo stesso nome. I comandi all'interno di una sessione possono essere nascosti o sostituiti da comandi con lo stesso nome. Questo articolo illustra come eseguire comandi nascosti e come evitare conflitti di nomi di comando.

Precedenza del comando

Quando una sessione di PowerShell include più comandi con lo stesso nome, PowerShell determina il comando da eseguire usando le regole seguenti.

Se si specifica il percorso di un comando, PowerShell esegue il comando nella posizione specificata dal percorso.

Ad esempio, il comando seguente esegue lo script FindDocs.ps1 nella C:\TechDocs directory:

C:\TechDocs\FindDocs.ps1

È possibile eseguire qualsiasi comando eseguibile usando il percorso completo. Come funzionalità di sicurezza, PowerShell non esegue comandi eseguibili, inclusi gli script di PowerShell e i comandi nativi, a meno che il comando non si trovi in un percorso elencato nella $env:Path variabile di ambiente.

Per eseguire un file eseguibile presente nella directory corrente, specificare il percorso completo o usare il percorso .\ relativo per rappresentare la directory corrente.

Ad esempio, per eseguire il FindDocs.ps1 file nella directory corrente, digitare:

.\FindDocs.ps1

Se non si specifica un percorso, PowerShell usa l'ordine di precedenza seguente quando esegue i comandi.

Alias
Funzione
Cmdlet (vedere Risoluzione dei nomi dei cmdlet)
File eseguibili esterni (inclusi i file di script di PowerShell)

Pertanto, se si digita help, PowerShell cerca innanzitutto un alias denominato , quindi una funzione denominata Helphelpe infine un cmdlet denominato Help. Esegue il primo help elemento trovato.

Ad esempio, se la sessione contiene un cmdlet e una funzione, entrambi denominati Get-Map, quando si digita Get-Map, PowerShell esegue la funzione.

Nota

Questo vale solo per i comandi caricati. Se è presente un build eseguibile e un alias build per una funzione con il nome di all'interno di Invoke-Build un modulo non caricato nella sessione corrente, PowerShell esegue invece l'eseguibile build . Non carica automaticamente i moduli se trova l'eseguibile esterno. È solo quando non viene rilevato alcun eseguibile esterno che viene richiamato un alias, una funzione o un cmdlet con il nome specificato.

Risoluzione degli elementi con gli stessi nomi

In seguito a queste regole, gli elementi possono essere sostituiti o nascosti da elementi con lo stesso nome.

Gli elementi sono nascosti o ombreggiati se è comunque possibile accedere all'elemento originale, ad esempio qualificando il nome dell'elemento con un nome di modulo.

Ad esempio, se si importa una funzione con lo stesso nome di un cmdlet nella sessione, il cmdlet viene nascosto, ma non sostituito. È possibile eseguire il cmdlet specificando il nome completo del modulo.

Quando gli elementi vengono sostituiti o sovrascritti, non è più possibile accedere all'elemento originale.

Ad esempio, se si importa una variabile con lo stesso nome di una variabile nella sessione, la variabile originale viene sostituita. Non è possibile qualificare una variabile con un nome di modulo.

Se si crea una funzione nella riga di comando e quindi si importa una funzione con lo stesso nome, la funzione originale viene sostituita.

Ricerca di comandi nascosti

Il parametro All del cmdlet Get-Command ottiene tutti i comandi con il nome specificato, anche se sono nascosti o sostituiti. A partire da PowerShell 3.0, per impostazione predefinita, Get-Command ottiene solo i comandi eseguiti quando si digita il nome del comando.

Negli esempi seguenti la sessione include una Get-Date funzione e un cmdlet Get-Date . È possibile usare Get-Command per determinare quale comando viene scelto per primo.

Get-Command Get-Date

CommandType     Name                      ModuleName
-----------     ----                      ----------
Function        Get-Date

Usa il parametro All per elencare i comandi disponibili Get-Date .

Get-Command Get-Date -All

CommandType     Name                 Version    Source
-----------     ----                 -------    ------
Function        Get-Date
Cmdlet          Get-Date             7.0.0.0    Microsoft.PowerShell.Utility

Get-Command where -All

CommandType Name                     Version      Source
----------- ----                     -------      ------
Alias       where -> Where-Object
Application where.exe                10.0.22621.1 C:\Windows\system32\where.exe

È possibile eseguire comandi specifici includendo informazioni qualificanti che distinguono il comando da altri comandi con lo stesso nome. Per i cmdlet, è possibile usare il nome completo del modulo. Per i file eseguibili, è possibile includere l'estensione di file. Ad esempio, per eseguire la versione eseguibile dell'uso where.exedi where .

Usare nomi completi di modulo

L'uso del nome completo del modulo di un cmdlet consente di eseguire comandi nascosti da un elemento con lo stesso nome. Ad esempio, è possibile eseguire il Get-Date cmdlet qualificandolo con il nome del modulo Microsoft.PowerShell.Utility o il relativo percorso. Quando si usano nomi completi di modulo, il modulo può essere importato automaticamente nella sessione a seconda del valore di $PSModuleAutoLoadingPreference.

Nota

Non è possibile usare nomi di modulo per qualificare variabili o alias.

L'uso di nomi completi di modulo garantisce che si esegua il comando che si intende eseguire. Questo è il metodo consigliato per chiamare i cmdlet durante la scrittura di script che si intende distribuire.

Nell'esempio seguente viene illustrato come qualificare un comando includendo il nome del modulo.

Importante

La qualifica del modulo usa il carattere barra rovesciata (\) per separare il nome del modulo dal nome del comando, indipendentemente dalla piattaforma.

New-Alias -Name "Get-Date" -Value "Get-ChildItem"
Microsoft.PowerShell.Utility\Get-Date

Tuesday, May 16, 2023 1:32:51 PM

Per eseguire un New-Map comando dal modulo, usare il nome completo del MapFunctions modulo:

MapFunctions\New-Map

Per trovare il modulo da cui è stato importato un comando, usare la proprietà ModuleName dei comandi.

(Get-Command <command-name>).ModuleName

Ad esempio, per trovare l'origine del Get-Date cmdlet, digitare:

(Get-Command Get-Date).ModuleName

Microsoft.PowerShell.Utility

Se si vuole qualificare il nome del comando usando il percorso del modulo, è necessario usare la barra (/) come separatore di percorso e il carattere barra rovesciata (\) prima del nome del comando. Usare l'esempio seguente per eseguire il Get-Date cmdlet :

//localhost/c$/Progra~1/PowerShell/7-preview/Modules/Microsoft.PowerShell.Utility\Get-Date

Il percorso può essere un percorso completo o un percorso relativo alla posizione corrente. In Windows non è possibile usare un percorso completo dell'unità. È necessario usare un percorso UNC, come illustrato nell'esempio precedente o un percorso relativo all'unità corrente. Nell'esempio seguente si presuppone che la posizione corrente si trova nell'unità C: .

/Progra~1/PowerShell/7-preview/Modules/Microsoft.PowerShell.Utility\Get-Date

Usare l'operatore di chiamata

È anche possibile usare l'operatore di chiamata (&) per eseguire comandi nascosti combinandolo con una chiamata a Get-ChildItem (l'alias è dir) Get-Command o Get-Module.

L'operatore di chiamata esegue stringhe e blocchi di script in un ambito figlio. Per altre informazioni, vedere about_Operators.

Ad esempio, usare il comando seguente per eseguire la funzione denominata Map nascosta da un alias denominato Map.

& (Get-Command -Name Map -CommandType Function)

& (dir Function:\map)

È anche possibile salvare il comando nascosto in una variabile per semplificare l'esecuzione.

Ad esempio, il comando seguente salva la Map funzione nella $myMap variabile e quindi usa l'operatore Call per eseguirlo.

$myMap = (Get-Command -Name map -CommandType function)
& ($myMap)

Elementi sostituiti

Un elemento sostituito è un elemento a cui non è più possibile accedere. È possibile sostituire gli elementi importando elementi con lo stesso nome da un modulo.

Ad esempio, se si digita una Get-Map funzione nella sessione e si importa una funzione denominata Get-Map, sostituisce la funzione originale. Non è possibile recuperarlo nella sessione corrente.

Le variabili e gli alias non possono essere nascosti perché non è possibile usare un operatore di chiamata o un nome completo per eseguirli. Quando si importano variabili e alias da un modulo, le variabili nella sessione vengono sostituite con lo stesso nome.

Risoluzione dei nomi dei cmdlet

Quando non si usa il nome completo di un cmdlet, PowerShell verifica se il cmdlet viene caricato nella sessione corrente. Se sono presenti più moduli caricati che contengono lo stesso nome di cmdlet, PowerShell usa il cmdlet del primo modulo trovato alfabeticamente.

Se il cmdlet non viene caricato, PowerShell cerca i moduli installati e carica automaticamente il primo modulo che contiene il cmdlet ed esegue tale cmdlet. PowerShell cerca i moduli in ogni percorso definito nella variabile di $env:PSModulePath ambiente. I percorsi vengono cercati nell'ordine in cui sono elencati nella variabile . All'interno di ogni percorso, i moduli vengono cercati in ordine alfabetico. PowerShell usa il cmdlet dalla prima corrispondenza trovata.

Evitare conflitti di nomi

Il modo migliore per gestire i conflitti dei nomi dei comandi consiste nel prevenirli. Quando si assegna un nome ai comandi, usare un nome univoco. Ad esempio, aggiungere le iniziali o l'acronimo del nome della società ai sostantivi nei comandi.

Quando si importano comandi nella sessione da un modulo di PowerShell o da un'altra sessione, è possibile usare il Prefix parametro del cmdlet Import-Module o Import-PSSession per aggiungere un prefisso ai nomi dei comandi.

Ad esempio, il comando seguente evita qualsiasi conflitto con i Get-Date cmdlet e Set-Date disponibili con PowerShell quando si importa il DateFunctions modulo.

Import-Module -Name DateFunctions -Prefix ZZ

Esecuzione di file eseguibili esterni

In Windows. PowerShell considera le estensioni di file elencate nella $env:PATHEXT variabile di ambiente come file eseguibili. I file che non sono eseguibili di Windows vengono passati a Windows per l'elaborazione. Windows cerca l'associazione di file ed esegue il verbo predefinito della shell di Windows per l'estensione. Affinché Windows supporti l'esecuzione in base all'estensione di file, l'associazione deve essere registrata con il sistema.

È possibile registrare il motore eseguibile per un'estensione di file usando i ftype comandi e assoc della shell dei comandi CMD. PowerShell non dispone di metodi diretti per registrare il gestore di file. Per altre informazioni, vedere la documentazione per il comando ftype .

Per visualizzare un'estensione di file come eseguibile nella sessione corrente, è necessario aggiungere l'estensione alla $env:PATHEXT variabile di ambiente.

Condividi tramite