11. Moduler

Redaktionell anteckning

Viktig

Windows PowerShell Language Specification 3.0 publicerades i december 2012 och baseras på Windows PowerShell 3.0. Den här specifikationen återspeglar inte det aktuella tillståndet för PowerShell. Det finns ingen plan för att uppdatera den här dokumentationen för att återspegla det aktuella tillståndet. Den här dokumentationen presenteras här för historisk referens.

Specifikationsdokumentet är tillgängligt som ett Microsoft Word-dokument från Microsoft Download Center på: https://www.microsoft.com/download/details.aspx?id=36389 Att Word-dokumentet har konverterats för presentation här på Microsoft Learn. Under konverteringen har vissa redaktionella ändringar gjorts för att anpassa formateringen för Docs-plattformen. Vissa stavfel och mindre fel har korrigerats.

11.1 Introduktion

Enligt §3.14är en modul en fristående återanvändbar enhet som gör att PowerShell-kod kan partitioneras, organiseras och abstraheras. En modul kan innehålla en eller flera modulmedlemmar, som är kommandon (till exempel cmdletar och funktioner) och objekt (till exempel variabler och alias). Namnen på dessa medlemmar kan hållas privata i modulen eller så kan de exporteras till sessionen där modulen importeras.

Det finns tre olika modultyper: manifest, skript och binärt. En manifestmodul är en fil som innehåller information om en modul och styr vissa aspekter av modulens användning. En skriptmodul är en PowerShell-skriptfil med filnamnstillägget .psm1 i stället för .ps1. En binär modul innehåller klasstyper som definierar cmdletar och providers. Till skillnad från skriptmoduler skrivs binära moduler på kompilerade språk. Binära moduler omfattas inte av den här specifikationen.

En binär modul är en .NET-sammansättning (d.v.s. en DLL) som kompilerats mot PowerShell-biblioteken.

Moduler kan kapsla; En modul kan alltså importera en annan modul. En modul som har associerade kapslade moduler är en rotmodul.

När en PowerShell-session skapas importeras som standard inga moduler.

När moduler importeras definieras sökvägen som används för att hitta dem av miljövariabeln PSModulePath-.

Följande cmdletar hanterar moduler:

11.2 Skriva en skriptmodul

En skriptmodul är en skriptfil. Överväg följande skriptmodul:

function Convert-CentigradeToFahrenheit ([double]$tempC) {
    return ($tempC * (9.0 / 5.0)) + 32.0
}
New-Alias c2f Convert-CentigradeToFahrenheit

function Convert-FahrenheitToCentigrade ([double]$tempF) {
    return ($tempF - 32.0) * (5.0 / 9.0)
}
New-Alias f2c Convert-FahrenheitToCentigrade

Export-ModuleMember -Function Convert-CentigradeToFahrenheit
Export-ModuleMember -Function Convert-FahrenheitToCentigrade
Export-ModuleMember -Alias c2f, f2c

Den här modulen innehåller två funktioner som var och en har ett alias. Som standard exporteras alla funktionsnamn och endast funktionsnamn. Men när cmdleten Export-ModuleMember har använts för att exportera något exporteras endast de saker som exporteras explicit. En serie kommandon och objekt kan exporteras i ett anrop eller ett antal anrop till den här cmdleten. sådana anrop är kumulativa för den aktuella sessionen.

11.3 Installera en skriptmodul

En skriptmodul definieras i en skriptfil och moduler kan lagras i valfri katalog. Miljövariabeln PSModulePath pekar på en uppsättning kataloger som ska sökas när modulrelaterade cmdletar letar efter moduler vars namn inte innehåller en fullständigt kvalificerad sökväg. Du kan ange ytterligare sökvägar för sökning. till exempel

$Env:PSModulePath = $Env:PSModulePath + ";<additional-path>"

Eventuella ytterligare sökvägar som läggs till påverkar endast den aktuella sessionen.

