Detailed explanation of require and include path issues in PHP, requireinclude_PHP tutorial

Detailed explanation of require and include path issues in PHP, requireinclude

1 Absolute path, relative path and undetermined path

Relative path

Relative paths refer to paths starting with ., such as

Copy code The code is as follows:

./a/a.php (relative to the current directory)
../common.inc.php (relative to the parent directory),

Absolute path

The absolute path is a path starting with / or a drive letter similar to C:/ under Windows. The full path can uniquely determine the final address of the file without any reference path. For example

Copy code The code is as follows:

/apache/wwwroot/site/a/a.php
c:/wwwroot/site/a/a.php

Undetermined path

Any path that does not start with . or /, nor does it start with drive letter:/ under Windows, such as

Copy code The code is as follows:

a/a.php
common.inc.php,

At first I thought this was also a relative path, but in PHP’s include/require mechanism, this type of path is handled completely differently from relative paths starting with . require './a.php' and require 'a.php' are different!

Let’s analyze the processing methods of these three types of include paths: First, remember a conclusion: if the include path is a relative path or an absolute path, it will not go to include_path (the include_path environment variable defined in php.ini, or in the program Use set_include_path(...) to find the file.

Test environment description

Note: The following discussion and conclusion are based on this environment: Assume A=http://www.xxx.com/app/test/a.php. It is emphasized again that the following discussion is for the case of direct access to A.

2. Relative path:
Relative paths require a reference directory to determine the final path of the file. In include parsing, no matter how many levels of inclusion are nested, this reference directory is the directory where the program execution entry file is located.

Example 1

Define in A require './b/b.php'; // Then B=[SITE]/app/test/b/b.php
Define in B require './c.php'; // Then C=[SITE]/app/test/c.php is not [SITE]/app/test/b/c.php

Example 2

Defined in A require './b/b.php'; // Then B=[SITE]/app/test/b/b.php
Define in B require '../c.php'; // Then C=[SITE]/app/c.php is not [SITE]/app/test/c.php

Example 3

Defined in A require '../b.php'; //Then B=[SITE]/app/b.php
Define in B require '../c.php'; //Then C=[SITE]/app/c.php is not [SITE]/c.php

Example 4:

Defined in A require '../b.php'; // Then B=[SITE]/app/b.php
Define in B require './c/c.php'; //Then C=[SITE]/app/test/c/c.php is not [SITE]/app/c/c.php

Example 5

Define in A require '../inc/b.php'; // Then B=[SITE]/app/inc/b.php
Define in B require './c/c.php'; // Then C still =[SITE]/app/test/c/c.php not [SITE]/app/inc/c/c.php

Example 6

Define in A require '../inc/b.php'; // Then B=[SITE]/app/inc/b.php
Define in B require './c.php'; // Then C=[SITE]/app/test/c.php is not [SITE]/app/inc/c.php

3. Absolute path

Absolute paths are relatively simple and less likely to cause confusion and errors. require|inclue corresponds to files on the disk.

require '/wwwroot/xxx.com/app/test/b.php'; // In Linux
require 'c:/wwwroot/xxx.com/app/test/b.php'; // in windows
dirname(__FILE__) is also calculated as a directory in the form of an absolute path, but it should be noted that __FILE__ is a Magic constants, which is equal to the absolute path of the php file where this statement is written at any time, so dirname(__FILE__) is also It always points to the absolute path of the php file where this statement is written, and has nothing to do with whether the file is included and used by other files.

Example 1

Defined in A require '../b.php'; // then B=[SITE]/app/b.php
Define in B require dirname(__FILE__).'/c.php'; // Then B=[SITE]/app/c.php

Example 2

Define in A require '../inc/b.php'; // then B=[SITE]/app/inc/b.php
Define in B require dirname(__FILE__).'/c.php'; // Then B=[SITE]/app/inc/c.php is always in the same directory as B
Conclusion: No matter B is included and used by A, or directly accessed

B if require dirname(__FILE__).'/c.php'; // will always refer to the c.php file in the same directory as B;
If B requires dirname(__FILE__).'/../c.php'; // it will always refer to the c.php file in the parent directory of the directory where the B file is located;
If B requires dirname(__FILE__).'/c/c.php'; // it will always refer to the c.php file in the c subdirectory of the directory where the B file is located;

4. Undetermined path

First, use the include directories defined in include_path to splice [undetermined path] one by one. If an existing file is found, the include will exit successfully. If it is not found, use the directory where the php file that executes the require statement is located to splice [undetermined path] ] to search for the file. If the file exists, it will exit successfully. Otherwise, it means the file does not exist and an error will occur. Undetermined paths are easy to confuse and are not recommended.

5. Solution

Since the "reference directory" in "relative path" is the directory where the execution entry file is located, the "undetermined" path is also easier to confuse, so the best solution is to use an "absolute path"; for example, the content of b.php As shown below, no matter where b.php is required, the path of b.php is used as a reference to require c.php

$dir = dirname(__FILE__);
require($dir . '../c.php');
Or define a general function import.php, set it to "automatically import files in advance", and make the following configuration in php.ini

Change configuration item (required) auto_prepend_file = "C:xampphtdocsauto_prepend_file.php"
Change configuration item (optional) allow_url_include = On

The content of import.php is as follows

Copy code The code is as follows:

function import($path) {
$old_dir = getcwd(); // Save the original "reference directory"
chdir(dirname(__FILE__)); // Change the "reference directory" to the absolute path of the current script
​ require_once($path);
chdir($old_dir); // Change back to the original "reference directory"
}

In this way, you can use the import() function to require the file. No matter how many levels of "reference directories" it contains, it is the current file

http://www.bkjia.com/PHPjc/932469.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/932469.htmlTechArticleDetailed explanation of require and include path issues in PHP, requireinclude 1 absolute path, relative path and undetermined path relative path relative path Refers to the path starting with ., such as copy code code...