Arbeiten mit PHP-Attributen: Do's & Don'ts

Attribute in PHP vereinfachen die Codekonfiguration, indem sie es Ihnen ermöglichen, Codeelemente direkt mit Metadaten zu kommentieren, was möglicherweise den Boilerplate in Frameworks wie Laravel reduziert. Allerdings können Attribute wie bei jeder Funktion überbeansprucht oder falsch angewendet werden, was zu unübersichtlichen Controllern und schwieriger zu wartendem Code führt.

In diesem Beitrag untersuchen wir Best Practices für die Verwendung von Attributen auf eine Weise, die die Klarheit des Codes verbessert. Ich werde außerdem eine Tabelle mit „Geboten und Verboten“ mit Beispielen für jeden Vergleich bereitstellen und Szenarien hervorheben, in denen Attribute gut funktionieren – und in denen sie möglicherweise nicht funktionieren.

1. Attribute in PHP verstehen

Hier ist ein kurzes Beispiel für die Definition und Verwendung eines Attributs, um etwas Kontext bereitzustellen:

#[Attribute]
class MyCustomAttribute {
    public function __construct(public string $description) {}
}

#[MyCustomAttribute("This is a test class")]
class MyClass {
    #[MyCustomAttribute("This is a test method")]
    public function myMethod() {}
}

2. Gebote und Verbote: Kurzer Überblick

Hier ist eine Tabelle, die Best Practices und häufige Fallstricke zusammenfasst:

