Type ஸ்கிரிப்ட் மாஸ்டர் டேட்டா மேலாண்மை: ரெஃப்ரென்ஸ் டேட்டா வகைகளை செயல்படுத்துவதற்கான ஒரு வழிகாட்டி

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

நவீன பயன்பாடுகளில் ரெஃப்ரென்ஸ் டேட்டா மேலாண்மை ஏன் முக்கியமானது

குறியீட்டில் மூழ்குவதற்கு முன், எங்கள் முக்கிய கருத்துகளைப் பற்றிய தெளிவான புரிதலை நிறுவுவோம்.

மாஸ்டர் டேட்டா மேலாண்மை (MDM) என்பது வணிகம் மற்றும் IT ஆகியவை ஒன்றிணைந்து நிறுவனத்தின் அதிகாரப்பூர்வ பகிரப்பட்ட மாஸ்டர் டேட்டா சொத்துகளின் ஒருமைப்பாடு, துல்லியம், நிர்வாகம், சொற்பொருள் நிலைத்தன்மை மற்றும் பொறுப்புக்கூறலை உறுதி செய்வதற்காக தொழில்நுட்பத்தை இயக்கிய ஒழுக்கம் ஆகும். மாஸ்டர் தரவு என்பது வாடிக்கையாளர்கள், தயாரிப்புகள், ஊழியர்கள் மற்றும் இருப்பிடங்கள் போன்ற ஒரு வணிகத்தின் 'பெயர்களை' குறிக்கிறது.

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

• நாடுகளின் பட்டியல் (எ.கா., அமெரிக்கா, ஜெர்மனி, ஜப்பான்)
• நாணய குறியீடுகள் (USD, EUR, JPY)
• ஆர்டர் நிலைகள் (நிலுவையில், செயலாக்கம், அனுப்பப்பட்டது, வழங்கப்பட்டது, ரத்து செய்யப்பட்டது)
• பயனர் பாத்திரங்கள் (நிர்வாகி, ஆசிரியர், பார்வையாளர்)
• தயாரிப்பு வகைகள் (எலக்ட்ரானிக்ஸ், ஆடை, புத்தகங்கள்)

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

முக்கிய பிரச்சினை: "மேஜிக் ஸ்ட்ரிங்ஸின்" ஆபத்துகள்

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

            
function processOrder(orderId: number, newStatus: string) {
  if (newStatus === 'shipped') {
    // Logic for shipping
    console.log(`Order ${orderId} has been shipped.`);
  } else if (newStatus === 'delivered') {
    // Logic for delivery confirmation
    console.log(`Order ${orderId} confirmed as delivered.`);
  } else if (newStatus === 'pending') {
    // ...and so on
  }
}

// Somewhere else in the application...
processOrder(12345, 'Shipped'); // Uh oh, a typo!

            

              
                Copy
              
            
          

இந்த அணுகுமுறை, பெரும்பாலும் "மேஜிக் ஸ்ட்ரிங்ஸ்" என்று அழைக்கப்படுவதை நம்பியிருப்பது, ஆபத்து நிறைந்தது:

• எழுத்துப்பிழை பிழைகள்: மேலே காணப்படுவது போல், `shipped` vs. `Shipped` கண்டறிய கடினமான நுட்பமான பிழைகளை ஏற்படுத்தும். கம்பைலர் எந்த உதவியும் வழங்காது.
• கண்டுபிடிக்க முடியவில்லை: ஒரு புதிய டெவலப்பருக்கு சரியான நிலைகள் என்ன என்பதை அறிய எளிதான வழி இல்லை. சாத்தியமான அனைத்து சரம் மதிப்புகளையும் கண்டுபிடிக்க அவர்கள் முழு குறியீட்டு தளத்தையும் தேட வேண்டும்.
• பராமரிப்பு கெட்ட கனவு: வணிகம் 'shipped' ஐ 'dispatched' என மாற்ற முடிவு செய்தால் என்ன செய்வது? எந்த நிகழ்வுகளையும் நீங்கள் தவறவிடாதீர்கள் அல்லது தற்செயலாக தொடர்பில்லாத ஒன்றை மாற்றாமல், ஆபத்தான, திட்டம் தழுவிய தேடல் மற்றும் மாற்றத்தை நீங்கள் செய்ய வேண்டும்.
• உண்மையின் ஒரே ஆதாரம் இல்லை: சரியான மதிப்புகள் பயன்பாடு முழுவதும் சிதறிக்கிடக்கின்றன, இது முன்முனை, பின்தளம் மற்றும் தரவுத்தளம் ஆகியவற்றுக்கு இடையே சாத்தியமான முரண்பாடுகளுக்கு வழிவகுக்கிறது.

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

