Functional vs Object-Oriented Programming: A TypeScript Guide

Introduction

The choice between functional and object-oriented programming paradigms has shaped software development for decades. While many developers find themselves in heated debates about which approach is superior, the reality is that both paradigms offer unique strengths and are suited to different problems. TypeScript, with its robust type system and JavaScript foundation, provides an excellent platform for exploring both approaches.

As a developer who has worked extensively with both paradigms in TypeScript since 2019, I've seen how each approach can dramatically impact code maintainability, testing, and team collaboration. This comprehensive guide examines the fundamental differences between functional and object-oriented programming, demonstrates both approaches through practical TypeScript examples, and provides guidance on when to choose each paradigm.

Understanding Programming Paradigms

Before diving into specific implementations, it's crucial to understand what these paradigms represent at their core.

Object-Oriented Programming (OOP)

Object-oriented programming organizes code around objects—entities that encapsulate both data (properties) and behavior (methods). The core principles of OOP include:

• Encapsulation: Bundling data and methods that operate on that data

• Inheritance: Creating new classes based on existing ones

• Polymorphism: Using a unified interface for different underlying types

• Abstraction: Hiding complex implementation details behind simple interfaces

Functional Programming (FP)

Functional programming treats computation as the evaluation of mathematical functions. It emphasizes:

• Immutability: Data structures that don't change after creation

• Pure Functions: Functions with no side effects that always return the same output for the same input

• Function Composition: Building complex operations by combining simpler functions

• Higher-Order Functions: Functions that take other functions as arguments or return functions

TypeScript's Support for Both Paradigms

TypeScript's strength lies in its ability to support multiple programming paradigms while providing strong typing. Let's examine how TypeScript facilitates both approaches.

TypeScript and Object-Oriented Programming

TypeScript extends JavaScript with classical OOP features that many developers from languages like Java and C# find familiar:

// Interface definition for type safety
interface Vehicle {
  make: string;
  model: string;
  year: number;
  start(): void;
  stop(): void;
}

// Abstract base class
abstract class BaseVehicle implements Vehicle {
  constructor(
    public make: string,
    public model: string,
    public year: number
  ) {}

  abstract start(): void;
  abstract stop(): void;

  // Shared behavior
  getInfo(): string {
    return `${this.year} ${this.make} ${this.model}`;
  }
}

// Concrete implementation with inheritance
class Car extends BaseVehicle {
  private isRunning: boolean = false;

  start(): void {
    if (!this.isRunning) {
      console.log(`Starting ${this.getInfo()}`);
      this.isRunning = true;
    }
  }

  stop(): void {
    if (this.isRunning) {
      console.log(`Stopping ${this.getInfo()}`);
      this.isRunning = false;
    }
  }

  // Car-specific behavior
  honk(): void {
    console.log("Beep beep!");
  }
}

// Usage
const myCar = new Car("Toyota", "Corolla", 2023);
myCar.start(); // Starting 2023 Toyota Corolla
myCar.honk();  // Beep beep!
myCar.stop();  // Stopping 2023 Toyota Corolla

TypeScript and Functional Programming

TypeScript's type system also excels at supporting functional programming patterns:

// Type definitions for functional approach
type VehicleData = {
  readonly make: string;
  readonly model: string;
  readonly year: number;
};

type VehicleState = {
  readonly vehicle: VehicleData;
  readonly isRunning: boolean;
};

// Pure functions - no side effects
const createVehicle = (make: string, model: string, year: number): VehicleData => ({
  make,
  model,
  year
});

const createVehicleState = (vehicle: VehicleData): VehicleState => ({
  vehicle,
  isRunning: false
});

const startVehicle = (state: VehicleState): VehicleState => {
  if (state.isRunning) {
    return state; // Already running, return unchanged
  }
  
  console.log(`Starting ${getVehicleInfo(state.vehicle)}`);
  return { ...state, isRunning: true };
};

