டைப்ஸ்கிரிப்ட் அசெர்ஷன் ஃபங்ஷன்கள்: ரன்டைம் வகை பாதுகாப்பிற்கான முழுமையான வழிகாட்டி

வலை மேம்பாட்டு உலகில், உங்கள் குறியீட்டின் எதிர்பார்ப்புகளுக்கும் அது பெறும் தரவுகளின் யதார்த்தத்திற்கும் இடையிலான ஒப்பந்தம் பெரும்பாலும் பலவீனமாக உள்ளது. டைப்ஸ்கிரிப்ட், ஜாவாஸ்கிரிப்டை நாம் எழுதும் விதத்தில் ஒரு புரட்சியை ஏற்படுத்தியுள்ளது, இது ஒரு சக்திவாய்ந்த ஸ்டேடிக் டைப் சிஸ்டத்தை வழங்கி, எண்ணற்ற பிழைகளை உற்பத்திக்கு வருவதற்கு முன்பே கண்டறிகிறது. இருப்பினும், இந்த பாதுகாப்பு வலை முதன்மையாக கம்பைல்-டைம் இல் மட்டுமே உள்ளது. உங்கள் அழகாக டைப் செய்யப்பட்ட பயன்பாடு ரன்டைம் இல் வெளியுலகிலிருந்து குழப்பமான, கணிக்க முடியாத தரவைப் பெறும்போது என்ன நடக்கும்? இங்குதான் டைப்ஸ்கிரிப்டின் அசெர்ஷன் ஃபங்ஷன்கள் உண்மையான வலுவான பயன்பாடுகளை உருவாக்குவதற்கான ஒரு தவிர்க்க முடியாத கருவியாக மாறுகின்றன.

இந்த விரிவான வழிகாட்டி உங்களை அசெர்ஷன் ஃபங்ஷன்களுக்குள் ஆழமாக அழைத்துச் செல்லும். அவை ஏன் அவசியம், அவற்றை புதிதாக எப்படி உருவாக்குவது, மற்றும் பொதுவான நிஜ-உலக சூழ்நிலைகளில் அவற்றை எவ்வாறு பயன்படுத்துவது என்பதை நாம் ஆராய்வோம். முடிவில், கம்பைல்-டைமில் வகை-பாதுகாப்பாக இருப்பது மட்டுமல்லாமல், ரன்டைமிலும் நெகிழ்வான மற்றும் கணிக்கக்கூடிய குறியீட்டை எழுத நீங்கள் தயாராகிவிடுவீர்கள்.

பெரும் பிளவு: கம்பைல்-டைம் vs. ரன்டைம்

அசெர்ஷன் ஃபங்ஷன்களை முழுமையாகப் பாராட்ட, அவை தீர்க்கும் அடிப்பட சவாலை நாம் முதலில் புரிந்து கொள்ள வேண்டும்: டைப்ஸ்கிரிப்டின் கம்பைல்-டைம் உலகிற்கும் ஜாவாஸ்கிரிப்டின் ரன்டைம் உலகிற்கும் இடையிலான இடைவெளி.

டைப்ஸ்கிரிப்டின் கம்பைல்-டைம் சொர்க்கம்

நீங்கள் டைப்ஸ்கிரிப்ட் குறியீட்டை எழுதும்போது, நீங்கள் ஒரு டெவலப்பரின் சொர்க்கத்தில் வேலை செய்கிறீர்கள். டைப்ஸ்கிரிப்ட் கம்பைலர் (tsc) ஒரு விழிப்புள்ள உதவியாளராக செயல்படுகிறது, நீங்கள் வரையறுத்த வகைகளுக்கு எதிராக உங்கள் குறியீட்டை பகுப்பாய்வு செய்கிறது. அது சரிபார்க்கிறது:

ஃபங்ஷன்களுக்கு தவறான வகைகள் அனுப்பப்படுதல்.
ஒரு ஆப்ஜெக்டில் இல்லாத பண்புகளை அணுகுதல்.
null அல்லது undefined ஆக இருக்கக்கூடிய ஒரு வேரியபிளை அழைத்தல்.

