ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಯುಟಿಲಿಟಿ ಟೈಪ್ಸ್‌ನಲ್ಲಿ ಪರಿಣತಿ: ಜಾಗತಿಕ ಡೆವಲಪರ್‌ಗಳಿಗೆ ಒಂದು ಪ್ರಾಯೋಗಿಕ ಮಾರ್ಗದರ್ಶಿ

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್, ಅಂತರ್ನಿರ್ಮಿತ ಯುಟಿಲಿಟಿ ಟೈಪ್ಸ್‌ನ ಒಂದು ಶಕ್ತಿಶಾಲಿ ಸಂಗ್ರಹವನ್ನು ನೀಡುತ್ತದೆ, ಇದು ನಿಮ್ಮ ಕೋಡ್‌ನ ಟೈಪ್ ಸುರಕ್ಷತೆ, ಓದುವಿಕೆ ಮತ್ತು ನಿರ್ವಹಣೆಯನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಹೆಚ್ಚಿಸುತ್ತದೆ. ಈ ಯುಟಿಲಿಟಿ ಟೈಪ್ಸ್ ಮೂಲಭೂತವಾಗಿ ಪೂರ್ವ-ನಿರ್ಧಾರಿತ ಟೈಪ್ ರೂಪಾಂತರಗಳಾಗಿವೆ, ಇವುಗಳನ್ನು ನೀವು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಟೈಪ್ಸ್‌ಗೆ ಅನ್ವಯಿಸಬಹುದು, ಪುನರಾವರ್ತಿತ ಮತ್ತು ದೋಷಪೂರಿತ ಕೋಡ್ ಬರೆಯುವುದರಿಂದ ನಿಮ್ಮನ್ನು ಉಳಿಸುತ್ತದೆ. ಈ ಮಾರ್ಗದರ್ಶಿ ಜಗತ್ತಿನಾದ್ಯಂತದ ಡೆವಲಪರ್‌ಗಳಿಗೆ ಅನುರಣಿಸುವ ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳೊಂದಿಗೆ ವಿವಿಧ ಯುಟಿಲಿಟಿ ಟೈಪ್ಸ್‌ ಅನ್ನು ಅನ್ವೇಷಿಸುತ್ತದೆ.

ಯುಟಿಲಿಟಿ ಟೈಪ್ಸ್‌ ಅನ್ನು ಏಕೆ ಬಳಸಬೇಕು?

ಯುಟಿಲಿಟಿ ಟೈಪ್ಸ್ ಸಾಮಾನ್ಯ ಟೈಪ್ ಮ್ಯಾನಿಪ್ಯುಲೇಶನ್ ಸನ್ನಿವೇಶಗಳನ್ನು ಪರಿಹರಿಸುತ್ತವೆ. ಅವುಗಳನ್ನು ಬಳಸುವುದರಿಂದ, ನೀವು ಹೀಗೆ ಮಾಡಬಹುದು:

• ಬಾಯ್ಲರ್‌ಪ್ಲೇಟ್ ಕೋಡ್ ಕಡಿಮೆ ಮಾಡಿ: ಪುನರಾವರ್ತಿತ ಟೈಪ್ ವ್ಯಾಖ್ಯಾನಗಳನ್ನು ಬರೆಯುವುದನ್ನು ತಪ್ಪಿಸಿ.
• ಟೈಪ್ ಸುರಕ್ಷತೆಯನ್ನು ಸುಧಾರಿಸಿ: ನಿಮ್ಮ ಕೋಡ್ ಟೈಪ್ ನಿರ್ಬಂಧಗಳಿಗೆ ಬದ್ಧವಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.
• ಕೋಡ್ ಓದುವಿಕೆಯನ್ನು ಹೆಚ್ಚಿಸಿ: ನಿಮ್ಮ ಟೈಪ್ ವ್ಯಾಖ್ಯಾನಗಳನ್ನು ಹೆಚ್ಚು ಸಂಕ್ಷಿಪ್ತ ಮತ್ತು ಸುಲಭವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಂತೆ ಮಾಡಿ.
• ನಿರ್ವಹಣೆಯನ್ನು ಹೆಚ್ಚಿಸಿ: ಮಾರ್ಪಾಡುಗಳನ್ನು ಸರಳಗೊಳಿಸಿ ಮತ್ತು ದೋಷಗಳನ್ನು ಪರಿಚಯಿಸುವ ಅಪಾಯವನ್ನು ಕಡಿಮೆ ಮಾಡಿ.

