PHP 命名空间 namespace 函数调用 类引用 详解
PHP namespace 命名空间 函数调用 类引用 详细测试分析
本文测试中,假设index.php页面和test.php页面在同一个根目录下,方便加载test.php页面。
前提条件都是在namespace A;下进行测试。
namespaceA;useB\D,C\EasF;
// 函数调用
foo(); // 首先尝试调用定义在命名空间"A"中的函数foo()
\foo(); // 调用全局空间函数 "foo"
my\foo(); // 调用定义在命名空间"A\my"中函数 "foo"
F(); // 首先尝试调用定义在命名空间"A"中的函数 "F"
B\foo(); // 调用命名空间 "A\B" 中函数 "foo"
B::foo(); // 调用命名空间 "A" 中定义的类 "B" 的 "foo" 方法
D::foo(); // 使用导入规则，调用命名空间 "B" 中定义的类 "D" 的 "foo" 方法
\B\foo(); // 调用命名空间 "B" 中的函数 "foo"
\B::foo(); // 调用全局空间中的类 "B" 的 "foo" 方法
A\B::foo(); // 调用命名空间 "A\A" 中定义的类 "B" 的 "foo" 方法
\A\B::foo(); // 调用命名空间 "A\B" 中定义的类 "B" 的 "foo" 方法
//类引用
new B(); // 创建命名空间 "A" 中定义的类 "B" 的一个对象
new D(); // 使用导入规则，创建命名空间 "B" 中定义的类 "D" 的一个对象
new F(); // 使用导入规则，创建命名空间 "C" 中定义的类 "E" 的一个对象
new \B(); // 创建定义在全局空间中的类 "B" 的一个对象
new \D(); // 创建定义在全局空间中的类 "D" 的一个对象
new \F(); // 创建定义在全局空间中的类 "F" 的一个对象
函数调用
1当前命名空间A下函数调用 语法 foo();
index.php页面
<?phpnamespaceA;header("content-type:text/html;charset=utf-8");require'test.php';//加载定义命名空间"A\my"的页面functionfoo(){echo'我是命名空间"A"中的函数foo()';}//函数调用foo();//首先尝试调用定义在命名空间"A"中的函数foo()//再尝试调用全局函数"foo"
结果为
我是命名空间"A"中的函数foo()
2当前命名空间A下调用命名空间"A\my"中的函数foo() 语法 my\foo();
index.php页面
<?phpnamespaceA;header("content-type:text/html;charset=utf-8");require'test.php';//加载定义命名空间"A\my"的页面//调用函数my\foo();//调用定义在命名空间"A\my"中函数"foo"?>
test.php页面(定义命名空间"A\my"的页面)
<?phpnamespaceA\my;functionfoo(){echo'我是命名空间"A\my"中的函数foo()';}?>
结果为
我是命名空间"A\my"中的函数foo()
3.当前命名空间A下调用命名空间 "A\B"的函数"foo"
语法
require 'test.php';//加载命名空间 "A\B"的函数"foo"文件
B\foo();
index.php页面
<?phpnamespaceA;header("content-type:text/html;charset=utf-8");useB\D,C\EasF;require'test.php';//加载命名空间"A\B"的函数"foo"文件B\foo();//调用命名空间"A\B"中函数"foo"?>
test.php页面(定义命名空间 "A\B"的函数"foo"的页面)
<?phpnamespaceA\B;functionfoo(){echo'命名空间"A\B"中函数"foo"';}?>
结果为
命名空间"A\B"中函数"foo"
4.当前命名空间A下调用本命名空间 "A" 中定义的类 "B" 的 "foo" 静态方法
语法
B::foo();
index.php页面
<?phpnamespaceA;header("content-type:text/html;charset=utf-8");useB\D,C\EasF;classB{staticpublicfunctionfoo(){echo'命名空间"A"中定义的类"B"的"foo"方法';}}B::foo();//调用命名空间"A"中定义的类"B"的"foo"方法//如果未找到类"A\B"，则尝试自动装载类"A\B"?>
结果为
命名空间"A"中定义的类"B"的"foo"方法
5.当前命名空间A下调用本命名空间 "B" 中定义的类 "D" 的 "foo" 静态方法
语法
require 'test.php'; //加载文件
use B\D; //引导类
D::foo(); //进行调用
index.php页面
<?phpnamespaceA;header("content-type:text/html;charset=utf-8");require'test.php';useB\D,C\EasF;D::foo();//使用导入规则，调用命名空间"B"中定义的类"D"的"foo"方法//如果类"B\D"未找到，则尝试自动装载类"B\D"?>
test.php页面(定义命名空间 "B"的类"D"的函数"foo"的页面)
<?phpnamespaceB;classD{staticpublicfunctionfoo(){echo'命名空间"B"中定义的类"D"的"foo"方法';}}?>
结果为
命名空间"B"中定义的类"D"的"foo"方法
6.当前命名空间A下调用命名空间 "B"的函数"foo"
语法
require 'test.php';//加载命名空间 "B"的函数"foo"文件
\B\foo();
index.php页面
<?phpnamespaceA;header("content-type:text/html;charset=utf-8");useB\D,C\EasF;require'test.php';//加载命名空间"B"的函数"foo"文件\B\foo();//调用命名空间"B"中函数"foo"?>
test.php页面(定义命名空间 "B"的函数"foo"的页面)
<?phpnamespaceB;functionfoo(){echo'命名空间"B"中函数"foo"';}?>
结果为
命名空间"B"中函数"foo"
7.当前命名空间A下调用全局空间 "B"的函数"foo"静态方法
语法
require 'test.php';//加载全局空间 "B"的函数"foo"文件
\B::foo();
index.php页面
<?phpnamespaceA;header("content-type:text/html;charset=utf-8");useB\D,C\EasF;require'test.php';//加载全局空间"B"的函数"foo"文件\B::foo();//调用全局空间中的类"B"的"foo"方法//如果类"B"未找到，则尝试自动装载类"B"?>
test.php页面(定义全局空间 "B"的函数"foo"的页面)
<?phpclassB{staticpublicfunctionfoo(){echo'全局空间的B类中foo方法';}}?>
结果为
全局空间的B类中foo方法
8.当前命名空间A下调用命名空间 "A\A"的B类"foo"静态方法
语法
require 'test.php';//加载命名空间 "A\A"的B类"foo"静态方法文件
A\B::foo();
index.php页面
<?phpnamespaceA;header("content-type:text/html;charset=utf-8");useB\D,C\EasF;require'test.php';//加载命名空间"A\A"的B类"foo"静态方法文件A\B::foo();//调用命名空间"A\A"中定义的类"B"的"foo"方法//如果类"A\A\B"未找到，则尝试自动装载类"A\A\B"?>
test.php页面(定义命名空间 "A\A"的B类"foo"静态方法的页面)
<?phpnamespaceA\A;classB{staticpublicfunctionfoo(){echo'命名空间A\A中B类foo方法';}}?>
结果为
命名空间A\A中B类foo方法
9.当前命名空间A下调用命名空间 "A\B"的B类"foo"静态方法
语法
require 'test.php';//加载命名空间 "A\B"的B类"foo"静态方法文件
\A\B::foo();
index.php页面
<?phpnamespaceA;header("content-type:text/html;charset=utf-8");require'test.php';//加载命名空间"A\B"的B类"foo"静态方法文件\A\B::foo();//调用命名空间"A\B"中定义的类"B"的"foo"方法//如果类"A\B"未找到，则尝试自动装载类"A\B"?>
test.php页面(定义命名空间 "A\B"的B类"foo"静态方法的页面)
<?phpnamespaceA\B;classB{staticpublicfunctionfoo(){echo'命名空间A\B中B类的foo静态方法';}}?>
结果为
命名空间A\B中B类的foo静态方法
类引用
1当前命名空间A下本空间类引用 语法 $b=new B();
index.php页面
<?phpnamespaceA;header("content-type:text/html;charset=utf-8");useB\D,C\EasF;classB{public$name='我是命名空间"A"中定义的类"B"的一个对象';}$b=newB();//创建命名空间"A"中定义的类"B"的一个对象//如果未找到，则尝试自动装载类"A\B"echo$b->name;
结果为
我是命名空间"A"中定义的类"B"的一个对象
2当前命名空间A下命名空间 "B" 中定义的类 "D"引用
语法
use B\D //导入命名空间B中的D类
$b=new D();
index.php页面
<?phpnamespaceA;header("content-type:text/html;charset=utf-8");useB\D,C\EasF;require'test.php';//加载命名空间B中的D类的文件$d=newD();//使用导入规则，创建命名空间"B"中定义的类"D"的一个对象//如果未找到，则尝试自动装载类"B\D"echo$d->name;?>
test.php页面(定义命名空间B中D类的页面)
<?phpnamespaceB;classD{public$name='命名空间B中D类';}?>
结果为
命名空间B中D类
3当前命名空间A下命名空间 "C" 中定义的类 "E"引用
语法
use C\E as F //导入命名空间C中的E类 F为命名空间 "C" 中定义的类 "E"的别名
$b=new F();
index.php页面
<?phpnamespaceA;header("content-type:text/html;charset=utf-8");useB\D,C\EasF;require'test.php';//加载命名空间C中的E类的文件$f=newF();//使用导入规则，创建命名空间"C"中定义的类"E"的一个对象//如果未找到，则尝试自动装载类"C\E"echo$f->name;?>
test.php页面(定义命名空间C中E类的页面)
<?phpnamespaceC;classE{public$name='命名空间C中E类';}?>
结果为
命名空间C中E类
4当前命名空间A下全局空间中定义的类 "B","D" "F"引用
语法
require 'test.php';//加载全局空间中定义的类 "B","D" "F"文件
$b=new \B(); // \ 表示绝对路径引用 全局空间中定义的类
$d=new \D();
$f=new \F();
index.php页面
<?phpnamespaceA;header("content-type:text/html;charset=utf-8");useB\D,C\EasF;require'test.php';//加载全局空间中定义的类"B","D""F"文件$b=new\B();//创建定义在全局空间中的类"B"的一个对象//如果未发现，则尝试自动装载类"B"$d=new\D();//创建定义在全局空间中的类"D"的一个对象//如果未发现，则尝试自动装载类"D"$f=new\F();//创建定义在全局空间中的类"F"的一个对象//如果未发现，则尝试自动装载类"F"echo$b->name;echo'<br/>';echo$d->name;echo'<br/>';echo$f->name;?>
test.php页面(全局空间中定义的类 "B","D" "F"的页面)
<?phpclassB{public$name='全局空间的类B';}classD{public$name='全局空间的类D';}classF{public$name='全局空间的类F';}?>
结果为
全局空间的类B全局空间的类D全局空间的类F
附录
<?phpnamespaceA;useB\D,C\EasF;//函数调用foo();//首先尝试调用定义在命名空间"A"中的函数foo()//再尝试调用全局函数"foo"\foo();//调用全局空间函数"foo"my\foo();//调用定义在命名空间"A\my"中函数"foo"F();//首先尝试调用定义在命名空间"A"中的函数"F"//再尝试调用全局函数"F"//类引用newB();//创建命名空间"A"中定义的类"B"的一个对象//如果未找到，则尝试自动装载类"A\B"newD();//使用导入规则，创建命名空间"B"中定义的类"D"的一个对象//如果未找到，则尝试自动装载类"B\D"newF();//使用导入规则，创建命名空间"C"中定义的类"E"的一个对象//如果未找到，则尝试自动装载类"C\E"new\B();//创建定义在全局空间中的类"B"的一个对象//如果未发现，则尝试自动装载类"B"new\D();//创建定义在全局空间中的类"D"的一个对象//如果未发现，则尝试自动装载类"D"new\F();//创建定义在全局空间中的类"F"的一个对象//如果未发现，则尝试自动装载类"F"//调用另一个命名空间中的静态方法或命名空间函数B\foo();//调用命名空间"A\B"中函数"foo"B::foo();//调用命名空间"A"中定义的类"B"的"foo"方法//如果未找到类"A\B"，则尝试自动装载类"A\B"D::foo();//使用导入规则，调用命名空间"B"中定义的类"D"的"foo"方法//如果类"B\D"未找到，则尝试自动装载类"B\D"\B\foo();//调用命名空间"B"中的函数"foo"\B::foo();//调用全局空间中的类"B"的"foo"方法//如果类"B"未找到，则尝试自动装载类"B"//当前命名空间中的静态方法或函数A\B::foo();//调用命名空间"A\A"中定义的类"B"的"foo"方法//如果类"A\A\B"未找到，则尝试自动装载类"A\A\B"\A\B::foo();//调用命名空间"A\B"中定义的类"B"的"foo"方法//如果类"A\B"未找到，则尝试自动装载类"A\B"?>
声明：本站所有文章资源内容，如无特殊说明或标注，均为采集网络资源。如若本站内容侵犯了原著者的合法权益，可联系本站删除。
