オブジェクト指向のデザインパターンと関数型で出てくる仕組みで似ているものを教えてよ！

copy

Plain

🤖 
オブジェクト指向のデザインパターンと関数型プログラミングのパターンで
類似点があるものについて説明しましょう。

copy

Javascript

// OOP Iterator
class NumberIterator {
    constructor(numbers) {
        this.numbers = numbers;
        this.index = 0;
    } 
    
    hasNext() {
        return this.index < this.numbers.length;
    }
    
    next() {
        	       return this.numbers[this.index++];
      }
}

// 関数型
const numbers = [1, 2, 3, 4, 5];
const doubled = numbers.map(x => x * 2);

copy

Javascript

// OOP Strategy
class SortStrategy {
    sort(data) {
          // ソートロジック
      }
}

// 関数型
const sort = (data, compareFunc) => {
     // compareFuncを使ってソート
}

copy

Javascript

// OOP Decorator
class BaseComponent {
    operation() { return "Base"; }
}

class Decorator extends BaseComponent {
    constructor(component) {
        super();
        this.component = component;
    }
    
    operation() {
        return this.component.operation() + " + Extra";
    }
}

// 関数型
const base = x => x;
const addExtra = f => x => f(x) + " + Extra";
const decorated = addExtra(base);

copy

Javascript

// OOP Memento
class Editor {
    constructor(content) {
        this.content = content;
    }
    
    createMemento() {
        return new EditorMemento(this.content);
    }
    
    restore(memento) {
        this.content = memento.getContent();
    }
}

// 関数型（Immutable.js風）
const history = [];
let currentState = Map({ content: "initial" });
history.push(currentState);
currentState = currentState.set("content", "updated");
history.push(currentState);

copy

Javascript

// OOP Template Method
abstract class DataProcessor {
    process() {
        this.validate();
        this.transform();
        this.save();
    }
    abstract validate();
    abstract transform();
    abstract save();
}

// 関数型
const process = validate => transform => save =>
    data => save(transform(validate(data)));

copy

Javascript

// OOP Visitor
interface Shape {
    accept(visitor: ShapeVisitor);
}

interface ShapeVisitor {
    visitCircle(circle: Circle);
    visitSquare(square: Square);
}

// 関数型（Scala風）
sealed trait Shape
case class Circle(radius: Double) extends Shape
case class Square(side: Double) extends Shape

def calculateArea(shape: Shape): Double = shape match {
    case Circle(r) => Math.PI * r * r
    case Square(s) => s * s
}

copy

Javascript

// OOP Chain
class Handler {
    setNext(handler: Handler) {
        this.nextHandler = handler;
        return handler;
    }
    
    handle(request: Request) {
        if (this.canHandle(request)) {
            return this.process(request);
        }
        return this.nextHandler?.handle(request);
    }
}

// 関数型（Maybe モナド風）
const processRequest = request =>
    validateRequest(request)
        .flatMap(authenticateRequest)
        .flatMap(processData)
        .flatMap(saveResult);

copy

Javascript

// OOP Flyweight
class CharacterFactory {
    private characters = new Map();
    
    getCharacter(char: string) {
        if (!this.characters.has(char)) {
            this.characters.set(char, new Character(char));
        }
        return this.characters.get(char);
    }
}

// 関数型
const memoize = fn => {
    const cache = new Map();
    return (...args) => {
        const key = JSON.stringify(args);
        if (!cache.has(key)) {
            cache.set(key, fn(...args));
        }
        return cache.get(key);
    };
};