การเพิ่มประสิทธิภาพทรัพยากรด้วย TypeScript: ประสิทธิภาพผ่านความปลอดภัยของประเภท

ในภูมิทัศน์ของการพัฒนาซอฟต์แวร์ที่เปลี่ยนแปลงตลอดเวลา การเพิ่มประสิทธิภาพการใช้ทรัพยากรเป็นสิ่งสำคัญยิ่ง TypeScript ซึ่งเป็นซูเปอร์เซ็ตของ JavaScript มีเครื่องมือและเทคนิคอันทรงพลังเพื่อให้บรรลุเป้าหมายนี้ ด้วยการใช้ระบบการพิมพ์แบบคงที่และคุณสมบัติคอมไพเลอร์ขั้นสูง นักพัฒนาสามารถปรับปรุงประสิทธิภาพของแอปพลิเคชัน ลดข้อผิดพลาด และปรับปรุงความสามารถในการบำรุงรักษาโค้ดโดยรวมได้อย่างมาก คู่มือฉบับสมบูรณ์นี้จะสำรวจกลยุทธ์สำคัญในการเพิ่มประสิทธิภาพโค้ด TypeScript โดยมุ่งเน้นที่ประสิทธิภาพผ่านความปลอดภัยของประเภท

ทำความเข้าใจถึงความสำคัญของการเพิ่มประสิทธิภาพทรัพยากร

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

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

ด้วยการมุ่งเน้นไปที่การเพิ่มประสิทธิภาพทรัพยากร นักพัฒนาสามารถสร้างแอปพลิเคชันที่มีประสิทธิภาพ เชื่อถือได้ และคุ้มค่ามากขึ้น

บทบาทของ TypeScript ในการเพิ่มประสิทธิภาพทรัพยากร

ระบบการพิมพ์แบบคงที่ของ TypeScript มีข้อดีหลายประการสำหรับการเพิ่มประสิทธิภาพทรัพยากร:

• การตรวจจับข้อผิดพลาดล่วงหน้า: คอมไพเลอร์ของ TypeScript จะระบุข้อผิดพลาดที่เกี่ยวข้องกับประเภทในระหว่างการพัฒนา ป้องกันไม่ให้ข้อผิดพลาดเหล่านั้นแพร่กระจายไปยังรันไทม์ ซึ่งช่วยลดความเสี่ยงของพฤติกรรมที่ไม่คาดคิดและการขัดข้องที่อาจทำให้ทรัพยากรสูญเปล่า
• ปรับปรุงการดูแลโค้ด: การใส่คำอธิบายประกอบประเภททำให้โค้ดเข้าใจและปรับโครงสร้างใหม่ได้ง่ายขึ้น ซึ่งช่วยลดความซับซ้อนของกระบวนการระบุและแก้ไขปัญหาคอขวดด้านประสิทธิภาพ
• การสนับสนุนเครื่องมือที่ดียิ่งขึ้น: ระบบประเภทของ TypeScript ช่วยให้คุณสมบัติ IDE มีประสิทธิภาพมากขึ้น เช่น การเติมโค้ดอัตโนมัติ การปรับโครงสร้างใหม่ และการวิเคราะห์แบบคงที่ เครื่องมือเหล่านี้สามารถช่วยให้นักพัฒนาระบุปัญหาด้านประสิทธิภาพที่อาจเกิดขึ้นและเพิ่มประสิทธิภาพโค้ดได้อย่างมีประสิทธิภาพมากขึ้น
• การสร้างโค้ดที่ดีขึ้น: คอมไพเลอร์ของ TypeScript สามารถสร้างโค้ด JavaScript ที่ได้รับการเพิ่มประสิทธิภาพ ซึ่งใช้ประโยชน์จากคุณสมบัติภาษาที่ทันสมัยและสภาพแวดล้อมเป้าหมาย

กลยุทธ์สำคัญสำหรับการเพิ่มประสิทธิภาพทรัพยากรด้วย TypeScript

ต่อไปนี้คือกลยุทธ์สำคัญบางประการสำหรับการเพิ่มประสิทธิภาพโค้ด TypeScript:

