PHP Academy · Lektion

Try, Catch och Finally

Hantera undantag under körning på ett robust sätt med blocken try/catch/finally.

Lektion 2 av 413 steg

Try, Catch och Finally är en gratis lektion i PHP Academy på CoddyKit. Detta är lektion 2 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för PHP Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i PHP Academy innehåller totalt 4 lektioner.

Undantag jämfört med fel

PHP har två sätt att signalera problem:

Fel — traditionella PHP-notiser, varningar och fatalfel (som togs upp i föregående lektion)
Undantag — objekt som kastas när något exceptionellt inträffar och fångas med try/catch

Undantag är det moderna och rekommenderade sättet att hantera återställningsbara fel.

Kasta ett undantag

Använd throw för att signalera att något gick fel:

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

echo divide(10, 2);   // 5
// divide(10, 0);     // throws exception

try-/catch-block

Omslut kod som kan kasta undantag med try och hantera undantagen i catch:

<?php
try {
    $result = divide(10, 0);
    echo $result;
} catch (InvalidArgumentException $e) {
    echo 'Error: ' . $e->getMessage();
    echo ' in ' . $e->getFile() . ':' . $e->getLine();
}

Flera catch-block

Fånga olika undantagstyper i separata catch-block:

<?php
try {
    $pdo = new PDO($dsn, $user, $pass);
    $result = performQuery($pdo);
} catch (PDOException $e) {
    error_log('DB error: ' . $e->getMessage());
    echo 'Database unavailable';
} catch (RuntimeException $e) {
    echo 'Runtime error: ' . $e->getMessage();
} catch (\Throwable $e) {
    echo 'Unexpected error: ' . $e->getMessage();
}

finally-block

finally körs oavsett om ett undantag kastades eller inte — perfekt för rensning:

<?php
$connection = null;
try {
    $connection = openDatabaseConnection();
    $data = fetchData($connection);
} catch (DatabaseException $e) {
    error_log($e->getMessage());
    echo 'DB error';
} finally {
    // Always runs — even if exception was thrown
    if ($connection) {
        closeConnection($connection);
    }
}

Undantagshierarki

PHP:s hierarki för undantagsklasser:

Throwable (gränssnitt)
├─ Error — fel i PHP-motorn (TypeError, ParseError …)
└─ Exception — undantag i applikationen
├─ RuntimeException
├─ InvalidArgumentException
├─ LogicException
└─ PDOException

Fånga Throwable

Fånga både undantag och PHP-fel med Throwable:

<?php
try {
    $result = someFunction();
} catch (\Exception $e) {
    echo 'Exception: ' . $e->getMessage();
} catch (\Error $e) {
    echo 'PHP Error: ' . $e->getMessage();
}

// Or catch both at once:
try {
    // ...
} catch (\Throwable $e) {
    echo get_class($e) . ': ' . $e->getMessage();
}

Union-catch (PHP 8)

PHP 8 gör det möjligt att fånga flera undantagstyper i ett och samma catch-block:

<?php
try {
    processRequest();
} catch (InvalidArgumentException | RuntimeException $e) {
    echo 'Handled: ' . $e->getMessage();
}

// Compare PHP 7 approach:
// catch (InvalidArgumentException $e) { ... }
// catch (RuntimeException $e) { ... }

Kasta om undantag

Fånga, logga och kasta om ett undantag så att det förs vidare upp genom anropsstacken:

<?php
function processOrder(int $id): void {
    try {
        $order = loadOrder($id);
        $order->process();
    } catch (PaymentException $e) {
        error_log('Payment failed for order ' . $id . ': ' . $e->getMessage());
        throw $e;  // re-throw after logging
    }
}

Kedja undantag

Skicka med det ursprungliga undantaget som 'previous' för att bevara kontexten:

<?php
try {
    $data = fetchFromAPI();
} catch (NetworkException $e) {
    throw new ServiceUnavailableException(
        'Cannot reach upstream service',
        0,
        $e  // $previous — preserves original cause
    );
}

// Retrieve original:
// $e->getPrevious()

set_exception_handler

Registrera en global hanterare för undantag som inte fångats:

<?php
set_exception_handler(function(\Throwable $e): void {
    error_log(sprintf(
        '[UNCAUGHT] %s: %s in %s:%d',
        get_class($e),
        $e->getMessage(),
        $e->getFile(),
        $e->getLine()
    ));
    http_response_code(500);
    echo 'An unexpected error occurred. Please try again.';
    exit(1);
});

Snabbtest

Vilket block i try/catch/finally garanteras att köras oavsett om ett undantag kastas eller inte?

Besvara frågan i den interaktiva lektionen

Sammanfattning: try/catch/finally

Sammanfattning av undantagshantering:

Kasta undantag med throw new ExceptionClass()
Fånga undantag med catch (Type $e)
Använd flera catch-block för olika typer
finally körs alltid — använd det för rensning
Union-catch i PHP 8: catch (A | B $e)
Kasta om undantag för att bevara kontexten i anropsstacken

Gratis att börja

Lär dig PHP med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 49
Lektioner: 195

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Try, Catch och Finally” gratis?

Ja – hela texten till ”Try, Catch och Finally” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i PHP Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i PHP Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Try, Catch och Finally”?

Hantera undantag under körning på ett robust sätt med blocken try/catch/finally. Ni övar på PHP Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig PHP Academy?

Du behöver inga förkunskaper. Utbildningen i PHP Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.

Hur lång tid tar lektionen ”Try, Catch och Finally”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här PHP Academy-lektionen?

Ja. Varje PHP Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till PHP Academy