คุณสมบัติและการทำงานของภาษา TypeScript

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

• ทำไมต้องใช้ภาษา TypeScript
• การคอมไพล์โปรแกรมภาษา TypeScript
• Type annotations
• Static type checking
• Type inferring
• Compile-time type checking

ทำไมต้องใช้ภาษา TypeScript

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

let score = 10;
score = "ten";

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

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

let name = "Cristo";
name = 10;
console.log(name.toLowerCase());

ในตัวอย่างนี้เราได้ประกาศตัวแปร name สำหรับเก็บชื่อที่เป็น String แต่ลองจินตนาการว่าคุณได้เผลอเปลี่ยนค่าในตัวแปรเป็นตัวเลขอาจโดยตั้งใจหรือไม่ตั้งใจ และในบรรทัดสุดท้าย เราเรียกใช้เมธอด toLowerCase ซึ่งเป็นเมธอดบนออบเจ็คของ String

ในกรณีนี้เราจะได้รับข้อผิดพลาด และนี่เป็นผลลัพธ์เมื่อรันโปรแกรม

TypeError: name.toLowerCase is not a function

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

ด้วยเหตุนี้เราจึงจำเป็นต้องการวิธีควบคุมประเภทข้อมูลที่ตัวแปรสามารถมีได้ และ TypeScript เป็นวิธีที่จะจัดการกับปัญหานี้

การคอมไพล์โปรแกรมภาษา TypeScript

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

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

ลองมาดูตัวอย่างโค้ดต่อไปนี้ที่เขียนในภาษา TypeScript ซึ่งเป็นโปรแกรมบวกเลขอย่างง่ายจากสองตัวแปร

let a: number = 2;
let b: number = 3;

console.log(`a + b = ${a + b}`);

เมื่อคอมไพล์โปรแกรมด้วยคำสั่ง tsc add.ts เราจะได้รับไฟล์โปรแกรมของภาษา JavaScript ที่มีเนื้อหาดังต่อไปนี้

var a = 2;
var b = 3;
console.log("a + b = " + (a + b));

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

นอกจากนี้ บางคำสั่งในภาษา TypeScript เช่นการประกาศตัวแปรด้วยคำสั่ง let ถูกเปลี่ยนเป็น var นี่เป็นเพราะว่าเวอร์ชันเป้าหมายของภาษา JavaScript ในการคอมไพล์ถูกกำหนดเป็น es3 และเช่นเดียวกัน Template string ถูกเปลี่ยนเป็นการเชื่อมต่อ String ด้วยตัวดำเนินการ + ซึ่งนี่สามารถตั้งค่าได้ด้วยตัวเลือก --target ในตอนคอมไพล์ และเราจะไม่ครอบคลุมเรื่องนี้ในตอนนี้

หลังจากที่ได้รับโค้ดของภาษา JavaScript แล้ว เราสามารถรันโปรแกรมด้วยคำสั่ง node add.js ซึ่งเป็นวิธีในการรันโปรแกรมปกติบน Node.js และนี่เป็นผลลัพธ์การทำงานของโปรแกรม

a + b = 5

นั่นหมายความว่าเราเขียนโปรแกรมในภาษา TypeScript คอมไพล์มันไปยังภาษา JavaScript และรันเพื่อผลลัพธ์ได้สำเร็จ

Type annotations

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

นี่เป็นตัวอย่างของการประกาศตัวแปรแบบระบุประเภทข้อมูลในภาษา TypeScript

let firstName: string = "Metin";

ในตัวอย่างนี้เป็นการประกาศตัวแปร firstName สำหรับเก็บข้อมูลประเภท String โดยเราต้องระบุประเภทหลังชื่อตัวแปรโดยคั่นด้วยเครื่องหมายโคลอน (:)

firstName = 10;

จากนั้นเป็นการพยายามเปลี่ยนแปลงค่าในตัวแปร firstName ให้เป็นตัวเลข ซึ่งนี่จะทำให้เกิดข้อผิดพลาดขึ้นในตอนที่คอมไพล์โปรแกรม

