How to Check If a String is Null or Empty in PowerShell

Why Check for Empty Strings

Here are some common reasons you may want to check if a string is null or empty in PowerShell:

• Validate user input in a script before taking action on it
• Avoid errors by acting on a string only if it has a value
• Check function parameters before passing them to other functions
• Conditionally execute code based on whether a string has a value
• Handle default values when a string does not have an assigned value
• Improve script robustness by checking string values explicitly

Put simply, checking for empty strings allows you to write cleaner, more resilient PowerShell scripts.

Using Comparison Operators

One straightforward method is comparing a string variable directly against $null using PowerShell’s comparison operators:

Check for null string

$string = $null

if ($string -eq $null) {
  "String is null"
}

The -eq operator checks for equality. If $string equals $null it will return $true.

Check for empty string

To check for an empty string, compare it against an empty string literal:

$string = ""

if ($string -eq "") {
  "String is empty"  
}

The empty quotes "" represent an empty string value.

Check for null or empty

To check for either null or empty in one comparison:

$string = ""

if ($string -eq $null -or $string -eq "") {
  "String is null or empty"
}

Using the -or operator allows multiple comparisons.

This checks $string against both $null and "" empty string.

Evaluating $null Automatically

In PowerShell, a null string variable evaluates to $false automatically:

$string = $null

if ($string) {
  "String has value"
}
else {
  "String is null or empty"
}

Here no comparison is needed. $string evaluates to $false due to being $null.

The same occurs for an empty string:

$string = "" 

if ($string) {
  "String has value"
}
else {
  "String is null or empty" 
}

Empty "" also evaluates to $false allowing a simplified null/empty check.

Using the -eq Operator

Another approach is using PowerShell’s -eq operator to evaluate a variable.

The -eq operator will return $true if the variable has a value:

$string = "test"

if ($string -eq $true) {
  "String has value"
}
else {
  "String is null or empty"
}

Here -eq $true evaluates the value of $string. If not null or empty, it returns $true.

To flip this and check for null/empty:

$string = ""

if ($string -eq $false) {
  "String is null or empty"
}
else {
  "String has value"
}

Now -eq $false returns true for a null or empty string.

Using Boolean Logic

You can also use the Boolean -not operator to check for null/empty strings:

$string = ""

if (-not $string) {
  "String is null or empty"
}
else {
  "String has value"
}

The -not operator negates the evaluation. So -not $string returns $true if $string is null or empty.

To check for a value, switch the comparison:

$string = "test"

if (-not $string) {
  "String is null or empty" 
}
else {
  "String has value"
}

Now -not $string returns false since the string has a value.

Using Set-StrictMode

You can enable PowerShell’s Set-StrictMode to require variable initialization:

Set-StrictMode -Version Latest

$string 

# Output: Cannot index into a null array

Now referencing an uninitialized variable throws an error instead of assuming $null or empty.

To suppress the error:

$string = $null

$string

Initializing it to $null explicitly makes the error go away.

This ensures you avoid uninitialized variables in your scripts.

Cmdlet Methods

In addition to comparison operators, PowerShell also provides cmdlets to check strings.

Test-Connection Cmdlet

The Test-Connection cmdlet lets you check a string variable:

$string = "test"

Test-Connection -Quiet -Count 1 -ComputerName $string

It pings the computer specified in $string. If $string is empty, it returns $false.

To test explicitly for empty:

$string = ""

if (Test-Connection -Quiet -Count 1 -ComputerName $string) {
  "String has value"
}
else {
  "String is null or empty"
}

Where-Object Cmdlet

The Where-Object cmdlet can filter based on a null/empty string:

$string = ""

$string | Where-Object {$_}

This filters for cases where $string has a value. If null/empty it returns nothing.

You can store the result in a variable:

$result = $string | Where-Object {$_}

if ($result) {
  "String has value"
}
else {
  "String is null or empty"
}

Now you can act on $result explicitly.

Evaluating Empty String Examples

Let’s look at some examples of evaluating different empty string scenarios in PowerShell:

Uninitialized variable

$string

if ($string) {
  "Has value"
}
else {
  "Null or empty" # Prints this 
}

Uninitialized $string variable evaluates to null or empty.

Null assigned variable

$string = $null

if ($string) {
  "Has value"  
}
else {
  "Null or empty" # Prints this
}

Assigning $null explicitly also evaluates to null/empty.

Empty string literal

$string = ""

if ($string -eq "") {
  "Null or empty" # Prints this
}
else {
  "Has value"
}

Assigning an empty string literal "" evaluates to null/empty when compared.

Non-empty string

$string = "test" 

if ($string) {
  "Has value" # Prints this
}
else {
  "Null or empty"
}

A string with any value inside evaluates to not null/empty.

Explicit $true evaluation

$string = "test"

if ($string -eq $true) {
  "Has value" # Prints this 
}
else {
  "Null or empty"
}

Comparing to $true also prints “Has value” for any non-empty string.

Handling Null and Empty Strings

Once you’ve checked for null/empty strings, you can handle them appropriately:

• Set a default value:

$string = $null

if (-not $string) {
  $string = "default"
}

• Throw a terminating error:

$string = ""

if (-not $string) {
  throw "String is null or empty"
}

• Continue to next iteration:

$string = $null

if (-not $string) {
  continue
}

# Rest of loop code

• Return from current scope:

$string = "" 

if (-not $string) {
  return
}

• Assign to another variable:

$string2 = $string

if (-not $string) {
  $string2 = "default"
}

These examples demonstrate useful ways to handle null/empty strings programmatically in your scripts.

Avoid Common Empty String Pitfalls

When checking for null/empty strings, beware of some common pitfalls:

• Uninitialized strings default to empty rather than null
• Empty strings ("") are different than $null empty variables
• Be cautious when handling empty strings in arrays
• Strings with only whitespace are not null/empty
• Check string parameters explicitly before passing to other functions
• Use quotes around empty string literals ("") in comparisons

Understanding the subtle differences in how null, empty, and uninitialized strings behave in PowerShell will help avoid logical errors. Explicit checks are key.

Putting It All Together

Here is a PowerShell function that shows a complete example of null/empty string validation:

function Test-String {

  param (
    [string] $value
  )

  # Initialize to empty if null
  if (-not $value) {
    $value = ""
  }

  # Explicit checks
  if ($value -eq "") {
    Write-Output "String is empty"
  }
  elseif ($value -eq $null) {
    Write-Output "String is null"
  }
  else {
    Write-Output "String has value" 
  }

}

Test-String -Value $null
Test-String -Value "" 
Test-String -Value "test"

This demonstrates parameter validation, null/empty checks, and default assignment. The result is a robust string evaluation function.

Summary

To recap, here are effective ways to check for null and empty strings in PowerShell:

• Use comparison operators -eq, -ne, etc. against $null and ""
• Rely on automatic $true/$false evaluation for null/empty
• Leverage -not and other Boolean logic
• Enable Set-StrictMode to catch uninitialized variables
• Use cmdlets like Test-Connection and Where-Object
• Evaluate empty strings explicitly before handling
• Avoid common pitfalls like uninitialized variables

Checking for null and empty strings is a critical skill for any PowerShell scripter. Use these best practices to validate parameters, act conditionally, and write resilient script logic.