Een PowerShell-scriptmodule schrijven

2025-03-25

Een scriptmodule is een geldig PowerShell-script dat is opgeslagen in een .psm1-extensie. Met deze extensie kan de PowerShell-engine regels en module-cmdlets in uw bestand gebruiken. De meeste van deze mogelijkheden zijn er om u te helpen bij het installeren van uw code op andere systemen, evenals het beheren van het bereik. U kunt ook een modulemanifestbestand gebruiken, waarin complexere installaties en oplossingen worden beschreven.

Een PowerShell-scriptmodule schrijven

Als u een scriptmodule wilt maken, slaat u een geldig PowerShell-script op in een .psm1-bestand. Het script en de map waarin het is opgeslagen, moeten dezelfde naam gebruiken. Een script met de naam MyPsScript.psm1 wordt bijvoorbeeld opgeslagen in een map met de naam MyPsScript.

De map van de module moet zich in een pad bevinden dat is opgegeven in $Env:PSModulePath. De map van de module kan alle resources bevatten die nodig zijn om het script uit te voeren en een modulemanifestbestand dat beschrijft in PowerShell hoe uw module werkt.

Een eenvoudige PowerShell-module maken

In de volgende stappen wordt beschreven hoe u een PowerShell-module maakt.

Sla een PowerShell-script op met een .psm1-extensie. Gebruik dezelfde naam voor het script en de map waarin het script wordt opgeslagen.

Als u een script opslaat met de extensie .psm1, kunt u de module-cmdlets gebruiken, zoals Import-Module. De module-cmdlets bestaan voornamelijk, zodat u uw code kunt importeren en exporteren naar de systemen van andere gebruikers. De alternatieve oplossing is het laden van uw code op andere systemen en vervolgens dot-source in het actieve geheugen, wat geen schaalbare oplossing is. Zie Informatie over een Windows PowerShell-modulevoor meer informatie. Wanneer gebruikers uw .psm1-bestand importeren, zijn alle functies in uw script standaard toegankelijk, maar variabelen niet.

Aan het einde van dit artikel is een voorbeeld van een PowerShell-script met de titel Show-Calendarbeschikbaar.
```
function Show-Calendar {
param(
    [datetime] $Start = [datetime]::Today,
    [datetime] $End = $Start,
    $FirstDayOfWeek,
    [int[]] $HighlightDay,
    [string[]] $HighlightDate = [datetime]::Today.ToString('yyyy-MM-dd')
    )

    #actual code for the function goes here see the end of the topic for the complete code sample
}
```
Als u de toegang van gebruikers tot bepaalde functies of variabelen wilt beheren, roept u Export-ModuleMe mber aan aan het einde van uw script aan.

De voorbeeldcode onderaan het artikel heeft slechts één functie, die standaard wordt weergegeven. Het is echter raadzaam om expliciet aan te roepen welke functies u beschikbaar wilt maken, zoals beschreven in de volgende code:
```
function Show-Calendar {
      }
Export-ModuleMember -Function Show-Calendar
```
U kunt beperken wat er wordt geïmporteerd met behulp van een modulemanifest. Zie Een PowerShell-module importeren en Een PowerShell-modulemanifest schrijvenvoor meer informatie.
Als u modules hebt die uw eigen module moet laden, kunt u Import-Moduleboven aan de module gebruiken.

De Import-Module cmdlet importeert een doelmodule in een systeem en kan later in de procedure worden gebruikt om uw eigen module te installeren. In de voorbeeldcode onderaan dit artikel worden geen importmodules gebruikt. Maar als dat het gebeurt, worden ze boven aan het bestand weergegeven, zoals wordt weergegeven in de volgende code:
```
Import-Module GenericModule
```
Als u uw module wilt beschrijven in het PowerShell Help-systeem, kunt u standaard help-opmerkingen in het bestand gebruiken of een extra Help-bestand maken.

Het codevoorbeeld onderaan dit artikel bevat de Help-informatie in de opmerkingen. U kunt ook uitgebreide XML-bestanden schrijven die aanvullende Help-inhoud bevatten. Zie Help voor Windows PowerShell-modules schrijvenvoor meer informatie.
Als u extra modules, XML-bestanden of andere inhoud hebt die u met uw module wilt verpakken, kunt u een modulemanifest gebruiken.

Een modulemanifest is een bestand dat de namen van andere modules, mapindelingen, versienummers, ontwerpgegevens en andere gegevens bevat. PowerShell gebruikt het manifestbestand van de module om uw oplossing te organiseren en te implementeren. Zie Een PowerShell-modulemanifest schrijvenvoor meer informatie.
Als u de module wilt installeren en uitvoeren, slaat u de module op in een van de juiste PowerShell-paden en gebruikt u Import-Module.

De paden waar u de module kunt installeren, bevinden zich in de globale variabele $Env:PSModulePath. Een algemeen pad voor het opslaan van een module op een systeem zou bijvoorbeeld %SystemRoot%/users/<user>/Documents/PowerShell/Modules/<moduleName>zijn. Zorg ervoor dat u een map maakt voor uw module die dezelfde naam gebruikt als de scriptmodule, zelfs als dit slechts één .psm1 bestand is. Als u de module niet hebt opgeslagen op een van deze paden, moet u de locatie van de module opgeven in de opdracht Import-Module. Anders zou PowerShell de module niet kunnen vinden.

Notitie

Vanaf PowerShell 3.0 hoeft u de module niet expliciet te importeren als u uw module in een van de PowerShell-modulepaden hebt geplaatst. Uw module wordt automatisch geladen wanneer een gebruiker uw functie aanroept. Zie Een PowerShell-module importeren en about_PSModulePathvoor meer informatie over het modulepad.
Als u een module uit de actieve service in de huidige PowerShell-sessie wilt verwijderen, gebruikt u Remove-Module.

