PHP Academy · Lektion

Oprettelse af brugerdefinerede undtagelser

Udvid Exception-klassen for at opbygge domænespecifikke fejltyper.

Lektion 3 af 413 trin

Oprettelse af brugerdefinerede undtagelser er en gratis PHP Academy-lektion på CoddyKit. Dette er lektion 3 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i PHP Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. PHP Academy-kurset indeholder 4 lektioner i alt.

Hvorfor bruge tilpassede undtagelser?

Tilpassede undtagelser giver dig mulighed for at:

Skelne mellem fejl i din applikation og generiske PHP-fejl
Medtage domænespecifikke data (ordre-id, bruger-id osv.)
Indfange specifikke fejltyper på forskellige lag
Oprette meningsfulde og selvforklarende fejlhierarkier

Udvidelse af Exception

Opret en tilpasset undtagelse ved at udvide basisklassen Exception:

<?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;
    }
}

Brug af en tilpasset undtagelse

Udløs og indfang din tilpassede undtagelse:

<?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;
    }
}

Design af undtagelseshierarki

Design et hierarki til dit domæne:

<?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");
    }
}

Håndtering efter hierarki

Indfang en basisklasse for at håndtere alle afledte undtagelser:

<?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);
}

Tilføjelse af kontekst til undtagelser

Berig undtagelser med yderligere data til fejlsøgning:

<?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;
    }
}

Eksempel på HTTP-undtagelse

Brug af HTTP-undtagelsen i en webapplikation:

<?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()]);
}

Grænsefladebaserede undtagelser

Brug grænseflader til at gruppere indbyrdes uafhængige undtagelsesklasser:

<?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();
}

Mønsteret med navngivne konstruktører

Brug statiske fabriksmetoder til almindelige undtagelsesscenarier:

<?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);

Serialisering af undtagelser

Konvertér undtagelsesdata til et array til logning eller svar fra API'er:

<?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,
    ];
}

Bedste praksis for tilpassede undtagelser

Retningslinjer for design af tilpassede undtagelser:

Udvid RuntimeException ved uventede tilstande
Udvid LogicException ved programmeringsfejl (ugyldige argumenter)
Opret ikke en undtagelsesklasse for enhver mulig meddelelse — brug i stedet koder
Brug PascalCase til navne på undtagelsesklasser, og lad dem slutte på Exception
Dokumentér, hvilke undtagelser hver metode kan udløse

Hurtigtjek

Hvilken PHP-basisklasse skal du udvide for at oprette en tilpasset undtagelse, der repræsenterer en logisk fejl i din kode?

Besvar den i den interaktive lektion

Opsummering: Tilpassede undtagelser

Opsummering af tilpassede undtagelser:

Udvid Exception eller en underklasse
Tilføj domænespecifikke egenskaber og metoder
Design hierarkier — indfang forælderen for at indfange alle underklasser
Brug grænseflader til at gruppere indbyrdes uafhængige undtagelser
Brug statiske navngivne konstruktører for tydelighed
Kald altid parent::__construct()

Gratis at komme i gang

Lær PHP med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 49
Lektioner: 195

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Oprettelse af brugerdefinerede undtagelser” gratis?

Ja — hele teksten til “Oprettelse af brugerdefinerede undtagelser” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af PHP Academy-kurset, skal du opgradere til CoddyKit PRO. PHP Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Oprettelse af brugerdefinerede undtagelser”?

Udvid Exception-klassen for at opbygge domænespecifikke fejltyper. Du øver dig i PHP Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på PHP Academy?

Der kræves ingen tidligere erfaring. PHP Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 3 af 4.

Hvor lang tid tager lektionen “Oprettelse af brugerdefinerede undtagelser”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne PHP Academy-lektion?

Ja. Alle PHP Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

PHP-fejltyper og rapportering
Try, catch og finally
Oprettelse af brugerdefinerede undtagelser
Fejllogning og bedste praksis

← Tilbage til PHP Academy