இந்த செயல்முறை உங்கள் குறியீடு இயக்கப்படுவதற்கு முன்பு நடக்கிறது. இறுதி வெளியீடு அனைத்து வகை குறிப்புகளும் நீக்கப்பட்ட சாதாரண ஜாவாஸ்கிரிப்ட் ஆகும். டைப்ஸ்கிரிப்டை ஒரு கட்டிடத்திற்கான விரிவான கட்டிடக்கலை வரைபடமாக நினைத்துப் பாருங்கள். இது அனைத்து திட்டங்களும் சரியாக இருப்பதையும், அளவீடுகள் சரியானவை என்பதையும், மற்றும் காகிதத்தில் கட்டமைப்பு ஒருமைப்பாடு உறுதி செய்யப்படுவதையும் உறுதி செய்கிறது.

ஜாவாஸ்கிரிப்டின் ரன்டைம் யதார்த்தம்

உங்கள் டைப்ஸ்கிரிப்ட் ஜாவாஸ்கிரிப்டாக தொகுக்கப்பட்டு ஒரு பிரவுசர் அல்லது நோட்.ஜேஎஸ் சூழலில் இயங்கும்போது, ஸ்டேடிக் வகைகள் மறைந்துவிடும். உங்கள் குறியீடு இப்போது ரன்டைமின் மாறும், கணிக்க முடியாத உலகில் செயல்படுகிறது. அது கட்டுப்படுத்த முடியாத மூலங்களிலிருந்து வரும் தரவுகளைக் கையாள வேண்டும், அவை:

ஏபிஐ ரெஸ்பான்ஸ்கள் (API Responses): ஒரு பேக்எண்ட் சேவை எதிர்பாராதவிதமாக அதன் தரவு கட்டமைப்பை மாற்றக்கூடும்.
பயனர் உள்ளீடு (User Input): HTML படிவங்களிலிருந்து வரும் தரவு, உள்ளீட்டு வகையைப் பொருட்படுத்தாமல், எப்போதும் ஒரு ஸ்டிரிங்காகக் கருதப்படுகிறது.
லோக்கல் ஸ்டோரேஜ் (Local Storage): localStorage இலிருந்து பெறப்பட்ட தரவு எப்போதும் ஒரு ஸ்டிரிங் மற்றும் அதை பார்ஸ் செய்ய வேண்டும்.
சுற்றுச்சூழல் மாறிகள் (Environment Variables): இவை பெரும்பாலும் ஸ்டிரிங்குகளாக இருக்கும் மற்றும் முற்றிலும் இல்லாமல் இருக்கலாம்.

நமது ஒப்புமையைப் பயன்படுத்தினால், ரன்டைம் என்பது கட்டுமான தளம். வரைபடம் சரியானதாக இருந்தது, ஆனால் வழங்கப்பட்ட பொருட்கள் (தரவு) தவறான அளவு, தவறான வகை, அல்லது வெறுமனே காணாமல் போகலாம். இந்த தவறான பொருட்களைக் கொண்டு நீங்கள் கட்ட முயன்றால், உங்கள் கட்டமைப்பு இடிந்து விழும். இங்குதான் ரன்டைம் பிழைகள் ஏற்படுகின்றன, இது பெரும்பாலும் "Cannot read properties of undefined" போன்ற செயலிழப்புகளுக்கும் பிழைகளுக்கும் வழிவகுக்கிறது.

அசெர்ஷன் ஃபங்ஷன்களின் வருகை: இடைவெளியைக் குறைத்தல்

ஆக, ரன்டைமின் கணிக்க முடியாத பொருட்களின் மீது நமது டைப்ஸ்கிரிப்ட் வரைபடத்தை எப்படி செயல்படுத்துவது? தரவு வரும்போதே அதைச் சரிபார்த்து, அது நமது எதிர்பார்ப்புகளுடன் பொருந்துகிறதா என்பதை உறுதிசெய்ய ஒரு பொறிமுறை நமக்குத் தேவை. இதைத்தான் அசெர்ஷன் ஃபங்ஷன்கள் துல்லியமாகச் செய்கின்றன.

அசெர்ஷன் ஃபங்ஷன் என்றால் என்ன?

ஒரு அசெர்ஷன் ஃபங்ஷன் என்பது டைப்ஸ்கிரிப்டில் ஒரு சிறப்பு வகை ஃபங்ஷன் ஆகும், இது இரண்டு முக்கியமான நோக்கங்களுக்காக செயல்படுகிறது:

ரன்டைம் சரிபார்ப்பு (Runtime Check): இது ஒரு மதிப்பு அல்லது நிபந்தனை மீது ஒரு சரிபார்ப்பைச் செய்கிறது. சரிபார்ப்பு தோல்வியுற்றால், அது ஒரு பிழையை வீசுகிறது, உடனடியாக அந்த குறியீட்டுப் பாதையின் செயல்பாட்டை நிறுத்துகிறது. இது தவறான தரவு உங்கள் பயன்பாட்டிற்குள் மேலும் பரவுவதைத் தடுக்கிறது.
கம்பைல்-டைம் டைப் நேரோயிங் (Compile-Time Type Narrowing): சரிபார்ப்பு வெற்றியடைந்தால் (அதாவது, எந்தப் பிழையும் வீசப்படாவிட்டால்), அது டைப்ஸ்கிரிப்ட் கம்பைலருக்கு அந்த மதிப்பின் வகை இப்போது மேலும் குறிப்பிட்டது என்று சமிக்ஞை செய்கிறது. கம்பைலர் இந்த உறுதிமொழியை நம்புகிறது மற்றும் அதன் நோக்கத்தின் மீதமுள்ள பகுதிக்கு அந்த மதிப்பை உறுதியளிக்கப்பட்ட வகையாகப் பயன்படுத்த உங்களை அனுமதிக்கிறது.

இதன் மாயம் ஃபங்ஷனின் கையொப்பத்தில் உள்ளது, இது asserts என்ற முக்கிய சொல்லைப் பயன்படுத்துகிறது. இரண்டு முதன்மை வடிவங்கள் உள்ளன:

asserts condition [is type]: இந்த வடிவம் ஒரு குறிப்பிட்ட condition உண்மை என்பதை உறுதிப்படுத்துகிறது. ஒரு மாறியின் வகையைக் குறைக்கவும் நீங்கள் விருப்பமாக is type (ஒரு வகை предикеட்) சேர்க்கலாம்.
asserts this is type: இது this சூழலின் வகையை உறுதிப்படுத்த வகுப்பு முறைகளுக்குள் பயன்படுத்தப்படுகிறது.

முக்கிய அம்சம் "தோல்வியில் பிழையை வீசுதல்" (throw on failure) நடத்தை. ஒரு எளிய if சரிபார்ப்பைப் போலல்லாமல், ஒரு அசெர்ஷன் அறிவிக்கிறது: "இந்த நிபந்தனை நிரல் தொடர உண்மையாக இருக்க வேண்டும். அது இல்லையென்றால், இது ஒரு விதிவிலக்கான நிலை, நாம் உடனடியாக நிறுத்த வேண்டும்."

உங்கள் முதல் அசெர்ஷன் ஃபங்ஷனை உருவாக்குதல்: ஒரு நடைமுறை உதாரணம்

ஜாவாஸ்கிரிப்ட் மற்றும் டைப்ஸ்கிரிப்டில் மிகவும் பொதுவான பிரச்சனைகளில் ஒன்றான, சாத்தியமான null அல்லது undefined மதிப்புகளைக் கையாள்வதில் இருந்து தொடங்குவோம்.

பிரச்சனை: தேவையற்ற Null-கள்

ஒரு விருப்ப பயனர் ஆப்ஜெக்டை எடுத்து பயனரின் பெயரை லாக் செய்ய விரும்பும் ஒரு ஃபங்ஷனை கற்பனை செய்து பாருங்கள். டைப்ஸ்கிரிப்டின் கடுமையான null சரிபார்ப்புகள் ஒரு சாத்தியமான பிழையைப் பற்றி நம்மை சரியாக எச்சரிக்கும்.


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

function logUserName(user: User | undefined) {
  // 🚨 TypeScript Error: 'user' is possibly 'undefined'.
  console.log(user.name.toUpperCase()); 
}

இதை சரிசெய்வதற்கான நிலையான வழி ஒரு if சரிபார்ப்பு ஆகும்:


function logUserName(user: User | undefined) {
  if (user) {
    // Inside this block, TypeScript knows 'user' is of type 'User'.
    console.log(user.name.toUpperCase());
  } else {
    console.error('User is not provided.');
  }
}

இது வேலை செய்கிறது, ஆனால் இந்தச் சூழலில் `user` `undefined` ஆக இருப்பது சரிசெய்ய முடியாத பிழையாக இருந்தால் என்ன செய்வது? ஃபங்ஷன் அமைதியாக தொடர நாங்கள் விரும்பவில்லை. அது சத்தமாக தோல்வியடைய வேண்டும் என்று நாங்கள் விரும்புகிறோம். இது மீண்டும் மீண்டும் வரும் பாதுகாப்பு விதிகளுக்கு வழிவகுக்கிறது.

