1 Absolute path, relative path and undetermined path
Relative path
Relative paths refer to paths starting with ., such as
./a/a.php (relative to the current directory)
../common.inc.php (relative to the upper-level 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
/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
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 the include_path (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 require './b/b.php' in A; // Then B=[SITE]/app/test/b/b.php
Define require './c.php'; // in B, then C=[SITE]/app/test/c.php is not [SITE]/app/test/b/c.php
Example 2
Define require './b/b.php' in A; // Then B=[SITE]/app/test/b/b.php
Define require '../c.php'; // in B, then C=[SITE]/app/c.php is not [SITE]/app/test/c.php
Example 3
Define require '../b.php' in A; //Then B=[SITE]/app/b.php
Define require '../c.php'; //then C=[SITE]/app/c.php is not [SITE]/c.php
Example 4:
Define require '../b.php'; // in A, then B=[SITE]/app/b.php
Define require './c/c.php'; // then C=[SITE]/app/test/c/c.php is not [SITE]/app/c/c.php
Example 5
Define require '../inc/b.php' in A; // Then B=[SITE]/app/inc/b.php
Define require './c/c.php' in B; // Then C is still =[SITE]/app/test/c/c.php, not [SITE]/app/inc/c/c.php
Example 6
Define require '../inc/b.php' in A; // Then B=[SITE]/app/inc/b.php
Define require './c.php'; // in B, then C=[SITE]/app/test/c.php is not [SITE]/app/inc/c.php
3. Absolute path
The absolute path is relatively simple and less likely to cause confusion and error. The require|inclue one corresponds to the file 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__) 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
Define require '../b.php' in A; // Then B=[SITE]/app/b.php
Define in B require dirname(__FILE__).'/c.php'; // Then B=[SITE]/app/c.php
Example 2
Define require '../inc/b.php' in A; // Then B=[SITE]/app/inc/b.php
Defined in B require dirname(__FILE__).'/c.php'; // Then B=[SITE]/app/inc/c.php is always in the same directory as B
Conclusion: Whether B is included and used by A, or directly accessed
If B requires dirname(__FILE__).'/c.php'; // it 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 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 the configuration item (required) auto_prepend_file = "C:xampphtdocsauto_prepend_file.php"
Change configuration items (optional) allow_url_include = On
The content of import.php 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
![[Web front-end] Node.js quick start](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
