+10

SOLID trong React và React Native: Hướng dẫn toàn diện

Chào các bạn! Hôm nay mình sẽ cùng các bạn đào sâu vào các nguyên lý SOLID và cách áp dụng chúng trong React và React Native. Đây là những kiến thức cực kỳ quan trọng mà bất kỳ lập trình viên nào cũng cần nắm vững để có thể viết code chất lượng và dễ bảo trì.

SOLID là gì?

SOLID không phải là một công nghệ mới hay framework nào đâu nhé. Đây là tập hợp 5 nguyên lý thiết kế phần mềm được đúc kết từ kinh nghiệm của các lập trình viên đi trước:

  1. Single Responsibility Principle (SRP)
  2. Open-Closed Principle (OCP)
  3. Liskov Substitution Principle (LSP)
  4. Interface Segregation Principle (ISP)
  5. Dependency Inversion Principle (DIP)

Áp dụng tốt SOLID sẽ giúp code của chúng ta dễ đọc, dễ bảo trì và mở rộng hơn rất nhiều. Đặc biệt trong các dự án lớn, việc tuân thủ SOLID là vô cùng quan trọng.

Chú ý: SOLID không phải là luật bất di bất dịch, mà là những nguyên tắc hướng dẫn giúp chúng ta viết code tốt hơn. Trong thực tế, việc áp dụng SOLID cần sự linh hoạt và cân nhắc kỹ lưỡng.

Mình hy vọng qua bài viết này, các bạn sẽ hiểu rõ hơn về SOLID và cách áp dụng chúng trong React và React Native.

Nếu có bất kỳ thắc mắc nào, đừng ngần ngại comment bên dưới nhé. Chúc các bạn code vui vẻ! 😊

OK, giờ chúng ta sẽ đi sâu vào từng nguyên lý nhé!

1. Single Responsibility Principle (SRP)

Single Responsibility Principle (SRP): Just Because You Can, Doesn't Mean You Should

Nguyên lý đầu tiên trong SOLID - Single Responsibility Principle (SRP) - nêu rõ rằng một class hoặc module chỉ nên có một lý do duy nhất để thay đổi. Nói cách khác, mỗi thành phần trong code của chúng ta chỉ nên chịu trách nhiệm cho một chức năng cụ thể.

Để hiểu rõ hơn về SRP, hãy xem xét ví dụ sau trong React:

// Component vi phạm SRP
const UserProfile = ({ user, updateUser, sendEmail }) => {
  const [name, setName] = useState(user.name);
  const [email, setEmail] = useState(user.email);

  const handleNameChange = (e) => setName(e.target.value);
  const handleEmailChange = (e) => setEmail(e.target.value);

  const handleSubmit = () => {
    updateUser({ ...user, name, email });
  };

  const handleSendEmail = () => {
    sendEmail(email, "Welcome to our platform!");
  };

  return (
    <div>
      <input value={name} onChange={handleNameChange} />
      <input value={email} onChange={handleEmailChange} />
      <button onClick={handleSubmit}>Cập nhật</button>
      <button onClick={handleSendEmail}>Gửi email chào mừng</button>
    </div>
  );
};

Trong ví dụ trên, component UserProfile đang vi phạm SRP vì nó đang thực hiện nhiều nhiệm vụ:

  1. Hiển thị thông tin người dùng
  2. Xử lý việc cập nhật thông tin
  3. Gửi email

Để tuân thủ SRP, chúng ta nên tách component này thành các component nhỏ hơn, mỗi component chỉ đảm nhận một nhiệm vụ:

// Component hiển thị và cập nhật thông tin
const UserInfoForm = ({ user, onUpdate }) => {
  const [name, setName] = useState(user.name);
  const [email, setEmail] = useState(user.email);

  const handleNameChange = (e) => setName(e.target.value);
  const handleEmailChange = (e) => setEmail(e.target.value);

  const handleSubmit = () => {
    onUpdate({ ...user, name, email });
  };

  return (
    <div>
      <input value={name} onChange={handleNameChange} />
      <input value={email} onChange={handleEmailChange} />
      <button onClick={handleSubmit}>Cập nhật</button>
    </div>
  );
};

// Component xử lý gửi email
const WelcomeEmailButton = ({ email, onSendEmail }) => {
  const handleSendEmail = () => {
    onSendEmail(email, "Welcome to our platform!");
  };

  return <button onClick={handleSendEmail}>Gửi email chào mừng</button>;
};

