TypeScript interview questions and answers

TypeScript is an open-source programming language that is a superset of JavaScript. It was developed by Microsoft and first released in 2012. TypeScript is designed to make it easier to build large-scale JavaScript applications by adding optional static type checking, class-based object-oriented programming, and interfaces to the language.

TypeScript is fully compatible with existing JavaScript code and can be used to develop both client-side and server-side applications. It compiles down to plain JavaScript, which can be run in any browser or runtime environment that supports JavaScript.
One of the key benefits of using TypeScript is that it catches errors at compile-time rather than at runtime, which can save developers a lot of time and effort in debugging. By adding type annotations to variables, functions, and objects, TypeScript helps to ensure that code is more predictable, easier to maintain, and less error-prone.
TypeScript also includes modern language features such as async/await, decorators, and generics, which can help developers to write more concise and expressive code. Additionally, TypeScript integrates with popular development tools such as Visual Studio Code, Webpack, and Babel, making it easy to incorporate into existing development workflows.
Overall, TypeScript is a powerful and flexible language that can help developers to write more robust and maintainable code, particularly for larger-scale projects.

Here's an example implementation of a TypeScript class that represents a bank account:

class BankAccount {
  private balance: number;

  constructor() {
    this.balance = 0;
  }

  deposit(amount: number): void {
    this.balance += amount;
  }

  withdraw(amount: number): void {
    if (this.balance >= amount) {
      this.balance -= amount;
    } else {
      throw new Error('Insufficient funds');
    }
  }

  getBalance(): number {
    return this.balance;
  }
}

In this example, the BankAccount class has a private balance property, initialized to 0 in the constructor. The deposit method takes an amount as a parameter and adds it to the account balance. The withdraw method checks if the account has sufficient funds and deducts the amount if possible, otherwise throwing an error. The getBalance method returns the current balance of the account.
Here's an example of how you can use the BankAccount class:

const account = new BankAccount();
console.log(account.getBalance()); // Output: 0

account.deposit(100);
console.log(account.getBalance()); // Output: 100

account.withdraw(50);
console.log(account.getBalance()); // Output: 50

account.withdraw(100); // Throws an error: Insufficient funds

This is a basic example of how you can implement a bank account class in TypeScript. You can extend this class with additional features, such as transaction history, account holder information, or interest calculation, based on your specific requirements.

In TypeScript, arrays are used to store a collection of values of the same type. The syntax for declaring an array in TypeScript is similar to JavaScript:

// declare an array of numbers
let myArray: number[] = [1, 2, 3, 4, 5];

In this example, we declare an array of numbers and initialize it with some values. The type of the array is specified using the syntax number[], which indicates that the array can only contain values of the number type.
Arrays in TypeScript also support a number of methods and properties that can be used to manipulate and access their contents. Here are some examples:

// add an element to the end of the array
myArray.push(6);

// remove the last element of the array
myArray.pop();

// get the length of the array
let length = myArray.length;

// access an element of the array
let firstElement = myArray[0];

In addition to these standard array methods, TypeScript also provides support for higher-order functions such as map, filter, and reduce, which allow developers to perform complex operations on arrays with ease.
Overall, arrays in TypeScript are a powerful and flexible way to work with collections of values, and are a core part of many TypeScript applications.

In programming, a data type is a classification of data that determines the possible values that a variable or expression can take, as well as the operations that can be performed on it. 
In TypeScript, there are several primitive data types that can be used to represent simple values. Here are some examples of primitive data types in TypeScript:
1. `number`: Used to represent numeric values, including integers, decimals, and floating-point numbers.
2. `string`: Used to represent textual data, such as words, phrases, and sentences.
3. `boolean: Used to represent logical values, which can be either true or false`.
4. `null and undefined: Used to represent the absence of a value. null is typically used to indicate that a variable or object has no value, while undefined` is used to indicate that a variable or object has not been initialized.
5. `symbol`: Used to represent unique identifiers, which are often used in object properties and as keys in maps and sets.
These primitive data types are the building blocks of more complex data structures in TypeScript, such as arrays, objects, and classes. Understanding the different data types in TypeScript is important for writing clear and concise code that is easy to read and maintain.

In TypeScript, an interface is a way of defining a contract or shape for an object. An interface describes the properties and methods that an object should have, without providing an implementation for those properties and methods.
Here's an example of how to define an interface in TypeScript:

interface Person {
  firstName: string;
  lastName: string;
  age: number;
}

In this example, we define an interface called Person that requires an object to have three properties: firstName, lastName, and age. The firstName and lastName properties must be of type string, while the age property must be of type number.
We can then use this interface to ensure that an object conforms to this shape:

function printPerson(person: Person) {
  console.log(`Name: ${person.firstName} ${person.lastName}, Age: ${person.age}`);
}

let myPerson = { firstName: "John", lastName: "Doe", age: 30 };
printPerson(myPerson);

In this example, we define a function called printPerson that expects an argument of type Person. We then create an object called myPerson that matches the shape of the Person interface, and pass it to the printPerson function.
Using interfaces in this way can help to ensure that objects in a TypeScript application conform to a consistent shape, making it easier to write and maintain code. Interfaces can also be used to define more complex object shapes, including interfaces that extend other interfaces and interfaces with optional properties.

In TypeScript, a class is a blueprint for creating objects that share similar characteristics and behavior. A class defines the properties and methods that an object should have, and provides an implementation for those properties and methods. Classes are an essential part of object-oriented programming (OOP) and are used to create reusable and modular code.
Here's an example of how to define a class in TypeScript:

class Person {
  firstName: string;
  lastName: string;
  age: number;

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

  getFullName() {
    return `${this.firstName} ${this.lastName}`;
  }
}

