详细分析PHP 命名空间(namespace)

PHP 命名空间(namespace)是在PHP 5.3中加入的，如果你学过C#和Java，那命名空间就不算什么新事物。 不过在PHP当中还是有着相当重要的意义。

PHP 命名空间可以解决以下两类问题：

  1. 用户编写的代码与PHP内部的类/函数/常量或第三方类/函数/常量之间的名字冲突。
  2. 为很长的标识符名称(通常是为了缓解第一类问题而定义的)创建一个别名（或简短）的名称，提高源代码的可读性。

定义命名空间

默认情况下，所有常量、类和函数名都放在全局空间下，就和PHP支持命名空间之前一样。

命名空间通过关键字namespace 来声明。如果一个文件中包含命名空间，它必须在其它所有代码之前声明命名空间。语法格式如下；

<?php
// 定义代码在 'MyProject' 命名空间中
namespace MyProject; 

// ... 代码 ...

你也可以在同一个文件中定义不同的命名空间代码，如：

<?php
namespace MyProject;

const CONNECT_OK = 1;
class Connection { /* ... */ }
function connect() { /* ... */ }

namespace AnotherProject;

const CONNECT_OK = 1;
class Connection { /* ... */ }
function connect() { /* ... */ }
?>

不建议使用这种语法在单个文件中定义多个命名空间。建议使用下面的大括号形式的语法。

<?php
namespace MyProject {
 const CONNECT_OK = 1;
 class Connection { /* ... */ }
 function connect() { /* ... */ }
}

namespace AnotherProject {
 const CONNECT_OK = 1;
 class Connection { /* ... */ }
 function connect() { /* ... */ }
}
?>

将全局的非命名空间中的代码与命名空间中的代码组合在一起，只能使用大括号形式的语法。全局代码必须用一个不带名称的 namespace 语句加上大括号括起来，例如：

<?php
namespace MyProject {

const CONNECT_OK = 1;
class Connection { /* ... */ }
function connect() { /* ... */ }
}

namespace { // 全局代码
session_start();
$a = MyProject\connect();
echo MyProject\Connection::start();
}
?>

在声明命名空间之前唯一合法的代码是用于定义源文件编码方式的 declare 语句。所有非 PHP 代码包括空白符都不能出现在命名空间的声明之前。

<?php
declare(encoding='UTF-8'); //定义多个命名空间和不包含在命名空间中的代码
namespace MyProject {

const CONNECT_OK = 1;
class Connection { /* ... */ }
function connect() { /* ... */ }
}

namespace { // 全局代码
session_start();
$a = MyProject\connect();
echo MyProject\Connection::start();
}
?>

以下代码会出现语法错误：

<html>
<?php
namespace MyProject; // 命名空间前出现了“<html>” 会致命错误 -　命名空间必须是程序脚本的第一条语句
?>

子命名空间

与目录和文件的关系很像，PHP 命名空间也允许指定层次化的命名空间的名称。因此，命名空间的名字可以使用分层次的方式定义：

<?php
namespace MyProject\Sub\Level; //声明分层次的单个命名空间

const CONNECT_OK = 1;
class Connection { /* ... */ }
function Connect() { /* ... */ }

?>

上面的例子创建了常量 MyProject\Sub\Level\CONNECT_OK，类 MyProject\Sub\Level\Connection 和函数 MyProject\Sub\Level\Connect。

命名空间使用

