Hoofdstuk 9 - Functies

PowerShell-eenregelige en scripts die vaak moeten worden gewijzigd, zijn goede kandidaten om omgezet te worden tot herbruikbare functies.

Schrijf waar mogelijk functies omdat ze meer toolgeoriënteerd zijn. U kunt de functies toevoegen aan een scriptmodule, die module op een locatie plaatsen die is gedefinieerd in de $env:PSModulePathen de functies aanroepen zonder dat u hoeft te zoeken waar u de functies hebt opgeslagen. Met behulp van de module PowerShellGet kunt u uw PowerShell-modules eenvoudig delen in een NuGet-opslagplaats. PowerShellGet wordt geleverd met PowerShell versie 5.0 en hoger. Het is ook beschikbaar als een afzonderlijke download voor PowerShell versie 3.0 en hoger.

Overcomplicaat dingen niet. Houd het eenvoudig en gebruik de eenvoudigste manier om een taak uit te voeren. Vermijd aliassen en positionele parameters in code die u opnieuw gebruikt. Maak uw code op voor leesbaarheid. Codeer geen waarden; parameters en variabelen gebruiken. Schrijf geen onnodige code, zelfs niet als het geen kwaad kan. Het voegt onnodige complexiteit toe. Aandacht voor details gaat veel verder bij het schrijven van PowerShell-code.

Naamgeving

Gebruik bij het benoemen van uw functies in PowerShell een Pascal-case naam met een goedgekeurd werkwoord en een enkel naamwoord. Voer Get-Verbuit om een lijst met goedgekeurde werkwoorden in PowerShell te verkrijgen. In het volgende voorbeeld worden de resultaten van Get-Verb gesorteerd op de eigenschap Werkwoord.

Get-Verb | Sort-Object -Property Verb

De eigenschap Group geeft een idee van hoe de werkwoorden moeten worden gebruikt.

Verb        Group
----        -----
Add         Common
Approve     Lifecycle
Assert      Lifecycle
Backup      Data
Block       Security
Checkpoint  Data
Clear       Common
Close       Common
Compare     Data
Complete    Lifecycle
Compress    Data
Confirm     Lifecycle
Connect     Communications
Convert     Data
ConvertFrom Data
ConvertTo   Data
Copy        Common
Debug       Diagnostic
Deny        Lifecycle
Disable     Lifecycle
Disconnect  Communications
Dismount    Data
Edit        Data
Enable      Lifecycle
Enter       Common
Exit        Common
Expand      Data
Export      Data
Find        Common
Format      Common
Get         Common
Grant       Security
Group       Data
Hide        Common
Import      Data
Initialize  Data
Install     Lifecycle
Invoke      Lifecycle
Join        Common
Limit       Data
Lock        Common
Measure     Diagnostic
Merge       Data
Mount       Data
Move        Common
New         Common
Open        Common
Optimize    Common
Out         Data
Ping        Diagnostic
Pop         Common
Protect     Security
Publish     Data
Push        Common
Read        Communications
Receive     Communications
Redo        Common
Register    Lifecycle
Remove      Common
Rename      Common
Repair      Diagnostic
Request     Lifecycle
Reset       Common
Resize      Common
Resolve     Diagnostic
Restart     Lifecycle
Restore     Data
Resume      Lifecycle
Revoke      Security
Save        Data
Search      Common
Select      Common
Send        Communications
Set         Common
Show        Common
Skip        Common
Split       Common
Start       Lifecycle
Step        Common
Stop        Lifecycle
Submit      Lifecycle
Suspend     Lifecycle
Switch      Common
Sync        Data
Test        Diagnostic
Trace       Diagnostic
Unblock     Security
Undo        Common
Uninstall   Lifecycle
Unlock      Common
Unprotect   Security
Unpublish   Data
Unregister  Lifecycle
Update      Data
Use         Other
Wait        Lifecycle
Watch       Common
Write       Communications

Het is belangrijk om een goedgekeurd werkwoord te gebruiken voor uw PowerShell-functies. Modules met functies met niet-goedgekeurde werkwoorden genereren een waarschuwingsbericht wanneer ze worden geïmporteerd in een PowerShell-sessie. Dit waarschuwingsbericht zorgt ervoor dat uw functies er onprofessioneel uitzien. Niet-goedgekeurde werkwoorden beperken ook de detectie van uw functies.

Een eenvoudige functie

