Summary of usage of autoload in php_PHP tutorial-PHP Tutorial-php.cn

Summary of usage of autoload in php_PHP tutorial

WBOY

Release： 2016-07-13 10:25:25

Original

826 people have browsed it

Autoload is provided in PHP to help us conveniently include files, but autoload is not able to handle all situations as imagined. Today we will record some of the problems with autoload that we encountered a few days ago.

Why use Autoload

When using classes in PHP, we must load them before use, whether through require or include, but there will be two problems that affect our decision to load.

The first is that I don’t know where this class file is stored, and the other is that I don’t know when I need to use this file. Especially when there are a lot of project files, it is impossible to write a long string of require at the beginning of each file....

After PHP5, we can solve this problem through __autoload. And after PHP5.1, spl_autoload_register() is also provided to provide a more complete loading mechanism.

After reading the article Autoloading in PHP, I understand the loading mechanism of Autoload. When a class is instantiated through new, PHP will load the corresponding file through the defined __autoload function. If this class file uses If extends or implements needs to use other class files, PHP will re-run autoload to search and load the class files. If two requests for the same class file occur, an error will be reported. The author of the original article provided three interesting examples to illustrate this problem, which can be viewed by downloading the source code here.

Generally, there are many ways to solve the problem of finding files in the corresponding location when loading. The most commonly used one is to specify a specific naming standard.

Zend’s method

zend recommends one of the most popular methods, including the path in the file name. For example, the following example:

// Main.class

function __autoload($class_name) {
$path = str_replace('_', DIRECTORY_SEPARATOR, $class_name);
require_once $path.'.php';
}

$temp = new Main_Super_Class(); All underscores will be replaced with separators in the path. In the above example, the Main/Super/Class.php file will be reached

The disadvantage of this method is that during the coding process, we must clearly know where the code file should be, and because

The file path is hard-coded in the class name. If we need to modify the folder structure, we must manually modify all class names.

'Include All' method

If you are in a development environment and don’t care much about speed, it is very convenient to use this method. By placing all class files in one or several specific folders, and then traversing to find and load them.

For example:

Copy code The code is as follows:

$arr = array (
'Project/Classes',
'Project/Classes/Children',
'Project/Interfaces'
);

foreach($arr as $dir) {
$dir_list = opendir($dir);

while ($file = readdir($dir_list)) {
$path = $dir.DIRECTORY_SEPARATOR.$file;
if(in_array($file, array('.', '..') ) || is_dir($path))
continue;

if (strpos($file, ".class.php"))
require_once $path;
}
}
?>

Associating files and locations

Another method is to establish an associated configuration file between the class file and its location, for example:

Copy the code The code is as follows:

// configuration.php
array_of_associations = array(
'MainSuperClass' = 'C:/Main/Super/Class.php',
'MainPoorClass' = 'C:/blablabla /gy.php'
);

The file called

Copy the code The code is as follows:

require 'autoload_generated.php';

function __autoload($className) {
global $autoload_list;
require_once $autoload_list[$className];
}

$x = new A();
?>

Of course, if there are too many files, it will be a troublesome thing to maintain, but which one is better than hard-coding the location in the class name?

Of course we don’t want to maintain this list manually, so we can use automatic generation of this file to achieve this. The corresponding file can be phpxmljson and so on. The author of the original article implemented such a tool. If you think about it carefully, this is not difficult to implement. The author of the original article even developed a small Autoload framework, which is worth learning.