ટેમ્પલેટ લિટરલ ટાઇપ્સ: ટાઇપસ્ક્રીપ્ટમાં સ્ટ્રિંગ પેટર્ન મેચિંગ અને વેલિડેશન

ટાઇપસ્ક્રીપ્ટની ટાઇપ સિસ્ટમ સતત વિકસિત થઈ રહી છે, જે વિકાસકર્તાઓને જટિલ લોજિક વ્યક્ત કરવા અને ટાઇપ સલામતી સુનિશ્ચિત કરવા માટે વધુ શક્તિશાળી સાધનો પ્રદાન કરે છે. તાજેતરના સંસ્કરણોમાં રજૂ કરાયેલી સૌથી રસપ્રદ અને સર્વતોમુખી સુવિધાઓમાંની એક ટેમ્પલેટ લિટરલ ટાઇપ્સ છે. આ ટાઇપ્સ તમને ટાઇપ લેવલ પર સ્ટ્રિંગ્સને મેનીપ્યુલેટ કરવાની મંજૂરી આપે છે, અદ્યતન સ્ટ્રિંગ પેટર્ન મેચિંગ અને વેલિડેશનને સક્ષમ કરે છે. આ વધુ મજબૂત અને જાળવણી યોગ્ય એપ્લિકેશન્સ બનાવવા માટે શક્યતાઓની એક નવી દુનિયા ખોલે છે.

ટેમ્પલેટ લિટરલ ટાઇપ્સ શું છે?

ટેમ્પલેટ લિટરલ ટાઇપ્સ એ એક પ્રકારનો ટાઇપ છે જે સ્ટ્રિંગ લિટરલ ટાઇપ્સ અને યુનિયન ટાઇપ્સને જોડીને બનાવવામાં આવે છે, જે રીતે જાવાસ્ક્રિપ્ટમાં ટેમ્પલેટ લિટરલ્સ કાર્ય કરે છે. જો કે, રનટાઇમ સ્ટ્રિંગ્સ બનાવવાને બદલે, તેઓ હાલના લોકોના આધારે નવી ટાઇપ્સ બનાવે છે.

અહીં એક મૂળભૂત ઉદાહરણ છે:

            type Greeting<T extends string> = `Hello, ${T}!`;

type MyGreeting = Greeting<"World">; // type MyGreeting = "Hello, World!"

            

              
                Copy
              
            
          

આ ઉદાહરણમાં, `Greeting` એ એક ટેમ્પલેટ લિટરલ ટાઇપ છે જે સ્ટ્રિંગ ટાઇપ `T` ને ઇનપુટ તરીકે લે છે અને એક નવી ટાઇપ પરત કરે છે જે "Hello, ", `T`, અને "!" નું જોડાણ છે.

મૂળભૂત સ્ટ્રિંગ પેટર્ન મેચિંગ

ટેમ્પલેટ લિટરલ ટાઇપ્સનો ઉપયોગ મૂળભૂત સ્ટ્રિંગ પેટર્ન મેચિંગ કરવા માટે થઈ શકે છે. આ તમને એવી ટાઇપ્સ બનાવવા માટે પરવાનગી આપે છે જે અમુક પેટર્ન સાથે મેળ ખાતી હોય તો જ માન્ય હોય.

ઉદાહરણ તરીકે, તમે એક ટાઇપ બનાવી શકો છો જે ફક્ત "prefix-" થી શરૂ થતી સ્ટ્રિંગ્સને સ્વીકારે છે:

            type PrefixedString<T extends string> = T extends `prefix-${string}` ? T : never;

type ValidPrefixedString = PrefixedString<"prefix-valid">; // type ValidPrefixedString = "prefix-valid"
type InvalidPrefixedString = PrefixedString<"invalid">; // type InvalidPrefixedString = never

            

              
                Copy
              
            
          