const stopVehicle = (state: VehicleState): VehicleState => {
  if (!state.isRunning) {
    return state; // Already stopped, return unchanged
  }
  
  console.log(`Stopping ${getVehicleInfo(state.vehicle)}`);
  return { ...state, isRunning: false };
};

const getVehicleInfo = (vehicle: VehicleData): string => 
  `${vehicle.year} ${vehicle.make} ${vehicle.model}`;

// Function composition
const honk = (): void => console.log("Beep beep!");

// Usage with immutable data
const vehicleData = createVehicle("Toyota", "Corolla", 2023);
let vehicleState = createVehicleState(vehicleData);

vehicleState = startVehicle(vehicleState); // Starting 2023 Toyota Corolla
honk(); // Beep beep!
vehicleState = stopVehicle(vehicleState);  // Stopping 2023 Toyota Corolla

Real-World Comparison: E-commerce Shopping Cart

To better illustrate the differences, let's implement a shopping cart system using both paradigms.

Object-Oriented Approach

// OOP Implementation
interface Product {
  id: string;
  name: string;
  price: number;
  category: string;
}

interface CartItem {
  product: Product;
  quantity: number;
}

class ShoppingCart {
  private items: Map<string, CartItem> = new Map();
  private discountRate: number = 0;

  addItem(product: Product, quantity: number = 1): void {
    const existingItem = this.items.get(product.id);
    
    if (existingItem) {
      existingItem.quantity += quantity;
    } else {
      this.items.set(product.id, { product, quantity });
    }
  }

  removeItem(productId: string): void {
    this.items.delete(productId);
  }

  updateQuantity(productId: string, quantity: number): void {
    const item = this.items.get(productId);
    if (item) {
      if (quantity <= 0) {
        this.removeItem(productId);
      } else {
        item.quantity = quantity;
      }
    }
  }

  applyDiscount(rate: number): void {
    this.discountRate = Math.max(0, Math.min(1, rate));
  }

  getSubtotal(): number {
    return Array.from(this.items.values())
      .reduce((total, item) => total + (item.product.price * item.quantity), 0);
  }

  getDiscount(): number {
    return this.getSubtotal() * this.discountRate;
  }

  getTotal(): number {
    return this.getSubtotal() - this.getDiscount();
  }

  getItems(): CartItem[] {
    return Array.from(this.items.values());
  }

  clear(): void {
    this.items.clear();
    this.discountRate = 0;
  }

  checkout(): CheckoutResult {
    if (this.items.size === 0) {
      throw new Error("Cannot checkout empty cart");
    }

    const result: CheckoutResult = {
      items: this.getItems(),
      subtotal: this.getSubtotal(),
      discount: this.getDiscount(),
      total: this.getTotal(),
      timestamp: new Date()
    };

    this.clear();
    return result;
  }
}

interface CheckoutResult {
  items: CartItem[];
  subtotal: number;
  discount: number;
  total: number;
  timestamp: Date;
}

// Usage
const cart = new ShoppingCart();
const laptop: Product = { id: "1", name: "Laptop", price: 999.99, category: "Electronics" };
const mouse: Product = { id: "2", name: "Mouse", price: 29.99, category: "Electronics" };

cart.addItem(laptop, 1);
cart.addItem(mouse, 2);
cart.applyDiscount(0.1); // 10% discount

console.log(`Total: $${cart.getTotal().toFixed(2)}`); // Total: $953.97
const checkoutResult = cart.checkout();

Functional Approach

// Functional Implementation
type Product = {
  readonly id: string;
  readonly name: string;
  readonly price: number;
  readonly category: string;
};

type CartItem = {
  readonly product: Product;
  readonly quantity: number;
};

type CartState = {
  readonly items: readonly CartItem[];
  readonly discountRate: number;
};

type CheckoutResult = {
  readonly items: readonly CartItem[];
  readonly subtotal: number;
  readonly discount: number;
  readonly total: number;
  readonly timestamp: Date;
};

// Pure functions for cart operations
const createEmptyCart = (): CartState => ({
  items: [],
  discountRate: 0
});