ரெஃப்ரென்ஸ் தரவிற்கான அடிப்படை TypeScript வடிவங்கள்

ரெஃப்ரென்ஸ் தரவை நிர்வகிப்பதற்கு TypeScript பல சிறந்த வடிவங்களை வழங்குகிறது, ஒவ்வொன்றும் அதன் சொந்த வர்த்தகங்களுடன். கிளாசிக் முதல் நவீன சிறந்த நடைமுறை வரை மிகவும் பொதுவானவற்றை ஆராய்வோம்.

அணுகுமுறை 1: கிளாசிக் `enum`

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

            
export enum OrderStatus {
  Pending = 'PENDING',
  Processing = 'PROCESSING',
  Shipped = 'SHIPPED',
  Delivered = 'DELIVERED',
  Cancelled = 'CANCELLED',
}

function processOrder(orderId: number, newStatus: OrderStatus) {
  if (newStatus === OrderStatus.Shipped) {
    console.log(`Order ${orderId} has been shipped.`);
  }
}

processOrder(123, OrderStatus.Shipped); // Correct and type-safe
// processOrder(123, 'SHIPPED'); // Compile-time error! Great!

            

              
                Copy
              
            
          

நன்மை:

• தெளிவான நோக்கம்: இது தொடர்பான மாறிலிகளின் தொகுப்பை நீங்கள் வரையறுக்கிறீர்கள் என்று இது வெளிப்படையாகக் கூறுகிறது. `OrderStatus` என்ற பெயர் மிகவும் விளக்கமானது.
• பெயரளவு தட்டச்சு செய்தல்: `OrderStatus.Shipped` என்பது 'SHIPPED' என்ற சரம் மட்டுமல்ல; இது `OrderStatus` வகையைச் சேர்ந்தது. இது சில சூழ்நிலைகளில் வலுவான வகை சரிபார்ப்பை வழங்க முடியும்.
• படிக்கும் திறன்: `OrderStatus.Shipped` என்பது ஒரு மூல சரத்தை விட படிக்கக்கூடியதாக கருதப்படுகிறது.

பாதகம்:

• JavaScript தடம்: TypeScript எண்ணங்கள் ஒரு கம்பைல் நேர கட்டுமானம் மட்டுமல்ல. அவை தொகுக்கப்பட்ட வெளியீட்டில் ஒரு JavaScript பொருளை (உடனடியாக அழைக்கப்படும் செயல்பாடு வெளிப்பாடு அல்லது IIFE) உருவாக்குகின்றன, இது உங்கள் மூட்டை அளவை அதிகரிக்கிறது.
• எண் எண்ணங்களுடன் சிக்கலானது: இங்கே சரம் எண்ணங்களைப் பயன்படுத்தியிருந்தாலும் (இது பரிந்துரைக்கப்பட்ட நடைமுறை), TypeScript இல் உள்ள இயல்புநிலை எண் எண்ணங்கள் குழப்பமான தலைகீழ்-மேப்பிங் நடத்தையைக் கொண்டிருக்கலாம்.
• குறைந்த நெகிழ்வானது: கூடுதல் வேலை இல்லாமல் எண்ணங்களிலிருந்து யூனியன் வகைகளை உருவாக்குவது அல்லது அவற்றை மிகவும் சிக்கலான தரவு கட்டமைப்புகளுக்குப் பயன்படுத்துவது கடினம்.

அணுகுமுறை 2: இலகுரக சரம் லிட்டரல் யூனியன்கள்

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

            
export type OrderStatus =
  | 'PENDING'
  | 'PROCESSING'
  | 'SHIPPED'
  | 'DELIVERED'
  | 'CANCELLED';

function processOrder(orderId: number, newStatus: OrderStatus) {
  if (newStatus === 'SHIPPED') {
    console.log(`Order ${orderId} has been shipped.`);
  }
}

processOrder(123, 'SHIPPED'); // Correct and type-safe
// processOrder(123, 'shipped'); // Compile-time error! Awesome!

            

              
                Copy
              
            
          

நன்மை:

