TypeScript சரிபார்ப்பு: வலிமையான பயன்பாடுகளுக்கான ரன்டைம் வகை சரிபார்ப்பு நூலகங்களில் முழுத் தேர்ச்சி

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

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

TypeScript-ல் ரன்டைம் வகை சரிபார்ப்பு ஏன் முக்கியமானது

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

ரன்டைம் சரிபார்ப்பு அத்தியாவசியமாக மாறும் சூழ்நிலைகளைக் கருத்தில் கொள்ளுங்கள்:

• API பதில்கள்: வெளி API-களிலிருந்து பெறப்படும் தரவு, ஆவணப்படுத்தப்பட்ட ஸ்கீமாக்களைக் கொண்டிருந்தாலும், எதிர்பாராத சிக்கல்கள், API வழங்குநரின் செயல்படுத்துதலில் ஏற்படும் மாற்றங்கள் அல்லது நெட்வொர்க் பிழைகள் காரணமாக எதிர்பார்ப்புகளில் இருந்து எப்போதாவது விலகலாம்.
• பயனர் உள்ளீடு: படிவங்கள் மற்றும் பயனர் இடைமுகங்கள் செயலாக்கத்திற்கு முன் சரிபார்க்கப்பட வேண்டிய தரவைச் சேகரிக்கின்றன, சரியான மற்றும் எதிர்பார்க்கப்படும் வடிவங்கள் மட்டுமே ஏற்றுக்கொள்ளப்படுவதை உறுதிசெய்கின்றன. உள்ளீட்டு வடிவங்கள் (தொலைபேசி எண்கள் அல்லது தேதிகள் போன்றவை) கணிசமாக வேறுபடக்கூடிய சர்வதேச பயன்பாடுகளுக்கு இது மிக முக்கியமானது.
• கட்டமைப்பு கோப்புகள்: பயன்பாடுகள் பெரும்பாலும் கட்டமைப்பு கோப்புகளை (எ.கா., JSON, YAML) நம்பியுள்ளன. தொடக்கத்தில் இந்தக் கோப்புகளைச் சரிபார்ப்பது, பயன்பாடு சரியாக கட்டமைக்கப்பட்டுள்ளதை உறுதிசெய்கிறது, செயலிழப்புகள் அல்லது தவறான நடத்தையைத் தடுக்கிறது.
• நம்பத்தகாத மூலங்களிலிருந்து வரும் தரவு: நம்பத்தகாத மூலங்களிலிருந்து உருவாகும் தரவுகளுடன் தொடர்பு கொள்ளும்போது, இன்ஜெக்ஷன் தாக்குதல்கள் அல்லது தரவுச் சிதைவைத் தடுக்க முழுமையான சரிபார்ப்பு ஒரு பாதுகாப்பு நடவடிக்கையாகும்.
• பல சூழல் நிலைத்தன்மை: வெவ்வேறு JavaScript ரன்டைம்கள் (Node.js, உலாவிகள்) மற்றும் சீரியலைசேஷன்/டிசீரியலைசேஷன் (எ.கா., JSON.parse/stringify) போது தரவு கட்டமைப்புகள் சீராக இருப்பதை உறுதி செய்வது முக்கியம்.

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

TypeScript ரன்டைம் சரிபார்ப்புக்கான முக்கிய நூலகங்கள்

நல்ல வேளையாக, TypeScript சூழல் ரன்டைம் வகை சரிபார்ப்பு மற்றும் தரவு சரிபார்ப்புக்காக சிறப்பாக வடிவமைக்கப்பட்ட பல சிறந்த நூலகங்களை வழங்குகிறது. இந்த நூலகங்கள் உங்கள் எதிர்பார்க்கப்படும் தரவு கட்டமைப்புகளை விவரிக்கும் ஸ்கீமாக்களை வரையறுக்க உங்களை அனுமதிக்கின்றன, பின்னர் உள்வரும் தரவை சரிபார்க்க இந்த ஸ்கீமாக்களைப் பயன்படுத்தலாம்.

மிகவும் பிரபலமான மற்றும் பயனுள்ள சில நூலகங்களை நாங்கள் ஆராய்வோம்:

1. Zod

