M

MLOG

मराठी

टाइपस्क्रिप्टच्या युटिलिटी टाइप्समध्ये पारंगत व्हा: टाइप ट्रान्सफॉर्मेशनसाठी शक्तिशाली साधने, कोड पुनर्वापर सुधारणे, आणि तुमच्या ऍप्लिकेशन्समध्ये टाइप सुरक्षा वाढवणे.

टाइपस्क्रिप्ट युटिलिटी टाइप्स: अंगभूत टाइप हाताळणी साधने

टाइपस्क्रिप्ट ही एक शक्तिशाली भाषा आहे जी जावास्क्रिप्टमध्ये स्टॅटिक टायपिंग आणते. या भाषेचे एक प्रमुख वैशिष्ट्य म्हणजे टाइप्स हाताळण्याची क्षमता, ज्यामुळे डेव्हलपर्सना अधिक मजबूत आणि देखरेख करण्यायोग्य कोड तयार करता येतो. टाइपस्क्रिप्टमध्ये अंगभूत युटिलिटी टाइप्सचा एक संच आहे जो सामान्य टाइप रूपांतरणे सोपी करतो. हे युटिलिटी टाइप्स टाइप सुरक्षा वाढवण्यासाठी, कोड पुनर्वापर सुधारण्यासाठी, आणि तुमच्या डेव्हलपमेंट वर्कफ्लोला सुव्यवस्थित करण्यासाठी अमूल्य साधने आहेत. हा व्यापक मार्गदर्शक तुम्हाला सर्वात आवश्यक टाइपस्क्रिप्ट युटिलिटी टाइप्सबद्दल माहिती देईल, ज्यात व्यावहारिक उदाहरणे आणि उपयुक्त माहिती असेल, जेणेकरून तुम्ही त्यात पारंगत होऊ शकाल.

टाइपस्क्रिप्ट युटिलिटी टाइप्स म्हणजे काय?

युटिलिटी टाइप्स हे पूर्वनिर्धारित टाइप ऑपरेटर आहेत जे विद्यमान टाइप्सना नवीन टाइप्समध्ये रूपांतरित करतात. ते टाइपस्क्रिप्ट भाषेत अंगभूत आहेत आणि सामान्य टाइप हाताळणीसाठी एक संक्षिप्त आणि घोषणात्मक मार्ग प्रदान करतात. युटिलिटी टाइप्स वापरल्याने बॉयलरप्लेट कोड लक्षणीयरीत्या कमी होऊ शकतो आणि तुमची टाइप व्याख्या अधिक अर्थपूर्ण आणि समजण्यास सोपी होते.

त्यांना व्हॅल्यूजऐवजी टाइप्सवर कार्य करणाऱ्या फंक्शन्सप्रमाणे समजा. ते इनपुट म्हणून एक टाइप घेतात आणि आउटपुट म्हणून एक सुधारित टाइप परत करतात. यामुळे तुम्हाला कमीतकमी कोडसह क्लिष्ट टाइप संबंध आणि रूपांतरणे तयार करता येतात.

युटिलिटी टाइप्स का वापरावे?

तुमच्या टाइपस्क्रिप्ट प्रोजेक्ट्समध्ये युटिलिटी टाइप्स समाविष्ट करण्याची अनेक आकर्षक कारणे आहेत:

अत्यावश्यक टाइपस्क्रिप्ट युटिलिटी टाइप्स

चला, टाइपस्क्रिप्टमधील काही सर्वात सामान्यपणे वापरल्या जाणाऱ्या आणि फायदेशीर युटिलिटी टाइप्सचा शोध घेऊया. आम्ही त्यांचा उद्देश, सिंटॅक्स आणि त्यांच्या वापराचे स्पष्टीकरण देण्यासाठी व्यावहारिक उदाहरणे देऊ.

१. Partial<T>

Partial<T> युटिलिटी टाइप, T टाइपच्या सर्व प्रॉपर्टीजना ऐच्छिक (optional) बनवतो. जेव्हा तुम्हाला एखाद्या विद्यमान टाइपच्या काही किंवा सर्व प्रॉपर्टीज असलेला नवीन टाइप तयार करायचा असतो, परंतु त्या सर्व प्रॉपर्टीज असणे आवश्यक नसते, तेव्हा हे उपयुक्त ठरते.

