TypeScript

Question 1

How do you declare a variable with a specific type in TypeScript?

Answer 1

Use the let or const keyword followed by the variable name and a type annotation. For example:

let name: string;
const age: number = 30;

Question 2

What is the syntax for defining a function with typed parameters and a return type in TypeScript?

Answer 2

Define the function with parameter types and a return type. For example:

function sum(lhs: number, rhs: number): number {
  return lhs + rhs;
}

Question 3

How do you create an array of numbers in TypeScript?

Answer 3

Use square brackets with the type number. For example:

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

Question 3

What is a tuple in TypeScript, and how do you define one?

Answer 3

A tuple is an array with a fixed number of elements of specified types. Define it using square brackets with types. For example:

let book: [string, number];
book = ["sample", 1980];

Question 4

How do you define a class with private, protected, and public properties in TypeScript?

Answer 4

Use the class keyword and specify access modifiers for each property. For example:

class Dimension {
  private length: number;
  protected width: number;
  public height: number;

  constructor(l: number, w: number, h: number) {
    this.length = l;
    this.width = w;
    this.height = h;
  }

  getLength(): number {
    return this.length;
  }
}

Question 5

What is an interface in TypeScript, and how do you implement it in a class?

Answer 5

An interface defines a contract for object shapes. Implement it in a class using the implements keyword. For example:

interface Area {
  area(): number;
}

class Rectangle implements Area {
  constructor(public length: number, public width: number) {}

  area(): number {
    return this.length * this.width;
  }
}

Question 6

How do you handle exceptions in TypeScript?

Answer 6

Use try…catch blocks to handle exceptions. For example:

try {
  // code that may throw an error
} catch (e) {
  console.error(`An error occurred: ${e}`);
}

Question 7

What is optional chaining in TypeScript, and how is it used?

Answer 7

Optional chaining allows safe access to nested object properties that might be null or undefined. Use the ?. operator. For example:

console.log(result?.pii?.age);

Question 8

How do you define a generic function in TypeScript?

Answer 8

Use angle brackets to specify a generic type parameter. For example:

function getFirst<T>(arr: T[]): T | undefined {
  return arr.length > 0 ? arr[0] : undefined;
}

Question 9

What is the purpose of utility types like Pick and Omit in TypeScript?

Answer 9

Utility types allow you to create new types by selecting or omitting properties from existing types. For example:

interface UserForm {
  email: string;
  password: string;
  phoneNumber?: string;
}

type LoginForm = Pick<UserForm, "email" | "password">;
type ContactForm = Omit<UserForm, "password">;

Question 10

What is type assertion in TypeScript, and how is it used?

Answer 10

Type assertion tells the compiler to treat a variable as a specific type. Use as or angle bracket syntax. For example:

let someValue: any = "Hello, world!";
let strLength: number = (someValue as string).length;

Question 11

What are union types in TypeScript?

Answer 11

Union types allow a variable to hold one of several types. Use the | symbol. For example:

let value: string | number;
value = "hello";
value = 42;

Question 12

How do you create a Readonly object in TypeScript?

Answer 12

Use the Readonly utility type to make all properties of an object immutable. For example:

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

const user: Readonly<User> = { name: "John", age: 30 };
// user.name = "Jane"; // Error: Cannot assign to 'name'

Question 13

How do enums work in TypeScript?

Answer 13

Enums define a set of named constants. Use enum. For example:

enum Color {
  Red,
  Green,
  Blue,
}

let c: Color = Color.Green;

Question 14

What is a mapped type in TypeScript?

Answer 14

Mapped types create new types by transforming properties of an existing type. For example:

type Readonly<T> = {
  readonly [P in keyof T]: T[P];
};

Question 15

What are type guards in TypeScript?

Answer 15

Type guards are functions or constructs that allow you to narrow types during runtime checks. For example:

function isString(value: any): value is string {
  return typeof value === "string";
}

Question 16

What is the never type in TypeScript?

Answer 16

The never type represents values that never occur, often used in unreachable code. For example:

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

Question 17

How do you use decorators in TypeScript?

Answer 17

Decorators are special declarations prefixed with @ that can modify classes or members. For example:

function Log(target: any, key: string) {
  console.log(`${key} was called`);
}

class Example {
  @Log
  method() {}
}

Question 18

What are index signatures in TypeScript?

Answer 18

Index signatures define the type of keys and their corresponding values for an object. For example:

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

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

Question 19

What is the purpose of the Partial utility type in TypeScript?

Answer 19

Partial makes all properties of a type optional. For example:

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

const partialUser: Partial<User> = { name: "Alice" };</User>