52+ Top TypeScript Interview Questions and Answers for All Skill Levels in 2025

TypeScript is a statically typed superset of JavaScript that adds type safety and powerful tooling features to the language. It is widely used in front-end frameworks like Angular, React, and Vue, as well as in back-end development with Node.js.

By tackling TypeScript interview questions on concepts like mapping types and static typing, you can improve your chances of landing roles such as a front-end developer. This post covers key TypeScript interview topics across all skill levels, providing valuable insights and examples.

Core TypeScript Interview Questions and Answers for Beginners

The core TypeScript interview questions will focus on aspects like data types, syntax, functions, and essential concepts like getters and setters.

Here are some core TypeScript interview questions and answers.

1. What is the definition of TypeScript?

A: TypeScript is an open-source statically typed superset of JavaScript developed by Microsoft. It extends JavaScript by adding static types, generics, interfaces, and modern ECMAScript features, making it more scalable for large applications. 

Since TypeScript compiles to plain JavaScript, it can run in any environment that supports JavaScript. It is used in frameworks like Angular, React, Vue.js, and Node.js to build complex web applications with better structure and safety.

2. How are Arrays defined and used in TypeScript?

A: Arrays in TypeScript are used similarly to JavaScript arrays but with added type safety. They can be declared using bracket notation (type[]) or generic syntax (Array<type>).

• type[] notation:

let numbers: number[] = [10, 20, 30];
numbers.push(40); // Works fine
numbers.push("fifty"); // Error: Argument of type 'string' is not assignable to parameter of type 'number'.

• Array<type> notation:

let colors: Array<string> = ["Red", "Green", "Blue"];
colors.push("Yellow"); // Allowed

TypeScript also supports tuples, a specialized type of array where each element has a fixed type:

let user: [string, number] = ["Raj", 30]; // First element must be a string, second must be a number

Also Read: What Is an Array? Understanding the Array Meaning, Types, and Practical Applications

3. What are some key applications of TypeScript?

A: TypeScript is widely used in software development due to its strong type system, tooling support, and scalability. 

Here are some key applications:

• Frontend Development: It is a preferred choice for Angular and is widely used with React and Vue.js to build type-safe UI components and manage state effectively.
• Backend Development: It is used with Node.js frameworks like NestJS and Express to develop APIs and microservices with structured type definitions.
• Enterprise Applications: Large companies use TypeScript to maintain scalable, maintainable, and bug-free codebases.
• Game Development: Frameworks like Phaser use TypeScript to develop browser-based games with improved performance.
• Static Site Generation & Server-Side Rendering: TypeScript is used in frameworks like Next.js for static site generation and hybrid rendering.

Learn the latest languages, such as JavaScript, to create web applications for roles like web developer. Enroll in upGrad’s Online Software Development Courses now!

4. What are the benefits of using TypeScript?

A: The benefits of TypeScript include better code maintainability, static typing, and improved debugging.

Here are the benefits of using TypeScript:

• Static Typing: Detects errors at compile time, preventing common JavaScript runtime issues.
• Better Code Maintainability: TypeScript's type safety ensures better maintainability in large-scale applications by catching errors early in the development process.
• Enhanced Developer Tooling: Works seamlessly with modern IDEs like VS Code, offering autocompletion, error detection, and refactoring tools.
• Object-Oriented Programming (OOP) Support: Features like classes, interfaces, and generics enable better code structuring.
• Latest ECMAScript Features: TypeScript supports the latest ECMAScript features (like async/await), allowing you to write clean JavaScript while compiling down to a compatible version for older browsers.
• Improved Debugging: TypeScript's static type checking helps catch type errors and issues during the compile time, which leads to fewer runtime errors.

5. What are the drawbacks of using TypeScript?

A: Increase in complexity, a steep learning curve, and compilation overhead are some main drawbacks of using TypeScript.

Here are the drawbacks:

• Increased Complexity: For beginners, even concepts like generics or interfaces may seem complex compared to pure JavaScript.
• Compilation Overhead: Unlike JavaScript, which runs directly in browsers, TypeScript must be compiled into JavaScript before execution.
• Additional Setup Required: TypeScript requires configuration (tsconfig.json) and build tools like Webpack or Babel, increasing setup time.
• Learning Curve: Developers must learn types, interfaces, generics, and utility types, making it more complex than JavaScript.
• No Runtime Type Checking: TypeScript ensures type safety at compile time, but if data comes from an external source (e.g., API), additional validation is required.

6. What are the key features of Arrays in TypeScript?

A: TypeScript arrays have several built-in features like tuple support and type safety, making them more powerful and type-safe than JavaScript arrays.

Here are the features of Arrays:

• Type Safety: Ensures all elements in an array match the specified type, preventing accidental type mismatches.
• Generic Support: Arrays can use generics (Array<T>) for better flexibility.
• Readonly Arrays: Prevents accidental modifications by making an array immutable.
• Tuple Support: Allows defining arrays with fixed types at specific indexes.
• Strict Type Checking for Methods: TypeScript ensures array methods like map(), filter(), and reduce() maintain type safety.

7. How do you declare variables in TypeScript?

A: Variables are declared in TypeScript using let, const, or var, similar to JavaScript. However, TypeScript allows explicit type annotations, ensuring type safety and preventing unintended assignments.

Here’s how you declare variables:

• Using let: Allows block-scoped variables that can be reassigned.

Example:

let age: number = 25;
age = 30; // Allowed
age = "thirty"; // Error: Type 'string' is not assignable to type 'number'

• Using const: Variables declared with const cannot be reassigned.

Example:

const name: string = "Alice";
name = "Bob"; // Error: Cannot assign to 'name' because it is a constant.

• Using var: Behaves like JavaScript’s var, but lacks block scoping.

Example:

var greeting: string = "Hello";

8. What access modifiers are available in TypeScript?

A: Access modifiers are used to enforce encapsulation and data security in TypeScript applications.

Here are the access modifiers available:

• public (Default): Members are accessible from anywhere.

Example:

class Person {
  public name: string;
  constructor(name: string) {
    this.name = name;
  }
}
const user = new Person("Alice");
console.log(user.name); // Accessible

