TypeScript Academy · บทเรียน

การยืนยันซ้อนและความเสี่ยง

ทำความเข้าใจว่าเมื่อใดจำเป็นต้องใช้ as unknown as T และเหตุใดจึงอันตราย

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

การยืนยันซ้อนคืออะไร

การยืนยันซ้อนจะเชื่อมการแปลงชนิดด้วย as สองครั้ง โดยมักผ่าน unknown: value as unknown as T วิธีนี้บังคับให้เกิดการแปลงที่คอมไพเลอร์จะปฏิเสธหากใช้วิธีปกติ

const s = 'hello';
const n = s as unknown as number; // forced
console.log(typeof n); // still 'string' at runtime!

เหตุใด TS จึงบล็อกการแปลงชนิดโดยตรง

TypeScript จะบล็อก s as number เมื่อ string และ number ไม่มีส่วนที่ทับซ้อนกัน เพราะเกือบแน่นอนว่านั่นเป็นความผิดพลาด ข้อผิดพลาดนี้ช่วยป้องกันคุณจากการยืนยันที่ไม่สมเหตุสมผล

const s = 'text';
// const n = s as number; // Error: types do not sufficiently overlap
console.log('Direct unrelated assertion is rejected');

เหตุใด unknown จึงเปิดทางให้แปลงชนิดได้

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

const s = 'text';
const step1 = s as unknown; // always allowed
const step2 = step1 as number; // allowed from unknown
console.log(typeof step2);

การยืนยันซ้อนหลอกคอมไพเลอร์

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

const fake = 'oops' as unknown as number;
console.log(fake + 1); // 'oops1' — string concatenation at runtime

การใช้ผิดวิธีที่พบได้จริง

บางครั้งนักพัฒนาใช้การยืนยันซ้อนเพื่อปิดบังข้อผิดพลาดเมื่อรูปร่างของข้อมูลไม่ตรงกัน วิธีนี้ซ่อนข้อบกพร่องที่มีอยู่จริง เพราะค่าดังกล่าวไม่เคยมีคุณสมบัติตามที่อ้างไว้

type User = { id: number; name: string };
const partial = { id: 1 };
const user = partial as unknown as User;
console.log(user.name); // undefined at runtime

เมื่อใดจึงจำเป็นต้องใช้การยืนยันซ้อน

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

// Bridging a known-compatible external type:
type LibA = { value: number };
type LibB = { value: number };
const a: LibA = { value: 5 };
const b = a as unknown as LibB; // structurally identical
console.log(b.value);

เหตุใดจึงเป็นสัญญาณเตือนของโค้ด

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

// Treat 'as unknown as' as a red flag in code review.
const data: unknown = JSON.parse('{}');
// Better: validate with a type guard instead of forcing.
console.log('Prefer validation over double assertion');

เลือกใช้การตรวจสอบความถูกต้อง

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

type User = { id: number; name: string };
function isUser(v: unknown): v is User {
  return typeof v === 'object' && v !== null &&
    'id' in v && 'name' in v;
}
const raw: unknown = { id: 1, name: 'Sam' };
if (isUser(raw)) console.log(raw.name);

เลือกใช้การแปลงชนิดอย่างถูกต้อง

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

const s = '42';
const n = Number(s); // real conversion
console.log(n + 1, typeof n);

อธิบายกรณีที่ถูกต้องซึ่งพบได้น้อย

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

type Raw = { ts: number };
type Event = { ts: number };
const raw: Raw = { ts: 100 };
// Safe: Raw and Event are structurally identical.
const ev = raw as unknown as Event;
console.log(ev.ts);

สรุปแนวทาง

หลักง่าย ๆ คือ หากคุณกำลังเขียน as unknown as ให้หยุดและถามตัวเองว่าการตรวจสอบความถูกต้องหรือการแปลงจะปลอดภัยกว่าหรือไม่ ในเก้าครั้งจากสิบครั้ง คำตอบคือใช่

// Decision: validate? convert? or genuinely bridge identical types?
const input = '7';
const parsed = Number.parseInt(input, 10); // convert, don't force
console.log(parsed);

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

ทดสอบความเข้าใจเกี่ยวกับการยืนยันซ้อนของคุณ

ทบทวน: การยืนยันซ้อน

คุณได้เรียนรู้ว่า:

value as unknown as T บังคับให้เกิดการแปลงชนิดที่ TypeScript จะปฏิเสธหากใช้วิธีปกติ
วิธีนี้ทำงานได้เพราะ unknown มีส่วนทับซ้อนกับทุกชนิดข้อมูล แต่จะไม่เปลี่ยนแปลงสิ่งใดขณะทำงาน
นี่คือสัญญาณเตือนของโค้ด เพราะคุณกำลังฝืนระบบชนิดข้อมูลและสูญเสียการปกป้องจากระบบ
ควรเลือกใช้การตรวจสอบความถูกต้อง (ตัวตรวจสอบชนิด) หรือการแปลงจริงแทน

ต่อไปคือการเปรียบเทียบการยืนยันกับตัวตรวจสอบชนิดแบบตรงประเด็น

// Validate, don't force:
const raw: unknown = '99';
const n = typeof raw === 'string' ? Number(raw) : 0;
console.log(n);

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

บทเรียน “การยืนยันซ้อนและความเสี่ยง” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “การยืนยันซ้อนและความเสี่ยง”

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

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

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

บทเรียน “การยืนยันซ้อนและความเสี่ยง” ใช้เวลานานแค่ไหน

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

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

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

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

← กลับไปที่ TypeScript Academy