Powershell: how to use an if condition with true false

pooja520 

No worries at all!

Taking a brief look at some of your final points:

The .Equals() method

Looking at the reference documentation (below), you can see there's two overrides for the .Equals() method: one that accepts an actual Boolean value and another that accepts any object type.

• Boolean.Equals Method (System) | Microsoft Docs

Without going into depth here, only the .Equals() that takes the Boolean parameter is of use in the majority of cases.

This is necessary to remember when looking at the example you provided - which uses mixed types, which I'll do again before bringing things together.

First, here's your example again as the reference point.

$Stat = 'False'
$True -eq $Stat
> True #how do I get here False?

Here's the important takeaways in short form:

• Your first statement is a String assignment, not a Boolean assignment;
• Your second statement is comparing a Boolean type on the left to a string type on the right, which should be read as:
  
  $True -eq ($null -ne $Stat)
  
  And since $Stat is indeed not a null reference, this leads to the assessment of $True -eq $True, which of course is true, which brings you to your third point of:
• "How can we get a false instead?"

Before getting to answering that, here's another reference image.

This picture should help illustrate the difference between what I said before as well as speak to why you get $true and not $false for your third line.

The if() statement highlights what I said in my previous post which is that the value held in the string, $Stat, is not implicitly converted to its Boolean equivalent. Rather, PowerShell sees some random old string and performs an existence - or "not null" - check.

So, where you are expecting this assessment:

$True -eq (implied conversion of string 'false' to $false)

What PowerShell is actually doing is this:

$True -eq ($Stat -ne $null)

Which is how you get to the assessment of $True -eq $True, which of course produces the result you see of True.

So, this gets us as far as explaining the result you saw but not yet how to do what you want, which is to assess a string as if it were a Boolean.

It's important to mention at this point that you cannot implicitly convert a string into a Boolean value - as you noted in your comment where you tried to typecast using the [bool] prefix. This is actually one instance where PowerShell and it's cousin, C#, are consistent, since you can't do it that way there, either.

Here's a very simple, single-line function that shows you how PowerShell responds to the implied string-to-Boolean conversion scenario (i.e. it throws an exception saying it cannot):

So, now that we've seen PowerShell's "reluctance" to perform implicit casting from a string to a Boolean, how do we move forward with a proper Boolean value-to-value comparison?

We're getting closer to answering that, but we're not there yet!

While we cannot implicitly convert a string to a Boolean, we can implicitly convert a Boolean to a string. This behaviour explains what you see below:

The first line equates to:

$false -eq ($null -ne [string])

Which is why you get a result of false where you might have been excused for expecting a true. In this example, the left and the right sides of the operand are of Boolean type.

The second line, however, involves strings on both sides of the operand. In other words, the second line equates to:

"false" -eq ($false.ToString())

Which of course produces the expected result of true.

Slightly modifying our earlier single-line function to require a [string] input, we can see a degree of progress.

But we're still not there yet since a string-to-string comparison isn't what I would call robust.

Enter the .Parse() and .TryParse() methods

The Boolean structure defines a .Parse() method - well two, actually, but there's no need for discussing both.

• Boolean.Parse Method (System) | Microsoft Docs
• Boolean.TryParse Method (System) | Microsoft Docs

The key point of difference with these two is that for Parse, you should wrap that in your own try ... catch block, where TryParse avoids the need for the try ... catch block at the expense of creating an additional clause in your "if" statement.

Parse() with try ... catch

TryParse()

Summary

That's a much deeper dive than is generally needed for most situations but the general gist is to pick a data type to compare and adjust accordingly:

• Compare a string to a string by placing the static string on the left and the string or Boolean variable to the right of the operand, or;
• Compare a Boolean to a Boolean by suitably parsing the supplied string variable into a Boolean.

Either of these approaches should yield consistent results.

As I mentioned before, Booleans can be deceptive in PowerShell under certain circumstances.

Cheers,

Lain