Type 'number' is not assignable to type 'string'.

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

หมายเหตุ: กับคุณสมบัติ Static type checking ที่มากับ Editor ข้อผิดพลาดจะแสดงในทันทีโดยที่ไม่ต้องคอมไพล์โปรแกรมก่อน เราจะพูดถึงเรื่องนี้ในภายหลัง

นอกจากนี้ Type annotation ยังสามารถใช้ได้ในทุกที่ที่เป็นการประกาศตัวแปร เช่น รายการพารามิเตอร์ของฟังก์ชัน ค่าที่ส่งกลับของฟังก์ชัน และแอททริบิวต์ของคลาส ยกตัวอย่างเช่น นี่เป็นโปรแกรมสำหรับหาความยาวของ String

function lengthOfString(s: string): number {
    return s.length;
}

นี่เป็นการระบุประเภทข้อมูลสำหรับพารามิเตอร์ของฟังก์ชัน และประเภทข้อมูลที่ฟังก์ชันนี้จะส่งค่ากลับ โดยฟังกชัน lengthOfString นั้นรับพารามิเตอร์เป็น String และส่งค่ากลับเป็นความยาวของ String ซึ่งเป็นมีประเภทข้อมูลเป็น number

ต่อมาเป็นตัวอย่างการใช้งาน Type annotation ในคลาส User ที่แต่ละตัวแปรมีการระบุประเภทข้อมูลด้วย โดยที่ id เก็บข้อมูลที่เป็นตัวเลข และ name เก็บชื่อที่มีค่าเป็น String

class User {
    id: number;
    name: string;
}

ในกรณีที่คุณต้องการระบุประเภทข้อมูลให้กับฟิลด์ออบเจ็ค Literal คุณสามารถสร้าง type เพื่อใช้สำหรับอธิบายโครงสร้างของออบเจ็คได้ ยกตัวอย่างเช่น ออบเจ็คสำหรับเก็บตำแหน่ง x, y ต่อไปนี้

type Point = {
    x: number;
    y: number;
};

let point: Point = {
    x: 5,
    y: 10
};

เมื่อทำงานกับออบเจ็ค Literal เราไม่สามารถกำหนดประเภทข้อมูลให้กับฟิลด์ของออบเจ็คได้โดยตรงเนื่องจากเครื่องหมายโคลอนถูกใช้ในการแบ่งแยกระหว่าง Key และ Value ไปแล้ว แต่เราจะต้องสร้างประเภทข้อมูลสำหรับออบเจ็คโดยใช้คำสั่ง type จากนั้นนำมาใช้ในตอนที่ประกาศออบเจ็ค point เพื่อให้มีประเภทข้อมูลเป็น Point แทน

และเมื่อเราประกาศประเภทข้อมูลด้วยคำสั่ง type มันสามารถนำไปใช้ซ้ำๆ ได้ตลอดทั้งโปรแกรมที่ต้องการประเภทข้อมูลดังกล่าวนี้ ยกตัวอย่างเช่น

type Point = {
    x: number;
    y: number;
};

function showPoint(p: Point): void {
    console.log(`x=${p.x}, y=${p.y}`);
}

let point: Point = {
    x: 5,
    y: 10
};

showPoint(point);

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

นอกจากนี้ TypeScript ยังสนับสนุนการกำหนดประเภทข้อมูลในรูปแบบอื่นๆ เช่น Union type หรือ Literal type ซึ่งคุณจะได้เรียนรู้ในบทต่อไป

Static type checking

Static type checking เป็นคุณสมบัติที่โดดเด่นของภาษา TypeScript ที่ทำงานร่วมกับ Editor ที่สนับสนุนสำหรับตรวจสอบความถูกต้องของโปรแกรมก่อนที่จะคอมไพล์ ถ้าหากคุณใช้ Editor เป็น Visual Studio Code คุณได้รับตัวช่วยนี้โดยปริยาย ยกตัวอย่างเช่น

let year: number = 2021;
year = "Twenty Twenty-One";

