Bekerja dengan Atribut PHP: Lakukan & Larangan

Atribut dalam PHP memudahkan konfigurasi kod dengan membenarkan anda menganotasi elemen kod dengan metadata secara langsung, yang berpotensi mengurangkan boilerplate dalam rangka kerja seperti Laravel. Walau bagaimanapun, seperti mana-mana ciri, atribut boleh digunakan secara berlebihan atau salah guna, membawa kepada pengawal yang tidak kemas dan kod yang lebih sukar untuk diselenggara.

Dalam siaran ini, kami akan meneroka amalan terbaik untuk menggunakan atribut dengan cara yang meningkatkan kejelasan kod. Saya juga akan menyediakan jadual "buat dan tidak boleh" dengan contoh untuk setiap perbandingan, menyerlahkan senario di mana atribut berfungsi dengan baik—dan di mana ia mungkin tidak.

1. Memahami Atribut dalam PHP

Berikut ialah contoh pantas untuk mentakrif dan menggunakan atribut untuk menyediakan beberapa konteks:

#[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. Perkara yang boleh dan tidak boleh dilakukan: Gambaran Keseluruhan Pantas

Berikut ialah jadual untuk meringkaskan amalan terbaik dan perangkap biasa:

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. Perbandingan Terperinci dengan Contoh

Mari kita menyelami setiap perbandingan dengan contoh khusus.

1. Gunakan Atribut untuk Standard, Konfigurasi Berulang (Do)

Atribut sesuai untuk konfigurasi standard yang tidak memerlukan logik yang rumit. Berikut ialah tiga contoh yang baik:

• Menentukan Laluan: Gunakan atribut untuk menentukan laluan mudah dengan kaedah dan laluan HTTP.

#[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() {}
}

• Kawalan Cache: Gunakan atribut untuk menentukan tempoh cache untuk kaedah.

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

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

• Penghadan Kadar: Atribut Pendikit boleh digunakan untuk mengehadkan bilangan permintaan bagi setiap pengguna.

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

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

Jangan Bebankan Atribut dengan Konfigurasi Kompleks (Jangan)

Elakkan menggunakan atribut untuk konfigurasi yang memerlukan berbilang parameter atau syarat. Inilah perkara yang tidak boleh dilakukan:

• Melebihi beban dengan Berbilang Konfigurasi: Elakkan menambah berbilang parameter pada atribut.

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

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

• Logik Bersyarat dalam Atribut: Elakkan tetapan bersyarat dalam atribut.

  #[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')]

• Konfigurasi Berantai dalam Atribut Tunggal: Elakkan rantaian berbilang gelagat konfigurasi dalam satu atribut.

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

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

2. Leverage Atribut untuk Metadata (Do)

Gunakan atribut sebagai penanda atau metadata, bukannya membenamkan logik aplikasi di dalamnya. Begini caranya:

• Anotasi untuk Pengesahan: Tandai medan seperti yang diperlukan dengan atribut.

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

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

• Tentukan Kaedah HTTP sebagai Metadata: Gunakan atribut untuk menandakan jenis kaedah HTTP.

  #[Attribute]
  class Required {}

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

• Nyatakan Tahap Akses: Gunakan atribut untuk menunjukkan keperluan tahap akses.

  #[Attribute]
  class Get {}

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

Jangan Benamkan Logik Perniagaan dalam Atribut (Jangan)

Elakkan menggunakan atribut untuk menentukan tingkah laku aplikasi secara langsung. Inilah perkara yang tidak boleh dilakukan:

• Elakkan Keadaan Langsung dalam Atribut: Jangan letakkan semakan bersyarat dalam atribut.

  #[Attribute]
  class RequiresAdmin {}

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

• Elakkan Panggilan Kaedah dalam Atribut: Jangan letakkan panggilan fungsi atau logik perniagaan dalam atribut.

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

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

• Elakkan Nilai Dikira dalam Atribut: Atribut hendaklah metadata statik, bukan nilai yang dikira.

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

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

3. Gunakan Atribut untuk Anotasi Mudah dan Boleh Digunakan Semula (Do)

Atribut berfungsi dengan baik untuk anotasi ringan yang boleh digunakan semula. Berikut ialah beberapa contoh anotasi boleh guna semula:

• Pendikit Mudah: Atribut pendikit mudah untuk mengehadkan kadar permintaan.

#[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() {}
}

• Kawalan Cache: Tambahkan atribut kawalan cache dengan parameter tempoh tunggal.

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

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

• Amaran Penamatan: Tandai kaedah sebagai tidak digunakan untuk memaklumkan pembangun.

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

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

Jangan Terlalu Guna Atribut untuk Konfigurasi Yang Lebih Mudah dalam Format Lain (Jangan)

Sesetengah konfigurasi diurus dengan lebih baik di luar atribut. Inilah perkara yang tidak boleh dilakukan:

• Konfigurasi Peranti Tengah: Elakkan mengkonfigurasi perisian tengah secara terus dalam atribut.

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

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

• Peraturan Kebenaran: Konfigurasi kebenaran kompleks adalah lebih baik dalam fail dasar.

  #[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')]

• Peraturan Pengesahan Kompleks: Jauhkan logik pengesahan daripada atribut.

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

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

Kesimpulan

Atribut menawarkan cara yang elegan untuk mengendalikan konfigurasi berulang, terutamanya dalam rangka kerja PHP seperti Laravel.

Walau bagaimanapun, ia berfungsi paling baik sebagai metadata mudah, dan adalah penting untuk mengelak daripada membebankannya dengan konfigurasi atau logik yang kompleks.

Dengan mengikuti amalan terbaik dan menggunakan atribut sebagai anotasi yang ringan dan boleh diguna semula, anda boleh memanfaatkan potensi penuh mereka tanpa menambahkan kerumitan yang tidak perlu pada pangkalan kod anda.

---

Penaja

Sokong kerja sumber terbuka saya dengan menaja saya di Penaja GitHub! Tajaan anda membantu saya terus mencipta pakej, alatan dan kandungan pendidikan Laravel yang berguna yang memberi manfaat kepada komuniti pembangun. Terima kasih kerana membantu menjadikan sumber terbuka lebih baik!

---

Foto oleh Milad Fakurian di Unsplash

Atas ialah kandungan terperinci Bekerja dengan Atribut PHP: Lakukan & Larangan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!