सिंटॅक्स:

type Partial<T> = { [P in keyof T]?: T[P]; };

उदाहरण:

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

type OptionalUser = Partial<User>; // सर्व प्रॉपर्टीज आता ऐच्छिक आहेत

const partialUser: OptionalUser = {
 name: "Alice", // फक्त 'name' प्रॉपर्टी दिली आहे
};

वापराचे उदाहरण: एखाद्या ऑब्जेक्टला केवळ विशिष्ट प्रॉपर्टीजसह अपडेट करणे. उदाहरणार्थ, युझर प्रोफाइल अपडेट फॉर्मची कल्पना करा. तुम्हाला युझर्सना एकाच वेळी प्रत्येक फील्ड अपडेट करण्याची आवश्यकता नसते.

२. Required<T>

Required<T> युटिलिटी टाइप, T टाइपच्या सर्व प्रॉपर्टीजना आवश्यक (required) बनवतो. हे Partial<T> च्या विरुद्ध आहे. जेव्हा तुमच्याकडे ऐच्छिक प्रॉपर्टीज असलेला टाइप असतो आणि तुम्हाला खात्री करायची असते की सर्व प्रॉपर्टीज उपस्थित आहेत, तेव्हा हे उपयुक्त ठरते.

सिंटॅक्स:

type Required<T> = { [P in keyof T]-?: T[P]; };

उदाहरण:

interface Config {
 apiKey?: string;
 apiUrl?: string;
}

type CompleteConfig = Required<Config>; // सर्व प्रॉपर्टीज आता आवश्यक आहेत

const config: CompleteConfig = {
 apiKey: "your-api-key",
 apiUrl: "https://example.com/api",
};

वापराचे उदाहरण: ऍप्लिकेशन सुरू करण्यापूर्वी सर्व कॉन्फिगरेशन सेटिंग्ज पुरवल्या गेल्या आहेत याची खात्री करणे. हे गहाळ किंवा अनडिफाइंड सेटिंग्जमुळे होणाऱ्या रनटाइम त्रुटी टाळण्यास मदत करू शकते.

३. Readonly<T>

Readonly<T> युटिलिटी टाइप, T टाइपच्या सर्व प्रॉपर्टीजना केवळ-वाचनीय (readonly) बनवतो. हे तुम्हाला एखाद्या ऑब्जेक्टच्या प्रॉपर्टीज तयार झाल्यानंतर चुकून बदलण्यापासून प्रतिबंधित करते. हे अपरिवर्तनीयतेला (immutability) प्रोत्साहन देते आणि तुमच्या कोडची अचूकता सुधारते.

सिंटॅक्स:

type Readonly<T> = { readonly [P in keyof T]: T[P]; };

उदाहरण:

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

type ImmutableProduct = Readonly<Product>; // सर्व प्रॉपर्टीज आता केवळ-वाचनीय आहेत

const product: ImmutableProduct = {
 id: 123,
 name: "Example Product",
 price: 25.99,
};

// product.price = 29.99; // त्रुटी: 'price' ला नियुक्त करू शकत नाही कारण ती केवळ-वाचनीय प्रॉपर्टी आहे.

वापराचे उदाहरण: अपरिवर्तनीय डेटा स्ट्रक्चर्स तयार करणे, जसे की कॉन्फिगरेशन ऑब्जेक्ट्स किंवा डेटा ट्रान्सफर ऑब्जेक्ट्स (DTOs), जे तयार झाल्यानंतर बदलले जाऊ नयेत. हे विशेषतः फंक्शनल प्रोग्रामिंग पॅराडाइम्समध्ये उपयुक्त आहे.

४. Pick<T, K extends keyof T>

Pick<T, K extends keyof T> युटिलिटी टाइप, T टाइपमधून K प्रॉपर्टीजचा संच निवडून (picking) एक नवीन टाइप तयार करतो. जेव्हा तुम्हाला विद्यमान टाइपच्या फक्त काही प्रॉपर्टीजची आवश्यकता असते तेव्हा हे उपयुक्त ठरते.

