about_Modules

Artikel
11/12/2024

Kort beskrivning

Förklarar hur du installerar, importerar och använder PowerShell-moduler.

Lång beskrivning

PowerShell är både ett kommandogränssnitt och ett skriptspråk. Kommandon i PowerShell implementeras som skript, funktioner eller cmdletar. Språket innehåller nyckelord som ger strukturen och logiken för bearbetning och andra resurser, till exempel variabler, providers, alias.

En modul är en fristående, återanvändbar enhet som kan innehålla cmdletar, leverantörer, funktioner, variabler och andra resurser. Som standard läser PowerShell automatiskt in en installerad modul första gången du använder ett kommando från modulen. Du kan konfigurera funktionen för automatisk inläsning av moduler med hjälp av variabeln $PSModuleAutoloadingPreference. Mer information finns i about_Preference_Variables.

Du kan också läsa in eller ta bort moduler manuellt under en PowerShell-session. Om du vill läsa in eller läsa in en modul igen använder du Import-Module. Om du vill ta bort en modul använder du cmdleten Remove-Module .

PowerShell innehåller en basuppsättning moduler. Vem som helst kan skapa nya moduler med hjälp av C# eller själva PowerShell-skriptspråket. Moduler som skrivits i C# som kompilerade .NET-sammansättningar kallas för inbyggda moduler. Moduler skrivna i PowerShell kallas skriptmoduler.

Den här artikeln beskriver hur du använder PowerShell-moduler. Information om hur du skapar PowerShell-moduler finns i Skriva en PowerShell-modul.

Kommentar

Innan PowerShell 3.0 paketerades cmdletar och leverantörer i PowerShell-snapin-moduler. Från och med PowerShell 3.0 läggs snapin-modulen Microsoft.PowerShell.Core till i varje session som standard. Det här är den enda snapin-modulen som finns kvar i PowerShell. Alla andra snapin-moduler konverterades till moduler. Det går inte längre att skapa nya snapin-moduler.

Standardmodulplatser

PowerShell lagrar moduler på följande standardplatser:

I Windows
- Alla användares omfång – $env:ProgramFiles\PowerShell\Modules
- Aktuellt användaromfång – $HOME\Documents\PowerShell\Modules
- Moduler som levereras med PowerShell – $PSHOME\Modules
I Linux och macOS
- Alla användares omfång – /usr/local/share/powershell/Modules
- Aktuellt användaromfång – $HOME/.local/share/powershell/Modules
- Moduler som levereras med PowerShell – $PSHOME/Modules

Som standard Modules finns inte mappen för den aktuella användaren. Om du har installerat en modul i omfånget CurrentUser med eller Install-Module Install-PSResourceskapar Modules dessa cmdletar mappen för den aktuella användaren. Om mappen inte finns kan du skapa den manuellt.

Använd följande kommando för att skapa en Modules mapp för den aktuella användaren:

$folder = New-Item -Type Directory -Path $HOME\Documents\PowerShell\Modules

Dessa platser ingår automatiskt i $env:PSModulePath miljövariabeln. Mer information om standardmodulplatserna finns i about_PSModulePath.

Automatisk inläsning av modul

Första gången du kör ett kommando från en installerad modul importerar PowerShell automatiskt (läser in) modulen. Modulen måste lagras på de platser som anges i $env:PSModulePath miljövariabeln.

Med automatisk inläsning av moduler kan du använda kommandon i en modul utan konfiguration eller profilkonfiguration. Vart och ett av följande exempel gör att CimCmdlets-modulen , som innehåller Get-CimInstance, importeras till din session.

Kör kommandot
```
Get-CimInstance Win32_OperatingSystem
```
Hämta kommandot
```
Get-Command Get-CimInstance
```
Få hjälp för kommandot
```
Get-Help Get-CimInstance
```

När du använder Get-Command med jokertecken (*) importerar Inte PowerShell några moduler. Du kan använda jokertecken för kommandoidentifiering utan att läsa in moduler som du kanske inte behöver i sessionen.

Importera en modul manuellt

Du måste importera en modul manuellt när en modul inte är installerad på de platser som anges av $env:PSModulePath miljövariabeln, eller när modulen tillhandahålls som en fristående .dll modul eller .psm1 fil i stället för en paketerad modul.

Kommandon som använder PowerShell-providers importerar inte heller automatiskt en modul. Om du till exempel använder ett kommando som kräver WSMan: enheten, till exempel cmdleten Get-PSSessionConfiguration , kan du behöva köra cmdleten Import-Module för att importera modulen Microsoft.WSMan.Management som innehåller WSMan: enheten.