โค้ดนี้จะเกิดข้อผิดพลาดถ้าหากมันถูกคอมไพล์ แต่เมื่อคุณเขียนโปรแกรมบน Visual Studio Code มันจะแจ้งเตือนให้ทราบในทันทีว่าบรรทัดที่สองมีข้อผิดพลาดนี้ นั่นหมายความว่าคุณจะได้เห็นข้อผิดพลาดก่อนที่จะคอมไพล์โปรแกรมและสามารถแก้ไขมันได้ในทันที

Type 'string' is not assignable to type 'number'.

ข้อผิดพลาดนี้ได้บอกว่าประเภทข้อมูลที่เป็น String ไม่สามารถกำหนดค่าได้ในตัวแปร year ซึ่งมีประเภทข้อมูลเป็น number

ในการเข้าถึงฟิลด์หรือเรียกใช้เมธอดของออบเจ็คที่ไม่ถูกต้องตามประเภทข้อมูลของมัน คุณก็จะได้ัรับการแจ้งเตือนจาก Static type checking เช่นเดียวกัน

let n: number = 10;
console.log(n.toLocaleLowerCase());

นั่นเป็นเพราะว่า TypeScript ทราบเกี่ยวกับออบเจ็คของตัวเลขในภาษา JavaScript และเมื่อเราพยายามเรียกใช้เมธอด toLocaleLowerCase ซึ่งไม่มีอยู่บนออบเจ็คของ number มันจะแจ้งข้อผิดพลาดให้เราทราบในทันทีว่า เมธอด toLocaleLowerCase ไม่มีอยู่บนออบเจ็คของตัวเลข

Property 'toLocaleLowerCase' does not exist on type 'number'.

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

type Point = {
    x: number;
    y: number;
};

let point: Point = {
    x: 5,
    y: 10
};

console.log(point.z);

นี่เป็นข้อผิดพลาดที่ Editor จะแจ้งให้ทราบในทันทีเพราะ TypeScript ทราบว่าฟิลด์ z ที่ถูกเข้าถึงไม่มีอยู่บนออบเจ็ค point ที่มีประเภทข้อมูลเป็น Point

Property 'z' does not exist on type 'Point'.

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

Type inferring

Type inferring คือการประกาศตัวแปรโดยไม่เราไม่จำเป็นต้องระบุประเภทข้อมลที่ต้องการใช้งาน แต่ปล่อยให้ TypeScript คาดเดาประเภทข้อมูลให้อัติโนมัติจาก Literal นี่เป็นคุณสมบัติที่อำนวยความสะดวกเป็นอย่างมาก และสนับสนุนความเข้ากันได้ในการเปลี่ยนโค้ดภาษา JavaScript มายัง TypeScript

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

let siteName = "marcuscode";

ในกรณีนี้ TypeScript จะใช้ประเภทข้อมูลจากค่าที่กำหนดให้กับตัวแปรซึ่งก็คือ string ดังนั้นนี่จะม่ีค่าเท่ากับการประกาศตัวแปรพร้อมกับการระบุประเภทข้อมูลเป็น string เหมือนในคำสั่งต่อไปนี้

let siteName: string = "marcuscode";

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

let siteName = "marcuscode";
siteName = 10; // Error

แม้ว่าโปรแกรมจาก program.ts จะเหมือนกับโปรแกรมที่เขียนในภาษา JavaScript แต่การพยายามเปลี่ยนค่าในตัวแปรเป็นประเภทข้อมูลอื่นก็จะไม่สามารถทำได้ เนื่องจากตัวแปร siteName มีประเภทข้อมูลเป็น string จากคุณสมบัติ Type inferring ของ TypeScript

นอกจากนี้ Type inferring สามารถเกิดขึ้นได้ทุกที่ที่เราสามารถระบุประเภทข้อมูลในภาษา TypeScript ยกตัวอย่างเช่นในฟังก์ชัน add นี้

function add(a: number, b: number) {
    return a + b;
}

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

function add(a: number, b: number): number {
    return a + b;
}