Notitie

Remove-Module verwijdert een module uit de huidige PowerShell-sessie, maar verwijdert de module niet of verwijdert u de bestanden van de module niet.

voorbeeld van Show-Calendar code

Het volgende voorbeeld is een scriptmodule die één functie bevat met de naam Show-Calendar. Met deze functie wordt een visuele weergave van een agenda weergegeven. Het voorbeeld bevat de PowerShell Help-tekenreeksen voor de synopsis, beschrijving, parameterwaarden en code. Wanneer de module wordt geïmporteerd, zorgt de Export-ModuleMember opdracht ervoor dat de Show-Calendar functie wordt geëxporteerd als een modulelid.

<#
 .SYNOPSIS
  Displays a visual representation of a calendar.

 .DESCRIPTION
  Displays a visual representation of a calendar. This function supports multiple months
  and lets you highlight specific date ranges or days.

 .PARAMETER Start
  The first month to display.

 .PARAMETER End
  The last month to display.

 .PARAMETER FirstDayOfWeek
  The day of the month on which the week begins.

 .PARAMETER HighlightDay
  Specific days (numbered) to highlight. Used for date ranges like (25..31).
  Date ranges are specified by the Windows PowerShell range syntax. These dates are
  enclosed in square brackets.

 .PARAMETER HighlightDate
  Specific days (named) to highlight. These dates are surrounded by asterisks.

 .EXAMPLE
   # Show a default display of this month.
   Show-Calendar

 .EXAMPLE
   # Display a date range.
   Show-Calendar -Start "March, 2010" -End "May, 2010"

 .EXAMPLE
   # Highlight a range of days.
   Show-Calendar -HighlightDay (1..10 + 22) -HighlightDate "2008-12-25"
#>
function Show-Calendar {
param(
    [datetime] $Start = [datetime]::Today,
    [datetime] $End = $Start,
    $FirstDayOfWeek,
    [int[]] $HighlightDay,
    [string[]] $HighlightDate = [datetime]::Today.ToString('yyyy-MM-dd')
    )

## Determine the first day of the start and end months.
$Start = New-Object DateTime $Start.Year,$Start.Month,1
$End = New-Object DateTime $End.Year,$End.Month,1

## Convert the highlighted dates into real dates.
[datetime[]] $HighlightDate = [datetime[]] $HighlightDate

## Retrieve the DateTimeFormat information so that the
## calendar can be manipulated.
$dateTimeFormat  = (Get-Culture).DateTimeFormat
if($FirstDayOfWeek)
{
    $dateTimeFormat.FirstDayOfWeek = $FirstDayOfWeek
}

$currentDay = $Start

## Process the requested months.
while($Start -le $End)
{
    ## Return to an earlier point in the function if the first day of the month
    ## is in the middle of the week.
    while($currentDay.DayOfWeek -ne $dateTimeFormat.FirstDayOfWeek)
    {
        $currentDay = $currentDay.AddDays(-1)
    }

    ## Prepare to store information about this date range.
    $currentWeek = New-Object PsObject
    $dayNames = @()
    $weeks = @()

    ## Continue processing dates until the function reaches the end of the month.
    ## The function continues until the week is completed with
    ## days from the next month.
    while(($currentDay -lt $Start.AddMonths(1)) -or
        ($currentDay.DayOfWeek -ne $dateTimeFormat.FirstDayOfWeek))
    {
        ## Determine the day names to use to label the columns.
        $dayName = "{0:ddd}" -f $currentDay
        if($dayNames -notcontains $dayName)
        {
            $dayNames += $dayName
        }

        ## Pad the day number for display, highlighting if necessary.
        $displayDay = " {0,2} " -f $currentDay.Day

        ## Determine whether to highlight a specific date.
        if($HighlightDate)
        {
            $compareDate = New-Object DateTime $currentDay.Year,
                $currentDay.Month,$currentDay.Day
            if($HighlightDate -contains $compareDate)
            {
                $displayDay = "*" + ("{0,2}" -f $currentDay.Day) + "*"
            }
        }

        ## Otherwise, highlight as part of a date range.
        if($HighlightDay -and ($HighlightDay[0] -eq $currentDay.Day))
        {
            $displayDay = "[" + ("{0,2}" -f $currentDay.Day) + "]"
            $null,$HighlightDay = $HighlightDay
        }

        ## Add the day of the week and the day of the month as note properties.
        $currentWeek | Add-Member NoteProperty $dayName $displayDay

        ## Move to the next day of the month.
        $currentDay = $currentDay.AddDays(1)

        ## If the function reaches the next week, store the current week
        ## in the week list and continue.
        if($currentDay.DayOfWeek -eq $dateTimeFormat.FirstDayOfWeek)
        {
            $weeks += $currentWeek
            $currentWeek = New-Object PsObject
        }
    }

    ## Format the weeks as a table.
    $calendar = $weeks | Format-Table $dayNames -AutoSize | Out-String

    ## Add a centered header.
    $width = ($calendar.Split("`n") | Measure-Object -Maximum Length).Maximum
    $header = "{0:MMMM yyyy}" -f $Start
    $padding = " " * (($width - $header.Length) / 2)
    $displayCalendar = " `n" + $padding + $header + "`n " + $calendar
    $displayCalendar.TrimEnd()

    ## Move to the next month.
    $Start = $Start.AddMonths(1)

}
}
Export-ModuleMember -Function Show-Calendar

Delen via

Een PowerShell-scriptmodule schrijven