PHP命名空間與自動載入實例詳解

include 和 require 是PHP中引入檔案的兩個基本方法。在小規模開發中直接使用 include 和 require 沒喲什麼不妥，但在大型專案中會造成大量的 include 和 require 堆積。這樣的程式碼既不優雅，執行效率也很低，而且維護起來也相當困難。

為了解決這個問題，部分框架會給予一個引入檔案的設定清單，在物件初始化的時候把需要的檔案引入。但這只是讓程式碼變得更簡潔了一些，引入的效果仍然是差強人意。 PHP5 之後，隨著 PHP 物件導向支援的完善，__autoload 函數才真正使得自動載入成為可能。

* include 和 require 功能是一樣的，它們的不同在於 include 出錯時只會產生警告，而 require 會拋出錯誤終止腳本。

* include_once 和 include 唯一的區別在於 include_once 會檢查檔案是否已引入，如果是則不會重複引入。

=================自動載入==================

實現自動載入最簡單的方式就是使用__autoload 魔術方法。當需要使用的類別沒有被引入時，這個函數會在PHP報錯前被觸發，未定義的類別名稱會被當作參數傳入。至於函數具體的邏輯，這需要使用者自己去實作。

先建立一個autoload.php 來做一個簡單的測試：

// 类未定义时，系统自动调用function __autoload($class)
{    /* 具体处理逻辑 */
    echo $class;// 简单的输出未定义的类名}new HelloWorld();/**
 * 输出 HelloWorld 与报错信息
 * Fatal error: Class 'HelloWorld' not found */

透過這個簡單的範例可以發現，在類別的實例化過程中，系統所做的工作大致是如此的：

/* 模拟系统实例化过程 */function instance($class)
{    // 如果类存在则返回其实例
    if (class_exists($class, false)) {        return new $class();
    }    // 查看 autoload 函数是否被用户定义
    if (function_exists('__autoload')) {
        __autoload($class); // 最后一次引入的机会    }    // 再次检查类是否存在
    if (class_exists($class, false)) {        return new $class();
    } else { // 系统：我实在没辙了
        throw new Exception('Class Not Found');
    }
}

明白了__autoload 函數的工作原理之後，那就讓我們來用它去實作自動載入。

先建立一個類別檔案（建議檔案名稱與類別名稱一致），程式碼如下：

class [ClassName] 
{    // 对象实例化时输出当前类名
    function __construct()
    {        echo &#39;<h1 id="nbsp-nbsp-CLASS-nbsp-nbsp">&#39; . __CLASS__ . &#39;</h1>&#39;;
    }
}

（我這裡建立了一個HelloWorld 類別用作示範）接下來我們就要定義_ _autoload 的具體邏輯，使它能夠實現自動載入：

function __autoload($class)
{    // 根据类名确定文件名
    $file = $class . '.php';    if (file_exists($file)) {        include $file; // 引入PHP文件    }
}new HelloWorld();/**
 * 输出 <h1 id="HelloWorld">HelloWorld</h1> */

=================命名空間============ ======

其實命名空間並不是什麼新事物，很多語言（例如C++）早就支援這個特性了。只不過 PHP 起步比較晚，直到 PHP 5.3 之後才支援。

命名空間簡而言之就是一種標識，它的主要目的是解決命名衝突的問題。

就像在日常生活中，有很多名字相同的人，要如何區分這些人呢？那就需要加上一些額外的標識。

把工作單位當成標識似乎不錯，這樣就不用擔心 「撞名」 的尷尬了。

這裡我們來做一個小任務，去介紹百度的CEO李彥宏：

namespace 百度;class 李彦宏
{    function __construct()
    {        echo '百度创始人';
    }
}

↑ 這就是李彥宏的基本資料了，namespace 是他的單位標識，class 是他的姓名。

命名空間透過關鍵字 namespace 來宣告。如果一個檔案中包含命名空間，它必須在其它所有程式碼之前聲明命名空間。

new 百度\李彦宏(); // 限定类名new \百度\李彦宏(); // 完全限定类名

↑ 在一般情況下，無論是向別人介紹 "百度 李彥宏" 還是 "百度公司 李彥宏"，他們都能夠明白。

在目前命名空間沒有宣告的情況下，限定類別名稱和完全限定類別名稱是等價的。因為如果不指定空間，則預設為全域（\）。

namespace 谷歌;new 百度\李彦宏(); // 谷歌\百度\李彦宏（实际结果）new \百度\李彦宏(); // 百度\李彦宏（实际结果）

↑ 如果你在Google公司向他們的員工介紹李彥宏，一定要指明是 "百度公司的李彥宏"。否則他會認為百度是Google的一個部門，而李彥宏只是其中的一位員工而已。

這個範例展示了在命名空間下，使用限定類別名稱和完全限定類別名稱的差異。 （完全限定類別名稱 = 目前命名空間 + 限定類別名稱）

/* 导入命名空间 */use 百度\李彦宏;new 李彦宏(); // 百度\李彦宏（实际结果）/* 设置别名 */use 百度\李彦宏 AS CEO;new CEO(); // 百度\李彦宏（实际结果）/* 任何情况 */new \百度\李彦宏();// 百度\李彦宏（实际结果）

↑ 第一種情況是別人已經認識李彥宏了，你只需要直接說名字，他就能知道你指的是誰。第二種情況是李彥宏就是他們的CEO，你直接說CEO，他可以立刻反應過來。

使用命名空間只是讓類別名稱有了前綴，不容易發生衝突，系統仍然不會進行自動導入。

如果不引入文件，系統會在拋出 "Class Not Found" 錯誤之前觸發 __autoload 函數，並將限定類別名稱傳入作為參數。

所以上面的範例都是基於你已經將相關文件手動引入的情況下實現的，否則系統會拋出 " Class '百度\李彥宏' not found"。

=================spl_autoload==================

接下来让我们要在含有命名空间的情况下去实现自动加载。这里我们使用 spl_autoload_register() 函数来实现，这需要你的 PHP 版本号大于 5.12。

spl_autoload_register 函数的功能就是把传入的函数（参数可以为回调函数或函数名称形式）注册到 SPL __autoload 函数队列中，并移除系统默认的 __autoload() 函数。

一旦调用 spl_autoload_register() 函数，当调用未定义类时，系统就会按顺序调用注册到 spl_autoload_register() 函数的所有函数，而不是自动调用 __autoload() 函数。

现在，我们来创建一个 Linux 类，它使用 os 作为它的命名空间（建议文件名与类名保持一致）：

namespace os; // 命名空间class Linux // 类名{    function __construct()
    {        echo &#39;<h1 id="nbsp-nbsp-CLASS-nbsp-nbsp">&#39; . __CLASS__ . &#39;</h1>&#39;;
    }
}

接着，在同一个目录下新建一个 PHP 文件，使用 spl_autoload_register 以函数回调的方式实现自动加载：

spl_autoload_register(function ($class) { // class = os\Linux
    /* 限定类名路径映射 */
    $class_map = array(        // 限定类名 => 文件路径
        'os\\Linux' => './Linux.php',
    );    /* 根据类名确定文件名 */
    $file = $class_map[$class];    /* 引入相关文件 */
    if (file_exists($file)) {        include $file;
    }
});new \os\Linux();

这里我们使用了一个数组去保存类名与文件路径的关系，这样当类名传入时，自动加载器就知道该引入哪个文件去加载这个类了。

但是一旦文件多起来的话，映射数组会变得很长，这样的话维护起来会相当麻烦。如果命名能遵守统一的约定，就可以让自动加载器自动解析判断类文件所在的路径。接下来要介绍的PSR-4 就是一种被广泛采用的约定方式。

=================PSR-4规范==================

PSR-4 是关于由文件路径自动载入对应类的相关规范，规范规定了一个完全限定类名需要具有以下结构：

\(\)*\

如果继续拿上面的例子打比方的话，顶级命名空间相当于公司，子命名空间相当于职位，类名相当于人名。那么李彦宏标准的称呼为 "百度公司 CEO 李彦宏"。

PSR-4 规范中必须要有一个顶级命名空间，它的意义在于表示某一个特殊的目录（文件基目录）。子命名空间代表的是类文件相对于文件基目录的这一段路径（相对路径），类名则与文件名保持一致（注意大小写的区别）。

举个例子：在全限定类名 \app\view\news\Index 中，如果 app 代表 C:\Baidu，那么这个类的路径则是 C:\Baidu\view\news\Index.php

我们就以解析 \app\view\news\Index 为例，编写一个简单的 Demo：

$class = 'app\view\news\Index';/* 顶级命名空间路径映射 */$vendor_map = array(    'app' => 'C:\Baidu',);/* 解析类名为文件路径 */$vendor = substr($class, 0, strpos($class, '\\')); // 取出顶级命名空间[app]$vendor_dir = $vendor_map[$vendor]; // 文件基目录[C:\Baidu]$rel_path = dirname(substr($class, strlen($vendor))); // 相对路径[/view/news]$file_name = basename($class) . '.php'; // 文件名[Index.php]/* 输出文件所在路径 */echo $vendor_dir . $rel_path . DIRECTORY_SEPARATOR . $file_name;

通过这个 Demo 可以看出限定类名转换为路径的过程。那么现在就让我们用规范的面向对象方式去实现自动加载器吧。

首先我们创建一个文件 Index.php，它处于 \app\mvc\view\home 目录中：

namespace app\mvc\view\home;class Index
{    function __construct()
    {        echo &#39;<h1 id="nbsp-Welcome-nbsp-To-nbsp-Home-nbsp"> Welcome To Home </h1>&#39;;
    }
}

接着我们在创建一个加载类（不需要命名空间），它处于 \ 目录中：

class Loader
{    /* 路径映射 */
    public static $vendorMap = array(        'app' => __DIR__ . DIRECTORY_SEPARATOR . 'app',
    );    /**
     * 自动加载器     */
    public static function autoload($class)
    {        $file = self::findFile($class);        if (file_exists($file)) {
            self::includeFile($file);
        }
    }    /**
     * 解析文件路径     */
    private static function findFile($class)
    {        $vendor = substr($class, 0, strpos($class, '\\')); // 顶级命名空间
        $vendorDir = self::$vendorMap[$vendor]; // 文件基目录
        $filePath = substr($class, strlen($vendor)) . '.php'; // 文件相对路径
        return strtr($vendorDir . $filePath, '\\', DIRECTORY_SEPARATOR); // 文件标准路径    }    /**
     * 引入文件     */
    private static function includeFile($file)
    {        if (is_file($file)) {            include $file;
        }
    }
}

最后，将 Loader 类中的 autoload 注册到 spl_autoload_register 函数中：

include 'Loader.php'; // 引入加载器spl_autoload_register('Loader::autoload'); // 注册自动加载new \app\mvc\view\home\Index(); // 实例化未引用的类/**
 * 输出: <h1 id="nbsp-Welcome-nbsp-To-nbsp-Home-nbsp"> Welcome To Home </h1> */

示例中的代码其实就是 ThinkPHP 自动加载器源码的精简版，它是 ThinkPHP 5 能实现惰性加载的关键。

至此，自动加载的原理已经全部讲完了，如果有兴趣深入了解的话，可以参考下面的 ThinkPHP 源码。

class Loader
{    protected static $instance = [];    // 类名映射
    protected static $map = [];    // 命名空间别名
    protected static $namespaceAlias = [];    // PSR-4
    private static $prefixLengthsPsr4 = [];    private static $prefixDirsPsr4    = [];    private static $fallbackDirsPsr4  = [];    // PSR-0
    private static $prefixesPsr0     = [];    private static $fallbackDirsPsr0 = [];    // 自动加载的文件
    private static $autoloadFiles = [];    // 自动加载
    public static function autoload($class)
    {        // 检测命名空间别名
        if (!empty(self::$namespaceAlias)) {            $namespace = dirname($class);            if (isset(self::$namespaceAlias[$namespace])) {                $original = self::$namespaceAlias[$namespace] . '\\' . basename($class);                if (class_exists($original)) {                    return class_alias($original, $class, false);
                }
            }
        }        if ($file = self::findFile($class)) {            // Win环境严格区分大小写
            if (IS_WIN && pathinfo($file, PATHINFO_FILENAME) != pathinfo(realpath($file), PATHINFO_FILENAME)) {                return false;
            }

            __include_file($file);            return true;
        }
    }    /**
     * 查找文件
     * @param $class
     * @return bool     */
    private static function findFile($class)
    {        if (!empty(self::$map[$class])) {            // 类库映射
            return self::$map[$class];
        }        // 查找 PSR-4
        $logicalPathPsr4 = strtr($class, '\\', DS) . EXT;        $first = $class[0];        if (isset(self::$prefixLengthsPsr4[$first])) {            foreach (self::$prefixLengthsPsr4[$first] as $prefix => $length) {                if (0 === strpos($class, $prefix)) {                    foreach (self::$prefixDirsPsr4[$prefix] as $dir) {                        if (is_file($file = $dir . DS . substr($logicalPathPsr4, $length))) {                            return $file;
                        }
                    }
                }
            }
        }        // 查找 PSR-4 fallback dirs
        foreach (self::$fallbackDirsPsr4 as $dir) {            if (is_file($file = $dir . DS . $logicalPathPsr4)) {                return $file;
            }
        }        // 查找 PSR-0
        if (false !== $pos = strrpos($class, '\\')) {            // namespaced class name
            $logicalPathPsr0 = substr($logicalPathPsr4, 0, $pos + 1)            . strtr(substr($logicalPathPsr4, $pos + 1), '_', DS);
        } else {            // PEAR-like class name
            $logicalPathPsr0 = strtr($class, '_', DS) . EXT;
        }        if (isset(self::$prefixesPsr0[$first])) {            foreach (self::$prefixesPsr0[$first] as $prefix => $dirs) {                if (0 === strpos($class, $prefix)) {                    foreach ($dirs as $dir) {                        if (is_file($file = $dir . DS . $logicalPathPsr0)) {                            return $file;
                        }
                    }
                }
            }
        }        // 查找 PSR-0 fallback dirs
        foreach (self::$fallbackDirsPsr0 as $dir) {            if (is_file($file = $dir . DS . $logicalPathPsr0)) {                return $file;
            }
        }        return self::$map[$class] = false;
    }    // 注册classmap
    public static function addClassMap($class, $map = '')
    {        if (is_array($class)) {
            self::$map = array_merge(self::$map, $class);
        } else {
            self::$map[$class] = $map;
        }
    }    // 注册命名空间
    public static function addNamespace($namespace, $path = '')
    {        if (is_array($namespace)) {            foreach ($namespace as $prefix => $paths) {
                self::addPsr4($prefix . '\\', rtrim($paths, DS), true);
            }
        } else {
            self::addPsr4($namespace . '\\', rtrim($path, DS), true);
        }
    }    // 添加Ps0空间
    private static function addPsr0($prefix, $paths, $prepend = false)
    {        if (!$prefix) {            if ($prepend) {
                self::$fallbackDirsPsr0 = array_merge(
                    (array) $paths,
                    self::$fallbackDirsPsr0
                );
            } else {
                self::$fallbackDirsPsr0 = array_merge(
                    self::$fallbackDirsPsr0,
                    (array) $paths
                );
            }            return;
        }        $first = $prefix[0];        if (!isset(self::$prefixesPsr0[$first][$prefix])) {
            self::$prefixesPsr0[$first][$prefix] = (array) $paths;            return;
        }        if ($prepend) {
            self::$prefixesPsr0[$first][$prefix] = array_merge(
                (array) $paths,
                self::$prefixesPsr0[$first][$prefix]
            );
        } else {
            self::$prefixesPsr0[$first][$prefix] = array_merge(
                self::$prefixesPsr0[$first][$prefix],
                (array) $paths
            );
        }
    }    // 添加Psr4空间
    private static function addPsr4($prefix, $paths, $prepend = false)
    {        if (!$prefix) {            // Register directories for the root namespace.
            if ($prepend) {
                self::$fallbackDirsPsr4 = array_merge(
                    (array) $paths,
                    self::$fallbackDirsPsr4
                );
            } else {
                self::$fallbackDirsPsr4 = array_merge(
                    self::$fallbackDirsPsr4,
                    (array) $paths
                );
            }
        } elseif (!isset(self::$prefixDirsPsr4[$prefix])) {            // Register directories for a new namespace.
            $length = strlen($prefix);            if ('\\' !== $prefix[$length - 1]) {                throw new \InvalidArgumentException("A non-empty PSR-4 prefix must end with a namespace separator.");
            }
            self::$prefixLengthsPsr4[$prefix[0]][$prefix] = $length;
            self::$prefixDirsPsr4[$prefix]                = (array) $paths;
        } elseif ($prepend) {            // Prepend directories for an already registered namespace.
            self::$prefixDirsPsr4[$prefix] = array_merge(
                (array) $paths,
                self::$prefixDirsPsr4[$prefix]
            );
        } else {            // Append directories for an already registered namespace.
            self::$prefixDirsPsr4[$prefix] = array_merge(
                self::$prefixDirsPsr4[$prefix],
                (array) $paths
            );
        }
    }    // 注册命名空间别名
    public static function addNamespaceAlias($namespace, $original = '')
    {        if (is_array($namespace)) {
            self::$namespaceAlias = array_merge(self::$namespaceAlias, $namespace);
        } else {
            self::$namespaceAlias[$namespace] = $original;
        }
    }    // 注册自动加载机制
    public static function register($autoload = '')
    {        // 注册系统自动加载
        spl_autoload_register($autoload ?: 'think\\Loader::autoload', true, true);        // 注册命名空间定义
        self::addNamespace([            'think'    => LIB_PATH . 'think' . DS,
            'behavior' => LIB_PATH . 'behavior' . DS,
            'traits'   => LIB_PATH . 'traits' . DS,
        ]);        // 加载类库映射文件
        if (is_file(RUNTIME_PATH . 'classmap' . EXT)) {
            self::addClassMap(__include_file(RUNTIME_PATH . 'classmap' . EXT));
        }        // Composer自动加载支持
        if (is_dir(VENDOR_PATH . 'composer')) {
            self::registerComposerLoader();
        }        // 自动加载extend目录
        self::$fallbackDirsPsr4[] = rtrim(EXTEND_PATH, DS);
    }    // 注册composer自动加载
    private static function registerComposerLoader()
    {        if (is_file(VENDOR_PATH . 'composer/autoload_namespaces.php')) {            $map = require VENDOR_PATH . 'composer/autoload_namespaces.php';            foreach ($map as $namespace => $path) {
                self::addPsr0($namespace, $path);
            }
        }        if (is_file(VENDOR_PATH . 'composer/autoload_psr4.php')) {            $map = require VENDOR_PATH . 'composer/autoload_psr4.php';            foreach ($map as $namespace => $path) {
                self::addPsr4($namespace, $path);
            }
        }        if (is_file(VENDOR_PATH . 'composer/autoload_classmap.php')) {            $classMap = require VENDOR_PATH . 'composer/autoload_classmap.php';            if ($classMap) {
                self::addClassMap($classMap);
            }
        }        if (is_file(VENDOR_PATH . 'composer/autoload_files.php')) {            $includeFiles = require VENDOR_PATH . 'composer/autoload_files.php';            foreach ($includeFiles as $fileIdentifier => $file) {                if (empty(self::$autoloadFiles[$fileIdentifier])) {
                    __require_file($file);
                    self::$autoloadFiles[$fileIdentifier] = true;
                }
            }
        }
    }    /**
     * 导入所需的类库 同java的Import 本函数有缓存功能
     * @param string $class   类库命名空间字符串
     * @param string $baseUrl 起始路径
     * @param string $ext     导入的文件扩展名
     * @return boolean     */
    public static function import($class, $baseUrl = '', $ext = EXT)
    {        static $_file = [];        $key          = $class . $baseUrl;        $class        = str_replace(['.', '#'], [DS, '.'], $class);        if (isset($_file[$key])) {            return true;
        }        if (empty($baseUrl)) {            list($name, $class) = explode(DS, $class, 2);            if (isset(self::$prefixDirsPsr4[$name . '\\'])) {                // 注册的命名空间
                $baseUrl = self::$prefixDirsPsr4[$name . '\\'];
            } elseif ('@' == $name) {                //加载当前模块应用类库
                $baseUrl = App::$modulePath;
            } elseif (is_dir(EXTEND_PATH . $name)) {                $baseUrl = EXTEND_PATH;
            } else {                // 加载其它模块的类库
                $baseUrl = APP_PATH . $name . DS;
            }
        } elseif (substr($baseUrl, -1) != DS) {            $baseUrl .= DS;
        }        // 如果类存在 则导入类库文件
        if (is_array($baseUrl)) {            foreach ($baseUrl as $path) {                $filename = $path . DS . $class . $ext;                if (is_file($filename)) {                    break;
                }
            }
        } else {            $filename = $baseUrl . $class . $ext;
        }        if (!empty($filename) && is_file($filename)) {            // 开启调试模式Win环境严格区分大小写
            if (IS_WIN && pathinfo($filename, PATHINFO_FILENAME) != pathinfo(realpath($filename), PATHINFO_FILENAME)) {                return false;
            }
            __include_file($filename);            $_file[$key] = true;            return true;
        }        return false;
    }    /**
     * 实例化（分层）模型
     * @param string $name         Model名称
     * @param string $layer        业务层名称
     * @param bool   $appendSuffix 是否添加类名后缀
     * @param string $common       公共模块名
     * @return Object
     * @throws ClassNotFoundException     */
    public static function model($name = '', $layer = 'model', $appendSuffix = false, $common = 'common')
    {        if (isset(self::$instance[$name . $layer])) {            return self::$instance[$name . $layer];
        }        if (strpos($name, '/')) {            list($module, $name) = explode('/', $name, 2);
        } else {            $module = Request::instance()->module();
        }        $class = self::parseClass($module, $layer, $name, $appendSuffix);        if (class_exists($class)) {            $model = new $class();
        } else {            $class = str_replace('\\' . $module . '\\', '\\' . $common . '\\', $class);            if (class_exists($class)) {                $model = new $class();
            } else {                throw new ClassNotFoundException('class not exists:' . $class, $class);
            }
        }
        self::$instance[$name . $layer] = $model;        return $model;
    }    /**
     * 实例化（分层）控制器 格式：[模块名/]控制器名
     * @param string $name         资源地址
     * @param string $layer        控制层名称
     * @param bool   $appendSuffix 是否添加类名后缀
     * @param string $empty        空控制器名称
     * @return Object|false
     * @throws ClassNotFoundException     */
    public static function controller($name, $layer = 'controller', $appendSuffix = false, $empty = '')
    {        if (strpos($name, '/')) {            list($module, $name) = explode('/', $name);
        } else {            $module = Request::instance()->module();
        }        $class = self::parseClass($module, $layer, $name, $appendSuffix);        if (class_exists($class)) {            return new $class(Request::instance());
        } elseif ($empty && class_exists($emptyClass = self::parseClass($module, $layer, $empty, $appendSuffix))) {            return new $emptyClass(Request::instance());
        }
    }    /**
     * 实例化验证类 格式：[模块名/]验证器名
     * @param string $name         资源地址
     * @param string $layer        验证层名称
     * @param bool   $appendSuffix 是否添加类名后缀
     * @param string $common       公共模块名
     * @return Object|false
     * @throws ClassNotFoundException     */
    public static function validate($name = '', $layer = 'validate', $appendSuffix = false, $common = 'common')
    {        $name = $name ?: Config::get('default_validate');        if (empty($name)) {            return new Validate;
        }        if (isset(self::$instance[$name . $layer])) {            return self::$instance[$name . $layer];
        }        if (strpos($name, '/')) {            list($module, $name) = explode('/', $name);
        } else {            $module = Request::instance()->module();
        }        $class = self::parseClass($module, $layer, $name, $appendSuffix);        if (class_exists($class)) {            $validate = new $class;
        } else {            $class = str_replace('\\' . $module . '\\', '\\' . $common . '\\', $class);            if (class_exists($class)) {                $validate = new $class;
            } else {                throw new ClassNotFoundException('class not exists:' . $class, $class);
            }
        }
        self::$instance[$name . $layer] = $validate;        return $validate;
    }    /**
     * 数据库初始化 并取得数据库类实例
     * @param mixed         $config 数据库配置
     * @param bool|string   $name 连接标识 true 强制重新连接
     * @return \think\db\Connection     */
    public static function db($config = [], $name = false)
    {        return Db::connect($config, $name);
    }    /**
     * 远程调用模块的操作方法 参数格式 [模块/控制器/]操作
     * @param string       $url          调用地址
     * @param string|array $vars         调用参数 支持字符串和数组
     * @param string       $layer        要调用的控制层名称
     * @param bool         $appendSuffix 是否添加类名后缀
     * @return mixed     */
    public static function action($url, $vars = [], $layer = 'controller', $appendSuffix = false)
    {        $info   = pathinfo($url);        $action = $info['basename'];        $module = '.' != $info['dirname'] ? $info['dirname'] : Request::instance()->controller();        $class  = self::controller($module, $layer, $appendSuffix);        if ($class) {            if (is_scalar($vars)) {                if (strpos($vars, '=')) {                    parse_str($vars, $vars);
                } else {                    $vars = [$vars];
                }
            }            return App::invokeMethod([$class, $action . Config::get('action_suffix')], $vars);
        }
    }    /**
     * 字符串命名风格转换
     * type 0 将Java风格转换为C的风格 1 将C风格转换为Java的风格
     * @param string  $name 字符串
     * @param integer $type 转换类型
     * @return string     */
    public static function parseName($name, $type = 0)
    {        if ($type) {            return ucfirst(preg_replace_callback('/_([a-zA-Z])/', function ($match) {                return strtoupper($match[1]);
            }, $name));
        } else {            return strtolower(trim(preg_replace("/[A-Z]/", "_\\0", $name), "_"));
        }
    }    /**
     * 解析应用类的类名
     * @param string $module 模块名
     * @param string $layer  层名 controller model ...
     * @param string $name   类名
     * @param bool   $appendSuffix
     * @return string     */
    public static function parseClass($module, $layer, $name, $appendSuffix = false)
    {        $name  = str_replace(['/', '.'], '\\', $name);        $array = explode('\\', $name);        $class = self::parseName(array_pop($array), 1) . (App::$suffix || $appendSuffix ? ucfirst($layer) : '');        $path  = $array ? implode('\\', $array) . '\\' : '';        return App::$namespace . '\\' . ($module ? $module . '\\' : '') . $layer . '\\' . $path . $class;
    }    /**
     * 初始化类的实例
     * @return void     */
    public static function clearInstance()
    {
        self::$instance = [];
    }
}/**
 * 作用范围隔离
 *
 * @param $file
 * @return mixed */function __include_file($file)
{    return include $file;
}function __require_file($file)
{    return require $file;
}

相关推荐：

PHP命名空间namespace定义详解

完全掌握php命名空间

PHP命名空间详细使用方法

以上是PHP命名空間與自動載入實例詳解的詳細內容。更多資訊請關注PHP中文網其他相關文章！