Breaking News: Grepper is joining You.com. Read the official announcement!

facade design pattern typescript

Restu Wahyu Saputra answered on November 18, 2021 Popularity 6/10 Helpfulness 2/10

answer facade design pattern typescript

related ts Facade pattern

facade design pattern typescript

Comment

interface Store {
  product(name: string): string
  category(): string
}

class Minuman implements Store {
   product(name: string): string {
      return name
   }
   
   category(): string {
      return 'minuman'
   }
}

class Makanan implements Store {   
   product(name: string): string {
      return name
   }
   
   category(): string {
     return 'makanan'
   }
}

class StoreFaced {
  public minuman: InstanceType<typeof Minuman>
  public makanan: InstanceType<typeof Makanan>
  
  constructor() {
    this.minuman = new Minuman()
    this.makanan = new Makanan()
  }
  
  storeMinuman(name: string): string {
    return this.minuman.product(name)
  }
  
  storeMakanan(name: string): string {
    return this.makanan.product(name)
  }
}

const res = new StoreFaced()
console.log(`product name: ${res.storeMinuman("cola cola")} and product category ${res.minuman.category()}`)
console.log(`product name: ${res.storeMakanan("biskuat")} and product category ${res.makanan.category()}`)

Popularity 6/10 Helpfulness 2/10 Language typescript

Source: Grepper

Tags: facade typescript

Link to this answer
Share Copy Link

Contributed on Nov 18 2021

Restu Wahyu Saputra

0 Answers Avg Quality 2/10

Closely Related Answers

ts Facade pattern

Comment

/*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();

Popularity 4/10 Helpfulness 1/10 Language typescript

Source: dev.to

Tags: facade typescript

Link to this answer
Share Copy Link

Contributed on May 06 2022

barisx

0 Answers Avg Quality 2/10

ts Facade pattern

Comment

/*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();

Popularity 5/10 Helpfulness 1/10 Language typescript

Source: dev.to

Tags: typescript facade

Link to this answer
Share Copy Link

Contributed on May 06 2022

barisx

0 Answers Avg Quality 2/10

facade design pattern typescript

Contents

More Related Answers

facade design pattern typescript

Closely Related Answers

ts Facade pattern

ts Facade pattern

Grepper

Documentation

Social

Legal

Contact

Oops, You will need to install Grepper and log-in to perform this action.