Do’s	Don’ts
Use attributes for standard, repetitive configurations (e.g., HTTP methods, caching).	Don’t overload attributes with complex configurations or conditional logic.
Leverage attributes for metadata rather than core application logic.	Avoid embedding business logic or intricate rules within attributes.
Apply attributes for simple, reusable annotations (e.g., #[Throttle], #[Cache]).	Don’t try to replace Laravel’s route files entirely with attribute-based routing.
Cache attribute-based reflections when possible to improve performance.	Don’t rely solely on attributes for configurations that need flexibility or change often.
Document your attributes, so team members understand their purpose and usage.	Avoid using attributes for configurations where traditional methods work better (e.g., middleware settings).

3. Detaillierte Vergleiche mit Beispielen

Lassen Sie uns jeden Vergleich anhand konkreter Beispiele genauer betrachten.

1. Verwenden Sie Attribute für standardmäßige, sich wiederholende Konfigurationen (Do)

Attribute sind ideal für Standardkonfigurationen, die keine komplexe Logik erfordern. Hier sind drei gute Beispiele:

• Routen definieren: Verwenden Sie Attribute, um einfache Routen mit HTTP-Methoden und -Pfaden zu definieren.

#[Attribute]
class MyCustomAttribute {
    public function __construct(public string $description) {}
}

#[MyCustomAttribute("This is a test class")]
class MyClass {
    #[MyCustomAttribute("This is a test method")]
    public function myMethod() {}
}

• Cache-Steuerung: Verwenden Sie ein Attribut, um die Cache-Dauer für Methoden anzugeben.

  #[Attribute]
  class Route {
      public function __construct(public string $method, public string $path) {}
  }

  class ProductController {
      #[Route('GET', '/products')]
      public function index() {}
  }

• Ratenbegrenzung: Ein Throttle-Attribut könnte verwendet werden, um die Anzahl der Anfragen pro Benutzer zu begrenzen.

  #[Attribute]
  class Cache {
      public function __construct(public int $duration) {}
  }

  class ProductController {
      #[Cache(3600)]
      public function show($id) {}
  }

Überladen Sie Attribute nicht mit komplexen Konfigurationen (nicht)

Vermeiden Sie die Verwendung von Attributen für Konfigurationen, die mehrere Parameter oder Bedingungen erfordern. Folgendes sollten Sie nicht tun:

• Überladung mit mehreren Konfigurationen: Vermeiden Sie das Hinzufügen mehrerer Parameter zu einem Attribut.

  #[Attribute]
  class Throttle {
      public function __construct(public int $maxAttempts) {}
  }

  class UserController {
      #[Throttle(5)]
      public function store() {}
  }

• Bedingte Logik in Attributen: Vermeiden Sie bedingte Einstellungen innerhalb von Attributen.

  #[Attribute]
  class Route {
      public function __construct(
          public string $method,
          public string $path,
          public ?string $middleware = null,
          public ?string $prefix = null
      ) {}
  }

  #[Route('POST', '/users', middleware: 'auth', prefix: '/admin')]

• Verkettete Konfigurationen in einem einzelnen Attribut: Vermeiden Sie die Verkettung mehrerer Konfigurationsverhalten in einem Attribut.

  #[Attribute]
  class Condition {
      public function __construct(public string $condition) {}
  }

  class Controller {
      #[Condition("isAdmin() ? 'AdminRoute' : 'UserRoute'")]
      public function index() {}
  }

2. Attribute für Metadaten nutzen (Do)

Verwenden Sie Attribute als Markierungen oder Metadaten, anstatt Anwendungslogik darin einzubetten. So geht's:

• Anmerkungen zur Validierung: Markieren Sie ein Feld mit einem Attribut als erforderlich.

  #[Attribute]
  class Combined {
      public function __construct(
          public int $cacheDuration,
          public int $rateLimit
      ) {}
  }

  #[Combined(cacheDuration: 300, rateLimit: 5)]

• HTTP-Methode als Metadaten angeben: Verwenden Sie Attribute, um den HTTP-Methodentyp zu markieren.

  #[Attribute]
  class Required {}

  class User {
      #[Required]
      public string $name;
  }

• Zugriffsebenen angeben: Verwenden Sie Attribute, um Zugriffsebenenanforderungen anzugeben.

  #[Attribute]
  class Get {}

  class BlogController {
      #[Get]
      public function list() {}
  }

Geschäftslogik nicht in Attribute einbetten (nicht)

Vermeiden Sie die Verwendung von Attributen, um das Anwendungsverhalten direkt zu bestimmen. Folgendes sollten Sie nicht tun:

• Direkte Bedingungen in Attributen vermeiden: Platzieren Sie keine bedingten Prüfungen in Attributen.

  #[Attribute]
  class RequiresAdmin {}

  class SettingsController {
      #[RequiresAdmin]
      public function update() {}
  }

• Methodenaufrufe in Attributen vermeiden: Platzieren Sie keine Funktionsaufrufe oder Geschäftslogik in Attributen.

  #[Attribute]
  class AccessControl {
      public function __construct(public string $role) {}
  }

  #[AccessControl(role: isAdmin() ? 'admin' : 'user')]

• Berechnete Werte in Attributen vermeiden: Attribute sollten statische Metadaten sein, keine berechneten Werte.

  #[Attribute]
  class ConditionalCache {
      public function __construct(public int $duration) {}
  }

  #[ConditionalCache(duration: userHasPremium() ? 3600 : 300)]

3. Attribute für einfache, wiederverwendbare Anmerkungen anwenden (Do)

Attribute eignen sich gut für einfache Anmerkungen, die wiederverwendet werden können. Hier sind einige Beispiele für wiederverwendbare Anmerkungen:

• Einfache Drosselung: Ein einfaches Drosselungsattribut zur Begrenzung der Anforderungsraten.

#[Attribute]
class MyCustomAttribute {
    public function __construct(public string $description) {}
}

#[MyCustomAttribute("This is a test class")]
class MyClass {
    #[MyCustomAttribute("This is a test method")]
    public function myMethod() {}
}

• Cache-Kontrolle: Fügen Sie Cache-Kontrollattribute mit einem einzigen Dauerparameter hinzu.

  #[Attribute]
  class Route {
      public function __construct(public string $method, public string $path) {}
  }

  class ProductController {
      #[Route('GET', '/products')]
      public function index() {}
  }

• Veraltungswarnung: Markieren Sie Methoden als veraltet, um Entwickler zu warnen.

  #[Attribute]
  class Cache {
      public function __construct(public int $duration) {}
  }

  class ProductController {
      #[Cache(3600)]
      public function show($id) {}
  }

Verwenden Sie Attribute nicht zu häufig für Konfigurationen, die in anderen Formaten einfacher sind (nicht)

Einige Konfigurationen lassen sich außerhalb von Attributen besser verwalten. Folgendes sollten Sie nicht tun:

• Middleware-Konfiguration: Vermeiden Sie die direkte Konfiguration von Middleware in Attributen.

  #[Attribute]
  class Throttle {
      public function __construct(public int $maxAttempts) {}
  }

  class UserController {
      #[Throttle(5)]
      public function store() {}
  }

• Autorisierungsregeln: Komplexe Autorisierungskonfigurationen sind in Richtliniendateien besser.

  #[Attribute]
  class Route {
      public function __construct(
          public string $method,
          public string $path,
          public ?string $middleware = null,
          public ?string $prefix = null
      ) {}
  }

  #[Route('POST', '/users', middleware: 'auth', prefix: '/admin')]

• Komplexe Validierungsregeln: Halten Sie die Validierungslogik von Attributen fern.

  #[Attribute]
  class Condition {
      public function __construct(public string $condition) {}
  }

  class Controller {
      #[Condition("isAdmin() ? 'AdminRoute' : 'UserRoute'")]
      public function index() {}
  }

Abschluss

Attribute bieten eine elegante Möglichkeit, sich wiederholende Konfigurationen zu handhaben, insbesondere in PHP-Frameworks wie Laravel.

Am besten funktionieren sie jedoch als einfache Metadaten, und es ist wichtig, sie nicht mit komplexen Konfigurationen oder Logik zu überladen.

Indem Sie die Best Practices befolgen und Attribute als leichte, wiederverwendbare Annotationen verwenden, können Sie ihr volles Potenzial nutzen, ohne Ihrer Codebasis unnötige Komplexität hinzuzufügen.

---

Sponsor

Unterstützen Sie meine Open-Source-Arbeit, indem Sie mich auf GitHub Sponsors sponsern! Ihr Sponsoring hilft mir, weiterhin nützliche Laravel-Pakete, Tools und Bildungsinhalte zu erstellen, die der Entwicklergemeinschaft zugute kommen. Vielen Dank, dass Sie dazu beigetragen haben, Open Source besser zu machen!

---

Foto von Milad Fakurian auf Unsplash

Das obige ist der detaillierte Inhalt vonArbeiten mit PHP-Attributen: Do's & Don'ts. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!