Zod அதன் உள்ளுணர்வு API, வலுவான TypeScript ஒருங்கிணைப்பு மற்றும் விரிவான அம்சங்களுக்காக விரைவாகப் பிரபலமடைந்துள்ளது. இது உங்கள் தரவுகளுக்கான "ஸ்கீமாவை" வரையறுக்கவும், பின்னர் ரன்டைமில் தரவை பார்ஸ் செய்து சரிபார்க்க அந்த ஸ்கீமாவை பயன்படுத்தவும் உங்களை அனுமதிக்கிறது. Zod-ன் ஸ்கீமாக்கள் வலுவாக டைப் செய்யப்பட்டவை, அதாவது TypeScript வகைகள் ஸ்கீமா வரையறையிலிருந்து நேரடியாகக் கணிக்கப்படலாம், கைமுறை வகை விளக்கங்களின் தேவையை குறைக்கிறது.

Zod-ன் முக்கிய அம்சங்கள்:

• அறிமுக வகைப்படுத்தல்: Zod ஸ்கீமாக்களிலிருந்து நேரடியாக TypeScript வகைகளை அறியலாம்.
• அறிவிப்பு ஸ்கீமா வரையறை: நெஸ்டட் ஆப்ஜெக்ட்டுகள், அரேக்கள், யூனியன்கள், இன்டர்செக்ஷன்கள் மற்றும் தனிப்பயன் வகைகள் உள்ளிட்ட சிக்கலான தரவு கட்டமைப்புகளை தெளிவான மற்றும் படிக்கக்கூடிய முறையில் வரையறுக்கவும்.
• சக்திவாய்ந்த மாற்றம்: பார்ஸிங் செய்யும் போது தரவை மாற்றவும் (எ.கா., ஸ்ட்ரிங்-ஐ எண்ணாக, தேதி பார்ஸிங்).
• விரிவான பிழை அறிக்கை: உலகளாவிய பயனர்களுக்கு பிழைத்திருத்தம் மற்றும் கருத்துக்களை வழங்குவதற்கு முக்கியமான விரிவான மற்றும் பயனர் நட்பு பிழை செய்திகளை வழங்குகிறது.
• உள்ளமைக்கப்பட்ட சரிபார்ப்பாளர்கள்: ஸ்ட்ரிங்குகள், எண்கள், பூலியன்கள், தேதிகள் மற்றும் பலவற்றிற்கான பரந்த அளவிலான உள்ளமைக்கப்பட்ட சரிபார்ப்பாளர்களை வழங்குகிறது, மேலும் தனிப்பயன் சரிபார்ப்பாளர்களை உருவாக்கும் திறனையும் வழங்குகிறது.
• சங்கிலித் தொடர் API: ஸ்கீமாக்கள் எளிதாக தொகுக்கப்படக்கூடியவை மற்றும் நீட்டிக்கக்கூடியவை.

எடுத்துக்காட்டு: Zod மூலம் ஒரு பயனர் சுயவிவரத்தை சரிபார்த்தல்

ஒரு API-யிலிருந்து பயனர் சுயவிவரத் தரவைப் பெறுகிறோம் என்று கற்பனை செய்வோம். பயனருக்கு ஒரு சரியான பெயர், ஒரு விருப்பமான வயது மற்றும் ஆர்வங்களின் பட்டியல் இருப்பதை உறுதி செய்ய விரும்புகிறோம்.

            
import { z } from 'zod';

// Define the schema for a User Profile
const UserProfileSchema = z.object({
  name: z.string().min(1, "Name cannot be empty."), // Name is a required string, at least 1 character
  age: z.number().int().positive().optional(),     // Age is an optional positive integer
  interests: z.array(z.string()).min(1, "At least one interest is required."), // Interests is an array of strings, at least one item
  isActive: z.boolean().default(true)           // isActive is a boolean, defaults to true if not provided
});

// Infer the TypeScript type from the schema
type UserProfile = z.infer<typeof UserProfileSchema>;

// Example API response data
const apiResponse1 = {
  name: "Alice",
  age: 30,
  interests: ["coding", "travel"],
  isActive: false
};

const apiResponse2 = {
  name: "Bob",
  // age is missing
  interests: [] // empty interests array
};

