TypeScript Academy · บทเรียน

ชนิด any และเหตุผลที่ควรหลีกเลี่ยง

ทำความเข้าใจ any และกรณีที่ชนิดนี้ทำให้จุดประสงค์ของ TypeScript สูญเสียไป

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

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

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

ชนิด `any` เป็นช่องทางหลีกหนีของ TypeScript ซึ่งปิดการตรวจสอบชนิดทั้งหมดสำหรับตัวแปรหนึ่งตัว ในบทเรียนนี้ คุณจะเข้าใจว่าชนิดนี้ปรากฏขึ้นเมื่อใดและเหตุใดจึงควรใช้ให้น้อยที่สุด

ชนิดใดก็ได้ทำอะไรได้บ้าง

ตัวแปรที่มีชนิดเป็น `any` สามารถเก็บค่าใดก็ได้และรองรับการดำเนินการใดก็ได้ TypeScript จะหยุดตรวจสอบตัวแปรนี้โดยสิ้นเชิง
let x: any = 5;
x = 'hello';       // OK
x = true;          // OK
x.nonExistent();   // No error — but crashes at runtime!

ชนิดใดก็ได้แพร่กระจายอย่างไร

การกำหนดตัวแปร `any` ให้กับตัวแปรที่มีชนิดจะทำให้ตัวแปรที่มีชนนิดนั้นได้รับผลกระทบตามไปด้วย `any` แพร่กระจายไปทั่วฐานโค้ดของคุณอย่างเงียบ ๆ
let data: any = fetchData();
let name: string = data.name; // name is now effectively any

เมื่อใดที่ TypeScript อนุมานเป็นชนิดใดก็ได้

หากคุณประกาศตัวแปรโดยไม่มีค่าเริ่มต้นและไม่มีคำอธิบายชนิด TypeScript จะอนุมานเป็น `any` เปิดใช้ `noImplicitAny` เพื่อให้กรณีนี้กลายเป็นข้อผิดพลาดขณะคอมไพล์
let value; // inferred as any — dangerous!
value = 42;
value = 'hello';

// Fix:
let value2: number;

แฟล็ก noImplicitAny

ตัวเลือกคอมไพเลอร์ `noImplicitAny` ซึ่งเปิดใช้โดย `strict` จะบังคับให้คุณระบุชนิด แทนที่จะย้อนกลับไปใช้ `any` โดยค่าเริ่มต้น
// tsconfig.json
{ "compilerOptions": { "noImplicitAny": true } }

// Now this is an error:
function process(data) { } // Error: Parameter has implicit any type

การใช้งานชนิดใดก็ได้อย่างเหมาะสม

บางครั้ง `any` ก็หลีกเลี่ยงไม่ได้ เช่น ระหว่างการย้ายจาก JavaScript การจัดการไลบรารีจากภายนอกที่ไม่มีชนิด หรือการทำงานกับข้อมูลที่เปลี่ยนแปลงได้อย่างแท้จริง ควรใช้ชนิดนี้อย่างประหยัดและจำกัดไว้เฉพาะจุด
// Acceptable: narrow scope, clearly documented
function parseJson(raw: string): any {
  return JSON.parse(raw); // validate with Zod afterwards
}

การยืนยันชนิดเป็นทางเลือก

แทนที่จะใช้ `any` ให้ใช้การยืนยันชนิดเมื่อคุณมีข้อมูลมากกว่าคอมไพเลอร์ วิธีนี้ปลอดภัยกว่าเพราะคุณยืนยันว่าจะใช้ชนิดที่เฉพาะเจาะจง
const raw = JSON.parse(text) as { name: string; age: number };
console.log(raw.name); // typed correctly

ชนิดใดก็ได้เทียบกับอ็อบเจกต์

ชนิด `object` ยอมรับค่าที่ไม่ใช่ชนิดพื้นฐานใด ๆ แต่ไม่อนุญาตให้เข้าถึงคุณสมบัติตามอำเภอใจเหมือน `any` จึงเพิ่มความปลอดภัยได้เล็กน้อย
let o: object = { x: 1 };
// o.x; // Error — object doesn't allow property access

let a: any = { x: 1 };
a.x; // OK — but no safety

ชนิดใดก็ได้ปิดการเติมข้อความอัตโนมัติ

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

แทนที่ชนิดใดก็ได้ด้วยชนิดไม่ทราบแน่ชัด

สำหรับข้อมูลภายนอกที่คุณควบคุมไม่ได้ ควรเลือกใช้ `unknown` เพราะบังคับให้คุณจำกัดชนิดให้แคบลงก่อนใช้งาน ต่างจาก `any` ที่อนุญาตให้ทำสิ่งใดก็ได้
let input: unknown = getInput();
// input.toUpperCase(); // Error — must narrow first
if (typeof input === 'string') {
  console.log(input.toUpperCase()); // OK
}

หนี้ของชนิดใดก็ได้

ให้มอง `any` เป็นหนี้ ทุกครั้งที่ใช้จะทำให้ฐานโค้ดปลอดภัยน้อยลง ตั้งเป้าให้โค้ดที่ใช้งานจริงไม่มีชนิด `any` เลย และใช้กฎ @typescript-eslint/no-explicit-any ของ ESLint

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

ตัวเลือกคอมไพเลอร์ใดทำให้ TypeScript รายงานข้อผิดพลาดเมื่อตัวแปรมีชนิด `any` โดยปริยาย

สรุปทบทวน

ชนิด `any` ปิดการตรวจสอบชนิดของ TypeScript และแพร่กระจายไปทั่วโค้ด เปิดใช้ noImplicitAny แทนที่ `any` ด้วย `unknown` สำหรับข้อมูลภายนอก และใช้การยืนยันชนิดในกรณีเฉพาะ
เริ่มต้นได้ฟรี

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

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

คอร์ส
101
บทเรียน
352

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

บทเรียน “ชนิด any และเหตุผลที่ควรหลีกเลี่ยง” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “ชนิด any และเหตุผลที่ควรหลีกเลี่ยง”

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

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

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

บทเรียน “ชนิด any และเหตุผลที่ควรหลีกเลี่ยง” ใช้เวลานานแค่ไหน

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

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

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

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

  1. ชนิดข้อมูลพื้นฐาน: string, number, boolean
  2. ชนิด any และเหตุผลที่ควรหลีกเลี่ยง
  3. unknown เทียบกับ any: ตัวเลือกที่ปลอดภัยกว่า
  4. null, undefined และการตรวจสอบค่า null อย่างเข้มงวด
← กลับไปที่ TypeScript Academy