PHP Academy · Les

Aangepaste uitzonderingen maken

Breid de klasse Exception uit om domeinspecifieke fouttypen te maken.

Les 3 van 413 stappen

Aangepaste uitzonderingen maken is een gratis PHP Academy-les op CoddyKit. Dit is les 3 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject PHP Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus PHP Academy bevat in totaal 4 lessen.

Waarom aangepaste uitzonderingen?

Met aangepaste uitzonderingen kun je:

Fouten van je toepassing onderscheiden van algemene PHP-fouten
Domeinspecifieke gegevens bevatten (bestel-ID, gebruikers-ID enzovoort)
Specifieke fouttypen op verschillende lagen opvangen
Betekenisvolle, zichzelf documenterende hiërarchieën van fouten maken

Exception uitbreiden

Maak een aangepaste uitzondering door de basisklasse Exception uit te breiden:

<?php
class ValidationException extends \Exception
{
    private array $errors;

    public function __construct(array $errors, string $message = '', int $code = 0)
    {
        $this->errors = $errors;
        parent::__construct($message ?: implode(', ', $errors), $code);
    }

    public function getErrors(): array
    {
        return $this->errors;
    }
}

Een aangepaste uitzondering gebruiken

Werp je aangepaste uitzondering en vang haar op:

<?php
function createUser(array $data): void {
    $errors = [];
    if (empty($data['email'])) $errors[] = 'Email required';
    if (empty($data['name']))  $errors[] = 'Name required';

    if ($errors) {
        throw new ValidationException($errors);
    }
    // save user...
}

try {
    createUser([]);
} catch (ValidationException $e) {
    foreach ($e->getErrors() as $err) {
        echo '- ' . $err . PHP_EOL;
    }
}

Een uitzonderingshiërarchie ontwerpen

Ontwerp een hiërarchie voor je domein:

<?php
// Base exception for your app
class AppException extends \RuntimeException {}

// Domain-specific exceptions
class NotFoundException extends AppException {}
class AuthException extends AppException {}
class PaymentException extends AppException {}

// Specific payment errors
class InsufficientFundsException extends PaymentException {
    public function __construct(public readonly float $balance, public readonly float $required) {
        parent::__construct("Insufficient funds: have $balance, need $required");
    }
}

Opvangen op basis van hiërarchie

Vang een basisklasse op om alle afgeleide uitzonderingen af te handelen:

<?php
try {
    processPayment($order);
} catch (InsufficientFundsException $e) {
    echo 'Low balance: need ' . $e->required;
} catch (PaymentException $e) {
    echo 'Payment failed: ' . $e->getMessage();
} catch (AppException $e) {
    echo 'App error: ' . $e->getMessage();
} catch (\Throwable $e) {
    // Last resort
    error_log($e);
}

Context toevoegen aan uitzonderingen

Verrijk uitzonderingen met extra gegevens om fouten beter te kunnen opsporen:

<?php
class HttpException extends \RuntimeException
{
    public function __construct(
        private int    $statusCode,
        string         $message = '',
        ?\Throwable    $previous = null
    ) {
        parent::__construct($message, $statusCode, $previous);
    }

    public function getStatusCode(): int
    {
        return $this->statusCode;
    }
}

Voorbeeld van een HTTP-uitzondering

De HTTP-uitzondering gebruiken in een webtoepassing:

<?php
try {
    $user = findUserById($id);
    if (!$user) throw new HttpException(404, 'User not found');
    if (!$user->canAccess($resource)) {
        throw new HttpException(403, 'Access denied');
    }
} catch (HttpException $e) {
    http_response_code($e->getStatusCode());
    echo json_encode(['error' => $e->getMessage()]);
}

Uitzonderingen op basis van koppelvlakken

Gebruik koppelvlakken om niet-gerelateerde uitzonderingsklassen te groeperen:

<?php
interface UserFacingException
{
    public function getUserMessage(): string;
}

class ValidationException extends \Exception implements UserFacingException
{
    public function getUserMessage(): string
    {
        return 'Please check your input: ' . $this->getMessage();
    }
}

// In controller:
catch (UserFacingException $e) {
    echo $e->getUserMessage();
}

Patroon voor benoemde constructors

Gebruik statische fabrieksmethoden voor veelvoorkomende uitzonderingsscenario's:

<?php
class OrderException extends \RuntimeException
{
    public static function notFound(int $id): self
    {
        return new self("Order #$id not found", 404);
    }

    public static function alreadyShipped(int $id): self
    {
        return new self("Order #$id already shipped", 409);
    }
}

throw OrderException::notFound($orderId);

Uitzonderingen serialiseren

Zet uitzonderingsgegevens om naar een array voor logboekregistratie of API-antwoorden:

<?php
function exceptionToArray(\Throwable $e): array {
    return [
        'type'    => get_class($e),
        'message' => $e->getMessage(),
        'code'    => $e->getCode(),
        'file'    => $e->getFile(),
        'line'    => $e->getLine(),
        'trace'   => $e->getTraceAsString(),
        'previous' => $e->getPrevious()
            ? exceptionToArray($e->getPrevious())
            : null,
    ];
}

Goede werkwijzen voor aangepaste uitzonderingen

Richtlijnen voor het ontwerpen van aangepaste uitzonderingen:

Breid RuntimeException uit voor onverwachte omstandigheden
Breid LogicException uit voor programmeerfouten (ongeldige argumenten)
Maak niet voor elk mogelijk bericht een uitzonderingsklasse — gebruik in plaats daarvan codes
Gebruik PascalCase voor namen van uitzonderingsklassen en laat ze eindigen op Exception
Documenteer welke uitzonderingen elke methode kan werpen

Korte controle

Welke PHP-basisklasse moet je uitbreiden om een aangepaste uitzondering te maken die een logische fout in je code vertegenwoordigt?

Beantwoord dit in de interactieve les

Samenvatting: aangepaste uitzonderingen

Samenvatting van aangepaste uitzonderingen:

Breid Exception of een subklasse daarvan uit
Voeg domeinspecifieke eigenschappen en methoden toe
Ontwerp hiërarchieën — vang de bovenliggende klasse op om alle onderliggende klassen op te vangen
Gebruik koppelvlakken om niet-gerelateerde uitzonderingen te groeperen
Gebruik statische benoemde constructors voor duidelijkheid
Roep altijd parent::__construct() aan

Gratis beginnen

Leer PHP met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 49
Lessen: 195

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Aangepaste uitzonderingen maken” gratis?

Ja — de volledige tekst van “Aangepaste uitzonderingen maken” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus PHP Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus PHP Academy bevat in totaal 4 lessen.

Wat leer ik in “Aangepaste uitzonderingen maken”?

Breid de klasse Exception uit om domeinspecifieke fouttypen te maken. Je oefent met PHP Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met PHP Academy te beginnen?

Ervaring vooraf is niet nodig. PHP Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.

Hoe lang duurt de les “Aangepaste uitzonderingen maken”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over PHP Academy?

Ja. Elke les over PHP Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar PHP Academy