ಕೋರ್ ಯುಟಿಲಿಟಿ ಟೈಪ್ಸ್

Partial

Partial ಒಂದು ಟೈಪ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ, ಇದರಲ್ಲಿ T ನ ಎಲ್ಲಾ ಪ್ರಾಪರ್ಟಿಗಳು ಐಚ್ಛಿಕವಾಗಿರುತ್ತವೆ (optional). ಭಾಗಶಃ ಅಪ್‌ಡೇಟ್‌ಗಳು ಅಥವಾ ಕಾನ್ಫಿಗರೇಶನ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳಿಗಾಗಿ ಟೈಪ್ ರಚಿಸಲು ಇದು ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ.

ಉದಾಹರಣೆ:

ನೀವು ವಿವಿಧ ಪ್ರದೇಶಗಳ ಗ್ರಾಹಕರೊಂದಿಗೆ ಇ-ಕಾಮರ್ಸ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಅನ್ನು ನಿರ್ಮಿಸುತ್ತಿದ್ದೀರಿ ಎಂದು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ. ನಿಮ್ಮಲ್ಲಿ Customer ಎಂಬ ಟೈಪ್ ಇದೆ:

interface Customer {
  id: string;
  firstName: string;
  lastName: string;
  email: string;
  phoneNumber: string;
  address: {
    street: string;
    city: string;
    country: string;
    postalCode: string;
  };
  preferences?: {
    language: string;
    currency: string;
  }
}

ಗ್ರಾಹಕರ ಮಾಹಿತಿಯನ್ನು ಅಪ್‌ಡೇಟ್ ಮಾಡುವಾಗ, ನೀವು ಎಲ್ಲಾ ಫೀಲ್ಡ್‌ಗಳನ್ನು ಕಡ್ಡಾಯಗೊಳಿಸಲು ಬಯಸದಿರಬಹುದು. Partial ನಿಮಗೆ Customer ನ ಎಲ್ಲಾ ಪ್ರಾಪರ್ಟಿಗಳು ಐಚ್ಛಿಕವಾಗಿರುವ ಒಂದು ಟೈಪ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಅನುಮತಿಸುತ್ತದೆ:

type PartialCustomer = Partial<Customer>;

function updateCustomer(id: string, updates: PartialCustomer): void {
  // ... ಗ್ರಾಹಕರನ್ನು ಕೊಟ್ಟಿರುವ ID ಯೊಂದಿಗೆ ಅಪ್‌ಡೇಟ್ ಮಾಡಲು ಇಂಪ್ಲಿಮೆಂಟೇಶನ್
}

updateCustomer("123", { firstName: "John", lastName: "Doe" }); // ಮಾನ್ಯವಾಗಿದೆ
updateCustomer("456", { address: { city: "London" } }); // ಮಾನ್ಯವಾಗಿದೆ

Readonly

Readonly ಒಂದು ಟೈಪ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ, ಇದರಲ್ಲಿ T ನ ಎಲ್ಲಾ ಪ್ರಾಪರ್ಟಿಗಳು readonly ಆಗಿರುತ್ತವೆ, ಇನಿಶಿಯಲೈಸೇಶನ್ ನಂತರದ ಮಾರ್ಪಾಡನ್ನು ತಡೆಯುತ್ತದೆ. ಇದು ಬದಲಾಗದ ಸ್ಥಿತಿಯನ್ನು (immutability) ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಮೌಲ್ಯಯುತವಾಗಿದೆ.

ಉದಾಹರಣೆ:

ನಿಮ್ಮ ಜಾಗತಿಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಾಗಿ ಕಾನ್ಫಿಗರೇಶನ್ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಪರಿಗಣಿಸಿ:

interface AppConfig {
  apiUrl: string;
  theme: string;
  supportedLanguages: string[];
  version: string; // ಆವೃತ್ತಿ ಸೇರಿಸಲಾಗಿದೆ
}

const config: AppConfig = {
  apiUrl: "https://api.example.com",
  theme: "dark",
  supportedLanguages: ["en", "fr", "de", "es", "zh"],
  version: "1.0.0"
};

ಇನಿಶಿಯಲೈಸೇಶನ್ ನಂತರ ಕಾನ್ಫಿಗರೇಶನ್‌ನ ಆಕಸ್ಮಿಕ ಮಾರ್ಪಾಡನ್ನು ತಡೆಯಲು, ನೀವು Readonly ಅನ್ನು ಬಳಸಬಹುದು:

type ReadonlyAppConfig = Readonly<AppConfig>;

const readonlyConfig: ReadonlyAppConfig = {
  apiUrl: "https://api.example.com",
  theme: "dark",
  supportedLanguages: ["en", "fr", "de", "es", "zh"],
  version: "1.0.0"
};

// readonlyConfig.apiUrl = "https://newapi.example.com"; // ದೋಷ: 'apiUrl' ಗೆ ನಿಯೋಜಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ ಏಕೆಂದರೆ ಇದು ಓದಲು-ಮಾತ್ರ ಪ್ರಾಪರ್ಟಿ.

Pick

Pick ಎಂಬುದು T ನಿಂದ K ಪ್ರಾಪರ್ಟಿಗಳ ಗುಂಪನ್ನು ಆರಿಸುವ ಮೂಲಕ ಒಂದು ಟೈಪ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ, ಇಲ್ಲಿ K ಎಂಬುದು ನೀವು ಸೇರಿಸಲು ಬಯಸುವ ಪ್ರಾಪರ್ಟಿ ಹೆಸರುಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಸ್ಟ್ರಿಂಗ್ ಲಿಟರಲ್ ಟೈಪ್ಸ್‌ನ ಯೂನಿಯನ್ ಆಗಿದೆ.

ಉದಾಹರಣೆ:

ನಿಮ್ಮಲ್ಲಿ ವಿವಿಧ ಪ್ರಾಪರ್ಟಿಗಳೊಂದಿಗೆ Event ಇಂಟರ್ಫೇಸ್ ಇದೆ ಎಂದುಕೊಳ್ಳಿ:

interface Event {
  id: string;
  title: string;
  description: string;
  location: string;
  startTime: Date;
  endTime: Date;
  organizer: string;
  attendees: string[];
}

ನಿರ್ದಿಷ್ಟ ಡಿಸ್ಪ್ಲೇ ಕಾಂಪೊನೆಂಟ್‌ಗಾಗಿ ನಿಮಗೆ ಕೇವಲ title, location, ಮತ್ತು startTime ಅಗತ್ಯವಿದ್ದರೆ, ನೀವು Pick ಅನ್ನು ಬಳಸಬಹುದು:

type EventSummary = Pick<Event, "title" | "location" | "startTime">;

function displayEventSummary(event: EventSummary): void {
  console.log(`ಈವೆಂಟ್: ${event.title} ಸ್ಥಳ ${event.location} ದಿನಾಂಕ ${event.startTime}`);
}

Omit

Omit ಎಂಬುದು T ನಿಂದ K ಪ್ರಾಪರ್ಟಿಗಳ ಗುಂಪನ್ನು ಹೊರತುಪಡಿಸಿ ಒಂದು ಟೈಪ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ, ಇಲ್ಲಿ K ಎಂಬುದು ನೀವು ಹೊರತುಪಡಿಸಲು ಬಯಸುವ ಪ್ರಾಪರ್ಟಿ ಹೆಸರುಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಸ್ಟ್ರಿಂಗ್ ಲಿಟರಲ್ ಟೈಪ್ಸ್‌ನ ಯೂನಿಯನ್ ಆಗಿದೆ. ಇದು Pick ನ ವಿರುದ್ಧವಾಗಿದೆ.