सिंटॅक्स:

type Pick<T, K extends keyof T> = { [P in K]: T[P]; };

उदाहरण:

interface Employee {
 id: number;
 name: string;
 department: string;
salary: number;
}

type EmployeeNameAndDepartment = Pick<Employee, "name" | "department">; // फक्त 'name' आणि 'department' निवडा

const employeeInfo: EmployeeNameAndDepartment = {
 name: "Bob",
 department: "Engineering",
};

वापराचे उदाहरण: विशेष डेटा ट्रान्सफर ऑब्जेक्ट्स (DTOs) तयार करणे ज्यात केवळ विशिष्ट ऑपरेशनसाठी आवश्यक असलेला डेटा असतो. यामुळे कार्यक्षमता सुधारू शकते आणि नेटवर्कवर प्रसारित होणाऱ्या डेटाचे प्रमाण कमी होऊ शकते. कल्पना करा की क्लायंटला युझर तपशील पाठवताना पगारासारखी संवेदनशील माहिती वगळायची आहे. तुम्ही फक्त `id` आणि `name` पाठवण्यासाठी Pick वापरू शकता.

५. Omit<T, K extends keyof any>

Omit<T, K extends keyof any> युटिलिटी टाइप, T टाइपमधून K प्रॉपर्टीजचा संच वगळून (omitting) एक नवीन टाइप तयार करतो. हे Pick<T, K extends keyof T> च्या विरुद्ध आहे आणि जेव्हा तुम्हाला विद्यमान टाइपमधून काही विशिष्ट प्रॉपर्टीज वगळायच्या असतात तेव्हा हे उपयुक्त ठरते.

सिंटॅक्स:

type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;

उदाहरण:

interface Event {
 id: number;
 title: string;
description: string;
 date: Date;
 location: string;
}

type EventSummary = Omit<Event, "description" | "location">; // 'description' आणि 'location' वगळा

const eventPreview: EventSummary = {
 id: 1,
 title: "Conference",
 date: new Date(),
};

वापराचे उदाहरण: विशिष्ट उद्देशांसाठी डेटा मॉडेलची सोपी आवृत्ती तयार करणे, जसे की एखाद्या कार्यक्रमाचा सारांश दाखवणे ज्यात पूर्ण वर्णन आणि स्थान समाविष्ट नाही. क्लायंटला डेटा पाठवण्यापूर्वी संवेदनशील फील्ड काढून टाकण्यासाठी देखील याचा वापर केला जाऊ शकतो.

६. Exclude<T, U>

Exclude<T, U> युटिलिटी टाइप, T मधून U ला नियुक्त करता येणारे सर्व टाइप्स वगळून (excluding) एक नवीन टाइप तयार करतो. जेव्हा तुम्हाला युनियन टाइपमधून काही विशिष्ट टाइप्स काढून टाकायचे असतात तेव्हा हे उपयुक्त ठरते.

सिंटॅक्स:

type Exclude<T, U> = T extends U ? never : T;

उदाहरण:

type AllowedFileTypes = "image" | "video" | "audio" | "document";
type MediaFileTypes = "image" | "video" | "audio";

type DocumentFileTypes = Exclude<AllowedFileTypes, MediaFileTypes>; // "document"

const fileType: DocumentFileTypes = "document";

वापराचे उदाहरण: युनियन टाइपला फिल्टर करणे जेणेकरून विशिष्ट संदर्भात संबंधित नसलेले विशिष्ट टाइप्स काढून टाकता येतील. उदाहरणार्थ, तुम्हाला परवानगी असलेल्या फाइल प्रकारांच्या सूचीमधून काही फाइल प्रकार वगळायचे असतील.

७. Extract<T, U>

Extract<T, U> युटिलिटी टाइप, T मधून U ला नियुक्त करता येणारे सर्व टाइप्स काढून (extracting) एक नवीन टाइप तयार करतो. हे Exclude<T, U> च्या विरुद्ध आहे आणि जेव्हा तुम्हाला युनियन टाइपमधून विशिष्ट टाइप्स निवडायचे असतात तेव्हा हे उपयुक्त ठरते.

