JavaScriptのモジュールビルダーパターン：複雑なオブジェクト作成をマスターする

            
// User classes
class AdminUser {
  constructor(name) {
    this.name = name;
    this.role = 'admin';
  }
}

class RegularUser {
  constructor(name) {
    this.name = name;
    this.role = 'regular';
  }
}

class GuestUser {
  constructor() {
    this.name = 'Guest';
    this.role = 'guest';
  }
}

// Simple Factory
class UserFactory {
  static createUser(role, name) {
    switch (role) {
      case 'admin':
        return new AdminUser(name);
      case 'regular':
        return new RegularUser(name);
      case 'guest':
        return new GuestUser();
      default:
        throw new Error('Invalid user role');
    }
  }
}

// Usage
const admin = UserFactory.createUser('admin', 'Alice');
const regular = UserFactory.createUser('regular', 'Bob');
const guest = UserFactory.createUser('guest');

console.log(admin);
console.log(regular);
console.log(guest);

            

              
                Copy
              
            
          

            
// Abstract Factory
class UserFactory {
  createUser(name) {
    throw new Error('Method not implemented');
  }
}

// Concrete Factories
class AdminUserFactory extends UserFactory {
  createUser(name) {
    return new AdminUser(name);
  }
}

class RegularUserFactory extends UserFactory {
  createUser(name) {
    return new RegularUser(name);
  }
}

// Usage
const adminFactory = new AdminUserFactory();
const regularFactory = new RegularUserFactory();

const admin = adminFactory.createUser('Alice');
const regular = regularFactory.createUser('Bob');

console.log(admin);
console.log(regular);

            

              
                Copy
              
            
          

            
// Abstract Products
class Button {
  render() {
    throw new Error('Method not implemented');
  }
}

class TextField {
  render() {
    throw new Error('Method not implemented');
  }
}

// Concrete Products
class WindowsButton extends Button {
  render() {
    return 'Windows Button';
  }
}

class macOSButton extends Button {
  render() {
    return 'macOS Button';
  }
}

class WindowsTextField extends TextField {
  render() {
    return 'Windows TextField';
  }
}

class macOSTextField extends TextField {
  render() {
    return 'macOS TextField';
  }
}

// Abstract Factory
class UIFactory {
  createButton() {
    throw new Error('Method not implemented');
  }

  createTextField() {
    throw new Error('Method not implemented');
  }
}

// Concrete Factories
class WindowsUIFactory extends UIFactory {
  createButton() {
    return new WindowsButton();
  }

  createTextField() {
    return new WindowsTextField();
  }
}

class macOSUIFactory extends UIFactory {
  createButton() {
    return new macOSButton();
  }

  createTextField() {
    return new macOSTextField();
  }
}

// Usage
function createUI(factory) {
  const button = factory.createButton();
  const textField = factory.createTextField();
  return {
    button: button.render(),
    textField: textField.render()
  };
}

const windowsUI = createUI(new WindowsUIFactory());
const macOSUI = createUI(new macOSUIFactory());

console.log(windowsUI);
console.log(macOSUI);

            

              
                Copy
              
            
          

            
// Computer class
class Computer {
  constructor(cpu, ram, storage, graphicsCard, monitor) {
    this.cpu = cpu;
    this.ram = ram;
    this.storage = storage;
    this.graphicsCard = graphicsCard;
    this.monitor = monitor;
  }

  toString() {
    return `Computer: CPU=${this.cpu}, RAM=${this.ram}, Storage=${this.storage}, GraphicsCard=${this.graphicsCard}, Monitor=${this.monitor}`;
  }
}

// Builder class
class ComputerBuilder {
  constructor() {
    this.cpu = null;
    this.ram = null;
    this.storage = null;
    this.graphicsCard = null;
    this.monitor = null;
  }

  setCPU(cpu) {
    this.cpu = cpu;
    return this;
  }

  setRAM(ram) {
    this.ram = ram;
    return this;
  }

  setStorage(storage) {
    this.storage = storage;
    return this;
  }

  setGraphicsCard(graphicsCard) {
    this.graphicsCard = graphicsCard;
    return this;
  }

  setMonitor(monitor) {
    this.monitor = monitor;
    return this;
  }

  build() {
    return new Computer(this.cpu, this.ram, this.storage, this.graphicsCard, this.monitor);
  }
}

// Usage
const builder = new ComputerBuilder();
const myComputer = builder
  .setCPU('Intel i7')
  .setRAM('16GB')
  .setStorage('1TB SSD')
  .setGraphicsCard('Nvidia RTX 3080')
  .setMonitor('32-inch 4K')
  .build();

console.log(myComputer.toString());

const basicComputer = new ComputerBuilder()
 .setCPU("Intel i3")
 .setRAM("8GB")
 .setStorage("500GB HDD")
 .build();

console.log(basicComputer.toString());

            

              
                Copy
              
            
          

            
// Shape class
class Shape {
  constructor(color = 'red', x = 0, y = 0) {
    this.color = color;
    this.x = x;
    this.y = y;
  }

  draw() {
    console.log(`Drawing shape at (${this.x}, ${this.y}) with color ${this.color}`);
  }

  clone() {
    return Object.assign(Object.create(Object.getPrototypeOf(this)), this);
  }
}

// Usage
const prototypeShape = new Shape();

const shape1 = prototypeShape.clone();
shape1.x = 10;
shape1.y = 20;
shape1.color = 'blue';
shape1.draw();

const shape2 = prototypeShape.clone();
shape2.x = 30;
shape2.y = 40;
shape2.color = 'green';
shape2.draw();

prototypeShape.draw(); // Original prototype remains unchanged

            

              
                Copy
              
            
          

            
// Deep clone function (using JSON stringify/parse)
function deepClone(obj) {
  return JSON.parse(JSON.stringify(obj));
}

// Example with nested object
class Circle {
    constructor(radius, style = { color: 'red' }) {
        this.radius = radius;
        this.style = style;
    }

    clone() {
        return deepClone(this);
    }

    draw() {
        console.log(`Drawing a circle with radius ${this.radius} and color ${this.style.color}`);
    }
}

const originalCircle = new Circle(5, { color: 'blue' });
const clonedCircle = originalCircle.clone();
clonedCircle.radius = 10;
clonedCircle.style.color = 'green';

originalCircle.draw(); // Output: Drawing a circle with radius 5 and color blue
clonedCircle.draw();   // Output: Drawing a circle with radius 10 and color green

            

              
                Copy