ટાઇપસ્ક્રિપ્ટના મેપ્ડ ટાઇપ્સ અને કન્ડિશનલ ટાઇપ્સમાં નિપુણતા

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

મેપ્ડ ટાઇપ્સ શું છે?

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

મૂળભૂત સિન્ટેક્સ

મેપ્ડ ટાઇપ માટે સિન્ટેક્સ નીચે મુજબ છે:

type NewType<T> = {
  [K in keyof T]: Transformation;
};

• T: ઇનપુટ ટાઇપ કે જેના પર તમે મેપ કરવા માંગો છો.
• K in keyof T: ઇનપુટ ટાઇપ T માં દરેક કી પર પુનરાવર્તન કરે છે. keyof T એ T માંના તમામ પ્રોપર્ટી નામોનું યુનિયન બનાવે છે, અને K પુનરાવર્તન દરમિયાન દરેક વ્યક્તિગત કીનું પ્રતિનિધિત્વ કરે છે.
• Transformation: તમે દરેક પ્રોપર્ટી પર જે રૂપાંતરણ લાગુ કરવા માંગો છો. આ એક મોડિફાયર (જેમ કે readonly અથવા ?) ઉમેરવાનું, ટાઇપ બદલવાનું, અથવા સંપૂર્ણપણે કંઈક બીજું હોઈ શકે છે.

વ્યવહારુ ઉદાહરણો

પ્રોપર્ટીઝને ફક્ત વાંચવા માટે બનાવવી (Read-Only)

ચાલો કહીએ કે તમારી પાસે યુઝર પ્રોફાઇલનું પ્રતિનિધિત્વ કરતું એક ઇન્ટરફેસ છે:

interface UserProfile {
  name: string;
  age: number;
  email: string;
}

તમે એક નવો ટાઇપ બનાવી શકો છો જ્યાં બધી પ્રોપર્ટીઝ ફક્ત વાંચવા માટે (read-only) હોય:

type ReadOnlyUserProfile = {
  readonly [K in keyof UserProfile]: UserProfile[K];
};

હવે, ReadOnlyUserProfile માં UserProfile જેવી જ પ્રોપર્ટીઝ હશે, પરંતુ તે બધી ફક્ત વાંચવા માટે (read-only) હશે.

પ્રોપર્ટીઝને વૈકલ્પિક બનાવવી (Optional)

તેવી જ રીતે, તમે બધી પ્રોપર્ટીઝને વૈકલ્પિક બનાવી શકો છો:

type OptionalUserProfile = {
  [K in keyof UserProfile]?: UserProfile[K];
};

OptionalUserProfile માં UserProfile ની બધી પ્રોપર્ટીઝ હશે, પરંતુ દરેક પ્રોપર્ટી વૈકલ્પિક હશે.

પ્રોપર્ટી ટાઇપ્સમાં ફેરફાર કરવો

તમે દરેક પ્રોપર્ટીના ટાઇપમાં પણ ફેરફાર કરી શકો છો. ઉદાહરણ તરીકે, તમે બધી પ્રોપર્ટીઝને સ્ટ્રિંગમાં રૂપાંતરિત કરી શકો છો:

type StringifiedUserProfile = {
  [K in keyof UserProfile]: string;
};

આ કિસ્સામાં, StringifiedUserProfile માંની બધી પ્રોપર્ટીઝ string ટાઇપની હશે.

કન્ડિશનલ ટાઇપ્સ શું છે?

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

મૂળભૂત સિન્ટેક્સ

કન્ડિશનલ ટાઇપ માટે સિન્ટેક્સ નીચે મુજબ છે:

T extends U ? X : Y

• T: જે ટાઇપની તપાસ કરવામાં આવી રહી છે.
• U: જે ટાઇપને T દ્વારા વિસ્તૃત કરવામાં આવી રહ્યું છે (શરત).
• X: જો T એ U ને વિસ્તૃત કરે તો પરત કરવાનો ટાઇપ (શરત સાચી છે).
• Y: જો T એ U ને વિસ્તૃત ન કરે તો પરત કરવાનો ટાઇપ (શરત ખોટી છે).

વ્યવહારુ ઉદાહરણો

કોઈ ટાઇપ સ્ટ્રિંગ છે કે નહિ તે નક્કી કરવું

ચાલો એક એવો ટાઇપ બનાવીએ જે ઇનપુટ ટાઇપ સ્ટ્રિંગ હોય તો string પરત કરે, અને અન્યથા number પરત કરે:

type StringOrNumber<T> = T extends string ? string : number;

type Result1 = StringOrNumber<string>;  // string
type Result2 = StringOrNumber<number>;  // number
type Result3 = StringOrNumber<boolean>; // number

યુનિયનમાંથી ટાઇપ કાઢવો

