Extending Exceptions

    A User defined Exception class can be defined by extending the built-in Exception class. The members and properties below, show what is accessible within the child class that derives from the built-in Exception class.

    Example #1 The Built in Exception class

    <?php
    class Exception implements Throwable
    {
    protected     $message = 'Unknown exception'; // exception message
    private $string; // __toString cache
    protected $code = 0; // user defined exception code
    protected $file; // source filename of exception
    protected $line; // source line of exception
    private $trace; // backtrace
    private $previous; // previous exception if nested exception

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

    final private function     __clone(); // Inhibits cloning of exceptions.

    final public function getMessage(); // message of exception
    final public function getCode(); // code of exception
    final public function getFile(); // source filename
    final public function getLine(); // source line
    final public function getTrace(); // an array of the backtrace()
    final public function getPrevious(); // previous exception
    final public function getTraceAsString(); // formatted string of trace

    // Overrideable
    public function __toString(); // formatted string for display
    }
    ?>

    If a class extends the built-in Exception class and re-defines the constructor, it is highly recommended that it also call parent::__construct() to ensure all available data has been properly assigned. The __toString() method can be overridden to provide a custom output when the object is presented as a string.

    Nota:

    Exceptions cannot be cloned. Attempting to clone an Exception will result in a fatal E_ERROR error.

    Example #2 Extending the Exception class

    <?php
    /**
    * Define a custom exception class
    */
    class MyException extends Exception
    {
    // Redefine the exception so message isn't optional
    public function __construct($message, $code = 0, Throwable $previous = null) {
    // some code

    // make sure everything is assigned properly
    parent::__construct($message, $code, $previous);
    }

    // custom string representation of object
    public function __toString() {
    return     __CLASS__ . ": [{$this->code}]: {$this->message}\n";
    }

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


    /**
    * Create a class to test the 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 custom exception
    throw new MyException('1 is an invalid parameter', 5);
    break;

    case     self::THROW_DEFAULT:
    // throw default one.
    throw new Exception('2 is not allowed as a parameter', 6);
    break;

    default:
    // No exception, object will be created.
    $this->var = $avalue;
    break;
    }
    }
    }


    // Example 1
    try {
    $o = new TestException(TestException::THROW_CUSTOM);
    } catch (    MyException $e) { // Will be caught
    echo "Caught my exception\n", $e;
    $e->customFunction();
    } catch (    Exception $e) { // Skipped
    echo "Caught Default Exception\n", $e;
    }

    // Continue execution
    var_dump($o); // Null
    echo "\n\n";


    // Example 2
    try {
    $o = new TestException(TestException::THROW_DEFAULT);
    } catch (    MyException $e) { // Doesn't match this type
    echo "Caught my exception\n", $e;
    $e->customFunction();
    } catch (    Exception $e) { // Will be caught
    echo "Caught Default Exception\n", $e;
    }

    // Continue execution
    var_dump($o); // Null
    echo "\n\n";


    // Example 3
    try {
    $o = new TestException(TestException::THROW_CUSTOM);
    } catch (    Exception $e) { // Will be caught
    echo "Default Exception caught\n", $e;
    }

    // Continue execution
    var_dump($o); // Null
    echo "\n\n";


    // Example 4
    try {
    $o = new TestException();
    } catch (    Exception $e) { // Skipped, no exception
    echo "Default Exception caught\n", $e;
    }

    // Continue execution
    var_dump($o); // TestException
    echo "\n\n";
    ?>

    Improve This Page

    Learn How To Improve This Page • Submit a Pull Request • Report a Bug
    ＋add a note

    User Contributed Notes 6 notes

    up
    17
    iamhiddensomewhere at gmail dot com
    14 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
    Hayley Watson
    5 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
    5
    michaelrfairhurst at gmail dot com
    12 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
    4
    sapphirepaw.org
    14 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
    Dor
    13 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
    -4
    shaman_master at list dot ru
    9 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>
    ＋add a note
    To Top