આ ઉદાહરણમાં, `PrefixedString` એ ચકાસવા માટે કન્ડિશનલ ટાઇપનો ઉપયોગ કરે છે કે શું ઇનપુટ સ્ટ્રિંગ `T` "prefix-" થી શરૂ થાય છે. જો તે કરે છે, તો ટાઇપ `T` પોતે જ છે; અન્યથા, તે `never` છે. `never` એ ટાઇપસ્ક્રીપ્ટમાં એક વિશેષ ટાઇપ છે જે ક્યારેય ન બનતા મૂલ્યોના ટાઇપનું પ્રતિનિધિત્વ કરે છે, અસરકારક રીતે અમાન્ય સ્ટ્રિંગને બાકાત રાખે છે.

સ્ટ્રિંગના ભાગો કાઢવા

ટેમ્પલેટ લિટરલ ટાઇપ્સનો ઉપયોગ સ્ટ્રિંગના ભાગો કાઢવા માટે પણ થઈ શકે છે. જ્યારે તમારે સ્ટ્રિંગ્સમાંથી ડેટાને પાર્સ કરવાની અને તેને વિવિધ ટાઇપ્સમાં રૂપાંતરિત કરવાની જરૂર હોય ત્યારે આ ખાસ કરીને ઉપયોગી છે.

ચાલો કહીએ કે તમારી પાસે એક સ્ટ્રિંગ છે જે "x:10,y:20" ફોર્મેટમાં કોઓર્ડિનેટનું પ્રતિનિધિત્વ કરે છે. તમે x અને y વેલ્યુ કાઢવા માટે ટેમ્પલેટ લિટરલ ટાઇપ્સનો ઉપયોગ કરી શકો છો:

            type CoordinateString = `x:${number},y:${number}`;

type ExtractX<T extends CoordinateString> = T extends `x:${infer X},y:${number}` ? X : never;
type ExtractY<T extends CoordinateString> = T extends `x:${number},y:${infer Y}` ? Y : never;

type XValue = ExtractX<"x:10,y:20">; // type XValue = 10
type YValue = ExtractY<"x:10,y:20">; // type YValue = 20

            

              
                Copy
              
            
          

આ ઉદાહરણમાં, `ExtractX` અને `ExtractY` એ સ્ટ્રિંગના ભાગોને કેપ્ચર કરવા માટે `infer` કીવર્ડનો ઉપયોગ કરે છે જે `number` ટાઇપ સાથે મેળ ખાય છે. `infer` તમને પેટર્ન મેચમાંથી ટાઇપ કાઢવાની મંજૂરી આપે છે. કેપ્ચર કરેલ ટાઇપ્સનો ઉપયોગ પછી કન્ડિશનલ ટાઇપના રિટર્ન ટાઇપ તરીકે થાય છે.

અદ્યતન સ્ટ્રિંગ વેલિડેશન

અદ્યતન સ્ટ્રિંગ વેલિડેશન કરવા માટે ટેમ્પલેટ લિટરલ ટાઇપ્સને અન્ય ટાઇપસ્ક્રીપ્ટ સુવિધાઓ સાથે જોડી શકાય છે, જેમ કે યુનિયન ટાઇપ્સ અને કન્ડિશનલ ટાઇપ્સ. આ તમને એવી ટાઇપ્સ બનાવવા માટે પરવાનગી આપે છે જે સ્ટ્રિંગ્સની રચના અને સામગ્રી પર જટિલ નિયમો લાગુ કરે છે.

ઉદાહરણ તરીકે, તમે એક ટાઇપ બનાવી શકો છો જે ISO 8601 તારીખ સ્ટ્રિંગ્સને માન્ય કરે છે:

            type Year = `${number}${number}${number}${number}`;
type Month = `0${number}` | `10` | `11` | `12`;
type Day = `${0}${number}` | `${1 | 2}${number}` | `30` | `31`;

type ISODate = `${Year}-${Month}-${Day}`;

type ValidDate = ISODate extends "2023-10-27" ? true : false; // true
type InvalidDate = ISODate extends "2023-13-27" ? true : false; // false

