Validate Boolean Array in PowerShell: Is -contains Enough?

• ✅ PowerShell's -contains checks only for the presence of a value, not full-array validation.
• ⏱️ .All() in PowerShell 7+ offers significantly better performance than Where-Object.
• 🧪 Validating both type and content is crucial to avoid false positives with implicit coercion.
• ⚠️ Mixed or null values in boolean arrays can lead to unreliable script behavior.
• 🔁 Custom foreach loops provide reliable cross-version behavior for all boolean checks.

Checking if a PowerShell boolean array has only $true, only $false, or some of both is important for scripts. This includes things like checking feature flags, automation results, or CI/CD runs. People often use PowerShell's -contains operator the wrong way for this. This can cause bugs because it only does one thing. This guide shows how to correctly check boolean arrays. We will cover ways that work well, are easy to maintain, and work with different PowerShell versions. This helps make sure your scripts work correctly and are easy to understand.

Understanding Boolean Arrays in PowerShell

A boolean array in PowerShell holds only $true or $false values. Typically, you define one like this:

[bool[]]$flags = $true, $false, $true

Here, [bool[]] explicitly says the array holds only boolean values. This is important for scripts to work reliably. But PowerShell is loosely typed. This means it often changes values like 1, 0, "true", "false", or even $null without you knowing. For instance:

$test = @(1, 0, "true", "", $null)
foreach ($val in $test) {
    Write-Output "$val is seen as: $([bool]$val)"
}

Output:

1 is seen as: True
0 is seen as: False
true is seen as: True
 is seen as: False
 is seen as: False

So, putting loosely typed data into code that expects [bool] values can lead to unexpected results.

To make sure your boolean array is really made of [bool] values:

$boolOnly = $flags -is [bool[]]

However, this only checks the type you said the array should be. It does not check the type of each item. A better way:

$flags.All({ $_ -is [bool] })

This checks that every single item is a boolean. This is especially important when you read data from other places like JSON, XML, or APIs.

Using -contains for Validation

The -contains operator in PowerShell checks if any single item in an array matches the value you give it:

$flags = $true, $false, $true

$flags -contains $true   # Returns $true because $true is present
$flags -contains $false  # Also returns $true

What it does not do is confirm whether all values are $true or $false. This leads to a big misunderstanding when people write code like:

if ($flags -contains $true) {
    # Assumes all values are $true – WRONG
}

This error can cause bugs. It lets checks pass even with arrays that have both $true and $false, like @($true, $false).

Per Microsoft’s PowerShell documentation, "-contains returns True if the collection includes the item." That's all. It's good for checking if any element matches. But it does not check if all items are the same.

Common Validation Scenarios

Here are practical situations with boolean arrays and how to handle them correctly:

1. Are all values $true?

Using Where-Object:

!($flags | Where-Object { $_ -ne $true })

If none of the elements are not $true, then all must be $true.

Using PowerShell 7+'s .All():

$flags.All({ $_ -eq $true })

2. Are all values $false?

!($flags | Where-Object { $_ -ne $false })

Or:

$flags.All({ $_ -eq $false })

3. Is the array mixed (some $true, some $false)?

$flags -contains $true -and $flags -contains $false

This pattern is easy to read. And it works well to see if the array has both $true and $false values.

4. Is every element a [bool]?

$flags.All({ $_ -is [bool] })

This test helps you get the right answer. It stops you from misunderstanding results when data from other places has types that don't work right. This includes things like 1, 0, or $null.

Better Approaches Than -contains

If you are checking whole arrays, don't use -contains. Here are other ways to do it. Which one you pick depends on your PowerShell version and how easy you want the code to read.

Where-Object (All Versions)

# Validate all true
if (!($flags | Where-Object { $_ -ne $true })) {
    "All values are True"
}

# Validate all false
if (!($flags | Where-Object { $_ -ne $false })) {
    "All values are False"
}

This way of writing is long. But it works with Windows PowerShell 5.1 and older versions.

.All() (PowerShell 7+)

$flags.All({ $_ })         # All true
$flags.All({ -not $_ })    # All false

It is shorter and works better.

foreach Loop (Universal)

function Is-AllTrue($array) {
    foreach ($val in $array) {
        if (-not $val) { return $false }
    }
    return $true
}

This is good for scripts that need to work everywhere. It doesn't need PowerShell 7 features.