தீர்வு: ஒரு `assertIsDefined` அசெர்ஷன் ஃபங்ஷன்

இந்த முறையை நேர்த்தியாகக் கையாள ஒரு மறுபயன்பாட்டுக்குரிய அசெர்ஷன் ஃபங்ஷனை உருவாக்குவோம்.


// Our reusable assertion function
function assertIsDefined<T>(value: T, message: string = "Value is not defined"): asserts value is NonNullable<T> {
  if (value === undefined || value === null) {
    throw new Error(message);
  }
}

// Let's use it!
interface User {
  name: string;
  email: string;
}

function logUserName(user: User | undefined) {
  assertIsDefined(user, "User object must be provided to log name.");

  // No error! TypeScript now knows 'user' is of type 'User'.
  // The type has been narrowed from 'User | undefined' to 'User'.
  console.log(user.name.toUpperCase());
}

// Example usage:
const validUser = { name: 'Alice', email: 'alice@example.com' };
logUserName(validUser); // Logs "ALICE"

const invalidUser = undefined;
try {
  logUserName(invalidUser); // Throws an Error: "User object must be provided to log name."
} catch (error) {
  console.error(error.message);
}

அசெர்ஷன் கையொப்பத்தை பிரித்தல்

கையொப்பத்தை பிரிப்போம்: asserts value is NonNullable<T>

asserts: இது இந்த ஃபங்ஷனை ஒரு அசெர்ஷன் ஃபங்ஷனாக மாற்றும் சிறப்பு டைப்ஸ்கிரிப்ட் முக்கியச் சொல்.
value: இது ஃபங்ஷனின் முதல் பாராமீட்டரைக் குறிக்கிறது (நமது விஷயத்தில், `value` என்ற பெயரிடப்பட்ட மாறி). எந்த மாறியின் வகை குறைக்கப்பட வேண்டும் என்பதை இது டைப்ஸ்கிரிப்டிற்குச் சொல்கிறது.
is NonNullable<T>: இது ஒரு வகை предикеட். ஃபங்ஷன் ஒரு பிழையை வீசவில்லை என்றால், `value` இன் வகை இப்போது NonNullable<T> என்று கம்பைலருக்குச் சொல்கிறது. டைப்ஸ்கிரிப்டில் உள்ள NonNullable பயன்பாட்டு வகை ஒரு வகையிலிருந்து null மற்றும் undefined ஆகியவற்றை நீக்குகிறது.

அசெர்ஷன் ஃபங்ஷன்களுக்கான நடைமுறை பயன்பாட்டு வழக்குகள்

இப்போது நாம் அடிப்படைகளைப் புரிந்து கொண்டோம், பொதுவான, நிஜ-உலகப் பிரச்சனைகளைத் தீர்க்க அசெர்ஷன் ஃபங்ஷன்களை எவ்வாறு பயன்படுத்துவது என்பதை ஆராய்வோம். அவை உங்கள் பயன்பாட்டின் எல்லைகளில் மிகவும் சக்திவாய்ந்தவை, அங்கு வெளிப்புற, வகைப்படுத்தப்படாத தரவு உங்கள் கணினியில் நுழைகிறது.

பயன்பாட்டு வழக்கு 1: ஏபிஐ ரெஸ்பான்ஸ்களை சரிபார்த்தல்

இது விவாதத்திற்குரிய வகையில் மிக முக்கியமான பயன்பாட்டு வழக்கு. ஒரு fetch கோரிக்கையிலிருந்து வரும் தரவு இயல்பாகவே நம்பத்தகாதது. டைப்ஸ்கிரிப்ட் `response.json()` இன் முடிவை `Promise` அல்லது `Promise` என சரியாக வகைப்படுத்துகிறது, அதை நீங்கள் சரிபார்க்கும்படி கட்டாயப்படுத்துகிறது.

சூழ்நிலை

நாங்கள் ஒரு ஏபிஐயிலிருந்து பயனர் தரவைப் பெறுகிறோம். அது எங்கள் `User` இடைமுகத்துடன் பொருந்தும் என்று நாங்கள் எதிர்பார்க்கிறோம், ஆனால் நாங்கள் உறுதியாக இருக்க முடியாது.


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

// A regular type guard (returns a boolean)
function isUser(data: unknown): data is User {
  return (
    typeof data === 'object' &&
    data !== null &&
    'id' in data && typeof (data as any).id === 'number' &&
    'name' in data && typeof (data as any).name === 'string' &&
    'email' in data && typeof (data as any).email === 'string'
  );
}