PHP 命名空间中的类名可以通过三种方式引用：

  1. 非限定名称，或不包含前缀的类名称，例如 $a=new foo(); 或 foo::staticmethod();。如果当前命名空间是 currentnamespace，foo 将被解析为 currentnamespace\foo。如果使用 foo 的代码是全局的，不包含在任何命名空间中的代码，则 foo 会被解析为foo。 警告：如果命名空间中的函数或常量未定义，则该非限定的函数名称或常量名称会被解析为全局函数名称或常量名称。
  2. 限定名称,或包含前缀的名称，例如 $a = new subnamespace\foo(); 或 subnamespace\foo::staticmethod();。如果当前的命名空间是 currentnamespace，则 foo 会被解析为 currentnamespace\subnamespace\foo。如果使用 foo 的代码是全局的，不包含在任何命名空间中的代码，foo 会被解析为subnamespace\foo。
  3. 完全限定名称，或包含了全局前缀操作符的名称，例如， $a = new \currentnamespace\foo(); 或 \currentnamespace\foo::staticmethod();。在这种情况下，foo 总是被解析为代码中的文字名(literal name)currentnamespace\foo。

下面是一个使用这三种方式的实例：

file1.php 文件代码

<?php
namespace Foo\Bar\subnamespace; 

const FOO = 1;
function foo() {}
class foo
{
 static function staticmethod() {}
}
?>

file2.php 文件代码

<?php
namespace Foo\Bar;
include 'file1.php';

const FOO = 2;
function foo() {}
class foo
{
 static function staticmethod() {}
}

/* 非限定名称 */
foo(); // 解析为函数 Foo\Bar\foo
foo::staticmethod(); // 解析为类 Foo\Bar\foo ，方法为 staticmethod
echo FOO; // 解析为常量 Foo\Bar\FOO

/* 限定名称 */
subnamespace\foo(); // 解析为函数 Foo\Bar\subnamespace\foo
subnamespace\foo::staticmethod(); // 解析为类 Foo\Bar\subnamespace\foo,
         // 以及类的方法 staticmethod
echo subnamespace\FOO; // 解析为常量 Foo\Bar\subnamespace\FOO

/* 完全限定名称 */
\Foo\Bar\foo(); // 解析为函数 Foo\Bar\foo
\Foo\Bar\foo::staticmethod(); // 解析为类 Foo\Bar\foo, 以及类的方法 staticmethod
echo \Foo\Bar\FOO; // 解析为常量 Foo\Bar\FOO
?>

注意访问任意全局类、函数或常量，都可以使用完全限定名称，例如 \strlen() 或 \Exception 或 \INI_ALL。

在命名空间内部访问全局类、函数和常量：

<?php
namespace Foo;

function strlen() {}
const INI_ALL = 3;
class Exception {}

$a = \strlen('hi'); // 调用全局函数strlen
$b = \INI_ALL; // 访问全局常量 INI_ALL
$c = new \Exception('error'); // 实例化全局类 Exception
?>

命名空间和动态语言特征

PHP 命名空间的实现受到其语言自身的动态特征的影响。因此，如果要将下面的代码转换到命名空间中，动态访问元素。

example1.php 文件代码：

<?php
class classname
{
 function __construct()
 {
  echo __METHOD__,"\n";
 }
}
function funcname()
{
 echo __FUNCTION__,"\n";
}
const constname = "global";

$a = 'classname';
$obj = new $a; // prints classname::__construct
$b = 'funcname';
$b(); // prints funcname
echo constant('constname'), "\n"; // prints global
?>

必须使用完全限定名称（包括命名空间前缀的类名称）。注意因为在动态的类名称、函数名称或常量名称中，限定名称和完全限定名称没有区别，因此其前导的反斜杠是不必要的。

动态访问命名空间的元素

<?php
namespace namespacename;
class classname
{
 function __construct()
 {
  echo __METHOD__,"\n";
 }
}
function funcname()
{
 echo __FUNCTION__,"\n";
}
const constname = "namespaced";

include 'example1.php';

$a = 'classname';
$obj = new $a; // 输出 classname::__construct
$b = 'funcname';
$b(); // 输出函数名
echo constant('constname'), "\n"; // 输出 global