// Component cha, kết hợp các component con
const UserProfile = ({ user, updateUser, sendEmail }) => {
  return (
    <div>
      <UserInfoForm user={user} onUpdate={updateUser} />
      <WelcomeEmailButton email={user.email} onSendEmail={sendEmail} />
    </div>
  );
};

Sau khi refactor, mỗi component giờ đây chỉ có một trách nhiệm duy nhất:

  • UserInfoForm: Hiển thị và xử lý cập nhật thông tin người dùng
  • WelcomeEmailButton: Xử lý việc gửi email chào mừng
  • UserProfile: Kết hợp các component con lại với nhau

Lợi ích của việc áp dụng SRP:

  1. Code dễ đọc và dễ hiểu hơn: Mỗi component có một mục đích rõ ràng.
  2. Dễ bảo trì: Khi cần thay đổi logic, chỉ cần tập trung vào một component cụ thể.
  3. Tái sử dụng: Các component nhỏ có thể được tái sử dụng ở nhiều nơi trong ứng dụng.
  4. Dễ test: Viết unit test cho các component đơn giản sẽ dễ dàng hơn.

Tuy nhiên, cần lưu ý rằng việc áp dụng SRP không có nghĩa là tách mọi thứ thành các component siêu nhỏ. Chúng ta cần cân nhắc giữa việc tuân thủ nguyên lý và việc giữ cho code không trở nên quá phức tạp với quá nhiều component nhỏ.

2. Open-Closed Principle (OCP)

image.png

Nguyên lý Open-Closed (OCP) là một trong những nguyên lý quan trọng trong SOLID, nó phát biểu rằng: "Các thực thể (classes, modules, functions, etc.) nên mở cho việc mở rộng, nhưng đóng cho việc sửa đổi."

Để hiểu rõ hơn, hãy phân tích các khái niệm:

  • Mở cho việc mở rộng: Có thể dễ dàng thêm tính năng mới mà không ảnh hưởng đến code hiện tại.
  • Đóng cho việc sửa đổi: Không cần phải thay đổi code đã có khi thêm tính năng mới.

Trong React, chúng ta có thể áp dụng OCP bằng cách thiết kế các component linh hoạt, có khả năng mở rộng mà không cần sửa đổi code gốc. Hãy xem xét ví dụ sau:

// Ví dụ chưa áp dụng OCP
const Form = ({ type }) => {
  if (type === 'login') {
    return <LoginForm />;
  } else if (type === 'register') {
    return <RegisterForm />;
  }
  // Mỗi khi thêm loại form mới, phải sửa đổi component này
};

Trong ví dụ trên, mỗi khi muốn thêm một loại form mới, chúng ta phải sửa đổi component Form. Điều này vi phạm nguyên lý OCP.

Hãy áp dụng OCP để cải thiện:

// Component Form tuân thủ OCP
const Form = ({ children }) => (
  <div className="form-container">
    {children}
  </div>
);

// Sử dụng
const App = () => (
  <Form>
    {formType === 'login' && <LoginForm />}
    {formType === 'register' && <RegisterForm />}
    {formType === 'reset-password' && <ResetPasswordForm />}
    {/* Có thể thêm nhiều loại form khác mà không cần sửa đổi Form */}
  </Form>
);

Trong ví dụ này:

  • Form component giờ đây chỉ là một container, không quan tâm đến logic bên trong.
  • Việc thêm form mới được thực hiện ở component cha (App), không cần sửa đổi Form.
  • Form đã mở cho việc mở rộng (có thể thêm bất kỳ loại form nào) và đóng cho việc sửa đổi (không cần thay đổi code của Form).

Lợi ích của việc áp dụng OCP:

  1. Giảm rủi ro khi thêm tính năng mới: Không cần sửa đổi code đã hoạt động ổn định.
  2. Tăng tính linh hoạt và tái sử dụng: Form có thể được sử dụng cho nhiều loại form khác nhau.
  3. Dễ dàng mở rộng: Thêm form mới không ảnh hưởng đến code hiện tại.

Tuy nhiên, cần lưu ý rằng việc áp dụng OCP cũng có thể dẫn đến việc tạo ra nhiều abstraction hơn cần thiết. Vì vậy, cần cân nhắc giữa việc tuân thủ nguyên lý và giữ cho code đơn giản, dễ hiểu.

Vây OCP giúp chúng ta tạo ra các component linh hoạt, dễ mở rộng trong React. Bằng cách thiết kế các component tuân thủ OCP, chúng ta có thể xây dựng các ứng dụng React có khả năng mở rộng cao, dễ bảo trì và ít rủi ro khi thêm tính năng mới.