सिंटॅक्स:

type Extract<T, U> = T extends U ? T : never;

उदाहरण:

type InputTypes = string | number | boolean | null | undefined;
type PrimitiveTypes = string | number | boolean;

type NonNullablePrimitives = Extract<InputTypes, PrimitiveTypes>; // string | number | boolean

const value: NonNullablePrimitives = "hello";

वापराचे उदाहरण: विशिष्ट निकषांवर आधारित युनियन टाइपमधून विशिष्ट टाइप्स निवडणे. उदाहरणार्थ, तुम्हाला युनियन टाइपमधून सर्व प्रिमिटिव्ह टाइप्स काढायचे असतील ज्यात प्रिमिटिव्ह टाइप्स आणि ऑब्जेक्ट टाइप्स दोन्ही समाविष्ट आहेत.

८. NonNullable<T>

NonNullable<T> युटिलिटी टाइप, T टाइपमधून null आणि undefined वगळून एक नवीन टाइप तयार करतो. जेव्हा तुम्हाला खात्री करायची असते की एखादा टाइप null किंवा undefined असू शकत नाही तेव्हा हे उपयुक्त ठरते.

सिंटॅक्स:

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

उदाहरण:

type MaybeString = string | null | undefined;

type DefinitelyString = NonNullable<MaybeString>; // string

const message: DefinitelyString = "Hello, world!";

वापराचे उदाहरण: एखाद्या व्हॅल्यूवर ऑपरेशन करण्यापूर्वी ती null किंवा undefined नाही याची खात्री करणे. हे अनपेक्षित null किंवा undefined व्हॅल्यूजमुळे होणाऱ्या रनटाइम त्रुटी टाळण्यास मदत करू शकते. अशा परिस्थितीचा विचार करा जिथे तुम्हाला युझरच्या पत्त्यावर प्रक्रिया करायची आहे, आणि कोणत्याही ऑपरेशनपूर्वी पत्ता null नसणे महत्त्वाचे आहे.

९. ReturnType<T extends (...args: any) => any>

ReturnType<T extends (...args: any) => any> युटिलिटी टाइप, T फंक्शन टाइपचा रिटर्न टाइप काढतो. जेव्हा तुम्हाला फंक्शन परत करणाऱ्या व्हॅल्यूचा टाइप जाणून घ्यायचा असतो तेव्हा हे उपयुक्त ठरते.

सिंटॅक्स:

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

उदाहरण:

function fetchData(url: string): Promise<{ data: any }> {
 return fetch(url).then(response => response.json());
}

type FetchDataReturnType = ReturnType<typeof fetchData>; // Promise<{ data: any }>

async function processData(data: FetchDataReturnType) {
 // ...
}

वापराचे उदाहरण: फंक्शनद्वारे परत केलेल्या व्हॅल्यूचा टाइप निश्चित करणे, विशेषतः असिंक्रोनस ऑपरेशन्स किंवा जटिल फंक्शन सिग्नेचर्स हाताळताना. हे तुम्हाला परत केलेल्या व्हॅल्यूला योग्यरित्या हाताळत असल्याची खात्री करण्यास मदत करते.

१०. Parameters<T extends (...args: any) => any>

Parameters<T extends (...args: any) => any> युटिलिटी टाइप, T फंक्शन टाइपचे पॅरामीटर टाइप्स टपल (tuple) म्हणून काढतो. जेव्हा तुम्हाला फंक्शन स्वीकारणाऱ्या आर्ग्युमेंट्सचे टाइप्स जाणून घ्यायचे असतात तेव्हा हे उपयुक्त ठरते.

सिंटॅक्स:

type Parameters<T extends (...args: any) => any> = T extends (...args: infer P) => any ? P : never;

उदाहरण:

function createUser(name: string, age: number, email: string): void {
 // ...
}

type CreateUserParams = Parameters<typeof createUser>; // [string, number, string]

function logUser(...args: CreateUserParams) {
 console.log("Creating user with:", args);
}

