我应该避免在Java中的if语句中使用“！”吗？

Question

Our team's Java Coding Guideline says:

Avoid using "!" in if statement as much as possible.

I have asked other colleagues, but no one gave me clear ideas why, because the guideline was created a long time ago and the author might have left our company.

Do you have any idea?

Answer 1

With the information provided, this calls for some speculation. One possible reason is that the intent was not for an if-statement by itself but for an if-else statement. In that case, I can see where you might say that you should reverse the cases so that you don't have the extra operation of the negation. Instead of

if (! boolVar) {
  // Something
} else {
  // Something else
}

you might prefer

if (boolVar) {
  // Something else
} else {
  // Something
}

Whether this is worth it or not is probably more a matter of taste and standardization than anything else.

Answer 2

The rule is likely an adaptation from Robert Martin's Clean Code , page 302:

Negatives are just a bit harder to understand than positives. So, when possible, conditionals should be expressed as positives. For example:

 if(buffer.shouldCompact()) 

is preferable to

 if(!buffer.shouldNotCompact()) 

As an example, suppose you're creating a validator that requires two things to be false for the entity to be valid:

• The entity must not have been created within the last 12 hours, and
• The entity's bank account total sum must not exceed $50,000.

Naturally the idea would be to write two methods for this:

boolean isCreatedWithinLastTwelveHours(BankAccount account)
boolean hasMoreThanTotalSumCap(BankAccount account)

...at which point, you then invoke these as:

boolean newAccount = isCreatedWithinTheLastTwelveHours(account);
boolean highEndAccount = hasMoreThanTotalSumCap(account);

if(!newAccount && !highEndAccount) { // ... other logic

// The more astute would use DeMorgan's law in an effort to make this more readable

if(!(newAccount || highEndAccount)) { // other logic

Well...wouldn't it be nicer if you just said what they weren't instead?

boolean isNotCreatedWithinLastTwelveHours(BankAccount account)
boolean hasLessThanTotalSumCap(BankAccount account)

That'd make the expression a bit more concise:

if(notNewAccount && notHighEndAccount) { // .. carry on!

Answer 3

Of course "!" can be used when you like. There is no "unless" in java and you have no other choices in some conditions.

Answer 4

Looks like yet-another-useless-rule. Generally speaking, there are no absolute terms in this scenario, true that if you are in a if-else clause then possibly it is better to write

if(myCondition) {
    doThis()
} else {
    doSomethingElse()
}

Instead of

if(!myCondition) {
   doSomethingElse()
} else {
   doThis()
}

However, that said, in some scenarios is actually quite ok to use the negation operator, particularly if no else clause is provided, example

if (!tokenDoesCompute()) {
   throw InvalidTockenException("Whatever")
}

And actually in that scenario, using "!" makes quite a bit of sense for me.

Finally, if no one can really explain WHY the rule is there, maybe it is time to remove it, the only good reason I could find for it would be to provide consistency regarding the code style.

Answer 5

Okay, I answer my own question. As other say, maybe this is written for the readability.

In The Art of Readable Code (p. 72) says:

Prefer dealing with the positive case first instead of the negative-eg, if(debug) instead of if(!debug)

I found below post as well:

• Readable Code - Remove Checking null

   bool func(String name) { if ( (name != null) && (name.equals("true") ) { //... } else { //... } } 

   bool func(String name) { if ( "true".equals(name) ) { //... } else { //... } } 

Answer 6

Ofcourse you can use the negation operator ! whenever you like.

However, if you have a situation where you have to write some actions in both if and else block then the following is more readable :

if(status){
//do something
}
else{
//do something else
}

than

if(!status){
//do something
}
else{
//do something else
}

But if you have situation where you only need to perform certain actions based on just one condition, ie if you have only an if block & no else block, then it is reasonably fine to use ! in if

Answer 7

I haven't seen anyone else suggest this, which is probably because they hate it as much as I do, but I'm showing it for completeness.

// Using not operator (preferred)
if (! someTest) { ... }

// Using compact not operator (kind of hides it)
if (!someTest) { ... }

// Comparing to false (ok, explicitly states what you want)
if (someTest == false) { ... }

// Comparing to true (a bit obscure)
if (someTest != true) { ... }

They all do the same, but please keep using ! , just make sure you add a space after it, so it's easier to see.