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

// old interface
class TruthAndDare {
  constructor(){
    this.turn = Math.floor(Math.random() * 2) + 1;
  }
  Getturn(){
    if(this.turn == 1){
      this.turn = 2
    }else{
      this.turn = 1
    }
    return this.turn
  }
  playGame(playerOnename,playerTwoname){
    if(this.Getturn() == 1){
      return`${playerOnename}'s turn`
    }else{
      return `${playerTwoname}'s turn`
    }
  }
}

// new interface
class NewTruthAndDare {
  constructor(randomValue){
      this.turn = randomValue
  }
 
  newplayGame(playerOnename,playerTwoname){
    if((this.turn % 2) == 0){
      return `${playerOnename}'s turn`
    }else{
      return `${playerTwoname}'s turn`
    }
  }
}

// Adapter Class
class Adapter {
  constructor(randomValue) {
    const newGame = new NewTruthAndDare(randomValue)

    this.playGame = function(playerOnename,playerTwoname) {
     return newGame.newplayGame(playerOnename,playerTwoname)
    };
  }
}

const obj = new Adapter(6) //pass even/odd values here to see varying results
console.log(obj.playGame("Ross","Chandler"))

# Explanation

In the code above, we have a `TruthAndDare` class, which has a `playGame` function that decides which player's turn it is, depending on the `turn` variable. The `constructor` initializes `turn` to either `1` or `2` randomly.

The `turn` variable is accessed through the `Getturn` function. 

```
  Getturn(){
    if(this.turn == 1){
      this.turn = 2
    }else{
      this.turn = 1
    }
    return this.turn
  }
```
If the value of `turn` is `1`, the function sets it to `2` and vice versa. 

Next, we decide to update how the turns are chosen, so we create a new class, `NewTruthAndDare`. It consists of the following modifications:

* we set `turn` to some `randomValue` passed through the constructor. 

  ```
  constructor(randomValue){
    this.turn = randomValue;
  }
  ```

* Next, we define the `newplayGame` function. 

  ```
  newplayGame(playerOnename,playerTwoname)    
  {
    if((this.turn % 2) == 0){
      return `${playerOnename}'s turn`
    }else{
      return `${playerTwoname}'s turn`
    }
  }
  ```
  We access `turn` and check whether it is even. If it's even, it is player 1's turn, else, it is player 2's turn.

Finally, we make sure that the interface does not change for the players. This means they can keep calling `playGame` without knowing that the method to randomize turns has changed or the function name has changed to `newplayGame`. For this purpose, we define the `Adapter` class.

```
class Adapter {
  constructor(randomValue) {
    const newGame = new NewTruthAndDare(randomValue)

    this.playGame = function(playerOnename,playerTwoname) {
     return newGame.newplayGame(playerOnename,playerTwoname)
    };
  }
}
```

* We create an object `newGame` of the class `NewTruthAndDare`. 

* Next, we define the `playGame` function in it. In the definition, we call the `newGame.newplayGame` function. 

So now, the players can keep calling the `playGame` function as it is, but on the backend, the `newplayGame` function will execute instead.

```
const obj = new Adapter(6) 
obj.playGame("Ross","Chandler") //`obj.playGame` will execute `newplayGame`
```

# Explanation

In the code above, we have a `TruthAndDare` class, which has a `playGame` function that decides which player's turn it is, depending on the `turn` variable. The `constructor` initializes `turn` to either `1` or `2` randomly.

The `turn` variable is accessed through the `Getturn` function. 

```
  Getturn(){
    if(this.turn == 1){
      this.turn = 2
    }else{
      this.turn = 1
    }
    return this.turn
  }
```
If the value of `turn` is `1`, the function sets it to `2` and vice versa. 

Next, we decide to update how the turns are chosen, so we create a new class, `NewTruthAndDare`. It consists of the following modifications:

* we set `turn` to some `randomValue` passed through the constructor. 

  ```
  constructor(randomValue){
    this.turn = randomValue;
  }
  ```

* Next, we define the `newplayGame` function. 

  ```
  newplayGame(playerOnename,playerTwoname)    
  {
    if((this.turn % 2) == 0){
      return `＄{playerOnename}'s turn`
    }else{
      return `＄{playerTwoname}'s turn`
    }
  }
  ```
  We access `turn` and check whether it is even. If it's even, it is player 1's turn, else, it is player 2's turn.

Finally, we make sure that the interface does not change for the players. This means they can keep calling `playGame` without knowing that the method to randomize turns has changed or the function name has changed to `newplayGame`. For this purpose, we define the `Adapter` class.

```
class Adapter {
  constructor(randomValue) {
    const newGame = new NewTruthAndDare(randomValue)

    this.playGame = function(playerOnename,playerTwoname) {
     return newGame.newplayGame(playerOnename,playerTwoname)
    };
  }
}
```

* We create an object `newGame` of the class `NewTruthAndDare`. 

* Next, we define the `playGame` function in it. In the definition, we call the `newGame.newplayGame` function. 

So now, the players can keep calling the `playGame` function as it is, but on the backend, the `newplayGame` function will execute instead.

```
const obj = new Adapter(6) 
obj.playGame("Ross","Chandler") //`obj.playGame` will execute `newplayGame`
```

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