/* 如果使用双引号，使用方法为 "\\namespacename\\classname"*/
$a = '\namespacename\classname';
$obj = new $a; // 输出 namespacename\classname::__construct
$a = 'namespacename\classname';
$obj = new $a; // 输出 namespacename\classname::__construct
$b = 'namespacename\funcname';
$b(); // 输出 namespacename\funcname
$b = '\namespacename\funcname';
$b(); // 输出 namespacename\funcname
echo constant('\namespacename\constname'), "\n"; // 输出 namespaced
echo constant('namespacename\constname'), "\n"; // 输出 namespaced
?>

namespace关键字和__NAMESPACE__常量

PHP支持两种抽象的访问当前命名空间内部元素的方法，__NAMESPACE__ 魔术常量和namespace关键字。

常量__NAMESPACE__的值是包含当前命名空间名称的字符串。在全局的，不包括在任何命名空间中的代码，它包含一个空的字符串。

__NAMESPACE__ 示例, 在命名空间中的代码

<?php
namespace MyProject;

echo '"', __NAMESPACE__, '"'; // 输出 "MyProject"
?>

__NAMESPACE__ 示例，全局代码

<?php

echo '"', __NAMESPACE__, '"'; // 输出 ""
?>

常量 __NAMESPACE__ 在动态创建名称时很有用，例如：

使用__NAMESPACE__动态创建名称

<?php
namespace MyProject;

function get($classname)
{
 $a = __NAMESPACE__ . '\\' . $classname;
 return new $a;
}
?>

关键字 namespace 可用来显式访问当前命名空间或子命名空间中的元素。它等价于类中的 self 操作符。

namespace操作符，命名空间中的代码

<?php
namespace MyProject;

use blah\blah as mine; // see "Using namespaces: importing/aliasing"

blah\mine(); // calls function blah\blah\mine()
namespace\blah\mine(); // calls function MyProject\blah\mine()

namespace\func(); // calls function MyProject\func()
namespace\sub\func(); // calls function MyProject\sub\func()
namespace\cname::method(); // calls static method "method" of class MyProject\cname
$a = new namespace\sub\cname(); // instantiates object of class MyProject\sub\cname
$b = namespace\CONSTANT; // assigns value of constant MyProject\CONSTANT to $b
?>

namespace操作符, 全局代码

<?php

namespace\func(); // calls function func()
namespace\sub\func(); // calls function sub\func()
namespace\cname::method(); // calls static method "method" of class cname
$a = new namespace\sub\cname(); // instantiates object of class sub\cname
$b = namespace\CONSTANT; // assigns value of constant CONSTANT to $b
?>

使用命名空间：别名/导入

PHP 命名空间支持 有两种使用别名或导入方式：为类名称使用别名，或为命名空间名称使用别名。

在PHP中，别名是通过操作符 use 来实现的. 下面是一个使用所有可能的三种导入方式的例子：

1、使用use操作符导入/使用别名

<?php
namespace foo;
use My\Full\Classname as Another;

// 下面的例子与 use My\Full\NSname as NSname 相同
use My\Full\NSname;

// 导入一个全局类
use \ArrayObject;

$obj = new namespace\Another; // 实例化 foo\Another 对象
$obj = new Another; // 实例化 My\Full\Classname　对象
NSname\subns\func(); // 调用函数 My\Full\NSname\subns\func
$a = new ArrayObject(array(1)); // 实例化 ArrayObject 对象
// 如果不使用 "use \ArrayObject" ，则实例化一个 foo\ArrayObject 对象
?>

2、 一行中包含多个use语句

<?php
use My\Full\Classname as Another, My\Full\NSname;

$obj = new Another; // 实例化 My\Full\Classname 对象
NSname\subns\func(); // 调用函数 My\Full\NSname\subns\func
?>

导入操作是在编译执行的，但动态的类名称、函数名称或常量名称则不是。

3、导入和动态名称

<?php
use My\Full\Classname as Another, My\Full\NSname;

$obj = new Another; // 实例化一个 My\Full\Classname 对象
$a = 'Another';
$obj = new $a;  // 实际化一个 Another 对象
?>