1. การใช้ Type Annotations อย่างมีประสิทธิภาพ

Type annotations เป็นรากฐานสำคัญของระบบประเภทของ TypeScript การใช้ Type annotations อย่างมีประสิทธิภาพสามารถปรับปรุงความชัดเจนของโค้ดได้อย่างมาก และช่วยให้คอมไพเลอร์สามารถทำการเพิ่มประสิทธิภาพเชิงรุกได้มากขึ้น

ตัวอย่าง:

// ไม่มี Type Annotations
function add(a, b) {
  return a + b;
}

// มี Type Annotations
function add(a: number, b: number): number {
  return a + b;
}

ในตัวอย่างที่สอง Type annotations : number ระบุอย่างชัดเจนว่าพารามิเตอร์ a และ b เป็นตัวเลข และฟังก์ชันคืนค่าเป็นตัวเลข ซึ่งช่วยให้คอมไพเลอร์สามารถตรวจจับข้อผิดพลาดของประเภทได้ตั้งแต่เนิ่นๆ และสร้างโค้ดที่มีประสิทธิภาพมากขึ้น

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

2. การใช้ Interfaces และ Types

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

ตัวอย่าง:

interface User {
  id: number;
  name: string;
  email: string;
}

type Product = {
  id: number;
  name: string;
  price: number;
};

function displayUser(user: User) {
  console.log(`User: ${user.name} (${user.email})`);
}

function calculateDiscount(product: Product, discountPercentage: number): number {
  return product.price * (1 - discountPercentage / 100);
}

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

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

3. การเพิ่มประสิทธิภาพโครงสร้างข้อมูลและอัลกอริทึม

การเลือกโครงสร้างข้อมูลและอัลกอริทึมที่เหมาะสมเป็นสิ่งสำคัญสำหรับประสิทธิภาพ พิจารณาสิ่งต่อไปนี้:

• Arrays vs. Objects: ใช้ arrays สำหรับรายการที่มีลำดับ และ objects สำหรับคู่คีย์-ค่า
• Sets vs. Arrays: ใช้ sets สำหรับการทดสอบการเป็นสมาชิกที่มีประสิทธิภาพ
• Maps vs. Objects: ใช้ maps สำหรับคู่คีย์-ค่าที่คีย์ไม่ใช่สตริงหรือสัญลักษณ์
• ความซับซ้อนของอัลกอริทึม: เลือกอัลกอริทึมที่มีความซับซ้อนด้านเวลาและพื้นที่ต่ำที่สุดเท่าที่จะเป็นไปได้

ตัวอย่าง:

// ไม่มีประสิทธิภาพ: ใช้ array สำหรับการทดสอบการเป็นสมาชิก
const myArray = [1, 2, 3, 4, 5];
const valueToCheck = 3;

if (myArray.includes(valueToCheck)) {
  console.log("ค่ามีอยู่ใน array");
}

// มีประสิทธิภาพ: ใช้ set สำหรับการทดสอบการเป็นสมาชิก
const mySet = new Set([1, 2, 3, 4, 5]);
const valueToCheck = 3;

if (mySet.has(valueToCheck)) {
  console.log("ค่ามีอยู่ใน set");
}

ในตัวอย่างนี้ การใช้ Set สำหรับการทดสอบการเป็นสมาชิกมีประสิทธิภาพมากกว่าการใช้ array เนื่องจากเมธอด Set.has() มีความซับซ้อนด้านเวลาเป็น O(1) ในขณะที่เมธอด Array.includes() มีความซับซ้อนด้านเวลาเป็น O(n)

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

4. การลดการจัดสรรหน่วยความจำ

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

ตัวอย่าง:

// ไม่มีประสิทธิภาพ: สร้าง array ใหม่ในการวนซ้ำแต่ละครั้ง
function processData(data: number[]) {
  const results: number[] = [];
  for (let i = 0; i < data.length; i++) {
    results.push(data[i] * 2);
  }
  return results;
}

// มีประสิทธิภาพ: แก้ไข array ต้นฉบับในตำแหน่งเดิม
function processData(data: number[]) {
  for (let i = 0; i < data.length; i++) {
    data[i] *= 2;
  }
  return data;
}

