PHP – Difference Between (null != $object) and ($object != null)

code-qualityconditionsobject-orientedPHP

I am used to Java and therefore always think conditions are interpreted from left to right, i.e. there is a vital difference in null != $obj and $obj != null

Now this seems not to be the case with PHP.

Can I do something wrong in PHP when I always start with null on the left-hand side? Can I keep my behaviour from Java or do I need to train myself to do something else when dealing with PHP conditions?

Best Answer

There is no (technical) difference – nor is there in Java to my knowledge.
In PHP, do not use either of these.

I recommend you always use the strict comparison operators === and !== if possible. You will know when you actually need loose comparison operators.

Misunderstandings

I believe you may be confused about a couple of things:

short-circuiting operators
order of evaluation
operator precedence

I just found that the PHP manual says: "PHP checks each condition in order from left to right"

No,

the PHP manual does not say that, it's a comment.
PHP does not do that.

PHP evaluates the conditions from left to right, but it stops once the result is known:

expr1 && expr2

If expr1 evaluates to false, expr2 will not be evaluated. This is called short-circuiting and it does not seem to be very well-documented – I couldn't find any other official note on the matter except for the comment in Example #1. It is a well-known feature, though.

Fallacies

I am used to Java and therefore always think conditions are interpreted from left to right, i.e. there is a vital difference in null != $obj and $obj != null

PHP checks each condition in order from left to right
Ergo: The same "best practice" can be applied

Ergo: nothing – non sequitur. The conclusion does not follow from the premise. Using constant == $variable or $variable == constant is not connected to either of short-circuiting, order of evaluation or operator precedence.

Undefined behavior

Both operands of != are always evaluated. In the case of PHP, the evaluation order (which is irrelevant here) is actually unspecified (as in absent from the documentation).

Related Solutions

PHP – Advantages of Multiple Methods Over Switch

A switch is considered not OOP because often polymorphism can do the trick.

In your case, an OOP implementation could be this:

class Oop 
{
  protected $goer;

  public function __construct($goer)
  {
    $this->goer = $goer;
  }

  public function go()
  {
    return $this->goer->go();
  }
}

class Goer
{
  public function go()
  {
    //...
  }
}

class GoerA extends Goer
{
  public function go()
  {
    //...
  }
}

class GoerB extends Goer
{
  public function go()
  {
    //...
  }
}

class GoerC extends Goer
{
  public function go()
  {
    //...
  }
}


$oop = new Oop(new GoerB());
$oop->go();

Web Development – How to Keep Track of Large Projects

The trick to understanding a large code base is to not try to understand all of it. After a certain size, you can't hold a mental model in your head of the entire thing. You start with an anchor point that makes sense for whatever task you need to work on first, then branch from there, learning only the parts you need and trusting that the rest of it works as advertised. It's just like understanding recursion. If you try to hold the entire stack in your head your brain explodes.

Grep, debuggers, and intellisense are your friends here. If you don't know how a function ends up getting called, set a breakpoint on it and work your way down the stack trace.

The other thing to note is that large code bases don't spring up out of nowhere. The larger it is, the more programmers there are with experience on it, so ask them where to start, but be specific. Ask questions like, "I need to add a new payment provider. Where in the code should I be looking?" Focus on just that task instead of trying to understand the entire code base, and piece by piece your familiarity will grow.