Generic factory pattern in Typescript - Mini Project: Build & Apply

Generic Factory Pattern in TypeScript

📖 Scenario: You are building a simple system that creates different types of vehicles. Each vehicle has a name and a method to describe itself. You want to use a generic factory pattern to create vehicles easily without repeating code.

🎯 Goal: Build a generic factory function in TypeScript that can create different vehicle objects with a common interface. You will create vehicle classes, a factory function, and use it to create and display vehicle details.

📋 What You'll Learn

Create two vehicle classes: Car and Bike, each with a name property and a describe() method.

Create a generic factory function called createVehicle that takes a class constructor and a name, then returns an instance of that class.

Use the factory function to create a Car named "Sedan" and a Bike named "Mountain Bike".

Call the describe() method on both created vehicles and print the results.

💡 Why This Matters

🌍 Real World

Generic factory patterns help create objects flexibly in software like games, simulations, or business apps where many similar objects are needed.

💼 Career

Understanding generic factories is useful for software developers to write reusable and scalable code, especially in TypeScript and other typed languages.

1

Create Vehicle Classes

Create two classes called Car and Bike. Each class should have a constructor that takes a name string and stores it in a public property called name. Also, add a method called describe() that returns a string: for Car return `This is a car named ${this.name}`, and for Bike return `This is a bike named ${this.name}`.

Typescript

# Your code here

Hint

Use class keyword to create classes. The constructor should take name and assign it to a public property. The describe() method returns a string describing the vehicle.

2

Create Generic Factory Function

Create a generic function called createVehicle that takes two parameters: a class constructor ctor of type new (name: string) => T and a name string. The function should return a new instance of T by calling new ctor(name).

Typescript

class Car {
    constructor(public name: string) {}
    describe(): string {
        return `This is a car named ${this.name}`;
    }
}

class Bike {
    constructor(public name: string) {}
    describe(): string {
        return `This is a bike named ${this.name}`;
    }
}

// Your code here

Hint

Use a generic function with a constructor type parameter. The function creates and returns a new instance using new ctor(name).

3

Use Factory to Create Vehicles

Use the createVehicle function to create a Car instance named "Sedan" and a Bike instance named "Mountain Bike". Store them in variables called myCar and myBike respectively.

Typescript

class Car {
    constructor(public name: string) {}
    describe(): string {
        return `This is a car named ${this.name}`;
    }
}

class Bike {
    constructor(public name: string) {}
    describe(): string {
        return `This is a bike named ${this.name}`;
    }
}

function createVehicle(ctor: new (name: string) => T, name: string): T {
    return new ctor(name);
}

// Your code here

Hint

Call createVehicle with the class and name to create instances. Assign them to myCar and myBike.

4

Print Vehicle Descriptions

Use console.log to print the result of calling describe() on myCar and myBike.

Typescript

class Car {
    constructor(public name: string) {}
    describe(): string {
        return `This is a car named ${this.name}`;
    }
}

class Bike {
    constructor(public name: string) {}
    describe(): string {
        return `This is a bike named ${this.name}`;
    }
}

function createVehicle(ctor: new (name: string) => T, name: string): T {
    return new ctor(name);
}

const myCar = createVehicle(Car, "Sedan");
const myBike = createVehicle(Bike, "Mountain Bike");

// Your code here

Hint

Use console.log(myCar.describe()) and console.log(myBike.describe()) to print the descriptions.

Practice

1.

What is the main purpose of the Generic factory pattern in TypeScript?

easy

A. To enforce strict typing on all variables.

B. To create objects without specifying their exact class.

C. To handle asynchronous operations automatically.

D. To optimize code for faster execution.

Solution

1. Step 1: Understand the pattern's goal

   The generic factory pattern is designed to create objects without needing to know their exact class ahead of time.

2. Step 2: Compare options with the pattern's purpose

   To create objects without specifying their exact class. correctly states this purpose. Other options describe unrelated features.

3. Final Answer:

   To create objects without specifying their exact class. -> Option B

4. Quick Check:

   Generic factory pattern = create objects flexibly [OK]

Hint: Focus on object creation without class details [OK]

Common Mistakes:

• Confusing with async handling
• Thinking it enforces variable typing
• Assuming it optimizes runtime speed

2.

Which of the following is the correct syntax to declare a generic factory function in TypeScript?

function create<T>(): T { /* ... */ }

easy

A. function create<T>(): T { return new T(); }

B. function create<T>(): T { return T(); }

C. function create<T>(): T { return new Object(); }

