Question 1

What is TypeScript, and how is it different from JavaScript?

Accepted Answer

TypeScript is a strongly-typed, open-source programming language developed by Microsoft that acts as a strict syntactical superset of JavaScript. Unlike JavaScript, TypeScript checks code structures at compile-time and outputs standard JavaScript files, providing features like type safety, interfaces, static typing, and IDE auto-completion.

Question 2

Explain the difference between `interface` and `type` alias.

Accepted Answer

Both interfaces and type aliases can define shapes of objects. However, `interface` is open-ended and supports declaration merging (defining same interface multiple times appends fields), and can be extended with `extends`. A `type` alias is closed, can represent primitive unions, intersections, and tuples, but cannot be re-declared to merge properties.
Code Example:
// Interface declaration merging
interface User { name: string; }
interface User { age: number; } // Now User has both name & age

// Type union
type Status = 'active' | 'inactive';

Question 3

What are generics in TypeScript?

Accepted Answer

Generics allow developers to create reusable components, functions, or classes that work with multiple types rather than a single typed definition. They allow users to pass the type argument dynamically while maintaining type safety. Code Example: function identity(arg: T): T { return arg; } let output1 = identity("hello"); let output2 = identity(100);

Question 4

What is the difference between `any` and `unknown` types?

Accepted Answer

The `any` type disables all type checking—you can access any property or execute any method on it. The `unknown` type is a type-safe counterpart to `any`. While you can assign anything to an `unknown` variable, you cannot access its properties or invoke methods until you narrow the type using type checking or assertions.
Code Example:
let val1: any = "hello";
val1.trim(); // Allowed

let val2: unknown = "hello";
// val2.trim(); // Error! unknown type not checked
if (typeof val2 === "string") {
  val2.trim(); // Narrowed successfully!
}

Question 5

What are union and intersection types?

Accepted Answer

A union type (`A | B`) represents a value that can be *either* type A or type B. An intersection type (`A & B`) combines multiple types into one, requiring the value to satisfy *all* types simultaneously.
Code Example:
// Union type
type StringOrNumber = string | number;

// Intersection type
interface Named { name: string; }
interface Aged { age: number; }
type Employee = Named & Aged; // Must contain name AND age

Question 6

What is Type Narrowing / Type Guards?

Accepted Answer

Type narrowing is the process where TypeScript analyzes conditional flows and refines types from broad categories to more specific definitions. Common methods include using `typeof`, `instanceof`, the `in` operator, or custom type guard predicates.
Code Example:
function printLength(val: string | number) {
  if (typeof val === "string") {
    console.log(val.length); // TypeScript narrows to string
  } else {
    console.log(val.toFixed()); // TypeScript narrows to number
  }
}

Question 7

How do you define a custom type guard in TypeScript?

Accepted Answer

A custom type guard is a function whose return type is a type predicate (`parameterName is Type`). If the function returns true, TypeScript narrows the parameter to that type in the corresponding block.
Code Example:
interface Cat { meow: () => void; }
interface Dog { bark: () => void; }

function isCat(pet: Cat | Dog): pet is Cat {
  return (pet as Cat).meow !== undefined;
}

Question 8

What does the `keyof` operator do?

Accepted Answer

The `keyof` operator takes an object type and returns a union type of its keys (properties).
Code Example:
interface User {
  id: number;
  name: string;
}

type UserKeys = keyof User; // 'id' | 'name'

Question 9

What are utility types? List some common ones.

Accepted Answer

Utility types are globally available generic helper types in TypeScript that facilitate common type transformations. Common ones include `Partial` (makes properties optional), `Required` (makes properties required), `Readonly` (makes properties read-only), and `Record` (maps keys to types).

Question 10

Explain the `Pick` and `Omit` utility types.

Accepted Answer

`Pick` constructs a type by picking a subset of keys `K` from type `T`. `Omit` constructs a type by removing keys `K` from type `T`. Code Example: interface Todo { title: string; description: string; completed: boolean; } type TodoPreview = Pick; type TodoWithoutDescription = Omit;

Question 11

What is the difference between `never` and `void`?

Accepted Answer

`void` means the function runs to completion but does not return a meaningful value (or returns undefined). `never` represents the type of values that *never occur*—for example, a function that always throws an exception or enters an infinite loop, returning no value whatsoever.
Code Example:
function logMessage(msg: string): void {
  console.log(msg);
}

function throwError(msg: string): never {
  throw new Error(msg);
}

Question 12

What is an enum in TypeScript, and how is it used?

Accepted Answer

Enums (enumerated types) allow developers to define a set of named constants, either numeric or string-based, improving code readability and restriction. Constant enums (`const enum`) are compiled away completely, yielding raw values in the JS output.
Code Example:
enum Direction {
  Up = "UP",
  Down = "DOWN",
  Left = "LEFT",
  Right = "RIGHT"
}

Question 13

What is a Tuple type?

Accepted Answer

A tuple is a specialized array type where you specify the exact number of elements, as well as the types of elements at specific index positions.
Code Example:
let employee: [number, string] = [1, "John"];
// employee = ["John", 1]; // Error!

Question 14

What is type assertion, and how does it differ from type casting?

Accepted Answer