ಉದಾಹರಣೆ:

ಅದೇ Event ಇಂಟರ್ಫೇಸ್ ಬಳಸಿ, ಹೊಸ ಈವೆಂಟ್‌ಗಳನ್ನು ರಚಿಸಲು ನೀವು ಒಂದು ಟೈಪ್ ಅನ್ನು ರಚಿಸಲು ಬಯಸಿದರೆ, ಸಾಮಾನ್ಯವಾಗಿ ಬ್ಯಾಕೆಂಡ್‌ನಿಂದ ರಚಿಸಲಾದ id ಪ್ರಾಪರ್ಟಿಯನ್ನು ಹೊರತುಪಡಿಸಲು ನೀವು ಬಯಸಬಹುದು:

type NewEvent = Omit<Event, "id">;

function createEvent(event: NewEvent): void {
  // ... ಹೊಸ ಈವೆಂಟ್ ರಚಿಸಲು ಇಂಪ್ಲಿಮೆಂಟೇಶನ್
}

Record

Record ಒಂದು ಆಬ್ಜೆಕ್ಟ್ ಟೈಪ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ, ಅದರ ಪ್ರಾಪರ್ಟಿ ಕೀಗಳು K ಮತ್ತು ಪ್ರಾಪರ್ಟಿ ಮೌಲ್ಯಗಳು T ಆಗಿರುತ್ತವೆ. K ಎಂಬುದು ಸ್ಟ್ರಿಂಗ್ ಲಿಟರಲ್ ಟೈಪ್ಸ್, ನಂಬರ್ ಲಿಟರಲ್ ಟೈಪ್ಸ್, ಅಥವಾ ಸಿಂಬಲ್‌ನ ಯೂನಿಯನ್ ಆಗಿರಬಹುದು. ಇದು ಡಿಕ್ಷನರಿಗಳು ಅಥವಾ ಮ್ಯಾಪ್‌ಗಳನ್ನು ರಚಿಸಲು ಪರಿಪೂರ್ಣವಾಗಿದೆ.

ಉದಾಹರಣೆ:

ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ಯೂಸರ್ ಇಂಟರ್ಫೇಸ್‌ಗಾಗಿ ನೀವು ಅನುವಾದಗಳನ್ನು ಸಂಗ್ರಹಿಸಬೇಕಾಗಿದೆ ಎಂದು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ. ನಿಮ್ಮ ಅನುವಾದಗಳಿಗಾಗಿ ಟೈಪ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ನೀವು Record ಅನ್ನು ಬಳಸಬಹುದು:

type Translations = Record<string, string>;

const enTranslations: Translations = {
  "hello": "Hello",
  "goodbye": "Goodbye",
  "welcome": "Welcome to our platform!"
};

const frTranslations: Translations = {
  "hello": "Bonjour",
  "goodbye": "Au revoir",
  "welcome": "Bienvenue sur notre plateforme !"
};

function translate(key: string, language: string): string {
  const translations = language === "en" ? enTranslations : frTranslations; //ಸರಳೀಕರಿಸಲಾಗಿದೆ
  return translations[key] || key; // ಅನುವಾದ ಸಿಗದಿದ್ದರೆ ಕೀಗೆ ಹಿಂತಿರುಗುವುದು
}

console.log(translate("hello", "en")); // ಔಟ್‌ಪುಟ್: Hello
console.log(translate("hello", "fr")); // ಔಟ್‌ಪುಟ್: Bonjour
console.log(translate("nonexistent", "en")); // ಔಟ್‌ಪುಟ್: nonexistent

Exclude