• Private: Members are accessible only within the class.

Example:

class BankAccount {
  private balance: number;
  constructor(initialBalance: number) {
    this.balance = initialBalance;
  }
}
const account = new BankAccount(1000);
console.log(account.balance); // Error: Property 'balance' is private.

• Protected: Similar to private, but also accessible within subclasses.

Example:

class Vehicle {
  protected speed: number = 0;
}
class Car extends Vehicle {
  increaseSpeed() {
    this.speed += 10; // Allowed in subclass
  }
}
const myCar = new Car();
myCar.speed = 50; // Error: Property 'speed' is protected.

9. How do Loops work in TypeScript?

A: Loops in TypeScript allow you to iterate over collections or execute code multiple times. Commonly used loops are for, while, and do-while.

Here’s how loops work:

• for Loop: Executes a block of code a fixed number of times, commonly used for iterating over arrays with an index.

Example:

for (let i = 0; i < 5; i++) {
  console.log(i); // Prints numbers 0 to 4
}

• while Loop: Runs as long as a specified condition is true. Commonly used when the number of iterations is unknown beforehand.

Example:

let count = 0;
while (count < 3) {
  console.log("Hello"); // Prints "Hello" three times
  count++;
}

• do-while Loop: Similar to while, but ensures the loop runs at least once before checking the condition.

Example:

let num = 10;
do {
  console.log(num); // Runs once even though num is greater than 5
} while (num < 5);

• for...of Loop: Iterates over values in an iterable object like an array. It is commonly used for looping through lists.

Example:

let fruits = ["Apple", "Banana", "Cherry"];
for (let fruit of fruits) {
  console.log(fruit); // Prints each fruit
}

• for...in Loop: Iterates over keys (property names) of an object. It is commonly used for object property iteration.

Example:

let person = { name: "Raj", age: 25 };
for (let key in person) {
  console.log(key, person[key as keyof typeof person]); // Prints property names and values
}

10. What purpose does the tsconfig.json file serve?

A: The tsconfig.json file is the configuration file that defines compiler options, file inclusions, and project settings to control TypeScript compilation.

Key purposes include:

• Specifies Compiler Options: Defines how TypeScript compiles code, including target ECMAScript versions, module systems, and output directories. This helps ensure compatibility across different environments.
• Includes & Excludes Files: Determines which files and directories TypeScript should compile, preventing unnecessary files (like node_modules) from being processed.
• Enforces Code Standards: Allows strict type-checking rules (strict: true), ensuring consistent coding practices across a project and reducing potential errors.

Example:

{
  "compilerOptions": {
    "target": "ES6",
    "strict": true,
    "outDir": "./dist",
    "module": "CommonJS"
  },
  "include": ["src"],
  "exclude": ["node_modules"]
}

11. How can a string be converted into a number in TypeScript?

A: The right method to convert depends on whether the number is an integer or floating-point value.

The commonly used methods include:

• Using parseInt(): Converts a string to an integer by parsing its leading numeric part. If the string contains decimals, they are truncated.

Example:

let num = parseInt("42.9"); 
console.log(num); // Output: 42

• Using parseFloat(): Converts a string into a floating-point number by preserving decimal values.

Example:

let num = parseFloat("42.9");
console.log(num); // Output: 42.9

• Using the Number() function: Converts a string into either an integer or floating-point number while maintaining the original format. Returns NaN if the string is invalid.

Example:

let num = Number("42.9");
console.log(num); // Output: 42.9

• Using the Unary + Operator: A shorthand method to convert a string into a number with minimal syntax.

Example:

let num = +"42.9";
console.log(num); // Output: 42.9

12. What is contextual typing in TypeScript?

A: Contextual typing feature automatically infers types based on context rather than requiring explicit annotations.

It improves code clarity, reduces redundancy, and enhances developer experience.

Example: Inferring function parameters:

let printMessage = (msg: string) => {
  console.log(msg);
};

Here, TypeScript infers that msg must be a string, so an explicit type declaration is unnecessary.

13 What is JSX and how does it relate to TypeScript?

A: JSX (JavaScript XML) is a syntax extension used in React that allows you to write HTML-like structures within JavaScript or TypeScript. 

It improves code readability and enables you to define UI components more declaratively. JSX elements are compiled into standard JavaScript using tools like Babel.

TypeScript can also compile JSX directly without needing Babel if the appropriate jsx option is set in tsconfig.json.

In TypeScript, JSX can be used by setting the jsx option in tsconfig.json. TypeScript improves JSX by adding strict type-checking to component props, improving error detection.

Example:

type ButtonProps = {
  label: string;
};

const Button: React.FC<ButtonProps> = ({ label }) => {
  return <button>{label}</button>;
};

export default Button;

14. What is static typing and how is it implemented in TypeScript?

A: Static typing allows you to determine variable types at compile time rather than runtime, preventing type-related errors before execution. It reduces runtime errors, improves code maintainability, and enhances development efficiency.

JavaScript itself doesn't have "dynamic typing", as is commonly believed. JavaScript's types are actually dynamic, but not strictly enforced (e.g., type coercion).

Here’s how static typing is used in TypeScript:

• Explicit Type Annotations: Developers manually define variable types to ensure correct data usage.

Example:

let name: string = "Raj"; // Only allows strings
let age: number = 25; // Only allows numbers

• Type Inference: TypeScript automatically assigns types based on the initial value, reducing redundancy.

Example:

let isAdmin = true; // Inferred as 'boolean'

• Function Parameter and Return Types: Enforces type constraints for function inputs and outputs, ensuring predictable behavior.

Example:

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

• Strict Type Checking: Flags type mismatches at compile time, preventing potential runtime bugs.

Example:

let count: number = "ten"; // ❌ Error: Type 'string' is not assignable to 'number'

15. How do the import and export keywords function in TypeScript?

A: The import and export keyword enables modular programming by allowing code to be shared across multiple files, improving reusability.

Here’s how they function:

Exporting Modules: Modules can be exported in two ways:

• Named Export: Allows exporting multiple values from a file.

Example:

export const pi = 3.14;
export function square(num: number): number {
  return num * num;
}

