How can I check if a string is null or empty in PowerShell?

You guys are making this too hard. PowerShell handles this quite elegantly e.g.:

> $str1 = $null
> if ($str1) { 'not empty' } else { 'empty' }
empty

> $str2 = ''
> if ($str2) { 'not empty' } else { 'empty' }
empty

> $str3 = ' '
> if ($str3) { 'not empty' } else { 'empty' }
not empty

> $str4 = 'asdf'
> if ($str4) { 'not empty' } else { 'empty' }
not empty

> if ($str1 -and $str2) { 'neither empty' } else { 'one or both empty' }
one or both empty

> if ($str3 -and $str4) { 'neither empty' } else { 'one or both empty' }
neither empty

---

You can use the IsNullOrEmpty static method:

[string]::IsNullOrEmpty(...)

---

In addition to [string]::IsNullOrEmpty in order to check for null or empty you can cast a string to a Boolean explicitly or in Boolean expressions:

$string = $null
[bool]$string
if (!$string) { "string is null or empty" }

$string = ''
[bool]$string
if (!$string) { "string is null or empty" }

$string = 'something'
[bool]$string
if ($string) { "string is not null or empty" }

Output:

False
string is null or empty

False
string is null or empty

True
string is not null or empty

---

If it is a parameter in a function, you can validate it with ValidateNotNullOrEmpty as you can see in this example:

Function Test-Something
{
    Param(
        [Parameter(Mandatory=$true)]
        [ValidateNotNullOrEmpty()]
        [string]$UserName
    )

    #stuff todo
}

---

Personally, I do not accept a whitespace ($STR3) as being 'not empty'.

When a variable that only contains whitespaces is passed onto a parameter, it will often error that the parameters value may not be '$null', instead of saying it may not be a whitespace, some remove commands might remove a root folder instead of a subfolder if the subfolder name is a "white space", all the reason not to accept a string containing whitespaces in many cases.

I find this is the best way to accomplish it:

$STR1 = $null
IF ([string]::IsNullOrWhitespace($STR1)){'empty'} else {'not empty'}

Empty

$STR2 = ""
IF ([string]::IsNullOrWhitespace($STR2)){'empty'} else {'not empty'}

Empty

$STR3 = " "
IF ([string]::IsNullOrWhitespace($STR3)){'empty !! :-)'} else {'not Empty :-('}

Empty!! :-)

$STR4 = "Nico"
IF ([string]::IsNullOrWhitespace($STR4)){'empty'} else {'not empty'}

Not empty

---

PowerShell 2.0 replacement for [string]::IsNullOrWhiteSpace() is string -notmatch "\S"

("\S" = any non-whitespace character)

> $null  -notmatch "\S"
True
> "   "  -notmatch "\S"
True
> " x "  -notmatch "\S"
False

Performance is very close:

> Measure-Command {1..1000000 |% {[string]::IsNullOrWhiteSpace("   ")}}
TotalMilliseconds : 3641.2089

> Measure-Command {1..1000000 |% {"   " -notmatch "\S"}}
TotalMilliseconds : 4040.8453

---

I have a PowerShell script I have to run on a computer so out of date that it doesn't have [String]::IsNullOrWhiteSpace(), so I wrote my own.

function IsNullOrWhitespace($str)
{
    if ($str)
    {
        return ($str -replace " ","" -replace "`t","").Length -eq 0
    }
    else
    {
        return $TRUE
    }
}

---

# cases
$x = null
$x = ''
$x = ' '

# test
if ($x -and $x.trim()) {'not empty'} else {'empty'}
or
if ([string]::IsNullOrWhiteSpace($x)) {'empty'} else {'not empty'}

---

Another way to accomplish this in a pure PowerShell way would be to do something like this:

("" -eq ("{0}" -f $val).Trim())

This evaluates successfully for null, empty string, and whitespace. I'm formatting the passed value into an empty string to handle null (otherwise a null will cause an error when the Trim is called). Then just evaluate equality with an empty string. I think I still prefer the IsNullOrWhiteSpace, but if you're looking for another way to do it, this will work.

$val = null    
("" -eq ("{0}" -f $val).Trim())
>True
$val = "      "
("" -eq ("{0}" -f $val).Trim())
>True
$val = ""
("" -eq ("{0}" -f $val).Trim())
>True
$val = "not null or empty or whitespace"
("" -eq ("{0}" -f $val).Trim())
>False

In a fit of boredom, I played with this some and made it shorter (albeit more cryptic):

!!(("$val").Trim())

or

!(("$val").Trim())

depending on what you're trying to do.

---

Many good answers here; let me offer a pragmatic summary with PowerShell-idiomatic solutions:

Given a variable $str that may contain $null or a string:

# Test for $null or '' (empty string).
# Equivalent of: [string]::IsNullOrEmpty($str)
-not $str            

# Test for $null or '' or all-whitespace.
# Equivalent of: [string]::IsNullOrWhitespace($str)
$str -notmatch '\S'  

Using the -not operator takes advantage of PowerShell's implicit to-Boolean conversion logic: -not forces a string operand to be converted to a Boolean, and the empty string is considered $false, whereas any non-empty string - irrespective of its value - is $true; similarly, $null always converts to $false. See the bottom section of this answer for a general overview of PowerShell's to-Boolean conversions.

See the bottom section of this answer for a general overview of PowerShell's to-Boolean conversions.

The regex-based -match / -notmatch operators, as string-only operators, coerce their LHS operand to a string, and $null is treated like '' in this conversion. \S is a regex escape sequence that matches any non-whitespace character (it is the negated form of \s). -match / -notmatch perform substring matching by default (and only ever return one match), so if \S matches, the implication is that at least one character that isn't a whitespace character is present.

\S is a regex escape sequence that matches any non-whitespace character (it is the negated form of \s).

-match / -notmatch perform substring matching by default (and only ever return one match), so if \S matches, the implication is that at least one character that isn't a whitespace character is present.

---

Another alternative adding 2 new Script Methods to the System.String instances using Update-TypeData:

Update-TypeData -MemberType ScriptMethod -MemberName IsNullOrEmpty -Value {
    return [string]::IsNullOrEmpty($this)
} -TypeName System.String

Update-TypeData -MemberType ScriptMethod -MemberName IsNullOrWhiteSpace -Value {
    return [string]::IsNullOrWhiteSpace($this)
} -TypeName System.String

'hello'.IsNullOrEmpty()  # => False
''.IsNullOrEmpty()       # => True
' '.IsNullOrEmpty()      # => False
' '.IsNullOrWhiteSpace() # => True

---

Addressing the tangential shortcoming with @KeithHill's answer not covering the IsNullOrWhitespace case, in PowerShell 7.1 and later we can use the null-conditional member operator to gracefully check if a string is null or whitespace without needing to first check that the string isn't $null ourselves, while avoiding the use of [string]::IsNullOrWhitespace(string).

Note: You can also do this with PowerShell 7.0 if you enable the PSNullConditionalOperators experimental feature: Enable-ExperimentalFeature -Name PSNullConditionalOperators

To use the $str3 example from Keith's answer (and pretending the ternary operator doesn't also exist since 7.0 for clarity):

$str3 = ' '
if ( ${str3}?.Trim() ) {
  'not empty or whitespace'
} else {
  'empty or whitespace'
}
empty or whitespace

.Trim() is only invoked if $str3 is a non-null value, otherwise $null is returned instead.

One thing to remember is that a question mark ? is valid as part of a variable name. This is why we must first disambiguate the variable name by before applying the conditional-access operator like so: ${str3}

Since I did mention the ternary operator earlier, and since this answer already centers around PowerShell 7.1 and later, you can simplify the code block above by using the ternary operator, removing the boilerplate if/then/else statement almost entirely:

${str3}?.Trim() ? 'not empty or whitespace' : 'empty or whitespace'

The ternary operator is a simplified if/then/else statement for basic conditionals. I don't want to muddy the waters too much here with nuances around it, but read it as "if the left side of the lone question-mark ? is true, execute what is on the right side of the ?, or else execute what comes after the colon :".

You can read more about the ternary operator in the PowerShell documentation.

---

Note that the "if ($str)" and "IsNullOrEmpty" tests don't work comparably in all instances: an assignment of $str=0 produces false for both, and depending on intended program semantics, this could yield a surprise.

---

An extension of the answer from Keith Hill (to account for whitespace):

$str = "     "
if ($str -and $version.Trim()) { Write-Host "Not Empty" } else { Write-Host "Empty" }

This returns "Empty" for nulls, empty strings, and strings with whitespace, and "Not Empty" for everything else.

---

You can use a conditional statement with both IsNullOrWhitespace() and isNullOrEmpty() static methods testing for white spaces or a null value. For example, before inserting into a MySQL database, I loop through the values I will enter and use the condition to avoid null or whitespace values.

// RowData is iterative, in this case a hashtable,
// $_.values targets the values of the hashtable

```PowerShell
$rowData | ForEach-Object {
    if(-not [string]::IsNullOrEmpty($_.values) -and
        -not [string]::IsNullOrWhiteSpace($_.values)) {
            // Insert logic here to use non-null/whitespace values
    }
}

---

Somewhat related hack - you can exclude empty values (eg Excel has a habit of including an extra empty cell when copying into PowerShell) like this:

get-clipboard | ? {$_}

---