PHP namespace 命名空间 函数调用 类引用 详细测试分析

本文测试中,假设index.php页面和test.php页面在同一个根目录下,方便加载test.php页面。

前提条件都是在namespace A;下进行测试。namespace A;

use B\D, C\E as F;

// 函数调用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页面<?php

namespace A;

header("content-type:text/html;charset=utf-8");

require 'test.php';//加载定义命名空间"A\my"的页面

function foo(){

echo '我是命名空间"A"中的函数foo()';

}

// 函数调用

foo();      // 首先尝试调用定义在命名空间"A"中的函数foo()

// 再尝试调用全局函数 "foo"

结果为我是命名空间"A"中的函数foo()

2当前命名空间A下调用命名空间"A\my"中的函数foo()  语法 my\foo();

index.php页面<?php

namespace A;

header("content-type:text/html;charset=utf-8");

require 'test.php';//加载定义命名空间"A\my"的页面

//调用函数

my\foo();   // 调用定义在命名空间"A\my"中函数 "foo"

?>

test.php页面(定义命名空间"A\my"的页面)<?php

namespace A\my;

function foo(){

echo '我是命名空间"A\my"中的函数foo()';

}

?>

结果为

我是命名空间"A\my"中的函数foo()

3.当前命名空间A下调用命名空间 "A\B"的函数"foo"

语法

require 'test.php';//加载命名空间 "A\B"的函数"foo"文件

B\foo();

index.php页面<?php

namespace A;

header("content-type:text/html;charset=utf-8");

use B\D, C\E as F;

require 'test.php';//加载命名空间 "A\B"的函数"foo"文件

B\foo();    // 调用命名空间 "A\B" 中函数 "foo"

?>

test.php页面(定义命名空间 "A\B"的函数"foo"的页面)<?php

namespace A\B;

function foo(){

echo '命名空间 "A\B" 中函数 "foo"';

}

?>

结果为命名空间 "A\B" 中函数 "foo"

4.当前命名空间A下调用本命名空间 "A" 中定义的类 "B" 的 "foo" 静态方法

语法

B::foo();

index.php页面<?php

namespace A;

header("content-type:text/html;charset=utf-8");

use B\D, C\E as F;