તમે યુનિયન ટાઇપમાંથી કોઈ ચોક્કસ ટાઇપ કાઢવા માટે કન્ડિશનલ ટાઇપ્સનો ઉપયોગ કરી શકો છો. ઉદાહરણ તરીકે, non-nullable ટાઇપ્સ કાઢવા માટે:

type NonNullable<T> = T extends null | undefined ? never : T;

type Result4 = NonNullable<string | null | undefined>; // string

અહીં, જો T એ null અથવા undefined હોય, તો ટાઇપ never બની જાય છે, જેને પછી ટાઇપસ્ક્રિપ્ટના યુનિયન ટાઇપ સરળીકરણ દ્વારા ફિલ્ટર કરવામાં આવે છે.

ટાઇપ્સનું અનુમાન (Inferring) કરવું

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

type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;

function myFunction(x: number): string {
  return x.toString();
}

type Result5 = ReturnType<typeof myFunction>; // string

આ ઉદાહરણમાં, ReturnType ફંક્શનનો રિટર્ન ટાઇપ કાઢે છે. તે તપાસે છે કે T એ કોઈ પણ આર્ગ્યુમેન્ટ્સ લેતું ફંક્શન છે અને R ટાઇપ પરત કરે છે. જો તે હોય, તો તે R પરત કરે છે; અન્યથા, તે any પરત કરે છે.

મેપ્ડ ટાઇપ્સ અને કન્ડિશનલ ટાઇપ્સનું સંયોજન

મેપ્ડ ટાઇપ્સ અને કન્ડિશનલ ટાઇપ્સની સાચી શક્તિ તેમને સંયોજિત કરવાથી આવે છે. આ તમને અત્યંત લવચીક અને અર્થપૂર્ણ ટાઇપ રૂપાંતરણો બનાવવાની મંજૂરી આપે છે.

ઉદાહરણ: ડીપ રીડઓન્લી (Deep Readonly)

એક સામાન્ય ઉપયોગ એ છે કે એક એવો ટાઇપ બનાવવો જે ઓબ્જેક્ટની બધી પ્રોપર્ટીઝ, જેમાં નેસ્ટેડ પ્રોપર્ટીઝનો પણ સમાવેશ થાય છે, તેને ફક્ત વાંચવા માટે (read-only) બનાવે છે. આ રિકર્સિવ કન્ડિશનલ ટાઇપનો ઉપયોગ કરીને પ્રાપ્ત કરી શકાય છે.

type DeepReadonly<T> = {
  readonly [K in keyof T]: T[K] extends object ? DeepReadonly<T[K]> : T[K];
};

interface Company {
  name: string;
  address: {
    street: string;
    city: string;
  };
}

type ReadonlyCompany = DeepReadonly<Company>;

અહીં, DeepReadonly રિકર્સિવ રીતે બધી પ્રોપર્ટીઝ અને તેમની નેસ્ટેડ પ્રોપર્ટીઝ પર readonly મોડિફાયર લાગુ કરે છે. જો કોઈ પ્રોપર્ટી ઓબ્જેક્ટ હોય, તો તે તે ઓબ્જેક્ટ પર રિકર્સિવ રીતે DeepReadonly ને કૉલ કરે છે. અન્યથા, તે ફક્ત પ્રોપર્ટી પર readonly મોડિફાયર લાગુ કરે છે.

ઉદાહરણ: ટાઇપ દ્વારા પ્રોપર્ટીઝ ફિલ્ટર કરવી

ચાલો કહીએ કે તમે એક એવો ટાઇપ બનાવવા માંગો છો જેમાં ફક્ત ચોક્કસ ટાઇપની પ્રોપર્ટીઝ શામેલ હોય. તમે આ પ્રાપ્ત કરવા માટે મેપ્ડ ટાઇપ્સ અને કન્ડિશનલ ટાઇપ્સનું સંયોજન કરી શકો છો.

type FilterByType<T, U> = {
  [K in keyof T as T[K] extends U ? K : never]: T[K];
};

interface Person {
  name: string;
  age: number;
  isEmployed: boolean;
}

type StringProperties = FilterByType<Person, string>; // { name: string; }

type NonStringProperties = Omit<Person, keyof StringProperties>;

આ ઉદાહરણમાં, FilterByType એ T ની પ્રોપર્ટીઝ પર પુનરાવર્તન કરે છે અને તપાસે છે કે દરેક પ્રોપર્ટીનો ટાઇપ U ને વિસ્તૃત કરે છે કે નહીં. જો તે કરે છે, તો તે પરિણામી ટાઇપમાં પ્રોપર્ટીનો સમાવેશ કરે છે; અન્યથા, તે કીને never પર મેપ કરીને તેને બાકાત રાખે છે. કીને ફરીથી મેપ કરવા માટે "as" ના ઉપયોગ પર ધ્યાન આપો. પછી અમે મૂળ ઇન્ટરફેસમાંથી સ્ટ્રિંગ પ્રોપર્ટીઝને દૂર કરવા માટે `Omit` અને `keyof StringProperties` નો ઉપયોગ કરીએ છીએ.

