PowerShell Parameter Validation

PowerShell is a powerful scripting language that allows for automation and configuration management. One of the key features that make PowerShell scripts robust and reliable is parameter validation. By using parameter validation, you can ensure that the input to your functions and scripts meets certain criteria before the code is executed. This helps in preventing errors and improving the overall quality of your scripts.

Types of Parameter Validation

PowerShell provides several ways to validate parameters:

Required Parameters

You can specify that a parameter is required by using the [Parameter(Mandatory=$true)] attribute. This ensures that the user must provide a value for the parameter.

function Get-User {
    [CmdletBinding()]
    param (
        [Parameter(Mandatory=$true)]
        [string]$Username
    )
    # Function code here
}

ValidateNotNullOrEmpty

The [ValidateNotNullOrEmpty()] attribute ensures that the parameter is not null or an empty string.

function Get-User {
    [CmdletBinding()]
    param (
        [Parameter(Mandatory=$true)]
        [ValidateNotNullOrEmpty()]
        [string]$Username
    )
    # Function code here
}

Other variants are [ValidateNotNull()] and [ValidateNotNullOrWhiteSpace()], which behave in a similar way.

ValidateSet

The [ValidateSet()] attribute restricts the parameter value to a predefined set of valid values.

function Set-Environment {
    [CmdletBinding()]
    param (
        [Parameter(Mandatory=$true)]
        [ValidateSet("Development", "Testing", "Production")]
        [string]$Environment
    )
    # Function code here
}

ValidateRange

The [ValidateRange()] attribute ensures that the parameter value falls within a specified range.

function Set-Volume {
    [CmdletBinding()]
    param (
        [Parameter(Mandatory=$true)]
        [ValidateRange(0, 100)]
        [int]$Level
    )
    # Function code here
}

ValidatePattern

The [ValidatePattern()] attribute uses a regular expression to validate the parameter value.

function Set-Email {
    [CmdletBinding()]
    param (
        [Parameter(Mandatory=$true)]
        [ValidatePattern("^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$")]
        [string]$Email
    )
    # Function code here
}

ValidateLength

The [ValidateLength()] attribute ensures that the parameter value has a length within a specified range.

function Set-Name {
    [CmdletBinding()]
    param (
        [Parameter(Mandatory=$true)]
        [ValidateLength(8, 16)]
        [string]$Name
    )
    # Function code here
}

ValidateCount

The [ValidateCount()] attribute ensures that the parameter array has a specific number of elements.

function Set-Coordinates {
    [CmdletBinding()]
    param (
        [Parameter(Mandatory=$true)]
        [ValidateCount(2, 2)]
        [float[]]$Coordinates
    )
    # Function code here
}

TypeCasting

Another methode of validating input is to typecast your parameters, as you can see in each example, every parameter has a defined type, this way powershell knows what type of information is in the parameter and validates it. In the example below the parameter -Age is defined as an [int], it will therefore only except a numerical input.

Custom Validation

You can also create custom validation by using the [ValidateScript()] attribute, which allows you to write a script block that validates the parameter value.

function Set-Age {
    [CmdletBinding()]
    param (
        [Parameter(Mandatory=$true)]
        [ValidateScript({$_ -ge 0 -and $_ -le 120})]
        [int]$Age
    )
    # Function code here
}

When useing [ValidateScript()] you can also use other functions in the scriptblock. For example when validating a path you would do someting like this:

function Set-MyPath {
    [CmdletBinding()]
    param (
        [Parameter(Mandatory=$true)]
        [ValidateScript({
            If (Test-Path $_ ) {
                continue
            } Else {
                Throw "Path '$($_)' is invalid"
            }
        })]
        [string]$Path
    )
    # Function code here
}

Conclusion

Parameter validation in PowerShell is a powerful feature that helps ensure the integrity and reliability of your scripts. By using the various validation attributes, you can enforce rules on the input parameters, making your scripts more robust and less prone to errors.