const addItemToCart = (cart: CartState, product: Product, quantity: number = 1): CartState => {
  const existingItemIndex = cart.items.findIndex(item => item.product.id === product.id);
  
  if (existingItemIndex >= 0) {
    const updatedItems = cart.items.map((item, index) =>
      index === existingItemIndex
        ? { ...item, quantity: item.quantity + quantity }
        : item
    );
    return { ...cart, items: updatedItems };
  }
  
  return {
    ...cart,
    items: [...cart.items, { product, quantity }]
  };
};

const removeItemFromCart = (cart: CartState, productId: string): CartState => ({
  ...cart,
  items: cart.items.filter(item => item.product.id !== productId)
});

const updateItemQuantity = (cart: CartState, productId: string, quantity: number): CartState => {
  if (quantity <= 0) {
    return removeItemFromCart(cart, productId);
  }
  
  const updatedItems = cart.items.map(item =>
    item.product.id === productId
      ? { ...item, quantity }
      : item
  );
  
  return { ...cart, items: updatedItems };
};

const applyDiscount = (cart: CartState, rate: number): CartState => ({
  ...cart,
  discountRate: Math.max(0, Math.min(1, rate))
});

// Calculation functions
const calculateSubtotal = (items: readonly CartItem[]): number =>
  items.reduce((total, item) => total + (item.product.price * item.quantity), 0);

const calculateDiscount = (subtotal: number, discountRate: number): number =>
  subtotal * discountRate;

const calculateTotal = (subtotal: number, discount: number): number =>
  subtotal - discount;

// Higher-order function for cart calculations
const withCartCalculations = <T>(
  cart: CartState,
  fn: (subtotal: number, discount: number, total: number) => T
): T => {
  const subtotal = calculateSubtotal(cart.items);
  const discount = calculateDiscount(subtotal, cart.discountRate);
  const total = calculateTotal(subtotal, discount);
  return fn(subtotal, discount, total);
};

const checkoutCart = (cart: CartState): CheckoutResult => {
  if (cart.items.length === 0) {
    throw new Error("Cannot checkout empty cart");
  }

  return withCartCalculations(cart, (subtotal, discount, total) => ({
    items: cart.items,
    subtotal,
    discount,
    total,
    timestamp: new Date()
  }));
};

// Function composition for cart operations
const pipe = <T>(...fns: Array<(arg: T) => T>) => (value: T): T =>
  fns.reduce((acc, fn) => fn(acc), value);

// Usage with function composition
const laptop: Product = { id: "1", name: "Laptop", price: 999.99, category: "Electronics" };
const mouse: Product = { id: "2", name: "Mouse", price: 29.99, category: "Electronics" };

const finalCart = pipe(
  (cart: CartState) => addItemToCart(cart, laptop, 1),
  (cart: CartState) => addItemToCart(cart, mouse, 2),
  (cart: CartState) => applyDiscount(cart, 0.1)
)(createEmptyCart());

const total = withCartCalculations(finalCart, (_, __, total) => total);
console.log(`Total: $${total.toFixed(2)}`); // Total: $953.97

const checkoutResult = checkoutCart(finalCart);

Advanced Patterns and Techniques

Object-Oriented: Design Patterns

TypeScript's OOP support enables classic design patterns:

// Strategy Pattern with TypeScript
interface PaymentStrategy {
  processPayment(amount: number): Promise<PaymentResult>;
}

class CreditCardPayment implements PaymentStrategy {
  constructor(private cardNumber: string, private cvv: string) {}

  async processPayment(amount: number): Promise<PaymentResult> {
    // Simulate credit card processing
    return {
      success: true,
      transactionId: `cc_${Date.now()}`,
      amount,
      method: 'Credit Card'
    };
  }
}

class PayPalPayment implements PaymentStrategy {
  constructor(private email: string) {}

  async processPayment(amount: number): Promise<PaymentResult> {
    // Simulate PayPal processing
    return {
      success: true,
      transactionId: `pp_${Date.now()}`,
      amount,
      method: 'PayPal'
    };
  }
}