// Our new assertion function
function assertIsUser(data: unknown): asserts data is User {
  if (!isUser(data)) {
    throw new TypeError('Invalid User data received from API.');
  }
}

async function fetchAndProcessUser(userId: number) {
  const response = await fetch(`https://api.example.com/users/${userId}`);
  const data: unknown = await response.json();

  // Assert the data shape at the boundary
  assertIsUser(data);

  // From this point on, 'data' is safely typed as 'User'.
  // No more 'if' checks or type casting needed!
  console.log(`Processing user: ${data.name.toUpperCase()} (${data.email})`);
}

fetchAndProcessUser(1);

இது ஏன் சக்தி வாய்ந்தது: ரெஸ்பான்ஸைப் பெற்ற உடனேயே `assertIsUser(data)` என்று அழைப்பதன் மூலம், நாம் ஒரு "பாதுகாப்புக் கதவை" உருவாக்குகிறோம். தொடரும் எந்த குறியீடும் `data`-வை ஒரு `User` ஆக நம்பிக்கையுடன் கையாளலாம். இது சரிபார்ப்பு தர்க்கத்தை வணிக தர்க்கத்திலிருந்து பிரிக்கிறது, இது மிகவும் தூய்மையான மற்றும் படிக்கக்கூடிய குறியீட்டிற்கு வழிவகுக்கிறது.

பயன்பாட்டு வழக்கு 2: சுற்றுச்சூழல் மாறிகள் இருப்பதை உறுதி செய்தல்

சர்வர் பக்க பயன்பாடுகள் (எ.கா., நோட்.ஜேஎஸ்-ல்) உள்ளமைவுக்கு சுற்றுச்சூழல் மாறிகளை பெரிதும் நம்பியுள்ளன. `process.env.MY_VAR`-ஐ அணுகுவது `string | undefined` என்ற வகையை அளிக்கிறது. இது நீங்கள் அதைப் பயன்படுத்தும் எல்லா இடங்களிலும் அதன் இருப்பைச் சரிபார்க்கும்படி உங்களைக் கட்டாயப்படுத்துகிறது, இது கடினமானதும் பிழை ஏற்பட வாய்ப்புள்ளதும் ஆகும்.

சூழ்நிலை

நமது பயன்பாட்டிற்குத் தொடங்க சுற்றுச்சூழல் மாறிகளிலிருந்து ஒரு ஏபிஐ கீ மற்றும் ஒரு டேட்டாபேஸ் யூஆர்எல் தேவை. அவை இல்லை என்றால், பயன்பாடு இயங்க முடியாது மற்றும் ஒரு தெளிவான பிழைச் செய்தியுடன் உடனடியாக செயலிழக்க வேண்டும்.


// In a utility file, e.g., 'config.ts'

export function getEnvVar(key: string): string {
  const value = process.env[key];

  if (value === undefined) {
    throw new Error(`FATAL: Environment variable ${key} is not set.`);
  }

  return value;
}

// A more powerful version using assertions
function assertEnvVar(key: string): asserts key is keyof NodeJS.ProcessEnv {
  if (process.env[key] === undefined) {
    throw new Error(`FATAL: Environment variable ${key} is not set.`);
  }
}

// In your application's entry point, e.g., 'index.ts'

function startServer() {
  // Perform all checks at startup
  assertEnvVar('API_KEY');
  assertEnvVar('DATABASE_URL');

  const apiKey = process.env.API_KEY;
  const dbUrl = process.env.DATABASE_URL;

  // TypeScript now knows apiKey and dbUrl are strings, not 'string | undefined'.
  // Your application is guaranteed to have the required config.
  console.log('API Key length:', apiKey.length);
  console.log('Connecting to DB:', dbUrl.toLowerCase());

  // ... rest of the server startup logic
}

startServer();

இது ஏன் சக்தி வாய்ந்தது: இந்த முறை "விரைவில்-தோல்வி" (fail-fast) என்று அழைக்கப்படுகிறது. உங்கள் பயன்பாட்டின் வாழ்க்கைச் சுழற்சியின் ஆரம்பத்திலேயே அனைத்து முக்கியமான உள்ளமைவுகளையும் ஒரு முறை சரிபார்க்கிறீர்கள். ஒரு சிக்கல் இருந்தால், அது ஒரு விளக்கமான பிழையுடன் உடனடியாகத் தோல்வியடைகிறது, இது காணாமல் போன மாறி இறுதியாகப் பயன்படுத்தப்படும்போது பின்னர் ஏற்படும் ஒரு மர்மமான செயலிழப்பை விட பிழைதிருத்தம் செய்ய மிகவும் எளிதானது.