3. Liskov Substitution Principle (LSP)

Liskov Substitution Principle (LSP)

Nguyên lý Liskov Substitution (LSP) là một trong những nguyên tắc quan trọng trong lập trình hướng đối tượng và thiết kế phần mềm. Nguyên lý này phát biểu rằng:

"Các đối tượng trong chương trình có thể được thay thế bởi các thể hiện của lớp con mà không làm thay đổi tính đúng đắn của chương trình."

Để hiểu rõ hơn, hãy phân tích các khái niệm:

  • Lớp cha (superclass): Định nghĩa một giao diện chung.
  • Lớp con (subclass): Kế thừa từ lớp cha và có thể mở rộng hoặc đặc biệt hóa hành vi.
  • Tính đúng đắn: Chương trình vẫn hoạt động đúng khi sử dụng lớp con thay cho lớp cha.

Trong React, chúng ta có thể áp dụng LSP bằng cách tạo ra các component có thể hoán đổi cho nhau mà không làm thay đổi logic của ứng dụng. Hãy xem xét ví dụ sau:

// Component cơ sở
const Button = ({ children, onClick, ...props }) => (
  <button onClick={onClick} {...props}>
    {children}
  </button>
);

// Các component con
const PrimaryButton = (props) => (
  <Button className="primary" {...props} />
);

const SecondaryButton = (props) => (
  <Button className="secondary" {...props} />
);

const DangerButton = (props) => (
  <Button className="danger" {...props} />
);

// Sử dụng
const App = () => {
  const handleClick = (type) => {
    console.log(`Clicked ${type} button`);
  };

  return (
    <div>
      <Button onClick={() => handleClick('default')}>Default Button</Button>
      <PrimaryButton onClick={() => handleClick('primary')}>Primary Action</PrimaryButton>
      <SecondaryButton onClick={() => handleClick('secondary')}>Secondary Action</SecondaryButton>
      <DangerButton onClick={() => handleClick('danger')}>Danger Action</DangerButton>
    </div>
  );
};

Trong ví dụ này:

  • Button là component cơ sở, định nghĩa giao diện chung cho tất cả các loại button.
  • PrimaryButton, SecondaryButton, và DangerButton là các component con, kế thừa từ Button.
  • Tất cả các component con đều có thể được sử dụng ở bất kỳ đâu mà Button được sử dụng, mà không làm thay đổi tính đúng đắn của chương trình.
Lợi ích của việc áp dụng LSP
  1. Tính linh hoạt: Có thể dễ dàng thêm các loại button mới mà không ảnh hưởng đến code hiện có.
  2. Tái sử dụng code: Logic chung được định nghĩa trong component cơ sở, giảm việc lặp lại code.
  3. Dễ bảo trì: Khi cần thay đổi hành vi chung, chỉ cần sửa đổi component cơ sở.

Tuy nhiên, cần lưu ý rằng việc áp dụng LSP không có nghĩa là tạo ra một hệ thống phân cấp phức tạp. Thay vào đó, nó khuyến khích chúng ta tạo ra các component linh hoạt và có thể thay thế cho nhau.

Ví dụ về việc vi phạm LSP:

const SpecialButton = ({ children, onClick, ...props }) => (
  <div onClick={onClick} {...props}>
    {children}
  </div>
);

SpecialButton vi phạm LSP vì nó không thể hoàn toàn thay thế Button. Nó sử dụng div thay vì button, có thể dẫn đến các vấn đề về accessibility và behavior không mong muốn.

Vậy nên việc áp dụng LSP trong React giúp chúng ta tạo ra các component linh hoạt, dễ mở rộng và bảo trì. Bằng cách tuân thủ nguyên lý này, chúng ta có thể xây dựng các ứng dụng React có cấu trúc tốt và dễ phát triển trong tương lai.

4. Interface Segregation Principle (ISP)

Nguyên lý Interface Segregation (ISP) là một trong những nguyên tắc quan trọng trong thiết kế phần mềm. Nguyên lý này phát biểu rằng:

"Không nên ép buộc client phải phụ thuộc vào các interface mà họ không sử dụng."

Để hiểu rõ hơn, hãy phân tích các khái niệm:

  • Interface: Trong React, có thể hiểu là tập hợp các props mà một component nhận vào.
  • Client: Các component sử dụng component khác.
  • Segregation: Tách biệt, phân chia thành các phần nhỏ hơn.

