Modello di fabbrica e modello di costruttore in javascript

Question

Ho visto un tutorial sul modello di progettazione in javascript. Anche se il tutorial è stato buono, mi ha lasciato poche domande.

Come vedo Factory e il costruttore producono lo stesso risultato. Quindi qual è la differenza tra entrambi? Quali sono gli scenari dei casi d'uso per ognuno?

pattern Factory

function factoryPattern(data) { 
    var factory = {}; 
    factory.name = data.name; 
    factory.title = data.title; 
    factory.startDate = data.startDate; 
    return factory; 
} 
var factoryUse = factoryPattern(jsonObj); 

modello Constructor

function constructorPattern(data) { 
    this.name = data.name; 
    this.title = data.title; 
    this.startDate = data.startDate; 
} 

var constructorUse = new constructorPattern(); 

Edit: Come ha spiegato @ Michael Warner. Il metodo Factory restituisce un oggetto immutabile che non ha alcun collegamento con il creatore dopo la creazione.

Ma nel patter del costruttore hanno un collegamento con loro.

Quindi avere un caso pratico d'uso sarebbe molto meglio capire perché a volte è bene avere un oggetto che abbia un collegamento con il proprio costruttore.

Answer 1

Con una fabbrica, si ha completa libertà sull'oggetto da restituire, quindi è possibile scegliere un costruttore o un altro in base ai dati di input, o all'ora del giorno, o addirittura non costruire nulla - quando si utilizza un fabbrica per restituire sigleons.

Al contrario un costruttore fondamentalmente crea un'istanza di un oggetto con un prototipo specifico, che è possibile configurare successivamente, nel corpo della funzione di costruzione.

Answer 2

Le fabbriche creano un oggetto e lo restituiscono. Questo è tutto. L'oggetto che viene creato è solo e la parte migliore di ciò è che puoi usare quell'oggetto e non essere influenzato da ciò che accade agli altri oggetti. Questo è noto come un singleton.

var Car = function(){ 
    var car = {}; 
    car.running = false; 
    car.toggleEngine = function(){ 
     this.running = !this.running; 
    } 
    return car; 
}; 

car1 = Car(); // running false 
car2 = Car(); // running false 
car1.toggleEngine(); // running true 
car2.toggleEngine = undefined; // to broke down. 
car1.toggleEngine(); //running false 

Costruttori aggiungere il codice alla funzione in modo da avere un collegamento al prototipo del costruttore dell'oggetto. La parte interessante di questo collegamento aggiuntivo consiste nell'utilizzare la tecnica condivisa funzionale che assomiglia a questo.

var Car = function(){ 
    this.running = false; 
}; 
Car.prototype.toggleEngine = function(){ 
    this.running = !this.running; 
} 
var car1 = new Car; //running false 
var car2 = new Car; //running false 

car2.toggleEngine() //running true 
Car.prototype.toggleEngine = function(){}; 
car1.toggleEngine() //running false 

Come possiamo vedere dopo che gli oggetti sono stati creati erano ancora molto collegati tra loro.

Per essere chiari è ancora possibile eseguire quanto segue e non effettuare gli oggetti creati dal costruttore. Con metodo condiviso funzionale e maschera la funzione prototipo fornita dal costruttore. Quindi non sono completamente collegati ma sono collegati tramite il prototipo dei costruttori.

var car1 = new Car; //running false 
var car2 = new Car; //running false 

car2.toggleEngine() //running true 
car2.toggleEngine = function(){}; 
car1.toggleEngine() //running true