பயன்பாட்டு வழக்கு 3: DOM உடன் வேலை செய்தல்

நீங்கள் DOM-ஐ வினவும்போது, உதாரணமாக `document.querySelector` உடன், முடிவு `Element | null` ஆகும். ஒரு எலிமெண்ட் இருப்பதாக நீங்கள் உறுதியாக இருந்தால் (எ.கா., பிரதான பயன்பாட்டு ரூட் `div`), தொடர்ந்து `null`-ஐ சரிபார்ப்பது சிரமமாக இருக்கும்.

சூழ்நிலை

எங்களிடம் `

` உடன் ஒரு HTML கோப்பு உள்ளது, மேலும் எங்கள் ஸ்கிரிப்ட் அதனுடன் உள்ளடக்கத்தை இணைக்க வேண்டும். அது இருப்பதாக எங்களுக்குத் தெரியும்.


// Reusing our generic assertion from earlier
function assertIsDefined<T>(value: T, message: string = "Value is not defined"): asserts value is NonNullable<T> {
  if (value === undefined || value === null) {
    throw new Error(message);
  }
}

// A more specific assertion for DOM elements
function assertQuerySelector<T extends Element>(selector: string, constructor?: new () => T): T {
  const element = document.querySelector(selector);
  assertIsDefined(element, `FATAL: Element with selector '${selector}' not found in the DOM.`);

  // Optional: check if it's the right kind of element
  if (constructor && !(element instanceof constructor)) {
    throw new TypeError(`Element '${selector}' is not an instance of ${constructor.name}`);
  }

  return element as T;
}

// Usage
const appRoot = document.querySelector('#app-root');
assertIsDefined(appRoot, 'Could not find the main application root element.');

// After the assertion, appRoot is of type 'Element', not 'Element | null'.
appRoot.innerHTML = '<h1>Hello, World!</h1>';

// Using the more specific helper
const submitButton = assertQuerySelector<HTMLButtonElement>('#submit-btn', HTMLButtonElement);
// 'submitButton' is now correctly typed as HTMLButtonElement
submitButton.disabled = true;

இது ஏன் சக்தி வாய்ந்தது: இது உங்கள் சூழலைப் பற்றி உங்களுக்குத் தெரிந்த ஒரு மாறிலி—ஒரு நிபந்தனை—யை வெளிப்படுத்த உங்களை அனுமதிக்கிறது. இது தேவையற்ற null-சரிபார்ப்பு குறியீட்டை நீக்குகிறது மற்றும் ஒரு குறிப்பிட்ட DOM கட்டமைப்பின் மீது ஸ்கிரிப்டின் சார்புநிலையை தெளிவாக ஆவணப்படுத்துகிறது. கட்டமைப்பு மாறினால், உங்களுக்கு உடனடி, தெளிவான பிழை கிடைக்கும்.

அசெர்ஷன் ஃபங்ஷன்கள் vs. மாற்று வழிகள்

டைப் கார்டுகள் அல்லது டைப் காஸ்டிங் போன்ற பிற வகை-குறைக்கும் நுட்பங்களுக்கு எதிராக ஒரு அசெர்ஷன் ஃபங்ஷனை எப்போது பயன்படுத்த வேண்டும் என்பதை அறிவது முக்கியம்.

