ts Facade pattern ts Facade pattern

/*Facade

The Facade pattern is a design pattern lets you define a simple unified interface

to a large body of code .

imagine you want to make a car and you want to make it with a engine,

transmission, and wheels.
First you need to make a car class:

*/

class Car {

  public makeCar() {

    console.log(‘Making a car…’);

  }

}
// Then you make a facade class that will make the car with an engine, transmission, and wheels and abstract the process from the user

class CarFacade {

  constructor(private car: Car) {}
  public makeCar() {

    this.car.makeCar();

    this.makeEngine();

    this.makeTransmission();

    this.makeWheels();

  }
  private makeEngine() {

    console.log(‘Making engine…’);

  }
  private makeTransmission() {

    console.log(‘Making transmission…’);

  }
  private makeWheels() {

    console.log(‘Making wheels…’);

  }

}
// Then you make your car:

const car = new CarFacade(new Car());

car.makeCar();/*Proxy

The Proxy design pattern is a design pattern lets you provide a surrogate

or placeholder object for another object to control access to it.
For example imagine you want to give students access to a

library but you don’t want them to be able to access the library directly.
First you need to make a library class:

*/

class Library {

  public getBooks() {

    console.log(‘Getting books…’);

  }

}
// Then you make a proxy class that will give students access to the library:

class LibraryProxy {

  constructor(private library: Library) {}
  public getBooks() {

    this.library.getBooks();

  }

}
// Then you make your library:

const library = new LibraryProxy(new Library());

library.getBooks();