Ловля кількох типів винятків в одному блоці вилову

Я хотів би більш чіткий спосіб отримати наступну функціональність, щоб зловити AErrorі BErrorв одному блоці:

try
{
    /* something */
}
catch( AError, BError $e )
{
    handler1( $e )
}
catch( Exception $e )
{
    handler2( $e )
}

Чи можна це зробити? Або я повинен їх ловити окремо?

AErrorі Berrorмають спільний базовий клас, але вони також діляться ним з іншими типами, до яких я хотів би потрапити handler2, тому я не можу просто спіймати базовий клас.

Оновлення:

Станом на PHP 7.1, це доступно.

Синтаксис:

try
{
    // Some code...
}
catch(AError | BError $e)
{
    // Handle exceptions
}
catch(Exception $e)
{
    // Handle the general case
}

Документи: https://www.php.net/manual/en/language.exceptions.php#example-287

RFC: https://wiki.php.net/rfc/multiple-catch

Звернутись: https://github.com/php/php-src/commit/0aed2cc2a440e7be17552cc669d71fdd24d1204a

Для PHP до 7.1:

Незважаючи на те, що ці відповіді кажуть, ви можете зловити AErrorі BErrorв одному блоці (дещо легше, якщо ви визначаєте винятки). Навіть враховуючи, що є винятки, через які ви хочете "провалитися", ви все одно можете мати змогу визначити ієрархію відповідно до ваших потреб.

abstract class MyExceptions extends Exception {}

abstract class LetterError extends MyExceptions {}

class AError extends LetterError {}

class BError extends LetterError {}

Тоді:

catch(LetterError $e){
    //voodoo
}

Як ви бачите тут і тут , навіть SPLвинятки за замовчуванням мають ієрархію, яку ви можете використовувати. Додатково, як зазначено в Посібнику PHP :

Коли буде викинуто виняток, код після оператора не буде виконуватися, і PHP спробує знайти перший відповідний блок лову.

Це означає, що ви могли також мати

class CError extends LetterError {}

з якою вам потрібно поводитися інакше, ніж AErrorабо BError, щоб ваша заява на вилов виглядала б так:

catch(CError $e){
    //voodoo
}
catch(LetterError $e){
    //voodoo
}

Якщо у вас був випадок, коли було двадцять і більше винятків, які легітимно належали до одного і того ж суперкласу, і вам потрібно було обробити п’ять (або будь-яку велику іш групу) з них в одну сторону, а решта - в іншу, ви можете ВЖЕ зробити це.

interface Group1 {}

class AError extends LetterError implements Group1 {}

class BError extends LetterError implements Group1 {}

І потім:

catch (Group1 $e) {}

Використання OOP, коли мова йде про винятки, дуже потужне. Використовуючи речі , як get_classі instanceofє хакі, і його слід уникати , якщо це можливо.

Ще одне рішення, яке я хотів би додати, - це введення функціоналу обробки винятків у свій метод.

Можна було

function handleExceptionMethod1(Exception $e)
{
    //voodoo
}

function handleExceptionMethod2(Exception $e)
{
    //voodoo
}

Якщо припустити, що ви абсолютно не можете контролювати ієрархії класів винятків або інтерфейси (і майже завжди буде спосіб), ви можете зробити наступне:

try
{
    stuff()
}
catch(ExceptionA $e)
{
    $this->handleExceptionMethod1($e);
}
catch(ExceptionB $e)
{
    $this->handleExceptionMethod1($e);
}
catch(ExceptionC $e)
{
    $this->handleExceptionMethod1($e);
}
catch(Exception $e)
{
    $this->handleExceptionMethod2($e);
}

Таким чином, у вас все ще є єдине місце розташування коду, яке ви повинні змінити, якщо ваш механізм обробки винятків потребує змін, і ви працюєте в загальних конструкціях OOP.

У PHP> = 7.1 це можливо. Дивіться відповідь нижче.

Якщо ви можете змінити винятки, скористайтеся цією відповіддю .

Якщо ви не можете, можете спробувати зловити всіх, Exceptionа потім перевірити, з яким винятком було кинуто instanceof.

try
{
    /* something */
}
catch( Exception $e )
{
    if ($e instanceof AError OR $e instanceof BError) {
       // It's either an A or B exception.
    } else {
        // Keep throwing it.
        throw $e;
    }
}

Але , мабуть, було б краще використовувати декілька блоків лову, як описано у вищезгаданій відповіді .

try
{
    /* something */
}
catch( AError $e )
{
   handler1( $e );
}
catch ( BError $b )
{
   handler2( $e );
}

Прихід у PHP 7.1 - це можливість ловити кілька типів.

Так що це:

<?php
try {
    /* ... */
} catch (FirstException $ex) {
    $this->manageException($ex);
} catch (SecondException $ex) {
    $this->manageException($ex);
}
?>

і

<?php
try {

} catch (FirstException | SecondException $ex) {
    $this->manageException($ex);
}
?>

є функціонально рівнозначними.

Станом на PHP 7.1,

catch( AError | BError $e )
{
    handler1( $e )
}

що цікаво, ви також можете:

catch( AError | BError $e )
{
    handler1( $e )
} catch (CError $e){
    handler2($e);
} catch(Exception $e){
    handler3($e);
}

і в більш ранніх версіях PHP:

catch(Exception $ex){
    if($ex instanceof AError){
        //handle a AError
    } elseif($ex instanceof BError){
        //handle a BError
    } else {
       throw $ex;//an unknown exception occured, throw it further
    }
}

Ця стаття охоплює питання electrictoolbox.com/php-catch-multiple-exception-types . Вміст публікації скопійовано безпосередньо зі статті:

Приклади винятків

Ось кілька прикладів винятків, визначених для цілей цього прикладу:

class FooException extends Exception 
{
  public function __construct($message = null, $code = 0) 
  {
    // do something
  }
}

class BarException extends Exception 
{
  public function __construct($message = null, $code = 0) 
  {
    // do something
  }
}

class BazException extends Exception 
{
  public function __construct($message = null, $code = 0) 
  {
    // do something
  }
}

Поводження з кількома винятками

Це дуже просто - може бути блок вилову для кожного типу винятків, який можна кинути:

try 
{
  // some code that might trigger a Foo/Bar/Baz/Exception
}

catch(FooException $e) 
{
  // we caught a foo exception
}

catch(BarException $e) 
{
  // we caught a bar exception
}

catch(BazException $e) 
{
  // we caught a baz exception
}

catch(Exception $e) 
{
  // we caught a normal exception
  // or an exception that wasn't handled by any of the above
}

Якщо буде викинуто виняток, який не обробляється жодною з інших заяв про вилов, він буде оброблятися блоком catch (Виняток $ e). Це не обов'язково має бути останнім.

Як розширення до прийнятої відповіді, ви можете переключити тип винятку, що призведе до шаблону, який приблизно нагадує оригінальний приклад:

try {

    // Try something

} catch (Exception $e) {

    switch (get_class($e)) {

        case 'AError':
        case 'BError':
            // Handle A or B
            break;

        case 'CError':
            // Handle C
            break;

        case default:
            // Rethrow the Exception
            throw $e;

    }

}

Ось розумна альтернатива, якщо ви не маєте контролю над визначенням винятків. Використовуйте ім’я змінної винятку, щоб класифікувати винятки, коли вони потрапляють. Потім перевірте наявність змінної виключення після блоку спробувати.

$ABError = null;
try {
    // something
} catch (AError $ABError) {  // let the exception fall through
} catch (BError $ABError) {  // let the exception fall through
} catch (Exception $e) {
    handler2($e);
}
if ($ABError) {
    handler1($ABError);
}

Цей дещо дивний підхід, мабуть, вартий лише тоді, коли існує багато дублювання між реалізацією блоку лову.

Окрім пропуску, також можна переступити за допомогою goto . Це дуже корисно, якщо ви хочете бачити, як горить світ.

<?php

class A_Error extends Exception {}
class B_Error extends Exception {}
class C_Error extends Exception {}

try {
    throw new A_Error();
} 
catch (A_Error $e) { goto abc; }
catch (B_Error $e) { goto abc; }
catch (C_Error $e) {
abc:
    var_dump(get_class($e));
    echo "Gotta Catch 'Em All\n";
}

3v4l.org

Прекрасний спосіб - використовувати set_exception_handler.

Увага!!! за допомогою PHP 7 ви можете отримати білий екран смерті за фатальні помилки. Наприклад, якщо ви викликаєте метод на об'єкт, який ви зазвичай отримуєте, Fatal error: Call to a member function your_method() on nullі ви очікуєте, що це з’явиться, якщо ввімкнено повідомлення про помилки.

Вищезгадана помилка НЕ ​​буде усунена catch(Exception $e). Вищевказана помилка НЕ ​​запустить жодного користувальницького обробника помилок, встановленого set_error_handler.

Ви повинні використовувати catch(Error $e){ }для вибору помилок у PHP7. . Це може допомогти:

class ErrorHandler{
    public static function excep_handler($e)
    {
        print_r($e);
    }
}
set_exception_handler(array('ErrorHandler','excep_handler'));

Ще один варіант, не вказаний тут, - це використовувати codeатрибут винятку, тому ви можете зробити щось подібне:

try {

    if (1 === $foo) {

         throw new Exception(sprintf('Invalid foo: %s', serialize($foo)), 1);
    }

    if (2 === $bar) {
        throw new Exception(sprintf('Invalid bar: %s', serialize($foo)), 2);
    }
} catch (Exception $e) {

    switch ($e->getCode()) {

        case 1:
            // Special handling for case 1
            break;

        case 2:
            // Special handling for case 2
            break;

        default:

            // Special handling for all other cases
    }
}

Гм, існує багато рішень, написаних для версії php нижче 7,1.

Ось ще один простий для тих, хто не хоче спіймати всі винятки і не може створити загальні інтерфейси:

<?php
$ex = NULL
try {
    /* ... */
} catch (FirstException $ex) {
    // just do nothing here
} catch (SecondException $ex) {
    // just do nothing here
}
if ($ex !== NULL) {
    // handle those exceptions here!
}
?>