Du kanske också vill ändra hur modulen importeras i sessionen. Till exempel lägger prefixparametern Import-Module för till ett distinkt prefix till substantivdelen av cmdletarna som importeras från modulen. Parametern NoClobber förhindrar att modulen lägger till kommandon som skulle dölja eller ersätta befintliga kommandon i sessionen. Mer information finns i Hantera namnkonflikter.

I följande exempel importeras BitsTransfer-modulen till den aktuella sessionen.

Import-Module BitsTransfer

Om du vill importera en modul som inte finns i använder $env:PSModulePathdu den fullständigt kvalificerade sökvägen till modulmappen. Om du till exempel vill lägga till TestCmdlets-modulen C:\ps-test i katalogen i sessionen skriver du:

Import-Module C:\ps-test\TestCmdlets

Om du vill importera en modulfil som inte finns i en modulmapp använder du den fullständigt kvalificerade sökvägen till modulfilen i kommandot . Om du till exempel vill lägga till modulen TestCmdlets.dll i C:\ps-test katalogen i sessionen skriver du:

Import-Module C:\ps-test\TestCmdlets.dll

Mer information om hur du lägger till moduler i sessionen finns i Import-Module.

Importera en modul i början av varje session

Kommandot Import-Module importerar moduler till din aktuella PowerShell-session. Om du vill importera en modul till varje PowerShell-session som du startar lägger du till kommandot i Import-Module din PowerShell-profil.

Mer information om profiler finns i about_Profiles.

Installera en publicerad modul

En publicerad modul är en modul som är tillgänglig från en registrerad lagringsplats, till exempel PowerShell-galleriet. Modulerna PowerShellGet och Microsoft.PowerShell.PSResourceGet tillhandahåller cmdletar för att hitta, installera och publicera PowerShell-moduler till en registrerad lagringsplats.

PowerShellGet-modulen ingår i PowerShell 5.0 och senare versioner. Modulen Microsoft.PowerShell.PSResourceGet ingår i PowerShell 7.4 och senare versioner och är den föredragna pakethanteraren för PowerShell. Microsoft.PowerShell.PSResourceGet kan installeras sida vid sida med PowerShellGet i äldre versioner av PowerShell. Använd cmdleten Install-Module eller Install-PSResource för att installera moduler från PowerShell-galleriet.

 Get-Command Install-Module, Install-PSResource

CommandType  Name                Version    Source
-----------  ----                -------    ------
Function     Install-Module      2.9.0      PowerShellGet
Cmdlet       Install-PSResource  1.0.0      Microsoft.PowerShell.PSResourceGet

Mer information finns i Översikt över PowerShellGet.

Installera en modul manuellt

Du kan installera en modul manuellt genom att kopiera modulinnehållet från en annan mapp. Den mappen kan finnas på en annan plats på den lokala datorn eller vara installerad på en annan dator. Om du vill installera en modul manuellt kopierar du hela modulmappen till en ny plats som ingår i .$env:PSModulePath

I PowerShell använder du cmdleten Copy-Item . Kör till exempel följande kommando för att kopiera MyModule mappen från C:\PSTest:

$modulePath = $HOME\Documents\PowerShell\Modules\MyModule
Copy-Item -Path C:\PSTest\MyModule\* -Destination $modulePath -Recurse

Du kan installera en modul på valfri plats, men om du installerar modulerna på en standardmodulplats blir det enklare att hantera dem.

Hitta installerade moduler

Cmdleten Get-Module hämtar PowerShell-modulerna som läses in i den aktuella PowerShell-sessionen.

Get-Module

Modulerna i listan kan innehålla moduler som har importerats från valfri plats, inte bara från $env:PSModulePath.

Använd följande kommando för att lista moduler som är installerade i $env:PSModulePath:

Get-Module -ListAvailable

Det här kommandot hämtar alla moduler som är installerade i $env:PSModulePath, inte bara de moduler som importeras till den aktuella sessionen. Det här kommandot visar inte moduler som är installerade på andra platser.

Mer information finns i Get-Module.

Visa en lista över kommandona i en modul

Använd cmdleten Get-Command för att hitta alla tillgängliga kommandon. Du kan använda parametrarna för cmdleten Get-Command för att filtrera kommandon, till exempel efter modul, namn och substantiv.

Om du vill hitta alla kommandon i en modul skriver du:

Get-Command -Module <module-name>