Exclude ಎಂಬುದು T ನಿಂದ U ಗೆ ನಿಯೋಜಿಸಬಹುದಾದ ಎಲ್ಲಾ ಯೂನಿಯನ್ ಸದಸ್ಯರನ್ನು ಹೊರತುಪಡಿಸಿ ಒಂದು ಟೈಪ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ. ಯೂನಿಯನ್‌ನಿಂದ ನಿರ್ದಿಷ್ಟ ಟೈಪ್‌ಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಲು ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ.

ಉದಾಹರಣೆ:

ನಿಮ್ಮಲ್ಲಿ ವಿವಿಧ ಈವೆಂಟ್ ಪ್ರಕಾರಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಟೈಪ್ ಇರಬಹುದು:

type EventType = "concert" | "conference" | "workshop" | "webinar";

ನೀವು "webinar" ಈವೆಂಟ್‌ಗಳನ್ನು ಹೊರತುಪಡಿಸುವ ಟೈಪ್ ರಚಿಸಲು ಬಯಸಿದರೆ, ನೀವು Exclude ಅನ್ನು ಬಳಸಬಹುದು:

type PhysicalEvent = Exclude<EventType, "webinar">;

// PhysicalEvent ಈಗ "concert" | "conference" | "workshop"

function attendPhysicalEvent(event: PhysicalEvent): void {
  console.log(`'${event}' ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ಭಾಗವಹಿಸಲಾಗುತ್ತಿದೆ`);
}

// attendPhysicalEvent("webinar"); // ದೋಷ: '"webinar"' ಪ್ರಕಾರದ ಆರ್ಗ್ಯುಮೆಂಟ್ '"concert" | "conference" | "workshop"' ಪ್ರಕಾರದ ಪ್ಯಾರಾಮೀಟರ್‌ಗೆ ನಿಯೋಜಿಸಲಾಗುವುದಿಲ್ಲ.

attendPhysicalEvent("concert"); // ಮಾನ್ಯವಾಗಿದೆ

Extract

Extract ಎಂಬುದು T ನಿಂದ U ಗೆ ನಿಯೋಜಿಸಬಹುದಾದ ಎಲ್ಲಾ ಯೂನಿಯನ್ ಸದಸ್ಯರನ್ನು ಹೊರತೆಗೆಯುವ ಮೂಲಕ ಒಂದು ಟೈಪ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ. ಇದು Exclude ನ ವಿರುದ್ಧವಾಗಿದೆ.

ಉದಾಹರಣೆ:

ಅದೇ EventType ಬಳಸಿ, ನೀವು ವೆಬಿನಾರ್ ಈವೆಂಟ್ ಪ್ರಕಾರವನ್ನು ಹೊರತೆಗೆಯಬಹುದು:

type OnlineEvent = Extract<EventType, "webinar">;

// OnlineEvent ಈಗ "webinar"

function attendOnlineEvent(event: OnlineEvent): void {
  console.log(`ಆನ್‌ಲೈನ್‌ನಲ್ಲಿ '${event}' ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ಭಾಗವಹಿಸಲಾಗುತ್ತಿದೆ`);
}

attendOnlineEvent("webinar"); // ಮಾನ್ಯವಾಗಿದೆ
// attendOnlineEvent("concert"); // ದೋಷ: '"concert"' ಪ್ರಕಾರದ ಆರ್ಗ್ಯುಮೆಂಟ್ '"webinar"' ಪ್ರಕಾರದ ಪ್ಯಾರಾಮೀಟರ್‌ಗೆ ನಿಯೋಜಿಸಲಾಗುವುದಿಲ್ಲ.

NonNullable

NonNullable ಎಂಬುದು T ನಿಂದ null ಮತ್ತು undefined ಅನ್ನು ಹೊರತುಪಡಿಸಿ ಒಂದು ಟೈಪ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ.

ಉದಾಹರಣೆ:

type MaybeString = string | null | undefined;

type DefinitelyString = NonNullable<MaybeString>;

// DefinitelyString ಈಗ string

function processString(str: DefinitelyString): void {
  console.log(str.toUpperCase());
}