In this example, we define a class called Person that has three properties (firstName, lastName, and age) and one method (getFullName). We also define a constructor function that initializes the values of these properties when a new object is created.
Classes in TypeScript can be used to create objects with behavior and state, whereas interfaces are used to describe the shape or structure of an object without providing an implementation. Interfaces cannot contain any implementation code, and they are not instantiated like classes.
Here's an example of how an interface might be used to describe the shape of the Person class:

interface Person {
  firstName: string;
  lastName: string;
  age: number;
  
  getFullName(): string;
}

In this example, we define an interface called Person that has the same properties and method as the Person class. However, the interface does not provide an implementation for the getFullName method. Instead, it simply describes the method signature.
In general, classes are used when you need to create objects with state and behavior, while interfaces are used when you need to describe the shape of an object. However, there are many cases where you might use both classes and interfaces together in a TypeScript application, depending on your specific requirements.

Here's an example TypeScript program that reads a JSON file, performs filtering, sorting, and transformation operations on the data:

import * as fs from 'fs';

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

// Read JSON data from file
const jsonData = fs.readFileSync('data.json', 'utf8');
const data: Person[] = JSON.parse(jsonData);

// Filter persons who are older than 30
const filteredData = data.filter(person => person.age > 30);

// Sort persons by name in ascending order
const sortedData = data.sort((a, b) => a.name.localeCompare(b.name));

// Transform data to include city and age information only
const transformedData = data.map(person => ({ city: person.city, age: person.age }));

console.log('Filtered Data:', filteredData);
console.log('Sorted Data:', sortedData);
console.log('Transformed Data:', transformedData);

In this example, we first import the fs module from Node.js to read the JSON file. We define an interface Person to represent the structure of each object in the JSON data.
We then read the JSON data from the file using fs.readFileSync and parse it into an array of Person objects.
Next, we perform various operations on the data. We filter the data to include only persons older than 30 using the filter method. We sort the data by name in ascending order using the sort method with a comparison function. Finally, we transform the data to include only the city and age information using the map method.
Finally, we log the filtered data, sorted data, and transformed data to the console.
Note: Make sure to replace 'data.json' with the actual path to your JSON file.
You can customize the filtering, sorting, and transformation logic based on your specific requirements.

In TypeScript, there are two ways to specify types: implicit and explicit. Implicit typing is when TypeScript infers the type of a variable based on its value, while explicit typing is when you specify the type explicitly in the code.
Here are some examples of implicit and explicit types in TypeScript:
**Implicit Typing:**

let name = "John"; // TypeScript infers that name is of type string
let age = 30; // TypeScript infers that age is of type number
let isMarried = false; // TypeScript infers that isMarried is of type boolean

In this example, we define three variables (name, age, and isMarried) without specifying the type explicitly. TypeScript infers the type based on the value that is assigned to the variable.
**Explicit Typing:**

let firstName: string = "John";
let lastName: string = "Doe";
let age: number = 30;
let isMarried: boolean = false;

In this example, we define the same three variables, but we specify the type explicitly using a colon (:) followed by the type. This is known as explicit typing.
Explicit typing can be useful when you want to specify the type of a variable that TypeScript cannot infer, or when you want to ensure that a variable has a specific type to prevent errors at runtime.
In general, it's recommended to use implicit typing when possible, as it can help to reduce the amount of boilerplate code in your TypeScript files. However, there are times when explicit typing may be necessary or desirable, depending on the specific requirements of your code.

TypeScript offers several advantages over traditional JavaScript:
1. **Type safety:** TypeScript introduces a static type system that allows developers to catch errors early in the development process, before they manifest at runtime. This can help to reduce bugs, improve code quality, and make refactoring easier and safer.
2. **Increased productivity:** TypeScript provides features like type inference, code completion, and refactorings that can help developers write code faster and with fewer errors.
3. **Better tooling:** TypeScript works well with popular IDEs like Visual Studio Code, providing advanced features like intelligent code completion, real-time error checking, and inline documentation.
4. **Improved maintainability:** By providing a more structured approach to programming, TypeScript can make code easier to understand, modify, and maintain over time. This can help to reduce the costs and risks associated with software maintenance.
5. **Compatibility with existing JavaScript codebases:** TypeScript is a superset of JavaScript, which means that any valid JavaScript code is also valid TypeScript code. This allows developers to gradually adopt TypeScript into existing JavaScript codebases without having to rewrite everything from scratch.
6. **Strong community support:** TypeScript has a large and growing community of developers, which means that there are plenty of resources available for learning, troubleshooting, and sharing best practices.
Overall, TypeScript can help developers write safer, more productive, and more maintainable code, which can lead to better software quality and faster development cycles.

While TypeScript offers many advantages, there are also some potential disadvantages to using it:
1. **Learning curve:** TypeScript has a steeper learning curve than traditional JavaScript, particularly for developers who are new to statically-typed languages or who are used to the more dynamic and flexible approach of JavaScript.
2. **Additional tooling:** To take full advantage of TypeScript, developers may need to set up additional tooling, such as build systems or task runners, which can add complexity to the development process.
3. **Overhead and complexity:** Because TypeScript is a more structured language than JavaScript, it can add overhead and complexity to some codebases. This can make it more difficult to write concise and maintainable code, particularly for small or simple projects.
4. **Runtime overhead:** While TypeScript can catch many errors at compile-time, there is still some runtime overhead associated with using the language. This can lead to longer development and testing cycles, and potentially slower code execution in some cases.
5. **Limited type system:** TypeScript's type system is not as powerful or flexible as some other statically-typed languages, such as Haskell or Rust. This can limit its ability to catch certain types of errors or enforce more complex constraints.
Overall, the benefits of TypeScript usually outweigh its drawbacks for most use cases, but it's important for developers to consider the tradeoffs carefully before deciding to use it in their projects.