Een functie in PowerShell wordt gedeclareerd met het sleutelwoord 'function', gevolgd door de functienaam en vervolgens een openings- en sluitaccolade ({ }). De code die door de functie wordt uitgevoerd, bevindt zich in die accolades.

function Get-Version {
    $PSVersionTable.PSVersion
}

De functie die in het volgende voorbeeld wordt weergegeven, is een eenvoudig voorbeeld dat de versie van PowerShell retourneert.

Get-Version

Major  Minor  Build  Revision
-----  -----  -----  --------
5      1      14393  693

Wanneer u een algemene naam gebruikt voor uw functies, zoals Get-Version, kan dit naamconflicten veroorzaken. Standaardopdrachten die in de toekomst zijn toegevoegd of opdrachten die anderen kunnen schrijven, kunnen hiermee conflicteren. Plaats een voorvoegsel bij het zelfstandige naamwoordgedeelte van uw functienamen om conflicten in naamgeving te voorkomen. Bijvoorbeeld: <ApprovedVerb>-<Prefix><SingularNoun>.

In het volgende voorbeeld wordt het voorvoegsel PSgebruikt.

function Get-PSVersion {
    $PSVersionTable.PSVersion
}

Behalve de naam is deze functie identiek aan de vorige.

Get-PSVersion

Major  Minor  Build  Revision
-----  -----  -----  --------
5      1      14393  693

U kunt nog steeds een naamconflict hebben, zelfs wanneer u een voorvoegsel toevoegt aan het zelfstandig naamwoord. Ik voeg graag mijn initialen toe als voorvoegsel voor mijn functiewoorden. Ontwikkel een standaard en blijf eraan hangen.

function Get-MrPSVersion {
    $PSVersionTable.PSVersion
}

Deze functie is niet anders dan de vorige twee, met uitzondering van het gebruik van een meer unieke naam om naamconflicten met andere PowerShell-opdrachten te voorkomen.

Get-MrPSVersion

Major  Minor  Build  Revision
-----  -----  -----  --------
5      1      14393  693

Zodra deze in het geheugen is geladen, kunt u functies op de Functie PSDrive zien.

Get-ChildItem -Path Function:\Get-*Version

CommandType     Name                                               Version
-----------     ----                                               -------
Function        Get-Version
Function        Get-PSVersion
Function        Get-MrPSVersion

Als u deze functies uit uw huidige sessie wilt verwijderen, verwijdert u deze uit de Functie PSDrive of sluit en opent u PowerShell opnieuw.

Get-ChildItem -Path Function:\Get-*Version | Remove-Item

Controleer of de functies inderdaad zijn verwijderd.

Get-ChildItem -Path Function:\Get-*Version

Als de functies als onderdeel van een module zijn geladen, kunt u de module verwijderen om ze te verwijderen.

Remove-Module -Name <ModuleName>

De Remove-Module cmdlet verwijdert PowerShell-modules uit het geheugen in uw huidige PowerShell-sessie. Deze worden niet van uw systeem of schijf verwijderd.

Parameterwaarden

Wijs geen waarden statisch toe. Gebruik in plaats daarvan parameters en variabelen. Wanneer u de parameters een naam geeft, gebruikt u waar mogelijk dezelfde naam als de standaard-cmdlets voor uw parameternamen.

In de volgende functie heb ik ComputerName gebruikt en niet Computer, ServerNameof Host voor de parameternaam. Met ComputerName standaardiseert u de parameternaam zodat deze qua naam en hoofdlettergebruik overeenkomt met de standaard-cmdlets.

function Test-MrParameter {

    param (
        $ComputerName
    )

    Write-Output $ComputerName

}

Met de volgende functie worden alle opdrachten op uw systeem opgevraagd en wordt het getal geretourneerd met specifieke parameternamen.

function Get-MrParameterCount {
    param (
        [string[]]$ParameterName
    )

    foreach ($Parameter in $ParameterName) {
        $Results = Get-Command -ParameterName $Parameter -ErrorAction SilentlyContinue

        [pscustomobject]@{
            ParameterName   = $Parameter
            NumberOfCmdlets = $Results.Count
        }
    }
}

Zoals u in de volgende resultaten kunt zien, zijn er 39 opdrachten met een ComputerName parameter. Er zijn geen opdrachten met parameters zoals Computer, ServerName, Hostof Machine.

Get-MrParameterCount -ParameterName ComputerName, Computer, ServerName,
    Host, Machine