• பூஜ்ஜிய JavaScript தடம்: `வகை` வரையறைகள் தொகுப்பின் போது முற்றிலும் அழிக்கப்படுகின்றன. அவை TypeScript கம்பைலருக்கு மட்டுமே உள்ளன, இதன் விளைவாக சுத்தமான, சிறிய JavaScript கிடைக்கும்.
• எளிமை: தொடரியல் நேரடியானது மற்றும் புரிந்துகொள்ள எளிதானது.
• சிறந்த தானியங்கு நிறைவு: இந்த வகையின் மாறிகளுக்கு குறியீடு ஆசிரியர்கள் சிறந்த தானியங்கு நிறைவை வழங்குகிறார்கள்.

பாதகம்:

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

            
// Duplication of values
export type OrderStatus = 'PENDING' | 'PROCESSING' | 'SHIPPED';

export const ALL_ORDER_STATUSES = ['PENDING', 'PROCESSING', 'SHIPPED'];

            

              
                Copy
              
            
          

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

அணுகுமுறை 3: `const` Assertion Power Play (தி கோல்ட் ஸ்டாண்டர்ட்)

TypeScript 3.4 இல் அறிமுகப்படுத்தப்பட்ட `as const` உறுதியானது, சரியான தீர்வை வழங்குகிறது. இது இரண்டு உலகின் சிறந்த கலவையை ஒருங்கிணைக்கிறது: இயக்க நேரத்தில் இருக்கும் உண்மையின் ஒற்றை ஆதாரம் மற்றும் கம்பைல் நேரத்தில் இருக்கும் ஒரு பெறப்பட்ட, சரியாக தட்டச்சு செய்யப்பட்ட யூனியன்.

இங்கே முறை உள்ளது:

            
// 1. Define the runtime data with 'as const'
export const ORDER_STATUSES = [
  'PENDING',
  'PROCESSING',
  'SHIPPED',
  'DELIVERED',
  'CANCELLED',
] as const;

// 2. Derive the type from the runtime data
export type OrderStatus = typeof ORDER_STATUSES[number];
//   ^? type OrderStatus = "PENDING" | "PROCESSING" | "SHIPPED" | "DELIVERED" | "CANCELLED"

// 3. Use it in your functions
function processOrder(orderId: number, newStatus: OrderStatus) {
  if (newStatus === 'SHIPPED') {
    console.log(`Order ${orderId} has been shipped.`);
  }
}

// 4. Use it at runtime AND compile time
processOrder(123, 'SHIPPED'); // Type-safe!

// And you can easily iterate over it for UIs!
function getStatusOptions() {
  return ORDER_STATUSES.map(status => ({ value: status, label: status.toLowerCase() }));
}

            

              
                Copy
              
            
          

இது ஏன் மிகவும் சக்தி வாய்ந்தது என்பதை உடைப்போம்:

• `as const` சாத்தியமான மிக குறிப்பிட்ட வகையை ஊகிக்க TypeScript ஐக் கூறுகிறது. `string[]` என்பதற்கு பதிலாக, இது `readonly ['PENDING', 'PROCESSING', ...]` என வகையை ஊகிக்கிறது. `readonly` மாற்றி வரிசையின் தற்செயலான மாற்றத்தைத் தடுக்கிறது.
• `typeof ORDER_STATUSES[number]` வகையை உருவாக்கும் மந்திரம். இது கூறுகிறது, "`ORDER_STATUSES` வரிசைக்குள் உள்ள உறுப்புகளின் வகையை எனக்குக் கொடுங்கள்." குறிப்பிட்ட சரம் லிட்டரல்களைப் பார்க்கவும், அவற்றிலிருந்து யூனியன் வகையை உருவாக்கவும் TypeScript போதுமான அளவு புத்திசாலித்தனமானது.
• உண்மையின் ஒற்றை ஆதாரம் (SSOT): `ORDER_STATUSES` வரிசை என்பது இந்த மதிப்புகள் வரையறுக்கப்பட்டுள்ள ஒரே இடம். வகை தானாகவே அதிலிருந்து பெறப்பட்டது. நீங்கள் வரிசையில் ஒரு புதிய நிலையைச் சேர்த்தால், `OrderStatus` வகை தானாகவே புதுப்பிக்கப்படும். வகை மற்றும் இயக்க நேர மதிப்புகள் ஒத்திசைவில் இல்லாத எந்தவொரு சாத்தியத்தையும் இது நீக்குகிறது.

