PHP 8.3.0 RC 6 available for testing
    Submit a Pull Request Report a Bug

    扩展（extend）异常处理类

    用户可以用自定义的异常处理类来扩展 PHP 内置的异常处理类。以下的代码说明了在内置的异常处理类中，哪些属性和方法在子类中是可访问和可继承的。

    示例 #1 内置的异常处理类

    <?php
    class Exception implements Throwable
    {
    protected     $message = 'Unknown exception'; // 异常信息
    private $string; // __toString 的缓存
    protected $code = 0; // 用户自定义异常错误码
    protected $file; // 发生异常的源文件名
    protected $line; // 发生异常的源代码行号
    private $trace; // backtrace
    private $previous; // 如果是嵌套异常，则是之前的 exception

    public function __construct($message = '', $code = 0, Throwable $previous = null);

    final private function     __clone(); // 禁止克隆异常。

    final public function getMessage(); // 异常信息
    final public function getCode(); // 异常错误码
    final public function getFile(); // 发生异常的源文件名
    final public function getLine(); // 发生异常的源代码行号
    final public function getTrace(); // backtrace() 数组
    final public function getPrevious(); // 之前的 exception
    final public function getTraceAsString(); // 已格成化成字符串的 getTrace() 信息

    // Overrideable
    public function __toString(); // 可输出的格式化后的字符串
    }
    ?>

    如果使用自定义的类来扩展内置异常处理类，并且要重新定义构造函数的话，建议同时调用 parent::__construct() 来确保所有的变量已赋值。当对象要输出字符串的时候，可以重载 __toString() 并自定义输出的样式。

    注意:

    不能 复制 Exception 对象。尝试对 clone Exception 会导致 fatal E_ERROR 错误。

    示例 #2 扩展 PHP 内置的异常处理类

    <?php
    /**
    * 自定义一个异常处理类
    */
    class MyException extends Exception
    {
    // 重定义构造器使 message 变为必须被指定的属性
    public function __construct($message, $code = 0, Throwable $previous = null) {
    // 这里写用户的代码

    // 确保所有变量都被正确赋值
    parent::__construct($message, $code, $previous);
    }

    // 自定义字符串输出的格式
    public function __toString() {
    return     __CLASS__ . ": [{$this->code}]: {$this->message}\n";
    }

    public function     customFunction() {
    echo     "A custom function for this type of exception\n";
    }
    }


    /**
    * 创建一个类，测试该 exception 类
    */
    class TestException
    {
    public     $var;

    const     THROW_NONE = 0;
    const     THROW_CUSTOM = 1;
    const     THROW_DEFAULT = 2;

    function     __construct($avalue = self::THROW_NONE) {

    switch (    $avalue) {
    case     self::THROW_CUSTOM:
    // 抛出自定义异常
    throw new MyException('1 is an invalid parameter', 5);
    break;

    case     self::THROW_DEFAULT:
    // 抛出默认的异常
    throw new Exception('2 is not allowed as a parameter', 6);
    break;

    default:
    // 没有异常的情况下，创建一个对象
    $this->var = $avalue;
    break;
    }
    }
    }


    // 例子 1
    try {
    $o = new TestException(TestException::THROW_CUSTOM);
    } catch (    MyException $e) { // 捕获异常
    echo "Caught my exception\n", $e;
    $e->customFunction();
    } catch (    Exception $e) { // 被忽略
    echo "Caught Default Exception\n", $e;
    }

    // 继续执行后续代码
    var_dump($o); // Null
    echo "\n\n";


    // 例子 2
    try {
    $o = new TestException(TestException::THROW_DEFAULT);
    } catch (    MyException $e) { // 不能匹配异常的种类，被忽略
    echo "Caught my exception\n", $e;
    $e->customFunction();
    } catch (    Exception $e) { // 捕获异常
    echo "Caught Default Exception\n", $e;
    }

    // 执行后续代码
    var_dump($o); // Null
    echo "\n\n";


    // 例子 3
    try {
    $o = new TestException(TestException::THROW_CUSTOM);
    } catch (    Exception $e) { // 捕获异常
    echo "Default Exception caught\n", $e;
    }

    // 执行后续代码
    var_dump($o); // Null
    echo "\n\n";


    // 例子 4
    try {
    $o = new TestException();
    } catch (    Exception $e) { // 没有异常，被忽略
    echo "Default Exception caught\n", $e;
    }

    // 执行后续代码
    var_dump($o); // TestException
    echo "\n\n";
    ?>
    ＋add a note

    User Contributed Notes 8 notes

    up
    16
    iamhiddensomewhere at gmail dot com
    13 years ago
    As previously noted exception linking was recently added (and what a god-send it is, it certainly makes layer abstraction (and, by association, exception tracking) easier).

    Since <5.3 was lacking this useful feature I took some initiative and creating a custom exception class that all of my exceptions inherit from:

    <?php

    class SystemException extends Exception
    {
    private     $previous;

    public function     __construct($message, $code = 0, Exception $previous = null)
    {
    parent::__construct($message, $code);

    if (!    is_null($previous))
    {
    $this -> previous = $previous;
    }
    }

    public function     getPrevious()
    {
    return     $this -> previous;
    }
    }

    ?>

    Hope you find it useful.
    up
    6
    sapphirepaw.org
    13 years ago
    Support for exception linking was added in PHP 5.3.0. The getPrevious() method and the $previous argument to the constructor are not available on any built-in exceptions in older versions of PHP.
    up
    1
    Hayley Watson
    4 years ago
    Check the other SPL Exception classes and extend one of those if your intended exception is a subclass of one of those. This allows more finesse when catching.
    up
    4
    michaelrfairhurst at gmail dot com
    11 years ago
    Custom exception classes can allow you to write tests that prove your exceptions
    are meaningful. Usually testing exceptions, you either assert the message equals
    something in which case you can't change the message format without refactoring,
    or not make any assertions at all in which case you can get misleading messages
    later down the line. Especially if your $e->getMessage is something complicated
    like a var_dump'ed context array.

    The solution is to abstract the error information from the Exception class into
    properties that can be tested everywhere except the one test for your formatting.

    <?php

    class TestableException extends Exception {

    private     $property;

    function     __construct($property) {

    $this->property = $property;
    parent::__construct($this->format($property));

    }

    function     format($property) {
    return     "I have formatted: " . $property . "!!";
    }

    function     getProperty() {
    return     $this->property;
    }

    }

    function     testSomethingThrowsTestableException() {
    try {
    throw new     TestableException('Property');
    } Catch (    TestableException $e) {
    $this->assertEquals('Property', $e->getProperty());
    }
    }

    function     testExceptionFormattingOnlyOnce() {
    $e = new TestableException;
    $this->assertEquals('I have formatted: properly for the only required test!!',
    $e->format('properly for the only required test')
    );
    }

    ?>
    up
    0
    Dor
    12 years ago
    It's important to note that subclasses of the Exception class will be caught by the default Exception handler

    <?php

    /**
    * NewException
    * Extends the Exception class so that the $message parameter is now mendatory.
    *
    */
    class NewException extends Exception {
    //$message is now not optional, just for the extension.
    public function __construct($message, $code = 0, Exception $previous = null) {
    parent::__construct($message, $code, $previous);
    }
    }

    /**
    * TestException
    * Tests and throws Exceptions.
    */
    class TestException {
    const     NONE = 0;
    const     NORMAL = 1;
    const     CUSTOM = 2;
    public function     __construct($type = self::NONE) {
    switch (    $type) {
    case     1:
    throw new     Exception('Normal Exception');
    break;
    case     2:
    throw new     NewException('Custom Exception');
    break;
    default:
    return     0; //No exception is thrown.
    }
    }
    }

    try {
    $t = new TestException(TestException::CUSTOM);
    }
    catch (    Exception $e) {
    print_r($e); //Exception Caught
    }

    ?>

    Note that if an Exception is caught once, it won't be caught again (even for a more specific handler).
    up
    -5
    shaman_master at list dot ru
    8 years ago
    Use this example for not numeric codes:
    <code>
    <?php
    class MyException extends Exception
    {
    /**
    * Creates a new exception.
    *
    * @param string $message Error message
    * @param mixed $code The exception code
    * @param Exception $previous Previous exception
    * @return void
    */
    public function __construct($message = '', $code = 0, Exception $previous = null)
    {
    // Pass the message and integer code to the parent
    parent::__construct((string)$message, (int)$code, $previous);

    // @link http://bugs.php.net/39615 Save the unmodified code
    $this->code = $code;
    }
    }
    </    code>
    up
    -15
    florenxe
    8 years ago
    I just wanted to add that "extends" is same concept of "Inheritance" or "Prototyping in Javascript". So when you extend a class, you are simply inheriting the class's methods and properties. So you can create custom classes from existing classes like extending the array class.
    up
    -18
    paragdiwan at gmail dot com
    14 years ago
    I have written similar simple custom exception class. Helpful for newbie.
    <?php
    /*
    This is written for overriding the exceptions.
    custom exception class
    */
    error_reporting(E_ALL-E_NOTICE);
    class     myCustomException extends Exception
    {

    public function     __construct($message, $code=0)
    {
    parent::__construct($message,$code);
    }

    public function     __toString()
    {
    return     "<b style='color:red'>".$this->message."</b>";
    }


    }

    class     testException
    {

    public function     __construct($x)
    {

    $this->x=$x;

    }

    function     see()
    {


    if(    $this->x==9 )
    {
    throw new     myCustomException("i didnt like it");
    }
    }
    }

    $obj = new testException(9);
    try{

    $obj->see();
    }
    catch(    myCustomException $e)
    {
    echo     $e;
    }
    ?>
    ＋add a note
    To Top