ParameterName NumberOfCmdlets
------------- ---------------
ComputerName               39
Computer                    0
ServerName                  0
Host                        0
Machine                     0

Gebruik dezelfde schrijfwijze voor je parameternamen als de standaard-cmdlets. Gebruik bijvoorbeeld ComputerName, niet computername. Dit naamgevingsschema helpt mensen die bekend zijn met PowerShell uw functies te ontdekken en eruit te zien als de standaard-cmdlets.

Met de instructie param kunt u een of meer parameters definiëren. Een komma (,) scheidt de parameterdefinities. Zie about_Functions_Advanced_Parametersvoor meer informatie.

Geavanceerde functies

Het omzetten van een functie in een geavanceerde functie in PowerShell is eenvoudig. Een van de verschillen tussen een functie en een geavanceerde functie is dat geavanceerde functies algemene parameters hebben die automatisch worden toegevoegd. Algemene parameters zijn bijvoorbeeld parameters zoals Uitvoerig en Foutopsporing.

Begin met de Test-MrParameter functie die in de vorige sectie is gebruikt.

function Test-MrParameter {

    param (
        $ComputerName
    )

    Write-Output $ComputerName

}

Er zijn een aantal verschillende manieren om de algemene parameters te bekijken. Eén manier is door de syntaxis te bekijken met Get-Command.

Get-Command -Name Test-MrParameter -Syntax

U ziet dat de functie Test-MrParameter geen algemene parameters heeft.

Test-MrParameter [[-ComputerName] <Object>]

Een andere is om in te zoomen op de parametereigenschap van Get-Command.

(Get-Command -Name Test-MrParameter).Parameters.Keys

ComputerName

Voeg het kenmerk CmdletBinding toe om de functie om te zetten in een geavanceerde functie.

function Test-MrCmdletBinding {

    [CmdletBinding()] # Turns a regular function into an advanced function
    param (
        $ComputerName
    )

    Write-Output $ComputerName

}

Wanneer u CmdletBindingopgeeft, worden de algemene parameters automatisch toegevoegd. CmdletBinding vereist een param blok, maar het param blok kan leeg zijn.

Get-Command -Name Test-MrCmdletBinding -Syntax

Test-MrCmdletBinding [[-ComputerName] <Object>] [<CommonParameters>]

Inzoomen op de eigenschap parameters van Get-Command toont de werkelijke parameternamen, inclusief de gebruikelijke.

(Get-Command -Name Test-MrCmdletBinding).Parameters.Keys

ComputerName
Verbose
Debug
ErrorAction
WarningAction
InformationAction
ErrorVariable
WarningVariable
InformationVariable
OutVariable
OutBuffer
PipelineVariable

OndersteuntShouldProcess

Het kenmerk SupportsShouldProcess voegt de WhatIf- en Bevestig- risicobeperkingsparameters toe. Deze parameters zijn alleen nodig voor opdrachten die wijzigingen aanbrengen.

function Test-MrSupportsShouldProcess {

    [CmdletBinding(SupportsShouldProcess)]
    param (
        $ComputerName
    )

    Write-Output $ComputerName

}

U ziet dat er nu WhatIf-parameters en Confirm-parameters zijn.

Get-Command -Name Test-MrSupportsShouldProcess -Syntax

Test-MrSupportsShouldProcess [[-ComputerName] <Object>] [-WhatIf] [-Confirm]
[<CommonParameters>]

U kunt ook Get-Command gebruiken om een lijst met de werkelijke parameternamen te retourneren, inclusief de gebruikelijke, samen met WhatIf en Bevestigen.

(Get-Command -Name Test-MrSupportsShouldProcess).Parameters.Keys

ComputerName
Verbose
Debug
ErrorAction
WarningAction
InformationAction
ErrorVariable
WarningVariable
InformationVariable
OutVariable
OutBuffer
PipelineVariable
WhatIf
Confirm

Parametervalidatie

Valideer de invoer vroeg. Sta uw code niet toe om door te gaan op een pad wanneer deze niet kan worden voltooid zonder geldige invoer.

Geef altijd een gegevenstype op voor de variabelen die worden gebruikt voor parameters. In het volgende voorbeeld wordt tekenreeks opgegeven als het gegevenstype voor de parameter ComputerName. Deze validatie beperkt het zodat slechts één computernaam kan worden opgegeven voor de ComputerName parameter.

function Test-MrParameterValidation {

    [CmdletBinding()]
    param (
        [string]$ComputerName
    )

    Write-Output $ComputerName

}

