Modèles de conception Javascript

Motif singleton | Modèle d'usine | Modèle de constructeur

Les sujets

• Modèle de singleton
• Modèle d'usine
• Modèle d'usine vs modèle de constructeur

• Le modèle de conception singleton expose une instance unique qui peut être utilisée par plusieurs composants
• Singleton Pattern peut être considéré comme la base des bibliothèques de gestion d'état globales telles que Redux ou React Context .
• C'est un modèle qui limite la classe à créer une seule instance.
• Ils sont accessibles globalement et agissent comme un point d'accès unique pour accéder à l'état global.

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;

• Enfin, nous créons l'instance de la classe comme suit : let stateUtilityInstance = Object.freeze(new StateUtility());.
• Nous avons utilisé Object.freezepour qu'aucune autre classe/composant/module ne puisse modifier le fichier stateUtilityInstance.

• Une usine est un objet ou une classe ou une fonction dans un paradigme de programmation fonctionnelle pour créer des objets.
• La méthode d'usine crée de nouveaux objets selon les instructions du client. Une façon de créer des objets en JavaScript consiste à appeler une fonction constructeur avec le nouvel opérateur
• Le modèle de conception d'usine est utilisé lorsque nous avons une superclasse avec plusieurs sous-classes et en fonction de l'entrée, nous devons renvoyer l'une des sous-classes . Ce modèle prend la responsabilité de l'instanciation d'une classe du programme client à la classe d'usine.
• Les classes délèguent la responsabilité à l'une des nombreuses sous-classes d'assistance et vous souhaitez localiser la connaissance de la sous-classe d'assistance qui est le délégué
• Les méthodes d'usine sont fréquemment utilisées dans les applications qui gèrent, maintiennent ou manipulent des collections d'objets différents mais qui ont en même temps de nombreuses caractéristiques (c'est-à-dire des méthodes et des propriétés) en commun.
• Le modèle d'usine peut utiliser un constructeur ou une classe à l'intérieur Mais le modèle d'usine est préféré dans les cas où le processus de création d'objet dépend de facteurs dynamiques, comme lorsque nous voulons créer dynamiquement des sous-classes.
• Factory nous offre un mécanisme de création d'objets à la fois flexible et réutilisable.

// 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]
// }

• Le modèle d'usine favorise la réutilisation du code en réutilisant les méthodes StartEngine, driveVehicleet .stopEngine

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();
    }
}

• Le modèle de constructeur et le modèle d'usine sont similaires car ce sont des modèles de création d'objet qui renvoient un nouvel objet
• La méthode d'usine peut retourner un objet déjà créé , contrairement à un constructeur, qui crée toujours une nouvelle instance.
• Les méthodes d'usine promeuvent l'idée de coder à l'aide de l'interface puis de l'implémentation, ce qui se traduit par un code plus flexible, mais le constructeur lie votre code à une implémentation particulière.
• Raisons d'utiliser des constructeurs : Nous utilisons des constructeurs pour initialiser l'objet avec l'état par défaut ou initial . Les valeurs par défaut des primitives peuvent ne pas correspondre à ce que vous recherchez. Une autre raison d'utiliser le constructeur est qu'il informe sur les dépendances.
• Raison d'utiliser Factory : Factory Method Pattern permet aux sous-classes de choisir le type d'objets à créer . Il favorise le couplage lâche en éliminant le besoin de lier des classes spécifiques à l'application dans le code.

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 }

• Lorsque notre configuration d'objet ou de composant implique un niveau élevé de complexité.
• Lorsque nous devons générer facilement différentes instances d'objets en fonction de l'environnement dans lequel nous nous trouvons.
• Lorsque nous travaillons avec de nombreux petits objets ou composants partageant les mêmes propriétés.
• Lors de la composition d'objets avec des instances d'autres objets qui n'ont besoin que de satisfaire un contrat d'API (aka, duck typing) pour fonctionner. Ceci est utile pour le découplage.

• Veuillez applaudir pour l'histoire et suivez-moi
• Voir plus de contenu sur les entretiens de codage et de conception de système
• Suivez-moi : LinkedIn !

Rejoignez le collectif de talents Level Up et trouvez un travail incroyable