Javascript-Designmuster

Singleton-Muster | Fabrikmuster | Konstruktormuster

Themen

• Singleton-Muster
• Fabrikmuster
• Fabrikmuster vs. Konstruktormuster

• Das Singleton-Entwurfsmuster macht eine einzelne Instanz verfügbar, die von mehreren Komponenten verwendet werden kann
• Singleton Pattern können als die Grundlagen globaler Zustandsverwaltungsbibliotheken wie Redux oder React Context angesehen werden .
• Es ist ein Muster, das die Klasse darauf beschränkt, nur eine Instanz zu erstellen.
• Auf sie kann global zugegriffen werden und fungiert als einzelner Zugriffspunkt für den Zugriff auf den globalen Zustand.

let instance;
let globalState = {
  color: ""
};

class StateUtility {
  constructor() {
    if (instance) {
      throw new Error("New instance cannot be created!!");
    }
    instance = this;
  }
  getPropertyByName(propertyName) {
    return globalState[propertyName];
  }
  setPropertyValue(propertyName, propertyValue) {
    globalState[propertyName] = propertyValue;
  }
}
let stateUtilityInstance = Object.freeze(new StateUtility());
export default stateUtilityInstance;

• Schließlich erstellen wir die Instanz der Klasse wie folgt: let stateUtilityInstance = Object.freeze(new StateUtility());.
• Wir haben verwendet Object.freeze, damit keine andere Klasse/Komponente/Modul die exponierte stateUtilityInstance.

• Eine Fabrik ist ein Objekt oder eine Klasse oder eine Funktion in einem funktionalen Programmierparadigma zum Erstellen von Objekten.
• Die Factory-Methode erstellt neue Objekte gemäß den Anweisungen des Clients. Eine Möglichkeit, Objekte in JavaScript zu erstellen, besteht darin, eine Konstruktorfunktion mit dem new-Operator aufzurufen
• Das Factory-Entwurfsmuster wird verwendet, wenn wir eine Oberklasse mit mehreren Unterklassen haben und basierend auf der Eingabe eine der Unterklassen zurückgeben müssen . Dieses Muster übernimmt die Verantwortung für die Instanziierung einer Klasse vom Client-Programm an die Factory-Klasse.
• Klassen delegieren die Verantwortung an eine von mehreren Hilfsunterklassen, und Sie möchten das Wissen darüber lokalisieren, welche Hilfsunterklasse der Delegierte ist
• Factory-Methoden werden häufig in Anwendungen verwendet, die Sammlungen von Objekten verwalten, warten oder manipulieren, die unterschiedlich sind, aber gleichzeitig viele Merkmale (dh Methoden und Eigenschaften) gemeinsam haben.
• Das Factory-Muster kann einen Konstruktor oder eine Klasse im Inneren verwenden. Das Factory-Muster wird jedoch in Fällen bevorzugt, in denen der Objekterstellungsprozess von dynamischen Faktoren abhängt – beispielsweise wenn wir Unterklassen dynamisch erstellen möchten.
• Factory bietet uns einen Objekterstellungsmechanismus, der sowohl flexibel als auch wiederverwendbar ist.

// creates factory function
function vehicleFactory (manufacturer, plateNO) {
    return  {
        manufacturer,
        plateNO,
        startEngine () {
            console.log("reving engine")
        },
        drive () {
            console.log("driving car...")
        }
    }
}
 
const Vehicle1 = vehicleFactory("Toyota", 12345);
console.log(Vehicle1) 
// prints 
//{
//  manufacturer: 'Toyota',
//  plateNO: 12345,
//  startEngine: [Function: startEngine],
//  drive: [Function: drive]
//}
  
const Vehicle2 = vehicleFactory("Ford", 13345);
console.log(Vehicle2) 
// prints 
// {
//  manufacturer: 'Ford',
//  plateNO: 13345,
//  startEngine: [Function: startEngine],
//  drive: [Function: drive]
// }

• Das Fabrikmuster fördert die Wiederverwendbarkeit von Code, indem die Methoden StartEngine, driveVehicle, und wiederverwendet stopEnginewerden.

class Car {
    constructor(options) {
        this.wheels = options.wheels || 4;
        this.doors = options.doors || 4;
        this.color = options.color || "silver"; 
    }
}