Er wordt een fout gegenereerd als er meer dan één computernaam is opgegeven.

Test-MrParameterValidation -ComputerName Server01, Server02

Test-MrParameterValidation : Cannot process argument transformation on
parameter 'ComputerName'. Cannot convert value to type System.String.
At line:1 char:42
+ Test-MrParameterValidation -ComputerName Server01, Server02
+                                          ~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : InvalidData: (:) [Test-MrParameterValidation]
   , ParameterBindingArgumentTransformationException
    + FullyQualifiedErrorId : ParameterArgumentTransformationError,Test-MrP
   arameterValidation

Het probleem met de huidige definitie is dat het geldig is om de waarde van de parameter ComputerName weg te laten, maar een waarde is vereist om de functie te voltooien. In dit scenario is het Mandatory parameterkenmerk nuttig.

De syntaxis die in het volgende voorbeeld wordt gebruikt, is compatibel met PowerShell versie 3.0 en hoger. [Parameter(Mandatory=$true)] kan worden opgegeven om de functie compatibel te maken met PowerShell versie 2.0 of hoger.

function Test-MrParameterValidation {

    [CmdletBinding()]
    param (
        [Parameter(Mandatory)]
        [string]$ComputerName
    )

    Write-Output $ComputerName

}

Nu de ComputerName is vereist, als deze niet is opgegeven, wordt er door de functie om een gevraagd.

Test-MrParameterValidation

cmdlet Test-MrParameterValidation at command pipeline position 1
Supply values for the following parameters:
ComputerName:

Als u meer dan één waarde wilt toestaan voor de parameter ComputerName, gebruikt u de tekenreeks gegevenstype, maar voegt u vierkante haken ([]) toe aan het gegevenstype om een matrix met tekenreeksen toe te staan.

function Test-MrParameterValidation {

    [CmdletBinding()]
    param (
        [Parameter(Mandatory)]
        [string[]]$ComputerName
    )

    Write-Output $ComputerName

}

Misschien wilt u een standaardwaarde opgeven voor de parameter ComputerName als deze niet is opgegeven. Het probleem is dat standaardwaarden niet kunnen worden gebruikt met verplichte parameters. Gebruik in plaats daarvan het kenmerk ValidateNotNullOrEmpty parametervalidatie met een standaardwaarde.

Zelfs wanneer u een standaardwaarde instelt, probeert u geen statische waarden te gebruiken. In het volgende voorbeeld wordt $env:COMPUTERNAME gebruikt als de standaardwaarde, die automatisch wordt vertaald naar de naam van de lokale computer als er geen waarde wordt opgegeven.

function Test-MrParameterValidation {

    [CmdletBinding()]
    param (
        [ValidateNotNullOrEmpty()]
        [string[]]$ComputerName = $env:COMPUTERNAME
    )

    Write-Output $ComputerName

}

Uitgebreide uitvoer

Inline opmerkingen zijn handig als u complexe code schrijft, maar gebruikers zien ze niet, tenzij ze de code bekijken.

De functie in het volgende voorbeeld bevat een inline opmerking in de foreach lus. Hoewel deze specifieke opmerking mogelijk niet moeilijk te vinden is, stelt u zich voor of de functie honderden regels code bevat.

function Test-MrVerboseOutput {

    [CmdletBinding()]
    param (
        [ValidateNotNullOrEmpty()]
        [string[]]$ComputerName = $env:COMPUTERNAME
    )

    foreach ($Computer in $ComputerName) {
        #Attempting to perform an action on $Computer <<-- Don't use
        #inline comments like this, use write verbose instead.
        Write-Output $Computer
    }

}

Een betere optie is om Write-Verbose te gebruiken in plaats van inline opmerkingen.

function Test-MrVerboseOutput {

    [CmdletBinding()]
    param (
        [ValidateNotNullOrEmpty()]
        [string[]]$ComputerName = $env:COMPUTERNAME
    )

    foreach ($Computer in $ComputerName) {
        Write-Verbose -Message "Attempting to perform an action on $Computer"
        Write-Output $Computer
    }

}

De Verbose uitvoer wordt niet weergegeven wanneer de functie wordt aangeroepen zonder de Verbose parameter.

Test-MrVerboseOutput -ComputerName Server01, Server02

De uitgebreide uitvoer wordt weergegeven wanneer de functie wordt aangeroepen met de Verbose parameter.

Test-MrVerboseOutput -ComputerName Server01, Server02 -Verbose

