Does Php Required Or Included Files Need To Follow The Order?

I'm new to PHP, so for example if I have a parent file that include the 2 child files: include_once('includes/child1.php'); include_once('includes/child2.php'); If child2.php have

Solution 1:

No code in child1 or child2 is actually being called. You're just defining some classes and functions, but nothing is calling any of these functions. Test::test_function() is never ever being evaluated, hence it cannot throw any error.

In general: yes, order matters. Everything you're trying to call needs to be defined before you call it. In this case, you're not calling anything, hence it's irrelevant.

Each file should take care of its own dependencies. I.e., child1.php should include (or better: require) child2.php itself if its code depends on it. Don't put the burden of including dependencies on the eventual user of child1.php, this just makes things extremely complicated.

In fact, you should be using autoloading, which will include all necessary files just in time as needed without you having to worry about the complexities of multiple include statements.

Solution 2:

You can think of the include family ( include_once, require, require_once ) as a cut and paste type operation. If you follow just envision php creating one big file, pasting the content from each include call ( in the top down order of execution ).

So you might have

index.php
includes.php
functions.php

And if you do this in index

include'includes.php'
some_function();

And then in includes.php

include'functions.php'

And then in functions php you have a function some_function(){} you can use this in the index file after the include, php will see it like this

include 'includes.php'
include 'functions.php'some_function(){} 
some_function();

In your example above you would not be able to call the class because you are calling it before including it. Like this

//include_once('includes/child1.php');
Test::test_function();

//include_once('includes/child2.php');classTest{
    staticfunctiontest_function() {

    }
}

However that said I notice you defined a "method" around your call to Test::test_function() that method would need to be wrapped in a class to work, if that was the intended way then it depends when you instantiate that class, you must do that after the Test class is defined. So for that case we will assume that that method is in a class

classTest2{
      publicstaticfunctioninitialize() {
          Test::test_function()
      }
 }

Now if you use this class back inside of the parent file or anywhere after the include of child2.php then it will work, so in the parent file if you do this.

include_once('includes/child1.php');
 include_once('includes/child2.php');

 Test2::initialize();

You would think of this as a big file like this

classTest2{
      publicstaticfunctioninitialize() {
          Test::test_function()
      }
 }

 classTest{
     staticfunctiontest_function() {

     }
 }

Test2::initialize();

It should be fine. You just cant call it before it is defined. Make sense?

All that said, I would strongly suggest looking into a PSR autoloader, that is the standard way of including classes these days.

Here is a good post on the topic

http://www.sitepoint.com/autoloading-and-the-psr-0-standard/

Update explination

I'll try to make this as simple as I can. The way PHP works is it loads a file and parses the code, this basically means it just checks the formatting for syntax errors or typos and any new functions or class definitions ( it only registers the names of that new stuff and checks the syntax ). Once that is done and passes it starts to execute the code from top to bottom.

Now when including a file it can't parse it right away because it needs to execute the includes, which it does not do during the initial parsing. After it runs the include it parses the new chunk of code, and then continues executing that new code from top to bottom until the end of the included file at which point it returns to the original file and continues on from the include deceleration.

So while it seems different that you can run a function before defining it in the same file, but not in an included file, it is actually the same behavior. This is because it needs to execute the file to know the functions or code that is in it. So if you call the function before the include, PHP hasn't had a chance to even look in the file yet. Some of this is because you could put an include in an if statement and then PHP would not need to include the file.

What it doesn't do is, parse the file run all the includes and then run the code. I hope that clarified how the process flow works.