PHP 네임스페이스 및 자동 로딩 인스턴스에 대한 자세한 설명
- 小云云원래의
- 2018-03-22 14:09:011749검색
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 '<h1>' . __CLASS__ . '</h1>';
}
}(여기서 시연을 위해 HelloWorld 클래스를 생성했습니다.) 다음으로 특정 클래스를 정의해야 합니다. 자동 로딩을 구현할 수 있는 __autoload 논리:
function __autoload($class)
{ // 根据类名确定文件名
$file = $class . '.php'; if (file_exists($file)) { include $file; // 引入PHP文件 }
}new HelloWorld();/**
* 输出 <h1>HelloWorld</h1> */=================== 네임스페이스================= =
사실 네임스페이스는 새로운 것이 아니며 많은 언어(예: C++)에서 이미 이 기능을 지원했습니다. 다만 PHP는 상대적으로 늦게 시작되었고 PHP 5.3까지는 지원되지 않았습니다.
간단히 말하면 네임스페이스는 식별자이며 주요 목적은 이름 충돌 문제를 해결하는 것입니다.
일상생활처럼 이름이 같은 사람이 많은데, 이 사람들을 어떻게 구별할 수 있을까요? 그런 다음 추가 로고를 추가해야 합니다.
직장을 로고로 활용해도 좋을 것 같으니 '이름 충돌'에 대한 당황스러움은 안하셔도 됩니다.
여기서 Baidu CEO Robin Li를 소개하는 작은 작업을 하겠습니다.
namespace 百度;class 李彦宏
{ function __construct()
{ echo '百度创始人';
}
}↑ 이것은 Robin Li의 기본 정보입니다. 네임스페이스는 그의 유닛 식별이고 클래스는 그의 이름입니다.
네임스페이스는 키워드 네임스페이스를 사용하여 선언됩니다. 파일에 네임스페이스가 포함되어 있으면 다른 모든 코드보다 먼저 네임스페이스를 선언해야 합니다.
new 百度\李彦宏(); // 限定类名new \百度\李彦宏(); // 完全限定类名
↑ 일반적인 상황에서는 "Baidu Robin Li"를 소개하든 "Baidu Inc. Robin Li"를 소개하든 다른 사람들은 이해할 수 있습니다.
현재 네임스페이스가 선언되지 않은 경우 정규화된 클래스 이름과 정규화된 클래스 이름은 동일합니다. 공백을 지정하지 않으면 기본값은 global()입니다.
namespace 谷歌;new 百度\李彦宏(); // 谷歌\百度\李彦宏（实际结果）new \百度\李彦宏(); // 百度\李彦宏（实际结果）
↑ Google 직원에게 Robin Li를 소개하는 경우 "Baidu의 Robin Robin"이라고 명시하세요. 그렇지 않으면 그는 Baidu는 Google의 부서이고 Robin Li는 Google의 직원 중 한 명일 뿐이라고 생각할 것입니다.
이 예에서는 네임스페이스에서 정규화된 클래스 이름과 정규화된 클래스 이름을 사용하는 것의 차이점을 보여줍니다. (완전한 클래스 이름 = 현재 네임스페이스 + 정규화된 클래스 이름)
/* 导入命名空间 */use 百度\李彦宏;new 李彦宏(); // 百度\李彦宏（实际结果）/* 设置别名 */use 百度\李彦宏 AS CEO;new CEO(); // 百度\李彦宏（实际结果）/* 任何情况 */new \百度\李彦宏();// 百度\李彦宏（实际结果）
↑ 첫 번째 상황은 다른 사람들이 이미 Robin Li를 알고 있으므로 이름만 직접 말하면 그는 당신이 누구를 지칭하는지 알 것입니다. 두 번째 상황은 Robin Li가 CEO라는 것입니다. CEO에게 직접 말하면 그는 즉시 반응할 수 있습니다.
네임스페이스를 사용하면 클래스 이름 앞에만 접두사가 추가되므로 충돌이 발생할 가능성이 적고 시스템은 여전히 클래스 이름을 자동으로 가져오지 않습니다.
파일이 도입되지 않으면 시스템은 __autoload 함수를 트리거하고 "클래스를 찾을 수 없음" 오류가 발생하기 전에 정규화된 클래스 이름을 매개 변수로 전달합니다.
따라서 위의 예는 모두 관련 파일을 수동으로 도입했다는 사실을 기반으로 합니다. 그렇지 않으면 시스템에서 "클래스 'Baidu Robin Li'를 찾을 수 없습니다"라는 메시지가 표시됩니다.
==================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 '<h1>' . __CLASS__ . '</h1>';
}
}接着，在同一个目录下新建一个 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 是关于由文件路径自动载入对应类的相关规范，规范规定了一个完全限定类名需要具有以下结构：
\8ee79bcbd86d4f3ff58e77260dbf6803(\62dd555a0fb7e11d8719306e139a32e9)*\9f92f7e78eacb2684f956ddec8c620be
如果继续拿上面的例子打比方的话，顶级命名空间相当于公司，子命名空间相当于职位，类名相当于人名。那么李彦宏标准的称呼为 "百度公司 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 '<h1> Welcome To Home </h1>';
}
}接着我们在创建一个加载类（不需要命名空间），它处于 \ 目录中：
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> 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 네임스페이스 및 자동 로딩 인스턴스에 대한 자세한 설명의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!
성명：
본 글의 내용은 네티즌들의 자발적인 기여로 작성되었으며, 저작권은 원저작자에게 있습니다. 본 사이트는 이에 상응하는 법적 책임을 지지 않습니다. 표절이나 침해가 의심되는 콘텐츠를 발견한 경우 admin@php.cn으로 문의하세요.
이전 기사：WordPress로 개인 블로그 구축다음 기사：WordPress로 개인 블로그 구축