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

# Problem statement

Study and  run the code snippet below:

class BankAccount {

    constructor(amount){
        this.amount = amount
    }

  checkAmount() {
      console.log(this.amount)
  }
  
  withdrawMoney(withdrawamount) {
    if(withdrawamount > this.amount){
        console.log("Not enough money")
    }
    else{
        this.amount -=  withdrawamount
    }
  }
   depositAmount(money){
        this.amount += money
    }
}

var account = new BankAccount(100)
account.checkAmount()
account.withdrawMoney(10)
account.checkAmount()
account.depositAmount(50)
account.checkAmount()

In the code above, you have a `BankAccount` class. You can check the `amount` in the account using the `checkAccount` function, withdraw a certain amount using the `withdrawMoney` function, and deposit an amount using the `depositAmount` function.

Your task is to modify the code above by using the *command pattern*. Remember, the pattern has the following parts:

* commands: `WithDraw`, `DepositAmount`, and `CheckAmount`

* receiver: `BankAccount`

* invoker: an `AccountManager` carrying out the operations requested using a `request` function

Use your knowledge of the pattern to divide your code into these objects.


# Input

Sending commands to carry out operations such as `withdrawMoney`, `checkAmount`, and `depositAmount`

# Output

The `amount` in the account after operations are performed

# Sample input
```
const manager = new AccountManager();
const account = new BankAccount(100)
const check = new CheckAmount(account);
manager.request(check)
const withdraw = new WithDrawAmount(account);
const deposit = new DepositAmount(account);
manager.request(withdraw,10)
manager.request(check)
manager.request(deposit,50)
manager.request(check)
```

# Sample output
```
100
90
140
```

In this challenge, you have to implement the command pattern to solve the given problem.

Before We Begin

Introduction To Design Patterns

Creational Patterns

Structural Patterns

Behavioral Patterns

Architectural Patterns

Conclusion

Challenge: Command Pattern

Problem statement