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

อาร์เรย์ Readonly และข้อมูลที่แก้ไขไม่ได้

ใช้ ReadonlyArray เพื่อป้องกันการแก้ไขโดยไม่ตั้งใจ

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

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

อาร์เรย์ที่เปลี่ยนแปลงได้อาจถูกแก้ไขโดยไม่ตั้งใจจากส่วนใดก็ได้ในโค้ดของคุณ ReadonlyArray และตัวปรับ readonly ของ TypeScript ช่วยบังคับใช้ความไม่เปลี่ยนแปลง

ตัวปรับ readonly สำหรับอาร์เรย์

เพิ่มตัวปรับ `readonly` ไว้หน้าชนิดอาร์เรย์เพื่อป้องกันการเปลี่ยนแปลง อาร์เรย์ยังอ่านได้แต่แก้ไขไม่ได้
const ids: readonly number[] = [1, 2, 3];
// ids.push(4);   // Error
// ids[0] = 99;   // Error
console.log(ids[0]); // OK — reading is fine

รูปแบบทั่วไป ReadonlyArray<T>

`ReadonlyArray` เป็นรูปแบบทั่วไปที่เทียบเท่ากับ `readonly T[]` ทั้งสองแบบป้องกัน push การนำสมาชิกออก การตัดแบ่ง และการกำหนดค่าด้วยดัชนี
const names: ReadonlyArray<string> = ['Alice', 'Bob'];
// names.push('Charlie'); // Error

การคืนอาร์เรย์แบบอ่านอย่างเดียวจากฟังก์ชัน

คืนอาร์เรย์แบบอ่านอย่างเดียวจากฟังก์ชัน เพื่อสื่อให้ผู้เรียกทราบว่าไม่ควรเปลี่ยนแปลงผลลัพธ์
function getConfig(): readonly string[] {
  return ['host', 'port', 'db'];
}

พารามิเตอร์ฟังก์ชันที่ไม่เปลี่ยนแปลง

ทำเครื่องหมายพารามิเตอร์อาร์เรย์เป็นแบบอ่านอย่างเดียว เพื่อป้องกันไม่ให้ฟังก์ชันเปลี่ยนแปลงอาร์เรย์ของผู้เรียก
function sum(nums: readonly number[]): number {
  return nums.reduce((a, b) => a + b, 0);
  // nums.push(99); // Error inside function
}

as const สำหรับอาร์เรย์ลิเทอรัล

การยืนยัน `as const` ทำให้อาร์เรย์เป็นแบบอ่านอย่างเดียว และอนุมานเป็นชนิดทูเพิลที่มีชนิดสมาชิกเป็นลิเทอรัล แทนที่จะขยายชนิดให้กว้างขึ้น
const colors = ['red', 'green', 'blue'] as const;
// type: readonly ['red', 'green', 'blue']
// colors.push('yellow'); // Error

readonly ไม่ได้แช่แข็งข้อมูลในระดับลึก

readonly ป้องกันเฉพาะการเปลี่ยนแปลงการอ้างอิงอาร์เรย์เท่านั้น หากสมาชิกเป็นอ็อบเจกต์ คุณยังสามารถเปลี่ยนแปลงคุณสมบัติของสมาชิกเหล่านั้นได้
const users: readonly { name: string }[] = [{ name: 'Alice' }];
// users.push({}); // Error
users[0].name = 'Bob'; // Allowed — object itself is mutable

ความไม่เปลี่ยนแปลงในระดับลึกด้วย Readonly<T>

หากต้องการให้อ็อบเจกต์ไม่เปลี่ยนแปลงในระดับลึก ให้ใช้ ReadonlyArray ร่วมกับ Readonly กับสมาชิก หรือใช้ไลบรารีอย่าง immer
type ImmutableUser = Readonly<{ name: string; scores: readonly number[] }>;
const u: ImmutableUser = { name: 'Alice', scores: [90, 85] };
// u.name = 'Bob';       // Error
// u.scores.push(100);  // Error

การกำหนดระหว่างอาร์เรย์ที่เปลี่ยนแปลงได้กับอาร์เรย์แบบอ่านอย่างเดียว

อาร์เรย์แบบอ่านอย่างเดียวไม่สามารถกำหนดให้กับชนิดอาร์เรย์แบบเปลี่ยนแปลงได้ (NOT) วิธีนี้ช่วยป้องกันการส่งอาร์เรย์ที่ไม่เปลี่ยนแปลงไปยังจุดที่คาดว่าจะมีการเปลี่ยนแปลงโดยไม่ตั้งใจ
const ro: readonly number[] = [1, 2];
const mutable: number[] = ro; // Error!

เมื่อใดควรใช้อาร์เรย์แบบอ่านอย่างเดียว

ใช้อาร์เรย์แบบอ่านอย่างเดียวกับอ็อบเจกต์การตั้งค่า ค่าคงที่ พารามิเตอร์ฟังก์ชันที่คุณรับรองว่าจะไม่เปลี่ยนแปลง และค่าที่ส่งกลับจากฟังก์ชันบริสุทธิ์

การกระจายจะสร้างอาร์เรย์ใหม่ที่เปลี่ยนแปลงได้

การกระจายอาร์เรย์แบบอ่านอย่างเดียวลงในลิเทอรัลอาร์เรย์ใหม่จะสร้างสำเนาที่เปลี่ยนแปลงได้ นี่เป็นรูปแบบที่ชัดเจนสำหรับการแก้ไขโดยไม่เปลี่ยนแปลงอาร์เรย์เดิม
const base: readonly number[] = [1, 2, 3];
const extended: number[] = [...base, 4]; // new mutable array

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

การดำเนินการใดที่ NOT อนุญาตให้ทำกับ `readonly number[]` ใน TypeScript

สรุปทบทวน

ใช้ `readonly T[]` หรือ `ReadonlyArray` เพื่อป้องกันการเปลี่ยนแปลงอาร์เรย์ ใช้ `as const` กับอาร์เรย์ค่าคงที่แบบลิเทอรัล และใช้การกระจายเพื่อสร้างสำเนาที่เปลี่ยนแปลงได้เมื่อต้องการเพิ่มสมาชิกให้อาร์เรย์แบบอ่านอย่างเดียว

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

บทเรียน “อาร์เรย์ Readonly และข้อมูลที่แก้ไขไม่ได้” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “อาร์เรย์ Readonly และข้อมูลที่แก้ไขไม่ได้”

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

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

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

บทเรียน “อาร์เรย์ Readonly และข้อมูลที่แก้ไขไม่ได้” ใช้เวลานานแค่ไหน

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

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

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

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

  1. อาร์เรย์แบบมีชนิดข้อมูล: T[] และ Array
  2. อาร์เรย์ Readonly และข้อมูลที่แก้ไขไม่ได้
  3. ทูเพิล: อาร์เรย์แบบมีชนิดข้อมูลและความยาวคงที่
  4. Enum: ค่าคงที่ตัวเลขและข้อความ
← กลับไปที่ TypeScript Academy