Trong React, chúng ta có thể áp dụng ISP bằng cách tách nhỏ các props, chỉ truyền những gì cần thiết cho mỗi component. Hãy xem xét ví dụ sau:

// Ví dụ chưa áp dụng ISP
const UserInfo = ({ user }) => (
  <div>
    <h1>{user.name}</h1>
    <p>{user.email}</p>
    <p>{user.address}</p>
  </div>
);

const AccountBalance = ({ user }) => (
  <p>Số dư: {user.balance}</p>
);

const MessageButton = ({ user }) => (
  <button onClick={user.onSendMessage}>Gửi tin nhắn</button>
);

const UserProfile = ({ user, onSendMessage }) => (
  <div>
    <UserInfo user={user} />
    <AccountBalance user={user} />
    <MessageButton user={user} />
  </div>
);

// Sử dụng
const App = () => (
  <UserProfile user={{
    name: 'John Doe',
    email: 'john@example.com',
    address: '123 Main St',
    accountBalance: 1000,
    sendMessage: () => console.log('Sending message...')
  }} />
);

Trong ví dụ trên, các component nhận vào một object user chứa tất cả thông tin, dù không phải tất cả các component đều cần tất cả thông tin đó. Điều này vi phạm nguyên lý ISP.

Hãy áp dụng ISP để cải thiện:

// Component tuân thủ ISP
const UserInfo = ({ name, email, address }) => (
  <div>
    <h1>{name}</h1>
    <p>{email}</p>
    <p>{address}</p>
  </div>
);

const AccountBalance = ({ balance }) => (
  <p>Số dư: {balance}</p>
);

const MessageButton = ({ onSendMessage }) => (
  <button onClick={onSendMessage}>Gửi tin nhắn</button>
);

const UserProfile = ({ user, onSendMessage }) => (
  <div>
    <UserInfo name={user.name} email={user.email} address={user.address} />
    <AccountBalance balance={user.accountBalance} />
    <MessageButton onSendMessage={onSendMessage} />
  </div>
);

// Sử dụng
const App = () => {
  const user = {
    name: 'John Doe',
    email: 'john@example.com',
    address: '123 Main St',
    accountBalance: 1000
  };
  const handleSendMessage = () => console.log('Sending message...');

  return <UserProfile user={user} onSendMessage={handleSendMessage} />;
};

Trong ví dụ này:

  • UserInfo, AccountBalance, và MessageButton là các component nhỏ, chỉ nhận vào những props cần thiết.
  • UserProfile tổng hợp các component nhỏ lại, nhưng vẫn tách biệt các chức năng.
  • Mỗi component chỉ phụ thuộc vào những props mà nó thực sự cần.

Lợi ích của việc áp dụng ISP:

  1. Tăng tính tái sử dụng: Các component nhỏ có thể được sử dụng độc lập ở nhiều nơi.
  2. Dễ bảo trì: Khi cần thay đổi một chức năng, chỉ cần tập trung vào component tương ứng.
  3. Giảm sự phụ thuộc: Mỗi component chỉ biết về những gì nó cần, giảm sự ràng buộc giữa các phần của ứng dụng.
  4. Dễ test: Các component nhỏ, độc lập dễ viết unit test hơn.

Tuy nhiên, cần lưu ý rằng việc áp dụng ISP cũng có thể dẫn đến việc tạo ra quá nhiều component nhỏ, làm tăng độ phức tạp của ứng dụng. Vì vậy, cần cân nhắc giữa việc tuân thủ nguyên lý và giữ cho code đơn giản, dễ hiểu.

Vậy nên ISP giúp chúng ta tạo ra các component linh hoạt, dễ bảo trì và tái sử dụng trong React. Bằng cách tuân thủ nguyên lý này, chúng ta có thể xây dựng các ứng dụng React có cấu trúc tốt, dễ phát triển và mở rộng trong tương lai.

5. Dependency Inversion Principle (DIP)

Nguyên lý cuối cùng nói rằng các module cấp cao không nên phụ thuộc vào các module cấp thấp. Cả hai nên phụ thuộc vào abstraction.

Để hiểu rõ hơn, hãy phân tích các khái niệm:

  • Module cấp cao: Đây là các module chứa logic nghiệp vụ chính, định nghĩa các quy tắc và luồng xử lý của ứng dụng. Chúng không nên phụ thuộc trực tiếp vào các chi tiết cụ thể.

  • Module cấp thấp: Đây là các module chứa các chi tiết cụ thể như gọi API, truy cập cơ sở dữ liệu, xử lý UI. Chúng thường phụ thuộc vào module cấp cao.

  • Abstraction: Đây là interface hoặc abstract class đóng vai trò trung gian, giúp module cấp cao và cấp thấp giao tiếp với nhau mà không phụ thuộc trực tiếp vào nhau.

