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

Partial และ Required: การสลับสถานะเสริม

ทำให้ทุกพร็อพเพอร์ตีเป็นแบบเสริมหรือจำเป็นพร้อมกัน

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

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

Partial ทำให้คุณสมบัติทั้งหมดเป็นตัวเลือกได้ ส่วน Required ทำให้คุณสมบัติทั้งหมดจำเป็น ทั้งสองเป็นประเภทเครื่องมือที่ใช้บ่อยที่สุดสำหรับการจัดการข้อมูลอย่างยืดหยุ่น

Partial<T>

Partial ทำให้คุณสมบัติทุกอย่างของ T เป็นตัวเลือก เหมาะสำหรับการดำเนินการอัปเดตหรือแก้ไขบางส่วนเมื่อคุณมีข้อมูลไม่ครบทุกช่อง
interface User { id: number; name: string; email: string; }
type PartialUser = Partial<User>;
// { id?: number; name?: string; email?: string; }

Partial ในฟังก์ชันอัปเดต

ใช้ Partial เมื่อสร้างฟังก์ชันอัปเดตหรือผสานข้อมูลที่รับเฉพาะช่องข้อมูลที่เปลี่ยนแปลง
function updateUser(id: number, changes: Partial<User>): User {
  const existing = findUser(id)!;
  return { ...existing, ...changes };
}

Required<T>

Required ลบตัวปรับแต่งตัวเลือกทั้งหมด ทำให้คุณสมบัติทุกอย่างเป็นสิ่งจำเป็น
type RequiredUser = Required<User>;
// All properties are now required — including those that were optional

Required สำหรับตรวจสอบการกำหนดค่า

ใช้ Required หลังจากผสานค่าเริ่มต้น เพื่อให้แน่ใจว่ามีค่าการกำหนดค่าครบถ้วน
interface Config { host?: string; port?: number; }
const defaults: Required<Config> = { host: 'localhost', port: 3000 };
function createConfig(opts: Config): Required<Config> {
  return { ...defaults, ...opts };
}

การทำงานภายในของ Partial

Partial ใช้ประเภทแบบแมปที่มีตัวปรับแต่ง +?
type Partial<T> = { [K in keyof T]?: T[K] };
// Equivalent to: { [K in keyof T]+?: T[K] }

การทำงานภายในของ Required

Required ใช้ประเภทแบบแมปที่มีตัวปรับแต่ง -?
type Required<T> = { [K in keyof T]-?: T[K] };

Deep Partial

Partial ที่มีมาให้ในระบบทำงานเพียงระดับเดียว สำหรับออบเจ็กต์ที่ซ้อนกัน คุณต้องใช้ DeepPartial แบบเรียกซ้ำ
type DeepPartial<T> = {
  [K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K]
};

การรวม Partial กับ Required

กำหนดให้บางช่องข้อมูลเป็นสิ่งจำเป็น พร้อมคงช่องข้อมูลอื่นไว้เป็นตัวเลือก โดยใช้ชนิดจุดตัด
// id required, everything else optional
type UpsertUser = Required<Pick<User, 'id'>> & Partial<Omit<User, 'id'>>;

Partial กับคุณสมบัติตัวเลือกในอินเทอร์เฟซ

การประกาศให้คุณสมบัติทั้งหมดของอินเทอร์เฟซเป็นตัวเลือกมีผลเหมือนการใช้ Partial แต่ใช้ได้เฉพาะกับประเภทนั้น ส่วน Partial สามารถนำกลับมาใช้กับประเภทใดก็ได้

การอนุมานประเภทด้วย Partial

TypeScript จำกัดประเภทของคุณสมบัติ Partial ได้อย่างถูกต้อง การเข้าถึงคุณสมบัติเหล่านี้อาจส่งคืน T[K] | undefined
function show(u: Partial<User>) {
  if (u.name !== undefined) {
    console.log(u.name.toUpperCase()); // safe
  }
}

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

ประเภทเครื่องมือใดทำให้คุณสมบัติทั้งหมดของอินเทอร์เฟซเป็นสิ่งจำเป็น รวมถึงคุณสมบัติที่เคยเป็นตัวเลือก

สรุปทบทวน

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

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

บทเรียน “Partial และ Required: การสลับสถานะเสริม” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “Partial และ Required: การสลับสถานะเสริม”

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

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

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

บทเรียน “Partial และ Required: การสลับสถานะเสริม” ใช้เวลานานแค่ไหน

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

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

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

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

  1. Partial และ Required: การสลับสถานะเสริม
  2. Pick และ Omit: การเลือกพร็อพเพอร์ตี
  3. Record: การแมปคีย์กับชนิดค่า
  4. Readonly, Exclude, Extract, NonNullable
← กลับไปที่ TypeScript Academy