PHP try catch: İstisna Yakalama, finally ve Throwable

PHP'de başarısız olabilecek kodu try { ... } içine koyar ve başarısızlığı catch (Exception $e) { ... } içinde ele alırsınız. try bloğundaki herhangi bir şey hata fırlatırsa PHP doğrudan eşleşen catch bloğuna atlar ve $e->getMessage() neyin yanlış gittiğini söyler. Hiçbir şey fırlatılmazsa catch bloğu atlanır.

<?php
function divide(int $a, int $b): float
{
    if ($b === 0) {
        throw new InvalidArgumentException('Cannot divide by zero');
    }
    return $a / $b;
}

try {
    echo divide(10, 4), "\n";
    echo divide(10, 0), "\n";      // exception: the next line never runs
    echo "not printed\n";
} catch (InvalidArgumentException $e) {
    echo 'Error: ', $e->getMessage(), "\n";
}

echo "The script keeps going\n";

divide(10, 0) ifadesini divide(10, 5) yapın ve tekrar çalıştırın: istisna olmaz, bu yüzden not printed yazdırılır ve catch bloğu atlanır. try olmasaydı istisna betiği ölümcül bir "Uncaught" hatasıyla bitirirdi. Kendi istisnalarınızı fırlatmak ve istisna sınıfları yazmak istisnalar sayfasında.

try catch söz dizimi

Tam biçimin üç parçası vardır. Yalnızca try ile birlikte en az bir catch veya bir finally zorunludur:

try {
    // code that may throw
} catch (SomeException $e) {
    // runs if SomeException (or a subclass) was thrown
} catch (OtherException | ThirdException $e) {
    // runs for either of these types
} finally {
    // always runs, thrown or not
}

catch içindeki tür neyi yakalayacağını belirler: sınıfın kendisini ve onu genişleten her sınıfı. PHP 8.0'dan beri ihtiyacınız olmadığında değişken isteğe bağlıdır: catch (JsonException) { ... }.

Exception, Error ve Throwable yakalama

PHP 7'den beri PHP'nin kendisinin tespit ettiği başarısızlıklar (olmayan bir metodu çağırmak, yanlış bir argüman türü, sıfıra bölme) Exception değil Error fırlatır ve PHP 8 eski uyarıların birçoğunu TypeError ve ValueError hatalarına çevirdi. İkisi de Throwable arayüzünü uygular ama hiçbiri diğerini genişletmez, bu yüzden catch (Exception $e) bir Error yakalamaz:

Throwable
├── Exception                 (problems a program expects and handles)
│   ├── InvalidArgumentException, RuntimeException, JsonException, ...
└── Error                     (engine errors, usually a bug in the code)
    ├── TypeError
    ├── ValueError
    ├── ArithmeticError
    │   └── DivisionByZeroError
    └── UnhandledMatchError, ...

Her sorunu hangi catch bloğunun ele aldığını görmek için bunu çalıştırın:

<?php
$problems = [
    'divide by zero' => fn () => 10 % 0,
    'wrong type'     => fn () => strlen([]),
    'bad value'      => fn () => str_repeat('x', -1),
    'missing method' => fn () => (new stdClass())->save(),
    'own exception'  => fn () => throw new RuntimeException('disk full'),
];

foreach ($problems as $label => $run) {
    try {
        $run();
    } catch (Exception $e) {
        echo "$label: caught as Exception (", get_class($e), ")\n";
    } catch (Error $e) {
        echo "$label: caught as Error (", get_class($e), ")\n";
    }
}

Peki hangisini yakalamalısınız?

• Neyin yanlış gidebileceğini ve ne yapılacağını bildiğinizde catch (SomeSpecificException $e). Kodların çoğu böyledir.
• "Bir kütüphanenin veya kodumun bilerek fırlattığı her şey" için catch (Exception $e).
• En dış seviyede (bir istek işleyici, bir iş çalıştırıcı) PHP'nin kendi hataları dahil her başarısızlığı loglamak ve dostça bir mesaj göstermek için catch (Throwable $e).

Birden çok istisna türünü yakalama

Farklı türleri farklı şekilde ele almak için birkaç catch bloğu yazın. PHP onları yukarıdan aşağıya dener ve ilk eşleşmeyi kullanır, bu yüzden belirli bir tür kendi üst sınıfından önce gelmelidir, yoksa üst sınıf önce her şeyi yakalar. Birkaç tür aynı muameleyi gördüğünde onları | ile tek bir catch içinde birleştirin:

<?php
function loadUser(mixed $id): array
{
    if (!is_int($id)) {
        throw new InvalidArgumentException("ID must be an integer, got " . get_debug_type($id));
    }
    if ($id < 1) {
        throw new DomainException("ID must be positive, got $id");
    }
    if ($id > 100) {
        throw new OutOfBoundsException("No user with ID $id");
    }
    return ['id' => $id, 'name' => 'User ' . $id];
}

foreach ([7, 'abc', -5, 500] as $id) {
    try {
        $user = loadUser($id);
        echo "Found {$user['name']}\n";
    } catch (OutOfBoundsException $e) {
        echo "404: {$e->getMessage()}\n";
    } catch (InvalidArgumentException | DomainException $e) {
        echo '400: ', $e->getMessage(), ' (', get_class($e), ")\n";
    }
}

Üç sınıf da Exception sınıfını genişletir, bu yüzden tek bir catch (Exception $e) de onları yakalardı, ama o zaman kod birine 404, diğerlerine 400 yanıtı veremezdi.

finally: her zaman çalışan kod

Bir finally bloğu, try ve catch nasıl biterse bitsin onlardan sonra çalışır: normal olarak, yakalanan bir istisnayla, kimsenin yakalamadığı bir istisnayla ya da bir return ile. try bloğunun edindiği her şeyi bırakmanın yeridir: bir dosyayı kapatmak, bir kilidi serbest bırakmak, bir zamanlayıcıyı durdurmak.

<?php
function process(string $file): string
{
    $handle = fopen($file, 'w');
    echo "opened $file\n";
    try {
        fwrite($handle, "data\n");
        if ($file === 'bad.txt') {
            throw new RuntimeException('write check failed');
        }
        return 'saved';           // finally still runs before returning
    } finally {
        fclose($handle);
        echo "closed $file\n";
    }
}

echo process('good.txt'), "\n\n";

try {
    echo process('bad.txt'), "\n";
} catch (RuntimeException $e) {
    echo 'Failed: ', $e->getMessage(), "\n";
}

good.txt için dosya saved yazdırılmadan önce kapanır, çünkü finally fonksiyon gerçekten dönmeden önce çalışır. bad.txt için process() içinde catch yoktur: finally dosyayı kapatır, sonra istisna çağıranın catch bloğuna kadar devam eder.

finally içinde return kullanmaktan kaçının: try bloğunun döndürdüğü değeri değiştirir ve dışarı çıkmakta olan bir istisnayı sessizce yok eder:

function f(): string
{
    try {
        return 'from try';
    } finally {
        return 'from finally';
    }
}

function g(): string
{
    try {
        throw new RuntimeException('lost');
    } finally {
        return 'no exception reaches the caller';
    }
}

echo f(); // from finally
echo g(); // no exception reaches the caller

Bir istisnayı yeniden fırlatma veya sarmalama

Bazen bir catch bloğu bir sorunu yalnızca kısmen ele alabilir: loglar, temizler, sonra devam etmesine izin verir. throw $e; aynı istisnayı yeniden fırlatır. Daha sık olarak orijinal nedeni koruyarak bağlam eklemek istersiniz; üçüncü yapıcı argümanı $previous bunun içindir:

<?php
class ConfigException extends RuntimeException {}

function readConfig(string $json): array
{
    try {
        return json_decode($json, true, flags: JSON_THROW_ON_ERROR);
    } catch (JsonException $e) {
        // Wrap: a clearer message, the original kept as "previous"
        throw new ConfigException('config.json is not valid JSON', 0, $e);
    }
}

try {
    print_r(readConfig('{"debug": true}'));
    readConfig('{"debug": true,}');
} catch (ConfigException $e) {
    echo $e->getMessage(), "\n";
    echo 'Caused by: ', get_class($e->getPrevious()), ': ', $e->getPrevious()->getMessage(), "\n";
}

Çağıran tek bir ConfigException ile uğraşır ve yapılandırmanın JSON olduğunu bilmesi gerekmez; getPrevious() ise düşük seviyeli ayrıntıyı log için saklar.

Yakalanmamış istisnalar ve global bir işleyici

Hiçbir catch bloğunun ele almadığı bir istisna betiği sınıfı, mesajı, dosyayı ve satırı ve bir yığın izini içeren ölümcül bir hatayla bitirir:

<?php
// No try/catch anywhere in this file
function charge(int $cents): void
{
    if ($cents <= 0) {
        throw new DomainException("Amount must be positive, got $cents");
    }
}

charge(500);
echo "first charge ok\n";
charge(-1);
echo "never printed\n";

PHP first charge ok yazdırır ve ardından:

PHP Fatal error:  Uncaught DomainException: Amount must be positive, got -1 in /home/index.php:6
Stack trace:
#0 /home/index.php(12): charge()
#1 {main}
  thrown in /home/index.php on line 6

Canlı bir sitede bu mesaj ziyaretçilere asla ulaşmamalıdır. set_exception_handler() kimsenin yakalamadığı her istisnayı alan bir fonksiyon kaydeder; onu loglamak ve kibar bir sayfa yazdırmak için tek bir yer:

<?php
set_exception_handler(function (Throwable $e) {
    // In production: write $e to a log file here
    echo "<h1>Something went wrong</h1>\n";
    echo "<p>We have been notified. Please try again later.</p>\n";
    echo '<!-- ', get_class($e), ': ', htmlspecialchars($e->getMessage()), " -->\n";
});

echo "<p>Loading your dashboard...</p>\n";
throw new RuntimeException('Database timeout');

İşleyici çalışır ve ardından betik durur; throw sonrasında devam etmenin yolu yoktur. PHP'nin kendi hata metninin sayfada gösterilip gösterilmeyeceğini hata raporlama sayfasında anlatılan display_errors belirler.

Uyarılar istisna değildir

try/catch yalnızca fırlatılan şeyleri görür. Birçok eski PHP fonksiyonu hata fırlatmaz: false veya null döndürür ve en fazla bir uyarı yazdırır. json_decode() tipik bir örnektir ve siz ondan hata fırlatmasını isteyene kadar onu try ile sarmak hiçbir şeyi değiştirmez:

<?php
$broken = '{"name": "Ada",}';

try {
    $data = json_decode($broken, true);
    var_dump($data);                    // NULL, and no exception
    echo 'Error: ', json_last_error_msg(), "\n";
} catch (JsonException $e) {
    echo "never reached\n";
}

try {
    $data = json_decode($broken, true, flags: JSON_THROW_ON_ERROR);
} catch (JsonException $e) {
    echo 'Caught: ', $e->getMessage(), "\n";
}

Böyle bir bayrağı olmayan fonksiyonlarda dönüş değerini kontrol edin (if ($handle === false)) ya da önce ön koşulu kontrol edin (file_exists(), isset()). ErrorException fırlatan bir set_error_handler(), her şey için tek bir kural istiyorsanız her uyarıyı gerçek bir istisnaya çevirir.

Tarif: form girdisini istisnalarla doğrulama

Pratik bir kalıp: doğrulama fonksiyonları hata fırlatır, sayfa onu yakalar ve mesajı formun yanında gösterir. Çalıştırın, sonra forma bir yaş yazın ve Send düğmesine basın: aynı betik $_POST doldurulmuş olarak yeniden çalışır.

<?php
function validAge(string $raw): int
{
    if (trim($raw) === '') {
        throw new InvalidArgumentException('Please enter your age.');
    }
    $age = filter_var($raw, FILTER_VALIDATE_INT);
    if ($age === false) {
        throw new InvalidArgumentException('Age must be a whole number.');
    }
    if ($age < 13) {
        throw new RangeException('You must be at least 13 to sign up.');
    }
    return $age;
}

$raw = $_POST['age'] ?? '';
$message = '';

if (($_SERVER['REQUEST_METHOD'] ?? 'GET') === 'POST') {
    try {
        $age = validAge($raw);
        $message = "<p style=\"color:green\">Welcome, age $age accepted.</p>";
    } catch (InvalidArgumentException | RangeException $e) {
        $message = '<p style="color:red">' . htmlspecialchars($e->getMessage()) . '</p>';
    }
}
?>
<form method="post">
    <label>Age <input name="age" value="<?= htmlspecialchars($raw) ?>"></label>
    <button>Send</button>
</form>
<?= $message ?>

Boş bir alanı, twelve, 9 ve 30 değerlerini deneyin. Başarısız olan her kural kendi mesajıyla hata fırlatır ve tek bir catch hepsini aynı kırmızı satıra çevirir. Formlar sayfası bunun üzerine birkaç alan ve her birinin yanında hatalarla inşa eder.