React Academy · บทเรียน

สล็อตที่ระบุชื่อผ่านพร็อพส์แบบออบเจ็กต์

สร้างสล็อต header/body/footer โดยส่ง JSX ผ่านพร็อพส์ที่ระบุชื่อ

บทเรียน 3 จาก 413 ขั้นตอน

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

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

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

ข้อจำกัดขององค์ประกอบลูก

พร็อพ `children` เพียงรายการเดียวเหมาะกับพื้นที่หนึ่งส่วน แต่เมื่อคอมโพเนนต์ต้องมีพื้นที่เนื้อหาอิสระหลายส่วน เช่น การ์ดที่มีส่วนหัวและท้ายกระดาษ พร็อพที่มีชื่อซึ่งเก็บ JSX คือทางออกที่สะอาดและเหมาะสม

สล็อตพร็อพที่มีชื่อ

กำหนดพร็อพสำหรับแต่ละสล็อตในอินเทอร์เฟซของคอมโพเนนต์ คอมโพเนนต์แม่ส่ง JSX ให้แต่ละพร็อพ จากนั้นคอมโพเนนต์จะแสดงผลแต่ละสล็อตในตำแหน่งที่ถูกต้อง
function Card({ header, body, footer }) {
  return (
    <div className="card">
      <div className="card-header">{header}</div>
      <div className="card-body">{body}</div>
      <div className="card-footer">{footer}</div>
    </div>
  );
}

// Usage
<Card
  header={<h2>Title</h2>}
  body={<p>Content here</p>}
  footer={<button>OK</button>}
/>

สล็อตที่ไม่บังคับ

ทำให้สล็อตไม่บังคับได้โดยแสดงผลเฉพาะเมื่อพร็อพมีค่าเป็นจริง วิธีนี้ทำให้คอมโพเนนต์เดียวกันทำงานได้ทั้งกรณีที่มีหรือไม่มีส่วนท้ายกระดาษ
function Card({ header, children, footer }) {
  return (
    <div>
      {header && <div className="header">{header}</div>}
      <div className="body">{children}</div>
      {footer && <div className="footer">{footer}</div>}
    </div>
  );
}

การผสมองค์ประกอบลูกกับสล็อตที่มีชื่อ

ใช้ `children` สำหรับพื้นที่เนื้อหาหลัก และใช้พร็อพที่มีชื่อสำหรับพื้นที่รอง วิธีนี้สอดคล้องกับหลักการที่ว่ากรณีใช้งานทั่วไปที่สุดควรใช้งานได้สะดวกที่สุด
<Dialog
  title="Confirm"
  actions={<><button>Cancel</button><button>OK</button></>}
>
  <p>Are you sure?</p>  {/* children = primary slot */}
</Dialog>

TypeScript: การกำหนดชนิดให้สล็อตที่มีชื่อ

กำหนดชนิดพร็อพสล็อตที่มีชื่อเป็น `React.ReactNode` เพื่อให้รองรับเนื้อหา JSX ได้ทุกชนิด
interface CardProps {
  header?: React.ReactNode;
  children: React.ReactNode;
  footer?: React.ReactNode;
}

สล็อตที่มีชื่อเทียบกับคอมโพเนนต์ประกอบ

พร็อพที่มีชื่อเรียบง่ายและชัดเจน คอมโพเนนต์ประกอบ เช่น `` ใช้งานสะดวกกว่าสำหรับกลุ่มคอมโพเนนต์ที่ซับซ้อน แต่ต้องตั้งค่าเพิ่มเติมด้วย Context ควรเริ่มจากพร็อพที่มีชื่อ และปรับไปใช้รูปแบบอื่นเมื่อจำเป็น

การส่งคอมโพเนนต์เป็นสล็อต

คุณยังสามารถกำหนดชนิดสล็อตเป็นคอมโพเนนต์ React แทน JSX ได้ คอมโพเนนต์แม่จะส่งการอ้างอิงคอมโพเนนต์ และส่วนจัดวางโครงร่างจะแสดงผลคอมโพเนนต์นั้น วิธีนี้ทำให้ส่วนจัดวางโครงร่างควบคุมได้ว่าจะให้สล็อตแสดงผลเมื่อใดและกี่ครั้ง
function Timeline({ renderItem, items }) {
  return (
    <ul>
      {items.map(item => (
        <li key={item.id}>{renderItem(item)}</li>
      ))}
    </ul>
  );
}

<Timeline
  items={data}
  renderItem={item => <EventCard event={item} />}
/>

การประกอบโครงร่างด้วยสล็อตที่มีชื่อ

คอมโพเนนต์จัดวางหน้าเว็บใช้สล็อตที่มีชื่ออย่างแพร่หลาย คอมโพเนนต์โครงหลักของหน้าที่มีสล็อต `sidebar`, `toolbar` และ `content` ช่วยให้หน้าต่าง ๆ ประกอบโครงหลักเดียวกันได้ โดยมีเนื้อหาในแต่ละพื้นที่แตกต่างกันอย่างสิ้นเชิง

การจัดทำเอกสารสำหรับสล็อตที่มีชื่อ

สล็อตที่มีชื่อสามารถอธิบายตัวเองได้ผ่านอินเทอร์เฟซ TypeScript หรือ PropTypes ผู้ใช้คอมโพเนนต์จะเห็นได้อย่างชัดเจนว่าสล็อตใดพร้อมใช้งานและสล็อตใดไม่บังคับ จึงลดความจำเป็นในการจัดทำเอกสารภายนอก

ตรวจสอบความเข้าใจ

ควรใช้ชนิด TypeScript ใดสำหรับพร็อพสล็อตที่มีชื่อซึ่งรองรับ JSX ได้ทุกชนิด

สรุปทบทวน

พร็อพสล็อตที่มีชื่อทำให้คอมโพเนนต์จัดวางโครงร่างยืดหยุ่นและอธิบายตัวเองได้ ใช้ children สำหรับพื้นที่หลัก ใช้พร็อพที่มีชื่อสำหรับพื้นที่รอง และกำหนดชนิดเป็น React.ReactNode

ถัดไป

บทเรียนถัดไป: **การโคลนและใส่พร็อพด้วย cloneElement** — คุณจะใช้ React.cloneElement เพื่อส่งพร็อพที่ซ่อนอยู่จากคอมโพเนนต์แม่ไปยังองค์ประกอบลูก
เริ่มต้นได้ฟรี

เรียนรู้ React ด้วย AI tutor — ฟรี

เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป

คอร์ส
88
บทเรียน
324

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

บทเรียน “สล็อตที่ระบุชื่อผ่านพร็อพส์แบบออบเจ็กต์” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “สล็อตที่ระบุชื่อผ่านพร็อพส์แบบออบเจ็กต์”

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

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

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

บทเรียน “สล็อตที่ระบุชื่อผ่านพร็อพส์แบบออบเจ็กต์” ใช้เวลานานแค่ไหน

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

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

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

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

  1. พื้นฐาน props.children
  2. ยูทิลิตี React.Children
  3. สล็อตที่ระบุชื่อผ่านพร็อพส์แบบออบเจ็กต์
  4. การโคลนและแทรกพร็อพส์ด้วย cloneElement
← กลับไปที่ React Academy