function processDate(date: ISODate) {
  // Function logic here.  TypeScript enforces the ISODate format.
  return `Processing date: ${date}`;
}

console.log(processDate("2024-01-15")); // Works
//console.log(processDate("2024-1-15")); // TypeScript error: Argument of type '"2024-1-15"' is not assignable to parameter of type '`${number}${number}${number}${number}-${0}${number}-${0}${number}` | `${number}${number}${number}${number}-${0}${number}-${1}${number}` | ... 14 more ... | `${number}${number}${number}${number}-12-31`'.

            

              
                Copy
              
            
          

અહીં, `Year`, `Month`, અને `Day` ને તારીખના દરેક ભાગ માટે માન્ય ફોર્મેટ્સનું પ્રતિનિધિત્વ કરવા માટે ટેમ્પલેટ લિટરલ ટાઇપ્સનો ઉપયોગ કરીને વ્યાખ્યાયિત કરવામાં આવ્યા છે. `ISODate` પછી આ ટાઇપ્સને જોડીને એક ટાઇપ બનાવે છે જે માન્ય ISO 8601 તારીખ સ્ટ્રિંગનું પ્રતિનિધિત્વ કરે છે. ઉદાહરણ એ પણ દર્શાવે છે કે આ ટાઇપનો ઉપયોગ ફંક્શનમાં ડેટા ફોર્મેટિંગને લાગુ કરવા માટે કેવી રીતે કરી શકાય છે, ખોટી તારીખ ફોર્મેટ્સને પસાર થવાથી અટકાવે છે. આ કોડની વિશ્વસનીયતામાં સુધારો કરે છે અને અમાન્ય ઇનપુટને કારણે થતી રનટાઇમ ભૂલોને અટકાવે છે.

વાસ્તવિક દુનિયાના ઉપયોગના કેસો

ટેમ્પલેટ લિટરલ ટાઇપ્સનો ઉપયોગ વિવિધ વાસ્તવિક દુનિયાના દૃશ્યોમાં થઈ શકે છે. અહીં કેટલાક ઉદાહરણો છે:

• ફોર્મ વેલિડેશન: તમે ફોર્મ ઇનપુટ્સના ફોર્મેટને માન્ય કરવા માટે ટેમ્પલેટ લિટરલ ટાઇપ્સનો ઉપયોગ કરી શકો છો, જેમ કે ઇમેઇલ સરનામાં, ફોન નંબર્સ અને પોસ્ટલ કોડ્સ.
• API વિનંતી વેલિડેશન: તમે API વિનંતી પેલોડ્સની રચનાને માન્ય કરવા માટે ટેમ્પલેટ લિટરલ ટાઇપ્સનો ઉપયોગ કરી શકો છો, તેની ખાતરી કરીને કે તેઓ અપેક્ષિત ફોર્મેટને અનુરૂપ છે. ઉદાહરણ તરીકે, ચલણ કોડને માન્ય કરવું (દા.ત., "USD", "EUR", "GBP").
• રૂપરેખાંકન ફાઇલ પાર્સિંગ: તમે રૂપરેખાંકન ફાઇલોને પાર્સ કરવા અને ચોક્કસ પેટર્નના આધારે મૂલ્યો કાઢવા માટે ટેમ્પલેટ લિટરલ ટાઇપ્સનો ઉપયોગ કરી શકો છો. રૂપરેખાંકન ઑબ્જેક્ટમાં ફાઇલ પાથને માન્ય કરવાનું વિચારો.
• સ્ટ્રિંગ-આધારિત એનમ્સ: તમે ટેમ્પલેટ લિટરલ ટાઇપ્સનો ઉપયોગ કરીને વેલિડેશન સાથે સ્ટ્રિંગ-આધારિત એનમ્સ બનાવી શકો છો.

ઉદાહરણ: ચલણ કોડ્સને માન્ય કરવું

