if ('constant' == $variable) vs. if ($variable == 'constant')

Question

Lately, I've been working a lot in PHP and specifically within the WordPress framework. I'm noticing a lot of code in the form of:

if ( 1 == $options['postlink'] )

Where I would have expected to see:

if ( $options['postlink'] == 1 )

Is this a convention found in certain languages / frameworks? Is there any reason the former approach is preferable to the latter (from a processing perspective, or a parsing perspective or even a human perspective?)

Or is it merely a matter of taste? I have always thought it better when performing a test, that the variable item being tested against some constant is on the left. It seems to map better to the way we would ask the question in natural language: "if the cake is chocolate" rather than "if chocolate is the cake".

Answer 1

The main reason to do this (so-called "Yoda conditional") is to prevent accidents whereby you accidentally use an assignment operator (=) instead of the equal comparison operator (==).

That is, if you made the mistake of doing:

$foo = 5;
if ($foo = 1) {
  // Stuff
}

The statement will evaluate to true (or, in the case of some languages—like PHP—a truthy value) and you'll have a hard-to-find bug.

But if you did:

$foo = 5;
if (1 = $foo) {
  // Stuff
}

You'll receive a fatal error because you can't assign $foo to an integer.

But as you pointed out, reversing the order generally makes things less readable. So, many coding standards (but not all, including WordPress) suggest or require $foo == 1 despite the bug hunting benefits of 1 == $foo.

Generally, my advice is to follow whatever established coding standard there is, if there is one: for WordPress, that means using Yoda conditionals.

When there isn't, and it's impossible to establish one through consensus with your peers, it's dealer's choice.

Answer 2

It's a defensive coding mechanism meant to prevent an accidental use of the assignment operator.

Consider a misuse/error of the assignment operator in place of the equality operator

if ( $options['postlink'] = 1  )

The above conditional would always return true, but that's probably not what the original programmer had in mind. Consider, in it's place, this

if( 1 = $options['postlink'])

Here, PHP (and most other languages) would refuse to run, as it's impossible to assign anything to the fixed value of 1. By coding up all the conditional statements this way, you automatically ensure no accidental usage of an assignment operator in a conditional.

Answer 3

I like using that convention in java to remove the possibility of a null pointer exception. So something like this won't cause you any problems or need any extra code:

String foo = null;

if ("bar".equals(foo))
{
    //Do something
}

Answer 4

In practice, many compilers will give you a warning if you write "if (x = 1)" instead of "if (x == 1)" because it is most likely a mistake.

With Clang, you can avoid the warning by effectively telling the compiler "I mean it, and I know what I'm doing", and this is done by writing "if ((x = 1))". Note the extra parentheses. That works in other situations as well. if (false) statement; may give you a warning that the statement is never executed; if ((false)) statement; doesn't give that warning.

PS. Many languages nowadays require that the expression in an "if" statement is boolean, without any automatic conversion. In "if (x = 1)" the expression has type "int" so it won't be accepted, except for the rare case "if (bool1 = bool2)".

Answer 5

if ($variable == 'constant')

Because you spend more time reading code than writing it (see https://www.goodreads.com/quotes/835238-indeed-the-ratio-of-time-spent-reading-versus-writing-is), and this form is easier to read.

Although User8 has a valid argument to have the constant first; that's reasoning about what to do from the code writer's perspective. Normally, there are less experienced coders reading code, and they need all the help they can get in matching the natural order that would have the constant laste. (And of course, good language design and compiler checks overcome the stated problem).