Top TypeScript Interview Questions for 2023 - IQCode

TypeScript: An Introduction

TypeScript is an open-source programming language created by Anders Hejlsberg at Microsoft. This statically-typed language is a superset of JavaScript, which means it compiles to plain JavaScript. TypeScript offers advanced features such as code completion, safe refactorings, and IntelliSense tool for developing large-scale JavaScript applications.

Why TypeScript?

JavaScript was not initially designed to build large-scale applications, and it does not offer tools and constructs for structuring complex projects. As JavaScript projects grow in size, they become harder to maintain. TypeScript addresses these issues by adding optional static typing and features such as classes and interfaces.

TypeScript files use a .ts extension, and all valid JavaScript code is valid TypeScript code. Renaming a .js file to .ts will not affect the code. Here is an example of a standard TypeScript program that adds two numbers and returns the result with annotated type.

function add(a: number, b: number): number {
    const sum = a + b;
    return sum;

When you compile TypeScript code, it generates plain vanilla JavaScript that gets executed. TypeScript does not add any additional cost to JavaScript as it is a compile-time tool only.

TypeScript Interview Questions for Freshers

1. What are the primitive types in TypeScript?

Understanding Arrays in TypeScript

In TypeScript, arrays are a collection of elements stored in sequential order, and each element can be of any data type. Arrays can be initialized using square brackets and can be accessed using an index value starting from 0.

For example, consider an array of numbers:

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

Here, we’ve declared an array of numbers using the syntax `let arrayName: datatype[] = [values]`. We can access the elements of the array using their index values as shown below:

numbers[0]; // Returns 1
numbers[1]; // Returns 2

We can also modify the elements of an array using the index values, or add or remove elements from the array using built-in methods such as `push()`, `pop()`, `splice()`, etc.

Arrays in TypeScript are also useful for creating multidimensional arrays or arrays with mixed data types.

// Multidimensional array
let matrix: number[][] = [[1, 2], [3, 4]];

// Array with mixed datatypes
let mix: (string | number)[] = [1, 'hello'];

Overall, understanding arrays is crucial in TypeScript as they are one of the key data structures used in the language.

Understanding the Use of "Any" Type in Programming

In programming, the "any" type is used to refer to values that can be of any data type. It is a dynamic data type, which means that it is flexible and helps to improve code management efficiency.

One of the main benefits of using the "any" type is that it allows you to write code that works with many different data types. This can be useful in situations where you do not know the type of data that you will be working with in advance.

However, the use of the "any" type can also make your code more complex and harder to debug. Therefore, it is important to use this data type judiciously and only when necessary.

What is the Void Type and When Should You Use It?

The void type in programming languages is used to indicate the absence of a value. In other words, it represents "nothing" or "empty".

In C and C++, the void keyword can be used as a function return type when the function does not return a value. For example:

void function_name(parameters) {
    // code here

This indicates that the function does not return a value and should be used when returning data is not necessary or relevant to the functionality of the program.

The void keyword can also be used as a pointer type to indicate that a pointer points to a value of unspecified type. This is commonly used in dynamic memory allocation, where the size and type of the data being pointed to may not be known until the program is running.

Overall, the void type should be used when you need to indicate that there is no return value or when you need to create a pointer that can point to any type of data.

Understanding Unknown Type: When and How to Use It in TypeScript

In TypeScript, the `unknown` type is used to represent a value that is unknown during compile-time. This type is used when you have a variable whose type you can’t determine until runtime. It’s similar to the `any` type, but with stricter rules.

You should use the `unknown` type when you’re not sure what type of data you are working with. This could happen when you’re dealing with data from an external source that can be of different types, or when you’re writing a generic function that should handle different types of input.

For example, let’s say you have an API endpoint that returns data in different formats depending on the request. In this case, you can use the `unknown` type to represent the response data, as you don’t know its type until the request is made.

async function fetchData(): Promise<unknown> {
  const response = await fetch('');
  const data = await response.json();
  return data;

To use the data returned by the `fetchData()` function, you’ll need to check its type and convert it to the appropriate type:

const data: unknown = await fetchData();
if (typeof data === 'string') {
  // handle string data
} else if (Array.isArray(data)) {
  // handle array data
} else {
  // handle other data types

By using the `unknown` type, you can write code that is more flexible and can handle different types of data without sacrificing type safety. However, you should be careful when using this type, as it can lead to runtime errors if you don’t handle the data properly.

Keywords for Declaring Variables in TypeScript

In TypeScript, there are two keywords that can be used for declaring variables, namely `let` and `const`.

`let` is used for declaring variables whose values can be modified after initialization, while `const` is used for declaring variables whose values cannot be reassigned after initialization.

Here is an example:

let age: number = 25;
age = 26; // allowed

const name: string = "John";
name = "Jane"; // not allowed

To declare a function with type annotations, the syntax is as follows:

def function_name(parameter_name: parameter_type) -> return_type:
    Docstring describing the function
    # Function code here
    return return_value


- "def" is the keyword used to declare a function - "function_name" is the name of the function - "parameter_name" is the name of the function parameter - "parameter_type" is the data type of the parameter - "-> return_type" indicates the data type of the return value - "Docstring describing the function" is a brief, optional description of what the function does - "Function code here" is the actual code that the function will execute - "return_value" is the value that the function will return, if applicable.

Here's an example:

def add_numbers(num1: int, num2: int) -> int:
    Returns the sum of two numbers
    return num1 + num2

In this example, "add_numbers" is the function name, "num1" and "num2" are the parameter names, "int" is the data type of the parameters, and "int" is the data type of the return value.

Creating Objects in TypeScript

In TypeScript, we can create objects using the object literal syntax. Here's an example:

  let car = {
    make: "Toyota",
    model: "Camry",
    year: 2020

We can also create objects using a constructor function. Here's an example:

  class Person {
    name: string;
    age: number;

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

    greet() {
      console.log("Hello, my name is " + + " and I am " + this.age + " years old.");

  let person1 = new Person("John", 30);

In this example, we define a class called "Person" and create an object of that class using the "new" keyword. We then call the "greet" method on the object to display a greeting message.

Overall, creating objects in TypeScript is similar to creating objects in JavaScript with the added benefit of type safety.

Specifying Optional Properties in TypeScript

In TypeScript, we can specify optional properties in an interface by adding a question mark after the property name. For example:

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

In the above example, `age` is an optional property as it is followed by a question mark. Optional properties can be left undefined, or set to a value of `undefined`. When using an optional property, we need to check if it exists before using it to avoid runtime errors.

We can also use the `Partial` utility type provided by TypeScript to create an interface with all optional properties. For example:

interface Person {
  name: string;
  age: number;

const partialPerson: Partial<Person> = {
  age: 30,

In this example, we have used the `Partial` type to create an interface `partialPerson` with all optional properties. We can then set the `age` property to a value of `30` without setting the `name` property.

Hope it helps!

Understanding Null in TypeScript

In TypeScript, null is a special value that represents the intentional absence of an object. It is essentially a variable that has no value or points to nothing. Variables that have been declared but have not been initialized are assigned the value of null.

Null is often used in TypeScript to represent invalid, empty, or non-existent values. It is commonly used in situations where an object may or may not exist or when a value is not yet known.

Null can also be used as a way of resetting a variable to a default or initial value. For example, if a variable is used to store user input and the user clears the input field, the value of the variable can be set to null to indicate that it is now empty.

It's important to note that null is not the same as undefined in TypeScript. While null represents the intentional absence of an object, undefined represents the absence of any value or uninitialized variables.

To check for null in TypeScript, you can use the '==' or '!=' operators, or the '===' or '!==' operators to check for null and undefined at the same time.

let myVar: string = null; // variable of type string assigned null value
if(myVar == null) {
   console.log("Variable is null!");

let myNum: number = undefined; // variable of type number assigned undefined value
if(myNum === undefined) {
  console.log("Variable is undefined!");

By understanding how null works in TypeScript, you can write more robust and error-free code that handles various scenarios where null values are expected.

Understanding Undefined in TypeScript

In TypeScript, the data type 'undefined' represents a value that is not assigned to a variable. It is a primitive data type that can be assigned to a variable explicitly or whenever a value is missing from an expected location. When used as a type annotation, it indicates that a variable may contain a value of 'undefined'.

For instance, let's consider an example in which a function returns an undefined value in case of an error.

function findMax(arr: number[]): number | undefined {
  if (arr.length === 0) {
    return undefined;
  let max = arr[0];
  for (let i = 1; i < arr.length; i++) {
    if (arr[i] > max) {
      max = arr[i];
  return max;
console.log(findMax([1, 2, 3])); // Output: 3
console.log(findMax([])); // Output: undefined 

In the above example, if the input array is empty, the function returns undefined. It is safer to allow for the possibility of undefined values and handle them appropriately in our code.

Purpose of the Never Type in TypeScript

In TypeScript, the "never" type represents a type of value that never occurs. It is used to define functions that never return, or variables that are never initialized. The "never" type is a subtype of every other type, which means that it can be assigned to any other type, but no other type can be assigned to "never".

The "never" type is useful for indicating that a function will never complete, either because it will throw an error or because it will loop indefinitely. For example, we could define a function that throws an error like this:

function neverReturns(): never {
  throw new Error('This function never returns!');

We can also use the "never" type to indicate that a variable will never be initialized. For example:

let neverInitialized: never;

This can be useful for catching errors at compile time, rather than at runtime.

Overall, the "never" type is a powerful tool in TypeScript for ensuring that our code behaves as we intend it to, and for catching errors before they can cause problems in production.

Explanation of Enums in TypeScript

In TypeScript, an


is a way to create a group of related values that can be assigned to a variable. It helps to define a set of named constants and makes code more readable and expressive.

An enum can be defined using the


keyword followed by a descriptive name in PascalCase notation, and a list of members enclosed in curly braces. For example, consider the following enum that defines different types of fruits:

enum Fruit {

In this example, the


enum has three members:


(assigned a value of 0),


(assigned a value of 1), and


(assigned a value of 2). If you want to give specific values to the enum members, you can do so by using an equal sign.

We can use enums to assign values to a variable as shown below:

let myFruit: Fruit = Fruit.Apple;



is assigned the value of


, which is equivalent to



Enums are useful when you have a set of related constant values that need to be used throughout your code. It helps prevent errors that can occur if you accidentally use an incorrect value. By using enums, you make it easier for others to understand your code, and you can make your code more maintainable and scalable.H3 tag: Understanding the typeof operator in TypeScript

The `typeof` operator in TypeScript is used to determine the type of a variable or expression at runtime. It is a unary operator that returns a string representation of the operand's data type.

For example, if we have a variable `age` that holds a number:

let age = 30;
console.log(typeof age); // Output: "number"

In this example, `typeof age` returns the string `"number"`, indicating that the variable `age` holds a value of type number.

The `typeof` operator is often used in conditional statements and to check if a certain property exists on an object:

if (typeof age === "number") {
  // Do something

if (typeof someObject.someProperty !== "undefined") {
  // Do something

As TypeScript is a typed language, the `typeof` operator can also be used to check the type of a value at compile time using type guards. For example:

function add(a: number | string, b: number | string): number | string {
  if (typeof a === "number" && typeof b === "number") {
    return a + b;
  } else if (typeof a === "string" && typeof b === "string") {
    return a.concat(b);
  } else {
    throw new Error("Parameters must be either numbers or strings.");

In this example, the `typeof` operator is used to check the type of the parameters `a` and `b`, and if they are both of type `number`, it adds them together, or if they are both of type `string`, it concatenates them together. If `a` and `b` are not of the same type, an error is thrown.

In summary, the `typeof` operator is a useful tool in TypeScript for determining the type of a value at runtime, using conditional statements, and checking types at compile time.

Rest Parameters and Arguments in TypeScript

In TypeScript, rest parameters allow a function to accept an indefinite number of arguments as an array. It is denoted by three dots before the parameter name.

For example:

function sum(...numbers: number[]): number {
  return numbers.reduce((total, num) => total + num, 0);

console.log(sum(1, 2, 3)); // Output: 6
console.log(sum(1, 2, 3, 4, 5)); // Output: 15

In this example, the `sum` function takes any number of arguments and computes their sum.

Rest arguments are the opposite of spread syntax. They allow you to pass an array of values as arguments to a function without having to manually extract each value.

For example:

function multiply(num1: number, num2: number, ...moreNums: number[]): number {
  let product = num1 * num2;
  for (let i = 0; i < moreNums.length; i++) {
    product *= moreNums[i];
  return product;

console.log(multiply(2, 3)); // Output: 6
console.log(multiply(2, 3, 4)); // Output: 24
console.log(multiply(2, 3, 4, 5)); // Output: 120

In this example, the `multiply` function takes in two required parameters and an indefinite number of optional parameters using rest syntax.

Parameter Destructuring

Parameter destructuring is a feature in JavaScript that allows developers to extract properties from objects and elements from arrays and set them as parameters in a function. This can simplify code and make it more readable. It helps to avoid writing code that manually extracts properties from objects and assign them to variables. By using parameter destructuring, we can directly extract the properties as named variables within the parameter list of the function.

Explanation of TypeScript Class Syntax

TypeScript is a superset of JavaScript that incorporates a class-based object-oriented programming (OOP) model. It offers Class Syntax, which provides syntactic sugar for creating JavaScript objects with functions as methods and properties. The syntax for defining a class in TypeScript is:

class ClassName {
   constructor(arguments) {
       // implementation
   methods(arguments) {
      // implementation
   properties(arguments) {
      // implementation



is the name of the class, and the


method is called when the object is created. Methods and properties can be added to the class as needed.

An example of a TypeScript class syntax is:

class Car {
   name: string;
   year: number;
   constructor(name: string, year: number) { = name;
       this.year = year;
   start() {
       console.log("Starting " +;
   stop() {
       console.log("Stopping " +;

In this example, the class






properties, which are assigned values in the constructor method. The




methods are also defined, which log messages to the console.

Class syntax in TypeScript simplifies object-oriented programming and enables developers to write scalable and maintainable applications.

Explanation of Arrow Function Syntax in TypeScript:

In TypeScript, Arrow function syntax is used to create functions in a more concise and expressive way. The syntax uses the '=>' symbol to define a function, and usually omits the 'function' keyword and curly braces.

Here's an example of an arrow function that takes two arguments:

const addNumbers = (a: number, b: number) => a + b;

This function takes two arguments, 'a' and 'b', and returns their sum.

Arrow functions can also be used with object and array literals, which can make code more readable and easier to understand. For example:

const users = [
  { name: 'John', age: 30 },
  { name: 'Jane', age: 25 },
  { name: 'Bob', age: 40 }

const names = =>;

In this example, the 'map' method is used to create a new array containing only the names of each user in the 'users' array. The arrow function passed to 'map' takes a single argument, 'user', and returns the value of ''.

Overall, Arrow functions in TypeScript provide a more concise and expressive syntax for creating functions, making code easier to read and understand.H3 tag: Syntax for Optional Parameters in TypeScript

Code tag:

Optional parameters in TypeScript can be marked by adding a question mark after the parameter name.

function exampleFunc(param1: number, param2?: string): void {
  // function body

In the above example, the 'param1' parameter is required, while the 'param2' parameter is optional. This means that 'param2' can be passed as an argument with its value, or it can be omitted from the argument list.

Purpose of the tsconfig.json File

The tsconfig.json file is used in TypeScript to configure the compiler settings for a project. It allows developers to specify options such as the target ECMAScript version, module format, source map generation, and many others.

The file also provides a way to manage and organize the project's source files, by allowing developers to specify which files should be included or excluded from the compilation process, as well as defining any necessary compiler options for those files.

Having a tsconfig.json file in a project ensures consistent compilation options across all developers and build environments, making it easier to maintain and share TypeScript projects.


The for loop in TypeScript has three different variants:

1. for...of loop: It is used to iterate over iterable objects like arrays, strings, etc. For example:

     let arr = [10, 20, 30];<br>
     for(let val of arr){<br>

2. loop: It is used to iterate over object properties. For example:

     let obj = {name: 'John', age: 30, city: 'New York'};<br>
     for(let prop in obj){<br>
        console.log(prop + ': ' + obj[prop]);<br>

3. for loop: It is the traditional for loop used to iterate over a range of numbers. For example:

     for(let i=0; i<5; i++){<br>

It's important to choose the right variant of for loop based on the data structure being used.

Explanation of Symbol Type in TypeScript

The Symbol type in TypeScript is a new primitive data type that was introduced in ECMAScript 6. It is used to create unique object keys. Each symbol created using the Symbol() function is unique and cannot be replicated. These unique symbols can also be used as property keys of objects.

Symbols are often used to represent unique identifiers of objects or to create private object keys that are inaccessible from outside the object. They can also be used to define well-known symbols, which are used in built-in JavaScript operations, such as Symbol.iterator.

Here is an example of how to use the Symbol type:

const mySymbol = Symbol();
const obj = {};

obj[mySymbol] = 'Hello, World!';

console.log(obj[mySymbol]); // Output: Hello, World!

In this example, we create a new symbol using the `Symbol()` function and assign it to `mySymbol`. We then create a new object `obj` and add a property to it using the symbol as the key. Finally, we log the value of the property using the symbol key.

Symbols are an important part of TypeScript and can be used in a variety of applications. They are a powerful tool for creating unique identifiers and private object keys, and are a valuable addition to the JavaScript language.

Explanation of Optional Chaining in TypeScript

Optional chaining is a new feature in TypeScript that allows developers to safely access nested object properties without causing runtime errors if any of the properties in the chain are undefined or null. This helps prevent common runtime errors that occur when accessing properties on objects without first checking if those properties exist.

Suppose you have an object with nested properties like the following:

const user = { name: 'John', address: { street: '123 Main St', city: 'Anytown', zip: '12345' } };

To access the zip code, you could use the following code:

const zipCode =;

However, if the address property is undefined or null, the code will throw a runtime error. To avoid this, you can use optional chaining in the following way:

const zipCode = user?.address?.zip;

The "?" symbol after each property name checks if the property exists before attempting to access it. If any of the properties in the chain are undefined or null, the expression will return undefined instead of throwing an error.

Optional chaining is especially useful when working with APIs that return complex object structures with many nested properties. With optional chaining, you can write more concise and expressive code that is less prone to runtime errors.

Typescript Function Overloads

In TypeScript, function overloads can be created by defining multiple function signatures above the actual function implementation. Each signature should have a different parameter and return type combination. Here's an example:

function reverse(string: string): string;
function reverse<T>(array: T[]): T[];
function reverse(stringOrArray: string | any[]): string | any[] {
  if (typeof stringOrArray === 'string') {
    return stringOrArray.split('').reverse().join('');
  } else {
    return stringOrArray.slice().reverse();

In this example, we have defined two function signatures for the `reverse` function. The first signature expects a string argument and returns a string. The second signature uses a generic type `T` to represent an array of any type and returns an array of the same type. The final implementation of the `reverse` function checks the type of the argument passed in and either reverses a string or an array.

You can add as many function signatures as necessary to cater to different argument types and return types. TypeScript will automatically choose the correct signature based on the arguments passed in.

Meaning of Type Inference

Type inference is a feature in programming languages that automatically deduces the data type of a variable based on its value. This means that the programmer does not have to explicitly state the data type when declaring variables, as the language can figure it out on its own. It helps in writing cleaner and shorter code, and can also catch some errors during compilation.

Understanding the Concept of Contextual Typing

Contextual typing is a feature in programming languages that allows the compiler to deduce the data type of a variable based on its context and usage, rather than declaring the data type explicitly. This means that the type of a variable can be inferred by the program's syntax and semantics, rather than being explicitly specified by the developer.

For example, in JavaScript, using the "var" keyword to declare a variable without explicitly stating its data type allows the language to infer the type based on how the variable is used in the code. This can make the code more concise and easier to read, as well as facilitating the use of more complex data structures.

Contextual typing is a common feature in modern programming languages, including TypeScript, Java, and Swift, and is generally considered a useful tool for improving developer productivity and code maintainability.

The Purpose of NoImplicitAny

The "noImplicitAny" option in TypeScript is used to ensure that all variables have a defined type. When this option is set to "true", the TypeScript compiler throws an error if a variable is declared without a type annotation. This helps to catch potential bugs early and improve the overall type safety of the code. In short, "noImplicitAny" enforces explicit type declarations of variables and functions in TypeScript.

Understanding Interfaces in Object-Oriented Programming

In object-oriented programming, an interface is a blueprint for a group of related functions that a class or a struct can implement. An interface declares a set of methods, properties, events, or indexers, but it doesn't contain their implementation. Instead, when a class inherits an interface, it must provide the implementation of all its members.

Interfaces enable us to define the contract between different components of our application without exposing their internal details. For example, a simple calculator interface may have methods for addition, subtraction, multiplication, and division, but any class that implements this interface can decide how to perform these operations.

In C#, an interface is defined using the interface keyword followed by a name and a list of members in curly braces. Here's an example of a simple interface:


public interface ICalculator
    int Add(int x, int y);
    int Subtract(int x, int y);
    int Multiply(int x, int y);
    int Divide(int x, int y);

When a class implements this interface, it must provide an implementation for all four methods. Here's an example of a simple calculator class that implements this interface:


public class SimpleCalculator : ICalculator
    public int Add(int x, int y)
        return x + y;

    public int Subtract(int x, int y)
        return x - y;

    public int Multiply(int x, int y)
        return x * y;

    public int Divide(int x, int y)
        return x / y;

By implementing the ICalculator interface, the SimpleCalculator class can be used interchangeably with any other class that implements the same interface, without any modification to the calling code. This makes our code more flexible, maintainable, and extensible.

Explanation of Member Visibility Control in TypeScript

In TypeScript, there are three types of member visibility controls - public, private, and protected.

1. Public: When a member is marked as public, which is the default case in TypeScript, it can be accessed from outside the class and inside the class.

2. Private: Members marked as private can only be accessed within the class they are declared in. Private members are often used to hide implementation details.

3. Protected: Members marked as protected can be accessed within the class and its subclasses (inheritance). Protected members help in encapsulation and inheritance.

For example, consider the following TypeScript class:

class MyClass {
  public a: number;
  private b: string;
  protected c: boolean;

In the above code, `a` is a public member that can be accessed from anywhere, while `b` is a private member that can only be accessed within the class `MyClass`. Similarly, `c` is a protected member that can be accessed within `MyClass` and its subclasses.

To utilize the benefits of these visibility controls, it's important to properly design and organize class structures in TypeScript.

Does TypeScript support static classes? If not, why?

In TypeScript, we can create classes with static properties and methods using the `static` keyword. These properties and methods are attached to the class constructor function instead of the instances of the class. Therefore, we can access them using the class name without creating an object of the class.

For example, consider the following code snippet:

class MyClass {
  static myStaticProperty: string = "Hello, World!";

  static myStaticMethod(): void {

console.log(MyClass.myStaticProperty);  // Output: "Hello, World!"
MyClass.myStaticMethod();  // Output: "Hello, World!"

As we can see, we can define static properties and methods in TypeScript classes.

However, we cannot define a class as `static` in TypeScript, as it is not a valid JavaScript syntax. Classes are not values that can be passed around, so they cannot be made `static`.

Abstract Classes in Object-Oriented Programming

In object-oriented programming, abstract classes are classes that cannot be instantiated directly and are meant to be used as base classes for other classes. They are designed to provide a common interface for a set of related classes, but without specifying the implementation details for each class.

Abstract classes are defined using the "abstract" keyword in their class declaration. They may have abstract methods, which are declared without an implementation, as well as non-abstract methods, which do have an implementation. Any class that inherits from an abstract class must provide an implementation for its abstract methods.

Abstract classes are particularly useful when designing complex systems where there are several related classes, but they differ in certain key ways. By using an abstract class as a base class, you can define a common set of methods and properties that all the related classes share, while allowing each class to implement its unique functionality in its own way. You can also ensure that the related classes adhere to a certain design pattern or interface, which can make your code easier to maintain and extend over time.

Understanding Anonymous Functions in TypeScript

In TypeScript, an anonymous function is a function without a name. It is also known as a lambda or arrow function. The syntax for an anonymous function in TypeScript is as follows:

(parameter1: type, parameter2: type, ...) => {
  // function body

Here, `(parameter1: type, parameter2: type, ...)` are the function parameters, and `=>` is the arrow operator that separates the function parameters from the function body. The function body is enclosed in curly braces `{}`.

For example, if we want to define an anonymous function that returns the sum of two numbers, the code would look like this:

let sum = (a: number, b: number) => {
  return a + b;

In the above code, `sum` is an anonymous function that takes two parameters `a` and `b` of type `number` and returns their sum.

We can also write the same function in a shorter form using the shorthand syntax of TypeScript's arrow function:

let sum = (a: number, b: number) => a + b;

In the above code, we have omitted the curly braces `{}` and the `return` keyword to make the code more concise.

Understanding Union Types in TypeScript

Union types in TypeScript allow a variable to have multiple possible data types, providing more flexibility compared to single data type variables. A union type is created by using the pipe operator '|' between the possible data types.

For example, let's say we have a variable called 'result' that can either be a string or a number, we can define the variable using union types as follows:


let result: string | number;

Now, the 'result' variable can either hold a string or a number value. We can assign values to the 'result' variable using any of these data types without TypeScript throwing an error:


result = "success"; // assigning a string value
result = 10; // assigning a number value

Using union types can help improve the type safety of our code while allowing for more flexibility in variable declarations.

Intersection Types in TypeScript

Intersection types in TypeScript allow us to combine multiple types into one. This means we can create a new type that has all the properties and methods of the combined types. Intersection types are denoted by the `&` symbol. For example, we can define an intersection type between two interfaces as follows:

interface Dog {
  name: string;
  breed: string;

interface Cat {
  name: string;
  age: number;

type DogCat = Dog & Cat;

Here, the `DogCat` type is an intersection of `Dog` and `Cat`. It has all the properties and methods of both `Dog` and `Cat` interfaces. We can use `DogCat` type to specify a variable that can hold values of either `Dog` or `Cat`.

Intersection types are useful in situations where we need to combine multiple types and create a new type that has all the features of the combined types. In TypeScript code, intersection types can increase code readability and make code more expressive.

Understanding Type Aliases and Creating One in Python

In Python, type aliases are alternate names given to existing complex types for convenience. They allow developers to create more readable and descriptive code.

To create a type alias, you can use the `typing` module and the `TypeAlias` function. Here's an example:

from typing import List, Tuple

# Type alias
Vector = List[float]
Coordinate = Tuple[float, float]

def scale(scalar: float, vector: Vector) -> Vector:
    return [scalar * num for num in vector]

def translate(translation: Coordinate, vector: Vector) -> Vector:
    return [translation[0] + num for num in vector], [translation[1] + num for num in vector]

In the example, we define a type alias `Vector` for the list of floating-point numbers. We also define a type alias `Coordinate` for a tuple of two floating-point numbers.

Then, we use these aliases as parameters in the `scale()` and `translate()` functions. This way, it becomes easier to understand what kind of data we expect and return.

Tuple Types in TypeScript

In TypeScript, a tuple is a type that allows you to express an array with a fixed number of elements, where each element can have a different data type. Tuple types are defined using square brackets "[]" and the types of the elements are written inside parentheses "()".

For example, a tuple of a string and a number can be defined as:

let myTuple: [string, number] = ["hello", 1];

Once a tuple type is defined, the order and number of elements must match exactly.

Tuples can be used to represent structures or objects in a more intuitive way. For instance, a tuple with three elements indicating a person's name, age, and address can be defined as:

let person: [string, number, string] = ["John", 30, "123 Elm Street"];

You can also access individual elements in a tuple using their index positions, similar to accessing array elements:

console.log(person[0]); // Output: "John"
console.log(person[1]); // Output: 30
console.log(person[2]); // Output: "123 Elm Street"

Tuple Destructuring in TypeScript

In TypeScript, tuple destructuring is a way to extract values from an array and assign them to individual variables. Here's how it works:

Let's say we have an array with two items:

const myArray = ['foo', 42];

We can create two variables (`myString` and `myNumber`) that correspond to the values in the array like this:

const [myString, myNumber] = myArray;

Now `myString` is assigned the value `'foo'` and `myNumber` is assigned the value `42`.

We can also use tuple destructuring with functions:

function getFooBar(): [string, number] {
  // some logic that returns a tuple
  return ['foo', 42];

const [myFoo, myBar] = getFooBar();

This will call the `getFooBar` function and assign the first value to `myFoo` and the second value to `myBar`.

Tuple destructuring is a powerful feature in TypeScript that simplifies code by allowing us to access array elements easily.

Understanding Type Assertions in TypeScript

Type assertions in TypeScript are a way to tell the compiler that we know the type of a variable more precisely than it does. This can be useful in situations where TypeScript can't infer the type on its own or when we know that the type will be different from what TypeScript has assumed.

For instance, consider the following code snippet:

const myVariable: unknown = "hello world";
const myLength = myVariable.length;

TypeScript would throw an error stating that the type "unknown" does not have a "length" property. This is because TypeScript cannot assume anything about the type "unknown". In this case, we can use a type assertion to tell TypeScript that the type of "myVariable" is actually a string:

const myVariable: unknown = "hello world";
const myLength = (myVariable as string).length;

The "as" keyword is used for type assertions in TypeScript. The above code snippet will not throw any errors, since we have told TypeScript that "myVariable" is a string. However, we need to be careful while using type assertions, since they can potentially lead to run-time errors if the type assertion is incorrect.

Enforcing Strict Null Checks in TypeScript

In TypeScript, strict null checks can be enforced by enabling the `strictNullChecks` flag in the `tsconfig.json` file. This flag will ensure that variables and parameters cannot be assigned a value of `null` or `undefined` unless explicitly specified.

Here is an example of enabling strict null checks in `tsconfig.json`:

  "compilerOptions": {
    "strictNullChecks": true

By enabling this flag, TypeScript will provide compile-time errors if variables or parameters are not properly initialized or have the potential to be `null` or `undefined`. This can help prevent unwanted runtime errors and improve the overall reliability of your code.

For example, consider the following function:

function getLength(str: string) {
  if (str) {
    return str.length;

Without strict null checks enabled, this function would compile without errors. However, the function has a potential runtime error if `str` is `undefined` or `null`. With strict null checks enabled, TypeScript will throw a compile-time error and force the developer to handle this case explicitly.

Overall, enabling strict null checks can help improve the safety and maintainability of your TypeScript code.

How to Use the "Readonly" Keyword to make Object Properties Immutable in TypeScript?

In TypeScript, the "readonly" keyword is used to enforce immutability for object properties. When a property is marked as "readonly", it can only be assigned a value once. Any subsequent attempts to modify it will result in a compile-time error.

Here is an example of how to use the "readonly" keyword:

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

let person: Person = { name: "John Doe", age: 30 }; = "Jane Doe"; // Compilation error: "Cannot assign to 'name' because it is a read-only property."

In the above example, the "Person" interface has two properties that are marked as "readonly": name and age. When we initialize the "person" object, we assign values to these properties. The "name" property cannot be modified because it's marked as "readonly", and attempting to do so will result in a compilation error.

By using the "readonly" keyword in TypeScript, you can ensure that certain properties of an object are immutable, which can help prevent bugs and make your code more reliable.

Understanding Type Declaration Files

A type declaration file is a file that describes the shape of an existing JavaScript codebase, either a library or a complex application. It provides type information for the entities exported from that codebase, such as functions, variables, and classes. This helps developers incorporate external code into their own projects and ensure they are using it correctly. In TypeScript, type declaration files have a `.d.ts` file extension and can be generated automatically using the `--declaration` compiler option.

Triple-Slash Directives Explained

Triple-slash directives are special comments used in TypeScript files to provide additional instructions to the TypeScript compiler. They are indicated by three slashes (///) and are placed at the top of the file or at the top of a module, class, or function declaration.

Triple-slash directives can be used to reference external libraries, to specify module dependencies, or to configure compiler options. Some common examples include:

- /// - /// - /// - ///

By using triple-slash directives, developers can extend the capabilities of TypeScript and ensure that their code is properly compiled and optimized for their intended use.

Purpose of the 'in' Operator

The 'in' operator is used to check if a specified value/variable exists within an iterable object such as a list, tuple, or dictionary. It returns a boolean value based on whether the specified value is found in the iterable object or not.

For example, if we have a list of names, we can use the 'in' operator to check if a specific name exists in the list or not.


names = ['Alice', 'Bob', 'Charlie']
if 'Charlie' in names:
    print('Charlie exists in the list')
    print('Charlie does not exist in the list')


Charlie exists in the list

In the above code, we are checking whether 'Charlie' exists in the 'names' list using the 'in' operator. Since 'Charlie' is present in the list, the output would be 'Charlie exists in the list'.

Understanding the 'implements' Clause in TypeScript

In TypeScript, the 'implements' clause is used to indicate that a class implements a particular interface. The 'implements' keyword is followed by the name of the interface that the class is implementing.

For example:

interface Shape {
  calculateArea(): number;

class Rectangle implements Shape {
  width: number;
  height: number;

  constructor(width: number, height: number) {
    this.width = width;
    this.height = height;

  calculateArea() {
    return this.width * this.height;

In the code above, the 'Rectangle' class implements the 'Shape' interface using the 'implements' keyword. The 'Shape' interface requires that any class implementing it have a 'calculateArea' method that returns a number. The 'Rectangle' class defines a 'calculateArea' method that returns the product of its width and height.

Using the 'implements' clause allows us to ensure that a class conforms to a certain interface, which can help us write more modular and reusable code.

Explanation of String Literal Types

String Literal Types are a type of string that is constrained to a set of specific values defined at the point of declaration. In other words, they are specific strings or characters that are assigned to a variable.

For example, suppose we want to define a variable that can only take two possible values: "male" or "female". In that case, we can use string literal types to constrain the variable to those two values only, like this:

type Gender = "male" | "female";
let myGender: Gender = "male";

In this example, we define a type `Gender` that can only be either "male" or "female". Then, we declare a variable `myGender` of type `Gender`, and assign the value "male" to it.

String Literal Types can be useful in scenarios where we want to limit the possible values of a variable or parameter in a function. By constraining the values to a specific set, we can avoid programming errors and make our code more robust.

Explanation of Template Literal Types

Template Literal Types are a relatively new feature in TypeScript that allow for more precise type definitions by leveraging the power of template literals. Template literals support embedded expressions, which can be used to build up strings in a more dynamic way. With template literal types, we can use the same syntax to define a type that not only describes the shape of a string but also constrains its contents. This makes it possible to create more specific types that can be used to enforce certain rules and restrictions at compile-time. Overall, the use of Template Literal Types can lead to more robust and reliable code.

Explanation of Inheritance in TypeScript

In the context of TypeScript, inheritance refers to the ability of a class to inherit properties and methods from a parent class. This enables the child class to reuse code from the parent class, thereby promoting code reuse and reducing redundancy.

To implement inheritance in TypeScript, you can use the "extends" keyword followed by the name of the parent class. The child class can then access the parent class properties and methods using the "super" keyword.

For example, consider a parent class "Animal" with a method "move" that prints a message. We can create a child class "Dog" that inherits from the Animal class and adds its own properties and methods. The Dog class can then call the move method from the Animal class using the "super.move()" syntax.

class Animal {
  move() {

class Dog extends Animal {
  breed: string;

  constructor(breed: string) {
    this.breed = breed;

  bark() {

const d = new Dog("Labrador");
d.move(); // Output: Moving...
d.bark(); // Output: Barking...

In this example, the Dog class inherits the move method from the Animal class and adds its own bark method. By using inheritance, we are able to reuse the move method from the Animal class without having to redefine it in the Dog class.

Conditional Types in TypeScript

Conditional types in TypeScript are used to define a type that depends on another type. They allow you to write type-level conditions that depend on the properties of another type.

Here's an example of a conditional type in TypeScript:

type MyConditionalType<T> = T extends string ? string : number;

In this example, we have defined a conditional type called


that takes a type parameter


. If


extends a


, then


evaluates to a


, otherwise, it evaluates to a



To create a conditional type, you use the


keyword to test the given type against a condition and return one of two possible types based on whether the condition is true or false.

Conditional types are useful in situations where you want to create a type that depends on runtime information, such as the type of a variable at runtime.


In TypeScript, we can define the type of a function using function types.

A function type describes the parameters and return type of a function. It consists of the parameter types enclosed in parentheses, followed by the return type after a => arrow.

Here's an example:

// Function type (param1: number, param2: string) => boolean;

// Function declaration that matches the function type function myFunction(param1: number, param2: string): boolean { // function body return true; }

In the above example, we defined a function type that takes in two parameters - a number and a string, and returns a boolean value. We then declared a function that matches this function type.

Function types can be used to define the type of variables that store functions, as well as function parameters and return values. They are a powerful feature of TypeScript that adds more type safety to our code.

List of Utility Types in TypeScript and their Usage

TypeScript provides several utility types that can be used to manipulate and transform types. Here are some of the commonly used utility types and their usages:


- returns a type with all properties of T set to optional. This means that you can assign an object with only some of the properties required by T. Example:

interface Person { name: string; age: number; } type PartialPerson = Partial<Person>;

- returns a type with all properties of T set to required. This means that you cannot assign an object without all of the properties required by T. Example:

interface Person { name?: string; age?: number; } type RequiredPerson = Required<Person>;

- returns a type with all properties of T set to readonly. This means that you cannot modify any of the properties of an object of type T. Example:

interface Person { readonly name: string; readonly age: number; } type ReadonlyPerson = Readonly<Person>;
Pick<T, K>

- returns a type with only the specified properties K of type T. Example:

interface Person { name: string; age: number; address: string; } type PersonNameAndAddress = Pick<Person, 'name' | 'address'>;
Omit<T, K>

- returns a type excluding the specified properties K from type T. Example:

interface Person { name: string; age: number; address: string; } type PersonWithoutAge = Omit<Person, 'age'>;
Record<K, T>

- returns a type with a set of properties K, and all values set to the type T. Example:

type PersonMap = Record<string, Person>;

These utility types provide a lot of flexibility when it comes to writing code with TypeScript, making your code more readable and maintainable.


This section presents the concluding remarks of the study.

Technical Interview Guides

Here are guides for technical interviews, categorized from introductory to advanced levels.

View All

Best MCQ

As part of their written examination, numerous tech companies necessitate candidates to complete multiple-choice questions (MCQs) assessing their technical aptitude.

View MCQ's
Made with love
This website uses cookies to make IQCode work for you. By using this site, you agree to our cookie policy

Welcome Back!

Sign up to unlock all of IQCode features:
  • Test your skills and track progress
  • Engage in comprehensive interactive courses
  • Commit to daily skill-enhancing challenges
  • Solve practical, real-world issues
  • Share your insights and learnings
Create an account
Sign in
Recover lost password
Or log in with

Create a Free Account

Sign up to unlock all of IQCode features:
  • Test your skills and track progress
  • Engage in comprehensive interactive courses
  • Commit to daily skill-enhancing challenges
  • Solve practical, real-world issues
  • Share your insights and learnings
Create an account
Sign up
Or sign up with
By signing up, you agree to the Terms and Conditions and Privacy Policy. You also agree to receive product-related marketing emails from IQCode, which you can unsubscribe from at any time.