if语句是否带有否定

Question

Obviously, these two samples achieve the same thing. But are there any, perhaps implementation-specific cases, where one could have better performance than the other?

Maybe a silly question, but this has got me thinking today.

Edit: The example uses strings but this can be anything , and my question has nothing to do with how fast a string comparison is etc.

if (something == 'something') {
  return "something's up";
}
return;

vs

if (something != 'something') {
  return;
}
return "something's up";

Answer 1

One could out perform the other very slightly if you anticipate how the if will trigger on average and how your specific CPU handles branch prediction . For instance if you know your CPU will always predict that the branch will lead into the if statement, and you expect something to equal true more often than not, then the first choice:

if (something == true) {
  return true;
}
return;

will out perform the second. CPU branch predictors are rarely this simple and are adaptive now ( http://en.wikipedia.org/wiki/Branch_predictor see "saturating counter") but hopefully this gives you a little insight. Either way the performance increase is extremely slight, especially on today's systems.

:ADDITION:

As for the two in the comments: When it reaches the CPU as assembly they will be exactly the same as what you have above so nothing really changes.

Answer 2

Either way it's fine, from a performance point of view they're almost certainly identical and any difference would be negligible. But for clarity, it's recommended that you write conditions like this:

if (something) {  // no need to compare something == true
  return true;
}
return false;

Or even better:

return something; // just return the boolean value!

No matter which version you choose, you should optimize for readability an clearness. It's more important to have a good name for the variable than the actual order in which you write the conditions.

Answer 3

Code is read and modified a lot more often than it's written. Since performance is the same when translated into assembly language, if statements should be written so that's it is the easiest to read.

Example :

if (x > (2 + 3)) //or something more complex
{
    return true;
}
else
{
    return false;
}

is easier to read that way :

bool isGreaterThanFive = x < (2 + 3)

if (isGreaterThanFive)
{
    return true;
}
else
{
    return false;
}

and even more compact :

if (isGreaterThanFive) return true; //Very close to human language
else return false;

OP's first code block si easier to read so it should be written that way, performance not being an issue.

EDIT : more about code readability, Code Complete by Steve McConnell http://en.wikipedia.org/wiki/Code_Complete