// --- Validation Example 1 ---
try {
  const validatedProfile1 = UserProfileSchema.parse(apiResponse1);
  console.log('Profile 1 is valid:', validatedProfile1);
  // TypeScript now knows validatedProfile1 has the type UserProfile
} catch (error) {
  if (error instanceof z.ZodError) {
    console.error('Validation errors for Profile 1:', error.errors);
  } else {
    console.error('An unexpected error occurred:', error);
  }
}

// --- Validation Example 2 ---
try {
  const validatedProfile2 = UserProfileSchema.parse(apiResponse2);
  console.log('Profile 2 is valid:', validatedProfile2);
} catch (error) {
  if (error instanceof z.ZodError) {
    console.error('Validation errors for Profile 2:', error.errors);
    /*
    Expected output for errors:
    [
      { code: 'array_min_size', message: 'At least one interest is required.', path: [ 'interests' ] }
    ]
    */
  } else {
    console.error('An unexpected error occurred:', error);
  }
}

// --- Example with optional property behavior ---
const apiResponse3 = {
    name: "Charlie",
    interests: ["reading"]
    // isActive is omitted, will default to true
};

try {
    const validatedProfile3 = UserProfileSchema.parse(apiResponse3);
    console.log('Profile 3 is valid (isActive defaults to true):', validatedProfile3);
    /*
    Expected output: {
      name: 'Charlie',
      interests: [ 'reading' ],
      isActive: true
    }
    */
} catch (error) {
    console.error('Validation errors for Profile 3:', error);
}

            

              
                Copy
              
            
          

Zod-ன் பிழை அறிக்கை சர்வதேச பயன்பாடுகளுக்கு குறிப்பாகப் பயனுள்ளதாக இருக்கும், ஏனெனில் பயனர் வட்டாரத்தின் அடிப்படையில் பிழை செய்திகளை சர்வதேசமயமாக்கலாம், இருப்பினும் நூலகமே இந்த செயல்முறையை எளிதாக்கும் கட்டமைக்கப்பட்ட பிழை தரவை வழங்குகிறது.

2. Yup

Yup என்பது JavaScript மற்றும் TypeScript-க்கான மற்றொரு பிரபலமான மற்றும் முதிர்ந்த சரிபார்ப்பு நூலகமாகும். இது பெரும்பாலும் படிவ சரிபார்ப்புக்காக Formik உடன் பயன்படுத்தப்படுகிறது, ஆனால் பொதுவான தரவு சரிபார்ப்புக்கும் சமமாக சக்தி வாய்ந்தது. Yup ஒரு ஃபுளுயன்ட் API-ஐப் பயன்படுத்தி ஸ்கீமாக்களை வரையறுக்கிறது, அவை பின்னர் JavaScript ஆப்ஜெக்ட்டுகளை சரிபார்க்கப் பயன்படுத்தப்படுகின்றன.

Yup-ன் முக்கிய அம்சங்கள்:

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

எடுத்துக்காட்டு: Yup மூலம் ஒரு தயாரிப்பு பட்டியல் உள்ளீட்டை சரிபார்த்தல்

ஒரு தயாரிப்பு உள்ளீட்டை சரிபார்ப்போம், அதற்கு ஒரு பெயர், விலை மற்றும் ஒரு விருப்பமான விளக்கம் இருப்பதை உறுதி செய்வோம்.

            
import * as yup from 'yup';

// Define the schema for a Product Entry
const ProductSchema = yup.object({
  name: yup.string().required('Product name is required.'),
  price: yup.number().positive('Price must be a positive number.').required('Price is required.'),
  description: yup.string().optional('Description is optional.'),
  tags: yup.array(yup.string()).default([]), // Default to an empty array if not provided
  releaseDate: yup.date().optional()
});

// Infer the TypeScript type from the schema
type Product = yup.InferType<typeof ProductSchema>;

// Example product data
const productData1 = {
  name: "Global Gadget",
  price: 199.99,
  tags: ["electronics", "new arrival"],
  releaseDate: new Date('2023-10-27T10:00:00Z')
};

const productData2 = {
  name: "Budget Widget",
  price: -10.50 // Invalid price
};

