2026 के लिए शीर्ष 40 TypeScript इंटरव्यू प्रश्न और उत्तर

TypeScript एक समय JavaScript का सीमित-प्रचलित सुपरसैट था, जो अब आधुनिक वेब डेवलपमेंट की एक मुख्य भाषा बन चुका है।

वेब एप्लिकेशंस पर काम करते हुए, मैंने प्रत्यक्ष रूप से देखा है कि स्ट्रॉन्ग टाइपिंग और मेन्टेनेबिलिटी कैसे बग्स कम करती है और टीमों के बीच सहयोग में सुधार करती है।

TypeScript यह सब प्रदान करता है, यही कारण है कि यह आधुनिक डेवलपमेंट के लिए उद्योग मानक बन गया है।

Microsoft (इसके निर्माता) से लेकर Google, Airbnb, और Netflix तक—कई संगठन React, Angular, और Node.js जैसे फ़्रेमवर्क में लिखे उत्पादों को TypeScript से संचालित करते हैं।

अपने काम में, मैंने अक्सर नौकरी विज्ञापनों में देखा है कि TypeScript में दक्षता एक मुख्य आवश्यकता के रूप में सूचीबद्ध होती है, न कि केवल एक वैकल्पिक कौशल के रूप में।

स्वयं TypeScript का उपयोग करने के बाद, यह कहना सुरक्षित है कि इसके टाइप्स, इंटरफेस, और उन्नत फीचर्स को समझना किसी भी डेवलपर के लिए तकनीकी साक्षात्कार की तैयारी में आवश्यक है।

बेसिक TypeScript इंटरव्यू प्रश्न

आइए अब कुछ सामान्य TypeScript इंटरव्यू प्रश्न देखें और समझें कि वे कोड सेफ़्टी और स्पष्टता से कैसे जुड़े हैं।

1. JavaScript के बजाय TypeScript क्यों?

TypeScript स्थिर टाइपिंग और कम्पाइल-टाइम एरर जाँच जोड़ता है, जो डेवलपर्स को शुरुआती चरण में बग पकड़ने और कोडबेस को अधिक पूर्वानुमेय बनाने में मदद करता है।

यह बेहतर मेन्टेनेबिलिटी और स्केलेबिलिटी सुनिश्चित करता है।

2. TypeScript किन समस्याओं को हल करता है?

TypeScript, JavaScript की टाइप सेफ़्टी, स्केलेबिलिटी, और रीडेबिलिटी से जुड़ी कमजोरियों को संबोधित करता है।

स्पष्ट टाइप डेफिनिशन लागू करने से सूक्ष्म रनटाइम बग्स रुकते हैं और रीफैक्टरिंग सुरक्षित होती है।

3. TypeScript में स्टैटिक टाइपिंग के प्रमुख लाभ क्या हैं?

स्टैटिक टाइपिंग कोड की विश्वसनीयता, ऑटो-कम्प्लीशन, और डेवलपर प्रोडक्टिविटी में सुधार लाती है।

यह टाइप एरर्स का शुरुआती पता लगाने में मदद करती है और IDEs को बेहतर टूलिंग सपोर्ट देने देती है।

4. टाइप एनोटेशंस क्या हैं और ये उपयोगी क्यों हैं?

टाइप एनोटेशंस डेवलपर्स को वेरिएबल टाइप्स को स्पष्ट रूप से घोषित करने देती हैं।

इससे कोड की पठनीयता बढ़ती है और रनटाइम एरर्स कम होते हैं।

यहाँ एक उदाहरण है:

let username: string = "DataCamper";
let age: number = 25;
let isAdmin: boolean = true;संचालित द्वारा

ऊपर दिए गए कोड में, कम्पाइलर सुनिश्चित करता है कि हर वेरिएबल को केवल सही टाइप ही असाइन हो।

उदाहरण के लिए, यदि आप age में कोई string असाइन करने की कोशिश करेंगे, तो TypeScript एरर फेंकेगा—जो गलतियों को जल्दी पकड़ने में मदद करता है।

स्पष्ट टाइपिंग विशेष रूप से फ़ंक्शन पैरामीटर्स, रिटर्न टाइप्स और API कॉन्ट्रैक्ट्स के लिए महत्वपूर्ण है, क्योंकि यह अन्य डेवलपर्स तक अपेक्षाएँ स्पष्ट रूप से पहुँचाती है।

5. TypeScript में टाइप इन्फेरेंस क्या है?

TypeScript असाइन की गई वैल्यू के आधार पर अपने आप टाइप्स का अनुमान लगा सकता है।

इसका मतलब है कि आपको हमेशा टाइप स्पष्ट रूप से घोषित करने की आवश्यकता नहीं होती—TypeScript खुद तय कर लेता है।

यहाँ एक उदाहरण है:

let count = 10;  // inferred as number
count = "hello"; // Error: Type 'string' is not assignable to type 'number'संचालित द्वारा

इस उदाहरण में, TypeScript ने प्रारंभिक वैल्यू के आधार पर count को number माना, इसलिए बाद में string असाइन करने पर कम्पाइल-टाइम एरर आता है।

टाइप इन्फेरेंस के लिए श्रेष्ठ अभ्यास:

एक्सपोर्टेड फ़ंक्शंस, क्लासेज़, और इंटरफेसेज़ के लिए स्पष्ट टाइप दें ताकि कॉन्ट्रैक्ट्स स्पष्ट रहें।
स्थानीय वेरिएबल्स के लिए, जहाँ टाइप साफ़ है, इन्फेरेंस होने दें।
जब तक बेहद आवश्यक न हो, any का उपयोग न करें, क्योंकि यह TypeScript की सुरक्षा सुविधाएँ निष्क्रिय कर देता है।

6. TypeScript ऐरेज़, ट्यूपल्स, और एनम्स को कैसे संभालता है?