• Default Export: Allows exporting a single value from a file.

Example:

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

Importing Modules: Modules are imported using the following ways:

• Importing Named Exports: Imports specific exported functions or variables using curly braces.

Example:

import { pi, square } from "./math";
console.log(square(4)); // Output: 16

• Importing Default Exports: Imports a single default export without curly braces.

Example:

import greet from "./greet";
console.log(greet("Raj")); // Output: Hello, Raj

16. Is it possible to use TypeScript for backend development?

A: TypeScript can be used for backend development, especially with Node.js frameworks like NestJS, Express, and Koa. It improves backend development by providing type safety, code structure, and better debugging features.

Here’s why you must use TypeScript for backend development:

• Type Safety: Enforces strict type checking, reducing runtime errors and ensuring data consistency in APIs and database operations.
• Scalability: Supports well-structured code using interfaces, generics, and modules, making large applications easier to manage.
• Improved Debugging: Identifies type mismatches, missing properties, and incorrect function signatures at compile time, preventing unexpected crashes.
• Better Code Maintenance: Provides advanced tooling support for autocompletion, refactoring, and documentation, making code easier to read and modify.

Also Read: What Does a Back-End Developer Do?

17. How can you check if a variable is null or undefined in TypeScript?

A: Checking if the variables are null (explicitly empty) or undefined (declared but not assigned a value) ensures error-free execution. It is especially important when handling user inputs or API responses.

Here’s how you can check:

• Using Strict Equality (=== or !==): Directly compares a variable with null or undefined to check its value.

Example:

if (value === null || value === undefined) {
  console.log("Value is either null or undefined");
}

• Using Optional Chaining (?.): Prevents runtime errors when accessing properties of null or undefined.

Example:

console.log(user?.name); // Returns 'undefined' instead of throwing an error

• Using Nullish Coalescing (??): Assigns a default value if the variable is null or undefined.

Example:

let result = value ?? "Default Value"; // Uses "Default Value" if value is null/undefined

• Using typeof Check: Ensures a variable exists before performing operations.

Example:

if (typeof value === "undefined") {
  console.log("Value is undefined");
}

18. What are getters and setters in TypeScript?

A: Getters and setters are special class methods used to encapsulate access to private properties, ensuring controlled property modification.

Here’s how they work in TypeScript:

• Getter (get): Allows reading a private property without directly exposing it. This improves data security and flexibility, allowing computed or transformed values.
• Setter (set): Allows controlled modification of a private property, enabling validation before assigning a new value.

Example:

class Person {
  private _age: number = 0;

  get age(): number {
    return this._age;
  }

  set age(value: number) {
    if (value < 0) {
      throw new Error("Age cannot be negative");
    }
    this._age = value;
  }
}

const user = new Person();
user.age = 25; // ✅ Valid
console.log(user.age); // Output: 25
user.age = -5; // ❌ Error: Age cannot be negative

19. How can constants be implemented within a class in TypeScript?

A: Constants are implemented using the readonly keyword or by declaring them as static readonly. The readonly keyword ensures that a property can be assigned only once, either at declaration or in the constructor.

Here’s how you can implement readonly:

• Using readonly: Declares an instance property that can be assigned only once, either at declaration or inside the constructor.

Example:

class Car {
  readonly brand: string;
  constructor(brand: string) {
    this.brand = brand; // Allowed in constructor
  }
}

• Using static readonly: Declares a class-level constant that is shared across all instances and cannot be modified.

Example:

class MathConstants {
  static readonly PI = 3.14;
}
console.log(MathConstants.PI); // Output: 3.14

20. What does the Declare keyword mean in TypeScript?

A: The declare keyword informs the compiler about the existence of a variable, function, or module without providing its actual implementation. 

It is mainly used for ambient declarations, allowing TypeScript to work with non-TypeScript libraries or global variables.

Here are the different use cases of declare keyword:

• Declaring Global Variables: Informs TypeScript about globally defined variables from external scripts.

Example:

declare var API_URL: string;
console.log(API_URL); // Assumes API_URL exists at runtime

• Declaring External Functions: Allows TypeScript to recognize JavaScript functions that are implemented elsewhere.

Example:

declare function fetchData(url: string): void;
fetchData("https://api.example.com");

• Declaring Modules: Defines types for external or untyped libraries to enable proper TypeScript support.

Example:

declare module "someLibrary" {
  export function someFunction(): void;
}

21. How do Interfaces function in TypeScript?

A: Interfaces define a contract for object structures, ensuring that objects follow a specific shape. Unlike classes, interfaces do not generate JavaScript code—they are used only for type checking during development.

Here’s how Interface functions in TypeScript:

• Defining and using an interface: Specifies a contract for object structure, ensuring objects follow a defined shape.

Example:

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

const user: Person = { name: "Kumar", age: 30 };

• Extending interfaces: Allows one interface to inherit properties from another, promoting reusability and modularity.

Example:

interface Employee extends Person {
  position: string;
}

const employee: Employee = { name: "Bob", age: 40, position: "Manager" };

Also Read: The Ultimate Guide to Interfaces in PHP: Definition, Implementation, and Best Practices for 2025

22. What is the purpose of the ‘as’ syntax in TypeScript?

A: The as keyword is used for type assertions, allowing you to tell TypeScript to treat a value as a specific type. It does not change the actual data but overrides TypeScript’s type inference property.

Here are the use cases of as keyword:

• Narrowing Down a Union Type: It is used to specify a more precise type from a broader union type to access specific properties or methods.

Example:

let value: string | number = "Hello";
let strLength: number = (value as string).length;
console.log(strLength); // Output: 5

TypeScript initially treats value as string | number, so length is not directly accessible. Using as string informs TypeScript that value is a string at that point.

• Type Assertion in DOM Manipulation: The keyword ensures that TypeScript correctly recognizes an element’s type when selecting it from the DOM.

Example:

let input = document.querySelector("#username") as HTMLInputElement;
console.log(input.value); // TypeScript now knows input is an HTMLInputElement

Without as, TypeScript would infer input as Element | null, preventing access to .value.

23. How are Lambda functions defined in TypeScript?