અદ્યતન ઉપયોગના કિસ્સાઓ અને પેટર્ન

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

ડિસ્ટ્રિબ્યુટિવ કન્ડિશનલ ટાઇપ્સ

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

type ToArray<T> = T extends any ? T[] : never;

type Result6 = ToArray<string | number>; // string[] | number[]

આ ઉદાહરણમાં, ToArray યુનિયન string | number ના દરેક સભ્ય પર વ્યક્તિગત રીતે લાગુ થાય છે, જેના પરિણામે string[] | number[] મળે છે. જો શરત ડિસ્ટ્રિબ્યુટિવ ન હોત, તો પરિણામ (string | number)[] હોત.

યુટિલિટી ટાઇપ્સનો ઉપયોગ

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

• Partial<T>: T ની બધી પ્રોપર્ટીઝને વૈકલ્પિક બનાવે છે.
• Required<T>: T ની બધી પ્રોપર્ટીઝને આવશ્યક બનાવે છે.
• Readonly<T>: T ની બધી પ્રોપર્ટીઝને ફક્ત વાંચવા માટે બનાવે છે.
• Pick<T, K>: T માંથી પ્રોપર્ટીઝ K નો સમૂહ પસંદ કરે છે.
• Omit<T, K>: T માંથી પ્રોપર્ટીઝ K નો સમૂહ દૂર કરે છે.
• Record<K, T>: T ટાઇપની પ્રોપર્ટીઝ K ના સમૂહ સાથે એક ટાઇપ બનાવે છે.
• Exclude<T, U>: T માંથી તે બધા ટાઇપ્સને બાકાત રાખે છે જે U ને અસાઇન કરી શકાય છે.
• Extract<T, U>: T માંથી તે બધા ટાઇપ્સને કાઢે છે જે U ને અસાઇન કરી શકાય છે.
• NonNullable<T>: T માંથી null અને undefined ને બાકાત રાખે છે.
• Parameters<T>: ફંક્શન ટાઇપ T ના પેરામીટર્સ મેળવે છે.
• ReturnType<T>: ફંક્શન ટાઇપ T નો રિટર્ન ટાઇપ મેળવે છે.
• InstanceType<T>: કન્સ્ટ્રક્ટર ફંક્શન ટાઇપ T નો ઇન્સ્ટન્સ ટાઇપ મેળવે છે.

આ યુટિલિટી ટાઇપ્સ શક્તિશાળી સાધનો છે જે જટિલ ટાઇપ મેનીપ્યુલેશનને સરળ બનાવી શકે છે. ઉદાહરણ તરીકે, તમે Pick અને Partial ને જોડીને એક એવો ટાઇપ બનાવી શકો છો જે ફક્ત અમુક પ્રોપર્ટીઝને વૈકલ્પિક બનાવે છે:

type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;

interface Product {
  id: number;
  name: string;
  price: number;
  description: string;
}

type OptionalDescriptionProduct = Optional<Product, "description">;

આ ઉદાહરણમાં, OptionalDescriptionProduct માં Product ની બધી પ્રોપર્ટીઝ છે, પરંતુ description પ્રોપર્ટી વૈકલ્પિક છે.

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

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

type Prefix<T, P extends string> = {
  [K in keyof T as `${P}${string & K}`]: T[K];
};

interface Settings {
  apiUrl: string;
  timeout: number;
}

type PrefixedSettings = Prefix<Settings, "data_">;

આ ઉદાહરણમાં, PrefixedSettings માં data_apiUrl અને data_timeout પ્રોપર્ટીઝ હશે.

શ્રેષ્ઠ પદ્ધતિઓ અને વિચારણાઓ

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

નિષ્કર્ષ

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

જેમ જેમ તમે તમારી ટાઇપસ્ક્રિપ્ટ યાત્રા ચાલુ રાખો છો, તેમ તેમ ઉપલબ્ધ સંસાધનોની સંપત્તિનો લાભ લેવાનું યાદ રાખો, જેમાં સત્તાવાર ટાઇપસ્ક્રિપ્ટ દસ્તાવેજીકરણ, ઓનલાઈન સમુદાયો અને ઓપન-સોર્સ પ્રોજેક્ટ્સનો સમાવેશ થાય છે. મેપ્ડ ટાઇપ્સ અને કન્ડિશનલ ટાઇપ્સની શક્તિને અપનાવો, અને તમે સૌથી પડકારજનક ટાઇપ-સંબંધિત સમસ્યાઓનો સામનો કરવા માટે સારી રીતે સજ્જ થશો.