நுட்பம்	தொடரியல்	தோல்வியில் நடத்தை	சிறந்தது
டைப் கார்டுகள்	`value is Type`	`false` ஐ வழங்குகிறது	கட்டுப்பாட்டு ஓட்டம் (`if/else`). "விரும்பத்தகாத" வழக்கில் ஒரு செல்லுபடியாகும், மாற்று குறியீட்டுப் பாதை இருக்கும்போது. எ.கா., "இது ஒரு ஸ்டிரிங்காக இருந்தால், அதைச் செயலாக்கவும்; இல்லையெனில், ஒரு இயல்புநிலை மதிப்பைப் பயன்படுத்தவும்."
அசெர்ஷன் ஃபங்ஷன்கள்	`asserts value is Type`	ஒரு `Error` ஐ வீசுகிறது	மாறிலிகளை அமல்படுத்துதல். ஒரு நிபந்தனை நிரல் சரியாகத் தொடர உண்மையாக இருக்க வேண்டும் போது. "விரும்பத்தகாத" பாதை ஒரு சரிசெய்ய முடியாத பிழையாகும். எ.கா., "ஏபிஐ ரெஸ்பான்ஸ் ஒரு User ஆப்ஜெக்டாக இருக்க வேண்டும்."
டைப் காஸ்டிங்	`value as Type`	ரன்டைம் விளைவு இல்லை	அரிதான சந்தர்ப்பங்களில், டெவலப்பரான உங்களுக்கு கம்பைலரை விட அதிகமாகத் தெரியும் மற்றும் தேவையான சரிபார்ப்புகளை ஏற்கனவே செய்துள்ளீர்கள். இது பூஜ்ஜிய ரன்டைம் பாதுகாப்பை வழங்குகிறது மற்றும் குறைவாகவே பயன்படுத்தப்பட வேண்டும். அதிகப்படியான பயன்பாடு ஒரு "குறியீட்டின் குறைபாடு" ஆகும்.

முக்கிய வழிகாட்டுதல்

உங்களிடமே கேளுங்கள்: "இந்தச் சரிபார்ப்பு தோல்வியுற்றால் என்ன நடக்க வேண்டும்?"

ஒரு முறையான மாற்றுப் பாதை இருந்தால் (எ.கா., பயனர் அங்கீகரிக்கப்படவில்லை என்றால் ஒரு உள்நுழைவு பொத்தானைக் காட்டுங்கள்), ஒரு if/else பிளாக்குடன் ஒரு டைப் கார்டை பயன்படுத்தவும்.
ஒரு தோல்வியுற்ற சரிபார்ப்பு உங்கள் நிரல் ஒரு தவறான நிலையில் உள்ளது மற்றும் பாதுகாப்பாக தொடர முடியாது என்று அர்த்தம் என்றால், ஒரு அசெர்ஷன் ஃபங்ஷனை பயன்படுத்தவும்.
ஒரு ரன்டைம் சரிபார்ப்பு இல்லாமல் கம்பைலரை மீறினால், நீங்கள் ஒரு டைப் காஸ்டை பயன்படுத்துகிறீர்கள். மிகவும் கவனமாக இருங்கள்.

மேம்பட்ட வடிவங்கள் மற்றும் சிறந்த நடைமுறைகள்

1. ஒரு மையப்படுத்தப்பட்ட அசெர்ஷன் நூலகத்தை உருவாக்கவும்

உங்கள் குறியீட்டுத் தளம் முழுவதும் அசெர்ஷன் ஃபங்ஷன்களை சிதறடிக்காதீர்கள். அவற்றை src/utils/assertions.ts போன்ற ஒரு பிரத்யேக பயன்பாட்டுக் கோப்பில் மையப்படுத்தவும். இது மறுபயன்பாடு, நிலைத்தன்மை ஆகியவற்றை ஊக்குவிக்கிறது, மற்றும் உங்கள் சரிபார்ப்பு தர்க்கத்தைக் கண்டுபிடித்து சோதிப்பதை எளிதாக்குகிறது.


// src/utils/assertions.ts

export function assert(condition: unknown, message: string): asserts condition {
  if (!condition) {
    throw new Error(message);
  }
}

export function assertIsDefined<T>(value: T): asserts value is NonNullable<T> {
  assert(value !== null && value !== undefined, 'This value must be defined.');
}

export function assertIsString(value: unknown): asserts value is string {
  assert(typeof value === 'string', 'This value must be a string.');
}

// ... and so on.

2. அர்த்தமுள்ள பிழைகளை வீசுங்கள்

ஒரு தோல்வியுற்ற அசெர்ஷனில் இருந்து வரும் பிழைச் செய்தி பிழைதிருத்தத்தின் போது உங்கள் முதல் துப்பு. அதை மதிக்கவும்! "Assertion failed" போன்ற ஒரு பொதுவான செய்தி உதவாது. பதிலாக, சூழலை வழங்கவும்:

என்ன சரிபார்க்கப்பட்டது?
என்ன எதிர்பார்க்கப்பட்ட மதிப்பு/வகை?
என்ன உண்மையான மதிப்பு/வகை பெறப்பட்டது? (உணர்திறன் வாய்ந்த தரவை லாக் செய்யாமல் கவனமாக இருங்கள்).