TypeScript ऐरेज़, ट्यूपल्स, और एनम्स पर सख्त टाइप लागू करने देता है ताकि स्पष्टता बढ़े और रनटाइम एरर्स से बचा जा सके।

यहाँ typed array का उदाहरण है:

let scores: number[] = [95, 80, 85];
scores.push(100); // OK
scores.push("A+"); // Errorसंचालित द्वारा

Typed arrays सुनिश्चित करते हैं कि ऐरे के सभी तत्व एक ही टाइप का पालन करें।

यहाँ tuple का उदाहरण है:

let user: [string, number] = ["Don", 25];संचालित द्वारा

ट्यूपल्स निश्चित-लंबाई वाले ऐरे परिभाषित करते हैं जिनमें हर पोज़िशन के लिए विशिष्ट टाइप होता है।

ये तब उपयोगी होते हैं जब क्रम और टाइप, दोनों मायने रखते हों।

यहाँ enum का उदाहरण है:

enum Status {
  Active,
  Inactive,
  Pending,
}
let currentStatus: Status = Status.Active;संचालित द्वारा

Enums नामित स्थिरांक प्रदान करते हैं, जिससे रीडेबिलिटी बढ़ती है और अमान्य वैल्यूज़ घटती हैं।

ये विशेष रूप से स्टेटस कोड्स, रोल्स, और कॉन्फ़िगरेशन विकल्पों में उपयोगी हैं।

7. any, unknown, और never टाइप्स में क्या अंतर है?

निम्न तालिका TypeScript में any, unknown, और never टाइप्स के प्रमुख अंतरों को दर्शाती है।

Type	Description
any	टाइप जाँच को पूरी तरह निष्क्रिय कर देता है; किसी भी वैल्यू की अनुमति देता है।
unknown	any का सुरक्षित विकल्प; उपयोग से पहले टाइप जाँचना आवश्यक है।
never	ऐसी वैल्यूज़ का प्रतिनिधित्व करता है जो कभी उत्पन्न नहीं होतीं (जैसे हमेशा एरर फेंकने वाले फ़ंक्शंस)।

यहाँ एक उदाहरण है:

function fail(): never {
  throw new Error("Something went wrong");
}संचालित द्वारा

टिप: लचीलेपन को बनाए रखते हुए टाइप सेफ़्टी के लिए any के बजाय unknown को प्राथमिकता दें।

8. TypeScript में null और undefined में क्या अंतर है?

null और undefined के प्रमुख अंतर:

undefined का मतलब है कि वेरिएबल डिक्लेयर किया गया है, पर उसे कोई वैल्यू असाइन नहीं हुई।
null एक स्पष्ट वैल्यू है, जिसका अर्थ है “कोई वैल्यू नहीं”。

TypeScript का strictNullChecks मोड इन्हें अलग टाइप्स की तरह ट्रीट करता है, जिससे null-सम्बंधी बग्स से बचाव होता है।

यहाँ एक उदाहरण है:

let a: string | null = null;
let b: string | undefined = undefined;संचालित द्वारा

9. strict कम्पाइलर ऑप्शन क्या करता है?

strict फ़्लैग TypeScript की सभी सख्त टाइप-जाँच नियमों को सक्षम करता है, जैसे:

strictNullChecks: null और undefined वैल्यूज़ को तब तक असाइन होने से रोकता है जब तक उन्हें स्पष्ट रूप से अनुमति न दी जाए, जिससे रनटाइम null रेफ़रेंस एरर्स से बचाव होता है।
noImplicitAny: सभी वेरिएबल्स के लिए स्पष्ट या inferred टाइप की आवश्यकता होती है, जिससे TypeScript के डिफ़ॉल्ट रूप से any मान लेने से रोका जाता है।
strictFunctionTypes: फ़ंक्शन टाइप संगतता के लिए कड़े नियम लागू करता है, जिससे पैरामीटर्स और रिटर्न टाइप्स की असंगतियाँ पकड़ी जा सकें।
strictBindCallApply: सुनिश्चित करता है कि bind, call, और apply मेथड्स फ़ंक्शंस के सही आर्ग्यूमेंट टाइप्स के साथ ही उपयोग हों।

यह सुरक्षित, अधिक पूर्वानुमेय कोड सुनिश्चित करता है और सूक्ष्म बग्स को शुरुआती चरण में पकड़ लेता है।

TypeScript टाइप सिस्टम इंटरव्यू प्रश्न

अब उन प्रमुख TypeScript टाइप सिस्टम अवधारणाओं पर नज़र डालते हैं, जिन पर तकनीकी साक्षात्कारों में अक्सर चर्चा होती है।

10. TypeScript में interfaces और type aliases में क्या अंतर है?

Interfaces और type aliases दोनों ऑब्जेक्ट्स के शेप का वर्णन करते हैं, लेकिन उनका उद्देश्य थोड़ा अलग होता है।

Interfaces को extends के साथ बढ़ाया जा सकता है, जो इन्हें हायरार्किकल ऑब्जेक्ट मॉडल्स के लिए उपयुक्त बनाता है।

Type aliases यूनियंस, इंटरसेक्शंस, प्रिमिटिव्स, और अधिक जटिल समग्र टाइप्स का प्रतिनिधित्व कर सकते हैं।

यहाँ एक उदाहरण है:

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

type Employee = {
  name: string;
  department: string;
};संचालित द्वारा

जब ऑब्जेक्ट शेप्स या क्लास कॉन्ट्रैक्ट्स परिभाषित करने हों, तो interfaces का उपयोग करें।

जब आपको यूनियंस या इंटरसेक्शंस जैसे लचीले, संयोज्य टाइप्स चाहिए हों, तो type aliases का उपयोग करें।