TypeScript இல் எளிய ரெஃப்ரென்ஸ் தரவைக் கையாளுவதற்கான நவீன, மரபுவழி மற்றும் வலுவான வழி இந்த முறை.

மேம்பட்ட செயல்படுத்தல்: சிக்கலான ரெஃப்ரென்ஸ் தரவை கட்டமைத்தல்

ரெஃப்ரென்ஸ் தரவு பெரும்பாலும் சரங்களின் எளிய பட்டியலை விட சிக்கலானது. ஷிப்பிங் படிவத்திற்கான நாடுகளின் பட்டியலை நிர்வகிப்பதை கவனியுங்கள். ஒவ்வொரு நாட்டிற்கும் ஒரு பெயர், இரண்டு எழுத்து ISO குறியீடு மற்றும் டயலிங் குறியீடு உள்ளது. இந்த விஷயத்தில் `as const` முறை அழகாக அளவிடப்படுகிறது.

தரவு சேகரிப்பை வரையறுத்தல் மற்றும் சேமித்தல்

முதலில், எங்கள் உண்மையின் ஒற்றை மூலத்தை உருவாக்குகிறோம்: பொருட்களின் வரிசை. முழு கட்டமைப்பையும் ஆழமாக படிக்க மட்டும் செய்ய மற்றும் துல்லியமான வகை அனுமானத்தை அனுமதிக்க நாங்கள் `as const` ஐப் பயன்படுத்துகிறோம்.

            
export const COUNTRIES = [
  {
    code: 'US',
    name: 'United States of America',
    dial: '+1',
    continent: 'North America',
  },
  {
    code: 'DE',
    name: 'Germany',
    dial: '+49',
    continent: 'Europe',
  },
  {
    code: 'IN',
    name: 'India',
    dial: '+91',
    continent: 'Asia',
  },
  {
    code: 'BR',
    name: 'Brazil',
    dial: '+55',
    continent: 'South America',
  },
] as const;

            

              
                Copy
              
            
          

சேகரிப்பிலிருந்து துல்லியமான வகைகளை உருவாக்குதல்

இப்போது, இந்த தரவு கட்டமைப்பிலிருந்து நேரடியாக மிகவும் பயனுள்ள மற்றும் குறிப்பிட்ட வகைகளை உருவாக்கலாம்.

            
// Derive the type for a single country object
export type Country = typeof COUNTRIES[number];
/*
  ^? type Country = {
      readonly code: "US";
      readonly name: "United States of America";
      readonly dial: "+1";
      readonly continent: "North America";
  } | {
      readonly code: "DE";
      ...
  }
*/

// Derive a union type of all valid country codes
export type CountryCode = Country['code']; // or `typeof COUNTRIES[number]['code']`
//   ^? type CountryCode = "US" | "DE" | "IN" | "BR"

// Derive a union type of all continents
export type Continent = Country['continent'];
//   ^? type Continent = "North America" | "Europe" | "Asia" | "South America"

            

              
                Copy
              
            
          

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

1. ஒரு நாட்டின் பொருளின் வடிவத்தை குறிக்கும் ஒரு `Country` வகை.
2. ஒரு `CountryCode` வகை எந்தவொரு மாறி அல்லது செயல்பாடு அளவுருவும் சரியான, இருக்கும் நாட்டு குறியீடுகளில் ஒன்றாக மட்டுமே இருக்க முடியும் என்பதை உறுதி செய்கிறது.
3. நாடுகளை வகைப்படுத்த ஒரு `Continent` வகை.

நீங்கள் `COUNTRIES` வரிசையில் ஒரு புதிய நாட்டைச் சேர்த்தால், இந்த அனைத்து வகைகளும் தானாகவே புதுப்பிக்கப்படும். இது கம்பைலரால் செயல்படுத்தப்படும் தரவு ஒருமைப்பாடு ஆகும்.

மையப்படுத்தப்பட்ட ரெஃப்ரென்ஸ் டேட்டா சேவையை உருவாக்குதல்

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

தொகுதி அடிப்படையிலான அணுகுமுறை

பெரும்பாலான பயன்பாடுகளுக்கு, தரவு மற்றும் சில பயன்பாட்டு செயல்பாடுகளை ஏற்றுமதி செய்யும் ஒரு எளிய தொகுதி போதுமானது மற்றும் நேர்த்தியானது.

            
// file: src/services/referenceData.ts

// ... (our COUNTRIES constant and derived types from above)

export const getCountries = () => COUNTRIES;