ચાલો ચલણ કોડ્સને માન્ય કરવાના વધુ વિગતવાર ઉદાહરણ પર એક નજર કરીએ. અમે એ સુનિશ્ચિત કરવા માંગીએ છીએ કે અમારી એપ્લિકેશનમાં ફક્ત માન્ય ISO 4217 ચલણ કોડ્સનો ઉપયોગ થાય છે. આ કોડ્સ સામાન્ય રીતે ત્રણ અપરકેસ અક્ષરો હોય છે.

            type CurrencyCode = `${Uppercase<string>}${Uppercase<string>}${Uppercase<string>}`;

function formatCurrency(amount: number, currency: CurrencyCode) {
  // Function logic to format currency based on the provided code.
  return `$${amount} ${currency}`;
}

console.log(formatCurrency(100, "USD")); // Works
//console.log(formatCurrency(100, "usd")); // TypeScript error: Argument of type '"usd"' is not assignable to parameter of type '`${Uppercase}${Uppercase}${Uppercase}`'.

//More precise example:
type ValidCurrencyCode = "USD" | "EUR" | "GBP" | "JPY" | "CAD" | "AUD"; // Extend as needed

type StronglyTypedCurrencyCode = ValidCurrencyCode;

function formatCurrencyStronglyTyped(amount: number, currency: StronglyTypedCurrencyCode) {
    return `$${amount} ${currency}`;
}

console.log(formatCurrencyStronglyTyped(100, "EUR")); // Works
//console.log(formatCurrencyStronglyTyped(100, "CNY")); // TypeScript error: Argument of type '"CNY"' is not assignable to parameter of type '"USD" | "EUR" | "GBP" | "JPY" | "CAD" | "AUD"'.

            

              
                Copy
              
            
          

આ ઉદાહરણ દર્શાવે છે કે `CurrencyCode` ટાઇપ કેવી રીતે બનાવવી જે ફક્ત ત્રણ અપરકેસ અક્ષરોથી બનેલી સ્ટ્રિંગ્સને સ્વીકારે છે. બીજું, વધુ મજબૂત રીતે ટાઇપ કરેલું ઉદાહરણ બતાવે છે કે આને સ્વીકાર્ય કરન્સીની પૂર્વવ્યાખ્યાયિત સૂચિમાં કેવી રીતે વધુ મર્યાદિત કરવું.

ઉદાહરણ: API એન્ડપોઇન્ટ પાથને માન્ય કરવું

બીજો ઉપયોગનો કેસ એ API એન્ડપોઇન્ટ પાથને માન્ય કરવાનો છે. તમે એક ટાઇપ વ્યાખ્યાયિત કરી શકો છો જે માન્ય API એન્ડપોઇન્ટ સ્ટ્રક્ચરનું પ્રતિનિધિત્વ કરે છે, એ સુનિશ્ચિત કરે છે કે વિનંતીઓ યોગ્ય પાથ પર કરવામાં આવી છે. આ ખાસ કરીને માઇક્રોસર્વિસ આર્કિટેક્ચરમાં ઉપયોગી છે જ્યાં બહુવિધ સેવાઓ વિવિધ APIs ને જાહેર કરી શકે છે.

            type APIServiceName = "users" | "products" | "orders";
type APIEndpointPath = `/${APIServiceName}/${string}`;

function callAPI(path: APIEndpointPath) {
  // API call logic
  console.log(`Calling API: ${path}`);
}

callAPI("/users/123"); // Valid
callAPI("/products/details"); // Valid
//callAPI("/invalid/path"); // TypeScript error

// Even more specific:
type APIAction = "create" | "read" | "update" | "delete";
type APIEndpointPathSpecific = `/${APIServiceName}/${APIAction}`;

function callAPISpecific(path: APIEndpointPathSpecific) {
  // API call logic
  console.log(`Calling specific API: ${path}`);
}