11. Union और Intersection टाइप्स क्या हैं?

यूनियन टाइप्स किसी वेरिएबल को एकाधिक संभावित टाइप्स रखने देते हैं, जबकि इंटरसेक्शन टाइप्स कई टाइप्स को एक में संयोजित करते हैं।

यहाँ यूनियन का उदाहरण है:

let id: string | number;
id = ‘abc’; // OK
id = 123; // OKसंचालित द्वारा

यहाँ इंटरसेक्शन का उदाहरण है:

type Admin = { name: string };
type Permissions = { canEdit: boolean };
type AdminUser = Admin & Permissions;संचालित द्वारा

यूनियन टाइप्स अक्सर फ़ंक्शन पैरामीटर्स में उपयोग होते हैं।

इंटरसेक्शन टाइप्स जटिल ऑब्जेक्ट कंपोज़िशन्स में सामान्य हैं।

12. टाइप नैरोइंग क्या है, और टाइप गार्ड्स कैसे काम करते हैं?

टाइप नैरोइंग नियंत्रण प्रवाह के आधार पर TypeScript को अधिक विशिष्ट टाइप का अनुमान लगाने देती है।

यहाँ एक उदाहरण है:

function printId(id: string | number) {
  if (typeof id === "string") {
    console.log(id.toUpperCase());
  } else {
    console.log(id.toFixed());
  }
}संचालित द्वारा

टाइप गार्ड्स विशेष कार्रवाइयों से पहले टाइप सत्यापित करके सुरक्षित रनटाइम ऑपरेशंस सुनिश्चित करते हैं।

आप उपयोग कर सकते हैं:

typeof: प्रिमिटिव्स के लिए
instanceof: क्लासेज़ के लिए
Custom type guards: param is Type सिन्टैक्स के साथ

टाइप गार्ड्स टाइप सेफ़्टी बढ़ाते हैं और रनटाइम एरर्स घटाते हैं।

13. Literal टाइप्स और Discriminated Unions क्या हैं?

लिटरल टाइप्स किसी वेरिएबल को पूर्व-परिभाषित वैल्यूज़ के एक विशिष्ट सेट तक सीमित करते हैं।

यहाँ एक उदाहरण है:

let direction: "up" | "down" | "left" | "right";संचालित द्वारा

डिस्क्रिमिनेटेड यूनियंस, पैटर्न मैचिंग के लिए लिटरल टाइप्स को ऑब्जेक्ट वैरिएंट्स के साथ जोड़ते हैं।

यहाँ एक उदाहरण है:

type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "square"; side: number };

function area(shape: Shape): number {
  if (shape.kind === "circle") return Math.PI * shape.radius ** 2;
  return shape.side ** 2;
}संचालित द्वारा

डिस्क्रिमिनेटेड यूनियंस ऑब्जेक्ट टाइप्स पर सुरक्षित ब्रांचिंग की सुविधा देती हैं और जटिल एप्लिकेशंस में लॉजिक को सरल बनाती हैं।

14. TypeScript में keyof, typeof, और in क्या हैं?

ये ऑपरेटर्स टाइप-स्तरीय रिफ्लेक्शन की शक्तिशाली क्षमता प्रदान करते हैं।

Keyof: किसी टाइप की प्रॉपर्टी नेम्स निकालता है
typeof: किसी वैल्यू का टाइप प्राप्त करता है
in: मैप्ड टाइप्स में उपयोग होता है

यहाँ एक उदाहरण है:

type Keys = keyof User; // "name" | "age"
const person = { name: "Alice", age: 25 };
type PersonType = typeof person; // { name: string; age: number }संचालित द्वारा

15. TypeScript में Index Signatures क्या हैं?

इंडेक्स सिग्नेचर्स डायनेमिक कीज़ वाले ऑब्जेक्ट्स की अनुमति देते हैं।

यहाँ एक उदाहरण है:

interface Errors {
  [key: string]: string;
}

const messages: Errors = {
  email: "Invalid email",
  password: "Required"
};संचालित द्वारा

इन्हें डिक्शनरीज़, मैप-जैसे ऑब्जेक्ट्स, या डायनेमिक कॉन्फ़िगरेशन पैटर्न्स के लिए उपयोग किया जाता है।

16. TypeScript में Structural Typing क्या है?

स्ट्रक्चरल टाइपिंग (डक टाइपिंग) का अर्थ है कि टाइप्स का मिलान उनके नाम से नहीं, बल्कि उनके स्ट्रक्चर से होता है।

यहाँ एक उदाहरण है:

interface Point { x: number; y: number; }
let p = { x: 10, y: 20, z: 30 };
let q: Point = p; // OK because structural matchसंचालित द्वारा

यह TypeScript को लचीला बनाता है और JavaScript पैटर्न्स के साथ अच्छी तरह काम करता है।

17. TypeScript में Declaration Merging क्या है?

डिक्लेरेशन मर्जिंग तब होता है जब TypeScript एक ही नाम वाली एकाधिक घोषणाओं को जोड़ देता है।

यहाँ दो इंटरफेसेज़ को मर्ज करने का उदाहरण है:

interface User { name: string; }
interface User { age: number; }
const u: User = { name: "Rob", age: 30 }; // mergedसंचालित द्वारा

यह थर्ड-पार्टी टाइप्स को बढ़ाने या लाइब्रेरीज़ को ऑगमेंट करने में उपयोगी है।

एडवांस्ड TypeScript इंटरव्यू प्रश्न

यहाँ उन्नत TypeScript इंटरव्यू प्रश्न और उनके उत्तर हैं।

18. TypeScript में Generics क्या हैं और ये उपयोगी क्यों हैं?

Generics आपको पुन: प्रयोज्य, टाइप-सेफ़ फ़ंक्शंस और क्लासेज़ लिखने देते हैं जो कई डेटा टाइप्स के साथ काम कर सकें।

