Application summary of PHP automatic loading autoload and namespace

Let me first tell you what a namespace is.

"What is a namespace? Broadly speaking, a namespace is a way of encapsulating things. This abstract concept can be seen in many places. For example, in operating systems, directories are used to group related files. For directories For files, it plays the role of a namespace. For example, the file foo.txt can exist in the directories /home/greg and /home/other at the same time, but two foo.txt cannot exist in the same directory document. 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. The application of this principle to the field of programming is the concept of namespace. ”

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. 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, our new class_name It becomes the parameter of this method. So we can use new in this method according to our needs Various judgments and divisions of class_name require the corresponding path class file to achieve automatic loading.

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

index.php

<?php 
$db = new Db();

If we do not manually import the Db class, the program may report an error saying that this class cannot be found:

Fatal error: Uncaught Error: Class 'DB' not found in D:webhellowebademo2017autoloadindex.php:2 Stack trace: #0 {main} thrown in D:webhellowebademo2017autoloadindex.php on line 2

So, let’s add the __autoload() method now and take a look:

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

According to the description of the automatic loading mechanism above, the output will be: 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, use __autoload() Basic automatic loading can be achieved. 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 is allowed in a project. __autoload() function, because PHP does not allow functions with duplicate names, which means you cannot declare two __autoload() function file, 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 spl_autoload_register() In this way, another awesome function was born and replaced it. It performs more efficiently and is more flexible.

Let’s first see how to use it. 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 LibDb.php file:

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

After running index.php, when new Db() is called, spl_autoload_register It will automatically go to the lib/ directory to find the corresponding Db.php file. After success, $db::test(); can be executed. . 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. Then if a page has multiple spl_autoload_registers, the execution order is according to the order of registration. Look down one by one. If found Just stop.

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 with duplicate names under complex paths. Autoloading is now the cornerstone of modern PHP frameworks, basically spl_autoload_register to implement automatic loading. So spl_autoload_register namespace It became 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 directly call multiple classes in the Lib directory on the homepage index.php.

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;;
 }
}

以上两个普通的类文件，添加了命名空间： namespace Lib; 表示该类文件属于Lib目录名称下的，当然你可以随便取个不一样的名字来表示你的项目名称。

现在我们来看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 LibDb(); ，但是涉及到多个类互相调用的时候就会很棘手，所以我们还是在文件开头就使用 use 把路径处理好。

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

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

结束语

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

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

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