The ultimate guide to coding interviews: Learn and practice JavaScript design patterns tested by FAANG engineers. Get interview-ready in just a few hours with battle-tested solutions.

If you're an experienced developer, chances are your interviewer won't ask you about language syntax. Instead, they'll focus on things that test your understanding of software architecture, and how capable you are at finding optimized solutions to given problems. 

That’s where a strong understanding of design patterns comes in handy. It's often useful to be able to draw on established patterns instead of reinventing the wheel.

In this course, you will learn how to effectively deploy design patterns to answer interview questions. The course is divided into four sections: Creational Patterns, Structural Patterns, Behavioral Patterns, and Architectural Patterns. Each section has its own set of design patterns which you’ll learn to use through various challenges. 

Every challenge contains a detailed solution explanation. By the end of this course (and with some practice), you will be able to confidently use design patterns to tackle advanced coding interview questions in JavaScript.

JavaScript Design Patterns for Coding Interviews

class Dress{
  constructor(serialNumber,type,color,designer,availability){
    this.serialNumber = serialNumber
    this.type = type
    this.color = color
    this.designer = designer
    this.availability = availability
    this.price = 0
  }
  dressPrice(){
    if(this.type == "maxi"){
      this.price = 1000
    }
    if(this.type == "gown"){
      this.price = 2000
    }
    if(this.type = "skirt"){
      this.price = 500
    }
    return this.price
  }  
}

class DressFactory {
  constructor() {
    this.existingDresses = {}
  }

  createDress(serialNumber,type,color, designer, availability) {
    var exists = this.existingDresses[serialNumber]
  
    if (!!exists) {
      return this.existingDresses[serialNumber]
    }
    else {
        var dress = new Dress(serialNumber,type,color, designer, availability)
        this.existingDresses[serialNumber]= dress
        return dress
      }
    }
}

const factory = new DressFactory()
const pinkdress1 = factory.createDress("#123","skirt","pink","Zara","yes")
const pinkdress2 = factory.createDress("#123","skirt","pink","Zara","yes")

console.log(pinkdress1 === pinkdress2)
console.log(pinkdress1.dressPrice())
console.log(pinkdress2.dressPrice())

# Explanation

As explained in the problem statement, we need to implement a functionality that doesn't allow dresses with the same `serialNumber` to be made more than once. For this purpose, a *flyweight factory* can be used. Before we get into that, let's look into the `Dress` class first.

```
class Dress{
  constructor(serialNumber,type,color,designer,availability){
    this.serialNumber = serialNumber
    this.type = type
    this.color = color
    this.designer = designer
    this.availability = availability
    this.price = 0
  }
  //code... 
}
```

A `Dress` instance contains the properties:
`serialNumber` (a unique ID), a `type` (maxi, gown, or skirt), `color`, the `designer` who made the dress, its `availability`, and `price`.

The `price` is initialized to `0` as it is set later on using the `dressPrice` function. Let's look into its implementation:

```
dressPrice(){
    if(this.type == "maxi"){
      this.price = 1000
    }
    if(this.type == "gown"){
      this.price = 2000
    }
    if(this.type = "skirt"){
      this.price = 500
    }
    return this.price
} 
```

Depending on the dress, we set the price equal to the price mentioned in the question and return it.

The next step is to set up a *flyweight factory* that monitors the number of dresses made corresponding to a `serialNumber`. We start by defining a class `DressFactory` like so: 

```
class DressFactory{
  constructor() {
    this.existingDresses = {}
  }
  //code....
}
```

Since it is a factory that produces a lot of dresses, we initialize a variable `existingDresses` in its `constructor` that will store all the unique dresses made.

Next, we define the `createDress` function, which is responsible for monitoring the dress creation process. 

```
class DressFactory{
  //code....
  createDress(serialNumber,type,color, designer, availability) {
  var exists;
    exists = this.existingDresses[serialNumber]
  
    if (!!exists) {
      return this.existingDresses[serialNumber]
    }
    else {
        var dress = new Dress(serialNumber,type,color, designer, availability)
        this.existingDresses[serialNumber]= dress
        return dress
      }
    }
}
```

The function accepts as parameters all the properties of a dress: `serialNumber`, `type`, `color`, `designer`, `availability`.                  Whenever a request to create a dress is invoked, the function first checks whether such a dress already exists or not. If not, it creates a new `Dress` instance, adds it to the list of `existingDresses`, and returns it. If an instance already exists, it is returned.

As you can see, if the same dress is instantiated twice, a new object is not created the second time.

```
console.log(pinkdress1 === pinkdress2) //true
```


Hence, the `DressFactory` prevents an unnecessary clutter of objects. The `Dress` instance acts as our *flyweight* object containing the intrinsic information such as the `dressPrice` function.

This lesson will explain the solution to the problem from the previous coding challenge.

Before We Begin

Introduction To Design Patterns

Creational Patterns

Structural Patterns

Behavioral Patterns

Architectural Patterns

Conclusion

Challenge: Solution Review

Solution #

Explanation