class B{

static  public function foo(){

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页面<?php

namespace A;

header("content-type:text/html;charset=utf-8");

require 'test.php';

use B\D, C\E as F;

D::foo();   // 使用导入规则，调用命名空间 "B" 中定义的类 "D" 的 "foo" 方法

// 如果类 "B\D" 未找到，则尝试自动装载类 "B\D"

?>

test.php页面(定义命名空间 "B"的类"D"的函数"foo"的页面)<?php

namespace B;

class D{

static public function foo(){

echo '命名空间 "B" 中定义的类 "D" 的 "foo" 方法';

}

}

?>

结果为命名空间 "B" 中定义的类 "D" 的 "foo" 方法

6.当前命名空间A下调用命名空间 "B"的函数"foo"

语法

require 'test.php';//加载命名空间 "B"的函数"foo"文件

\B\foo();

index.php页面<?php

namespace A;

header("content-type:text/html;charset=utf-8");

use B\D, C\E as F;

require 'test.php';//加载命名空间 "B"的函数"foo"文件

\B\foo();    // 调用命名空间 "B" 中函数 "foo"

?>

test.php页面(定义命名空间 "B"的函数"foo"的页面)<?php

namespace B;

function foo(){

echo '命名空间 "B" 中函数 "foo"';

}

?>

结果为命名空间 "B" 中函数 "foo"

7.当前命名空间A下调用全局空间 "B"的函数"foo"静态方法

语法

require 'test.php';//加载全局空间 "B"的函数"foo"文件

\B::foo();

index.php页面<?php

namespace A;

header("content-type:text/html;charset=utf-8");

use B\D, C\E as F;

require 'test.php';//加载全局空间 "B"的函数"foo"文件

\B::foo();  // 调用全局空间中的类 "B" 的 "foo" 方法

// 如果类 "B" 未找到，则尝试自动装载类 "B"

?>

test.php页面(定义全局空间 "B"的函数"foo"的页面)<?php

class B{

static public function foo(){

echo '全局空间的B类中foo方法';

}

}

?>

结果为全局空间的B类中foo方法

8.当前命名空间A下调用命名空间 "A\A"的B类"foo"静态方法

语法

require 'test.php';//加载命名空间 "A\A"的B类"foo"静态方法文件

A\B::foo();

index.php页面<?php

namespace A;

header("content-type:text/html;charset=utf-8");

use B\D, C\E as F;

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"静态方法的页面)<?php

namespace A\A;

class B{

static public function foo(){

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页面<?php

namespace A;

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"静态方法的页面)<?php

namespace A\B;

class B{

static public function foo(){

echo '命名空间A\B中B类的foo静态方法';

}

}

?>

结果为命名空间A\B中B类的foo静态方法

类引用

1当前命名空间A下本空间类引用  语法 $b=new B();

index.php页面<?php

namespace A;

header("content-type:text/html;charset=utf-8");

use B\D, C\E as F;

class B{

public $name='我是命名空间 "A" 中定义的类 "B" 的一个对象';

}

$b=new B();    // 创建命名空间 "A" 中定义的类 "B" 的一个对象

// 如果未找到，则尝试自动装载类 "A\B"

echo $b->name;

结果为我是命名空间 "A" 中定义的类 "B" 的一个对象

2当前命名空间A下命名空间 "B" 中定义的类 "D"引用

语法

use B\D        //导入命名空间B中的D类

$b=new D();

index.php页面<?php

namespace A;

header("content-type:text/html;charset=utf-8");

use B\D, C\E as F;

require 'test.php';//加载命名空间B中的D类的文件

$d=new D();    // 使用导入规则，创建命名空间 "B" 中定义的类 "D" 的一个对象

// 如果未找到，则尝试自动装载类 "B\D"

echo $d->name;

?>

test.php页面(定义命名空间B中D类的页面)<?php

namespace B;

class D{

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页面<?php

namespace A;

header("content-type:text/html;charset=utf-8");

use B\D, C\E as F;

require 'test.php';//加载命名空间C中的E类的文件

$f=new F();    // 使用导入规则，创建命名空间 "C" 中定义的类 "E" 的一个对象

// 如果未找到，则尝试自动装载类 "C\E"

echo $f->name;

?>

test.php页面(定义命名空间C中E类的页面)<?php

namespace C;

class E{

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页面<?php

namespace A;

header("content-type:text/html;charset=utf-8");

use B\D, C\E as F;

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 '
';

echo $d->name;

echo '
';

echo $f->name;

?>

test.php页面(全局空间中定义的类 "B","D" "F"的页面)<?php

class B{

public $name='全局空间的类B';

}

class D{

public $name='全局空间的类D';

}

class F{

public $name='全局空间的类F';

}

?>

结果为全局空间的类B

全局空间的类D

全局空间的类F

附录<?php

namespace A;

use B\D, C\E as F;

// 函数调用

foo();      // 首先尝试调用定义在命名空间"A"中的函数foo()

// 再尝试调用全局函数 "foo"

\foo();     // 调用全局空间函数 "foo"

my\foo();   // 调用定义在命名空间"A\my"中函数 "foo"

F();        // 首先尝试调用定义在命名空间"A"中的函数 "F"

// 再尝试调用全局函数 "F"

// 类引用

new B();    // 创建命名空间 "A" 中定义的类 "B" 的一个对象

// 如果未找到，则尝试自动装载类 "A\B"

new D();    // 使用导入规则，创建命名空间 "B" 中定义的类 "D" 的一个对象

// 如果未找到，则尝试自动装载类 "B\D"

new F();    // 使用导入规则，创建命名空间 "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"

?>