หมวดหมู่: Backend

ในโลกของการพัฒนาซอฟต์แวร์ขนาดใหญ่ ความแม่นยำของชนิดข้อมูล (Type Safety) คือรากฐานสำคัญที่ช่วยให้โค้ดมีความน่าเชื่อถือและง่ายต่อการบำรุงรักษา TypeScript ถูกสร้างขึ้นมาเพื่อยกระดับ JavaScript ด้วยระบบ Type System ที่แข็งแกร่ง แต่เมื่อเราต้องจัดการกับข้อมูลที่มีโครงสร้างซับซ้อน เช่น ข้อมูลที่ดึงมาจากฐานข้อมูล PostgreSQL การกำหนดชนิดข้อมูลพื้นฐานอย่าง `string` หรือ `number` จึงยังไม่เพียงพอ บทบาทของ “Object Types” จึงกลายเป็นหัวใจสำคัญในการสร้างความมั่นใจให้กับโค้ดของคุณ

TypeScript Object Types คืออะไร? (Structural Typing)

Object Types ใน TypeScript คือกลไกที่ช่วยให้เราสามารถกำหนด ‘รูปร่าง’ (Shape) ของข้อมูลที่คาดหวังได้ โดยหลักการที่สำคัญที่สุดคือ **Structural Typing** ซึ่งหมายความว่า TypeScript ไม่ได้สนใจว่า Object นั้นถูกสร้างมาจาก Class ใด แต่สนใจแค่ว่า Object นั้นมีคุณสมบัติ (Properties) อะไรบ้าง และแต่ละคุณสมบัติมีชนิดข้อมูลอะไร

ตัวอย่างเช่น หากเรากำหนดว่า Object ต้องมี `user_id` เป็น `number` และ `username` เป็น `string` ตัวแปรใดก็ตามที่มีโครงสร้างตรงตามนี้ก็จะถูกยอมรับ แม้ว่ามันจะไม่ได้มาจาก Class ที่เรากำหนดไว้ก็ตาม นี่คือจุดเด่นเชิงวิศวกรรมที่ช่วยให้เราสามารถตรวจสอบรูปแบบข้อมูล (Data Schema) ได้ตั้งแต่ขั้นตอน Compile Time ก่อนที่จะนำไปรันจริง ซึ่งเป็นประโยชน์อย่างยิ่งในการจัดการผลลัพธ์ที่ได้จาก PostgreSQL

Interface vs. Type Aliases: ข้อแตกต่างทางเทคนิคและการเลือกใช้

เมื่อต้องการกำหนดรูปทรง (Shape) ให้กับ Objects ใน TypeScript นักพัฒนาจะมีเครื่องมือหลักอยู่สองตัวคือ interface และ type ทั้งสองตัวสามารถใช้กำหนด Object Shape ได้ แต่มีข้อแตกต่างทางเทคนิคที่ควรทราบ:

1. Interface (การกำหนดโครงสร้าง)

interface มักถูกใช้เพื่อกำหนดโครงสร้างของ Object หรือ Class เป็นหลัก และมีจุดเด่นในการขยาย (Extending) หรือรวม (Implementing) โครงสร้างข้อมูลได้ง่าย

SQL

-- การกำหนดโครงสร้างข้อมูลที่คาดว่าจะได้จาก PostgreSQL Query Result (Schema Definition)</code>
interface UserRecord {
  user_id: number;
  username: string;
  is_active: boolean;
}

// ตัวอย่างการใช้: ฟังก์ชันที่รับข้อมูล UserRecord
function processUser(user: UserRecord): void {
  console.log(`Processing user: ${user.username}`);
}

2. Type Alias (การกำหนดชื่อชนิดข้อมูล)

type มีความยืดหยุ่นกว่า และสามารถใช้กำหนดชนิดข้อมูลที่ซับซ้อนกว่าได้ เช่น Union Types (การรวมชนิดข้อมูล) หรือ Tuple Types (ลำดับของข้อมูล) ซึ่งเหมาะมากเมื่อคุณต้องการกำหนดชนิดข้อมูลที่อาจเป็นได้หลายรูปแบบ

SQL

-- การกำหนดชนิดข้อมูลที่อาจเป็นได้หลายรูปแบบ (Union Type) เช่น ID ที่เป็นได้ทั้ง number หรือ string
type PrimaryKey = number | string;

// ตัวอย่างการใช้: การกำหนดชนิดข้อมูลสำหรับ ID ที่มาจากคอลัมน์ที่อาจมีการเปลี่ยนชนิดข้อมูล
function getRecord(id: PrimaryKey): void {
  -- โค้ดที่ใช้ ID นี้ในการเรียกใช้ PostgreSQL
}

การใช้งานขั้นสูง: การแมปข้อมูลจาก PostgreSQL

ในทางปฏิบัติ การใช้ Object Types ที่ทรงพลังที่สุดคือการแมป (Mapping) โครงสร้างข้อมูลที่ได้จาก PostgreSQL Query ให้ตรงกับ Object Type ที่เรากำหนดไว้ เพื่อให้มั่นใจว่าข้อมูลที่ส่งต่อในระบบจะไม่มีการผิดพลาดของโครงสร้าง (Schema Mismatch) เช่น หากเราคาดหวังว่าคอลัมน์ `email` จะเป็น `text` แต่จริง ๆ มันเป็น `varchar` การตรวจสอบ Type System จะช่วยแจ้งเตือนเราให้แก้ไขก่อนที่แอปพลิเคชันจะล่ม

บทสรุป

การทำความเข้าใจ Object Types ใน TypeScript ไม่ได้เป็นเพียงแค่การกำหนดตัวแปร แต่เป็นการสร้างสัญญา (Contract) ของข้อมูลที่ชัดเจนระหว่างส่วนต่าง ๆ ของระบบ เมื่อคุณใช้ Object Types อย่างถูกต้อง คุณกำลังยกระดับความปลอดภัยของโค้ดให้เทียบเท่ากับการออกแบบ Schema ที่แข็งแกร่งใน PostgreSQL ทำให้โค้ดของคุณมีความทนทาน (Robust) และง่ายต่อการบำรุงรักษาในระยะยาว