export const getCountryByCode = (code: CountryCode): Country | undefined => {
  // The 'find' method is perfectly type-safe here
  return COUNTRIES.find(country => country.code === code);
};

export const getCountriesByContinent = (continent: Continent): Country[] => {
  return COUNTRIES.filter(country => country.continent === continent);
};

// You can also export the raw data and types if needed
export { COUNTRIES, Country, CountryCode, Continent };

            

              
                Copy
              
            
          

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

ஒத்திசைவற்ற முறையில் ஏற்றப்பட்ட ரெஃப்ரென்ஸ் தரவைக் கையாளுதல்

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

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

            
import { z } from 'zod';

// 1. Define the schema for a single country using Zod
const CountrySchema = z.object({
  code: z.string().length(2),
  name: z.string(),
  dial: z.string(),
  continent: z.string(),
});

// 2. Define the schema for the API response (an array of countries)
const CountriesApiResponseSchema = z.array(CountrySchema);

// 3. Infer the TypeScript type from the Zod schema
export type Country = z.infer;

// We can still get a code type, but it will be 'string' since we don't know the values ahead of time.
// If the list is small and fixed, you can use z.enum(['US', 'DE', ...]) for more specific types.
export type CountryCode = Country['code'];

// 4. A service to fetch and cache the data
class ReferenceDataService {
  private countries: Country[] | null = null;

  async fetchAndCacheCountries(): Promise {
    if (this.countries) {
      return this.countries;
    }

    const response = await fetch('/api/v1/countries');
    const jsonData = await response.json();

    // Runtime validation!
    const validationResult = CountriesApiResponseSchema.safeParse(jsonData);

    if (!validationResult.success) {
      console.error('Invalid country data from API:', validationResult.error);
      throw new Error('Failed to load reference data.');
    }

    this.countries = validationResult.data;
    return this.countries;
  }
}

export const referenceDataService = new ReferenceDataService();

            

              
                Copy
              
            
          

இந்த அணுகுமுறை மிகவும் வலுவானது. இது ஊகிக்கப்பட்ட TypeScript வகைகள் மூலம் கம்பைல் நேர பாதுகாப்பை வழங்குகிறது மற்றும் வெளிப்புற மூலத்திலிருந்து வரும் தரவு எதிர்பார்க்கப்பட்ட வடிவத்துடன் பொருந்துகிறது என்பதை சரிபார்ப்பதன் மூலம் இயக்க நேர பாதுகாப்பை வழங்குகிறது. தேவைப்படும்போது தரவு கிடைக்கும் என்பதை உறுதிப்படுத்த பயன்பாடு துவக்கத்தில் `referenceDataService.fetchAndCacheCountries()` ஐ அழைக்கலாம்.

உங்கள் பயன்பாட்டில் ரெஃப்ரென்ஸ் தரவை ஒருங்கிணைத்தல்

ஒரு திடமான அடித்தளத்துடன், இந்த வகை-பாதுகாப்பான ரெஃப்ரென்ஸ் தரவை உங்கள் பயன்பாடு முழுவதும் பயன்படுத்துவது நேரடியானது மற்றும் நேர்த்தியானது.

UI கூறுகளில் (எ.கா., எதிர்வினை)

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

            
import React from 'react';
import { COUNTRIES, CountryCode } from '../services/referenceData';

interface CountrySelectorProps {
  selectedValue: CountryCode | null;
  onChange: (newCode: CountryCode) => void;
}

export const CountrySelector: React.FC = ({ selectedValue, onChange }) => {
  return (
     onChange(e.target.value as CountryCode)}
    >
      Select a country
      {COUNTRIES.map((country) => (
        
          {country.name} ({country.code})
        
      ))}
    
  );
};

            

              
                Copy
              
            
          

இங்கே, `selectedValue` சரியான `CountryCode` ஆக இருக்க வேண்டும் என்பதையும், `onChange` கால்பேக் எப்போதும் சரியான `CountryCode` ஐப் பெறும் என்பதையும் TypeScript உறுதி செய்கிறது.

வணிக தர்க்கம் மற்றும் API அடுக்குகளில்

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

            
import { OrderStatus } from '../services/referenceData';

interface Order {
  id: string;
  status: OrderStatus;
  items: any[];
}

// This function can only be called with a valid status.
function canCancelOrder(order: Order): boolean {
  // No need to check for typos like 'pendng' or 'Procesing'
  return order.status === 'PENDING' || order.status === 'PROCESSING';
}

