Paghawak ng Error sa TypeScript

Ipinaliliwanag ng artikulong ito ang paghawak ng error sa TypeScript.

YouTube Video

Paghawak ng Error sa TypeScript

Ang paghawak ng error sa TypeScript ay pangunahing ginagawa gamit ang try...catch na istruktura, katulad ng sa JavaScript. Sa TypeScript, posible ang mas malinaw na pamamahala ng nilalaman ng error gamit ang type inference. Ito ay nagbibigay-daan sa mas eksakto at madaling mabasang paghawak ng error.

Sintaks ng try...catch

Ang pangunahing sintaks para sa paghawak ng error ay ang mga sumusunod:.

 1try {
 2    // Code that may throw an error
 3    throw new Error("Something went wrong!");
 4} catch (error) {
 5    // Catch and handle the error
 6    console.error("Error:", error);
 7} finally {
 8    // Code that runs regardless of whether an error occurred
 9    console.log("Finally block executed.");
10}

Ligtas na Paghawak ng Error sa pamamagitan ng Mga Uri

Sa TypeScript, ang mga error na nahuli sa loob ng isang catch block ay itinuturing bilang any na uri, ngunit inirerekomenda na tukuyin ang angkop na uri para sa mas ligtas na paghawak ng error. Halimbawa, maaari kang magtakda at gumamit ng isang pasadyang uri ng error gaya ng mga sumusunod:.

 1class CustomError extends Error {
 2    constructor(message: string, public errorCode: number) {
 3        super(message);
 4        this.name = "CustomError";
 5    }
 6}
 7
 8try {
 9    throw new CustomError("Invalid operation", 400);
10} catch (error) {
11    if (error instanceof CustomError) {
12        console.error(`Error: ${error.message}, Code: ${error.errorCode}`);
13    } else {
14        console.error("Unknown error occurred");
15    }
16}

Sa halimbawang ito, gumawa ng klase na tinatawag na CustomError, at magtatapon ng error na may mga custom na katangian tulad ng errorCode. Sa catch block, gamitin ang instanceof upang matukoy ang uri ng error at magsagawa ng naaangkop na paghawak.

Paghawak ng Error sa Asynchronous na Paraan

Sa TypeScript, ginagamit din ang try...catch upang hawakan ang mga error kapag gumagamit ng mga asynchronous na function.

 1async function fetchData() {
 2    try {
 3        const response = await fetch("https://api.example.com/data");
 4        if (!response.ok) {
 5            throw new Error(`HTTP error! status: ${response.status}`);
 6        }
 7        const data = await response.json();
 8        console.log(data);
 9    } catch (error) {
10        console.error("Failed to fetch data:", error);
11    }
12}
13
14fetchData();

Sa halimbawa na ito, data ang kinukuha gamit ang fetch, at sinusuri ang response.ok upang maghagis ng error kung ang status code ay hindi OK. Ang error ay nahuli sa catch, at ang naaangkop na log ay inilalabas.

Buod

Sa TypeScript, ang paggamit ng mga uri upang linawin ang nilalaman ng error ay nagbibigay-daan sa mas ligtas at madaling mabasang paghawak ng error. Kapag humahawak ng mga error, mahalagang linawin kung anong mga uri ng error ang maaaring mangyari at hawakan ang mga ito nang naaayon.

Error

Ang klase na Error sa TypeScript ay lumalawak sa klase na Error sa JavaScript at isang pangunahing bagay para sa paglalarawan ng mga error. Sa pamamagitan ng paggamit ng klase na Error, maaari kang lumikha ng isang bagay na naglalaman ng mensahe ng error at magsagawa ng paghawak ng error.

Mga Pangunahing Kaalaman tungkol sa klase na Error

Ang klase na Error ay ginagamit tulad ng mga sumusunod.

1const error = new Error("Something went wrong!");
2console.log(error.message); // "Something went wrong!"
3console.log(error.name);    // "Error"

Mga Katangian