class PaymentProcessor {
  constructor(private strategy: PaymentStrategy) {}

  setStrategy(strategy: PaymentStrategy): void {
    this.strategy = strategy;
  }

  async process(amount: number): Promise<PaymentResult> {
    return this.strategy.processPayment(amount);
  }
}

interface PaymentResult {
  success: boolean;
  transactionId: string;
  amount: number;
  method: string;
}

// Usage
const processor = new PaymentProcessor(new CreditCardPayment("1234-5678-9012-3456", "123"));
const result = await processor.process(100.00);

Functional: Monads and Advanced Composition

TypeScript's type system supports functional patterns like monads:

// Maybe Monad implementation
abstract class Maybe<T> {
  abstract flatMap<U>(fn: (value: T) => Maybe<U>): Maybe<U>;
  abstract map<U>(fn: (value: T) => U): Maybe<U>;
  abstract filter(predicate: (value: T) => boolean): Maybe<T>;
  abstract getOrElse(defaultValue: T): T;
  abstract isEmpty(): boolean;

  static of<T>(value: T | null | undefined): Maybe<T> {
    return value != null ? new Some(value) : new None<T>();
  }

  static none<T>(): Maybe<T> {
    return new None<T>();
  }
}

class Some<T> extends Maybe<T> {
  constructor(private value: T) {
    super();
  }

  flatMap<U>(fn: (value: T) => Maybe<U>): Maybe<U> {
    return fn(this.value);
  }

  map<U>(fn: (value: T) => U): Maybe<U> {
    return Maybe.of(fn(this.value));
  }

  filter(predicate: (value: T) => boolean): Maybe<T> {
    return predicate(this.value) ? this : Maybe.none<T>();
  }

  getOrElse(_defaultValue: T): T {
    return this.value;
  }

  isEmpty(): boolean {
    return false;
  }
}

class None<T> extends Maybe<T> {
  flatMap<U>(_fn: (value: T) => Maybe<U>): Maybe<U> {
    return Maybe.none<U>();
  }

  map<U>(_fn: (value: T) => U): Maybe<U> {
    return Maybe.none<U>();
  }

  filter(_predicate: (value: T) => boolean): Maybe<T> {
    return this;
  }

  getOrElse(defaultValue: T): T {
    return defaultValue;
  }

  isEmpty(): boolean {
    return true;
  }
}

// Safe user lookup with Maybe
type User = {
  id: number;
  name: string;
  email: string;
  age: number;
};

const users: User[] = [
  { id: 1, name: "Alice", email: "[email protected]", age: 30 },
  { id: 2, name: "Bob", email: "[email protected]", age: 25 }
];

const findUserById = (id: number): Maybe<User> =>
  Maybe.of(users.find(user => user.id === id));

const getAdultUserEmail = (id: number): string =>
  findUserById(id)
    .filter(user => user.age >= 18)
    .map(user => user.email)
    .getOrElse("No adult user found");

console.log(getAdultUserEmail(1)); // [email protected]
console.log(getAdultUserEmail(999)); // No adult user found

Performance and Memory Considerations

Object-Oriented Performance Characteristics

// OOP: Object creation and memory usage
class DataProcessor {
  private cache: Map<string, any> = new Map();
  
  constructor(private config: ProcessorConfig) {}
  
  process(data: DataItem[]): ProcessedData[] {
    return data.map(item => {
      const cacheKey = this.generateCacheKey(item);
      
      if (this.cache.has(cacheKey)) {
        return this.cache.get(cacheKey);
      }
      
      const processed = this.performProcessing(item);
      this.cache.set(cacheKey, processed);
      return processed;
    });
  }
  
  private generateCacheKey(item: DataItem): string {
    return `${item.id}_${item.type}`;
  }
  
  private performProcessing(item: DataItem): ProcessedData {
    // Expensive operation
    return {
      id: item.id,
      result: item.value * this.config.multiplier,
      timestamp: Date.now()
    };
  }
}

