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;//简单的输出未定义的类名
}
newHelloWorld();
/**
*输出HelloWorld与报错信息
*Fatalerror:Class'HelloWorld'notfound
*/
通过这个简单的例子可以发现，在类的实例化过程中，系统所做的工作大致是这样的：
/*模拟系统实例化过程*/
functioninstance($class)
{
//如果类存在则返回其实例
if(class_exists($class,false)){
returnnew$class();
}
//查看autoload函数是否被用户定义
if(function_exists('__autoload')){
__autoload($class);//最后一次引入的机会
}
//再次检查类是否存在
if(class_exists($class,false)){
returnnew$class();
}else{//系统：我实在没辙了
thrownewException('ClassNotFound');
}
}
明白了__autoload函数的工作原理之后，那就让我们来用它去实现自动加载。
首先创建一个类文件（建议文件名与类名一致），代码如下：
class[ClassName]
{
//对象实例化时输出当前类名
function__construct()
{
echo''.__CLASS__.'
';
}
}
（我这里创建了一个HelloWorld类用作演示）接下来我们就要定义__autoload的具体逻辑，使它能够实现自动加载：
function__autoload($class)
{
//根据类名确定文件名
$file=$class.'.php';
if(file_exists($file)){
include$file;//引入PHP文件
}
}
newHelloWorld();
/**
*输出HelloWorld
*/
=================命名空间==================
其实命名空间并不是什么新生事物，很多语言（例如C++）早都支持这个特性了。只不过PHP起步比较晚，直到PHP5.3之后才支持。
命名空间简而言之就是一种标识，它的主要目的是解决命名冲突的问题。
就像在日常生活中，有很多姓名相同的人，如何区分这些人呢？那就需要加上一些额外的标识。
把工作单位当成标识似乎不错，这样就不用担心“撞名”的尴尬了。
这里我们来做一个小任务，去介绍百度的CEO李彦宏：
namespace百度;
class李彦宏
{
function__construct()
{
echo'百度创始人';
}
}
↑这就是李彦宏的基本资料了，namespace是他的单位标识，class是他的姓名。
命名空间通过关键字namespace来声明。如果一个文件中包含命名空间，它必须在其它所有代码之前声明命名空间。
new百度\李彦宏();//限定类名 new\百度\李彦宏();//完全限定类名
↑在一般情况下，无论是向别人介绍"百度李彦宏"还是"百度公司李彦宏"，他们都能够明白。
在当前命名空间没有声明的情况下，限定类名和完全限定类名是等价的。因为如果不指定空间，则默认为全局（\）。
namespace谷歌; new百度\李彦宏();//谷歌\百度\李彦宏（实际结果） new\百度\李彦宏();//百度\李彦宏（实际结果）
↑如果你在谷歌公司向他们的员工介绍李彦宏，一定要指明是"百度公司的李彦宏"。否则他会认为百度是谷歌的一个部门，而李彦宏只是其中的一位员工而已。
这个例子展示了在命名空间下，使用限定类名和完全限定类名的区别。（完全限定类名=当前命名空间+限定类名）
/*导入命名空间*/ use百度\李彦宏; new李彦宏();//百度\李彦宏（实际结果） /*设置别名*/ use百度\李彦宏ASCEO; newCEO();//百度\李彦宏（实际结果） /*任何情况*/ new\百度\李彦宏();//百度\李彦宏（实际结果）
↑第一种情况是别人已经认识李彦宏了，你只需要直接说名字，他就能知道你指的是谁。第二种情况是李彦宏就是他们的CEO，你直接说CEO，他可以立刻反应过来。
使用命名空间只是让类名有了前缀，不容易发生冲突，系统仍然不会进行自动导入。
如果不引入文件，系统会在抛出"ClassNotFound"错误之前触发__autoload函数，并将限定类名传入作为参数。
所以上面的例子都是基于你已经将相关文件手动引入的情况下实现的，否则系统会抛出"Class'百度\李彦宏'notfound"。
=================spl_autoload==================
接下来让我们要在含有命名空间的情况下去实现自动加载。这里我们使用spl_autoload_register()函数来实现，这需要你的PHP版本号大于5.12。
spl_autoload_register函数的功能就是把传入的函数（参数可以为回调函数或函数名称形式）注册到SPL__autoload函数队列中，并移除系统默认的__autoload()函数。
一旦调用spl_autoload_register()函数，当调用未定义类时，系统就会按顺序调用注册到spl_autoload_register()函数的所有函数，而不是自动调用__autoload()函数。
现在，我们来创建一个Linux类，它使用os作为它的命名空间（建议文件名与类名保持一致）：
namespaceos;//命名空间
classLinux//类名
{
function__construct()
{
echo''.__CLASS__.'
';
}
}
接着，在同一个目录下新建一个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目录中：
namespaceapp\mvc\view\home;
classIndex
{
function__construct()
{
echo'WelcomeToHome
';
}
}
接着我们在创建一个加载类（不需要命名空间），它处于\目录中：
classLoader
{
/*路径映射*/
publicstatic$vendorMap=array(
'app'=>__DIR__.DIRECTORY_SEPARATOR.'app',
);
/**
*自动加载器
*/
publicstaticfunctionautoload($class)
{
$file=self::findFile($class);
if(file_exists($file)){
self::includeFile($file);
}
}
/**
*解析文件路径
*/
privatestaticfunctionfindFile($class)
{
$vendor=substr($class,0,strpos($class,'\\'));//顶级命名空间
$vendorDir=self::$vendorMap[$vendor];//文件基目录
$filePath=substr($class,strlen($vendor)).'.php';//文件相对路径
returnstrtr($vendorDir.$filePath,'\\',DIRECTORY_SEPARATOR);//文件标准路径
}
/**
*引入文件
*/
privatestaticfunctionincludeFile($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();//实例化未引用的类
/**
*输出:WelcomeToHome
*/
示例中的代码其实就是ThinkPHP自动加载器源码的精简版，它是ThinkPHP5能实现惰性加载的关键。
至此，自动加载的原理已经全部讲完了，如果有兴趣深入了解的话，可以参考下面的ThinkPHP源码。
classLoader
{
protectedstatic$instance=[];
//类名映射
protectedstatic$map=[];
//命名空间别名
protectedstatic$namespaceAlias=[];
//PSR-4
privatestatic$prefixLengthsPsr4=[];
privatestatic$prefixDirsPsr4=[];
privatestatic$fallbackDirsPsr4=[];
//PSR-0
privatestatic$prefixesPsr0=[];
privatestatic$fallbackDirsPsr0=[];
//自动加载的文件
privatestatic$autoloadFiles=[];
//自动加载
publicstaticfunctionautoload($class)
{
//检测命名空间别名
if(!empty(self::$namespaceAlias)){
$namespace=dirname($class);
if(isset(self::$namespaceAlias[$namespace])){
$original=self::$namespaceAlias[$namespace].'\\'.basename($class);
if(class_exists($original)){
returnclass_alias($original,$class,false);
}
}
}
if($file=self::findFile($class)){
//Win环境严格区分大小写
if(IS_WIN&&pathinfo($file,PATHINFO_FILENAME)!=pathinfo(realpath($file),PATHINFO_FILENAME)){
returnfalse;
}
__include_file($file);
returntrue;
}
}
/**
*查找文件
*@param$class
*@returnbool
*/
privatestaticfunctionfindFile($class)
{
if(!empty(self::$map[$class])){
//类库映射
returnself::$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-4fallbackdirs
foreach(self::$fallbackDirsPsr4as$dir){
if(is_file($file=$dir.DS.$logicalPathPsr4)){
return$file;
}
}
//查找PSR-0
if(false!==$pos=strrpos($class,'\\')){
//namespacedclassname
$logicalPathPsr0=substr($logicalPathPsr4,0,$pos+1)
.strtr(substr($logicalPathPsr4,$pos+1),'_',DS);
}else{
//PEAR-likeclassname
$logicalPathPsr0=strtr($class,'_',DS).EXT;
}
if(isset(self::$prefixesPsr0[$first])){
foreach(self::$prefixesPsr0[$first]as$prefix=>$dirs){
if(0===strpos($class,$prefix)){
foreach($dirsas$dir){
if(is_file($file=$dir.DS.$logicalPathPsr0)){
return$file;
}
}
}
}
}
//查找PSR-0fallbackdirs
foreach(self::$fallbackDirsPsr0as$dir){
if(is_file($file=$dir.DS.$logicalPathPsr0)){
return$file;
}
}
returnself::$map[$class]=false;
}
//注册classmap
publicstaticfunctionaddClassMap($class,$map='')
{
if(is_array($class)){
self::$map=array_merge(self::$map,$class);
}else{
self::$map[$class]=$map;
}
}
//注册命名空间
publicstaticfunctionaddNamespace($namespace,$path='')
{
if(is_array($namespace)){
foreach($namespaceas$prefix=>$paths){
self::addPsr4($prefix.'\\',rtrim($paths,DS),true);
}
}else{
self::addPsr4($namespace.'\\',rtrim($path,DS),true);
}
}
//添加Ps0空间
privatestaticfunctionaddPsr0($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空间
privatestaticfunctionaddPsr4($prefix,$paths,$prepend=false)
{
if(!$prefix){
//Registerdirectoriesfortherootnamespace.
if($prepend){
self::$fallbackDirsPsr4=array_merge(
(array)$paths,
self::$fallbackDirsPsr4
);
}else{
self::$fallbackDirsPsr4=array_merge(
self::$fallbackDirsPsr4,
(array)$paths
);
}
}elseif(!isset(self::$prefixDirsPsr4[$prefix])){
//Registerdirectoriesforanewnamespace.
$length=strlen($prefix);
if('\\'!==$prefix[$length-1]){
thrownew\InvalidArgumentException("Anon-emptyPSR-4prefixmustendwithanamespaceseparator.");
}
self::$prefixLengthsPsr4[$prefix[0]][$prefix]=$length;
self::$prefixDirsPsr4[$prefix]=(array)$paths;
}elseif($prepend){
//Prependdirectoriesforanalreadyregisterednamespace.
self::$prefixDirsPsr4[$prefix]=array_merge(
(array)$paths,
self::$prefixDirsPsr4[$prefix]
);
}else{
//Appenddirectoriesforanalreadyregisterednamespace.
self::$prefixDirsPsr4[$prefix]=array_merge(
self::$prefixDirsPsr4[$prefix],
(array)$paths
);
}
}
//注册命名空间别名
publicstaticfunctionaddNamespaceAlias($namespace,$original='')
{
if(is_array($namespace)){
self::$namespaceAlias=array_merge(self::$namespaceAlias,$namespace);
}else{
self::$namespaceAlias[$namespace]=$original;
}
}
//注册自动加载机制
publicstaticfunctionregister($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自动加载
privatestaticfunctionregisterComposerLoader()
{
if(is_file(VENDOR_PATH.'composer/autoload_namespaces.php')){
$map=requireVENDOR_PATH.'composer/autoload_namespaces.php';
foreach($mapas$namespace=>$path){
self::addPsr0($namespace,$path);
}
}
if(is_file(VENDOR_PATH.'composer/autoload_psr4.php')){
$map=requireVENDOR_PATH.'composer/autoload_psr4.php';
foreach($mapas$namespace=>$path){
self::addPsr4($namespace,$path);
}
}
if(is_file(VENDOR_PATH.'composer/autoload_classmap.php')){
$classMap=requireVENDOR_PATH.'composer/autoload_classmap.php';
if($classMap){
self::addClassMap($classMap);
}
}
if(is_file(VENDOR_PATH.'composer/autoload_files.php')){
$includeFiles=requireVENDOR_PATH.'composer/autoload_files.php';
foreach($includeFilesas$fileIdentifier=>$file){
if(empty(self::$autoloadFiles[$fileIdentifier])){
__require_file($file);
self::$autoloadFiles[$fileIdentifier]=true;
}
}
}
}
/**
*导入所需的类库同java的Import本函数有缓存功能
*@paramstring$class类库命名空间字符串
*@paramstring$baseUrl起始路径
*@paramstring$ext导入的文件扩展名
*@returnboolean
*/
publicstaticfunctionimport($class,$baseUrl='',$ext=EXT)
{
static$_file=[];
$key=$class.$baseUrl;
$class=str_replace(['.','#'],[DS,'.'],$class);
if(isset($_file[$key])){
returntrue;
}
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($baseUrlas$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)){
returnfalse;
}
__include_file($filename);
$_file[$key]=true;
returntrue;
}
returnfalse;
}
/**
*实例化（分层）模型
*@paramstring$nameModel名称
*@paramstring$layer业务层名称
*@parambool$appendSuffix是否添加类名后缀
*@paramstring$common公共模块名
*@returnObject
*@throwsClassNotFoundException
*/
publicstaticfunctionmodel($name='',$layer='model',$appendSuffix=false,$common='common')
{
if(isset(self::$instance[$name.$layer])){
returnself::$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{
thrownewClassNotFoundException('classnotexists:'.$class,$class);
}
}
self::$instance[$name.$layer]=$model;
return$model;
}
/**
*实例化（分层）控制器格式：[模块名/]控制器名
*@paramstring$name资源地址
*@paramstring$layer控制层名称
*@parambool$appendSuffix是否添加类名后缀
*@paramstring$empty空控制器名称
*@returnObject|false
*@throwsClassNotFoundException
*/
publicstaticfunctioncontroller($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)){
returnnew$class(Request::instance());
}elseif($empty&&class_exists($emptyClass=self::parseClass($module,$layer,$empty,$appendSuffix))){
returnnew$emptyClass(Request::instance());
}
}
/**
*实例化验证类格式：[模块名/]验证器名
*@paramstring$name资源地址
*@paramstring$layer验证层名称
*@parambool$appendSuffix是否添加类名后缀
*@paramstring$common公共模块名
*@returnObject|false
*@throwsClassNotFoundException
*/
publicstaticfunctionvalidate($name='',$layer='validate',$appendSuffix=false,$common='common')
{
$name=$name?:Config::get('default_validate');
if(empty($name)){
returnnewValidate;
}
if(isset(self::$instance[$name.$layer])){
returnself::$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{
thrownewClassNotFoundException('classnotexists:'.$class,$class);
}
}
self::$instance[$name.$layer]=$validate;
return$validate;
}
/**
*数据库初始化并取得数据库类实例
*@parammixed$config数据库配置
*@parambool|string$name连接标识true强制重新连接
*@return\think\db\Connection
*/
publicstaticfunctiondb($config=[],$name=false)
{
returnDb::connect($config,$name);
}
/**
*远程调用模块的操作方法参数格式[模块/控制器/]操作
*@paramstring$url调用地址
*@paramstring|array$vars调用参数支持字符串和数组
*@paramstring$layer要调用的控制层名称
*@parambool$appendSuffix是否添加类名后缀
*@returnmixed
*/
publicstaticfunctionaction($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];
}
}
returnApp::invokeMethod([$class,$action.Config::get('action_suffix')],$vars);
}
}
/**
*字符串命名风格转换
*type0将Java风格转换为C的风格1将C风格转换为Java的风格
*@paramstring$name字符串
*@paraminteger$type转换类型
*@returnstring
*/
publicstaticfunctionparseName($name,$type=0)
{
if($type){
returnucfirst(preg_replace_callback('/_([a-zA-Z])/',function($match){
returnstrtoupper($match[1]);
},$name));
}else{
returnstrtolower(trim(preg_replace("/[A-Z]/","_\\0",$name),"_"));
}
}
/**
*解析应用类的类名
*@paramstring$module模块名
*@paramstring$layer层名controllermodel...
*@paramstring$name类名
*@parambool$appendSuffix
*@returnstring
*/
publicstaticfunctionparseClass($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).'\\':'';
returnApp::$namespace.'\\'.($module?$module.'\\':'').$layer.'\\'.$path.$class;
}
/**
*初始化类的实例
*@returnvoid
*/
publicstaticfunctionclearInstance()
{
self::$instance=[];
}
}
/**
*作用范围隔离
*
*@param$file
*@returnmixed
*/
function__include_file($file)
{
returninclude$file;
}
function__require_file($file)
{
returnrequire$file;
}
总结
以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，谢谢大家对毛票票的支持。