SOLID: S - Prinsip Tanggungjawab Tunggal (SRP)

Pengenalan kepada SRP:
Prinsip Tanggungjawab Tunggal (SRP) ialah salah satu daripada lima prinsip SOLID, satu set garis panduan untuk menulis kod yang lebih bersih dan lebih mampan. SRP menyatakan bahawa kelas harus mempunyai hanya satu sebab untuk berubah, bermakna ia hanya mempunyai satu tanggungjawab atau fungsi. Mengikuti prinsip ini menjadikan kod lebih mudah difahami, diselenggara dan diuji.

Objektif SRP:

• Penyelenggaraan Ringkas: Dengan kelas hanya mempunyai satu tanggungjawab, mengenal pasti dan membetulkan pepijat menjadi lebih mudah.
• Tanggungjawab Jelas: Setiap kelas mempunyai tujuan yang jelas, menjadikan kod lebih mudah difahami.
• Peningkatan Kebolehujian: Kelas dengan tanggungjawab tunggal lebih mudah untuk diasingkan dan diuji.
• Kemudahan Perubahan: Perubahan dalam tanggungjawab tertentu tidak menjejaskan bahagian lain sistem.

Contoh Amalan Buruk (Kelas):
Di sini kami mempunyai kelas UserService yang melakukan lebih daripada satu perkara: mengurus pengguna dan menghantar pemberitahuan.

class UserService {
  createUser(user: User): void {
    // Logic to create user
  }

  deleteUser(userId: string): void {
    // Logic to delete user
  }

  notifyUser(userId: string, message: string): void {
    // Logic to notify user
  }
}

Dalam pendekatan ini, kelas UserService mempunyai pelbagai tanggungjawab: mengurus pengguna dan menghantar pemberitahuan. Ini melanggar SRP.

Contoh Amalan Baik (Kelas):
Untuk menggunakan SRP, kami boleh memisahkan tanggungjawab ke dalam kelas yang berbeza.

class UserService {
  createUser(user: User): void {
    // Logic to create user
  }

  deleteUser(userId: string): void {
    // Logic to delete user
  }
}

class NotificationService {
  notifyUser(userId: string, message: string): void {
    // Logic to notify user
  }
}

Kini, UserService hanya mengendalikan penciptaan dan pemadaman pengguna, manakala NotificationService mengendalikan pemberitahuan. Setiap kelas mempunyai tanggungjawab tunggal, mengikut SRP.

Contoh Amalan Buruk (Fungsi):
Di sini kami mempunyai fungsi yang melakukan lebih daripada satu perkara: mencipta pengguna dan menghantar pemberitahuan.

function createUserAndNotify(user: User, message: string): void {
  // Logic to create user
  // Logic to send notification
}

Dalam pendekatan ini, fungsi createUserAndNotify mempunyai pelbagai tanggungjawab: mencipta pengguna dan menghantar pemberitahuan. Ini melanggar SRP.

Contoh Amalan Baik (Fungsi):
Untuk menggunakan SRP, kami boleh memisahkan tanggungjawab kepada fungsi yang berbeza.

function createUser(user: User): void {
  // Logic to create user
}

function notifyUser(userId: string, message: string): void {
  // Logic to notify user
}

// Using the separated functions
createUser(newUser);
notifyUser(newUser.id, 'Welcome!');

Kini, fungsi createUser hanya mengendalikan penciptaan pengguna, manakala notifyUser mengendalikan pemberitahuan. Setiap fungsi mempunyai satu tanggungjawab, mengikut SRP.

Aplikasi dalam React Native dengan TypeScript:
Bayangkan kita sedang membangunkan apl pengurusan tugasan. Kami boleh menggunakan SRP dengan mengasingkan logik pengurusan tugas dan logik pemberitahuan ke dalam kelas yang berbeza.

Contoh Amalan Buruk (Kelas):

class TaskService {
  addTask(task: Task): void {
    // Logic to add task
  }

  removeTask(taskId: string): void {
    // Logic to remove task
  }

  notifyTaskDue(taskId: string): void {
    // Logic to notify that the task is due
  }
}

Contoh Amalan Baik (Kelas):

class TaskService {
  addTask(task: Task): void {
    // Logic to add task
  }

  removeTask(taskId: string): void {
    // Logic to remove task
  }
}

class TaskNotificationService {
  notifyTaskDue(taskId: string): void {
    // Logic to notify that the task is due
  }
}

Contoh Amalan Buruk (Fungsi):

function addTaskAndNotify(task: Task): void {
  // Logic to add task
  // Logic to notify that the task is due
}

Contoh Amalan Baik (Fungsi):

function addTask(task: Task): void {
  // Logic to add task
}

function notifyTaskDue(taskId: string): void {
  // Logic to notify that the task is due
}

// Using the separated functions
addTask(newTask);
notifyTaskDue(newTask.id);

Dengan membahagikan tanggungjawab, kami menjadikan aplikasi lebih mudah untuk diselenggara dan dikembangkan.

Kesimpulan:
Mengikuti Prinsip Tanggungjawab Tunggal membantu memastikan kod bersih, teratur dan lebih mudah diselenggara. Menggunakan SRP dalam pembangunan React Native dengan TypeScript menghasilkan kod yang lebih modular dan boleh diuji. Sentiasa ingat untuk memastikan kelas dan fungsi anda tertumpu pada satu tanggungjawab untuk meraih semua faedah prinsip ini.

Atas ialah kandungan terperinci SOLID: S - Prinsip Tanggungjawab Tunggal (SRP). Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!