// processString(null); // ದೋಷ: 'null' ಪ್ರಕಾರದ ಆರ್ಗ್ಯುಮೆಂಟ್ 'string' ಪ್ರಕಾರದ ಪ್ಯಾರಾಮೀಟರ್‌ಗೆ ನಿಯೋಜಿಸಲಾಗುವುದಿಲ್ಲ.
// processString(undefined); // ದೋಷ: 'undefined' ಪ್ರಕಾರದ ಆರ್ಗ್ಯುಮೆಂಟ್ 'string' ಪ್ರಕಾರದ ಪ್ಯಾರಾಮೀಟರ್‌ಗೆ ನಿಯೋಜಿಸಲಾಗುವುದಿಲ್ಲ.
processString("hello"); // ಮಾನ್ಯವಾಗಿದೆ

ReturnType

ReturnType ಎಂಬುದು ಫಂಕ್ಷನ್ T ಯ ರಿಟರ್ನ್ ಟೈಪ್ ಅನ್ನು ಒಳಗೊಂಡಿರುವ ಒಂದು ಟೈಪ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ.

ಉದಾಹರಣೆ:

function greet(name: string): string {
  return `Hello, ${name}!`;
}

type Greeting = ReturnType<typeof greet>;

// Greeting ಈಗ string

const message: Greeting = greet("World");

console.log(message);

Parameters

Parameters ಎಂಬುದು ಫಂಕ್ಷನ್ ಟೈಪ್ T ಯ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳ ಟೈಪ್‌ಗಳಿಂದ ಒಂದು ಟಪಲ್ ಟೈಪ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ.

ಉದಾಹರಣೆ:

function logEvent(eventName: string, eventData: object): void {
  console.log(`ಈವೆಂಟ್: ${eventName}`, eventData);
}

type LogEventParams = Parameters<typeof logEvent>;

// LogEventParams ಈಗ [eventName: string, eventData: object]

const params: LogEventParams = ["user_login", { userId: "123", timestamp: Date.now() }];

logEvent(...params);

ConstructorParameters

ConstructorParameters ಎಂಬುದು ಒಂದು ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಫಂಕ್ಷನ್ ಟೈಪ್ T ಯ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳ ಟೈಪ್‌ಗಳಿಂದ ಒಂದು ಟಪಲ್ ಅಥವಾ ಅರೇ ಟೈಪ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ. ಇದು ಒಂದು ಕ್ಲಾಸ್‌ನ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ಗೆ ಪಾಸ್ ಮಾಡಬೇಕಾದ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳ ಟೈಪ್‌ಗಳನ್ನು ನಿರ್ಣಯಿಸುತ್ತದೆ.

ಉದಾಹರಣೆ:

class Greeter {
  greeting: string;

  constructor(message: string) {
    this.greeting = message;
  }

  greet() {
    return "Hello, " + this.greeting;
  }
}


type GreeterParams = ConstructorParameters<typeof Greeter>;

// GreeterParams ಈಗ [message: string]

const paramsGreeter: GreeterParams = ["World"];
const greeterInstance = new Greeter(...paramsGreeter);

console.log(greeterInstance.greet()); // ಔಟ್‌ಪುಟ್: Hello, World

Required

Required ಎಂಬುದು T ಯ ಎಲ್ಲಾ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಕಡ್ಡಾಯವಾಗಿ ಹೊಂದಿರುವ ಒಂದು ಟೈಪ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ. ಇದು ಎಲ್ಲಾ ಐಚ್ಛಿಕ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಕಡ್ಡಾಯಗೊಳಿಸುತ್ತದೆ.

ಉದಾಹರಣೆ:

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

type RequiredUserProfile = Required<UserProfile>;

// RequiredUserProfile ಈಗ { name: string; age: number; email: string; }

const completeProfile: RequiredUserProfile = {
  name: "Alice",
  age: 30,
  email: "alice@example.com"
};

