Pengenalan kepada Corak Reka Bentuk React

Apabila aplikasi React berkembang dalam saiz dan kerumitan, mengekalkan kod yang bersih, cekap dan berskala menjadi satu cabaran. Corak reka bentuk bertindak balas menawarkan penyelesaian yang terbukti kepada masalah pembangunan biasa, membolehkan pembangun membina aplikasi yang lebih mudah untuk diurus dan dilanjutkan. Corak ini menggalakkan modulariti, penggunaan semula kod dan pematuhan kepada amalan terbaik, menjadikannya alat penting untuk mana-mana pembangun React.

Dalam panduan ini, kami akan meneroka corak reka bentuk React utama, seperti Komponen Bekas dan Persembahan, Cangkuk Tersuai dan Corak Memoisasi, dengan praktikal contoh untuk menunjukkan faedah mereka. Sama ada anda seorang pemula atau pembangun yang berpengalaman, artikel ini akan membantu anda memahami cara menggunakan corak ini untuk meningkatkan aliran kerja anda dan mencipta aplikasi React yang lebih baik.

Bekas dan Komponen Persembahan

Corak Bekas dan Komponen Persembahan ialah pendekatan reka bentuk yang digunakan secara meluas dalam React yang memisahkan logik aplikasi daripada pemaparan UI. Pemisahan ini membantu dalam mencipta komponen modular, boleh guna semula dan boleh diuji, selaras dengan prinsip pengasingan kebimbangan.

• Komponen Bekas: Kendalikan logik perniagaan, pengurusan keadaan dan pengambilan data. Mereka menumpukan pada cara perkara berfungsi.
• Komponen Persembahan: Kendalikan paparan data dan UI. Mereka menumpukan pada bagaimana keadaan.

Bahagian ini menjadikan pangkalan kod anda lebih boleh diselenggara, kerana perubahan dalam logik atau UI boleh dikendalikan secara bebas tanpa menjejaskan satu sama lain.

Faedah Corak

1. Kebolehgunaan Semula Kod: Komponen pembentangan boleh digunakan semula merentasi bahagian aplikasi yang berlainan.
2. Kebolehujian yang Dipertingkat: Logik ujian menjadi lebih mudah kerana ia diasingkan dalam komponen bekas.
3. Penyelenggaraan Ringkas: Perubahan dalam logik atau UI boleh ditangani secara bebas, mengurangkan risiko memecahkan bahagian lain kod.

Contoh: Mengambil dan Memaparkan Data Pengguna

Begini cara corak Bekas dan Komponen Persembahan boleh dilaksanakan:

Komponen Bekas

import React, { useState, useEffect } from "react";
import UserList from "./UserList";

const UserContainer = () => {
  const [users, setUsers] = useState([]);
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    fetch("/api/users")
      .then((response) => response.json())
      .then((data) => {
        setUsers(data);
        setLoading(false);
      })
      .catch(() => setLoading(false));
  }, []);

  return <UserList users={users} loading={loading} />;
};

export default UserContainer;

Komponen Persembahan

import React from "react";

const UserList = ({ users, loading }) => {
  if (loading) return <p>Loading...</p>;

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

export default UserList;

Dalam contoh ini:

• UserContainer mengambil data pengguna dan menghantarnya, bersama-sama dengan keadaan pemuatan, sebagai prop kepada UserList.
• UserList memfokuskan semata-mata pada pemaparan data pengguna.

Corak ini meningkatkan kejelasan, mengurangkan pertindihan kod dan memudahkan ujian. Ia amat berguna untuk aplikasi yang pengambilan data dan pemaparan UI kerap dan kompleks.

Cangkuk Tersuai untuk Komposisi

Cangkuk Tersuai membolehkan anda merangkum logik boleh guna semula, menjadikan kod React anda lebih bersih dan lebih modular. Daripada menduplikasi logik merentasi berbilang komponen, anda boleh mengekstraknya ke dalam cangkuk dan menggunakannya di mana sahaja diperlukan. Ini meningkatkan kebolehgunaan semula kod dan kebolehujian sambil mematuhi prinsip DRY (Jangan Ulang Sendiri).

Contoh: Ambil Cangkuk Data

Cangkuk Tersuai

import React, { useState, useEffect } from "react";
import UserList from "./UserList";

const UserContainer = () => {
  const [users, setUsers] = useState([]);
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    fetch("/api/users")
      .then((response) => response.json())
      .then((data) => {
        setUsers(data);
        setLoading(false);
      })
      .catch(() => setLoading(false));
  }, []);

  return <UserList users={users} loading={loading} />;
};