वापराचे उदाहरण: फंक्शन स्वीकारणाऱ्या आर्ग्युमेंट्सचे टाइप्स निश्चित करणे, जे जेनेरिक फंक्शन्स किंवा डेकोरेटर्स तयार करताना उपयुक्त असू शकते ज्यांना वेगवेगळ्या सिग्नेचर्सच्या फंक्शन्ससह कार्य करण्याची आवश्यकता असते. हे डायनॅमिकली फंक्शनला आर्ग्युमेंट्स पास करताना टाइप सुरक्षा सुनिश्चित करण्यास मदत करते.

११. ConstructorParameters<T extends abstract new (...args: any) => any>

ConstructorParameters<T extends abstract new (...args: any) => any> युटिलिटी टाइप, T कन्स्ट्रक्टर फंक्शन टाइपचे पॅरामीटर टाइप्स टपल (tuple) म्हणून काढतो. जेव्हा तुम्हाला कन्स्ट्रक्टर स्वीकारणाऱ्या आर्ग्युमेंट्सचे टाइप्स जाणून घ्यायचे असतात तेव्हा हे उपयुक्त ठरते.

सिंटॅक्स:

type ConstructorParameters<T extends abstract new (...args: any) => any> = T extends abstract new (...args: infer P) => any ? P : never;

उदाहरण:

class Logger {
 constructor(public prefix: string, public enabled: boolean) {}
 log(message: string) {
 if (this.enabled) {
 console.log(`${this.prefix}: ${message}`);
 }
 }
}

type LoggerConstructorParams = ConstructorParameters<typeof Logger>; // [string, boolean]

function createLogger(...args: LoggerConstructorParams) {
 return new Logger(...args);
}

वापराचे उदाहरण: Parameters प्रमाणेच, परंतु विशेषतः कन्स्ट्रक्टर फंक्शन्ससाठी. फॅक्टरीज किंवा डिपेंडेंसी इंजेक्शन सिस्टीम तयार करताना हे मदत करते जिथे तुम्हाला वेगवेगळ्या कन्स्ट्रक्टर सिग्नेचर्ससह क्लासेस डायनॅमिकली इन्स्टँशिएट करण्याची आवश्यकता असते.

१२. InstanceType<T extends abstract new (...args: any) => any>

InstanceType<T extends abstract new (...args: any) => any> युटिलिटी टाइप, T कन्स्ट्रक्टर फंक्शन टाइपचा इन्स्टन्स टाइप काढतो. जेव्हा तुम्हाला कन्स्ट्रक्टर तयार करणाऱ्या ऑब्जेक्टचा टाइप जाणून घ्यायचा असतो तेव्हा हे उपयुक्त ठरते.

सिंटॅक्स:

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

उदाहरण:

class Greeter {
 greeting: string;
 constructor(message: string) {
 this.greeting = message;
 }
 greet() {
 return "Hello, " + this.greeting;
 }
}

type GreeterInstance = InstanceType<typeof Greeter>; // Greeter

const myGreeter: GreeterInstance = new Greeter("World");
console.log(myGreeter.greet());

वापराचे उदाहरण: कन्स्ट्रक्टरद्वारे तयार केलेल्या ऑब्जेक्टचा टाइप निश्चित करणे, जे इनहेरिटन्स किंवा पॉलिमॉर्फिझमसह काम करताना उपयुक्त आहे. हे क्लासच्या इन्स्टन्सचा संदर्भ देण्यासाठी टाइप-सुरक्षित मार्ग प्रदान करते.

१३. Record<K extends keyof any, T>

Record<K extends keyof any, T> युटिलिटी टाइप, एक ऑब्जेक्ट टाइप तयार करतो ज्याच्या प्रॉपर्टी कीज K आहेत आणि ज्याच्या प्रॉपर्टी व्हॅल्यूज T आहेत. जेव्हा तुम्हाला कीज आगाऊ माहित असतात तेव्हा डिक्शनरी-सारखे टाइप्स तयार करण्यासाठी हे उपयुक्त आहे.

सिंटॅक्स:

type Record<K extends keyof any, T> = { [P in K]: T; };

उदाहरण:

type CountryCode = "US" | "CA" | "GB" | "DE";

type CurrencyMap = Record<CountryCode, string>; // { US: string; CA: string; GB: string; DE: string; }