Du kan också ange en fullständigt kvalificerad sökväg när en modul importeras.

11.4 Importera en skriptmodul

Innan resurserna i en modul kan användas måste modulen importeras till den aktuella sessionen med hjälp av cmdleten Import-Module. Import-Module kan begränsa de resurser som faktiskt importeras.

När en modul importeras körs skriptfilen. Den processen kan konfigureras genom att definiera en eller flera parametrar i skriptfilen och skicka motsvarande argument via parametern ArgumentList för Import-Module.

Tänk på följande skript som använder dessa funktioner och alias som definierats i §11.2:

Import-Module "E:\Scripts\Modules\PSTest_Temperature" -Verbose

"0 degrees C is " + (Convert-CentigradeToFahrenheit 0) + " degrees F"
"100 degrees C is " + (c2f 100) + " degrees F"
"32 degrees F is " + (Convert-FahrenheitToCentigrade 32) + " degrees C"
"212 degrees F is " + (f2c 212) + " degrees C"

Om du importerar en modul uppstår en namnkonflikt när kommandon eller objekt i modulen har samma namn som kommandon eller objekt i sessionen. En namnkonflikt resulterar i att ett namn döljs eller ersätts. Prefixparametern för Import-Module kan användas för att undvika namngivningskonflikter. Dessutom kan parametrarna Alias, Cmdlet, Functionoch Variable begränsa valet av kommandon som ska importeras, vilket minskar risken för namnkonflikt.

Även om ett kommando är dolt kan det köras genom att kvalificera dess namn med namnet på den modul som det kommer från. Till exempel anropar & M\F 100 funktionen F i modulen Moch skickar argumentet 100.

När sessionen innehåller kommandon av samma slag med samma namn, till exempel två cmdletar med samma namn, körs som standard det senast tillagda kommandot.

Se §3.5.6 för en diskussion om omfång när det gäller moduler.

11.5 Ta bort en skriptmodul

En eller flera moduler kan tas bort från en session via cmdleten Remove-Module.

Om du tar bort en modul avinstalleras inte modulen.

I en skriptmodul är det möjligt att ange kod som ska köras innan modulen tas bort, enligt följande:

$MyInvocation.MyCommand.ScriptBlock.Module.OnRemove = { *on-removal-code* }

11.6 Modulmanifesten

Enligt §11.1är en manifestmodul en fil som innehåller information om en modul och styr vissa aspekter av modulens användning.

En modul behöver inte ha något motsvarande manifest, men om den gör det har manifestet samma namn som modulen som beskrivs, men med ett .psd1 filnamnstillägg.

Ett manifest innehåller en begränsad delmängd av PowerShell-skriptet, som returnerar en Hashtable som innehåller en uppsättning nycklar. Dessa nycklar och deras värden anger manifestelement för modulen. De beskriver alltså innehållet och attributen i modulen, definierar eventuella krav och avgör hur komponenterna bearbetas.

I princip är ett manifest en datafil. Den kan dock innehålla referenser till datatyper, if-instruktionen och aritmetiska operatorer och jämförelseoperatorer. (Tilldelningar, funktionsdefinitioner och loopar tillåts inte.) Ett manifest har också läsåtkomst till miljövariabler och kan innehålla anrop till cmdleten Join-Path, så att sökvägar kan skapas.

Notera

Redigerarens anmärkning: Det ursprungliga dokumentet innehåller en lista över nycklar som tillåts i en modulmanifestfil. Listan är inaktuell och ofullständig. En fullständig lista över nycklar i ett modulmanifest finns i New-ModuleManifest.

Den enda nyckel som krävs är ModuleVersion.

Här är ett exempel på ett enkelt manifest:

@{
ModuleVersion = '1.0'
Author = 'John Doe'
RequiredModules = @()
FunctionsToExport = 'Set*','Get*','Process*'
}