TypeScript does not perform runtime type casting. Instead, it uses type assertions (`value as Type` or `<Type>value`) to inform the compiler to treat a value as a specific type. It has no effect at runtime and does not convert data.

Question 15

What is the non-null assertion operator?

Accepted Answer

The non-null assertion operator is the exclamation mark (`!`) placed after a variable. It informs the TypeScript compiler that the value is not `null` or `undefined`, bypasses strict null checking.
Code Example:
let name: string | null = getName();
console.log(name!.length); // Tells compiler 'name' is guaranteed to be string

Question 16

What is the `readonly` modifier in TypeScript?

Accepted Answer

The `readonly` modifier makes object properties or array elements immutable. Once initialized, they cannot be modified or re-assigned.
Code Example:
interface Point {
  readonly x: number;
  readonly y: number;
}

let p: Point = { x: 10, y: 20 };
// p.x = 5; // Error: x is read-only

Question 17

Explain index signatures in TypeScript.

Accepted Answer

Index signatures are used when you don't know the exact names of an object's properties in advance, but you do know the type of keys and values.
Code Example:
interface StringDictionary {
  [key: string]: string;
}

let dict: StringDictionary = {
  hello: "world",
  goodbye: "friend"
};

Question 18

What are conditional types in TypeScript?

Accepted Answer

Conditional types select one of two types based on a relation test, similar to a ternary operator in JavaScript: `T extends U ? X : Y`. Code Example: type IsString = T extends string ? true : false; type A = IsString; // true type B = IsString; // false

Question 19

Explain the `infer` keyword in conditional types.

Accepted Answer

The `infer` keyword is used within the condition test of a conditional type to declare a new type variable dynamically, enabling TypeScript to extract types from other generic containers. Code Example: type GetReturnType = T extends (...args: any[]) => infer R ? R : any; type Func = () => number; type Return = GetReturnType; // number

Question 20

What are mapped types in TypeScript?

Accepted Answer

Mapped types allow you to create new object types based on the properties of an existing type, iterating over keys to transform their modifiers or types.
Code Example:
type ReadOnlyUser<T> = {
  readonly [P in keyof T]: T[P];
};

Question 21

Explain template literal types.

Accepted Answer

Template literal types are built on template literal strings in JavaScript, allowing you to combine unions to construct complex string types statically.
Code Example:
type Event = "click" | "hover";
type HandlerName = `on${Capitalize<Event>}`; // "onClick" | "onHover"

Question 22

What is structural typing in TypeScript?

Accepted Answer

TypeScript uses structural typing (also called duck typing). This means that type compatibility is determined by the shape/structure of the type, not its explicit declaration name. If two objects have the same properties with compatible types, they are considered compatible.

Question 23

What is strict mode in TypeScript?

Accepted Answer

Strict mode (enabled by setting `strict: true` in `tsconfig.json`) turns on a suite of type-checking behaviors, including `noImplicitAny`, `strictNullChecks`, `strictFunctionTypes`, and `strictBindCallApply`, leading to safer code layouts.

Question 24

How do you type React components and events in TypeScript?

Accepted Answer

You type functional components using `React.FC` or by defining props parameter directly. React event handlers are typed using React's event wrappers (e.g. `React.ChangeEvent` or `React.MouseEvent`). Code Example: import React from 'react'; interface ButtonProps { onClick: (e: React.MouseEvent) => void; } export const Button = ({ onClick }: ButtonProps) => ( );

Question 25

How do you declare types for external non-TypeScript JavaScript libraries?

Accepted Answer

You can download pre-existing declarations from DefinitelyTyped using `@types/[library]`. If no types exist, you can declare them yourself in a custom declaration file `declarations.d.ts` using `declare module 'library-name'`.
Code Example:
// declarations.d.ts
declare module 'legacy-js-lib' {
  export function doSomething(val: string): void;
}

TypeScript Interview Master

Difficulty Filters

Tools & Options

What is TypeScript, and how is it different from JavaScript?

Explain the difference between `interface` and `type` alias.

What are generics in TypeScript?

What is the difference between `any` and `unknown` types?

What are union and intersection types?

What is Type Narrowing / Type Guards?

How do you define a custom type guard in TypeScript?

What does the `keyof` operator do?

What are utility types? List some common ones.

Explain the `Pick` and `Omit` utility types.

What is the difference between `never` and `void`?

What is an enum in TypeScript, and how is it used?

What is a Tuple type?

What is type assertion, and how does it differ from type casting?

What is the non-null assertion operator?

What is the `readonly` modifier in TypeScript?

Explain index signatures in TypeScript.

What are conditional types in TypeScript?

Explain the `infer` keyword in conditional types.

What are mapped types in TypeScript?

Explain template literal types.

What is structural typing in TypeScript?

What is strict mode in TypeScript?

How do you type React components and events in TypeScript?

How do you declare types for external non-TypeScript JavaScript libraries?

Technical Interview Mastery Blueprint

1. The Engineering STAR Technique

2. Defending Architectural Trade-Offs

3. Clean Code & Edge-Case Proactivity

4. Antipatterns to Avoid

Explore Related Tools

Angular Interview Questions

Aws Interview Questions

Bootstrap Interview Questions

Dsa Interview Questions

Golang Interview Questions

Lld Interview Questions

Follow Us

Our Tools

Our Company

Special Tools