Ang Error na klase ay may mga sumusunod na katangian:.

• message Isang string na kumakatawan sa mensahe ng error.
• name Ang pangalan ng error. Sa default, ito ay "Error", pero maaari itong baguhin sa pamamagitan ng paglikha ng pasadyang klase ng error.
• stack Impormasyon ng stack trace na ginagamit para sa debugging. Isang string na nagpapakita kung aling code ang naging sanhi ng error noong nangyari ito.

Pasadyang Error na Klase

Posible rin na palawigin ang klase ng Error at lumikha ng sarili mong mga klase ng error. Ito ay kapaki-pakinabang sa mga sitwasyon kung saan kinakailangan ang tiyak na paghawak ng error. Halimbawa, ito ay epektibo kapag nais mong hawakan ang iba't ibang uri ng error tulad ng mga HTTP request error o database error.

Halimbawa ng Paglikha ng Pasadyang Error

 1class CustomError extends Error {
 2    constructor(message: string, public errorCode: number) {
 3        super(message); // Call the constructor of the parent class 'Error'
 4        this.name = "CustomError"; // Set the name of the error
 5    }
 6}
 7
 8const customError = new CustomError("Invalid operation", 400);
 9console.log(customError.message);   // "Invalid operation"
10console.log(customError.name);      // "CustomError"
11console.log(customError.errorCode); // 400

• Sa pamamagitan ng paglikha ng klase ng CustomError at pagdaragdag ng impormasyon tulad ng mga error code, maaari mong pamahalaan ang mas komprehensibong impormasyon tungkol sa mga error.

Pagmana ng Klase ng Error

Sa TypeScript, kapag naglikha ng pasadyang klase ng error sa pamamagitan ng pagpapalawig ng klase ng Error, may ilang mga puntong kailangang mag-ingat.

1. Pag-tawag sa super() Sa constructor ng custom na error class, kailangan mong tawagin ang super() upang magamit ang constructor ng Error na klase. Tinitiyak nito na ang mga katangian na message at stack ay tamang naitakda.

2. Pagdadagdag ng mga Katangian Kung gusto mong magdagdag ng karagdagang impormasyon sa error object, magtakda ng mga bagong katangian sa loob ng klase. Halimbawa, sa itaas na CustomError, isang katangian na errorCode ang idinagdag.

Pagtatapon at Paghuli ng mga Error

Maaari mong hawakan ang mga error sa pamamagitan ng pagtatapon ng error gamit ang Error na klase o custom na error class at pagkatapos ay i-catch ito.

 1function riskyOperation() {
 2    throw new Error("Something went wrong during the operation");
 3}
 4
 5try {
 6    riskyOperation();
 7} catch (error) {
 8    if (error instanceof Error) {
 9        console.error(error.message);  // "Something went wrong during the operation"
10        console.error(error.name);     // "Error"
11    }
12}

Sa kaso ng mga pasadyang error din, gumamit ng instanceof upang matukoy ang tiyak na mga error at hawakan ang mga ito nang naaangkop.

 1class CustomError extends Error {
 2    constructor(message: string, public errorCode: number) {
 3        super(message);
 4        this.name = "CustomError";
 5    }
 6}
 7
 8try {
 9    throw new CustomError("Database connection failed", 500);
10} catch (error) {
11    if (error instanceof CustomError) {
12        console.error(`Error: ${error.message}, Code: ${error.errorCode}`);
13    }
14}

Buod

Ang klase ng Error sa TypeScript ay isang pangunahing klase para sa pagsasagawa ng karaniwang paghawak ng error. Bukod dito, sa pamamagitan ng pagpapalawig ng klase ng Error upang lumikha ng mga pasadyang error, nagiging posible ang may kakayahang umangkop na paghawak ng error batay sa mga uri ng error at karagdagang impormasyon.

Maaari mong sundan ang artikulo sa itaas gamit ang Visual Studio Code sa aming YouTube channel. Paki-check din ang aming YouTube channel.

YouTube Video