Summary of PHP automatic loading and namespace applications

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 naming. Empty application, friends in need can refer to it.

Let me first tell you what a namespace is.

"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 this class, it will automatically call the __autoload($class_name) method in this file, and our new class_name will become 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(), as an example:

index.php

##

<?php 
$db = new Db();

If we do not import the Db class manually, the program may report an error saying that this class cannot 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

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

$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, you can use __autoload() to achieve basic automatic loading. 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 new Db() is called, spl_autoload_register will automatically go to the lib/ directory to find the corresponding Db.php file. After success, $db can be executed: :test(); . 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, standardized naming Space 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, 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, we want to implement The best thing is to use namespace and automatic loading to directly call multiple classes in the Lib directory in index.php on the homepage.

我们准备两个列文件：

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

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

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

结束语

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

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

相关推荐：

实例详解PHP命名空间用法

简单聊聊关于jquery的事件名称与命名空间

如何简单的实现php自动加载

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