const currencies: CurrencyMap = {
 US: "USD",
 CA: "CAD",
 GB: "GBP",
 DE: "EUR",
};

वापराचे उदाहरण: डिक्शनरी-सारखे ऑब्जेक्ट्स तयार करणे जिथे तुमच्याकडे कीजचा एक निश्चित संच असतो आणि तुम्हाला खात्री करायची असते की सर्व कीजमध्ये विशिष्ट टाइपच्या व्हॅल्यूज आहेत. कॉन्फिगरेशन फाइल्स, डेटा मॅपिंग्स, किंवा लुकअप टेबल्ससह काम करताना हे सामान्य आहे.

कस्टम युटिलिटी टाइप्स

टाइपस्क्रिप्टचे अंगभूत युटिलिटी टाइप्स शक्तिशाली असले तरी, तुम्ही तुमच्या प्रोजेक्टमधील विशिष्ट गरजा पूर्ण करण्यासाठी स्वतःचे कस्टम युटिलिटी टाइप्स देखील तयार करू शकता. यामुळे तुम्हाला क्लिष्ट टाइप रूपांतरणे एन्कॅप्सुलेट करता येतात आणि तुमच्या कोडबेसमध्ये त्यांचा पुन्हा वापर करता येतो.

उदाहरण:

// एखाद्या ऑब्जेक्टच्या विशिष्ट टाइप असलेल्या कीज मिळवण्यासाठी एक युटिलिटी टाइप
type KeysOfType<T, U> = { [K in keyof T]: T[K] extends U ? K : never }[keyof T];

interface Person {
 name: string;
 age: number;
 address: string;
 phoneNumber: number;
}

type StringKeys = KeysOfType<Person, string>; // "name" | "address"

युटिलिटी टाइप्स वापरण्यासाठी सर्वोत्तम पद्धती

निष्कर्ष

टाइपस्क्रिप्ट युटिलिटी टाइप्स ही शक्तिशाली साधने आहेत जी तुमच्या कोडची टाइप सुरक्षा, पुनर्वापर आणि देखभालक्षमता लक्षणीयरीत्या सुधारू शकतात. या युटिलिटी टाइप्समध्ये पारंगत होऊन, तुम्ही अधिक मजबूत आणि अर्थपूर्ण टाइपस्क्रिप्ट ऍप्लिकेशन्स लिहू शकता. या मार्गदर्शकाने सर्वात आवश्यक टाइपस्क्रिप्ट युटिलिटी टाइप्सचा आढावा घेतला आहे, ज्यात व्यावहारिक उदाहरणे आणि उपयुक्त माहिती दिली आहे, जेणेकरून तुम्हाला ते तुमच्या प्रोजेक्ट्समध्ये समाविष्ट करण्यास मदत होईल.

या युटिलिटी टाइप्ससह प्रयोग करण्याचे लक्षात ठेवा आणि तुमच्या स्वतःच्या कोडमधील विशिष्ट समस्या सोडवण्यासाठी त्यांचा कसा वापर केला जाऊ शकतो हे तपासा. जसजसे तुम्ही त्यांच्याशी अधिक परिचित व्हाल, तसतसे तुम्ही स्वच्छ, अधिक देखरेख करण्यायोग्य आणि अधिक टाइप-सुरक्षित टाइपस्क्रिप्ट ऍप्लिकेशन्स तयार करण्यासाठी त्यांचा अधिकाधिक वापर कराल. तुम्ही वेब ऍप्लिकेशन्स, सर्व्हर-साइड ऍप्लिकेशन्स किंवा इतर काहीही तयार करत असाल, युटिलिटी टाइप्स तुमच्या डेव्हलपमेंट वर्कफ्लो आणि तुमच्या कोडची गुणवत्ता सुधारण्यासाठी साधनांचा एक मौल्यवान संच प्रदान करतात. या अंगभूत टाइप हाताळणी साधनांचा फायदा घेऊन, तुम्ही टाइपस्क्रिप्टची पूर्ण क्षमता अनलॉक करू शकता आणि असा कोड लिहू शकता जो अर्थपूर्ण आणि मजबूत दोन्ही असेल.