Ini_set ('include _ path', CAKE_CORE_INCLUDE_PATH. PATH_SEPARATOR. ROOT. DS. APP_DIR. DS. PATH_SEPARATOR. ini_get ('include _ path '));
We can see that this program dynamically modifies include_path. However, cake adds CAKE_CORE_INCLUDE_PATH and APP_DIR to include_path, and preferentially finds inclusion programs in these two directories.
Note that the PATH_SEPARATOR variable is used here. This code can be used in both windows and linux.
Inspired by this, we can dynamically add some include directories as needed. For example, we have many libs: lib1, lib2, lib3, and so on. We don't have to add these libs to include_path because they may conflict.
You can create an inc_dir and add this directory to include_path. In inc_dir, create inc_path1.php tutorial inc_path2.php inc_path3.php
Ini_set ('include _ path', ini_get ('include _ path'). PATH_SEPARATOR. $ dirToLib1 );
Ini_set ('include _ path', ini_get ('include _ path'). PATH_SEPARATOR. $ dirToLib2 );
Ini_set ('include _ path', ini_get ('include _ path'). PATH_SEPARATOR. $ dirToLib3 );
When writing a program, for example, using lib2 functions. php
You can write it like this.
Require 'Inc _ path2.php ';
Require 'functions. Php ';
When the include (), require (), and fopen_with_path () functions are used to find files. without setting include_path, when these functions open files, the web root directory is used by default. after setting include_path, these php functions will first search for them under the specified include_path directory.
The principle is similar to the environment variables of the window system. When the window runs the cmd command, the system will search for the existence of these commands in the environment variables it sets after some cmd commands are entered, if yes, you can execute it.
2. Configure include_path
Modify the include_path entry in the php. Ini file.
Export de_path =.:/usr/local/lib/php:./include
Use the ini_set method.
Ini_set ("include_path", "..: ../:./include: ../include ");
Zendframework include setting index. php
Copy the code as follows:
Set_include_path ('.'. PATH_SEPARATOR. '../library /'
. PATH_SEPARATOR. './application/models /'
. PATH_SEPARATOR. './application/lib /'
. PATH_SEPARATOR.get_include_path ());
PATH_SEPARATOR is a constant. It is a ":" number in Linux and a ";" number in Windows.
Therefore, it is best to use the constant PATH_SEPARATOR in programming; otherwise, an error will occur if the system is transplanted from linux to win or vice versa!
Get_include_path gets the existing environment variables, and the preceding setting is the new system include
How does include_path work?
What if there are multiple sequence de_path statements?
Under what circumstances does include_path not work?
Today, I will give a comprehensive introduction to this question. Let's start with an example.
The following directory structure:
3. php in the root directory prints "root" and 3. php in the subdir directory prints "subdir ";
Now, my question is:
1. What output will I get when I run 1.php in the root directory?
2. Run 1.php in the upper-level directory under subdir. What output will it get?
3. When you cancel the current directory path (also called include_path = "path_to_subdir") in include_path, what are the output of the above two questions?
Include_path in PHP
When PHP encounters the require (_ once)/include (_ once) command, it first makes the following judgment:
Next, the following judgment will be made in _ php_stream_fopen_with_path:
A list of directories to be selected will be formed based on include_path and the path of the current execution file. For example, the following list of directories to be selected will be formed for the example above.
Then, start from the header of the list to be selected in sequence. According to DEFAULT_DIR_SEPARATOR (the environment in this article is ":"), extract a path from the list to be selected, and then append the file name to be included to the path, try. if it is successfully included, return; otherwise, continue to the next path to be selected.
So far, we have been able to answer the three questions I raised at the beginning.
1. because it is executed in the root directory. php contains 2. in php, the second path to be selected in include_path acts (path_to_subdir) and finds path_to_subdir/2.php, while in 2. php contains 3. in php, the current working directory is root, so it contains 3. in php, the first waiting path of include_path ". "(the current working directory), the matched file is found, so the output is" root ".
2. Same as 1, but the current path is subdir, so the output is "subdir ".
3. because the current path is include_path, 2. php contains 3. in php, it is path_to_subdir, so both root and subdir will get the "subdir" output.
If you clear include_path in 2.php,
It will be current_script_dir, and at this time current_script_dir is the path of 2. php, so we will still get the output of "subdir.
Directory relative path
When the relative directory path is used, the base point of the relative path is always the current working directory.
To illustrate the relative directory path, let's look at a column, or the directory structure above, but 1. php is changed:
2. php becomes:
If the command is executed in the root directory, 2. search in php 3. php will be searched in the relative path of the current directory, so the output is "root". If it is under subdir, execute 1.php (php-f .. /1.php), because it cannot be found under subdir ". /subdir/2. php "and exit unexpectedly.
1. because when using include_path and relative path, the performance will be related to the number of searches. In the worst case, if you have 10 include_path, you may try again for up to 11 times to find the file to be included. Therefore, it is best to use the absolute path when an absolute path is available.