Trong React, chúng ta có thể áp dụng nguyên lý này bằng cách sử dụng Dependency Injection hoặc Inversion of Control container. Hãy xem xét ví dụ sau:

// Ví dụ chưa áp dụng DIP
const UserList = () => {
  const [users, setUsers] = useState([]);

  // Module cấp cao (UserList) phụ thuộc trực tiếp vào module cấp thấp (fetch API)
  useEffect(() => {
    fetch('/api/users').then(res => res.json()).then(setUsers);
  }, []);

  return (
    <ul>
      {users.map(user => <li key={user.id}>{user.name}</li>)}
    </ul>
  );
};

Trong ví dụ trên, UserList (module cấp cao) phụ thuộc trực tiếp vào việc gọi API (module cấp thấp). Điều này vi phạm nguyên lý DIP.

Hãy áp dụng DIP bằng cách tạo một abstraction:

// Abstraction
const useUsers = () => {
  const [users, setUsers] = useState([]);

  useEffect(() => {
    // Module cấp cao (useUsers) không phụ thuộc trực tiếp vào module cấp thấp (fetch API)
    fetch('/api/users').then(res => res.json()).then(setUsers);
  }, []);

  return users;
};

// Module cấp cao
const UserList = ({ useUsers }) => {
  const users = useUsers();

  return (
    <ul>
      {users.map(user => <li key={user.id}>{user.name}</li>)}
    </ul>
  );
};

// Sử dụng
const App = () => <UserList useUsers={useUsers} />;

Trong ví dụ này:

  • useUsers là abstraction, đóng vai trò trung gian giữa module cấp cao và cấp thấp.
  • UserList là module cấp cao, không phụ thuộc trực tiếp vào việc gọi API.
  • Việc gọi API trong useUsers là module cấp thấp.

Bằng cách này, UserList không còn phụ thuộc trực tiếp vào việc gọi API nữa, mà phụ thuộc vào abstraction (hook useUsers). Điều này giúp code linh hoạt hơn, dễ dàng thay đổi cách lấy dữ liệu users mà không ảnh hưởng đến UserList.

Ví dụ, nếu muốn thay đổi cách lấy dữ liệu users (ví dụ từ local storage thay vì API), ta chỉ cần thay đổi implementation của useUsers mà không cần sửa đổi UserList:

const useUsersFromLocalStorage = () => {
  const [users, setUsers] = useState([]);

  useEffect(() => {
    const storedUsers = JSON.parse(localStorage.getItem('users') || '[]');
    setUsers(storedUsers);
  }, []);

  return users;
};

// Sử dụng
const App = () => <UserList useUsers={useUsersFromLocalStorage} />;

Suy ra, module cấp cao UserList không hề biết dữ liệu users đến từ đâu và cũng không quan tâm -> Đây chính xác là định nghĩa không phụ thuộc vào module cấp thấp. Nó chỉ luốn tin tưởng rằng Abstraction sẽ cung cấp dữ liệu cho nó.

Có một vài Design Pattern cũng sử dụng nguyên lý này như Repository Pattern, Service Pattern, Provider Pattern, Facade Pattern (Facade Pattern không hoàn toàn là DIP nhưng về mặt concept cũng giúp giảm sự phụ thuộc giữa các module)...

Như vậy, DIP giúp tạo ra các module độc lập, dễ bảo trì và mở rộng trong ứng dụng React của chúng ta.

Kết luận

SOLID không phải là luật bất di bất dịch, mà là những nguyên tắc hướng dẫn giúp chúng ta viết code tốt hơn. Trong thực tế, việc áp dụng SOLID cần sự linh hoạt và cân nhắc kỹ lưỡng.

Hy vọng qua bài viết này, các bạn đã hiểu rõ hơn về SOLID và cách áp dụng chúng trong React và React Native. Hãy thử áp dụng những nguyên lý này vào dự án của mình và chắc chắn bạn sẽ thấy code trở nên dễ đọc, dễ bảo trì và mở rộng hơn rất nhiều!

Nếu có bất kỳ thắc mắc nào, đừng ngần ngại comment bên dưới nhé. Chúc các bạn code vui vẻ! 😊


All Rights Reserved

Viblo
Let's register a Viblo Account to get more interesting posts.