about_Modules
Kort beskrivning
Förklarar hur du installerar, importerar och använder PowerShell-moduler.
Lång beskrivning
PowerShell är ett skriptspråk och ett kommandogränssnitt. Språket består av nyckelord som tillhandahåller strukturen och logiken för bearbetning och kommandon som utför arbetet. Kommandon i PowerShell implementeras som skript, funktioner eller cmdletar.
En modul är en fristående återanvändbar enhet som kan innehålla cmdletar, providers, funktioner, variabler och andra typer av resurser som kan importeras som en enda enhet.
PowerShell levereras med en basuppsättning moduler. Du kan också installera fler moduler efter behov. Som standard läses installerade moduler in automatiskt första gången du använder ett kommando från en modul. Använd variabeln $PSModuleAutoloadingPreference för att aktivera, inaktivera och konfigurera automatisk inläsning av moduler. Mer information finns i about_Preference_Variables.
Du kan ta bort eller läsa in igen under en session. Använd cmdleten Remove-Module för att ta bort en modul från sessionen. Använd cmdleten Import-Module för att läsa in en modul.
Moduler kan skapas som kompilerade .NET-sammansättningar skrivna i C#, eller skriptbaserade moduler skrivna i PowerShell. Det här avsnittet beskriver hur du använder PowerShell-moduler. Information om hur du skriver PowerShell-moduler finns i Skriva en PowerShell-modul.
Anteckning
Innan PowerShell 3.0 paketerades cmdletar och providers 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.
Installera en publicerad modul
En publicerad modul är en modul som är tillgänglig från en registrerad lagringsplats, till exempel PowerShell-galleriet. PowerShellGet- och Microsoft.PowerShell.PSResourceGet-modulerna 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. Microsoft.PowerShell.PSResourceGet är den nya föredragna pakethanteraren för PowerShell och kan installeras i tidigare 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
Om du får en modul som en mapp med filer i den måste du installera den på datorn innan du kan använda den i PowerShell.
PowerShell levereras med flera förinstallerade moduler. På Windows-baserade datorer innehåller många Windows-funktioner moduler för att hantera funktionen. Modulerna installeras när funktionen installeras. Andra moduler kan komma i ett installationsprogram eller installationsprogram som installerar modulen.
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-ModuleInstall-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
Kopiera hela modulmappen till den nya skapade mappen. 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 till den mapp som du nyss skapade:
Copy-Item -Path C:\PSTest\MyModule -Destination $folder
Du kan installera en modul på valfri plats, men om du installerar modulerna på en standardmodulplats blir det enklare att hantera dem. 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. Moduler på andra platser måste importeras med hjälp av cmdleten Import-Module .
Med automatisk inläsning av moduler kan du använda kommandon i en modul utan konfiguration eller profilkonfiguration. Du behöver inte hantera moduler när du har installerat dem på datorn.
Vart och ett av följande exempel gör att CimCmdlets-modulen , som innehåller Get-CimInstance, importeras till sessionen.
Kör kommandot
Get-CimInstance Win32_OperatingSystemHämta kommandot
Get-Command Get-CimInstanceFå hjälp för kommandot
Get-Help Get-CimInstance
Du kan använda cmdlet-listan Get-Command med kommandona i alla installerade moduler, även om de inte finns i sessionen ännu. När du använder Get-Command med jokertecken (*) importerar PowerShell inga moduler. Du kan använda jokertecken för kommandoidentifiering utan att läsa in moduler som du kanske inte behöver i sessionen.
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.
Importera en modul manuellt
Du måste importera en modul manuellt när en modul inte installeras 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.
Du kanske också vill ändra hur modulen importeras i sessionen. Till exempel lägger prefixparameternImport-Module för ett distinkt prefix till substantivdelen av cmdletarna som importeras från modulen. Parametern NoClobber förhindrar att modulen lägger till kommandon som döljer eller ersätter befintliga kommandon i sessionen. Mer information finns i Hantera namnkonflikter.
Du kan importera en modul som är installerad i din $env:PSModulePath genom att ange modulnamnet. Följande kommando importerar till exempel BitsTransfer-modulen till den aktuella sessionen.
Import-Module BitsTransfer
Om du vill importera en modul som inte finns i din $env:PSModulePathanvänder du den fullständigt kvalificerade sökvägen till modulmappen. Om du till exempel vill lägga till TestCmdlets-modulenC:\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 PowerShell-profilen.
Mer information om profiler finns i about_Profiles.
Hitta installerade moduler
Cmdleten Get-Module hämtar PowerShell-modulerna som har importerats i 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 som 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-CommandGet-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 resultera i att kommandon döljs eller ersätts. Kommandot ersätts när den importerade modulen innehåller ett kommando med samma namn som ett befintligt kommando i sessionen. Det nyligen importerade kommandot ersätter har företräde framför det befintliga kommandot.
Om 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örs 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 kommando som har dolts eller ersatts av att kvalificera kommandonamnet. Om du vill kvalificera kommandonamnet lägger du till namnet på modulen än den version av kommandot som du vill använda. Exempel:
Microsoft.PowerShell.Utility\Get-Date
Om du kör Get-Date med modulnamnsprefixet ser du till att köra versionen från modulen Microsoft.PowerShell.Utility .
Om du vill identifiera namnkonflikter använder du parametern Alla för 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 Import-ModuleAlias, 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.
Modulförfattare kan förhindra namnkonflikter med 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 för DefaultCommandPrefix.