यहाँ एक जनरिक फ़ंक्शन का उदाहरण है:

function identity<T>(value: T): T {
  return value;
}

let output = identity<string>("DataCamp");
let outputNumber = identity<number>(42);संचालित द्वारा

यहाँ एक जनरिक क्लास का उदाहरण है:

class Box<T> {
  content: T;
  constructor(content: T) {
    this.content = content;
  }
  getContent(): T {
    return this.content;
  }
}

let stringBox = new Box("Hello");
let numberBox = new Box(123);संचालित द्वारा

श्रेष्ठ अभ्यास:

<T>, <K, V>, या डोमेन-विशिष्ट जैसे वर्णनात्मक नामों का उपयोग करें।
अनावश्यक जटिलता से बचें।
स्वीकार्य टाइप्स को सीमित करने के लिए constraints (extends) का उपयोग करें।

Generics डुप्लिकेशन घटाकर और सुसंगत टाइपिंग लागू करके कोड रीउसएबिलिटी बढ़ाते हैं।

19. TypeScript Utility Types क्या हैं और इनका उपयोग कैसे होता है?

TypeScript मौजूदा टाइप्स को प्रभावी ढंग से संशोधित और परिवर्तित करने के लिए बिल्ट-इन यूटिलिटी टाइप्स प्रदान करता है।

यहाँ एक उदाहरण है:

interface Todo {
  title: string;
  description: string;
  completed: boolean;
}

type PartialTodo = Partial<Todo>; // all properties optional
type RequiredTodo = Required<Todo>; // all properties required
type TodoPreview = Pick<Todo, "title" | "completed">; // select specific properties
type TodoWithoutDescription = Omit<Todo, "description">; // exclude propertiesसंचालित द्वारा

ये विशेष रूप से API रिस्पॉन्सेज़, फ़ॉर्म्स, या कंपोनेंट प्रॉप्स के साथ काम करते समय उपयोगी हैं।

टिप: जहाँ संभव हो, यूटिलिटी टाइप्स का लाभ उठाएँ ताकि कोड सरल और टाइप-कंसिस्टेंसी बेहतर हो।

20. TypeScript में Conditional और Mapped टाइप्स क्या हैं?

कंडीशनल टाइप्स आपको टाइप्स के बीच संबंधों के आधार पर टाइप-स्तरीय लॉजिक परिभाषित करने देते हैं।

यहाँ एक उदाहरण है:

type IsString<T> = T extends string ? "yes" : "no";
type Result1 = IsString<string>; // "yes"
type Result2 = IsString<number>; // "no"संचालित द्वारा

मैप्ड टाइप्स आपको किसी टाइप की सभी प्रॉपर्टीज़ को एक साथ ट्रांसफ़ॉर्म करने देते हैं।

यहाँ एक उदाहरण है:

type ReadonlyTodo = {
  readonly [K in keyof Todo]: Todo[K];
};

type OptionalTodo = {
  [K in keyof Todo]?: Todo[K];
};संचालित द्वारा

मुख्य अंतर:

keyof किसी टाइप की प्रॉपर्टी नेम्स निकालता है।
typeof किसी वेरिएबल या ऑब्जेक्ट का टाइप देता है। इन्हें मिलाकर आप डायनेमिक टाइप मैनीपुलेशन और सुरक्षित रीफैक्टरिंग कर सकते हैं।

21. infer कीवर्ड TypeScript में किस लिए इस्तेमाल होता है?

infer आपको कंडीशनल टाइप के अंदर किसी टाइप को निकालने (infer करने) देता है।

यहाँ एक उदाहरण है:

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

type R = ReturnType<() => number>; // numberसंचालित द्वारा

आम तौर पर उन्नत यूटिलिटीज़ और जनरिक टाइप ट्रांसफ़ॉर्मेशंस में उपयोग होता है।

22. Template Literal टाइप्स क्या हैं?

टेम्पलेट लिटरल टाइप्स इंटरपोलेशन का उपयोग करके स्ट्रिंग टाइप्स बनाते हैं।

यहाँ एक उदाहरण है:

type Event = ${string}Changed;
let e: Event = "nameChanged"; // OKसंचालित द्वारा

यह इन कार्यों में उपयोगी है:

इवेंट नेमिंग
CSS क्लास पैटर्न्स
API रूट पैटर्न्स

23. TypeScript में satisfies और as const क्या हैं?

satisfies सुनिश्चित करता है कि कोई वैल्यू किसी टाइप को संतुष्ट करती है, लेकिन उसकी अपनी लिटरल टाइप बनी रहती है।

उदाहरण:

const config = {
  mode: "dark",
  version: 1
} satisfies { mode: string; version: number };संचालित द्वारा

as const सभी प्रॉपर्टीज़ को read-only और literal बना देता है।

उदाहरण:

const directions = ["up", "down"] as const;
// type is readonly ["up", "down"]संचालित द्वारा

satisfies और as const दोनों React, कॉन्फ़िग ऑब्जेक्ट्स, और डिस्क्रिमिनेटेड यूनियंस में उपयोगी हैं।

TypeScript फ़ंक्शंस और ऑब्जेक्ट्स इंटरव्यू प्रश्न

इस सेक्शन में हम फ़ंक्शंस और ऑब्जेक्ट्स से जुड़े TypeScript इंटरव्यू प्रश्नों का अन्वेषण करेंगे।

24. TypeScript में फ़ंक्शन ओवरलोडिंग कैसे काम करती है?

फ़ंक्शन ओवरलोडिंग आपको अलग-अलग आर्ग्यूमेंट टाइप्स या पैटर्न्स के लिए कई फ़ंक्शन सिग्नेचर्स परिभाषित करने देती है।

यहाँ एक उदाहरण है:

function add(a: number, b: number): number;
function add(a: string, b: string): string;
function add(a: any, b: any): any {
  return a + b;
}

let sumNumbers = add(5, 10); // 15
let sumStrings = add("Hello, ", "World"); // "Hello, World"संचालित द्वारा

श्रेष्ठ अभ्यास:

सभी संभावित ओवरलोड्स को इम्प्लिमेंटेशन से पहले घोषित करें।
कई टाइप्स को सुरक्षित रूप से संभालने के लिए टाइप गार्ड्स का उपयोग करें।

25. TypeScript में Optional और Rest पैरामीटर्स क्या हैं?

ऑप्शनल और रेस्ट पैरामीटर्स फ़ंक्शंस को अधिक लचीला और अभिव्यंजक बनाते हैं।

यहाँ एक उदाहरण है:

function greet(name: string, age?: number) {
  console.log(Hello ${name}, age: ${age ?? "unknown"});
}

function sum(...numbers: number[]) {
  return numbers.reduce((a, b) => a + b, 0);
}संचालित द्वारा

ऑप्शनल और रेस्ट पैरामीटर्स के उपयोग के प्रमुख नियम:

ऑप्शनल पैरामीटर के लिए ? का उपयोग करें।
रेस्ट पैरामीटर्स (वैरिऐडिक आर्ग्यूमेंट्स) के लिए ... का उपयोग करें।

इंटरव्यू में इनका उपयोग अक्सर इस बात का आकलन करने के लिए किया जाता है कि आप डायनेमिक फ़ंक्शन इनपुट्स को कितना अच्छी तरह संभालते हैं।

26. TypeScript में readonly और const में क्या अंतर है?

const वेरिएबल्स पर लागू होता है, जबकि readonly ऑब्जेक्ट प्रॉपर्टीज़ पर लागू होता है।

यहाँ एक उदाहरण है:

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

const user: User = { id: 1, name: "Bob" };
// user.id = 2; // Error: Cannot assign to 'id'

const { id, name } = user;
console.log(User ${name} has ID ${id});संचालित द्वारा

readonly और const के उपयोग के कुछ श्रेष्ठ अभ्यास:

उन ऑब्जेक्ट्स के लिए readonly का उपयोग करें जिन्हें बदला नहीं जाना चाहिए, जैसे API से प्राप्त डेटा।
ऐसे वेरिएबल्स के लिए const का उपयोग करें जिन्हें पुनः असाइन नहीं किया जाना चाहिए।
क्लीन और स्वयं-दस्तावेज़ीकरण कोड के लिए डीस्ट्रक्चरिंग को टाइप एनोटेशंस के साथ जोड़ें।

27. फ़ंक्शन टाइप वेरिएंस (Covariance और Contravariance) क्या है?

फ़ंक्शन टाइप वेरिएंस बताता है कि पैरामीटर और रिटर्न टाइप्स के आधार पर TypeScript कब एक फ़ंक्शन टाइप को दूसरे के स्थान पर सुरक्षित रूप से स्वीकार करता है।

रिटर्न टाइप्स: Covariant

कोई फ़ंक्शन कॉलर की अपेक्षा से अधिक विशिष्ट टाइप लौटा सकता है। उदाहरण:

type Animal = { name: string };
type Dog = Animal & { bark: () => void };

let f: () => Animal;
let g: () => Dog = () => ({ name: "Rex", bark() {} });

f = g; // OK: Dog is a subtype of Animalसंचालित द्वारा

पैरामीटर टाइप्स: Contravariant

कोई फ़ंक्शन अपेक्षा से अधिक सामान्य पैरामीटर टाइप्स स्वीकार कर सकता है। उदाहरण:

type Dog = { name: string; bark: () => void };
type Animal = { name: string };

type HandleDog = (dog: Dog) => void;
type HandleAnimal = (animal: Animal) => void;

let handleDog: HandleDog = d => console.log(d.bark());
let handleAnimal: HandleAnimal = a => console.log(a.name);

// A function that accepts an Animal is more general,
// so it can stand in for one that accepts a Dog
handleDog = handleAnimal; // OKसंचालित द्वारा

28. TypeScript में this टाइप्स क्या हैं?

this टाइप्स मेथड्स को क्लास के समान टाइप रिटर्न करने देते हैं, जो फ्लुएंट APIs के लिए उपयोगी है:

class Builder {
  setName(name: string): this {
    // ...
    return this;
  }
}
new Builder().setName("Test"); // chaining worksसंचालित द्वारा

TypeScript OOP इंटरव्यू प्रश्न

निम्न प्रश्न तकनीकी साक्षात्कारों में अक्सर पूछी जाने वाली TypeScript OOP अवधारणाओं को कवर करते हैं।

29. TypeScript ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग (OOP) को कैसे सपोर्ट करता है?

TypeScript क्लासेज़, इनहेरिटेंस, और एक्सेस मॉडिफ़ायर्स जैसी OOP सिद्धांतों को सपोर्ट करता है।

क्लासेज़ ऑब्जेक्ट्स के लिए पुन: प्रयोज्य ब्लूप्रिंट्स परिभाषित करती हैं, और इनहेरिटेंस एक क्लास को दूसरी क्लास का विस्तार करने देता है ताकि प्रॉपर्टीज़ और बिहेवियर्स साझा किए जा सकें।

यहाँ एक उदाहरण है:

class Animal {
  constructor(public name: string) {}

  move(distance: number) {
    console.log(${this.name} moved ${distance}m.);
  }
}

class Dog extends Animal {
  bark() {
    console.log("Woof!");
  }
}

const dog = new Dog("Buddy");
dog.bark();       // Woof!
dog.move(10);     // Buddy moved 10m.संचालित द्वारा

एक्सेस मॉडिफ़ायर्स में शामिल हैं:

public: कहीं से भी एक्सेसिबल
protected: क्लास और उसकी सबक्लासेज़ के भीतर एक्सेसिबल
private: केवल घोषित करने वाली क्लास के अंदर एक्सेसिबल

टिप: एन्कैप्सुलेशन सुनिश्चित करने के लिए एक्सेस मॉडिफ़ायर्स का उपयोग करें, जिससे आंतरिक लॉजिक या स्टेट का अनपेक्षित संशोधन रोका जा सके।

30. TypeScript में abstract classes और interfaces में क्या अंतर है?

Abstract क्लासेज़ और इंटरफेसेज़ दोनों ऑब्जेक्ट्स या क्लासेज़ के लिए कॉन्ट्रैक्ट परिभाषित करते हैं, लेकिन उनका उद्देश्य अलग है।

Abstract क्लासेज़ साझा इम्प्लिमेंटेशन और एब्स्ट्रैक्ट मेथड्स शामिल कर सकती हैं।

इंटरफेसेज़ केवल स्ट्रक्चर का वर्णन करती हैं, इम्प्लिमेंटेशन नहीं।

यहाँ एक उदाहरण है:

abstract class Shape {
  abstract getArea(): number; // must be implemented
}

class Circle extends Shape {
  constructor(public radius: number) {
    super();
  }

  getArea(): number {
    return Math.PI * this.radius ** 2;
  }
}संचालित द्वारा

श्रेष्ठ अभ्यास:

जब संबंधित क्लासेज़ में साझा लॉजिक चाहिए हो, तो abstract क्लासेज़ का उपयोग करें।
लचीले टाइप कॉन्ट्रैक्ट्स और ढीले-युग्मित डिज़ाइन के लिए इंटरफेसेज़ का उपयोग करें।

31. private, protected, और public मॉडिफ़ायर्स में क्या अंतर है?

यहाँ TypeScript के एक्सेस मॉडिफ़ायर्स और वे क्या नियंत्रित करते हैं, उसका तुलनात्मक विवरण है:

Modifier	Description
public	कहीं से भी एक्सेसिबल।
protected	क्लास और उसकी सबक्लासेज़ के भीतर एक्सेसिबल।
private	केवल घोषित करने वाली क्लास के अंदर एक्सेसिबल।

सही एक्सेस मॉडिफ़ायर का उपयोग एन्कैप्सुलेशन को बढ़ावा देता है, जिससे आंतरिक स्टेट और लॉजिक तक अनपेक्षित पहुँच या बदलाव रोका जा सके।

32. implements और extends में क्या अंतर है?

extends व्यवहार और प्रॉपर्टीज़ को विरासत में लेता है, जबकि implements केवल कॉन्ट्रैक्ट लागू कराता है, इम्प्लिमेंटेशन नहीं देता।

यहाँ एक उदाहरण है:

interface Logger { log(msg: string): void; }

class Base { foo() {} }

class MyClass extends Base implements Logger {
  log(msg: string) {}
}संचालित द्वारा

33. TypeScript में Mixins कैसे काम करते हैं?

मिक्सिन्स कई पुन: प्रयोज्य क्लास कंपोनेंट्स की अनुमति देते हैं।

यहाँ एक उदाहरण है:

type Constructor<T = {}> = new (...args: any[]) => T;

function Timestamped<TBase extends Constructor>(Base: TBase) {
  return class extends Base {
    timestamp = Date.now();
  };
}

class User {}
const TimestampedUser = Timestamped(User);संचालित द्वारा

जब आपको एकाधिक इनहेरिटेंस जैसे पैटर्न चाहिए हों, तब उपयोगी।

प्रैक्टिकल TypeScript इंटरव्यू प्रश्न

ये प्रश्न इंटरव्यू में आने वाले TypeScript के वास्तविक-जीवन अनुप्रयोगों पर केंद्रित हैं।

34. आप किसी JavaScript प्रोजेक्ट को TypeScript में कैसे माइग्रेट करेंगे?

लिगेसी JavaScript कोडबेस को TypeScript में माइग्रेट करना जोखिम और व्यवधान कम करने के लिए क्रमिक होना चाहिए।

अनुशंसित तरीका:

.js फाइलों का नाम बदलकर .ts करें।
tsconfig.json में allowJs और checkJs सक्षम करें।
कोर फ़ंक्शंस या मॉड्यूल्स से शुरू करते हुए धीरे-धीरे टाइप्स जोड़ें।
अस्थायी रूप से any का उपयोग करें, फिर कोडबेस परिष्कृत होने पर उपयुक्त टाइप्स से बदलें।

क्रमिक माइग्रेशन के लिए tsconfig.json का उदाहरण:

{
  "compilerOptions": {
    "allowJs": true,
    "checkJs": true,
    "strict": true
  }
}संचालित द्वारा

क्रमिक माइग्रेशन स्थिरता सुनिश्चित करता है और बड़े री-राइट बिना ही टीमों को जल्दी टाइप जाँच का लाभ लेने देता है।

35. आप React के साथ TypeScript कैसे उपयोग करते हैं?

React में TypeScript का उपयोग प्रॉप्स और स्टेट के लिए टाइप सेफ़्टी बढ़ाता है, जो रनटाइम एरर्स को रोकता है।

यहाँ एक उदाहरण है:

interface Props {
  title: string;
}

const Header: React.FC<Props> = ({ title }) => <h1>{title}</h1>;संचालित द्वारा

प्रॉप टाइप्स परिभाषित करने से TypeScript कम्पाइल-टाइम पर ग़लत या गुम प्रॉप्स पकड़ लेता है, जिससे विश्वसनीयता और प्रोडक्टिविटी बढ़ती है।

36. आप Node.js के साथ TypeScript कैसे उपयोग करते हैं?

