TypeScript interview questions and answers

type A = { x: string; y: number };
type B = { y: string; z: boolean };

type AB = A & B;
// AB.y = ?

{
  "compilerOptions": {
    "rootDir": "./src",
    "outDir": "./dist",
    "declaration": true
  }
}

function getLength<T>(value: T): number {
  return value.length; // ❌ ?
}

class BankAccount {
  public owner: string;
  private balance: number;
  protected accountNumber: string;

  constructor(owner: string, balance: number, number: string) {
    this.owner = owner;
    this.balance = balance;
    this.accountNumber = number;
  }
}

function formatId(id: string | number): string {
  return `ID: ${id}`;
}

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

type Circle    = { kind: 'circle';    radius: number };
type Rectangle = { kind: 'rectangle'; width: number; height: number };
type Triangle  = { kind: 'triangle';  base: number; height: number };

type Shape = Circle | Rectangle | Triangle;

function area(shape: Shape): number {
  switch (shape.kind) {
    case 'circle':    return Math.PI * shape.radius ** 2;
    case 'rectangle': return shape.width * shape.height;
    case 'triangle':  return 0.5 * shape.base * shape.height;
  }
}

// With noImplicitAny: true

function process(data) {     // (A) ?
  return data.length;
}

const items = [];             // (B) ?

function identity<T>(x: T) { // (C) ?
  return x;
}

function container<T = string>(value?: T): T | undefined {
  return value;
}

const a = container();         // T = ?
const b = container("hello"); // T = ?
const c = container(42);      // T = ?

class Point {
  constructor(
    public x: number,
    public y: number
  ) {}
}

type Required<T> = { [K in keyof T]-?: T[K] };
type Optional<T> = { [K in keyof T]+?: T[K] };

interface Config {
  host?: string;
  port?: number;
  debug?: boolean;
}

type StrictConfig = Required<Config>;
type FlexConfig   = Optional<Config>; // same as Config in this case

// tsconfig: "isolatedModules": true

// File 1 — const enum:
export const enum Direction { Up, Down, Left, Right }

// File 2 — using it:
import { Direction } from './file1';
const d = Direction.Up; // ?

async function fetchUser(id: string): Promise<{ id: string; name: string }> {
  // ...
  return { id, name: "Alice" };
}

type FetchUserResult = ReturnType<typeof fetchUser>;
// FetchUserResult = ?

class Counter {
  static count: number = 0;
  id: number;

  constructor() {
    Counter.count++;
    this.id = Counter.count;
  }

  static reset() { Counter.count = 0; }
}

type Cat = { meow: () => void };
type Dog = { bark: () => void };

function makeSound(animal: Cat | Dog) {
  if ('meow' in animal) {
    animal.meow(); // ?
  }
}

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

function updateUser(id: string, patch: Partial<User>): void { /* ... */ }

async function fetchData(): Promise<{ users: { id: string; name: string }[] }> {
  return { users: [] };
}

type ResponseData = Awaited<ReturnType<typeof fetchData>>;
type UserList = ResponseData['users'];
type User = UserList[number];

{ "compilerOptions": { "skipLibCheck": true } }

function createUser(name: string, age: number, role: 'admin' | 'user'): void { /* ... */ }

type CreateArgs = Parameters<typeof createUser>;

class Animal {
  constructor(public name: string) {}
  speak() { return `${this.name} makes a sound.`; }
}

class Dog extends Animal {
  constructor(name: string, public breed: string) {
    super(name); // ?
  }
}

type JSONValue =
  | string
  | number
  | boolean
  | null
  | JSONValue[]
  | { [key: string]: JSONValue };

type IsJSON<T> = T extends JSONValue ? true : false;

type A = IsJSON<string>;
type B = IsJSON<{ x: number; y: number }>;
type C = IsJSON<Date>;
type D = IsJSON<undefined>;

// src/global.d.ts
declare module '*.svg' {
  const content: string;
  export default content;
}

declare module '*.md' {
  const content: string;
  export default content;
}

function compose<A, B, C>(
  f: (b: B) => C,
  g: (a: A) => B
): (a: A) => C {
  return (a: A) => f(g(a));
}

const addOne = (n: number): number => n + 1;
const toString = (n: number): string => String(n);

const addOneThenString = compose(toString, addOne);
const result = addOneThenString(5); // ?

function Log(target: any, key: string, descriptor: PropertyDescriptor) {
  const original = descriptor.value;
  descriptor.value = function(...args: any[]) {
    console.log(`Calling ${key} with`, args);
    return original.apply(this, args);
  };
  return descriptor;
}

class Service {
  @Log
  process(data: string): string { return data.toUpperCase(); }
}

type A = Extract<string | number | boolean, string | number>;
type B = Exclude<string | number | boolean, string | number>;

type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "square"; side: number }
  | { kind: "rectangle"; width: number; height: number };

type Serialize<T> = {
  [K in keyof T]: T[K] extends Date
    ? string
    : T[K] extends (infer U)[]
    ? Serialize<U>[]
    : T[K] extends object
    ? Serialize<T[K]>
    : T[K];
};

interface Data {
  name: string;
  createdAt: Date;
  tags: string[];
  address: { city: string; updatedAt: Date };
}

type SerializedData = Serialize<Data>;

/// <reference types="node" />
/// <reference path="../global.d.ts" />
/// <reference lib="dom" />

// Top of a .ts file

type T1 = Awaited<Promise<string>>;
type T2 = Awaited<Promise<Promise<number>>>;
type T3 = Awaited<string>;

class A {
  private tsPrivate = 1;
  #jsPrivate = 2;
}

const a = new A();
(a as any).tsPrivate; // ?
(a as any).jsPrivate; // ?