Order of PHP class extensions in a single file

Question

In some cases defining PHP class extensions out of order causes a fatal error, and in some cases it doesn't. I'm trying to understand the underlying behavior.

For example, both

<?php
class BaseClass {}
class FirstExt extends BaseClass {}

and

<?php
class FirstExt extends BaseClass {}
class BaseClass {}

are fine, so it's not the case that simply defining subclasses out of order causes a problem.

However, errors arise when there are three classes involved, but only in one specific case, namely when the chain of classes is defined in reverse order. That is, the following code results in a fatal error:

<?php
class SecondExt extends FirstExt {}
class FirstExt extends BaseClass {}
class BaseClass {}

If you try to run this from the command line (say as main.php), you get

PHP Fatal error:  Class 'FirstExt' not found in /path/to/main.php on line 2

However, any of the other five orderings of the three classes run with no errors. I was quite surprised that even

<?php
class SecondExt extends FirstExt {}
class BaseClass {}
class FirstExt extends BaseClass {}

works fine. The distinguishing factor is that all three possible pairs of classes are out of order in the case that gives an error, whereas in all the other cases at most two of the three pairs are out of order.

What is going on under the hood to produce this behavior?

Answer 1

The behavior isn't intuitive, but I don't think it's a bug, it's just an effect of the way PHP loads classes.

In order for a class to extend a parent class, the parent class must already be defined when the child class is defined.

Based on my observations, it appears that after the file is parsed and execution begins, the following classes are defined:

• built-in classes
• all user-defined classes defined before the file was parsed
• user-defined base classes in that file
• user-defined classes in that file that extend another class already defined, either earlier in that file or before that file was parsed

Basically any class that can be defined at compile time will be, and any other classes not defined at that point will be (attempted to be) defined at run time.

So in this example:

<?php
echo class_exists('A') ? "Yes" : "No";   // No
echo class_exists('B') ? "Yes" : "No";   // Yes
echo class_exists('C') ? "Yes" : "No";   // Yes

class A extends B {}
class C {}
class B extends C {}

class B is defined when class A tries to extend it, because it was defined when the file was parsed, because class C was defined before it in the file.

But in this example:

<?php
echo class_exists('A') ? "Yes" : "No";   // No
echo class_exists('B') ? "Yes" : "No";   // No
echo class_exists('C') ? "Yes" : "No";   // Yes

class A extends B {}
class B extends C {}
class C {}

class B is not defined when class A tries to extend it, because it was not defined when the file was parsed, because class C was not defined before it in the file.

PHP tries to find it, but it's not going to check in the same file again, it's going to try to autoload it. That's when you get "not found".

Add a fourth class and you can see it doesn't only happen when the classes are defined in reverse order:

echo class_exists('A') ? "Yes" : "No";   // No
echo class_exists('B') ? "Yes" : "No";   // No
echo class_exists('C') ? "Yes" : "No";   // Yes
echo class_exists('D') ? "Yes" : "No";   // Yes

class A extends B {}
class D {}
class B extends C {}
class C extends D {}