A: Lambda functions define functions in TypeScript using the => syntax. They eliminate the need for the function keyword and automatically bind this.

Syntax of a Lambda function:

const add = (a: number, b: number): number => a + b;
console.log(add(5, 3)); // Output: 8

Example: Using Lamba function with Array:

const numbers = [1, 2, 3, 4];
const squared = numbers.map((num) => num * num);
console.log(squared); // Output: [1, 4, 9, 16]

24. How are objects created in TypeScript?

A: Objects can be created using object literals, interfaces, and classes, each having different use cases. 

Here’s how objects are created in TypeScript:

• Using object literals: Defines objects inline without requiring predefined structures, making them simple and flexible.

Example:

const user = {
  name: "Raj",
  age: 30,
  greet: () => "Hello!",
};
console.log(user.name); // Output: Raj

• Using interfaces: Ensures objects conform to a specific shape, improving type safety and maintainability.

Example:

interface Car {
  brand: string;
  year: number;
}

const myCar: Car = {
  brand: "Tesla",
  year: 2022,
};

• Using classes: Provides a structured blueprint for creating objects, allowing encapsulation, initialization, and method definitions.

Example:

class Person {
  name: string;
  age: number;

  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }
}

const person1 = new Person("Kumar", 40);
console.log(person1.name); // Output: Kumar

Core questions in TypeScript introduce concepts such as object creation, syntax usage, and key features like static typing. Now, let’s explore the TypeScript interview questions for intermediate learners.

Intermediate TypeScript Interview Questions for Developers

Knowledge of intermediate-level concepts like object-oriented principles, modules, namespaces, and advanced data handling is essential for career advancement.

Here are some TypeScript interview questions and answers for intermediate learners.

1. What are the various data types used in TypeScript?

A: TypeScript provides data types that help enforce type safety and improve code maintainability. They can be categorized into primitive types, user-defined types, and special types.

Here are the different data types used:

• Primitive Types (Built-in Types):
  • string: Represents textual data enclosed in quotes.

Example: 

let name: string = "Raj";

• number: Represents both integer and floating-point values.

Example:

let age: number = 25;

• boolean: Holds either true or false values.

Example:

let isLoggedIn: boolean = true;

• bigint: Used for very large numbers beyond the number type limit. 

Example:

let bigValue: bigint = 9007199254740991n;

• symbol: Creates unique and immutable identifiers.

example:

let id: symbol = Symbol("unique");

• User-Defined Types:
  • array: Stores multiple values of the same type.

Example:

let numbers: number[] = [1, 2, 3];

• tuple: A fixed-size array where each position has a specific type.

Example:

let user: [string, number] = ["Kumar", 30];

• enum: Defines a set of named constants for better readability.

Example:

enum Direction { Up, Down, Left, Right }
let move: Direction = Direction.Up;

• object: Represents key-value pairs with structured data.

Example: 

let person: { name: string; age: number } = { name: "Raj", age: 30 };

• Special Types:
  • any: Allows any data type but removes type safety.

Example:

let value: any = "Hello"; // Can be reassigned to any type

• unknown: Similar to any, but requires type checking before use.

Example:

let data: unknown = "TypeScript";
if (typeof data === "string") console.log(data.toUpperCase());

• void: Used for functions that don’t return a value.

Example:

function logMessage(): void {
  console.log("Logging...");
}

• null and undefined: Represent absence of a value.

Example:

let empty: null = null;
let notAssigned: undefined = undefined;

• never: Represents functions that never return, typically for errors.

Example:

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

Also Read: A Comprehensive Guide to Understanding the Different Types of Data

2. What does Type Inference mean in TypeScript?

A: Type inference means that the compiler automatically determines the type of a variable based on its initial value without requiring explicit type annotations. This helps reduce redundant type declarations while maintaining type safety.

Here’s how Type Inference works:

• Basic Inference: TypeScript infers the type of a variable based on its initial value, eliminating the need for explicit type annotations.

Example: 

let message = "Hello"; // Inferred as 'string'

• Function Return Type Inference: The return type of functions is inferred based on the return value, even if not explicitly specified.

Example:

function add(a: number, b: number) {
  return a + b; // Inferred as 'number'
}

• Array Inference: The arry type is inferred based on the elements it contains.

Example:

let numbers = [1, 2, 3]; // Inferred as 'number[]'

• Contextual Typing: The type is inferred based on the context, such as when a callback is passed to a method or event handler.

Example:

document.addEventListener("click", (event) => {
  console.log(event.clientX); // 'event' inferred as MouseEvent
});

3. Can you explain Tuples in TypeScript with an example?

A: A tuple is a special array where each element has a fixed type and position. It enables storing multiple values of different types in a structured way.

They can be used for API responses, structured data, and returning multiple values from functions.

Declaring a Tuple in TypeScript:

let user: [string, number] = ["Raj", 30];
console.log(user[0]); // Output: Raj
console.log(user[1]); // Output: 30

Example: Using Optional and Read-only Tuple

let employee: [string, number, boolean?] = ["Ram", 45]; // Optional third element
let config: readonly [number, string] = [404, "Not Found"]; // Read-only tuple

Also Read: What is Tuple in DBMS? Types, Examples & How to Work

4. What is an Anonymous Function in TypeScript?

A: An anonymous function has no name that is usually assigned to a variable or used inline. It is commonly used in callbacks, event handlers, and functional programming.

They can be sued for encapsulating functionality without polluting the global scope.

Example:

const greet = function(name: string): string {
  return `Hello, ${name}`;
};
console.log(greet("Raj")); // Output: Hello, Raj

TypeScript also supports arrow functions, which are a shorter syntax for anonymous functions.

Example:

const add = (a: number, b: number) => a + b;
console.log(add(5, 3)); // Output: 8

5. How can TypeScript be installed?

A: You can install TypeScript in two primary ways: globally for system-wide use or locally within a specific project.

Here’s how it can be installed:

• Installing Globally: Allows you to run TypeScript commands like tsc (TypeScript compiler) from any terminal.

npm install -g typescript

• Installing Locally: Allows you to run TypeScript only within the project. The compiler must be run via npx tsc.

npm install --save-dev typescript