另外，导入操作只影响非限定名称和限定名称。完全限定名称由于是确定的，故不受导入的影响。

4、导入和完全限定名称

<?php
use My\Full\Classname as Another, My\Full\NSname;

$obj = new Another; // 实例化 My\Full\Classname 类
$obj = new \Another; // 实例化 Another 类
$obj = new Another\thing; // 实例化 My\Full\Classname\thing 类
$obj = new \Another\thing; // 实例化 Another\thing 类
?>

使用命名空间：后备全局函数/常量

在一个命名空间中，当 PHP 遇到一个非限定的类、函数或常量名称时，它使用不同的优先策略来解析该名称。类名称总是解析到当前命名空间中的名称。因此在访问系统内部或不包含在命名空间中的类名称时，必须使用完全限定名称，例如：

1、在命名空间中访问全局类

<?php
namespace A\B\C;
class Exception extends \Exception {}

$a = new Exception('hi'); // $a 是类 A\B\C\Exception 的一个对象
$b = new \Exception('hi'); // $b 是类 Exception 的一个对象

$c = new ArrayObject; // 致命错误, 找不到 A\B\C\ArrayObject 类
?>

对于函数和常量来说，如果当前命名空间中不存在该函数或常量，PHP 会退而使用全局空间中的函数或常量。

2、 命名空间中后备的全局函数/常量

<?php
namespace A\B\C;

const E_ERROR = 45;
function strlen($str)
{
 return \strlen($str) - 1;
}

echo E_ERROR, "\n"; // 输出 "45"
echo INI_ALL, "\n"; // 输出 "7" - 使用全局常量 INI_ALL

echo strlen('hi'), "\n"; // 输出 "1"
if (is_array('hi')) { // 输出 "is not array"
 echo "is array\n";
} else {
 echo "is not array\n";
}
?>

全局空间

如果没有定义任何命名空间，所有的类与函数的定义都是在全局空间，与 PHP 引入命名空间概念前一样。在名称前加上前缀 \ 表示该名称是全局空间中的名称，即使该名称位于其它的命名空间中时也是如此。

使用全局空间说明

<?php
namespace A\B\C;

