What is the Template Method pattern?

Question

Accepted Answer

The **Template Method** pattern defines the **skeleton of an algorithm** in a base class, letting subclasses fill in specific steps without changing the overall structure. It captures a common process while allowing customization of individual steps.

## What the Template Method pattern does

```text
TEMPLATE METHOD → define an algorithm's overall STRUCTURE in a base method, with some STEPS
left for subclasses to implement:
  → the base class controls the overall flow (the "template")
  → subclasses override specific STEPS (the parts that vary)
  → the algorithm's structure is FIXED; the steps are customizable
→ "common process, customizable steps"
```

## Example

```js
// base class defines the algorithm skeleton
class DataProcessor {
  process() {                    // the template method (fixed structure)
    const data = this.read();    // step (subclass implements)
    const result = this.transform(data);  // step (subclass implements)
    this.save(result);           // step (subclass implements)
  }
  read() { throw 'implement'; }       // steps to be overridden
  transform(d) { throw 'implement'; }
  save(r) { throw 'implement'; }
}
// subclasses provide the specific steps; the overall process is the same
class CsvProcessor extends DataProcessor { read() {...} transform() {...} save() {...} }
```

## Benefits and uses

```text
BENEFITS:
  ✓ CODE REUSE → common algorithm structure defined ONCE (in the base); no duplication
  ✓ CONSISTENCY → all subclasses follow the same overall process
  ✓ CUSTOMIZATION → vary specific steps without rewriting the whole algorithm
  ✗ uses inheritance (consider composition/strategy alternatives for flexibility)
USES → frameworks (define a process, you fill in hooks); data processing pipelines;
  lifecycle methods (e.g. framework hooks/callbacks); workflows with varying steps
```

## Why it matters

Understanding the Template Method pattern is valuable because it's a **useful behavioral pattern** for capturing common processes with customizable steps, common in frameworks, so it's relevant design knowledge.

The Template Method pattern defines an algorithm's skeleton in a base class while letting subclasses fill in specific steps — capturing a common process while allowing customization of individual parts.

Understanding what it does (the base class controlling the overall flow as a fixed template, with subclasses overriding the specific steps that vary) is the core knowledge.

Understanding the **benefits** is key: **code reuse** (the common algorithm structure defined once in the base, avoiding duplication across subclasses that share a process), **consistency** (all subclasses following the same overall process — ensuring uniformity), and **customization** (varying specific steps without rewriting the whole algorithm).

These make Template Method valuable when you have a process that's the same overall but varies in details.

Understanding the caveat that it uses inheritance (with composition/Strategy as alternatives for more flexibility) reflects balanced judgment.

Understanding the **uses** — **frameworks** (defining a process where you fill in hooks — a very common framework pattern), data processing pipelines, **lifecycle methods** (framework hooks and callbacks, like the lifecycle methods in UI frameworks), and workflows with varying steps — clarifies its applicability.

The Template Method pattern is especially common in frameworks, where the framework defines the overall flow and you implement specific hooks (a pattern you encounter whenever you override framework lifecycle or hook methods).

Since the Template Method pattern is a useful behavioral pattern for capturing common processes with customizable steps (code reuse, consistency, customization), common in frameworks (lifecycle methods, hooks), and since understanding it and its uses is relevant for recognizing and using this framework-common pattern, understanding the Template Method pattern is valuable, practically-relevant design knowledge — a useful pattern for common processes with varying steps, especially prevalent in frameworks (lifecycle hooks), and important design knowledge for capturing shared algorithm structure while allowing step customization.