Verifying Installation:

tsc --version

6. What are Decorators in TypeScript?

A: Decorators are special functions that modify classes, methods, properties, or parameters at runtime. They are usually used in NestJS, Angular, and metadata-driven frameworks.

Decorators are not officially supported in TypeScript. They are part of the experimental proposal and are still in the "stage 2" proposal under ECMAScript.

In Angular, decorators are used to add metadata to classes, properties, methods, and parameters. They provide information that Angular uses to configure, instantiate, and manage different parts of the application.

Importance of using Decorators:

• Code Reusability: Allows reusable logic to be used across multiple methods or classes, such as logging, validation, or dependency injection, improving maintainability.
• Improve Readability: Decorators simplify configuration and setup in Angular by reducing boilerplate code, making the code easier to read.

Example: 

function Logger(constructor: Function) {
  console.log("Logging...");
}

@Logger
class Person {
  constructor(public name: string) {}
}

The @Logger is a decorator that runs when the Person class is instantiated.

7. How do Mixins work in TypeScript?

A: Mixins are a way to combine multiple classes or behaviors into a single class. Unlike inheritance, mixins allow a class to adopt properties and methods from multiple classes.

Mixins facilitate code reuse and improve maintainability by avoiding the limitations of single inheritance.

Here is how Mixins work in TypeScript:

• Define Multiple Classes with Reusable Methods: Create separate classes with methods that you want to reuse across other classes.

Example: 

class CanRun {
  run() {
    console.log("Running");
  }
}

class CanJump {
  jump() {
    console.log("Jumping");
  }
}

• Create a Mixin Function: A mixin function copies methods from base classes to the target class, combining their behaviors.

Example:

function applyMixins(derivedCtor: any, baseCtors: any[]) {
  baseCtors.forEach(baseCtor => {
    Object.getOwnPropertyNames(baseCtor.prototype).forEach(name => {
      derivedCtor.prototype[name] = baseCtor.prototype[name];
    });
  });
}

• Apply Mixins to a New Class: Use the mixin function to apply the functionality from multiple classes to a new class.

Example:

class SuperHuman implements CanRun, CanJump {
  run!: () => void;
  jump!: () => void;
}
applyMixins(SuperHuman, [CanRun, CanJump]);
const hero = new SuperHuman();
hero.run(); // Output: Running
hero.jump(); // Output: Jumping

8. How are Classes implemented in TypeScript?

A: Classes in TypeScript are implemented with additional type annotations for properties, methods, and constructors. TypeScript supports object-oriented programming (OOP) principles through encapsulation, inheritance, and polymorphism.

Classes also support access modifiers like public, private, and protected to control properties and methods.

Example: Basic Structure of Class

class Person {
  name: string;
  age: number;

  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }

  greet(): string {
    return `Hello, my name is ${this.name}`;
  }
}

const person = new Person("Raj", 30);
console.log(person.greet()); // Output: Hello, my name is Raj

9. How do you declare a Namespace in TypeScript?

A: Namespaces allow you to group related code together, helping avoid naming conflicts and organizing code into logical units. 

A namespace may contain variables, functions, classes, and interfaces, and it helps encapsulate the code to avoid pollution of the global scope.

Example: 

namespace Geometry {
  export function calculateArea(radius: number): number {
    return Math.PI * radius * radius;
  }

  export const PI = Math.PI;
}

console.log(Geometry.calculateArea(5)); // Output: 78.53981633974483

10. What are Rest Parameters and how are they used in TypeScript?

A: Rest parameters allow functions to accept an arbitrary number of arguments as an array. In TypeScript, rest parameters are defined using the ... syntax followed by the parameter name, which collects all remaining arguments into an array.

Rest Parameters are useful when you don't know how many arguments will be passed, making your function more flexible and easier to maintain.

Example:

function sum(...numbers: number[]): number {
  return numbers.reduce((acc, num) => acc + num, 0);
}
console.log(sum(1, 2, 3, 4)); // Output: 10

11. How are Objects handled in TypeScript?

A: TypeScript allows objects to be defined as key-value pairs where the keys are typically strings (or symbols), and the values are any data type. 

TypeScript adds type safety to objects by allowing you to define specific types for their properties.

Here’s how objects are handled:

1. Defining Objects:

let person: { name: string; age: number } = {
  name: "Raj",
  age: 30,
};

2. Using Interfaces and Classes:

• Interfaces: They can be used to define object structures and then reuse them across multiple objects or functions.

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

const user: Person = { name: "Rahul", age: 25 };

• Classes: They can define objects with specific methods and properties, encapsulating both data and behavior in an object-oriented way.

class Car {
  brand: string;
  constructor(brand: string) {
    this.brand = brand;
  }
}

const myCar = new Car("Tesla");

3. Special Handling: TypeScript supports readonly properties, preventing modifications after initialization.

let user: { readonly name: string } = { name: "Alice" };
// user.name = "Bob"; // ❌ Error: Cannot assign to 'name' because it is a read-only property.

12. What are Type Aliases in TypeScript?

A: A Type Alias allows you to define a custom name for a specific type or combination of types. It’s used for complex types like unions, intersections, or object shapes, making your code more reusable.

Example 1: Defining Type Alias

type Point = { x: number; y: number };

const point: Point = { x: 10, y: 20 };

Example 2: Creating union types using type aliases.

type Status = "success" | "error" | "loading";

13. What are Modules and how do they work in TypeScript?

A: Modules are used to organize and structure code by splitting it into multiple files. By encapsulating code into logical units, you can avoid naming conflicts and improve maintainability. Modules are based on the ES6 module system, which supports import and export. 

Here’s how modules work:

• Exporting: You can export variables, functions, classes, or interfaces from a module using the export keyword.

Example:

// file: math.ts
export function add(a: number, b: number): number {
  return a + b;
}

• Importing: You can import the exported entities into other files using the import keyword.

Example:

// file: app.ts
import { add } from './math';
console.log(add(2, 3)); // Output: 5

Modules can also have a default export for a single value, which simplifies importing:

// file: greet.ts
export default function greet(name: string): string {
  return `Hello, ${name}`;
}