export default UserContainer;

Menggunakan Cangkuk

import React from "react";

const UserList = ({ users, loading }) => {
  if (loading) return <p>Loading...</p>;

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

export default UserList;

Dalam contoh ini, cangkuk useFetchData merangkum logik pengambilan data, membenarkan mana-mana komponen untuk mengambil data dengan boilerplate minimum. Cangkuk tersuai tidak ternilai untuk memudahkan kod dan memastikan seni bina yang bersih.

Pengurusan Negeri dengan Pengurangan

Apabila menguruskan keadaan kompleks atau berkumpulan, Corak Pengurang menyediakan cara berstruktur untuk mengendalikan peralihan keadaan. Ia memusatkan logik keadaan ke dalam satu fungsi, menjadikan kemas kini keadaan boleh diramal dan lebih mudah untuk nyahpepijat. Cangkuk useReducer React sangat sesuai untuk melaksanakan corak ini.

Faedah Pengurang

1. Kebolehramalan: Perubahan keadaan ditakrifkan secara eksplisit melalui tindakan.
2. Skalabiliti: Sesuai untuk pengurusan keadaan kompleks dengan pelbagai kebergantungan.
3. Kebolehselenggaraan: Logik terpusat memudahkan penyahpepijatan dan ujian.

Contoh: Menguruskan Keadaan Pengesahan

Fungsi Pengurang

import { useState, useEffect } from "react";

const useFetchData = (url) => {
  const [data, setData] = useState(null);
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    fetch(url)
      .then((res) => res.json())
      .then((result) => {
        setData(result);
        setLoading(false);
      });
  }, [url]);

  return { data, loading };
};

export default useFetchData;

Komponen Menggunakan useReducer

import React from "react";
import useFetchData from "./useFetchData";

const Posts = () => {
  const { data: posts, loading } = useFetchData("/api/posts");

  if (loading) return <p>Loading...</p>;
  return (
    <ul>
      {posts.map((post) => (
        <li key={post.id}>{post.title}</li>
      ))}
    </ul>
  );
};

export default Posts;

Dalam contoh ini:

• AuthReducer mentakrifkan cara keadaan berubah berdasarkan tindakan.
• AuthComponent menggunakan useReducer untuk mengurus keadaan pengesahan.

Penurun amat berkesan untuk mengendalikan logik keadaan yang rumit dalam aplikasi boleh skala, menggalakkan kejelasan dan konsistensi dalam pengurusan negeri.

Corak Pembekal untuk API Konteks

Corak Pembekal memanfaatkan API Konteks React untuk berkongsi keadaan atau fungsi merentas komponen tanpa penggerudian prop. Ia membungkus komponen dalam penyedia konteks, membenarkan komponen bersarang dalam mengakses data kongsi.

Faedah

1. Mengelakkan Penggerudian Prop: Memudahkan penghantaran data melalui komponen bersarang dalam.
2. Pengurusan Negeri Berpusat: Urus keadaan global seperti tema atau pengesahan dengan mudah.

Contoh: Konteks Tema

const initialState = { isAuthenticated: false, user: null };

function authReducer(state, action) {
  switch (action.type) {
    case "LOGIN":
      return { ...state, isAuthenticated: true, user: action.payload };
    case "LOGOUT":
      return initialState;
    default:
      return state;
  }
}

Menggunakan Konteks

import React, { useState, useEffect } from "react";
import UserList from "./UserList";