// --- Validation Example 1 ---
ProductSchema.validate(productData1, { abortEarly: false })
  .then(function (validProduct: Product) {
    console.log('Product 1 is valid:', validProduct);
    // TypeScript knows validProduct is of type Product
  })
  .catch(function (err: yup.ValidationError) {
    console.error('Validation errors for Product 1:', err.errors);
  });

// --- Validation Example 2 ---
ProductSchema.validate(productData2, { abortEarly: false })
  .then(function (validProduct: Product) {
    console.log('Product 2 is valid:', validProduct);
  })
  .catch(function (err: yup.ValidationError) {
    console.error('Validation errors for Product 2:', err.errors);
    /*
    Expected output for errors:
    [
      'Price must be a positive number.'
    ]
    */
  });

// --- Example with default value behavior ---
const productData3 = {
    name: "Simple Item",
    price: 5.00
    // tags and releaseDate are omitted
};

ProductSchema.validate(productData3, { abortEarly: false })
    .then(function (validProduct: Product) {
        console.log('Product 3 is valid (tags default to []):', validProduct);
        /*
        Expected output: {
          name: 'Simple Item',
          price: 5,
          tags: [],
          releaseDate: undefined
        }
        */
    })
    .catch(function (err: yup.ValidationError) {
        console.error('Validation errors for Product 3:', err.errors);
    });

            

              
                Copy
              
            
          

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

3. io-ts

io-ts என்பது ஒரு செயல்பாட்டு நிரலாக்க அணுகுமுறையைப் பயன்படுத்தி TypeScript-க்கு ரன்டைம் வகை சரிபார்ப்பைக் கொண்டுவரும் ஒரு நூலகமாகும். இது "கோடெக்குகளை" வரையறுக்கிறது, அவை தரவை குறியாக்கம் மற்றும் குறியீட்டை நீக்க பயன்படுத்தப்படுகின்றன, தரவு ரன்டைமில் ஒரு குறிப்பிட்ட வகைக்கு இணங்குவதை உறுதிசெய்கிறது. இந்த நூலகம் அதன் துல்லியம் மற்றும் செயல்பாட்டு கோட்பாடுகளுக்கு வலுவான இணக்கத்திற்காக அறியப்படுகிறது.

io-ts-ன் முக்கிய அம்சங்கள்:

• கோடெக் அடிப்படையிலான: வகைகளை வரையறுக்க மற்றும் சரிபார்க்க கோடெக்குகளைப் பயன்படுத்துகிறது.
• செயல்பாட்டு நிரலாக்க முன்னுதாரணம்: செயல்பாட்டு நிரலாக்க பாணிகளுடன் நன்கு இணைகிறது.
• ரன்டைம் வகை பாதுகாப்பு: ரன்டைமில் உத்தரவாதமான வகை பாதுகாப்பை வழங்குகிறது.
• விரிவாக்கக்கூடியது: தனிப்பயன் கோடெக்குகளை உருவாக்க அனுமதிக்கிறது.
• விரிவான அம்சத் தொகுப்பு: யூனியன் வகைகள், இன்டர்செக்ஷன் வகைகள், ரிகர்சிவ் வகைகள் மற்றும் பலவற்றை ஆதரிக்கிறது.
• துணை நூலகங்கள்: எளிதான ப்ராமிஸ் ஒருங்கிணைப்பிற்கான io-ts-promise மற்றும் சிறந்த பிழை அறிக்கைக்காக io-ts-reporters போன்ற துணை நூலகங்களைக் கொண்டுள்ளது.

எடுத்துக்காட்டு: io-ts மூலம் ஒரு புவிஇருப்பிட புள்ளியை சரிபார்த்தல்

புவியியல் ஆயங்களை சரிபார்த்தல் ஒரு பொதுவான பணியாகும், குறிப்பாக இருப்பிடத்தை அறியும் உலகளாவிய பயன்பாடுகளுக்கு.

            
import *s t from 'io-ts';
import { formatValidationErrors } from 'io-ts-reporters'; // For better error reporting

// Define the codec for a Geolocation Point
const GeolocationPoint = t.type({
  latitude: t.number,
  longitude: t.number,
  accuracy: t.union([t.number, t.undefined]) // accuracy is optional
});