// file: app.ts
import greet from './greet';
console.log(greet("Raj")); // Output: Hello, Raj

14. What are Mapped Types in TypeScript?

A: Mapped types allow you to create new types by transforming properties of an existing type. They can be used for creating types that are based on the structure of other types, especially when you need to modify all or some properties.

Here’s how Mapped Types work:

A mapped type is defined using a keyof operator to iterate over keys of a type and apply transformations to the values.

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

Example: Making Properties readonly:

type Person = { name: string; age: number };
type ReadOnlyPerson = { readonly [K in keyof Person]: Person[K] };

const person: ReadOnlyPerson = { name: "Alice", age: 30 };
person.name = "Bob"; // Error: Cannot assign to 'name' because it is a read-only property.

Example: Making Properties optional:

type Person = { name: string; age: number };
type OptionalPerson = { [K in keyof Person]?: Person[K] };

const person: OptionalPerson = { name: "Alice" }; // Valid, age is optional

15. What are Conditional Types in TypeScript?

A: Conditional types allow you to define a type based on a condition that depends on another type. They follow the pattern: T extends U ? X : Y, meaning "if T extends U, use type X, otherwise, use type Y."

Here’s how Conditional Types work:

The type of value is determined by a condition, typically using the extends keyword.

Syntax:

type IsString<T> = T extends string ? "Yes" : "No";

Example 1: Simple Conditional Type

type IsString<T> = T extends string ? "Yes" : "No";
type Result1 = IsString<string>; // "Yes"
type Result2 = IsString<number>; // "No"

Example 2: Conditional Types with Union Types

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

type Result1 = ToArray<number>; // number[]
type Result2 = ToArray<number[]>; // number[]

16. What are Distributive Conditional Types and how do they function?

A: Distributive conditional types are a special form of conditional types that distribute over union types. When the conditional type is applied to a union, it automatically applies the type condition to each member of the union.

Here’s how Distributive Conditional functions:

• Without Distributive Conditional Types: If the type isn't a union, TypeScript applies the conditional type to the entire type as a whole.

type IsString<T> = T extends string ? "Yes" : "No";
type Result = IsString<number>; // Result is "No"

• With Distributive Conditional Types: When a union type is passed into a conditional type, TypeScript applies the condition individually to each member of the union.

type IsString<T> = T extends string ? "Yes" : "No";
type Result = IsString<string | number>; // "Yes" | "No"

Example: Distributive Conditional Type for Union Types

type IsString<T> = T extends string ? "Yes" : "No";
type Result = IsString<string | number>; // "Yes" | "No"

17. How can you support TypeScript files from Node Modules?

A: To use TypeScript files from Node Modules in a TypeScript project, ensure the TypeScript compiler can locate and check the type definitions within those modules.

You can do this by ensuring TypeScript definitions are available either through DefinitelyTyped or package-specific type definitions.

Here are the steps to support TypeScript files from Node Modules:

• Install Type Definitions: If the module provides type definitions, you can install them using npm or yarn:

npm install @types/module-name

• TypeScript Configuration: Make sure your tsconfig.json is correctly configured to include node_modules if necessary.

{
  "compilerOptions": {
    "typeRoots": ["node_modules/@types"]
  }
}

18. What are the main components of TypeScript?

A: TypeScript consists of components like Compiler and Type System that work together to provide advanced JavaScript features.

Here are the main components:

1. Type System: Allows defining and checking types of variables, functions, and objects, helping catch errors early.
   • Primitive Types: string, number, boolean, etc.
   • User-Defined Types: Interfaces, classes, type aliases.
2. Compiler (tsc): The compiler (tsc) converts TypeScript code into JavaScript, enforcing type checking and giving output that can run in JavaScript environments.
3. Type Declarations and Type Definitions: Declaration files (.d.ts) are used to describe the structure of external libraries, allowing you to use JavaScript libraries with type safety.
4. Type Inference: The types are automatically inferred based on the assigned values, reducing the need for explicit type annotations.
5. Advanced Features: Features like decorators, generics, interfaces, and type aliases make TypeScript powerful for large-scale applications.

19. How are Object-Oriented Principles supported by TypeScript?

A: TypeScript supports object-oriented programming (OOP) principles, such as encapsulation, inheritance, and polymorphism, to create more structured and reusable code.

Here’s how they are supported:

• Encapsulation: TypeScript supports encapsulation through access modifiers (public, private, protected), which protect access to class properties.

Example: 

class Car {
  private model: string;  // Private property, cannot be accessed outside the class
  
  constructor(model: string) {
    this.model = model;
  }

  public getModel(): string {
    return this.model;  // Public method that can be accessed outside
  }
}

const car = new Car("Tesla");
console.log(car.getModel()); // Tesla
// console.log(car.model);  // ❌ Error: Property 'model' is private

• Inheritance: To inherit properties and methods of another class, TypeScript uses the extends keyword.

Example: 

class Vehicle {
  move() {
    console.log("Moving...");
  }
}

class Car extends Vehicle {
  drive() {
    console.log("Driving...");
  }
}

const car = new Car();
car.move();  // Inherited method
car.drive(); // Car-specific method

• Polymorphism: To enable a single method to work with objects of different types, TypeScript uses method overriding or method overloading.

Example: 

class Animal {
  sound() {
    console.log("Some sound");
  }
}

class Dog extends Animal {
  sound() {
    console.log("Bark");
  }
}

const animal: Animal = new Dog();
animal.sound(); // Bark

Learn the framework of classes and objects and explore OOP principles. Join the free course on Java Object-oriented Programming.

20. What are the challenges when using Declaration Files in TypeScript?

A: Declaration files (.d.ts files) in TypeScript are used to provide type information for external libraries, especially when the library is written in JavaScript. 

Here are the challenges of using Declaration Files:

• Lack of Type Definitions for Some Libraries: Not all third-party JavaScript libraries come with built-in TypeScript support or type definitions. 
• Incomplete Type Definitions: Even with available declaration files, they may sometimes be outdated or incorrect, leading to potential type mismatches. 
• Declaring Complex Types: For complex JavaScript libraries that use advanced patterns (like mixins), writing accurate declaration files can be challenging. 
• Missing Type Checking for JavaScript Files: If a project includes JavaScript files without .d.ts files, TypeScript will not perform type checking for those files.
• Type Declaration Conflicts: Sometimes, declaration files from multiple sources may conflict with each other, leading to type errors.

