about_Command_Precedence

Kort beskrivning

Beskriver hur PowerShell avgör vilket kommando som ska köras.

Lång beskrivning

Kommandopriorence beskriver hur PowerShell avgör vilket kommando som ska köras när en session innehåller fler än ett kommando med samma namn. Kommandon i en session kan döljas eller ersättas av kommandon med samma namn. Den här artikeln visar hur du kör dolda kommandon och hur du undviker konflikter med kommandonamn.

Kommandopriorence

När en PowerShell-session innehåller fler än ett kommando som har samma namn avgör PowerShell vilket kommando som ska köras med hjälp av följande regler.

Om du anger sökvägen till ett kommando kör PowerShell kommandot på den plats som anges av sökvägen.

Följande kommando kör till exempel skriptet FindDocs.ps1 i C:\TechDocs katalogen:

C:\TechDocs\FindDocs.ps1

Du kan köra alla körbara kommandon med hjälp av dess fullständiga sökväg. Som en säkerhetsfunktion kör PowerShell inte körbara kommandon, inklusive PowerShell-skript och interna kommandon, såvida inte kommandot finns i en sökväg som anges i $env:Path miljövariabeln.

Om du vill köra en körbar fil som finns i den aktuella katalogen anger du den fullständiga sökvägen eller använder den relativa sökvägen .\ för att representera den aktuella katalogen.

Om du till exempel vill köra FindDocs.ps1 filen i den aktuella katalogen skriver du:

.\FindDocs.ps1

Om du inte anger en sökväg använder PowerShell följande prioritetsordning när den kör kommandon.

1. Alias
2. Funktion
3. Cmdlet (se Cmdlet-namnmatchning)
4. Externa körbara filer (inklusive PowerShell-skriptfiler)

Om du skriver helpletar PowerShell först efter ett alias med namnet help, sedan en funktion med namnet Helpoch slutligen en cmdlet med namnet Help. Det kör det första help objektet som hittas.

Om din session till exempel innehåller en cmdlet och en funktion, båda med namnet Get-Map, när du skriver Get-Map, kör PowerShell funktionen.

Lösa objekt med samma namn

Som ett resultat av dessa regler kan objekt ersättas eller döljas av objekt med samma namn.

Objekt döljs eller skuggas om du fortfarande kan komma åt det ursprungliga objektet, till exempel genom att kvalificera objektnamnet med ett modulnamn.

Om du till exempel importerar en funktion som har samma namn som en cmdlet i sessionen är cmdleten dold men inte ersatt. Du kan köra cmdleten genom att ange dess modulkvalificerade namn.

När objekt ersätts eller skrivs över kan du inte längre komma åt det ursprungliga objektet.

Om du till exempel importerar en variabel som har samma namn som en variabel i sessionen ersätts den ursprungliga variabeln. Du kan inte kvalificera en variabel med ett modulnamn.

Om du skapar en funktion på kommandoraden och sedan importerar en funktion med samma namn ersätts den ursprungliga funktionen.

Hitta dolda kommandon

Parametern Alla i cmdleten Get-Command hämtar alla kommandon med det angivna namnet, även om de är dolda eller ersatta. Från och med PowerShell 3.0 hämtas som standard Get-Command endast de kommandon som körs när du skriver kommandonamnet.

I följande exempel innehåller sessionen en Get-Date funktion och en Get-Date-cmdlet . Du kan använda Get-Command för att avgöra vilket kommando som väljs först.

Get-Command Get-Date

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

Använder parametern Alla för att visa tillgängliga Get-Date kommandon.

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

Du kan köra vissa kommandon genom att inkludera kvalificerande information som skiljer kommandot från andra kommandon som kan ha samma namn. För cmdletar kan du använda det modulkvalificerade namnet. För körbara filer kan du inkludera filtillägget. Om du till exempel vill köra den körbara versionen av where användningen where.exe.

Använda modulkvalificerade namn

Med hjälp av det modulkvalificerade namnet på en cmdlet kan du köra kommandon som döljs av ett objekt med samma namn. Du kan till exempel köra cmdleten Get-Date genom att kvalificera den med dess modulnamn Microsoft.PowerShell.Utility eller dess sökväg. När du använder modulkvalificerade namn kan modulen automatiskt importeras till sessionen beroende på värdet $PSModuleAutoLoadingPreferenceför .

Med hjälp av modulkvalificerade namn ser du till att du kör kommandot som du tänker köra. Det här är den rekommenderade metoden för att anropa cmdletar när du skriver skript som du tänker distribuera.

I följande exempel visas hur du kvalificerar ett kommando genom att inkludera dess modulnamn.

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

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

Om du vill köra ett New-Map kommando från modulen MapFunctions använder du dess modulkvalificerade namn:

MapFunctions\New-Map

Om du vill hitta modulen från vilken ett kommando importerades använder du modulename-egenskapen för kommandon.

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

Om du till exempel vill hitta källan till cmdleten Get-Date skriver du:

(Get-Command Get-Date).ModuleName

Microsoft.PowerShell.Utility

Om du vill kvalificera namnet på kommandot med hjälp av sökvägen till modulen måste du använda snedstrecket (/) som sökvägsavgränsare och omvänt snedstreck (\) före kommandonamnet. Använd följande exempel för att köra cmdleten Get-Date :

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

Sökvägen kan vara en fullständig sökväg eller en sökväg som är relativ till den aktuella platsen. I Windows kan du inte använda en enhetskvalificerad sökväg. Du måste använda en UNC-sökväg, som du ser i föregående exempel, eller en sökväg som är relativ till den aktuella enheten. I följande exempel förutsätts att din aktuella plats finns på C: enheten.

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

Använda samtalsoperatorn

Du kan också använda anropsoperatorn (&) för att köra dolda kommandon genom att kombinera den med ett anrop till Get-ChildItem (aliaset är dir) Get-Command eller Get-Module.

Anropsoperatorn kör strängar och skriptblock i ett underordnat omfång. Mer information finns i about_Operators.

Använd till exempel följande kommando för att köra funktionen med namnet Map som är dold av ett alias med namnet Map.

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

eller

& (dir Function:\map)

Du kan också spara det dolda kommandot i en variabel för att göra det enklare att köra.

Följande kommando sparar Map till exempel funktionen i variabeln $myMap och använder sedan operatorn Call för att köra den.

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

Ersatta objekt

Ett ersatt objekt är ett objekt som du inte längre kan komma åt. Du kan ersätta objekt genom att importera objekt med samma namn från en modul.

Om du till exempel skriver en Get-Map funktion i sessionen och importerar en funktion med namnet Get-Mapersätter den den ursprungliga funktionen. Du kan inte hämta den i den aktuella sessionen.

Variabler och alias kan inte döljas eftersom du inte kan använda en anropsoperator eller ett kvalificerat namn för att köra dem. När du importerar variabler och alias från en modul ersätter de variabler i sessionen med samma namn.

Cmdlet-namnmatchning

När du inte använder det kvalificerade namnet på en cmdlet kontrollerar PowerShell om cmdleten läses in i den aktuella sessionen. Om det finns flera inlästa moduler som innehåller samma cmdlet-namn använder PowerShell cmdleten från den första modulen som hittades alfabetiskt.

Om cmdleten inte läses in söker PowerShell igenom de installerade modulerna och läser in den första modulen automatiskt som innehåller cmdleten och kör cmdleten. PowerShell söker efter moduler i varje sökväg som definierats i $env:PSModulePath miljövariabeln. Sökvägarna genomsöks i den ordning som de visas i variabeln. Inom varje sökväg genomsöks modulerna i alfabetisk ordning. PowerShell använder cmdleten från den första matchningen som hittas.

Undvika namnkonflikter

Det bästa sättet att hantera konflikter med kommandonamn är att förhindra dem. När du namnger dina kommandon använder du ett unikt namn. Du kan till exempel lägga till dina initialer eller företagsnamnsakronymen i substantiven i dina kommandon.

När du importerar kommandon till sessionen från en PowerShell-modul eller från en annan session kan du använda parametern Prefix för cmdleten Import-Module eller Import-PSSession för att lägga till ett prefix i substantiven i namnen på kommandona.

Följande kommando undviker till exempel eventuella konflikter med Get-Date cmdletarna och Set-Date som medföljer PowerShell när du importerar modulen DateFunctions .

Import-Module -Name DateFunctions -Prefix ZZ

Köra externa körbara filer

I Windows. PowerShell behandlar filnamnstilläggen $env:PATHEXT som anges i miljövariabeln som körbara filer. Filer som inte är körbara Windows-filer överlämnas till Windows för att bearbetas. Windows letar upp filassociationen och kör standardverb för Windows Shell för tillägget. För att Windows ska kunna stödja körningen av filnamnstillägget måste associationen registreras med systemet.

Du kan registrera den körbara motorn för ett filnamnstillägg med hjälp ftype av kommandona och assoc för CMD-kommandogränssnittet. PowerShell har ingen direkt metod för att registrera filhanteraren. Mer information finns i dokumentationen för ftype-kommandot .

För att PowerShell ska kunna se ett filnamnstillägg som körbart i den aktuella sessionen måste du lägga till tillägget i $env:PATHEXT miljövariabeln.

Se även

• about_Aliases
• about_Functions
• about_Path_Syntax
• Aliasprovider
• Funktionsprovider
• Get-Command
• Import-Module
• Import-PSSession