Performance Considerations

When you work with large boolean arrays, like 10,000 items or more, you can see how fast each method is.

⚡ Benchmarks have shown:

(Source: Jones, 2022)

In short:

• On PowerShell 7+, use .All() for speed and clarity.
• For older versions, a foreach loop is faster than Where-Object.

For example, testing a 10K-array:

$bigArray = [bool[]]@(1..10000 | ForEach-Object { $_ % 2 -eq 0 })
$bigArray.All({ $_ -eq $true })  # Efficient

Edge Cases and Gotchas

Let's look at some tricky situations that can cause problems in your scripts:

Empty Arrays

@().All({ $_ -eq $true })    # Returns $true

Is it right to say all items are $true if there are no items? By strict logic, yes. But some people don't agree. Decide how your team will handle this case and always do it that way.

Mixed Types

This is dangerous:

$flags = @(1, $true, "false") 
$flags.All({ $_ })           # Returns $true

Why? Because "false" is text, not $false. But PowerShell sees it as $true. This is a common reason for getting wrong results.

Always check the type before checking the value:

$flags.All({ $_ -is [bool] })     # This is safer.

Nulls

$null acts like $false when PowerShell changes it to a boolean:

$flags = @($null, $true)
$flags.All({ $_ })               # returns False, fine
$flags.All({ $_ -is [bool] })    # returns False, better

Always check how nulls and empty text strings get into your data.

Tips for Code That Is Easy to Read and Work With

Like with any code, checking booleans should be easy to read, fix, and keep working:

✅ Use names for functions that say what they do:

function AllTrue { param($arr) $arr.All({ $_ }) }
function HasFalseValues { param($arr) $arr -contains $false }
function IsMixedBooleanArray { param($arr) ($arr -contains $true) -and ($arr -contains $false) }

📝 Write comments that explain why you wrote the code this way:

# Alert if any test outcome failed
if (IsMixedBooleanArray $testResults) {
    Write-Warning "Test suite returned mixed outcomes"
}

✅ Write tests for your checking code when you build functions or modules. For instance, with [Pester], check special cases for arrays. This includes arrays that are all true, all false, empty, mixed, or have the wrong types.

Real-World Use Cases

Checking boolean arrays is not just for studying. It is important where things must be right.

CI/CD Platforms

A common way this is used:

$taskResults = Get-TestResults | ForEach-Object { $_.Success }
if ($taskResults.All({ $_ })) {
    Write-Output "Pipeline success!"
}

System Audits

Checks for security, permissions, or feature settings:

function Audit-Permissions {
    param([bool[]]$results)
    if ($results.All({ $_ -eq $true })) {
        "All users have the required role"
    } else {
        "Some users are missing permissions"
    }
}

Feature Flag Enforcement

Check that all flags are set before you release a feature:

$flags = @($true, $true, $false)

if (-not ($flags.All({ $_ }))) {
    Write-Warning "Feature not enabled across all modules"
}

Code Examples and Good Ways to Write Code Summary

Three functions you can put straight into any script:

function AllTrue([bool[]]$arr) {
    $arr.All({ $_ })
}

function AllFalse([bool[]]$arr) {
    $arr.All({ -not $_ })
}

function IsMixed([bool[]]$arr) {
    ($arr -contains $true) -and ($arr -contains $false)
}

Final Recommendation

If you work with PowerShell boolean arrays—like in test scripts, DevOps runs, or admin jobs—it is very important to check them carefully. Understand exactly what each tool does:

• Use -contains only to check if an item is there, not to check the whole array.
• Use .All() when you can. It is shorter, fast, and clear.
• Fall back to Where-Object or foreach if you need to work with older versions.
• Always check that your data has the right type. PowerShell changing types automatically can cause bugs you don't see.

Write clearly, test special cases, and make sure your team knows the difference between checking if an item is there (-contains) and checking the whole array.

Be consistent, be careful, and keep using PowerShell.

Citations

• Microsoft Docs. (2023). about_Comparison_Operators – PowerShell. Retrieved from https://learn.microsoft.com/powershell
• Jones, R. (2022). PowerShell and Performance: Evaluating Collection Processing Methods. ScriptingBlog.
• Anderson, P. (2021). Common PowerShell Misconceptions and Edge Cases. DevCommunity Magazine.