Pijplijninvoer

Er is extra code nodig wanneer u wilt dat uw functie pijplijninvoer accepteert. Zoals eerder vermeld in dit boek, kunnen opdrachten pijplijninvoer accepteren op waarde (per type) of op eigenschapsnaam. U kunt uw functies schrijven zoals de systeemeigen opdrachten, zodat ze een of beide invoertypen accepteren.

Als u pijplijninvoer op waardewilt accepteren, specificeer dan het kenmerk parameter ValueFromPipeline voor die specifieke parameter. U kunt alleen pijplijninvoer accepteren op waarde van één parameter van elk gegevenstype. Als u twee parameters hebt die tekenreeksinvoer accepteren, kan slechts één daarvan pipeline-invoer aanvaarden op waarde. Als u op waarde hebt opgegeven voor beide tekenreeksparameters, weet de invoer niet aan welke parameter moet worden gekoppeld. Dit scenario is een andere reden waarom ik dit type pijplijninvoer aanroep op type in plaats van op waarde.

Pipeline-invoer wordt per item tegelijk verwerkt, vergelijkbaar met de wijze waarop items in een foreach-lus worden afgehandeld. Een process blok is vereist om elk item te verwerken als uw functie een matrix accepteert als invoer. Als uw functie slechts één waarde als invoer accepteert, is een process blok niet nodig, maar wordt aanbevolen voor consistentie.

function Test-MrPipelineInput {

    [CmdletBinding()]
    param (
        [Parameter(Mandatory,
                   ValueFromPipeline)]
        [string[]]$ComputerName
    )

    process {
        Write-Output $ComputerName
    }

}

Het accepteren van pijplijninvoer op eigenschapsnaam is vergelijkbaar, behalve dat u dit opgeeft met het parameterkenmerk ValueFromPipelineByPropertyName, en dat kan worden opgegeven voor een willekeurig aantal parameters, ongeacht het gegevenstype. Het belangrijkste punt is dat de uitvoer van het commando, die via piping binnenkomt, een eigenschapsnaam moet hebben die overeenkomt met de naam van de parameter of een parameteralias van uw functie.

function Test-MrPipelineInput {

    [CmdletBinding()]
    param (
        [Parameter(Mandatory,
                   ValueFromPipelineByPropertyName)]
        [string[]]$ComputerName
    )

    process {
            Write-Output $ComputerName
    }

}

begin en end blokken zijn optioneel. begin wordt opgegeven vóór het process blok en wordt gebruikt om initiële werkzaamheden uit te voeren voordat de items van de pijplijn worden ontvangen. Waarden die worden doorgesluisd zijn niet toegankelijk in blok begin. Het end blok wordt opgegeven na het process blok en wordt gebruikt voor het opschonen nadat alle items zijn verwerkt.

Foutafhandeling

De functie die in het volgende voorbeeld wordt getoond, genereert een onverwerkte uitzondering wanneer een computer niet kan worden benaderd.

function Test-MrErrorHandling {

    [CmdletBinding()]
    param (
        [Parameter(Mandatory,
                   ValueFromPipeline,
                   ValueFromPipelineByPropertyName)]
        [string[]]$ComputerName
    )

    process {
        foreach ($Computer in $ComputerName) {
            Test-WSMan -ComputerName $Computer
        }
    }

}

Er zijn verschillende manieren om fouten in PowerShell te verwerken. Try/Catch is een modernere manier om fouten te verwerken.

function Test-MrErrorHandling {

    [CmdletBinding()]
    param (
        [Parameter(Mandatory,
                   ValueFromPipeline,
                   ValueFromPipelineByPropertyName)]
        [string[]]$ComputerName
    )

    process {
        foreach ($Computer in $ComputerName) {
            try {
                Test-WSMan -ComputerName $Computer
            }
            catch {
                Write-Warning -Message "Unable to connect to Computer: $Computer"
            }
        }
    }

}

Hoewel de functie in het vorige voorbeeld foutafhandeling gebruikt, wordt er een onverwerkte uitzondering gegenereerd omdat de opdracht geen afsluitfout genereert. Alleen terminaalfouten worden opgevangen. Geef de parameter ErrorAction op met Stop als waarde om een niet-afbrekende fout om te zetten in een afbrekende fout.