Nyckeln GUID har ett string värde. Detta anger en globalt unik IDentifier (GUID) för modulen. GUID kan användas för att skilja mellan moduler med samma namn. Om du vill skapa ett nytt GUID anropar du metoden [guid]::NewGuid().

11.7 Dynamiska moduler

En dynamisk modul är en modul som skapas i minnet vid körning av cmdleten New-Module; den läses inte in från disken. Tänk på följande exempel:

$sb = {
    function Convert-CentigradeToFahrenheit ([double]$tempC) {
        return ($tempC * (9.0 / 5.0)) + 32.0
    }

    New-Alias c2f Convert-CentigradeToFahrenheit

    function Convert-FahrenheitToCentigrade ([double]$tempF) {
        return ($tempF - 32.0) * (5.0 / 9.0)
    }

    New-Alias f2c Convert-FahrenheitToCentigrade

    Export-ModuleMember -Function Convert-CentigradeToFahrenheit
    Export-ModuleMember -Function Convert-FahrenheitToCentigrade
    Export-ModuleMember -Alias c2f, f2c
}

New-Module -Name MyDynMod -ScriptBlock $sb
Convert-CentigradeToFahrenheit 100
c2f 100

Skriptblocket $sb definierar innehållet i modulen, i det här fallet två funktioner och två alias för dessa funktioner. Precis som med en modul på disk exporteras endast funktioner som standard, så Export-ModuleMember cmdlets-anrop finns för att exportera både funktionerna och aliasen.

När New-Module körs är de fyra namn som exporteras tillgängliga för användning i sessionen, vilket visas av anropen till Convert-CentigradeToFahrenheit och c2f.

Liksom alla moduler, kör medlemmarna i dynamiska moduler i ett privat modulomfång som är en underordnad del av det globala omfånget. Get-Module kan inte hämta en dynamisk modul, men Get-Command kan hämta de exporterade medlemmarna.

Om du vill göra en dynamisk modul tillgänglig för Get-Moduleskickar du ett New-Module-kommando till Import-Moduleeller skickar modulobjektet som New-Module returnerar till Import-Module. Den här åtgärden lägger till den dynamiska modulen i listan Get-Module, men den sparar inte modulen på disken eller gör den beständig.

11.8 Stängningar

En dynamisk modul kan användas för att skapa en closure, en funktion med associerad data. Tänk på följande exempel:

function Get-NextID ([int]$StartValue = 1) {
    $nextID = $StartValue
    {
        ($Script:nextID++)
    }.GetNewClosure()
}

$v1 = Get-NextID      # get a scriptblock with $StartValue of 0
& $v1                 # invoke Get-NextID getting back 1
& $v1                 # invoke Get-NextID getting back 2

$v2 = Get-NextID 100  # get a scriptblock with $StartValue of 100
& $v2                 # invoke Get-NextID getting back 100
& $v2                 # invoke Get-NextID getting back 101

Avsikten här är att Get-NextID returnera nästa ID i en sekvens vars startvärde kan anges. Flera sekvenser måste dock stödjas, var och en med sin egen $StartValue och $nextID kontext. Detta uppnås genom anropet till metoden [scriptblock]::GetNewClosure (§4.3.7).

Varje gång en ny stängning skapas av GetNewClosure, skapas en ny dynamisk modul och variablerna i anroparens omfång (i det här fallet skriptblocket som innehåller inkrementet) kopieras till den nya modulen. För att säkerställa att nextId som definierats i den överordnade funktionen (men utanför skriptblocket) ökas krävs det explicita Skript: omfångsprefixet.

Skriptblocket behöver naturligtvis inte vara en namngiven funktion. till exempel:

$v3 = & {      # get a scriptblock with $StartValue of 200
    param ([int]$StartValue = 1)
    $nextID = $StartValue
    {
        ($Script:nextID++)
    }.GetNewClosure()
} 200

& $v3          # invoke script getting back 200
& $v3          # invoke script getting back 201
  • Last updated on