0Pricing
PHP Academy · Lektion

Benutzerdefinierte Exceptions erstellen

Erweitern Sie die Klasse Exception, um domänenspezifische Fehlertypen zu erstellen.

Benutzerdefinierte Exceptions erstellen ist eine kostenlose PHP Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des PHP Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der PHP Academy-Kurs umfasst insgesamt 4 Lektionen.

Warum benutzerdefinierte Ausnahmen?

Benutzerdefinierte Ausnahmen ermöglichen Ihnen:

  • Die Fehler Ihrer Anwendung von allgemeinen PHP-Fehlern zu unterscheiden
  • Domänenspezifische Daten mitzuführen (Bestell-ID, Benutzer-ID usw.)
  • Auf verschiedenen Ebenen bestimmte Fehlertypen abzufangen
  • Aussagekräftige, selbstdokumentierende Fehlerhierarchien zu erstellen

Exception erweitern

Erstellen Sie eine benutzerdefinierte Ausnahme, indem Sie die Basisklasse Exception erweitern:

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

Benutzerdefinierte Ausnahme verwenden

Lösen Sie Ihre benutzerdefinierte Ausnahme aus und fangen Sie sie ab:

<?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 einer Ausnahmehierarchie

Entwerfen Sie eine Hierarchie für Ihre 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");
    }
}

Nach Hierarchie abfangen

Fangen Sie eine Basisklasse ab, um alle davon abgeleiteten Ausnahmen zu behandeln:

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

Ausnahmen um Kontext ergänzen

Ergänzen Sie Ausnahmen um zusätzliche Daten zur Fehlersuche:

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

Beispiel für eine HTTP-Ausnahme

Verwendung der HTTP-Ausnahme in einer Webanwendung:

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

Interface-basierte Ausnahmen

Verwenden Sie Interfaces, um nicht verwandte Ausnahme-Klassen zu gruppieren:

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

Muster für benannte Konstruktoren

Verwenden Sie statische Factory-Methoden für häufige Ausnahmeszenarien:

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

Ausnahmen serialisieren

Wandeln Sie Ausnahmedaten für die Protokollierung oder API-Antworten in ein Array um:

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

Bewährte Vorgehensweisen für benutzerdefinierte Ausnahmen

Richtlinien für den Entwurf benutzerdefinierter Ausnahmen:

  • Erweitern Sie RuntimeException für unerwartete Bedingungen
  • Erweitern Sie LogicException für Programmierfehler (ungültige Argumente)
  • Erstellen Sie nicht für jede mögliche Meldung eine eigene Ausnahme-Klasse — verwenden Sie stattdessen Codes
  • Halten Sie die Namen von Ausnahme-Klassen in PascalCase und lassen Sie sie mit Exception enden
  • Dokumentieren Sie, welche Ausnahmen jede Methode auslösen kann

Kurze Überprüfung

Welche PHP-Basisklasse sollten Sie erweitern, um eine benutzerdefinierte Ausnahme zu erstellen, die einen logischen Fehler in Ihrem Code darstellt?

Zusammenfassung: Benutzerdefinierte Ausnahmen

Zusammenfassung der benutzerdefinierten Ausnahmen:

  • Exception oder eine davon abgeleitete Klasse erweitern
  • Domänenspezifische Eigenschaften und Methoden hinzufügen
  • Hierarchien entwerfen — die Elternklasse abfangen, um alle Kindklassen abzufangen
  • Interfaces verwenden, um nicht verwandte Ausnahmen zu gruppieren
  • Statische benannte Konstruktoren für mehr Klarheit verwenden
  • Immer parent::__construct() aufrufen

Häufig gestellte Fragen

Ist die Lektion „Benutzerdefinierte Exceptions erstellen“ kostenlos?

Ja — der vollständige Text von „Benutzerdefinierte Exceptions erstellen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des PHP Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der PHP Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Benutzerdefinierte Exceptions erstellen“?

Erweitern Sie die Klasse Exception, um domänenspezifische Fehlertypen zu erstellen. Du übst PHP Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um PHP Academy zu starten?

Keine Vorkenntnisse erforderlich. PHP Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Benutzerdefinierte Exceptions erstellen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser PHP Academy-Lektion Code schreiben und ausführen?

Ja. Jede PHP Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. PHP-Fehlertypen und Fehlerberichterstattung
  2. Try, Catch und Finally
  3. Benutzerdefinierte Exceptions erstellen
  4. Fehler protokollieren und Best Practices
← Zurück zu PHP Academy