ในตัวอย่างที่สอง ฟังก์ชัน processData แก้ไข array ต้นฉบับในตำแหน่งเดิม หลีกเลี่ยงการสร้าง array ใหม่ ซึ่งช่วยลดการจัดสรรหน่วยความจำและปรับปรุงประสิทธิภาพ

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

5. การแบ่งโค้ดและการโหลดแบบ Lazy Loading

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

ตัวอย่าง: การใช้ dynamic imports ใน TypeScript:

async function loadModule() {
  const module = await import('./my-module');
  module.doSomething();
}

// เรียกใช้ loadModule() เมื่อคุณต้องการใช้โมดูล

เทคนิคนี้ช่วยให้คุณสามารถเลื่อนการโหลด my-module ออกไปจนกว่าจะจำเป็นต้องใช้จริงๆ ซึ่งช่วยลดเวลาโหลดเริ่มต้นของแอปพลิเคชันของคุณ

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

6. การใช้คีย์เวิร์ด `const` และ `readonly`

การใช้ const และ readonly สามารถช่วยให้คอมไพเลอร์และสภาพแวดล้อมรันไทม์สามารถสันนิษฐานเกี่ยวกับการเปลี่ยนแปลงไม่ได้ของตัวแปรและคุณสมบัติ ซึ่งนำไปสู่การเพิ่มประสิทธิภาพที่เป็นไปได้

ตัวอย่าง:

const PI: number = 3.14159;

interface Config {
  readonly apiKey: string;
}

const config: Config = {
  apiKey: 'YOUR_API_KEY'
};

// การพยายามแก้ไข PI หรือ config.apiKey จะทำให้เกิดข้อผิดพลาดขณะคอมไพล์
// PI = 3.14; // ข้อผิดพลาด: ไม่สามารถกำหนดค่าให้กับ 'PI' ได้ เนื่องจากเป็นค่าคงที่
// config.apiKey = 'NEW_API_KEY'; // ข้อผิดพลาด: ไม่สามารถกำหนดค่าให้กับ 'apiKey' ได้ เนื่องจากเป็นคุณสมบัติแบบอ่านอย่างเดียว

ด้วยการประกาศ PI เป็น const และ apiKey เป็น readonly คุณกำลังบอกคอมไพเลอร์ว่าค่าเหล่านี้ไม่ควรถูกแก้ไขหลังจากเริ่มต้นใช้งาน ซึ่งช่วยให้คอมไพเลอร์สามารถทำการเพิ่มประสิทธิภาพตามความรู้นี้ได้

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

7. การทำ Profiling และการทดสอบประสิทธิภาพ

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

เครื่องมือ: Chrome DevTools, Node.js Inspector, Lighthouse.

ข้อมูลเชิงลึกที่นำไปใช้ได้จริง: ทำการ profiling และทดสอบประสิทธิภาพโค้ดของคุณเป็นประจำเพื่อระบุและแก้ไขปัญหาคอขวดด้านประสิทธิภาพ

8. ทำความเข้าใจเกี่ยวกับการรวบรวมขยะ (Garbage Collection)

JavaScript (และ TypeScript ด้วย) ใช้การรวบรวมขยะอัตโนมัติ การทำความเข้าใจวิธีการทำงานของการรวบรวมขยะสามารถช่วยให้คุณเขียนโค้ดที่ลดการรั่วไหลของหน่วยความจำและปรับปรุงประสิทธิภาพได้

แนวคิดหลัก:

• การเข้าถึงได้ (Reachability): อ็อบเจกต์จะถูกรวบรวมขยะเมื่อไม่สามารถเข้าถึงได้จากอ็อบเจกต์ราก (เช่น อ็อบเจกต์ส่วนกลาง)
• การรั่วไหลของหน่วยความจำ (Memory Leaks): การรั่วไหลของหน่วยความจำเกิดขึ้นเมื่ออ็อบเจกต์ไม่จำเป็นต้องใช้แล้วแต่ยังสามารถเข้าถึงได้ ทำให้ไม่สามารถถูกรวบรวมขยะได้
• การอ้างอิงแบบวงกลม (Circular References): การอ้างอิงแบบวงกลมสามารถป้องกันไม่ให้อ็อบเจกต์ถูกรวบรวมขยะได้ แม้ว่าจะไม่จำเป็นต้องใช้แล้วก็ตาม