Intermediate questions will help you understand concepts such as tuples, decorators, and object-oriented programming (OOP) principles like inheritance. Now, let’s explore some advanced TypeScript interview questions.

Advanced TypeScript Interview Questions for Expert Developers

Advanced interview questions will cover topics like recursion, performance optimization, and design patterns, which are vital for senior developer roles.

Here are some advanced TypeScript interview questions and answers.

1. How do you compile TypeScript using Visual Studio Code?

A: To compile TypeScript code in Visual Studio Code (VS Code), you have to set up the TypeScript compiler (tsc) and configure it within the editor. 

Here are the steps to compile:

• Install TypeScript Globally: If TypeScript is not installed globally, run the following command in the terminal:

npm install -g typescript

• Create a TypeScript Configuration File: In your project folder, create a tsconfig.json file. This file configures the TypeScript compiler options for your project.

Run tsc --init in the terminal to generate a default tsconfig.json.

• Write Your TypeScript Code: Create .ts files in your project.

// example.ts
const greet = (name: string): string => {
  return `Hello, ${name}!`;
};
console.log(greet("Raj"));

• Compile the TypeScript Code: You can run tsc in the terminal, which will use the settings in tsconfig.json to compile all TypeScript files in the project.

tsc example.ts

• Auto-Compile with VS Code: You can use the Integrated Terminal in VS Code or configure the VS Code settings to automatically compile TypeScript on file save by using the "tsc: watch" command:
  • Go to the Command Palette (Ctrl+Shift+P), search for "TypeScript: Select TypeScript Version", and choose "Use Workspace Version".
  • Once set up, VS Code will automatically compile TypeScript files when they are saved.

In addition, you can set "strict": true in tsconfig.json for strict type-checking options. This is highly recommended for TypeScript projects as it helps catch errors earlier and enforces best practices in your code.

2. What are some of the recent updates in TypeScript?

A: Here are some recent updates in TypeScript that improve developer experience and add new features:

• TypeScript 4.4: TypeScript now checks type definitions more rigorously when you install third-party packages. It can infer the type of const variable in a better way.
• TypeScript 4.5: Improved support for ECMAScript modules (ESM), improving interoperability between TypeScript and modern JavaScript. It also allows more flexibility in string manipulation.
• TypeScript 4.6: The nullish coalescing operator (??) now works with stricter type checks. New improvements regarding inference with function parameters, allowing better type safety.

3. How have TypeScript's Awaited Types and Promises improved?

A: TypeScript’s improvements in Awaited types and Promise handling have enhanced working with asynchronous operations and simplify type inference for promises.

Here’s how they have improved:

1. Awaited Type:

The new feature extracts the resolved value from a Promise. It simplifies type declarations by inferring the resolved type of an asynchronous operation.

Example:

type MyPromise = Promise<string>;
type ResolvedType = Awaited<MyPromise>; // string

2. Improved Promise Typing:

Provides better inference when working with asynchronous functions that return Promises. It can automatically infer types inside async functions and Promise chains, reducing the need for explicit type annotations.

Example:

async function fetchData(): Promise<number> {
  return 42;  // TypeScript infers this as a Promise<number>
}

4. What is Type Assertion in TypeScript? Can you explain its types?

A: Type Assertion tells the compiler to treat a variable as a specific type. It is a way to provide stronger typing when the developer knows more about the value's type than TypeScript can infer.

Here are the different forms of Type Assertion:

• Angle-Bracket Syntax: You use the angle brackets (< >) around the variable to tell the compiler about its special type.

Example: 

let someValue: any = "Hello World";
let strLength: number = (<string>someValue).length;  // Angle-bracket assertion

• as Syntax: It is the preferred method in modern TypeScript due to its compatibility with JSX/TSX in React.

Example:

let someValue: any = "Hello World";
let strLength: number = (someValue as string).length;  // 'as' syntax

5. What are Recursive Type Aliases in TypeScript?

A: Using Recursive Type aliases, you can define types that refer to themselves, enabling the creation of complex structures like recursive data types or nested objects.

They are mainly used in defining self-referential structures like trees, graphs, or linked lists, commonly found in algorithms or data structures.

Working of Recursive Types:

By referring to itself, recursive types allow types to represent nested or hierarchical data, where each item can be of the same type as its parent.

Example:

type NestedObject = {
  value: number;
  next?: NestedObject;  // The type refers to itself
};

const list: NestedObject = {
  value: 1,
  next: {
    value: 2,
    next: {
      value: 3,
    },
  },
};

6. How can Generics be implemented in TypeScript?

A: Generics creates reusable and type-safe components, functions, and classes that can operate on multiple types while maintaining the type information. 

Using Generics, you can define a function or class without specifying a particular type upfront and instead specify when calling the function/class.

Here’s how it is implemented:

• Generic Functions: A function can accept a type parameter to ensure type safety for different data types.

Example:

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

const result = identity(5);  // result has type 'number'
const stringResult = identity("Hello");  // stringResult has type 'string'

• Generic Classes: Classes can also be generic, enabling them to work with different types.

Example:

class Box<T> {
  private value: T;
  constructor(value: T) {
    this.value = value;
  }

  getValue(): T {
    return this.value;
  }
}

const numberBox = new Box<number>(123);  // Works with numbers
const stringBox = new Box<string>("hello");  // Works with strings

• Generic Interfaces: Generics can be used with interfaces to enforce flexible and type-safe contracts for objects.

Example:

interface Pair<T, U> {
  first: T;
  second: U;
}

const pair: Pair<number, string> = { first: 1, second: "one" };

7. What is the difference between the "any" and "unknown" types in TypeScript?

A: Both any and unknown allow variables to hold any type of value, but they differ in the way they handle type safety and usage.

Here’s the difference between any and unknown types:

8. How is Enum used in TypeScript?

A: An Enum defines a set of named constants. Enums can represent discrete values, such as status codes or error types, in a clear and manageable way.