function Test-MrErrorHandling {

    [CmdletBinding()]
    param (
        [Parameter(Mandatory,
                   ValueFromPipeline,
                   ValueFromPipelineByPropertyName)]
        [string[]]$ComputerName
    )

    process {
        foreach ($Computer in $ComputerName) {
            try {
                Test-WSMan -ComputerName $Computer -ErrorAction Stop
            }
            catch {
                Write-Warning -Message "Unable to connect to Computer: $Computer"
            }
        }
    }

}

Wijzig de globale $ErrorActionPreference variabele niet, tenzij dit absoluut noodzakelijk is. Als u deze wijzigt in een lokaal bereik, wordt deze teruggezet naar de vorige waarde wanneer u dat bereik afsluit.

Als u iets zoals .NET rechtstreeks vanuit uw PowerShell-functie gebruikt, kunt u de parameter ErrorAction niet opgeven voor de opdracht zelf. U kunt de $ErrorActionPreference variabele net voordat u de .NET-methode aanroept, wijzigen.

Help op basis van opmerkingen

Het toevoegen van hulp aan uw functies wordt beschouwd als een best practice. Met Help kunnen personen met wie u ze deelt, weten hoe u ze kunt gebruiken.

function Get-MrAutoStoppedService {

<#
.SYNOPSIS
    Returns a list of services that are set to start automatically, are not
    currently running, excluding the services that are set to delayed start.

.DESCRIPTION
    Get-MrAutoStoppedService is a function that returns a list of services
    from the specified remote computer(s) that are set to start
    automatically, are not currently running, and it excludes the services
    that are set to start automatically with a delayed startup.

.PARAMETER ComputerName
    The remote computer(s) to check the status of the services on.

.PARAMETER Credential
    Specifies a user account that has permission to perform this action. The
    default is the current user.

.EXAMPLE
     Get-MrAutoStoppedService -ComputerName 'Server1', 'Server2'

.EXAMPLE
     'Server1', 'Server2' | Get-MrAutoStoppedService

.EXAMPLE
     Get-MrAutoStoppedService -ComputerName 'Server1' -Credential (Get-Credential)

.INPUTS
    String

.OUTPUTS
    PSCustomObject

.NOTES
    Author:  Mike F. Robbins
    Website: https://mikefrobbins.com
    Twitter: @mikefrobbins
#>

    [CmdletBinding()]
    param (

    )

    #Function Body

}

Wanneer u commentaar-gebaseerde hulp toevoegt aan uw functies, kan hulp worden opgevraagd voor deze functies, zoals bij de standaard ingebouwde commando's.

Alle syntaxis voor het schrijven van een functie in PowerShell kan overweldigend lijken voor iemand die aan de slag gaat. Als u de syntaxis voor iets niet meer weet, opent u een tweede exemplaar van de Ise (Integrated Scripting Environment) van PowerShell op een afzonderlijk beeldscherm en bekijkt u het fragment Cmdlet (geavanceerde functie) - Voltooien tijdens het typen van de code voor uw functies. Fragmenten kunnen worden geopend in PowerShell ISE met behulp van de toetsencombinatie Ctrl + J.

Samenvatting

In dit hoofdstuk hebt u de basisprincipes van het schrijven van functies in PowerShell geleerd, waaronder het volgende:

• Geavanceerde functies maken
• Parametervalidatie gebruiken
• Uitgebreide uitvoer gebruiken
• Ondersteun pijplijninvoer
• Fouten verwerken
• Opmerking-gebaseerde hulp maken

Recensie

1. Hoe verkrijgt u een lijst met goedgekeurde werkwoorden in PowerShell?
2. Hoe kunt u een PowerShell-functie omzetten in een geavanceerde functie?
3. Wanneer moeten de parameters WhatIf en Confirm worden toegevoegd aan uw PowerShell-functies?
4. Hoe zet u een niet-terminale fout om in een terminale fout?
5. Waarom moet u hulp op basis van opmerkingen toevoegen aan uw functies?

Verwijzingen

• functies_bespreken
• about_Functions_Advanced_Parameters
• about_CommonParameters
• about_Functions_CmdletBindingAttribute
• about_Functions_Advanced
• about_Try_Catch_Finally
• over_Opmerkinggebaseerde_Hulp
• Video: PowerShell Toolmaking met geavanceerde functies en scriptmodules

Volgende stappen

In hoofdstuk 10 leert u hoe u functies in scriptmodules kunt verpakken. U verkent modulestructuur, manifesten, het exporteren van openbare opdrachten en aanbevolen procedures voor het organiseren, delen en onderhouden van herbruikbare PowerShell-hulpprogramma's.