Extender las Excepciones

    Una clase de excepción definida por el usuario puede ser definida extendiendo la clase Exception integrada. Los miembros y las propiedades a continuación muestran lo que es accesible en la clase hija que deriva de la clase Exception integrada.

    Ejemplo #1 La clase de excepción integrada

    <?php
    class Exception implements Throwable
    {
    protected     $message = 'Unknown exception'; // Mensaje de excepción
    private $string; // caché de __toString
    protected $code = 0; // código de excepción definido por el usuario
    protected $file; // nombre de fichero fuente de la excepción
    protected $line; // línea fuente de la excepción
    private $trace; // traza de la pila de ejecución
    private $previous; // excepción previa si excepción anidada

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

    final private function     __clone(); // Inhibe la duplicación de excepciones.

    final public function getMessage(); // mensaje de la excepción
    final public function getCode(); // código de la excepción
    final public function getFile(); // nombre del fichero fuente
    final public function getLine(); // línea fuente
    final public function getTrace(); // array de la traza de la pila de ejecución
    final public function getPrevious(); // la excepción previa
    final public function getTraceAsString(); // traza en forma de string

    // Puede ser redefinida
    public function __toString(); // string formateada para la visualización
    }
    ?>

    Si una clase extiende la clase Exception integrada y redefine el constructor, se recomienda encarecidamente que también llame a parent::__construct() para asegurarse de que todos los datos disponibles hayan sido correctamente asignados. La función __toString() puede ser redefinida para proporcionar una salida personalizada cuando el objeto es presentado en forma de string.

    Nota:

    Las excepciones no pueden ser clonadas. Intentar clonar una Exception resultará en un error fatal E_ERROR.

    Ejemplo #2 Extender la clase Exception

    <?php
    /**
    * Define una clase de excepción personalizada.
    */
    class MyException extends Exception
    {
    // Redefine la excepción para que el mensaje no sea opcional.
    public function __construct($message, $code = 0, ?Throwable $previous = null) {
    // código

    // asegurarse de que todo esté correctamente asignado
    parent::__construct($message, $code, $previous);
    }

    // Representación personalizada del objeto en forma de string.
    public function __toString() {
    return     __CLASS__ . ": [{$this->code}]: {$this->message}\n";
    }

    public function     customFunction() {
    echo     "Una función personalizada para este tipo de excepción\n";
    }
    }

    /**
    * Crear una clase para probar la excepció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:
    // Lanza una excepción personalizada
    throw new MyException('1 no es un parámetro válido', 5);
    break;

    case     self::THROW_DEFAULT:
    // Lanza la predeterminada.
    throw new Exception('2 no está permitido como parámetro', 6);
    break;

    default:
    // Ninguna excepción, el objeto será creado.
    $this->var = $avalue;
    break;
    }
    }
    }

    // Ejemplo 1
    try {
    $o = new TestException(TestException::THROW_CUSTOM);
    } catch (    MyException $e) { // Será capturada
    echo "MyException capturada\n", $e;
    $e->customFunction();
    } catch (    Exception $e) { // Ignorada
    echo "Excepción predeterminada capturada\n", $e;
    }

    // Continuar la ejecución
    var_dump($o); // Null
    echo "\n\n";

    // Ejemplo 2
    try {
    $o = new TestException(TestException::THROW_DEFAULT);
    } catch (    MyException $e) { // No coincide con este tipo
    echo "MyException capturada\n", $e;
    $e->customFunction();
    } catch (    Exception $e) { // Será capturada
    echo "Excepción predeterminada capturada\n", $e;
    }

    // Continuar la ejecución
    var_dump($o); // Null
    echo "\n\n";

    // Ejemplo 3
    try {
    $o = new TestException(TestException::THROW_CUSTOM);
    } catch (    Exception $e) { // Será capturada
    echo "Excepción predeterminada capturada\n", $e;
    }

    // Continuar la ejecución
    var_dump($o); // Null
    echo "\n\n";

    // Ejemplo 4
    try {
    $o = new TestException();
    } catch (    Exception $e) { // Saltada, ninguna excepción
    echo "Excepción predeterminada capturada\n", $e;
    }

    // Continuar la ejecución
    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 5 notes

    up
    16
    iamhiddensomewhere at gmail dot com
    15 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
    6 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).
    ＋add a note
    To Top