// const incompleteProfile: RequiredUserProfile = { name: "Bob" }; // ದೋಷ: 'age' ಪ್ರಾಪರ್ಟಿ '{ name: string; }' ಪ್ರಕಾರದಲ್ಲಿ ಕಾಣೆಯಾಗಿದೆ ಆದರೆ 'Required' ನಲ್ಲಿ ಕಡ್ಡಾಯವಾಗಿದೆ.

ಸುಧಾರಿತ ಯುಟಿಲಿಟಿ ಟೈಪ್ಸ್

ಟೆಂಪ್ಲೇಟ್ ಲಿಟರಲ್ ಟೈಪ್ಸ್

ಟೆಂಪ್ಲೇಟ್ ಲಿಟರಲ್ ಟೈಪ್ಸ್ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಸ್ಟ್ರಿಂಗ್ ಲಿಟರಲ್ ಟೈಪ್ಸ್, ನಂಬರ್ ಲಿಟರಲ್ ಟೈಪ್ಸ್, ಮತ್ತು ಹೆಚ್ಚಿನದನ್ನು ಸಂಯೋಜಿಸುವ ಮೂಲಕ ಹೊಸ ಸ್ಟ್ರಿಂಗ್ ಲಿಟರಲ್ ಟೈಪ್ಸ್ ಅನ್ನು ರಚಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಇದು ಶಕ್ತಿಯುತ ಸ್ಟ್ರಿಂಗ್-ಆಧಾರಿತ ಟೈಪ್ ಮ್ಯಾನಿಪ್ಯುಲೇಶನ್ ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ.

ಉದಾಹರಣೆ:

type HTTPMethod = "GET" | "POST" | "PUT" | "DELETE";
type APIEndpoint = `/api/users` | `/api/products`;

type RequestURL = `${HTTPMethod} ${APIEndpoint}`;

// RequestURL is now "GET /api/users" | "POST /api/users" | ...

function makeRequest(url: RequestURL): void {
  console.log(`${url} ಗೆ ವಿನಂತಿ ಮಾಡಲಾಗುತ್ತಿದೆ`);
}

makeRequest("GET /api/users"); // ಮಾನ್ಯವಾಗಿದೆ
// makeRequest("INVALID /api/users"); // ದೋಷ

ಕಂಡಿಷನಲ್ ಟೈಪ್ಸ್

ಕಂಡಿಷನಲ್ ಟೈಪ್ಸ್ ಒಂದು ಷರತ್ತನ್ನು ಆಧರಿಸಿ ಟೈಪ್‌ಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ, ಇದನ್ನು ಟೈಪ್ ಸಂಬಂಧವಾಗಿ ವ್ಯಕ್ತಪಡಿಸಲಾಗುತ್ತದೆ. ಅವು ಟೈಪ್ ಮಾಹಿತಿಯನ್ನು ಹೊರತೆಗೆಯಲು infer ಕೀವರ್ಡ್ ಅನ್ನು ಬಳಸುತ್ತವೆ.

ಉದಾಹರಣೆ:

type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;

// T ಒಂದು Promise ಆಗಿದ್ದರೆ, ಟೈಪ್ U ಆಗಿರುತ್ತದೆ; ಇಲ್ಲದಿದ್ದರೆ, ಟೈಪ್ T ಆಗಿರುತ್ತದೆ.

async function fetchData(): Promise<number> {
  return 42;
}


type Data = UnwrapPromise<ReturnType<typeof fetchData>>;

// Data ಈಗ number

function processData(data: Data): void {
  console.log(data * 2);
}

processData(await fetchData());

interface FormData {
  firstName: string;
  lastName: string;
  email: string;
  country: string; // ಕಡ್ಡಾಯ
  city?: string; // ಐಚ್ಛಿಕ
  postalCode?: string;
  newsletterSubscription?: boolean;
}

// ಆರಂಭಿಕ ಫಾರ್ಮ್ ಮೌಲ್ಯಗಳು (ಐಚ್ಛಿಕ ಫೀಲ್ಡ್‌ಗಳು)
type InitialFormValues = Partial<FormData>;

