Summary of PHP automatic loading autoload and namespace methods

PHP’s automatic loading means that when we load an instantiated class, we don’t need to manually write require to import the class.php file. The program automatically loads and imports it for us. This article mainly introduces PHP automatic loading autoload and namespaces. Friends who need it can refer to the application. I hope it can help everyone.

"What is a namespace? Broadly speaking, a namespace is a way to encapsulate things. This abstract concept can be seen in many places. For example, in the operating system, directories are used to File grouping plays the role of a namespace for files in a directory. For example, the file foo.txt can exist in the directories /home/greg and /home/other at the same time, but in the same directory. There cannot be two foo.txt files in the directory. In addition, when accessing the foo.txt file outside the directory /home/greg, we must put the directory name and directory separator before the file name to get /home/greg/foo.txt. When this principle is applied to the field of programming, it is the concept of namespace. "

PHP's automatic loading means that when we load an instantiated class, we do not need to manually write require to import the class.php file, and the program automatically helps. We load and import it. With the namespace specification, we can easily handle the loading and calling of different classes in complex systems.

1. The principle of automatic loading and the use of __autoload

The principle of automatic loading is that when we instantiate a class, if PHP cannot find the class, it will automatically Call the __autoload($class_name) method in this file, and our new class_name becomes the parameter of this method. So in this method, we can require the corresponding path class file based on the various judgments and divisions we need new class_name to achieve automatic loading.

Let’s first look at the automatic call of __autoload(), for example:

index.php

<?php  
$db = new Db();

If we do not manually import the Db class, the program may An error was reported, saying that this class could not be found:

Fatal error: Uncaught Error: Class 'DB' not found in D:\web\helloweba\demo\2017\autoload\index.php:2 Stack trace: # 0 {main} thrown in D:\web\helloweba\demo\2017\autoload\index.php on line 2

So, let’s add __autoload() and take a look again:

$db = new DB();
function __autoload($className) {
 echo $className;
 exit();
}

According to the description of the automatic loading mechanism above, it will output: Db, which is the class name of the class we need new. Therefore, at this time we can load the class library file as needed in the __autoload() method.

2. spl_autoload_register automatically loads

If it is a small project, basic automatic loading can be achieved by using __autoload(). But if a project is large, or different automatic loading is required to load files with different paths, __autoload will be useless at this time, because only one __autoload() function is allowed in a project, because PHP does not allow functions with duplicate names. , which means you cannot declare two __autoload() function files, otherwise a fatal error will be reported. then what should we do? Don’t worry, whatever you think of, the PHP master has already thought of it. So another awesome function like spl_autoload_register() was born and replaced it. It performs more efficiently and is more flexible.

Let’s first see how to use it, and add the following code to index.php.

<?php  
spl_autoload_register(function($className){
 if (is_file(&#39;./Lib/&#39; . $className . &#39;.php&#39;)) {
 require &#39;./Lib/&#39; . $className . &#39;.php&#39;;
 }
});
$db = new Db();
$db::test();

Add the following code to the Lib\Db.php file:

<?php  
class Db
{
 public static function test()
 {
 echo &#39;Test&#39;;
 }
}

After running index.php, when calling new Db(), spl_autoload_register will automatically go to the lib/ directory to find the corresponding Db.php file, and can execute $db::test(); after success. Similarly, if there are multiple php class files in the Lib\ directory, they can be called directly in index.php without requiring multiple files.

In other words, spl_autoload_register can be reused multiple times. This solves the shortcomings of __autoload. If a page has multiple spl_autoload_registers, the order of execution is in the order of registration, one by one. Look down and stop if you find it.

3. spl_autoload_register automatic loading and namespace namespace

For very complex systems, the directory structure will also be very complex. The standardized namespace solves the problem of a large number of files, functions, and classes under complex paths. Duplicate name problem. Autoloading is now the cornerstone of modern PHP frameworks, and spl_autoload_register is basically used to implement automatic loading. So spl_autoload_register + namespace has become a mainstream.

According to the PSR series of specifications, namespace naming has been very standardized, so the detailed path can be found based on the namespace to find the class file.

We use the simplest example to illustrate how complex systems automatically load class files.

First, we prepare the system directory structure:

----/Lib  // 类目录
 --Db.php
 --Say.php
----autoload.php // 自动加载函数
----index.php // 首页

The above is a basic system directory. What we want to achieve is to use namespace and automatic loading to call Lib directly on the homepage index.php Multiple classes in the directory.

We prepare two column files:

Db.php

<?php  
namespace Lib;
class Db
{
 public function __construct()
 {
 //echo &#39;Hello Db&#39;;
 }
 public static function test()
 {
 echo &#39;Test&#39;;
 }
}
Say.php
<?php
namespace Lib;
class Say 
{
 public function __construct()
 {
 //echo &#39;Hello&#39;;
 }
 public function hello()
 {
 echo &#39;say hello&#39;;
 }
}

The above two ordinary class files have added namespace: namespace Lib; means that the class file belongs to Lib\ directory name, of course you can choose a different name to represent your project name.

Now let’s look at autoload.php:

<?php  
spl_autoload_register(function ($class) {
 $prefix = &#39;Lib\\&#39;;
 $base_dir = __DIR__ . &#39;/Lib/&#39;;
 // does the class use the namespace prefix?
 $len = strlen($prefix);
 if (strncmp($prefix, $class, $len) !== 0) {
 // no, move to the next registered autoloader
 return;
 }
 $relative_class = substr($class, $len);
 // 兼容Linux文件找。Windows 下（/ 和 \）是通用的
 $file = $base_dir . str_replace(&#39;\\&#39;, &#39;/&#39;, $relative_class) . &#39;.php&#39;;
 if (file_exists($file)) {
 require $file;
 }
});

以上代码使用函数 spl_autoload_register() 首先判断是否使用了命名空间，然后验证要调用的类文件是否存在，如果存在就 require 类文件。

好了，现在我们在首页index.php这样调用:

<?php  
use Lib\Db;
use Lib\Say;
require &#39;./autoload.php&#39;;
$db = new Db();
$db::test();
$say = new Say;
$say->hello();

我们只需使用一个require将autoload.php加载进来，使用 use 关键字将类文件路径变成绝对路径了，当然你也可以在调用类的时候把路径都写上，如： new Lib\Db(); ，但是涉及到多个类互相调用的时候就会很棘手，所以我们还是在文件开头就使用 use 把路径处理好。

接下来就直接调用Lib/目录下的各种类文件了，你可以在Lib/目录下放置多个类文件尝试下。

运行index.php看看是不是如您所愿。

结束语

该文简单介绍了自动加载以及命名空间的使用，实际开发中，我们很少去关注autoload自动加载的问题，因为大多数现代PHP框架都已经处理好了文件自动加载的问题。开发者只需关注业务代码，使用规范的命名空间就可以了。当然，如果你想自己开发个项目不依赖大型框架亦或者自己开发php框架，那你就得熟悉下autoload自动加载这个好东西了，毕竟它可以让我们“偷懒”，省事多了。

现代php里，我们经常使用 Composer 方式安装的组件，都可以通过autoload实现自动加载，所以还是一个“懒”字给我们带来了极好的开发效率。

相关推荐：

Laravel中autoload方法实现的用法详解

php autoload的用法总结

简单介绍自动加载类__autoload()用法

The above is the detailed content of Summary of PHP automatic loading autoload and namespace methods. For more information, please follow other related articles on the PHP Chinese website!