// Infer the TypeScript type from the codec
type Geolocation = t.TypeOf<typeof GeolocationPoint>;

// Example geolocation data
const geoData1 = {
  latitude: 34.0522,
  longitude: -118.2437,
  accuracy: 10.5
};

const geoData2 = {
  latitude: 'not a number',
  longitude: -0.1278
};

// --- Validation Example 1 ---
const result1 = GeolocationPoint.decode(geoData1);

if (result1._tag === 'Right') {
  const validatedGeo1: Geolocation = result1.right;
  console.log('Geolocation 1 is valid:', validatedGeo1);
} else {
  // result1._tag === 'Left'
  console.error('Validation errors for Geolocation 1:', formatValidationErrors(result1.left));
}

// --- Validation Example 2 ---
const result2 = GeolocationPoint.decode(geoData2);

if (result2._tag === 'Right') {
  const validatedGeo2: Geolocation = result2.right;
  console.log('Geolocation 2 is valid:', validatedGeo2);
} else {
  // result2._tag === 'Left'
  console.error('Validation errors for Geolocation 2:', formatValidationErrors(result2.left));
  /*
  Expected output for errors:
  - latitude: Expected number but received String
  */
}

// --- Example with optional property behavior ---
const geoData3 = {
    latitude: 51.5074, // London
    longitude: -0.1278
    // accuracy is omitted
};

const result3 = GeolocationPoint.decode(geoData3);

if (result3._tag === 'Right') {
    const validatedGeo3: Geolocation = result3.right;
    console.log('Geolocation 3 is valid (accuracy is undefined):', validatedGeo3);
    /*
    Expected output: {
      latitude: 51.5074,
      longitude: -0.1278,
      accuracy: undefined
    }
    */
} else {
    console.error('Validation errors for Geolocation 3:', formatValidationErrors(result3.left));
}

            

              
                Copy
              
            
          

செயல்பாட்டு நிரலாக்கக் கோட்பாடுகளைத் தழுவி, ரன்டைம் வகை பாதுகாப்பில் அதிக அளவு நம்பிக்கை தேவைப்படும் திட்டங்களுக்கு io-ts ஒரு சக்திவாய்ந்த தேர்வாகும். அதன் விரிவான பிழை அறிக்கை, குறிப்பாக io-ts-reporters உடன் இணைக்கப்படும்போது, சர்வதேசமயமாக்கப்பட்ட பயன்பாடுகளை பிழைத்திருத்தம் செய்வதற்கு விலைமதிப்பற்றது.

4. class-validator

class-validator மற்றும் அதன் துணை class-transformer ஆனது வகுப்புகளுடன் பணிபுரியும் சூழ்நிலைகளுக்கு, குறிப்பாக NestJS போன்ற ஃபிரேம்வொர்க்குகளில் சிறப்பாகும். இது கிளாஸ் பிராப்பர்ட்டிகளில் நேரடியாக டெகரேட்டர்களைப் பயன்படுத்தி சரிபார்ப்பு விதிகளை வரையறுக்க உங்களை அனுமதிக்கிறது.

class-validator-ன் முக்கிய அம்சங்கள்:

• டெகரேட்டர் அடிப்படையிலான சரிபார்ப்பு: கிளாஸ் பிராப்பர்ட்டிகளில் டெகரேட்டர்களைப் பயன்படுத்தவும் (எ.கா., @IsEmail(), @IsNotEmpty()).
• கிளாஸ்-டிரான்ஸ்ஃபார்மர் ஒருங்கிணைப்பு: சரிபார்ப்புக்கு முன் உள்வரும் தரவை கிளாஸ் இன்ஸ்டன்ஸ்களாக தடையின்றி மாற்றவும்.
• விரிவாக்கக்கூடியது: தனிப்பயன் சரிபார்ப்பு டெகரேட்டர்களை உருவாக்கவும்.
• உள்ளமைக்கப்பட்ட சரிபார்ப்பாளர்கள்: பொதுவான சரிபார்ப்பு தேவைகளுக்கான பரந்த அளவிலான டெகரேட்டர்கள்.
• பிழை கையாளுதல்: விரிவான சரிபார்ப்பு பிழை ஆப்ஜெக்ட்டுகளை வழங்குகிறது.

