0Pricing
React Academy · บทเรียน

คอมโพเนนต์บริสุทธิ์และการหลีกเลี่ยงผลข้างเคียงในการเรนเดอร์

เขียนฟังก์ชันเรนเดอร์ที่ไม่มีการกลายค่าและการอ่านข้อมูลภายนอก

คอมโพเนนต์บริสุทธิ์และการหลีกเลี่ยงผลข้างเคียงในการเรนเดอร์ เป็นบทเรียน React Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน React Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส React Academy มีบทเรียนทั้งหมด 4 บทเรียน

ยินดีต้อนรับ

ในบทเรียนนี้ คุณจะได้เรียนรู้ว่าคอมโพเนนต์ Pure ใน React หมายถึงอะไร เหตุใดฟังก์ชัน render จึงต้องปราศจากผลข้างเคียง และวิธีค้นหาและแก้ไขการละเมิดความบริสุทธิ์ที่พบบ่อย

ฟังก์ชัน Pure คืออะไร

ฟังก์ชัน Pure จะส่งคืนเอาต์พุตเดิมเสมอเมื่อได้รับอินพุตเดิม และไม่ก่อให้เกิดผลข้างเคียงที่สังเกตได้ React คาดหวังให้ฟังก์ชันคอมโพเนนต์ของคุณเป็น Pure กล่าวคือ เมื่อได้รับพร็อพส์และสถานะเดิม ก็ควรส่งคืน JSX เดิมเสมอ

เหตุใดความบริสุทธิ์จึงสำคัญใน React

React อาจเรียกใช้คอมโพเนนต์ของคุณหลายครั้ง (StrictMode ฟีเจอร์การทำงานพร้อมกัน และการ render บนเซิร์ฟเวอร์) หากการ render ของคุณมีผลข้างเคียง เช่น การเรียกเอพีไอ การเปลี่ยนแปลง DOM หรือการเขียนตัวแปรส่วนกลาง ผลเหล่านั้นจะทำงานหลายครั้งโดยคาดเดาไม่ได้

ความไม่บริสุทธิ์ที่พบบ่อย: การแก้ไขสถานะภายนอก

อย่าแก้ไขตัวแปรที่กำหนดไว้นอกคอมโพเนนต์ระหว่างการ render โดยเด็ดขาด การแก้ไขข้อมูลทำได้ภายในตัวจัดการเหตุการณ์หรือ useEffect แต่ทำไม่ได้ในระหว่างการ render
let totalRenders = 0; // external
function Counter() {
  totalRenders++; // BAD: side effect in render
  return <p>{totalRenders}</p>;
}

ความไม่บริสุทธิ์ที่พบบ่อย: การแก้ไขพร็อพส์

อย่าแก้ไขออบเจ็กต์พร็อพส์ภายในคอมโพเนนต์โดยเด็ดขาด พร็อพส์เป็นข้อมูลแบบอ่านอย่างเดียว หากต้องการเวอร์ชันที่แก้ไขแล้ว ให้สร้างตัวแปรใหม่
// Bad
function Badge({ user }) {
  user.name = user.name.toUpperCase(); // mutates prop!
  return <p>{user.name}</p>;
}

// Good
function Badge({ user }) {
  const displayName = user.name.toUpperCase();
  return <p>{displayName}</p>;
}

ความไม่บริสุทธิ์ที่พบบ่อย: การใช้ค่าสุ่มหรือวันที่ในการ render

การเรียก `Math.random()` หรือ `Date.now()` โดยตรงในการ render จะสร้างค่าที่แตกต่างกันในแต่ละครั้งที่เรียกใช้ ทำลายความบริสุทธิ์ ให้ย้ายการทำงานเหล่านี้ไปไว้ในตัวกำหนดค่าเริ่มต้นของสถานะหรือ useEffect
// Bad
function Token() {
  const id = Math.random(); // different every render!
  return <p>{id}</p>;
}

// Good
function Token() {
  const [id] = useState(() => Math.random());
  return <p>{id}</p>;
}

การเรียกเอพีไอควรอยู่ใน useEffect

การดึงข้อมูลโดยตรงภายในเนื้อหาฟังก์ชันคอมโพเนนต์ (ไม่ใช่ใน useEffect) ถือเป็นความไม่บริสุทธิ์ เพราะจะทำงานในการ render ทุกครั้ง ให้ย้ายการเรียกดึงข้อมูลไปไว้ใน useEffect พร้อมการพึ่งพาที่เหมาะสมเสมอ
// Bad
function Profile({ id }) {
  fetch('/api/user/' + id); // runs on every render!
  return <div />;
}

