Посочете моделите, които принадлежат към създаващите…

Фабричен метод (Factory Method): Определя интерфейс за създаване на обекти, но позволява на подкласовете да решат кой клас да инстанцират.

// Интерфейс на фабриката
class Creator {
    factoryMethod() {
        throw new Error("Методът трябва да бъде реализиран от подкласовете");
    }

    anOperation() {
        const product = this.factoryMethod();
        return `Creator: същата логика, само че работи с ${product.operation()}`;
    }
}

// Конкретна фабрика, създаваща ProductA
class ConcreteCreatorA extends Creator {
    factoryMethod() {
        return new ConcreteProductA();
    }
}

// Интерфейс на продукта
class Product {
    operation() {
        throw new Error("Методът трябва да бъде реализиран от подкласовете");
    }
}

// Конкретен продукт, създаден от ConcreteCreatorA
class ConcreteProductA extends Product {
    operation() {
        return "Резултат от ConcreteProductA";
    }
}

// Използване
const creator = new ConcreteCreatorA();
console.log(creator.anOperation());

Абстрактна фабрика (Abstract Factory): Предоставя интерфейс за създаване на семейства свързани или зависими обекти, без да специфицира конкретните им класове.

// Интерфейс на абстрактната фабрика
class AbstractFactory {
    createProductA() {
        throw new Error("Методът трябва да бъде реализиран от подкласовете");
    }

    createProductB() {
        throw new Error("Методът трябва да бъде реализиран от подкласовете");
    }
}

// Конкретна фабрика за създаване на продукти Вариант 1
class ConcreteFactory1 extends AbstractFactory {
    createProductA() {
        return new ConcreteProductA1();
    }

    createProductB() {
        return new ConcreteProductB1();
    }
}

// Конкретна фабрика за създаване на продукти Вариант 2
class ConcreteFactory2 extends AbstractFactory {
    createProductA() {
        return new ConcreteProductA2();
    }

    createProductB() {
        return new ConcreteProductB2();
    }
}

// Интерфейси на продуктите
class AbstractProductA {
    operationA() {
        throw new Error("Методът трябва да бъде реализиран от подкласовете");
    }
}

class AbstractProductB {
    operationB() {
        throw new Error("Методът трябва да бъде реализиран от подкласовете");
    }

    anotherOperationB(collaborator) {
        throw new Error("Методът трябва да бъде реализиран от подкласовете");
    }
}

// Конкретни продукти Вариант 1
class ConcreteProductA1 extends AbstractProductA {
    operationA() {
        return "Резултат от ConcreteProductA1";
    }
}

class ConcreteProductB1 extends AbstractProductB {
    operationB() {
        return "Резултат от ConcreteProductB1";
    }
    anotherOperationB(collaborator) {
        return `Резултат от ConcreteProductB1 съвместно с ${collaborator.operationA()}`;
    }
}

// Конкретни продукти Вариант 2
class ConcreteProductA2 extends AbstractProductA {
    operationA() {
        return "Резултат от ConcreteProductA2";
    }
}

class ConcreteProductB2 extends AbstractProductB {
    operationB() {
        return "Резултат от ConcreteProductB2";
    }
    anotherOperationB(collaborator) {
        return `Резултат от ConcreteProductB2 съвместно с ${collaborator.operationA()}`;
    }
}

// Използване
function clientCode(factory) {
    const productA = factory.createProductA();
    const productB = factory.createProductB();

    console.log(productB.operationB());
    console.log(productB.anotherOperationB(productA));
}

console.log('Клиент: Тест на Factory1...');
clientCode(new ConcreteFactory1());

console.log('Клиент: Тест на Factory2...');
clientCode(new ConcreteFactory2());

Строител (Builder): Позволява създаването на сложни обекти стъпка по стъпка. Дава възможност да се използва един и същ процес на строителство за получаване на различни представяния на обекта.

// Интерфейс на строителя
class Builder {
    producePartA() { }
    producePartB() { }
    producePartC() { }
}

// Конкретен строител
class ConcreteBuilder1 extends Builder {
    constructor() {
        super();
        this.reset();
    }

    reset() {
        this.product = new Product1();
    }

    producePartA() {
        this.product.parts.push('PartA1');
    }

    producePartB() {
        this.product.parts.push('PartB1');
    }

    producePartC() {
        this.product.parts.push('PartC1');
    }

    getProduct() {
        const result = this.product;
        this.reset();
        return result;
    }
}

// Представян продукт
class Product1 {
    constructor() {
        this.parts = [];
    }

    listParts() {
        console.log(`Частите на продукта: ${this.parts.join(', ')}`);
    }
}

// Директор (не е задължителен, управлява процеса на строителство)
class Director {
    setBuilder(builder) {
        this.builder = builder;
    }

    buildMinimalViableProduct() {
        this.builder.producePartA();
    }

    buildFullFeaturedProduct() {
        this.builder.producePartA();
        this.builder.producePartB();
        this.builder.producePartC();
    }
}

// Използване
const director = new Director();
const builder = new ConcreteBuilder1();
director.setBuilder(builder);

console.log('Стандартен минимален продукт:');
director.buildMinimalViableProduct();
builder.getProduct().listParts();

console.log('Стандартен пълен продукт:');
director.buildFullFeaturedProduct();
builder.getProduct().listParts();

console.log('Потребителски продукт:');
builder.producePartA();
builder.producePartC();
builder.getProduct().listParts();

Прототип (Prototype): Позволява копирането на съществуващи обекти, без да навлиза в подробности за тяхната реализация.

// Интерфейс на прототипа
class Prototype {
    clone() {
        throw new Error("Методът трябва да бъде реализиран от подкласовете");
    }
}

// Конкретен прототип
class ConcretePrototype1 extends Prototype {
    constructor(property) {
        super();
        this.property = property;
    }

    clone() {
        const clone = new ConcretePrototype1(this.property);
        // Може да добавите дълбоко копиране на други свойства, ако е необходимо
        return clone;
    }
}

// Използване
const original = new ConcretePrototype1("стойност");
const clone = original.clone();

console.log(`Оригинал property: ${original.property}`);
console.log(`Клон property: ${clone.property}`);

// Проверка дали това са различни обекти
console.log(`Различни обекти? ${original === clone}`);

Сингълтън (Singleton): Гарантира, че класът има само един екземпляр, и предоставя глобална точка за достъп до него.

class Singleton {
    static instance;

    constructor() {
        if (Singleton.instance) {
            return Singleton.instance;
        }
        Singleton.instance = this;
    }

    someBusinessLogic() {
        // ...
    }
}

// Използване
const s1 = new Singleton();
const s2 = new Singleton();

console.log(`Един и същ екземпляр? ${s1 === s2}`);

Посочете моделите, които принадлежат към създаващите.