எடுத்துக்காட்டு: class-validator மூலம் ஒரு மின்னஞ்சல் பதிவு படிவத்தை சரிபார்த்தல்

உலகம் முழுவதிலுமிருந்து பயனர் பதிவுசெய்தல்களைக் கையாளும் பேக்கெண்ட் API-களுக்கு இது குறிப்பாகப் பயனுள்ளதாக இருக்கும்.

            
import 'reflect-metadata'; // Required for decorators
import { validate, Contains, IsInt, Length, IsEmail, IsOptional } from 'class-validator';
import { plainToClass, classToPlain } from 'class-transformer';

// Define the DTO (Data Transfer Object) with validation decorators
class UserRegistrationDto {
  @Length(5, 50, { message: 'Username must be between 5 and 50 characters.' })
  username: string;

  @IsEmail({}, { message: 'Invalid email address format.' })
  email: string;

  @IsInt({ message: 'Age must be an integer.' })
  @IsOptional() // Age is optional
  age?: number;

  constructor(username: string, email: string, age?: number) {
    this.username = username;
    this.email = email;
    this.age = age;
  }
}

// Example incoming data (e.g., from an API request body)
const registrationData1 = {
  username: "global_user",
  email: "user@example.com",
  age: 25
};

const registrationData2 = {
  username: "short", // Too short username
  email: "invalid-email", // Invalid email
  age: 30.5 // Not an integer
};

// --- Validation Example 1 ---
// First, transform plain object into a class instance
const userDto1 = plainToClass(UserRegistrationDto, registrationData1);

validate(userDto1).then(errors => {
  if (errors.length > 0) {
    console.error('Validation errors for Registration 1:', errors);
  } else {
    console.log('Registration 1 is valid:', classToPlain(userDto1)); // Convert back to plain object for output
  }
});

// --- Validation Example 2 ---
const userDto2 = plainToClass(UserRegistrationDto, registrationData2);

validate(userDto2).then(errors => {
  if (errors.length > 0) {
    console.error('Validation errors for Registration 2:', errors.map(err => err.constraints));
    /*
    Expected output for errors.constraints:
    [ {
      length: 'Username must be between 5 and 50 characters.',
      isEmail: 'Invalid email address format.',
      isInt: 'Age must be an integer.'
    } ]
    */
  } else {
    console.log('Registration 2 is valid:', classToPlain(userDto2));
  }
});

// --- Example with optional property behavior ---
const registrationData3 = {
    username: "validUser",
    email: "valid@example.com"
    // age is omitted, which is allowed by @IsOptional()
};

const userDto3 = plainToClass(UserRegistrationDto, registrationData3);

validate(userDto3).then(errors => {
    if (errors.length > 0) {
        console.error('Validation errors for Registration 3:', errors);
    } else {
        console.log('Registration 3 is valid (age is undefined):', classToPlain(userDto3));
        /*
        Expected output: {
          username: 'validUser',
          email: 'valid@example.com',
          age: undefined
        }
        */
    }
});

            

              
                Copy
              
            
          

class-validator ஆனது சர்வர்-சைட் பயன்பாடுகள் அல்லது வகுப்புகள் மற்றும் ஆப்ஜெக்ட்-ஓரியன்டட் நிரலாக்கத்தை பெரிதும் நம்பியிருக்கும் ஃபிரேம்வொர்க்குகளில் குறிப்பாக பயனுள்ளதாக இருக்கும். அதன் டெகரேட்டர் அடிப்படையிலான தொடரியல் மிகவும் வெளிப்படையானது மற்றும் டெவலப்பர் நட்பு.

சரியான சரிபார்ப்பு நூலகத்தைத் தேர்ந்தெடுத்தல்

உங்கள் திட்டத்திற்கான சிறந்த சரிபார்ப்பு நூலகம் பல காரணிகளைப் பொறுத்தது:

• திட்ட முன்னுதாரணம்: நீங்கள் செயல்பாட்டு நிரலாக்கத்தில் தீவிரமாக இருந்தால், io-ts உங்கள் தேர்வாக இருக்கலாம். ஆப்ஜெக்ட்-ஓரியன்டட் அணுகுமுறைகளுக்கு, class-validator சிறந்து விளங்குகிறது. சிறந்த TypeScript கணிப்புடன் கூடிய பொதுவான, அறிவிப்பு அணுகுமுறைக்கு, Zod ஒரு வலிமையான போட்டியாளர். Yup பல சூழ்நிலைகளுக்கு ஏற்ற ஒரு முதிர்ந்த மற்றும் நெகிழ்வான API-ஐ வழங்குகிறது.
• TypeScript ஒருங்கிணைப்பு: Zod ஸ்கீமாக்களிலிருந்து நேரடியாக தடையற்ற TypeScript வகை கணிப்பில் முன்னிலை வகிக்கிறது. மற்றவை நல்ல ஒருங்கிணைப்பை வழங்குகின்றன, ஆனால் அதிக வெளிப்படையான வகை வரையறைகள் தேவைப்படலாம்.
• கற்றல் வளைவு: புதியவர்களுக்கு Zod மற்றும் Yup பொதுவாகத் தொடங்க எளிதானதாகக் கருதப்படுகிறது. io-ts அதன் செயல்பாட்டு தன்மை காரணமாக ஒரு செங்குத்தான கற்றல் வளைவைக் கொண்டுள்ளது. நீங்கள் டெகரேட்டர்களுடன் வசதியாக இருந்தால் class-validator நேரடியானது.
• சூழல் மற்றும் சமூகம்: Yup மற்றும் Zod பெரிய மற்றும் சுறுசுறுப்பான சமூகங்களைக் கொண்டுள்ளன, இது ஏராளமான ஆதாரங்களையும் ஆதரவையும் வழங்குகிறது.
• குறிப்பிட்ட அம்சங்கள்: சிக்கலான மாற்றங்கள் (Zod), படிவ ஒருங்கிணைப்பு (Yup) அல்லது டெகரேட்டர் அடிப்படையிலான சரிபார்ப்பு (class-validator) போன்ற குறிப்பிட்ட அம்சங்கள் உங்களுக்குத் தேவைப்பட்டால், இவை உங்கள் முடிவை பாதிக்கலாம்.

பல நவீன TypeScript திட்டங்களுக்கு, Zod அதன் சிறந்த வகை கணிப்பு, உள்ளுணர்வு API மற்றும் சக்திவாய்ந்த அம்சங்கள் காரணமாக ஒரு சிறந்த இடத்தைப் பிடிக்கிறது. இருப்பினும், மற்ற நூலகங்களின் பலத்தை புறக்கணிக்காதீர்கள்.

ரன்டைம் சரிபார்ப்புக்கான சிறந்த நடைமுறைகள்

ரன்டைம் சரிபார்ப்பை திறம்பட செயல்படுத்துவதற்கு ஒரு நூலகத்தைத் தேர்ந்தெடுப்பதை விட அதிகம் தேவைப்படுகிறது. பின்பற்ற வேண்டிய சில சிறந்த நடைமுறைகள் இங்கே:

1. விரைவாக சரிபார்க்கவும், அடிக்கடி சரிபார்க்கவும்

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

2. சரிபார்ப்பு லாஜிக்கை மையப்படுத்துதல்

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

3. விளக்கமான பிழை செய்திகளைப் பயன்படுத்தவும்

சரிபார்ப்பு பிழைகள் தகவல் அளிப்பதாக இருக்க வேண்டும். சர்வதேச பயன்பாடுகளுக்கு, பிழை செய்திகள்:

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

எடுத்துக்காட்டாக, "தவறான உள்ளீடு" என்பதற்குப் பதிலாக, "example@domain.com வடிவத்தில் சரியான மின்னஞ்சல் முகவரியை உள்ளிடவும்" என்பதைப் பயன்படுத்தவும். சர்வதேச பயனர்களுக்கு, இது அவர்களின் மொழி மற்றும் பிராந்திய மின்னஞ்சல் மரபுகளுக்கு உள்ளூர்மயமாக்கப்படலாம்.