// Good
useEffect(() => {
  fetch('/api/user/' + id).then(/*...*/);
}, [id]);

การแก้ไขข้อมูลภายในทำได้

การสร้างและแก้ไขออบเจ็กต์หรืออาร์เรย์ที่สร้างขึ้น *ภายใน* การเรียกใช้ render เดียวกันทำได้อย่างสมบูรณ์ เพราะไม่มีส่วนอื่นสังเกตเห็นข้อมูลเหล่านั้นได้ การทำเช่นนี้เรียกว่าการแก้ไขข้อมูลภายใน
function List({ items }) {
  const sorted = [...items]; // new array
  sorted.sort();             // mutating a local copy: OK
  return sorted.map(i => <li key={i}>{i}</li>);
}

ใช้ StrictMode เพื่อค้นหาความไม่บริสุทธิ์

React StrictMode จะเรียกใช้คอมโพเนนต์ของคุณสองครั้งในการพัฒนา หากส่วนติดต่อผู้ใช้ไม่สอดคล้องกันระหว่างการเรียกใช้ทั้งสองครั้ง หรือคุณเห็นผลข้างเคียงซ้ำ แสดงว่าการ render ของคุณไม่บริสุทธิ์ ให้แก้ไขความไม่บริสุทธิ์จนกว่าการเรียกใช้ซ้ำจะไม่ก่อปัญหา

คอมโพเนนต์ Pure และ React.memo

เมื่อคอมโพเนนต์เป็น Pure (พร็อพส์เดิม → เอาต์พุตเดิม) การครอบคอมโพเนนต์ด้วย `React.memo` จะบอก React ว่าสามารถข้ามการ render ใหม่ได้หากพร็อพส์ไม่เปลี่ยน ซึ่งช่วยเพิ่มประสิทธิภาพ
const Pure = React.memo(function Pure({ value }) {
  return <p>{value}</p>;
});

ตรวจสอบอย่างรวดเร็ว

ข้อใดต่อไปนี้เป็นผลข้างเคียงที่ยอมรับได้เมื่อทำโดยตรงภายในฟังก์ชัน render ของคอมโพเนนต์ React

สรุป

คอมโพเนนต์ Pure จะส่งคืน JSX เดิมเสมอเมื่อได้รับอินพุตเดิม หลีกเลี่ยงการแก้ไขพร็อพส์หรือตัวแปรภายนอกในการ render ใช้ useEffect สำหรับผลข้างเคียง และใช้ StrictMode เพื่อค้นหาการละเมิดความบริสุทธิ์

ถัดไป

บทเรียนถัดไป: **แนวปฏิบัติที่ดีที่สุดสำหรับคีย์และการอ้างอิง** — คุณจะใช้คีย์ที่คงที่อย่างถูกต้อง หลีกเลี่ยงข้อผิดพลาดจากการใช้ดัชนีเป็นคีย์ และทำงานกับการอ้างอิงแบบเรียกกลับ

คำถามที่พบบ่อย

บทเรียน “คอมโพเนนต์บริสุทธิ์และการหลีกเลี่ยงผลข้างเคียงในการเรนเดอร์” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “คอมโพเนนต์บริสุทธิ์และการหลีกเลี่ยงผลข้างเคียงในการเรนเดอร์” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส React Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส React Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “คอมโพเนนต์บริสุทธิ์และการหลีกเลี่ยงผลข้างเคียงในการเรนเดอร์”

เขียนฟังก์ชันเรนเดอร์ที่ไม่มีการกลายค่าและการอ่านข้อมูลภายนอก คุณปฏิบัติ React Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน React Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน React Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน

บทเรียน “คอมโพเนนต์บริสุทธิ์และการหลีกเลี่ยงผลข้างเคียงในการเรนเดอร์” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน React Academy นี้ได้ไหม

ได้ บทเรียน React Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

  1. StrictMode ทำอะไร
  2. คอมโพเนนต์บริสุทธิ์และการหลีกเลี่ยงผลข้างเคียงในการเรนเดอร์
  3. แนวทางปฏิบัติที่ดีสำหรับ Key และ Ref
  4. โครงสร้างโฟลเดอร์และหลักการตั้งชื่อ
← กลับไปที่ React Academy