callAPISpecific("/users/create"); // Valid
//callAPISpecific("/users/list"); // TypeScript error

            

              
                Copy
              
            
          

આ તમને API એન્ડપોઇન્ટ્સની રચનાને વધુ ચોક્કસ રીતે વ્યાખ્યાયિત કરવાની મંજૂરી આપે છે, ટાઇપોને અટકાવે છે અને તમારી એપ્લિકેશનમાં સુસંગતતા સુનિશ્ચિત કરે છે. આ એક મૂળભૂત ઉદાહરણ છે; ક્વેરી પરિમાણો અને URL ના અન્ય ભાગોને માન્ય કરવા માટે વધુ જટિલ પેટર્ન બનાવી શકાય છે.

ટેમ્પલેટ લિટરલ ટાઇપ્સનો ઉપયોગ કરવાના ફાયદા

સ્ટ્રિંગ પેટર્ન મેચિંગ અને વેલિડેશન માટે ટેમ્પલેટ લિટરલ ટાઇપ્સનો ઉપયોગ કરવાથી ઘણા ફાયદા થાય છે:

• સુધારેલી ટાઇપ સલામતી: ટેમ્પલેટ લિટરલ ટાઇપ્સ તમને સ્ટ્રિંગ્સ પર વધુ કડક ટાઇપ અવરોધો લાગુ કરવાની મંજૂરી આપે છે, રનટાઇમ ભૂલોનું જોખમ ઘટાડે છે.
• ઉન્નત કોડ વાંચનક્ષમતા: ટેમ્પલેટ લિટરલ ટાઇપ્સ સ્ટ્રિંગ્સના અપેક્ષિત ફોર્મેટને સ્પષ્ટપણે વ્યક્ત કરીને તમારા કોડને વધુ વાંચી શકાય તેવું બનાવે છે.
• વધેલી જાળવણીક્ષમતા: ટેમ્પલેટ લિટરલ ટાઇપ્સ સ્ટ્રિંગ વેલિડેશન નિયમો માટે સત્યનો એક સ્ત્રોત પ્રદાન કરીને તમારા કોડને વધુ જાળવણીક્ષમ બનાવે છે.
• બહેતર વિકાસકર્તા અનુભવ: ટેમ્પલેટ લિટરલ ટાઇપ્સ વધુ સારી ઓટોકમ્પ્લેશન અને ભૂલ સંદેશાઓ પ્રદાન કરે છે, એકંદર વિકાસકર્તા અનુભવને સુધારે છે.

મર્યાદાઓ

જ્યારે ટેમ્પલેટ લિટરલ ટાઇપ્સ શક્તિશાળી હોય છે, ત્યારે તેની કેટલીક મર્યાદાઓ પણ છે:

• જટિલતા: ટેમ્પલેટ લિટરલ ટાઇપ્સ જટિલ બની શકે છે, ખાસ કરીને જ્યારે જટિલ પેટર્ન સાથે કામ કરવું. ટાઇપ સલામતીના ફાયદાઓને કોડ જાળવણીક્ષમતા સાથે સંતુલિત કરવું મહત્વપૂર્ણ છે.
• પર્ફોર્મન્સ: ટેમ્પલેટ લિટરલ ટાઇપ્સ સંકલન પર્ફોર્મન્સને અસર કરી શકે છે, ખાસ કરીને મોટા પ્રોજેક્ટ્સમાં. આ એટલા માટે છે કારણ કે ટાઇપસ્ક્રીપ્ટે વધુ જટિલ ટાઇપ તપાસ કરવાની જરૂર છે.
• મર્યાદિત રેગ્યુલર એક્સપ્રેશન સપોર્ટ: જ્યારે ટેમ્પલેટ લિટરલ ટાઇપ્સ પેટર્ન મેચિંગ માટે પરવાનગી આપે છે, ત્યારે તેઓ રેગ્યુલર એક્સપ્રેશન સુવિધાઓની સંપૂર્ણ શ્રેણીને સમર્થન આપતા નથી. અત્યંત જટિલ સ્ટ્રિંગ વેલિડેશન માટે, યોગ્ય ઇનપુટ સેનિટાઇઝેશન માટે આ ટાઇપ કન્સ્ટ્રક્ટ્સની સાથે રનટાઇમ રેગ્યુલર એક્સપ્રેશન્સની હજુ પણ જરૂર પડી શકે છે.