Om du till exempel vill hitta kommandona i BitsTransfer-modulen skriver du:

Get-Command -Module BitsTransfer

Mer information om cmdleten finns i Get-Command Get-Command.

Ta bort en modul

När du tar bort en modul tas de kommandon som modulen lade till bort från sessionen. Följande kommando tar till exempel bort BitsTransfer-modulen från den aktuella sessionen.

Remove-Module BitsTransfer

Om du tar bort en modul återställs åtgärden att importera en modul. Om du tar bort en modul avinstalleras inte modulen. Mer information finns i Ta bort modul.

Kommandon kan läggas till i sessionen från moduler och snapin-moduler. Moduler kan lägga till alla typer av kommandon, inklusive cmdletar, providers och funktioner och objekt, till exempel variabler, alias och PowerShell-enheter. Snapin-moduler kan bara lägga till cmdletar och providers.

Innan du tar bort en modul från sessionen använder du följande kommandon för att avgöra vilken modul du vill ta bort.

Använd till exempel följande kommando för att hitta källan Get-Date till cmdletarna och Get-Help :

Get-Command Get-Date, Get-Help -All |
    Select-Object -Property Name, CommandType, Module ,PSSnapIn

Följande utdata visar att cmdleten Get-Help finns i snapin-modulen Microsoft.PowerShell.Core . Det går inte att ta bort den här snapin-modulen från sessionen.

Name     CommandType Module                       PSSnapIn
----     ----------- ------                       --------
Get-Date    Function
Get-Date      Cmdlet Microsoft.PowerShell.Utility
Get-Help      Cmdlet                              Microsoft.PowerShell.Core

Det finns två källor för Get-Date. Den ena är en funktion och den andra är en cmdlet i modulen Microsoft.PowerShell.Utility . Du kan ta bort modulen med .Remove-Module Om du vill ta bort funktionen kan du ta bort den Function: från enheten.

Remove-Item Function:Get-Date

Mer information om enheten finns i Function: about_Function_Provider.

Hantera namnkonflikter

Namnkonflikter uppstår när fler än ett kommando i sessionen har samma namn. Om du importerar en modul uppstår en namnkonflikt när kommandon i modulen har samma namn som kommandon eller objekt i sessionen.

Import-Module kan lägga till kommandon som döljer och ersätter kommandon i den aktuella sessionen. Namnkonflikter kan leda till att kommandon döljs eller ersätts. Kommandobyte sker när den importerade modulen innehåller ett kommando med samma namn som ett befintligt kommando i sessionen. Det nyligen importerade kommandot har företräde framför det befintliga kommandot.

När en session till exempel innehåller en funktion och en cmdlet med samma namn kör PowerShell funktionen som standard. När sessionen innehåller kommandon av samma typ med samma namn, till exempel två cmdletar med samma namn, kör den som standard det senast tillagda kommandot.

Mer information, inklusive en förklaring av prioritetsregler och instruktioner för att köra dolda kommandon, finns i about_Command_Precedence.

Du kan köra ett dolt eller ersatt kommando genom att kvalificera kommandonamnet. Om du vill kvalificera kommandonamnet lägger du till namnet på modulen som innehåller den version av kommandot som du vill använda. Till exempel:

Microsoft.PowerShell.Utility\Get-Date

Om du kör Get-Date med modulnamnprefixet ser du till att du kör versionen från modulen Microsoft.PowerShell.Utility .

Om du vill identifiera namnkonflikter använder du parametern Alla i cmdleten Get-Command . Som standard Get-Command hämtar endast de kommandon som körs när du skriver kommandonamnet. Parametern Alla hämtar alla kommandon med det specifika namnet i sessionen.

Om du vill förhindra namnkonflikter använder du parametrarna NoClobber eller Prefix för cmdleten Import-Module . Prefixparametern lägger till ett prefix i namnen på importerade kommandon så att de är unika i sessionen. Parametern NoClobber importerar inga kommandon som skulle dölja eller ersätta befintliga kommandon i sessionen.

Du kan också använda parametrarna Alias, Cmdlet, Funktion och Variabel för för att endast välja de kommandon som du vill importera, och du kan exkludera kommandon som orsakar namnkonflikter i sessionen. Import-Module

Modulförfattare kan förhindra namnkonflikter med hjälp av egenskapen DefaultCommandPrefix för modulmanifestet för att lägga till ett standardprefix i alla kommandonamn. Värdet för prefixparametern har företräde framför värdet DefaultCommandPrefix.

Dela via