Here’s how it is used:

• Numeric Enums: By default, numeric enums start at 0, and each subsequent value is incremented by 1 unless specified otherwise.

enum Direction {
  Up,    // 0
  Down,  // 1
  Left,  // 2
  Right  // 3
}

const move: Direction = Direction.Up;
console.log(move);  // Output: 0

• String Enums: String enums allow you to explicitly set the value of each enum member to a string.

enum Color {
  Red = "RED",
  Green = "GREEN",
  Blue = "BLUE"
}

const favoriteColor: Color = Color.Green;
console.log(favoriteColor);  // Output: GREEN

• Heterogeneous Enums: These can mix string and numeric values.

enum Status {
  Success = 1,
  Failed = "FAILED"
}

9. What are the different ways to define functions in TypeScript?

A: Functions in TypeScript can be defined using traditional function declarations, function expressions, and arrow functions.

Here are the different ways to define functions:

• Function Declarations: A function declaration defines a function using the function keyword, with explicit parameter types and a return type.

Example: 

function greet(name: string): string {
  return `Hello, ${name}`;
}
console.log(greet("Raj")); // Output: Hello, Raj

• Function Expressions: A function expression defines a function as part of an expression and can be assigned to a variable.

Example: 

const sum = function(a: number, b: number): number {
  return a + b;
};
console.log(sum(2, 3)); // Output: 5

• Arrow Functions: Arrow functions provide a shorter syntax and are often used for callbacks or functions that don't need their own this context.

Example:

const multiply = (a: number, b: number): number => a * b;
console.log(multiply(3, 4)); // Output: 12

• Function Types (Anonymous Functions): You can also define function types as part of variables or parameters using type annotations.

Example:

type AddFunction = (a: number, b: number) => number;
const add: AddFunction = (a, b) => a + b;
console.log(add(5, 6)); // Output: 11

10. How does TypeScript handle null and undefined differently compared to JavaScript?

A: In JavaScript, both null and undefined are falsy values. TypeScript enhances handling of these values by providing explicit type checking.

Here’s how null and undefined are handled:

• null: In TypeScript, variables that can be assigned null must be explicitly typed to allow null as a possible value.

let name: string | null = null;

• undefined: In TypeScript, variables can also be explicitly typed to accept undefined.

 
let count: number | undefined = undefined;

To handle null and undefined safely, you must use union types or enable optional chaining and nullish coalescing operators.

let user = { name: null };
console.log(user.name?.length); // Safely returns 'undefined' without errors

Now that you’ve explored advanced topics like recursion and design optimization in TypeScript, let’s check out the effective strategies to succeed in interviews.

Effective Strategies to Succeed in TypeScript Interviews

Knowledge of core concepts, such as custom types, and the ability to handle real-world scenarios, like error handling, can help tackle TypeScript interview questions.

Here are some strategies to succeed in TypeScript interview questions.

1. Understand Core TypeScript Concepts

Develop knowledge of using primitive types, custom types, interfaces, generics, and utility types like Partial<> and Readonly<>.  

Example: If you're asked to design a user profile interface, instead of relying on plain objects, use an interface:

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

2. Apply in Real-World Scenarios

Learn how to refactor JavaScript code or optimize an existing project using TypeScript. A common scenario involves working with RESTAPIs, where type safety ensures predictable responses.

Example: Instead of dealing with untyped API responses, define a response type to improve reliability:

async function fetchUserData(): Promise<UserProfile> {
  const response = await fetch('/api/user');
  return response.json();
}

3. Write Type-Safe Code 

Writing a clean, type-safe code is essential. TypeScript's strict mode discourages the use of any, so interviewers can expect you to define proper types.

Example: Implement a function to filter active users from a list:

type User = { id: number; name: string; isActive: boolean };

function getActiveUsers(users: User[]): User[] {
  return users.filter(user => user.isActive);
}

4. Debugging and Error Handling

Learn how to handle unexpected issues dynamically. A common interview scenario is handling API failures gracefully while maintaining type safety.

Example: A function that fetches user data but might return an error message instead:

type APIResponse<T> = { data?: T; error?: string };

async function fetchUser(): Promise<APIResponse<UserProfile>> {
  try {
    const response = await fetch('/api/user');
    if (!response.ok) throw new Error('Failed to fetch user');
    return { data: await response.json() };
  } catch (error) {
    return { error: (error as Error).message };
  }
}

Also Read: What is Debugging in Coding: Tools & Techniques for Debugging Explained

5. Using TypeScript in Large-scale Applications

Knowledge of modularization, type inference, and dependency management becomes crucial when working with microservices or component-driven architectures.

Example: Structure types properly when managing multiple feature modules in a React project:

// types/User.ts
export interface User {
  id: number;
  name: string;
  email: string;
}

// features/UserComponent.tsx
import { User } from '../types/User';

const UserComponent: React.FC<{ user: User }> = ({ user }) => {
  return <div>{user.name}</div>;
};

Now that you’ve examined tips to handle TypeScript interview questions, let’s check out ways to boost your knowledge in this field. 

How Can upGrad Enhance Your TypeScript Knowledge?

Knowledge of TypeScript concepts like mapping, conditional types, and handling unknown variables is essential for cracking interviews for roles such as full-stack developers. 

upGrad’s courses in basic web scripting provide foundational knowledge that prepares you for more advanced concepts in web programming.

Here are some courses for upskilling:

• JavaScript Basics from Scratch
• Advanced JavaScript for All
• Learn Basic Python Programming
• Data Structures & Algorithms

Unsure which course aligns with your career goals? upGrad offers personalized counseling to help map your learning journey and choose the right path. You can also visit your nearest upGrad offline center for an interactive experience!

Boost your career with our popular Software Engineering courses, offering hands-on training and expert guidance to turn you into a skilled software developer.

Explore our Popular Software Engineering Courses

Master in-demand Software Development skills like coding, system design, DevOps, and agile methodologies to excel in today’s competitive tech industry.

In-Demand Software Development Skills

Stay informed with our widely-read Software Development articles, covering everything from coding techniques to the latest advancements in software engineering.

Read our Popular Articles related to Software