શ્રેષ્ઠ પ્રયાસો

ટેમ્પલેટ લિટરલ ટાઇપ્સનો ઉપયોગ કરતી વખતે ધ્યાનમાં રાખવા માટે અહીં કેટલાક શ્રેષ્ઠ પ્રયાસો છે:

• સરળ શરૂઆત કરો: સરળ પેટર્નથી શરૂઆત કરો અને જરૂરિયાત મુજબ ધીમે ધીમે જટિલતા વધારો.
• વર્ણનાત્મક નામોનો ઉપયોગ કરો: કોડ વાંચનક્ષમતા સુધારવા માટે તમારા ટેમ્પલેટ લિટરલ ટાઇપ્સ માટે વર્ણનાત્મક નામોનો ઉપયોગ કરો.
• તમારા ટાઇપ્સનું દસ્તાવેજીકરણ કરો: તેમના હેતુ અને ઉપયોગને સમજાવવા માટે તમારા ટેમ્પલેટ લિટરલ ટાઇપ્સનું દસ્તાવેજીકરણ કરો.
• સારી રીતે પરીક્ષણ કરો: તમારા ટેમ્પલેટ લિટરલ ટાઇપ્સની ખાતરી કરવા માટે સંપૂર્ણ પરીક્ષણ કરો કે તેઓ અપેક્ષા મુજબ વર્તે છે.
• પર્ફોર્મન્સનો વિચાર કરો: સંકલન પર્ફોર્મન્સ પર ટેમ્પલેટ લિટરલ ટાઇપ્સની અસર વિશે સજાગ રહો અને તે મુજબ તમારા કોડને ઑપ્ટિમાઇઝ કરો.

નિષ્કર્ષ

ટેમ્પલેટ લિટરલ ટાઇપ્સ ટાઇપસ્ક્રીપ્ટમાં એક શક્તિશાળી સુવિધા છે જે તમને ટાઇપ લેવલ પર અદ્યતન સ્ટ્રિંગ મેનીપ્યુલેશન, પેટર્ન મેચિંગ અને વેલિડેશન કરવા માટે પરવાનગી આપે છે. ટેમ્પલેટ લિટરલ ટાઇપ્સનો ઉપયોગ કરીને, તમે વધુ મજબૂત, જાળવણીક્ષમ અને ટાઇપ-સલામત એપ્લિકેશન્સ બનાવી શકો છો. જ્યારે તેમની કેટલીક મર્યાદાઓ હોય છે, ત્યારે ટેમ્પલેટ લિટરલ ટાઇપ્સનો ઉપયોગ કરવાના ફાયદાઓ ઘણીવાર ગેરફાયદા કરતાં વધી જાય છે, જે તેમને કોઈપણ ટાઇપસ્ક્રીપ્ટ વિકાસકર્તાના શસ્ત્રાગારમાં એક મૂલ્યવાન સાધન બનાવે છે. જેમ જેમ ટાઇપસ્ક્રીપ્ટ ભાષા વિકસિત થવાનું ચાલુ રાખે છે, તેમ તેમ આ અદ્યતન ટાઇપ સુવિધાઓને સમજવી અને તેનો ઉપયોગ કરવો ઉચ્ચ ગુણવત્તાવાળા સોફ્ટવેર બનાવવા માટે નિર્ણાયક બનશે. જટિલતાને વાંચનક્ષમતા સાથે સંતુલિત કરવાનું યાદ રાખો અને હંમેશા સંપૂર્ણ પરીક્ષણને પ્રાથમિકતા આપો.