Not
Åtkomst till denna sida kräver auktorisation. Du kan prova att logga in eller byta katalog.
Åtkomst till denna sida kräver auktorisation. Du kan prova att byta katalog.
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 ger 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 cmdlets, providers, funktioner, variabler och andra typer av resurser som kan importeras som en enda enhet.
PowerShell levereras med en grundläggande uppsä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 ladda ur eller ladda om under en session.
Remove-Module Använd cmdleten 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 . I det här avsnittet beskrivs hur du använder PowerShell-moduler. Information om hur du skriver PowerShell-moduler finns i Skriva en PowerShell-modul.
Anmärkning
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 tilläggsmodulen som finns kvar i PowerShell. Alla andra snap-ins 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. Modulerna PowerShellGet och Microsoft.PowerShell.PSResourceGet tillhandahåller cmdletar för att hitta, installera och publicera PowerShell-moduler till en registrerad lagringsplats.
Modulen PowerShellGet 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 på 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 PowerShellGet Overview.
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. Dessa moduler installeras när funktionen installeras. Andra moduler kan finnas i ett installationsprogram som installerar modulen.
Som standard finns inte mappen Modules för den aktuella användaren. Om du har installerat en modul i CurrentUser-omfånget med hjälp av Install-Module eller Install-PSResourceskapar dessa cmdletar mappen Modules 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 moduler
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 automatiskt inläsning av moduler kan du använda kommandon i en modul utan att behöva göra någon inställning eller profilkonfiguration. Det finns inget behov av att hantera moduler när du har installerat dem på din dator.
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 cmdleten Get-Command för att lista kommandona i alla installerade moduler, även om de ännu inte finns i sessionen. 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.
Kommandon som använder PowerShell-providers importerar inte heller automatiskt en modul. Om du till exempel använder ett kommando som kräver den 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 är installerad på de platser som anges av $env:PSModulePath miljövariabeln, eller när modulen tillhandahålls som en fristående .dll 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 parametern Prefix för Import-Module till ett distinkt prefix till substantivdelen av de cmdletar som importerats från modulen. Parametern NoClobber hindrar modulen från att lägga till kommandon som skulle dölja eller ersätta befintliga kommandon i sessionen. Mer information finns i Hantera namnkonflikter.
Du kan importera en modul som är installerad i dig $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 modulen TestCmdlets i katalogen C:\ps-test 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 katalogen C:\ps-test 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 Import-Module i PowerShell-profilen.
Mer information om profiler finns i about_Profiles.
Hitta installerade moduler
Cmdleten Get-Module hämtar de PowerShell-moduler 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 modulen BitsTransfer skriver du:
Get-Command -Module BitsTransfer
Mer information om cmdleten Get-Command finns i 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 modulen BitsTransfer 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 Remove-Module.
Kommandon kan läggas till i din session från moduler och snapins. Moduler kan lägga till alla typer av kommandon, inklusive cmdlets, providers, funktioner och objekt, såsom 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 till cmdletarna Get-Date 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 denna snap-in 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 hjälp av Remove-Module. Om du vill ta bort funktionen kan du ta bort den från Function: enheten.
Remove-Item Function:Get-Date
För mer information om Function:-enheten, se 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 ersätter 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 kommando som har dolts eller ersatts 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 hämtar Get-Command bara 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. Parametern Prefix lägger till ett prefix i namnen på importerade kommandon så att de är unika i sessionen. Parametern NoClobber importerar inte några kommandon som skulle dölja eller ersätta befintliga kommandon i sessionen.
Du kan också använda Alias, Cmdlet, Functionoch Variable parametrar för Import-Module för att välja de kommandon som du vill importera och du kan undanta kommandon som orsakar namnkonflikter i sessionen.
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 parametern Prefix har företräde framför värdet för DefaultCommandPrefix.