Creational Design Pattern

Added the code for design pattern that comes under Creational design pattern

Author: lazy-sunshine

Diff for: builderPattern.js

@@ -0,0 +1,84 @@
+// // Builder Design Pattern, which is a pattern used to help construct complex objects. It helps separate
+// // object construction from its representation which will help us reuse this to create different representations.
+// // here we instantiate a object with basic parameter and all the code for its other pattern and added subsequemtly.
+// // the builder pattern is generally needed most when we need a way to help simplify constructions of complex objects, 
+// // so the best time to introduce this into your code is when you're hitting that point or when they are becoming large.
+// It lays out the following steps:
+
+//1. The base class contains the business logic
+
+// 2. It also receives the object that was created and proceeds to set the values
+// Separate the code that is responsible for creating objects into builders--which ultimately are also just objects/classes.
+
+// All of these builders will be responsible for defining the steps to construct the complex objects.
+// Can use an optional class which is called the Director
+// Directors are involved in defining methods ensuring that steps are executed in a specific order to build the commonly constructed objects.
+
+class Animal{
+    constructor(type,species,name,wild,food) {
+        this.type = type;
+        this.species = species;
+        this.name = name;
+        this.wild = wild ;
+        this.food = food ;
+        
+      }
+    
+      eat(target) {
+        console.log(`Eating target: ${target.name}`)
+      }
+} 
+
+
+
+class AnimalBuilder{
+
+     constructor(species, type){
+         this.species = species;
+         this.type =type;
+     }
+
+     setName(name){
+        this.name = name;
+        return this;
+     }
+
+     isWild(wild){
+         this.wild = wild;
+         return this;
+     }
+     eats(food){
+         this.food = food;
+         return this;
+     }
+
+     build(){
+        if(!this.name){
+            throw new Error('Name is missing'); 
+        }
+
+        return new Animal(this.type, this.species, this.name,this.wild,this.food);
+     }
+
+
+ }
+
+
+ //so now without the builder class we will previously call, here the issue is as the parameter increases its complexity
+ //increases as we have to always do a two and fro while instantiating the source code plus there could be easily mistakes
+
+ const rabbit = new Animal('rabbit', 'land', 'momo', null,'herbivore');
+
+
+ // with builder patterm
+
+ const lion = new AnimalBuilder('lion', 'land')
+                .setName('lion').isWild( true).eats('carnivore').build();
+
+
+//The builder pattern might seem similar to the abstract factory pattern but one difference is that the builder pattern creates 
+//an object step by step whereas the abstract factory pattern returns the object in one go.
+
+
+
+

Diff for: constructor_pattern.js

@@ -0,0 +1,24 @@
+function Animal(  species, animalName, food ) {
+  this.species= species;
+  this.animalName= animalName;
+  this.food = food;
+  this.eat = function () {
+    return this.animalName+ " eats" + this.food ;
+  };
+} 
+// We can create new instances of the animal
+const lion = new Animal('Felidae', 'lion', 'meet');
+
+In Es6 way using class 
+class Animal{
+constructor(species, animalName, food ){
+this._species= species;
+  this._animalName= animalName;
+  this._food = food;
+  this.eat = function () {
+    return this.animalName+ " eats" + this.food ;
+  };
+
+}
+}
+var rabbit = new Animal('Leporidae','rabbit', 'grass');

Diff for: factoryPattern.js

@@ -0,0 +1,65 @@
+class VehicleFactory{
+
+    constructor(){
+
+        this.createVehicle = function(configs){
+
+            let vehicle;
+            const {type} = configs;
+
+            switch(type){
+
+                case "Car" : 
+                    vehicle = new Car(configs);
+                    break;
+                
+                case "Truck": 
+                    vehicle =  new Truck(configs);
+                    break;
+
+                default :
+                    return null;
+            }
+
+            vehicle.genericInformation = () => {
+                console.log("heavy vehicle");
+            }
+
+            return vehicle;
+        }
+
+    }
+}
+
+class Car {
+    
+    constructor(options){
+          // some defaults
+        this.type = "Car";
+        this.doors = options.doors || 4;
+        this.state = options.state || "brand new";
+        this.color = options.color || "silver";
+    }
+
+    carForMe = (option) => {
+
+        const {coPassenger,  safetyLevel, sunRoof} = options;
+
+        if(coPassenger >=2 && safetyLevel <=5 && sunRoof) return "You need a fast and furious car";
+
+        else 
+            return "You are in for a cutesy small car. :) "
+    }
+  
+   
+  }
+
+class Truck {
+
+    constructor(options){
+        this.type="Truck";
+        this.state = options.state || "used";
+        this.wheelSize = options.wheelSize || "large";
+        this.color = options.color || "blue";
+    }
+}

Diff for: prototypePaatern.js

@@ -0,0 +1,30 @@
+1.// By using Object.create.Object.create creates an object which has a specified prototype and optionally contains specified properties as wel
+
+
+const car ={
+
+    name: "Maruti",
+
+    drive: function () {
+        console.log( "Weeee. I'm driving!" );
+      },
+     
+      panic: function () {
+        console.log( "Wait. How do you stop this thing?" );
+      }    
+};
+
+const options = {
+    "id": {
+    value: '11',
+    enumerable: true
+  },
+ 
+  "model": {
+    value: "Ford",
+    enumerable: true
+  }
+ }
+const yourCar = Object.create(car, options);
+
+

Diff for: singleTon.js

@@ -0,0 +1,19 @@
+class Logger {
+    constructor(name = "") {
+        if (!!Logger.instance) {
+            return Logger.instance;
+        }
+
+        Logger.instance = this;
+
+        this.name = name;
+
+        return this;
+    }
+
+    log(val) {
+        console.log(val);
+    }
+}
+
+