interface ProcessorConfig {
  multiplier: number;
  cacheSize: number;
}

interface DataItem {
  id: string;
  type: string;
  value: number;
}

interface ProcessedData {
  id: string;
  result: number;
  timestamp: number;
}

// Memory usage: One instance with internal state
const processor = new DataProcessor({ multiplier: 2, cacheSize: 1000 });

Functional Performance Characteristics

// Functional: Stateless operations with potential for optimization
type ProcessorConfig = {
  readonly multiplier: number;
  readonly cacheSize: number;
};

type DataItem = {
  readonly id: string;
  readonly type: string;
  readonly value: number;
};

type ProcessedData = {
  readonly id: string;
  readonly result: number;
  readonly timestamp: number;
};

// Memoization for performance
const memoize = <Args extends any[], Return>(
  fn: (...args: Args) => Return
): ((...args: Args) => Return) => {
  const cache = new Map<string, Return>();
  
  return (...args: Args): Return => {
    const key = JSON.stringify(args);
    if (cache.has(key)) {
      return cache.get(key)!;
    }
    
    const result = fn(...args);
    cache.set(key, result);
    return result;
  };
};

const performProcessing = (config: ProcessorConfig) => (item: DataItem): ProcessedData => ({
  id: item.id,
  result: item.value * config.multiplier,
  timestamp: Date.now()
});

const memoizedProcess = memoize(performProcessing);

const processData = (config: ProcessorConfig) => (data: readonly DataItem[]): readonly ProcessedData[] =>
  data.map(memoizedProcess(config));

// Usage: Each call creates new functions but can be optimized
const config: ProcessorConfig = { multiplier: 2, cacheSize: 1000 };
const processor = processData(config);

Testing Strategies

Testing Object-Oriented Code

// OOP Testing with dependency injection
interface Logger {
  log(message: string): void;
}

interface EmailService {
  sendEmail(to: string, subject: string, body: string): Promise<boolean>;
}

class UserService {
  constructor(
    private logger: Logger,
    private emailService: EmailService
  ) {}

  async createUser(userData: CreateUserData): Promise<User> {
    this.logger.log(`Creating user: ${userData.email}`);
    
    const user: User = {
      id: Date.now().toString(),
      ...userData,
      createdAt: new Date()
    };

    const emailSent = await this.emailService.sendEmail(
      user.email,
      "Welcome!",
      `Welcome to our service, ${user.name}!`
    );

    if (!emailSent) {
      this.logger.log(`Failed to send welcome email to ${user.email}`);
    }

    return user;
  }
}

// Testing with mocks
class MockLogger implements Logger {
  logs: string[] = [];
  
  log(message: string): void {
    this.logs.push(message);
  }
}

class MockEmailService implements EmailService {
  async sendEmail(to: string, subject: string, body: string): Promise<boolean> {
    return true; // Simulate successful email sending
  }
}

// Test
const mockLogger = new MockLogger();
const mockEmailService = new MockEmailService();
const userService = new UserService(mockLogger, mockEmailService);

const user = await userService.createUser({
  name: "John Doe",
  email: "[email protected]"
});

console.log(mockLogger.logs); // ["Creating user: [email protected]"]

Testing Functional Code

// Functional testing - easier to test pure functions
const validateEmail = (email: string): boolean =>
  /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);

const validateAge = (age: number): boolean =>
  age >= 0 && age <= 150;

const validateName = (name: string): boolean =>
  name.length >= 2 && name.length <= 50;

type ValidationResult = {
  readonly isValid: boolean;
  readonly errors: readonly string[];
};

const validateUser = (userData: CreateUserData): ValidationResult => {
  const errors: string[] = [];

  if (!validateEmail(userData.email)) {
    errors.push("Invalid email format");
  }

  if (!validateName(userData.name)) {
    errors.push("Name must be between 2 and 50 characters");
  }

  return {
    isValid: errors.length === 0,
    errors
  };
};