D. function create<T>(): T { return {} as T; }

Solution

1. Step 1: Analyze generic function syntax

   The function declares a generic type T and returns an object of type T.

2. Step 2: Check return statements for correctness

   function create<T>(): T { return {} as T; } uses a type assertion {} as T which is valid to create a generic placeholder object. function create<T>(): T { return new T(); } tries to use new T() which is invalid because T is a type parameter, not a constructor. function create<T>(): T { return T(); } calls T() like a function which is invalid. function create<T>(): T { return new Object(); } returns a generic object but not typed as T.

3. Final Answer:

   function create<T>(): T { return {} as T; } -> Option D

4. Quick Check:

   Generic factory syntax = use type assertion [OK]

Hint: Use type assertion to return generic type instance [OK]

Common Mistakes:

• Trying to instantiate generic type with new
• Calling generic type as a function
• Returning untyped objects without assertion

3.

What will be the output of this TypeScript code using a generic factory pattern?

interface Animal { speak(): string; }
class Dog implements Animal { speak() { return "Woof"; } }
function createAnimal<T extends Animal>(ctor: new () => T): T {
  return new ctor();
}
const dog = createAnimal(Dog);
console.log(dog.speak());

medium

A. "Woof"

B. undefined

C. TypeError at runtime

D. Compilation error

Solution

1. Step 1: Understand the factory function behavior

   The function createAnimal takes a constructor ctor and returns a new instance of type T which extends Animal.

2. Step 2: Trace the code execution

   We pass Dog class to createAnimal, so it returns a new Dog instance. Calling dog.speak() returns "Woof".

3. Final Answer:

   "Woof" -> Option A

4. Quick Check:

   Generic factory creates Dog, speak() = "Woof" [OK]

Hint: Trace constructor call and method output [OK]

Common Mistakes:

• Assuming generic type can't be instantiated
• Confusing type constraints with runtime errors
• Expecting undefined instead of method return

4.

Identify the error in this generic factory function and select the fix.

function createInstance<T>(): T {
  return new T();
}

medium

A. Add a constructor parameter: ctor: new () => T and return new ctor().

B. Remove new keyword and call T() directly.

C. Change return type to any to avoid errors.

D. Use Object.create(T) instead of new T().

Solution

1. Step 1: Identify why new T() causes error

   TypeScript does not allow new T() because T is a type parameter, not a constructor function.

2. Step 2: Apply correct fix using constructor parameter

   Passing a constructor function ctor: new () => T allows calling new ctor() to create an instance of T.

3. Final Answer:

   Add a constructor parameter: ctor: new () => T and return new ctor(). -> Option A

4. Quick Check:

   Generic factory needs constructor parameter [OK]

Hint: Pass constructor as parameter to instantiate generic type [OK]

Common Mistakes:

• Trying to instantiate generic type directly
• Removing new keyword incorrectly
• Changing return type to any loses type safety

5.

You want to create a generic factory that can produce different shapes with a draw() method. Which approach correctly uses the generic factory pattern to support adding new shapes easily?

interface Shape { draw(): void; }
class Circle implements Shape { draw() { console.log("Circle"); } }
class Square implements Shape { draw() { console.log("Square"); } }
// What is the best factory implementation?

hard

A. function createShape<T>(): T { return {} as T; }

B. function createShape(): Shape { return new Circle(); }

C. function createShape(ctor: new () => T): T { return new ctor(); }

D. function createShape(type: string): Shape { if(type === 'circle') return new Circle(); else return new Square(); }

Solution

1. Step 1: Understand the requirement for flexibility

   The factory should create any shape implementing Shape without hardcoding types.

2. Step 2: Evaluate each option

   function createShape(ctor: new () => T): T { return new ctor(); } uses a generic constructor parameter allowing easy addition of new shapes. function createShape(): Shape { return new Circle(); } always returns Circle, no flexibility. function createShape(type: string): Shape { if(type === 'circle') return new Circle(); else return new Square(); } uses string checks, less type-safe and harder to extend. function createShape<T>(): T { return {} as T; } returns an empty object cast to T, which is unsafe.

3. Final Answer:

   function createShape<T extends Shape>(ctor: new () => T): T { return new ctor(); } -> Option C

4. Quick Check:

   Generic factory with constructor param = flexible shape creation [OK]

Hint: Use generic constructor param for flexible object creation [OK]

Common Mistakes:

• Hardcoding return types limits extensibility
• Using string type checks reduces type safety
• Casting empty objects loses real behavior