const UserContainer = () => {
  const [users, setUsers] = useState([]);
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    fetch("/api/users")
      .then((response) => response.json())
      .then((data) => {
        setUsers(data);
        setLoading(false);
      })
      .catch(() => setLoading(false));
  }, []);

  return <UserList users={users} loading={loading} />;
};

export default UserContainer;

Komponen Pesanan Tinggi (HOC)

Komponen Pesanan Tinggi (HOC) ialah fungsi yang mengambil komponen dan mengembalikan komponen baharu dengan fungsi tambahan. Ia membenarkan anda menggunakan semula logik merentas berbilang komponen tanpa mengubah suai strukturnya.

Faedah

1. Kebolehgunaan Kod: Kongsi logik seperti pengesahan atau tema merentas komponen.
2. Encapsulation: Pastikan logik yang dipertingkatkan berasingan daripada komponen asal.

Contoh: HOC Pengesahan

import React from "react";

const UserList = ({ users, loading }) => {
  if (loading) return <p>Loading...</p>;

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

export default UserList;

Komponen Kompaun

Corak Komponen Kompaun membolehkan anda membina komponen induk dengan berbilang komponen anak yang berfungsi bersama secara padu. Corak ini sesuai untuk mencipta komponen UI yang fleksibel dan boleh digunakan semula.

Faedah

1. Kebolehsuaian: Komponen kanak-kanak boleh digabungkan dengan cara yang berbeza.
2. Kejelasan: Tentukan dengan jelas perhubungan antara komponen ibu bapa dan anak.

Contoh: Komponen Tab

import { useState, useEffect } from "react";

const useFetchData = (url) => {
  const [data, setData] = useState(null);
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    fetch(url)
      .then((res) => res.json())
      .then((result) => {
        setData(result);
        setLoading(false);
      });
  }, [url]);

  return { data, loading };
};

export default useFetchData;

1. useMemo: Menghafal hasil pengiraan, mengira semula hanya apabila kebergantungan berubah.

import React from "react";
import useFetchData from "./useFetchData";

const Posts = () => {
  const { data: posts, loading } = useFetchData("/api/posts");

  if (loading) return <p>Loading...</p>;
  return (
    <ul>
      {posts.map((post) => (
        <li key={post.id}>{post.title}</li>
      ))}
    </ul>
  );
};

export default Posts;

1. useCallback: Mengingat fungsi, berguna apabila menghantar panggilan balik kepada komponen anak.

const initialState = { isAuthenticated: false, user: null };

function authReducer(state, action) {
  switch (action.type) {
    case "LOGIN":
      return { ...state, isAuthenticated: true, user: action.payload };
    case "LOGOUT":
      return initialState;
    default:
      return state;
  }
}

Memoisasi meningkatkan prestasi dalam senario yang melibatkan set data yang besar atau kemas kini UI yang kompleks, memastikan apl React kekal responsif.

Kesimpulan

Menguasai corak reka bentuk bertindak balas adalah kunci untuk membina aplikasi yang boleh skala, boleh diselenggara dan cekap. Dengan menggunakan corak seperti Komponen Bekas dan Persembahan, Cangkuk Tersuai dan Memoisasi, anda boleh menyelaraskan pembangunan, meningkatkan kebolehgunaan semula kod dan meningkatkan prestasi. Corak lanjutan seperti Komponen Pesanan Tinggi, Komponen Kompaun dan Corak Pembekal memudahkan lagi pengurusan keadaan dan interaksi komponen yang kompleks.

Corak ini bukan sekadar teori—ia menangani cabaran dunia sebenar dalam pembangunan React, membantu anda menulis kod yang bersih dan modular. Mula menggabungkan corak ini ke dalam projek anda untuk mencipta aplikasi yang teguh, mudah untuk skala dan boleh diselenggara untuk jangka panjang. Dengan corak reka bentuk React dalam kit alat anda, anda akan lebih bersedia untuk menangani sebarang projek, tidak kira betapa rumitnya.
Untuk mendapatkan lebih banyak cerapan, lihat dokumentasi React Design Patterns pada Patterns.dev.

Atas ialah kandungan terperinci Corak Reka Bentuk React: Amalan Terbaik untuk Aplikasi Boleh Skala. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!