const createUserSafely = (userData: CreateUserData): User | ValidationResult => {
  const validation = validateUser(userData);
  
  if (!validation.isValid) {
    return validation;
  }

  return {
    id: Date.now().toString(),
    ...userData,
    createdAt: new Date()
  };
};

// Testing pure functions is straightforward
console.log(validateEmail("[email protected]")); // true
console.log(validateEmail("invalid-email")); // false
console.log(validateName("John")); // true
console.log(validateName("A")); // false

interface CreateUserData {
  name: string;
  email: string;
}

interface User extends CreateUserData {
  id: string;
  createdAt: Date;
}

When to Choose Each Paradigm

Choose Object-Oriented Programming When:

1. Modeling Real-World Entities: When your domain naturally maps to objects with properties and behaviors

2. Complex State Management: When you need to manage complex, mutable state that benefits from encapsulation

3. Team Familiarity: When your team has strong OOP background and existing OOP codebases

4. Framework Requirements: When using frameworks that are designed around OOP patterns

5. Large Team Projects: When you need clear ownership and responsibility boundaries

Choose Functional Programming When:

1. Data Transformation: When your application primarily transforms data from one form to another

2. Concurrency Needs: When you need to write concurrent or parallel code with minimal synchronization issues

3. Testing Requirements: When comprehensive testing and predictable behavior are critical

4. Mathematical Operations: When dealing with complex mathematical computations or algorithms

5. Immutability Benefits: When consistency and avoiding side effects are paramount

Hybrid Approaches in TypeScript

Often, the best solution combines both paradigms:

// Hybrid approach: OOP for structure, FP for operations
class DataAnalyzer {
  constructor(private config: AnalysisConfig) {}

  // OOP method that orchestrates FP operations
  async analyzeDataset(dataset: DataPoint[]): Promise<AnalysisResult> {
    const preprocessed = this.preprocess(dataset);
    const analyzed = await this.runAnalysis(preprocessed);
    return this.formatResults(analyzed);
  }

  // Private methods using functional approach
  private preprocess = (data: DataPoint[]): DataPoint[] =>
    pipe(
      filterValidData,
      normalizeValues,
      removeDuplicates
    )(data);

  private runAnalysis = async (data: DataPoint[]): Promise<RawAnalysisResult> => {
    const calculations = await Promise.all([
      calculateMean(data),
      calculateStandardDeviation(data),
      findOutliers(data)
    ]);

    return {
      mean: calculations[0],
      standardDeviation: calculations[1],
      outliers: calculations[2]
    };
  };

  private formatResults = (raw: RawAnalysisResult): AnalysisResult => ({
    summary: {
      mean: Number(raw.mean.toFixed(2)),
      standardDeviation: Number(raw.standardDeviation.toFixed(2)),
      outlierCount: raw.outliers.length
    },
    outliers: raw.outliers,
    generatedAt: new Date()
  });
}

// Pure functional operations
const filterValidData = (data: DataPoint[]): DataPoint[] =>
  data.filter(point => !isNaN(point.value) && point.value != null);

const normalizeValues = (data: DataPoint[]): DataPoint[] =>
  data.map(point => ({ ...point, value: Math.abs(point.value) }));

const removeDuplicates = (data: DataPoint[]): DataPoint[] =>
  data.filter((point, index, arr) => 
    arr.findIndex(p => p.id === point.id) === index
  );

const calculateMean = async (data: DataPoint[]): Promise<number> =>
  data.reduce((sum, point) => sum + point.value, 0) / data.length;

const calculateStandardDeviation = async (data: DataPoint[]): Promise<number> => {
  const mean = await calculateMean(data);
  const squaredDiffs = data.map(point => Math.pow(point.value - mean, 2));
  const avgSquaredDiff = squaredDiffs.reduce((sum, diff) => sum + diff, 0) / data.length;
  return Math.sqrt(avgSquaredDiff);
};

