So, examining this directory structure

• /include_one.php
• /include_two.php
• /directory/main_file.php

Assume that I am in /directory/main_file.php and I call include('../include_one.php'); inside of include_one.php, to include include_two.php. Do I need to call include('include_two.php); or include('../include_two.php');?

So my question is: When including a file, is the 'relative include path' shifted to the included file, or does it remain at the main including file?

I am aware that the best alternative would be to have a config.php which contains the root_path, however this is not possible at this stage.

So, im not sure who is right, as here is my test

directory structure

/include.php

/start/start.php

/folder1/includeone.php

/folder1/folder2/includetwo.php

and here is the contents of each file

start.php

<?php 
  echo 'including ../include.php<br />';
  include('../include.php');
?>

include.php

<?php 
  echo 'including folder1/includeone.php<br />';
  include('folder1/includeone.php');
?>

includeone.php

<?ph开发者_高级运维p 
  echo 'including folder2/includetwo.php<br />';
  include('folder2/includetwo.php');
?>

includetwo.php

<?php 
  echo 'done<br />';
?>

and the output is

including ../include.php

including folder1/includeone.php

including folder2/includetwo.php

done

The "relative include path" is not shifted to the included file... Which means that using relative paths generally ends badly.

A better solution, that I use almost all the time, is to always work with absolute paths -- and you can mix relatives and absolute paths using __DIR__, to get the directory that contains the file where this is written.

For example, in include_one.php, you'd use :

require_once __DIR__ . '/include_two.php';

To include the include_two.php file that's in the same directory as include_one.php.

And, in main_file.php, you'd use :

require_once __DIR__ . '/../include_one.php';

To include the include_one.php file that's one directory up.

With that, your includes will work, no matter from which file they are called.

The include path is relative to the first file in the include chain.

A good way to ensure the correct include path is to always include from the document root.

This is done like this:

include $_SERVER['DOCUMENT_ROOT'] . '/folder1/folder2/includetwo.php';

I am using this code:

if(!isset($TO_HOME_DIR)) $TO_HOME_DIR="../"; 

And I include a file:

include_once($TO_HOME_DIR."common/include_one.php");

With if(!isset($TO_HOME_DIR)), it's not important how much you include a file into included file into included file into includ..... Only first file's -and main file's- $TO_HOME_DIR declaration is used.

Second advantage of this approach is, if you change directory of file, you only need to change one line of code; $TO_HOME_DIR declaration. :)

Two demos of how include works in PHP

Im 2010 the author has wrote in his question:

So, im not sure who is right, as here is my test ...

and also in the comment:

still no answer to my update...

So I suggest my tests to understand how PHP includes work. The results were the same for versions 5 and 7.

Test 1

Files and directories:

1. /index.php

    <?php
    include 'subdirectory/index.php';

2. /subdirectory/index.php

    <?php
    include 'test.php';

3. /subdirectory/test.php

    <?php
    echo __FILE__;

The output:

/subdirectory/test.php

This test work well, because there is one and only one candidate for every include.

This requirement is also met for the test from the updated question. This is why it works well too.

Test 2

Let's copy test.php to the main root. So the new project structure is as follows:

/index.php
/test.php
/subdirectory/index.php
/subdirectory/test.php

Now the output becomes different::

/test.php

Second test has another result, because there are two candidates for the instruction include 'test.php'; and PHP chose by itself which file to include.

This is why the practice suggested by the author of the accepted answer saves the project from surprises.