SOLID principles

Five principles that make object-oriented designs easier to understand, change and maintain. The text is adapted from the training-algorithms repositories' README.

S Single Responsibility principle

“There should never be more than one reason for a class to change.”

A class should only have one reason to change
Separation of concerns
Different classes handle different, independent tasks

Diary

addNote(note)
removeNote(pos)
saveToFile(name)
loadFromFile(name)

PersistenceManager

saveToFile(diary, name)
loadFromFile(name)

Two reasons to change: note rules and file storage live in one class.

The repository splits a Diary (manages notes) from a PersistenceManager (saves and loads them):

training-algorithms-javascript/SOLID/SingleResponsibilityPrinciple.js (excerpt)

class Diary {
  constructor() {
    this.notes = [];
    this.count = 0;
  }
  addNote(note) {
    this.count += 1;
    this.notes.push(`${this.count}: ${note}`);
  }
  removeNote(pos) { /* ... */ }
  toString() { return this.notes.join("\n"); }
}

// Storage is a separate responsibility.
class PersistenceManager {
  static saveToFile(diary, filename) { /* fs.writeFileSync */ }
  static loadFromFile(filename) { /* fs.readFileSync */ }
}

O Open–Closed principle

“Software entities should be open for extension, but closed for modification.”

Add behaviour by adding new code (subclasses, strategies), not by editing tested code

A code example for this principle is coming soon.

L Liskov Substitution principle

“Functions that use pointers or references to base classes must be able to use objects of derived classes without knowing it.”

You should be able to substitute a base type with a subtype

A code example for this principle is coming soon.

I Interface Segregation principle

“Clients should not be forced to depend upon interfaces that they do not use.”

Don't put too much into an interface; split it into separate interfaces
YAGNI: You Aren't Gonna Need It

A code example for this principle is coming soon.

D Dependency Inversion principle

“Depend upon abstractions, not concretions.”

High-level modules should not depend on low-level ones; both use abstractions

A code example for this principle is coming soon.

Saved in this browser only. Part of Clean code foundations (0/5).