หลังจากที่ประกาศฟังก์ชัน add เราสามารถเรียกใช้งานมันและเก็บลงไว้ในตัวแปร sum โดยที่ไม่ต้องระบุประเภทข้อมูลได้ ยกตัวอย่างเช่น

let sum = add(2, 3);

ในกรณีนี้ตัวแปร sum จะมีประเภทข้อมูลเป็น number จากประเภทข้อมูลการส่งกลับของฟังก์ชัน add ที่มันได้รับค่ามาจาก Type inferring

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

let number;
number = 1;
number = "One";

ตัวแปร number ถูกประกาศโดยไม่ได้กำหนดค่าเริ่มต้นและไม่ระบุประเภทข้อมูล นั่นทำให้ TypeScript ไม่สามารถคาดเดาประเภทของตัวแปรได้ ดังนั้นมันใช้ any เป็นประเภทข้อมูลของตัวแปร นั่นทำให้ตัวแปรนี้สามารถใช้สำหรับเก็บประเภทข้อมูลใดก็ได้

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

function greet(name) {
    console.log(`Hello ${name}!`);
}

greet("Chris");
greet(15);

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

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

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

Compile-time type checking

หาก Editor ที่คุณใช้ไม่สนับสนุนคุณสมบัติ Static type checking คุณจะต้องทำการคอมไพล์โปรแกรมก่อนจึงจะทราบว่ามีข้อผิดพลาด อย่างไรก็ตาม บาง Editor อาจมี Extension ที่ให้สามารถทำได้ แต่ถ้าคุณเลือก Editor ที่นอกเหนือจาก VS Code คุณอาจจะต้องตรวจสอบคุณสมบัตินี้ด้วยตัวเอง อย่างไรก็ตาม เราแนะให้ใช้ VS Code หากเป็นไปได้

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

function greet(name: string): void {
    console.log(`Hello ${name}!`);
}

greet("Metin");
greet(34);

โค้ดนี้มีข้อผิดพลาดและคุณสามารถเห็นมันได้หรือไม่ สมมติว่าคุณไม่เห็นมันไม่ว่าจะด้วยเหตุผลอะไรก็ตาม สุดท้ายเราจะต้องคอมไพล์โปรแกรมก่อนที่จะรัน ดังนั้นมาลองคอมไพล์มันด้วยคำสั่ง tsc greet.ts

และนี่เป็นข้อผิดพลาดแบบเต็มๆ ที่เราได้รับในระหว่างการคอมไพล์

tsc greeting.ts
greeting.ts:6:7 - error TS2345: Argument of type 'number' is not assignable to parameter of type 'string'.

6 greet(34);
        ~~

Found 1 error.

TypeScript แจ้งให้ทราบว่าเราเรียกใช้ฟังก์ชัน greet กับประเภทข้อมูลของพารามิเตอร์ที่ไม่ถูกต้องในบรรทัดที่ 6 ที่ส่งค่าเป็นตัวเลขไปยังฟังก์ชัน ในขณะที่ฟังก์ชันต้องการพารามิเตอร์ที่เป็น String และในตอนนี้เราสามารถแก้ไขมันให้ถูกต้องได้แล้ว

อย่างไรก็ตาม แม้ว่าการคอมไพล์จะมีข้อผิดพลาด เราจะยังคงได้รับไฟล์ที่คอมไพล์แล้วในภาษา JavaScript ด้วยเสมอ จากตัวอย่างก่อนหน้า เราจะยังคงได้รับไฟล์นี้

function greet(name) {
    console.log("Hello " + name + "!");
}
greet("Metin");
greet(34);

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

นึี่ก็เป็นพฤติกรรมการทำงานพื้นฐานของภาษา TypeScript อย่างไรก็ตาม เราสามารถตั้งค่าการทำงานของมันได้ เช่น การกำหนดความเข้มงวดในการตรวจสอบ หรือการละเว้นข้อบังคับบางอย่างออกไป เป็นต้น ผ่านไฟล์ tsconfig.ts หรือผ่าน Command line options ของคำสั่ง tsc ซึ่งเราจะพูดถึงภายหลังในบทเรียนนี้