ตัวอย่าง:

// การสร้างการอ้างอิงแบบวงกลม
let obj1: any = {};
let obj2: any = {};

obj1.reference = obj2;
obj2.reference = obj1;

// แม้ว่า obj1 และ obj2 จะไม่ได้ถูกใช้แล้ว แต่ก็จะไม่ถูกรวบรวมขยะ
// เพราะยังสามารถเข้าถึงกันและกันได้

// หากต้องการตัดการอ้างอิงแบบวงกลม ให้ตั้งค่าการอ้างอิงเป็น null
obj1.reference = null;
obj2.reference = null;

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

9. การใช้ Web Workers สำหรับงานเบื้องหลัง

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

ตัวอย่าง:

// main.ts
const worker = new Worker('worker.ts');

worker.postMessage({ task: 'calculatePrimeNumbers', limit: 100000 });

worker.onmessage = (event) => {
  console.log('จำนวนเฉพาะ:', event.data);
};

// worker.ts
// โค้ดนี้ทำงานในเธรดแยกต่างหาก
self.onmessage = (event) => {
  const { task, limit } = event.data;
  if (task === 'calculatePrimeNumbers') {
    const primes = calculatePrimeNumbers(limit);
    self.postMessage(primes);
  }
};

function calculatePrimeNumbers(limit: number): number[] {
  // การนำการคำนวณจำนวนเฉพาะไปใช้
  const primes: number[] = [];
    for (let i = 2; i <= limit; i++) {
        let isPrime = true;
        for (let j = 2; j <= Math.sqrt(i); j++) {
            if (i % j === 0) {
                isPrime = false;
                break;
            }
        }
        if (isPrime) {
            primes.push(i);
        }
    }
    return primes;
}

ข้อมูลเชิงลึกที่นำไปใช้ได้จริง: ใช้ Web Workers เพื่อรันงานที่ใช้เวลานานในพื้นหลังและป้องกันไม่ให้เธรดหลักถูกบล็อก

10. ตัวเลือกคอมไพเลอร์และแฟล็กการเพิ่มประสิทธิภาพ

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

• `--target` (es5, es6, esnext): เลือกเวอร์ชัน JavaScript เป้าหมายที่เหมาะสมเพื่อเพิ่มประสิทธิภาพสำหรับสภาพแวดล้อมรันไทม์ที่เฉพาะเจาะจง การกำหนดเป้าหมายเวอร์ชันที่ใหม่กว่า (เช่น esnext) สามารถใช้ประโยชน์จากคุณสมบัติภาษาที่ทันสมัยเพื่อประสิทธิภาพที่ดีขึ้น
• `--module` (commonjs, esnext, umd): ระบุระบบโมดูล ES modules สามารถเปิดใช้งาน tree-shaking (การกำจัดโค้ดที่ไม่ได้ใช้) โดย bundlers
• `--removeComments`: ลบความคิดเห็นออกจาก JavaScript ที่ส่งออกเพื่อลดขนาดไฟล์
• `--sourceMap`: สร้าง source maps สำหรับการดีบัก แม้ว่าจะมีประโยชน์สำหรับการพัฒนา แต่ควรปิดใช้งานในการผลิตเพื่อลดขนาดไฟล์และปรับปรุงประสิทธิภาพ
• `--strict`: เปิดใช้งานตัวเลือกการตรวจสอบประเภทที่เข้มงวดทั้งหมดเพื่อความปลอดภัยของประเภทที่ดีขึ้นและโอกาสในการเพิ่มประสิทธิภาพที่เป็นไปได้

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

แนวทางปฏิบัติที่ดีที่สุดสำหรับการดูแลโค้ด TypeScript ที่เพิ่มประสิทธิภาพ

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

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

สรุป

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