TypeScript Academy · บทเรียน

ข้อมูลลับและความปลอดภัยด้านชนิดข้อมูล

จัดการค่าที่ละเอียดอ่อนโดยไม่ทำให้ค่าดังกล่าวรั่วไหลเข้าไปในชนิดข้อมูล

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

ข้อมูลลับต้องได้รับการดูแลเป็นพิเศษ

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

ปัญหาการบันทึกข้อมูลลับโดยไม่ตั้งใจ

ข้อมูลลับที่เป็นสตริงธรรมดาอาจถูกบันทึกที่ใดก็ได้โดยไม่ตั้งใจ เช่นผ่าน console.log(config) หรือการส่งออกข้อผิดพลาดที่แปลงออบเจ็กต์การกำหนดค่าทั้งหมดเป็นสตริง

const config = { dbPassword: "hunter2" };
console.log(config); // leaks the password

ประเภทข้อมูลลับแบบมีตราสัญลักษณ์

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

type Secret = string & { readonly __brand: "Secret" };
function secret(s: string): Secret { return s as Secret; }

เหตุใดการติดตราสัญลักษณ์จึงช่วยได้

เนื่องจาก Secret ไม่สามารถกำหนดให้เป็น string ธรรมดาได้โดยไม่มีเจตนา ฟังก์ชันจึงสามารถกำหนดให้รับ Secret ในจุดที่เหมาะสม และคุณจะไม่สามารถส่งต่อค่าไปยังจุดที่ไม่ปลอดภัยโดยไม่ได้ตั้งใจ

function connect(pw: Secret) { /* uses pw */ }
// connect("plain") -> type error; must wrap with secret()

คลาสตัวห่อข้อมูลลับ

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

class Secret {
  constructor(private readonly value: string) {}
  expose(): string { return this.value; }
  toString() { return "[REDACTED]"; }
}

ปิดบังข้อมูลระหว่างการแปลงเป็นสตริง

การกำหนด toJSON เองช่วยรับรองว่าข้อมูลลับจะไม่ปรากฏเมื่อออบเจ็กต์ถูกแปลงเป็นสตริงด้วย JSON.stringify ซึ่งเป็นช่องทางที่ข้อมูลรั่วไหลโดยไม่ตั้งใจพบบ่อยที่สุด

class Secret {
  constructor(private readonly value: string) {}
  expose() { return this.value; }
  toJSON() { return "[REDACTED]"; }
}
// JSON.stringify({ pw: new Secret("x") }) -> {"pw":"[REDACTED]"}

เปิดเผยอย่างชัดเจนเท่านั้น

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

const pw = new Secret("hunter2");
console.log(String(pw)); // [REDACTED]
connectToDb(pw.expose()); // deliberate access

อย่าใส่ข้อมูลลับไว้ในประเภทกว้าง

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

interface Config {
  host: string;
  dbPassword: Secret; // not a plain string
}

โหลดข้อมูลลับอย่างปลอดภัย

ห่อค่าลับจาก env ทันทีที่อ่าน เพื่อให้ค่าถูกติดตราสัญลักษณ์หรือห่อไว้ตั้งแต่วินาทีแรก และไม่เคยลอยอยู่ในรูปสตริงธรรมดา

const config = {
  host: process.env.DB_HOST!,
  dbPassword: new Secret(process.env.DB_PASSWORD!),
};

การป้องกันหลายชั้น

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

สรุปเทคนิค

ใช้ ชนิดข้อมูลแบบมีตรา เพื่อบังคับให้จัดการอย่างรอบคอบ ใช้ คลาสห่อหุ้ม ที่ลบข้อมูลลับใน toString/toJSON และใช้ expose() อย่างชัดแจ้งเพื่ออ่านค่า โดยป้องกันไม่ให้ความลับปรากฏในบันทึกเหตุการณ์และผลลัพธ์ที่ทำให้เป็นอนุกรม

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

ตรวจสอบความเข้าใจบทเรียนนี้อย่างรวดเร็ว

ทบทวน

ปกป้อง ความลับ ด้วย ชนิดข้อมูลแบบมีตรา (ซึ่งบังคับให้จัดการอย่างรอบคอบ) หรือใช้ คลาสห่อหุ้ม ที่ toString/toJSON คืนค่าเป็น [REDACTED] และเปิดเผยค่าจริงผ่าน expose() อย่างชัดแจ้งเท่านั้น วิธีนี้ช่วยป้องกันไม่ให้ความลับปรากฏในบันทึกเหตุการณ์และการตั้งค่าที่ทำให้เป็นอนุกรม

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

บทเรียน “ข้อมูลลับและความปลอดภัยด้านชนิดข้อมูล” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “ข้อมูลลับและความปลอดภัยด้านชนิดข้อมูล”

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

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

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

บทเรียน “ข้อมูลลับและความปลอดภัยด้านชนิดข้อมูล” ใช้เวลานานแค่ไหน

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

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

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

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

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