class Truck {
    constructor(options) {
        this.wheels = options.wheels || 6;
        this.doors = options.doors || 2;
        this.color = options.color || "red"; 
    }
}


class Factory {

    create = (options, vehicleType) => {

        if(!vehicleType) {
            return "unable to make vehicle. Please specify a vehicle type and tryagain!"
        }

        let vehicle;
        
        if (vehicleType === "car") {
            vehicle = new Car(options);
        } else if (vehicleType === "truck") {
            vehicle = new Truck(options);
        } 

  
        vehicle.vehicleType = vehicleType;

        vehicle.startEngine = ()=> console.log(`Reving ${vehicleType} engine`);

        vehicle.driveVehicle = ()=> console.log(`Driving ${vehicleType}...`);

        vehicle.stopEngine = ()=> console.log(`Stop ${vehicleType} engine`);

        return vehicle;
    }
 
};

const vehicleFactory = new Factory();

const car = vehicleFactory.create({
    wheels: 4,
    doors: 2,
    color: "black",
}, "car");

console.log(car)
console.log(car.startEngine())
console.log(car.driveVehicle())

// prints:
//Car {
//  wheels: 4,
//  doors: 4,
//  color: 'silver',
//  vehicleType: 'car',
//  startEngine: [Function],
//  driveVehicle: [Function],
//  stopEngine: [Function]
//}

// Reving car engine
// Driving car...

const truck = vehicleFactory.create({
    wheels: 4,
 doors: 2,
 color: "yellow",
}, "truck")

console.log(truck)
console.log(truck.startEngine())
console.log(truck.stopEngine())
// prints
//Truck {
//  wheels: 4,
//  doors: 2,
//  color: 'yellow',
//  vehicleType: 'truck',
//  startEngine: [Function],
//  driveVehicle: [Function],
//  stopEngine: [Function]
//}

// Reving truck engine
// Stop truck engine

class Car {
    constructor(options) {
        this.wheels = options.wheels || 4;
        this.doors = options.doors || 4;
        this.color = options.color || "silver"; 
    }
}

class Truck {
    constructor(options) {
        this.wheels = options.wheels || 6;
        this.doors = options.doors || 2;
        this.color = options.color || "red"; 
    }
}

class Bus {
    constructor(options) {
        this.wheels = options.wheels || 4;
        this.doors = options.doors || 4;
        this.color = options.color || "white"; 
    }
}

class Motorcycle {
    constructor(options) {
        this.wheels = options.wheels || 2;
        this.doors = options.doors || 0;
        this.color = options.color || "Black"; 
    }
}


class Factory {

    create = (options, vehicleType) => {

        if(!vehicleType) {
            return "unable to make vehicle. Please specify a vehicle type and tryagain!"
        }

        let vehicle;
        
        if (vehicleType === "car") {
            vehicle = new Car(options);
        } else if (vehicleType === "truck") {
            vehicle = new Truck(options);
        } else if (vehicleType === "bus") {
            vehicle = new Bus(options);
        } else if (vehicleType === "motorcycle") {
            vehicle = new Motocycle(options);
        }

  
        vehicle.vehicleType = vehicleType;

        vehicle.startEngine = ()=> console.log(`Reving ${vehicleType} engine`);

        vehicle.driveVehicle = ()=> console.log(`Driving ${vehicleType}...`);

        vehicle.stopEngine = ()=> console.log(`Stop ${vehicleType} engine`);

        return vehicle;
    }
 
};

const vehicleFactory = new Factory();

const bus = vehicleFactory.create({
    wheels: 4,
    doors: 4,
    color: "yellow",
}, "bus");

console.log(bus)
console.log(bus.startEngine())
console.log(bus.driveVehicle())

// prints:
// Bus {
//  wheels: 4,
//  doors: 4,
//  color: 'yellow',
//  vehicleType: 'bus',
//  startEngine: [Function],
//  driveVehicle: [Function],
//  stopEngine: [Function]
//}

// Reving bus engine
// Driving bus...

const bike = vehicleFactory.create({
    wheels: 2,
 doors: 0,
 color: "red",
}, "motorcycle")

