Coding Standards, why if ( boolVar ) over if ( boolVar == true )

[Alfred Taylor]

I've been flipping through various coding standards documents for C#/.NET
and all of them say to use:

if ( boolVar ) {...} instead of if ( boolVar == true ) {...}

For the life of my I can't figure out why. If anything, I would guess the
opposite would be better to use since the ! operator is so hard to read.

Upon quick glance,

if ( boolVar == false ) is easier to understand than if ( !boolVar )

Anybody have some more concrete reasons why one is preferred over the other
aside from one being less typing.

Thanks,
-A

[Alfred Taylor]

"Bruce Wood" <br*******@cana da.com> wrote in message
news:11******** **************@ z14g2000cwz.goo glegroups.com.. .

For those who found my preceding reply utterly unconvincing :) I offer
the following:

The problem with Alfred's original sample was the name of the variable.

Fair enough. ;)

-A

[Bruce Wood]

Incidentally (although I'm sure that this _will_ cause a holy war), I
apply the same reasoning to curly braces and all other manner of code
formatting: if I start work at a shop that formats their code a certain
way, and I insist upon continuing to do it "my way" because my way is
"better," then I am an idiot.

It doesn't matter how stupid "their way" of formatting code looks to
me. If everyone else in the shop is used to that, then that is what is
"more readable" and it is what I should be doing, too.

My dream shop would have an automated code formatter that would just
mash everyone's code and make it look the same every time it was
checked into the library. Visual Studio's "Edit->Advanced->Format
Selection" operation is your friend! Productivity wouldn't jump, but it
would improve.

I read stories of programmers (during the big boom, when we could get
away with anything, including bringing pets to work) insisting on
writing formatters / deformatters so that they could transform others'
code into "their" style, code in "their" style, and then transform the
code back to the group standards. I just shake my head in wonder at
such nonsense.

[RichS]

As a quick comment. I have a pet hate against this minimal typing when
it comes to string comparisons. Does anybody actually find this
readable ?!:

if ( !strcmp( string1, string2 ) )
{
// Strings match
}
else
{
// Strings dont match
}
I've gotten into the habit of putting the fixed value on the
left-hand-side. It takes a bit of getting used to, but as a consistent
approach I use this across the board, regardless of type.

if ( true == bValue )
{
}

if ( 0 == strcmp( string1, string2 ) )
{

}
etc..
etc..
Rich
Bruce Wood wrote:

Incidentally (although I'm sure that this _will_ cause a holy war), I
apply the same reasoning to curly braces and all other manner of code
formatting: if I start work at a shop that formats their code a certain way, and I insist upon continuing to do it "my way" because my way is
"better," then I am an idiot.

It doesn't matter how stupid "their way" of formatting code looks to
me. If everyone else in the shop is used to that, then that is what is "more readable" and it is what I should be doing, too.

My dream shop would have an automated code formatter that would just
mash everyone's code and make it look the same every time it was
checked into the library. Visual Studio's "Edit->Advanced->Format
Selection" operation is your friend! Productivity wouldn't jump, but it would improve.

I read stories of programmers (during the big boom, when we could get
away with anything, including bringing pets to work) insisting on
writing formatters / deformatters so that they could transform others' code into "their" style, code in "their" style, and then transform the code back to the group standards. I just shake my head in wonder at
such nonsense.

[Christoph Nahr]

On 3 Feb 2005 02:16:07 -0800, "RichS"
<ri************ ****@surfcontro l.com> wrote:

I've gotten into the habit of putting the fixed value on the
left-hand-side. It takes a bit of getting used to, but as a consistent
approach I use this across the board, regardless of type.

Argh, I absolutely hate that. Mathematical tradition always puts
variables on the left and constants on the right of a comparison, and
that's also the natural way to read a comparison. One of the best
things about C# as compared to C++ is that there's no auto-conversion
of everything to boolean, so you no longer have to invert comparisons
to prevent typo bugs...
--
http://www.kynosarges.de

[GingerDeafMan]

In article <11************ *********@l41g2 000cwc.googlegr oups.com>,
ri************* ***@surfcontrol .com says...

As a quick comment. I have a pet hate against this minimal typing when
it comes to string comparisons. Does anybody actually find this
readable ?!:

if ( !strcmp( string1, string2 ) )
{
// Strings match
}
else
{
// Strings dont match
}

This is a different issue altogether. strcmp does not actually return
boolean value. So, although the above will still work, it is
technically incorrect because the other possible return values are
negative or positive numbers denoting which string is "greater"
alphabetically, rather than true or false.

Above should have been
if(strcmp(str1, str2)==0)
//stings match

I've gotten into the habit of putting the fixed value on the
left-hand-side. It takes a bit of getting used to, but as a consistent
approach I use this across the board, regardless of type.

if ( true == bValue )

This is uncessessary extra bit of coding imo. Good C/Java/C#
programmers should be able to read

if(bValue)

happily and not dismiss the ! operand as "hard to read" e.g.

if(!bValue).

Daniel has already given a very good example as to why using

if(bvalue==true )

is a not a good practice and

if(true==bValue )

is just a workaround, imo, for those not confident enough to read pure
C/Java/etc syntax.

Just my 2p worth.

Cheers,

Paul.

[saurabh]

>

int i = 0;
...
if (i = 3) {...}

In good old days of C and C++ this would not have been flagged as a compile
time error which got quite a few people into habit of writing the condition
with constant on the left had side like : if ( 3 == i) This would trap the
missed equal to sign (if (3 = i)) as a compiler error !!

[Bruce Wood]

I never liked the

if (!strcmp(string 1, string2))

convention in C. It just struck me as sloppy: strcmp returns a
tri-state value, not a dual-state value, so using ! always struck me as
a cheap trick. I always preferred to code

if (strcmp(string1 , string2) == 0)

in order to highlight the fact that it could be zero, less than zero,
or greater than zero. As GingerDeafMan points out, thanks to Anders
Hejlsberg and team, C# doesn't allow you to treat integers as booleans,
so now everyone has to do it my way. :)

Of course, those few times when I was in a shop that had standardized
on testing strcmp results using the ! operator, I had to hold my nose
and adapt.... :)