4. உங்கள் TypeScript வகைகளுடன் பொருந்தக்கூடிய ஸ்கீமாக்களை வரையறுக்கவும்

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

5. சரிபார்ப்பு பிழைகளை மென்மையாக கையாளவும்

சரிபார்ப்பு பிழைகள் உங்கள் பயன்பாட்டை செயலிழக்க அனுமதிக்காதீர்கள். வலிமையான பிழை கையாளுதலை செயல்படுத்தவும். API இறுதிப் புள்ளிகளுக்கு, பொருத்தமான HTTP நிலை குறியீடுகளை (எ.கா., 400 Bad Request) மற்றும் பிழைகளை விவரிக்கும் கட்டமைக்கப்பட்ட JSON பதிலைத் திரும்பப் பெறுங்கள். பயனர் இடைமுகங்களுக்கு, தொடர்புடைய படிவ புலங்களுக்கு அடுத்ததாக தெளிவான பிழை செய்திகளைக் காண்பிக்கவும்.

6. வெவ்வேறு அடுக்குகளில் சரிபார்ப்பைக் கவனியுங்கள்

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

7. TypeScript-ன் வகை கணிப்பைப் பயன்படுத்தவும்

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

8. உலகளாவிய கருத்தாய்வுகள்: நேர மண்டலங்கள், நாணயங்கள் மற்றும் வடிவங்கள்

உலகளாவிய பார்வையாளர்களுக்காக உருவாக்கும்போது, சரிபார்ப்பு விதிகள் பிராந்திய வேறுபாடுகளைக் கொண்டிருக்க வேண்டும்:

• தேதிகள் மற்றும் நேரங்கள்: எதிர்பார்க்கப்படும் வடிவங்களுக்கு (எ.கா., DD/MM/YYYY vs. MM/DD/YYYY) ஏற்ப தேதிகள் மற்றும் நேரங்களை சரிபார்க்கவும் மற்றும் நேர மண்டல மாற்றங்களை சரியாகக் கையாளவும். Zod போன்ற நூலகங்களில் கட்டமைக்கக்கூடிய தேதி பார்சர்கள் உள்ளன.
• நாணயங்கள்: நாணய மதிப்புகளை சரிபார்க்கவும், குறிப்பிட்ட துல்லிய தேவைகள் அல்லது நாணய குறியீடுகளையும் சேர்க்கலாம்.
• தொலைபேசி எண்கள்: நாட்டின் குறியீடுகள் மற்றும் மாறுபட்ட வடிவங்களைக் கருத்தில் கொண்டு, சர்வதேச தொலைபேசி எண்களுக்கு வலிமையான சரிபார்ப்பைச் செயல்படுத்தவும். libphonenumber-js போன்ற நூலகங்களை சரிபார்ப்பு ஸ்கீமாக்களுடன் இணைந்து பயன்படுத்தலாம்.
• முகவரிகள்: அமைப்பு மற்றும் தேவைப்படும் புலங்களில் குறிப்பிடத்தக்க சர்வதேச வேறுபாடுகள் காரணமாக முகவரி கூறுகளை சரிபார்ப்பது சிக்கலாக இருக்கலாம்.

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

முடிவுரை

TypeScript-ன் கம்பைல்-டைம் சரிபார்ப்பு நவீன வலை உருவாக்கத்தின் ஒரு மூலக்கல்லாக இருந்தாலும், ரன்டைம் வகை சரிபார்ப்பு, குறிப்பாக உலகளாவிய சூழலில், வலிமையான, பாதுகாப்பான மற்றும் பராமரிக்கக்கூடிய பயன்பாடுகளை உருவாக்குவதற்கு சமமாக ஒரு முக்கிய அங்கமாகும். Zod, Yup, io-ts மற்றும் class-validator போன்ற சக்திவாய்ந்த நூலகங்களைப் பயன்படுத்துவதன் மூலம், தரவு ஒருமைப்பாட்டை உறுதிப்படுத்தலாம், எதிர்பாராத பிழைகளைத் தடுக்கலாம் மற்றும் உலகெங்கிலும் உள்ள பயனர்களுக்கு மிகவும் நம்பகமான அனுபவத்தை வழங்கலாம்.

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