/* 这个函数是 A\B\C\fopen */
function fopen() {
  /* ... */
  $f = \fopen(...); // 调用全局的fopen函数
  return $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" 的 "foo" 方法
    // 如果类 "A\B" 未找到，则尝试自动装载类 "A\B"
?>

名称解析遵循下列规则：

1. 对完全限定名称的函数，类和常量的调用在编译时解析。例如 new \A\B 解析为类 A\B。

2. 所有的非限定名称和限定名称（非完全限定名称）根据当前的导入规则在编译时进行转换。例如，如果命名空间 A\B\C 被导入为 C，那么对 C\D\e() 的调用就会被转换为 A\B\C\D\e()。

3. 在命名空间内部，所有的没有根据导入规则转换的限定名称均会在其前面加上当前的命名空间名称。例如，在命名空间 A\B 内部调用 C\D\e()，则 C\D\e() 会被转换为 A\B\C\D\e() 。

4. 非限定类名根据当前的导入规则在编译时转换（用全名代替短的导入名称）。例如，如果命名空间 A\B\C 导入为C，则 new C() 被转换为 new A\B\C() 。

5. 在命名空间内部（例如A\B），对非限定名称的函数调用是在运行时解析的。例如对函数 foo() 的调用是这样解析的：

  1. 在当前命名空间中查找名为 A\B\foo() 的函数
  2. 尝试查找并调用 全局(global) 空间中的函数 foo()。

6. 在命名空间（例如A\B）内部对非限定名称或限定名称类（非完全限定名称）的调用是在运行时解析的。下面是调用 new C() 及 new D\E() 的解析过程： new C()的解析:

  • 在当前命名空间中查找A\B\C类。
  • 尝试自动装载类A\B\C。

new D\E()的解析:

  • 在类名称前面加上当前命名空间名称变成：A\B\D\E，然后查找该类。
  • 尝试自动装载类 A\B\D\E。

为了引用全局命名空间中的全局类，必须使用完全限定名称 new \C()。

以上就是详细分析PHP 命名空间(namespace)的详细内容，更多关于PHP 命名空间(namespace)的资料请关注我们其它相关文章！

赞 (0)

相关推荐

  • PHP命名空间(namespace)原理与用法详解

    本文实例讲述了PHP命名空间(namespace)原理与用法.分享给大家供大家参考,具体如下: PHP 命名空间(namespace)是在PHP 5.3中加入的,它可以解决以下两类问题: 用户编写的代码与PHP内部的类/函数/常量或第三方类/函数/常量之间的名字冲突. 为很长的标识符名称(通常是为了缓解第一类问题而定义的)创建一个别名(或简短)的名称,提高源代码的可读性. 我们在默认情况下,所有常量.类和函数名都放在全局空间下,就和PHP支持命名空间之前一样,命名空间通过关键字namespace

  • php的命名空间与自动加载实现方法

    类的自动加载 引子 当我们在php代码中加载类时,我们必须要include或者require 某个类文件. 但遇到类似的情况,例如: require "Class1.php"; require "Class2.php"; $boy = $_GET['sex'] = 0?true:false; if($boy) { $class1 = new Class1(); }else{ $class2 = new Class2(); } 假如我们需要判断一个人的性别,如果是男的

  • 详解PHP中的命名空间

    命名空间其实早在PHP5.3就已经出现了.不过大部分同学可能在各种框架的使用中才会接触到命名空间的内容,当然,现代化的开发也都离不开这些能够快速产出的框架.这次我们不从框架的角度,仅从简单的代码角度来解析一下命名空间的概念和使用. 首先,我们要定义命名空间是个什么东西. 其实就像操作系统的目录一样,命名空间就是为了解决类似于操作系统中同一个文件夹不能有相同的文件名一样的问题.假设我们只有一个文件,一个目录,那么在这个目录中,是不能有两个完全相同的文件的.如果有这样名称完全相同的文件,那么操作系统

  • PHP命名空间与自动加载机制的基础介绍

    前言 include 和 require 是PHP中引入文件的两个基本方法.在小规模开发中直接使用 include 和 require 没哟什么不妥,但在大型项目中会造成大量的 include 和 require 堆积.这样的代码既不优雅,执行效率也很低,而且维护起来也相当困难. 为了解决这个问题,部分框架会给出一个引入文件的配置清单,在对象初始化的时候把需要的文件引入.但这只是让代码变得更简洁了一些,引入的效果仍然是差强人意.PHP5 之后,随着 PHP 面向对象支持的完善,__autoloa

  • PHP类的自动加载与命名空间用法实例分析

    本文实例讲述了PHP类的自动加载与命名空间用法.分享给大家供大家参考,具体如下: 作为一名合格的程序员,必定会有一个从面向过程编程到面向对象编程的转化过程,在这个过程中诸如命名空间,类,继承,接口,类自动加载等等都是需要我们去掌握的,之前对这些概念都不是很熟悉,只是能够基础地使用,在这里系统的记录一下关于命名空间与类的自动加载知识. 类的自动加载 什么是自动加载类? ? ? 从字面意思上就可以大概知道,当调用一个当前页面未定义的类的时候能够自动加载. 相信如果你之前了解过php的魔术方法的话,肯

  • php 命名空间(namespace)原理与用法实例小结

    本文实例讲述了php 命名空间(namespace)原理与用法.分享给大家供大家参考,具体如下: 命名空间一个最明确的目的就是解决重名问题,PHP中不允许两个函数或者类出现相同的名字,否则会产生一个致命的错误.这种情况下只要避免命名重复就可以解决,最常见的一种做法是约定一个前缀,也可以采用命名空间的方式解决 TestSpace.php <?php namespace Demo\Test; //声明一个命名空间Demo class Test1 { static function test() {

  • PHP 命名空间原理与用法详解

    本文实例讲述了PHP 命名空间原理与用法.分享给大家供大家参考,具体如下: 命名空间适用于 (PHP 5 >= 5.3.0, PHP 7) 使用命名空间基础 PHP 命名空间类似于文件系统, 在文件系统中访问一个文件有三种方式: 相对文件名形式如foo.txt.它会被解析为 currentdirectory/foo.txt,其中 currentdirectory 表示当前目录.因此如果当前目录是 /home/foo,则该文件名被解析为/home/foo/foo.txt. 相对路径名形式如subd

  • PHP 命名空间和自动加载原理与用法实例分析

    本文实例讲述了PHP 命名空间和自动加载原理与用法.分享给大家供大家参考,具体如下: PHP 命名空间 php5.3 之后引入了命名空间的特性,从本质上讲,命名空间就是一个容器,你可以将类.函数和变量放在其中,在命名空间中,你可以无条件地访问这些项,在命名空间之外,必须导入或引用命名空间,才能访问它所包含的项. 声明命名空间 namespace my; require_one 'outputter3.php'; class outputter { // 输出数据 public function

  • PHP命名空间用法实例分析

    本文实例讲述了PHP命名空间用法.分享给大家供大家参考,具体如下: 在讲解命名空间之前,我们先了解一个问题. 我们在网站根目录创建一个文件夹,在文件夹中创建a.php <?php class Apple{ function get_into(){ echo "this is A"; } } 然后再创建一个b.php <?php class Apple{ function get_into(){ echo "this is B"; } } 再创建一个ind

  • 详细分析PHP 命名空间(namespace)

    PHP 命名空间(namespace)是在PHP 5.3中加入的,如果你学过C#和Java,那命名空间就不算什么新事物. 不过在PHP当中还是有着相当重要的意义. PHP 命名空间可以解决以下两类问题: 用户编写的代码与PHP内部的类/函数/常量或第三方类/函数/常量之间的名字冲突. 为很长的标识符名称(通常是为了缓解第一类问题而定义的)创建一个别名(或简短)的名称,提高源代码的可读性. 定义命名空间 默认情况下,所有常量.类和函数名都放在全局空间下,就和PHP支持命名空间之前一样. 命名空间通

  • PHP命名空间namespace用法实例分析

    PHP命名空间namespace用法实例分析

    本文实例讲述了PHP命名空间namespace用法.分享给大家供大家参考,具体如下: namespace(命名空间)相当于函数.类,划分了一个区域,这样子就使得在同个页面中可以require相同的类,使用相同名字的函数 : 在项目中比较少用 name.php: <?php //命名要使用复合名称 namespace me\mine; class me{ public function __construct(){ echo 'name'.'<br>'; } public function

  • PHP命名空间namespace及use的简单用法分析

    本文实例讲述了PHP命名空间namespace及use的简单用法.分享给大家供大家参考,具体如下: 最近一段时间在研究php框架,一直想的什么时候才能开发出自己的框架,当然这是为了提升自己的编程水平,同时能把平时学的零散的东西糅合在一块熟练应用.但是开发一个框架根本不知道如何做起,先开发什么,虽然php的框架也不少,但是都是如何应用,没有文档和视频可以学习,这是让我特别郁闷的事情,相信不少想自己开发框架玩的小伙伴都有类似的感受,郁闷归郁闷,自己还是动手做了,做的时候困难和想象的一样难,从一开始就

  • PHP命名空间(Namespace)的使用详解

    对于命名空间,官方文档已经说得很详细[查看],我在这里做了一下实践和总结. 命名空间一个最明确的目的就是解决重名问题,PHP中不允许两个函数或者类出现相同的名字,否则会产生一个致命的错误.这种情况下只要避免命名重复就可以解决,最常见的一种做法是约定一个前缀. 例:项目中有两个模块:article和message board,它们各自有一个处理用户留言的类Comment.之后我可能想要增加对所有用户留言的一些信息统计功能,比如说我想得到所有留言的数量.这时候调用它们Comment提供的方法是很好的

  • PHP命名空间namespace定义及导入use用法详解

    本文实例讲述了PHP命名空间namespace定义及导入use用法.分享给大家供大家参考,具体如下: 在PHP中,出现同名函数或是同名类是不被允许的.为防止编程人员在项目中定义的类名或函数名出现重复冲突,在PHP5.3中引入了命名空间这一概念. 1.命名空间,即将代码划分成不同空间,不同空间的类名相互独立,互不冲突.一个php文件中可以存在多个命名空间,第一个命名空间前不能有任何代码.内容空间声明后的代码便属于这个命名空间,例如: <?php echo 111; //由于namespace前有代

  • 详细分析C++ 异常处理

    异常是程序在执行期间产生的问题.C++ 异常是指在程序运行时发生的特殊情况,比如尝试除以零的操作. 异常提供了一种转移程序控制权的方式.C++ 异常处理涉及到三个关键字:try.catch.throw. throw: 当问题出现时,程序会抛出一个异常.这是通过使用 throw 关键字来完成的. catch: 在您想要处理问题的地方,通过异常处理程序捕获异常.catch 关键字用于捕获异常. try: try 块中的代码标识将被激活的特定异常.它后面通常跟着一个或多个 catch 块. 如果有一个

  • 详细分析C++ 数据封装和数据抽象

    C++ 数据封装 所有的 C++ 程序都有以下两个基本要素: 程序语句(代码):这是程序中执行动作的部分,它们被称为函数. 程序数据:数据是程序的信息,会受到程序函数的影响. 封装是面向对象编程中的把数据和操作数据的函数绑定在一起的一个概念,这样能避免受到外界的干扰和误用,从而确保了安全.数据封装引申出了另一个重要的 OOP 概念,即数据隐藏. 数据封装是一种把数据和操作数据的函数捆绑在一起的机制,数据抽象是一种仅向用户暴露接口而把具体的实现细节隐藏起来的机制. C++ 通过创建类来支持封装和数

  • 详细分析C++ 多态和虚函数

    多态按字面的意思就是多种形态.当类之间存在层次结构,并且类之间是通过继承关联时,就会用到多态. C++ 多态意味着调用成员函数时,会根据调用函数的对象的类型来执行不同的函数. 下面的实例中,基类 Shape 被派生为两个类,如下所示: #include <iostream> using namespace std; class Shape { protected: int width, height; public: Shape( int a=0, int b=0) { width = a;

  • 详细分析C++ 信号处理

    信号是由操作系统传给进程的中断,会提早终止一个程序.在 UNIX.LINUX.Mac OS X 或 Windows 系统上,可以通过按 Ctrl+C 产生中断. 有些信号不能被程序捕获,但是下表所列信号可以在程序中捕获,并可以基于信号采取适当的动作.这些信号是定义在 C++ 头文件 <csignal> 中. 信号 描述 SIGABRT 程序的异常终止,如调用 abort. SIGFPE 错误的算术运算,比如除以零或导致溢出的操作. SIGILL 检测非法指令. SIGINT 程序终止(inte

  • 详细分析c# 运算符重载

    您可以重定义或重载 C# 中内置的运算符.因此,程序员也可以使用用户自定义类型的运算符.重载运算符是具有特殊名称的函数,是通过关键字 operator 后跟运算符的符号来定义的.与其他函数一样,重载运算符有返回类型和参数列表. 例如,请看下面的函数: public static Box operator+ (Box b, Box c) { Box box = new Box(); box.length = b.length + c.length; box.breadth = b.breadth

随机推荐