function assertIsUser(data: unknown): asserts data is User {
  if (!isUser(data)) {
    // Bad: throw new Error('Invalid data');
    // Good:
    throw new TypeError(`Expected data to be a User object, but received ${JSON.stringify(data)}`);
  }
}

3. செயல்திறனில் கவனம் செலுத்துங்கள்

அசெர்ஷன் ஃபங்ஷன்கள் ரன்டைம் சரிபார்ப்புகள், அதாவது அவை CPU சுழற்சிகளை உட்கொள்கின்றன. இது உங்கள் பயன்பாட்டின் எல்லைகளில் (ஏபிஐ நுழைவு, உள்ளமைவு ஏற்றுதல்) முற்றிலும் ஏற்றுக்கொள்ளத்தக்கது மற்றும் விரும்பத்தக்கது. இருப்பினும், ஒரு வினாடிக்கு ஆயிரக்கணக்கான முறை இயங்கும் ஒரு இறுக்கமான லூப் போன்ற செயல்திறன்-முக்கியமான குறியீட்டுப் பாதைகளுக்குள் சிக்கலான அசெர்ஷன்களை வைப்பதைத் தவிர்க்கவும். சரிபார்ப்பின் செலவு செய்யப்படும் செயல்பாட்டை விட (ஒரு நெட்வொர்க் கோரிக்கை போன்றவை) மிகக் குறைவாக இருக்கும் இடத்தில் அவற்றைப் பயன்படுத்தவும்.

முடிவுரை: நம்பிக்கையுடன் குறியீடு எழுதுதல்

டைப்ஸ்கிரிப்ட் அசெர்ஷன் ஃபங்ஷன்கள் ஒரு முக்கிய அம்சம் மட்டுமல்ல; அவை வலுவான, உற்பத்தி-தர பயன்பாடுகளை எழுதுவதற்கான ஒரு அடிப்படைக் கருவியாகும். கம்பைல்-டைம் கோட்பாட்டிற்கும் ரன்டைம் யதார்த்தத்திற்கும் இடையிலான முக்கியமான இடைவெளியைக் குறைக்க அவை உங்களுக்கு அதிகாரம் அளிக்கின்றன.

அசெர்ஷன் ஃபங்ஷன்களை ஏற்றுக்கொள்வதன் மூலம், நீங்கள்:

மாறிலிகளை அமல்படுத்தலாம்: உண்மையாக இருக்க வேண்டிய நிபந்தனைகளை முறையாக அறிவித்து, உங்கள் குறியீட்டின் அனுமானங்களை வெளிப்படையாക്കുക.
விரைவாகவும் சத்தமாகவும் தோல்வியடையலாம்: தரவு ஒருமைப்பாடு சிக்கல்களை மூலத்திலேயே பிடித்து, அவை பின்னர் நுட்பமான மற்றும் பிழைதிருத்தம் செய்ய கடினமான பிழைகளை ஏற்படுத்துவதைத் தடுக்கவும்.
குறியீட்டின் தெளிவை மேம்படுத்தலாம்: உட்பொதிக்கப்பட்ட if சரிபார்ப்புகள் மற்றும் டைப் காஸ்ட்களை நீக்கி, தூய்மையான, நேரியல், மற்றும் சுய-ஆவணப்படுத்தும் வணிக தர்க்கத்தை விளைவிக்கவும்.
நம்பிக்கையை அதிகரிக்கலாம்: உங்கள் வகைகள் கம்பைலருக்கான பரிந்துரைகள் மட்டுமல்ல, குறியீடு இயங்கும்போது அவை தீவிரமாக அமல்படுத்தப்படுகின்றன என்ற உறுதியுடன் குறியீட்டை எழுதவும்.

அடுத்த முறை நீங்கள் ஒரு ஏபிஐயிலிருந்து தரவைப் பெறும்போது, ஒரு உள்ளமைவுக் கோப்பைப் படிக்கும்போது, அல்லது பயனர் உள்ளீட்டைச் செயலாக்கும்போது, வகையை மாற்றிவிட்டு சிறந்ததை நம்ப வேண்டாம். அதை உறுதிப்படுத்துங்கள். உங்கள் கணினியின் விளிம்பில் ஒரு பாதுகாப்புக் கதவைக் கட்டுங்கள். உங்கள் எதிர்கால நீங்களும்—உங்கள் குழுவும்—நீங்கள் எழுதிய வலுவான, கணிக்கக்கூடிய, மற்றும் நெகிழ்வான குறியீட்டிற்கு நன்றி தெரிவிப்பார்கள்.