// ಅಪ್‌ಡೇಟ್ ಮಾಡಿದ ಫಾರ್ಮ್ ಮೌಲ್ಯಗಳು (ಕೆಲವು ಫೀಲ್ಡ್‌ಗಳು ಕಾಣೆಯಾಗಿರಬಹುದು)
type UpdatedFormValues = Partial<FormData>;

// ಸಲ್ಲಿಕೆಗೆ ಕಡ್ಡಾಯವಾದ ಫೀಲ್ಡ್‌ಗಳು
type RequiredForSubmission = Required<Pick<FormData, 'firstName' | 'lastName' | 'email' | 'country'>>;

// ನಿಮ್ಮ ಫಾರ್ಮ್ ಕಾಂಪೊನೆಂಟ್‌ಗಳಲ್ಲಿ ಈ ಟೈಪ್‌ಗಳನ್ನು ಬಳಸಿ
function initializeForm(initialValues: InitialFormValues): void { }
function updateForm(updates: UpdatedFormValues): void {}
function submitForm(data: RequiredForSubmission): void {}


const initialForm: InitialFormValues = { newsletterSubscription: true };

const updateFormValues: UpdatedFormValues = {
    firstName: "John",
    lastName: "Doe"
};

// const submissionData: RequiredForSubmission = { firstName: "test", lastName: "test", email: "test" }; // ದೋಷ: 'country' ಕಾಣೆಯಾಗಿದೆ
const submissionData: RequiredForSubmission = { firstName: "test", lastName: "test", email: "test", country: "USA" }; //ಸರಿ

interface APIResponse {
  user_id: string;
  first_name: string;
  last_name: string;
  email_address: string;
  profile_picture_url: string;
  is_active: boolean;
}

// API ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಹೆಚ್ಚು ಓದಬಲ್ಲ ಫಾರ್ಮ್ಯಾಟ್‌ಗೆ ಪರಿವರ್ತಿಸಿ
type UserData = {
  id: string;
  fullName: string;
  email: string;
  avatar: string;
  active: boolean;
};

function transformApiResponse(response: APIResponse): UserData {
  return {
    id: response.user_id,
    fullName: `${response.first_name} ${response.last_name}`,
    email: response.email_address,
    avatar: response.profile_picture_url,
    active: response.is_active
  };
}

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


// ನೀವು ಈ ರೀತಿ ಟೈಪ್ ಅನ್ನು ಜಾರಿಗೊಳಿಸಬಹುದು:

function saferTransformApiResponse(response: APIResponse): UserData {
    const {user_id, first_name, last_name, email_address, profile_picture_url, is_active} = response;
    const transformed: UserData = {
        id: user_id,
        fullName: `${first_name} ${last_name}`,
        email: email_address,
        avatar: profile_picture_url,
        active: is_active
    };

    return transformed;
}

interface AppSettings {
  theme: "light" | "dark";
  language: string;
  notificationsEnabled: boolean;
  apiUrl?: string; // ವಿಭಿನ್ನ ಪರಿಸರಗಳಿಗಾಗಿ ಐಚ್ಛಿಕ API URL
  timeout?: number;  //ಐಚ್ಛಿಕ
}

// ಡೀಫಾಲ್ಟ್ ಸೆಟ್ಟಿಂಗ್‌ಗಳು
const defaultSettings: AppSettings = {
  theme: "light",
  language: "en",
  notificationsEnabled: true
};

// ಬಳಕೆದಾರರ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಡೀಫಾಲ್ಟ್ ಸೆಟ್ಟಿಂಗ್‌ಗಳೊಂದಿಗೆ ವಿಲೀನಗೊಳಿಸುವ ಫಂಕ್ಷನ್
function mergeSettings(userSettings: Partial<AppSettings>): AppSettings {
  return { ...defaultSettings, ...userSettings };
}

// ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ವಿಲೀನಗೊಂಡ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಬಳಸಿ
const mergedSettings = mergeSettings({ theme: "dark", apiUrl: "https://customapi.example.com" });
console.log(mergedSettings);