const findOutliers = async (data: DataPoint[]): Promise<DataPoint[]> => {
  const mean = await calculateMean(data);
  const stdDev = await calculateStandardDeviation(data);
  const threshold = 2 * stdDev;
  
  return data.filter(point => Math.abs(point.value - mean) > threshold);
};

// Utility function for composition
const pipe = <T>(...fns: Array<(arg: T) => T>) => (value: T): T =>
  fns.reduce((acc, fn) => fn(acc), value);

// Type definitions
interface DataPoint {
  id: string;
  value: number;
  timestamp: Date;
}

interface AnalysisConfig {
  includeOutliers: boolean;
  precision: number;
}

interface RawAnalysisResult {
  mean: number;
  standardDeviation: number;
  outliers: DataPoint[];
}

interface AnalysisResult {
  summary: {
    mean: number;
    standardDeviation: number;
    outlierCount: number;
  };
  outliers: DataPoint[];
  generatedAt: Date;
}

Performance Comparison and Benchmarks

Memory Usage Patterns

// Memory profiling helper
const measureMemory = <T>(operation: () => T, label: string): T => {
  const before = (performance as any).memory?.usedJSHeapSize || 0;
  const result = operation();
  const after = (performance as any).memory?.usedJSHeapSize || 0;
  console.log(`${label}: ${(after - before) / 1024} KB`);
  return result;
};

// OOP approach - single object with state
const oopApproach = () => {
  class NumberProcessor {
    private results: number[] = [];
    
    process(numbers: number[]): number[] {
      this.results = numbers.map(n => n * 2);
      return this.results;
    }
    
    getAverage(): number {
      return this.results.reduce((a, b) => a + b, 0) / this.results.length;
    }
  }
  
  const processor = new NumberProcessor();
  const numbers = Array.from({ length: 10000 }, (_, i) => i);
  processor.process(numbers);
  return processor.getAverage();
};

// Functional approach - stateless operations
const functionalApproach = () => {
  const processNumbers = (numbers: readonly number[]): readonly number[] =>
    numbers.map(n => n * 2);
  
  const calculateAverage = (numbers: readonly number[]): number =>
    numbers.reduce((a, b) => a + b, 0) / numbers.length;
  
  const numbers = Array.from({ length: 10000 }, (_, i) => i) as readonly number[];
  const processed = processNumbers(numbers);
  return calculateAverage(processed);
};

// Performance comparison
console.time('OOP Approach');
const oopResult = measureMemory(oopApproach, 'OOP Memory');
console.timeEnd('OOP Approach');

console.time('Functional Approach');
const functionalResult = measureMemory(functionalApproach, 'Functional Memory');
console.timeEnd('Functional Approach');

console.log('Results equal:', oopResult === functionalResult);

Conclusion

The choice between functional and object-oriented programming in TypeScript isn't binary—both paradigms have their place in modern software development. Understanding when and how to apply each approach will make you a more effective developer.

Key Takeaways:

• Object-Oriented Programming excels at modeling complex domains with clear entity relationships and managing stateful systems

• Functional Programming shines in data processing, concurrent systems, and scenarios where predictability and testing are crucial

• TypeScript's type system supports both paradigms equally well, allowing for hybrid approaches

• Performance characteristics differ between approaches, with functional programming often providing better memory safety and OOP offering more intuitive state management

• Testing strategies vary significantly, with functional code generally being easier to test due to pure functions

The most successful TypeScript applications often combine both paradigms strategically—using OOP for system architecture and domain modeling while leveraging functional techniques for data processing and business logic. As you continue developing with TypeScript, consider the specific requirements of your project, team expertise, and long-term maintenance needs when choosing your programming approach.

By mastering both paradigms in TypeScript, you'll be equipped to make informed architectural decisions and write more maintainable, scalable applications that leverage the best of both worlds.

Further Reading and Resources

• TypeScript Handbook - Classes

• TypeScript for Functional Programmers

• TypeScript for OOP Programmers

• Functional Programming in TypeScript - Popular functional programming library

• Design Patterns in TypeScript - Implementation of classic OOP patterns