const myOrder: Order = { id: 'xyz', status: 'SHIPPED', items: [] };

if (canCancelOrder(myOrder)) {
  // This block is correctly (and safely) not executed.
}

            

              
                Copy
              
            
          

சர்வதேசமயமாக்கலுக்கு (i18n)

ரெஃப்ரென்ஸ் தரவு பெரும்பாலும் சர்வதேசமயமாக்கலின் முக்கிய அங்கமாகும். மொழிபெயர்ப்பு விசைகளைச் சேர்க்க எங்கள் தரவு மாதிரியை விரிவாக்கலாம்.

            
export const ORDER_STATUSES = [
  { code: 'PENDING', i18nKey: 'orderStatus.pending' },
  { code: 'PROCESSING', i18nKey: 'orderStatus.processing' },
  { code: 'SHIPPED', i18nKey: 'orderStatus.shipped' },
] as const;

export type OrderStatusCode = typeof ORDER_STATUSES[number]['code'];

            

              
                Copy
              
            
          

ஒரு UI கூறு பின்னர் பயனரின் தற்போதைய லோகேலுக்கு மொழிபெயர்க்கப்பட்ட சரத்தைத் தேட `i18nKey` ஐப் பயன்படுத்தலாம், அதே நேரத்தில் வணிக தர்க்கம் நிலையான, மாறாத `code` இல் தொடர்ந்து இயங்குகிறது.

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

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

• உண்மையின் ஒற்றை ஆதாரம் (SSOT): இது மிக முக்கியமான கொள்கை. அனைத்து ரெஃப்ரென்ஸ் தரவும் ஒருவரால் மற்றும் ஒரே ஒரு அதிகாரப்பூர்வ மூலத்திலிருந்து உருவாக வேண்டும். ஒரு முன்முனை பயன்பாட்டிற்கு, இது ஒரு ஒற்றை தொகுதி அல்லது சேவையாக இருக்கலாம். ஒரு பெரிய நிறுவனத்தில், இது பெரும்பாலும் ஒரு பிரத்யேக MDM அமைப்பு ஆகும், இதன் தரவு ஒரு API மூலம் வெளிப்படுத்தப்படுகிறது.
• தெளிவான உரிமை: ரெஃப்ரென்ஸ் தரவின் துல்லியம் மற்றும் ஒருமைப்பாட்டைப் பராமரிப்பதற்கு பொறுப்பான ஒரு குழு அல்லது தனிநபரை நியமிக்கவும். மாற்றங்கள் வேண்டுமென்றே மற்றும் நன்கு ஆவணப்படுத்தப்பட வேண்டும்.
• பதிப்பு கட்டுப்பாடு: ஒரு API இலிருந்து ரெஃப்ரென்ஸ் தரவு ஏற்றப்படும்போது, உங்கள் API எண்ட்பாயிண்ட்களை பதிவேற்றவும். தரவு கட்டமைப்பில் உள்ள முறிக்கும் மாற்றங்கள் பழைய வாடிக்கையாளர்களைப் பாதிப்பதிலிருந்து இது தடுக்கிறது.
• ஆவணமாக்கல்: ஒவ்வொரு ரெஃப்ரென்ஸ் தரவு தொகுப்பின் அர்த்தத்தையும் பயன்பாட்டையும் விளக்க JSDoc அல்லது பிற ஆவணமாக்கல் கருவிகளைப் பயன்படுத்தவும். எடுத்துக்காட்டாக, ஒவ்வொரு `OrderStatus` க்குப் பின்னாலும் உள்ள வணிக விதிகளை ஆவணப்படுத்தவும்.
• குறியீடு உருவாக்கலைக் கவனியுங்கள்: பின்தளம் மற்றும் முன்முனைக்கு இடையே இறுதி ஒத்திசைவுக்கு, உங்கள் பின்தள API விவரக்குறிப்பிலிருந்து (எ.கா., OpenAPI/Swagger) TypeScript வகைகளை நேரடியாக உருவாக்கும் கருவிகளைப் பயன்படுத்துவதைக் கவனியுங்கள். கிளையன்ட்-பக்க வகைகளை API இன் தரவு கட்டமைப்புகளுடன் ஒத்திசைவாக வைத்திருக்கும் செயல்முறையை இது தானியக்கமாக்குகிறது.

முடிவு: TypeScript உடன் தரவு ஒருமைப்பாட்டை உயர்த்துதல்

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

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

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