PHP 8.4.2 Released!

    例外を拡張する

    組み込みの Exception クラスを拡張することで、例外クラスをユーザーが 定義することが可能です。以下のメンバーおよびプロパティは、 組み込みの Exception クラスから派生した子クラスの中でアクセス可能です。

    例1 組み込みの例外クラス

    <?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
    }
    ?>

    クラスが、組み込みの Exception クラスを拡張し、 コンストラクタを再定義した場合、 全ての利用可能なデータが正しく代入されることを保証するために parent::__construct() もコールすることが強く推奨されます。 __toString() メソッドは、 オブジェクトが文字列として表された際に独自の出力を行うために 上書きすることができます。

    注意:

    例外を複製することはできません。Exception を clone しようとすると 致命的な E_ERROR エラーが発生します。

    例2 例外クラスを拡張する

    <?php
    /**
    * カスタム例外クラスを定義する
    */
    class MyException extends Exception
    {
    // 例外を再定義し、メッセージをオプションではなくする
    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";
    }
    }


    /**
    * 例外をテストするためのクラスを作成
    */
    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";
    ?>

    Found A Problem?

    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
    15 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
    10 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