console.log(bike)
console.log(bike.startEngine())
console.log(bike.stopEngine())
// prints
// Motorcycle {
//  wheels: 2,
//  doors: 0,
//  color: 'red',
//  vehicleType: 'bike',
//  startEngine: [Function],
//  driveVehicle: [Function],
//  stopEngine: [Function]
//}

// Reving motorcycle engine
// Stop motorcycle engine

var Factory = function () {
    this.createEmployee = function (type) {
        var employee;

        if (type === "fulltime") {
            employee = new FullTime();
        } else if (type === "parttime") {
            employee = new PartTime();
        } else if (type === "temporary") {
            employee = new Temporary();
        } else if (type === "contractor") {
            employee = new Contractor();
        }

        employee.type = type;

        employee.say = function () {
            console.log(this.type + ": rate " + this.hourly + "/hour");
        }

        return employee;
    }
}

var FullTime = function () {
    this.hourly = "$12";
};

var PartTime = function () {
    this.hourly = "$11";
};

var Temporary = function () {
    this.hourly = "$10";
};

var Contractor = function () {
    this.hourly = "$15";
};

function run() {

    var employees = [];
    var factory = new Factory();

    employees.push(factory.createEmployee("fulltime"));
    employees.push(factory.createEmployee("parttime"));
    employees.push(factory.createEmployee("temporary"));
    employees.push(factory.createEmployee("contractor"));

    for (var i = 0, len = employees.length; i < len; i++) {
        employees[i].say();
    }
}

• Das Konstruktormuster und das Fabrikmuster sind ähnlich, da es sich um Objekterstellungsmuster handelt, die ein neues Objekt zurückgeben
• Die Factory-Methode kann ein bereits erstelltes Objekt zurückgeben , im Gegensatz zu einem Konstruktor, der immer eine neue Instanz erstellt.
• Factory-Methoden fördern die Idee der Codierung mit Interface und dann Implementierung, was zu einem flexibleren Code führt, aber der Konstruktor bindet Ihren Code an eine bestimmte Implementierung.
• Gründe für die Verwendung von Konstruktoren: Wir verwenden Konstruktoren , um das Objekt mit dem Standard- oder Anfangszustand zu initialisieren . Die Standardwerte für Primitive sind möglicherweise nicht das, wonach Sie suchen. Ein weiterer Grund für die Verwendung des Konstruktors ist, dass er über Abhängigkeiten informiert.
• Grund für die Verwendung von Factory: Das Factory-Methodenmuster ermöglicht es den Unterklassen, den Typ der zu erstellenden Objekte auszuwählen . Es fördert die lose Kopplung, indem es die Notwendigkeit beseitigt, anwendungsspezifische Klassen in den Code einzubinden.

const vehicleOptions = {type: "cars", color: "white", doors: 4, wheels: 4}

// factory pattern
function Factory(options) {
  let factory = {};
  factory.type = options.type;
  factory.color = options.color;
  factory.wheels = options.wheels;
  factory.doors = options.doors;
  
  return factory;
}

const vehicle = Factory(vehicleOptions);

// constructor pattern
function ConstructorPattern(options) {
  this.type = options.type;
  this.color = options.color
  this.doors = options.doors;
  this.wheels = options.wheels;
}

const vehicle2 = new ConstructorPattern(vehicleOptions);

console.log("factory car", vehicle)
// prints { type: 'cars', color: 'white', wheels: 4, doors: 4 }

console.log("constructor car", vehicle2)
// prints { type: 'cars', color: 'white', wheels: 4, doors: 4 }

• Wenn unser Objekt- oder Komponentenaufbau ein hohes Maß an Komplexität beinhaltet.
• Wenn wir je nach Umgebung, in der wir uns befinden, einfach verschiedene Instanzen von Objekten generieren müssen.
• Wenn wir mit vielen kleinen Objekten oder Komponenten arbeiten, die dieselben Eigenschaften haben.
• Beim Zusammenstellen von Objekten mit Instanzen anderer Objekte, die nur einen API-Vertrag (auch bekannt als Duck Typing) erfüllen müssen, um zu funktionieren. Dies ist nützlich für die Entkopplung.

• Bitte klatscht für die Story und folgt mir
• Sehen Sie sich weitere Inhalte zu Programmier- und Systemdesign-Interviews an
• Folgen Sie mir: LinkedIn !

Tritt dem Talentkollektiv Level Up bei und finde einen tollen Job