TypeScript, API रूट्स, कॉन्फ़िगरेशन, और मिडलवेयर के लिए टाइप सेफ़्टी जोड़कर Node.js एप्लिकेशंस को बेहतर बनाता है।

यहाँ एक उदाहरण है:

import express, { Request, Response } from "express";
const app = express();

app.get("/", (req: Request, res: Response) => res.send("Hello TypeScript"));संचालित द्वारा

Request और Response को टाइप करने से सही पैरामीटर उपयोग सुनिश्चित होता है और सामान्य रनटाइम एरर्स से बचा जा सकता है।

TypeScript Node.js APIs को मेंटेन करना और सुरक्षित रूप से रीफैक्टर करना आसान बनाता है।

37. ऐसे थर्ड-पार्टी JavaScript लाइब्रेरीज़ को कैसे संभालेंगे जिनमें TypeScript डेफिनिशंस नहीं हैं?

कुछ लाइब्रेरीज़ में बिल्ट-इन टाइप्स नहीं होते। ऐसे में आपके पास दो प्रमुख विकल्प हैं:

विकल्प 1: समुदाय-रक्षित टाइप्स इंस्टॉल करें

npm install --save-dev @types/library-nameसंचालित द्वारा

विकल्प 2: कस्टम डिक्लेरेशन फ़ाइल बनाएँ

// custom.d.ts
declare module "legacy-library" {
  export function init(): void;
}संचालित द्वारा

टिप्स:

कस्टम डिक्लेरेशंस लिखने से पहले हमेशा @types देखें।
जटिल लाइब्रेरीज़ के लिए धीरे-धीरे टाइप्स जोड़ें ताकि संगतता बनी रहे।

थर्ड-पार्टी लाइब्रेरीज़ की उचित टाइपिंग आत्मविश्वास बढ़ाती है और रनटाइम बग्स घटाती है।

TypeScript कॉन्फ़िगरेशन और टूलिंग इंटरव्यू प्रश्न

यह सेक्शन TypeScript कॉन्फ़िगरेशन और टूलिंग के आवश्यक विषयों को कवर करता है, जिन पर तकनीकी साक्षात्कारों में अक्सर चर्चा होती है।

38. tsconfig.json क्या है, और यह महत्वपूर्ण क्यों है?

tsconfig.json किसी भी TypeScript प्रोजेक्ट की केंद्रीय कॉन्फ़िगरेशन फ़ाइल है।

यह कम्पाइलर का व्यवहार, इनक्लूडेड फाइलें, और सक्षम फीचर्स परिभाषित करता है।

यहाँ एक उदाहरण है:

{
  "compilerOptions": {
    "target": "ES2020",
    "module": "commonjs",
    "strict": true,
    "outDir": "./dist",
    "esModuleInterop": true,
    "forceConsistentCasingInFileNames": true,
    "noImplicitReturns": true,
    "noFallthroughCasesInSwitch": true
  },
  "include": ["src"],
  "exclude": ["node_modules", "dist"]
}संचालित द्वारा

मुख्य सेटिंग्स:

target: आउटपुट के लिए JavaScript संस्करण
module: मॉड्यूल सिस्टम (CommonJS, ESNext, आदि)
strict: सभी सख्त टाइप-जाँच विकल्प सक्षम करता है
outDir: कम्पाइल्ड कोड के लिए आउटपुट फ़ोल्डर
esModuleInterop: CommonJS मॉड्यूल इम्पोर्ट की अनुमति

संभावित बग्स को जल्दी पकड़ने और मेन्टेनेबिलिटी सुधारने के लिए strict मोड ज़रूर सक्षम करें।

39. Webpack, Vite, या Babel जैसे बिल्ड टूल्स के साथ TypeScript कैसे कॉन्फ़िगर करते हैं?

TypeScript आधुनिक बिल्ड सिस्टम्स के साथ सहजता से इंटीग्रेट हो जाता है।

आम सेटअप्‍स शामिल हैं:

Webpack: ऑन-द-फ्लाई कम्पाइलेशन के लिए ts-loader
Vite: तेज़ बिल्ड्स के लिए vite-plugin-ts
Babel: JS-हैवी एन्वायरनमेंट्स के लिए @babel/preset-typescript

उदाहरण Vite कॉन्‍फिगरेशन:

import { defineConfig } from "vite";
import react from "@vitejs/plugin-react";
import tsconfigPaths from "vite-tsconfig-paths";

export default defineConfig({
  plugins: [react(), tsconfigPaths()],
  build: {
    target: "es2020"
  }
});संचालित द्वारा

कम्पाइलर और बंडलर सेटिंग्स को संरेखित करें, इन्क्रीमेंटल बिल्ड्स सक्षम करें, और आसान डिबगिंग के लिए सोर्स मैप्स का उपयोग करें।

40. बेहतर कोड क्वालिटी के लिए आप TypeScript के साथ ESLint कैसे कॉन्फ़िगर करते हैं?

ESLint सुसंगत कोडिंग मानक बनाए रखने और शुरुआती चरण में एरर्स पकड़ने में मदद करता है।

आवश्यक पैकेज इंस्टॉल करें:

npm install eslint @typescript-eslint/parser @typescript-eslint/eslint-plugin --save-devसंचालित द्वारा

ESLint कॉन्फ़िगरेशन का उदाहरण:

{
  "parser": "@typescript-eslint/parser",
  "plugins": ["@typescript-eslint"],
  "extends": [
    "eslint:recommended",
    "plugin:@typescript-eslint/recommended"
  ],
  "rules": {
    "@typescript-eslint/no-explicit-any": "warn",
    "@typescript-eslint/explicit-function-return-type": "off"
  }
}संचालित द्वारा

टिप्स:

रूल्स को वैश्विक रूप से निष्क्रिय करने से बचें।
टाइप सेफ़्टी और लचीलापन में संतुलन के लिए प्रति-प्रोजेक्ट रूल्स को सूक्ष्म-ट्यून करें।
सुसंगत और साफ़ कोडबेस के लिए ESLint को Prettier के साथ उपयोग करें।

अपने TypeScript इंटरव्यू में सफलता के टिप्स

साक्षात्कार से पहले, आपको अपनी तकनीकी और संचार—दोनों कौशलों में निपुणता पर ध्यान देना चाहिए।

ऐसा करने के कुछ तरीके:

अध्ययन दृष्टिकोण:

एडवांस्ड टाइप्स, जनरिक्स, और यूटिलिटी टाइप्स पर आधिकारिक दस्तावेज़ की समीक्षा करें।
रटने के बजाय वास्तविक-जीवन उपयोग मामलों पर ध्यान दें।
टाइप एरर्स पढ़ने और समझने का अभ्यास करें, क्योंकि TypeScript कम्पाइलर संदेश अक्सर तकनीकी मूल्याँकनों का हिस्सा होते हैं।

प्रैक्टिस प्रोजेक्ट्स:

व्यावहारिक कौशल दिखाने के लिए छोटे लेकिन पूर्ण ऐप्स बनाएँ:

React To-Do सूची, typed प्रॉप्स और स्टेट के साथ
Express REST API, टाइप्ड रिक्वेस्ट और रिस्पॉन्स ऑब्जेक्ट्स के साथ
यूटिलिटी लाइब्रेरीज़, जनरिक्स और मैप्ड टाइप्स का उपयोग करते हुए

सामान्य गलतियाँ:

any का अत्यधिक उपयोग, जो TypeScript की टाइप सेफ़्टी को कमज़ोर करता है।
strict मोड की अनदेखी, जो रनटाइम बग्स को जन्म देती है।
null और undefined को टाइप डेफिनिशंस में गड़बड़ा देना।
थर्ड-पार्टी लाइब्रेरीज़ के लिए टाइप डेफिनिशंस इंस्टॉल या कॉन्फ़िगर करना भूल जाना।

कम्युनिकेशन टिप्स:

इंटरव्यू के दौरान, अपने टाइप निर्णयों के पीछे तर्क स्पष्ट रूप से समझाएँ।
दृष्टिकोणों के बीच ट्रेड-ऑफ़्स बताइए (उदाहरण: interface बनाम type alias, या abstract class बनाम interface)।
दिखाएँ कि TypeScript कैसे प्रोजेक्ट्स में मेन्टेनेबिलिटी और स्केलेबिलिटी सुधारता है।

निष्कर्ष

TypeScript आधुनिक वेब डेवलपमेंट पर लगातार हावी है, क्योंकि यह स्पष्ट, सुसंगत डेटा टाइप्स लागू करता है—जो बग्स को रोकते हैं और बड़े प्रोजेक्ट्स के लिए स्केलेबिलिटी सुधारते हैं।

सीखना जारी रखने के लिए, हमारे पूरे कोर्स कैटलॉग का अन्वेषण करें और विभिन्न तकनीकों में अपना ज्ञान बढ़ाएँ।

लेखक

Don Kaluarachchi

LinkedIn Twitter

मैं डॉन हूँ—कंसल्टेंट, डेवलपर, इंजीनियर, डिजिटल आर्किटेक्ट और लेखक (यानी, मैं कई भूमिकाएँ निभाता हूँ 👨‍💻🎩)। मुझे डिजिटल प्लेटफ़ॉर्म्स को सुचारू रूप से चलाना और उन्हें बेहतर बनाने के नए तरीके खोजना पसंद है। जब मैं कोड नहीं लिख रहा होता, तब मैं कृत्रिम बुद्धिमत्ता, डेटा विज्ञान और तकनीक से जुड़ी बातों पर लिखता हूँ।

सालों के दौरान, मैंने सॉफ़्टवेयर निर्माण और अनुकूलन से लेकर AI मॉडल परिनियोजन और क्लाउड समाधानों के डिज़ाइन तक हर तरह के काम किए हैं। मैंने Brunel University London से कृत्रिम बुद्धिमत्ता में मास्टर ऑफ़ साइंस और कंप्यूटर साइंस में बैचलर ऑफ़ साइंस की डिग्री प्राप्त की है।

FAQs

TypeScript का उपयोग किस लिए होता है?

TypeScript, JavaScript का typed सुपरसैट है जो साधारण JavaScript में कम्पाइल होता है। इसका उपयोग स्थिर टाइप जाँच के साथ स्केलेबल, मेन्टेनेबल एप्लिकेशंस बनाने के लिए किया जाता है।

2026 में डेवलपर्स के लिए TypeScript महत्वपूर्ण क्यों है?

जैसे-जैसे React, Angular, और Node.js जैसे फ़्रेमवर्क्स TypeScript को मानक बना रहे हैं, यह अब अधिकांश फ्रंट-एंड और फुल-स्टैक इंटरव्यूज़ में एक मुख्य कौशल है।

इंटरव्यू से पहले मैं TypeScript का अभ्यास कैसे कर सकता/सकती हूँ?

छोटे प्रोजेक्ट्स बनाइए (जैसे React To-Do ऐप या Node.js API) ताकि समझ गहरी हो और हैंड्स-ऑन इंटरव्यू कार्यों के लिए तैयारी हो।

TypeScript इंटरव्यू में किन आम गलतियों से बचना चाहिए?

‘any’ का अत्यधिक उपयोग, कम्पाइलर चेतावनियों को नज़रअंदाज़ करना, strict मोड छोड़ना, और अपने टाइप विकल्पों की व्याख्या न कर पाना—ये कुछ आम गलतियाँ हैं।

विषय

AWS एआई एजेंट्स