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

# Explanation

To make the problem easier to understand, let’s start by converting it to a diagram.

If you follow the diagram and the code, you'll see that there is an abstract `Loans` constructor function. Its purpose is to instantiate an instance of a specific loan constructor, depending on the parameters given. 

From the diagram above, you can see that three types of loan objects can be instantiated:

* `PersonalLoan`

* `StudentLoan`

* `HomeLoan`

These loans, in turn, have different types available. In our coding challenge, we do not go into these subcategories. However, knowing this will help you visualize the overall picture.


Coming back to our code. Let's start by understanding how `Loans` is following an abstract pattern.

* Inside the `Loan` function, we first define the `getloan` method.
  ```
  function Loans(){
   this.getloan = function(type,amount,duration){
       //code
   }
  }
  ```
  As you can see, it accepts the parameters `type`, `amount`, and `duration`. 

* Next, it defines the variable `loan`, which will store an instance of a specific loan at a given time.
  ```
  var loan;
  ```

* Depending on the `type` of loan required, the `getloan` function instantiates an instance of that loan. For example, if `type` equals `home` it instantiates `HomeLoan` instance. 

   ```
   loan = new HomeLoan(amount,duration)
   ```
  The same goes for the `student` and `personal` type of loans.

* In the end, the `getloan` function returns the specific `loan` instance.

Now, let's look at how the instance for a specific type of loan is created. As we discussed, we have three types and the constructor for each is declared as follows:

```
function HomeLoan(amount,duration){
  //code..
}

function StudentLoan(amount,duration){
   //code..
}

function PersonalLoan(amount,duration){
   //code..
}
```

As mentioned in the question, all three contain the properties `amount`, `interest`, and `duration`. These properties are initialized in the body of the constructor.

```
function HomeLoan(amount,duration){
  this.amount = amount
  this.interest = 0.08
  this.duration = duration
}

function StudentLoan(amount,duration){
   this.amount = amount
   this.interest = 0.03
   this.duration = duration
}

function PersonalLoan(amount,duration){
   this.amount = amount
   this.interest = 0.05
   this.duration = duration
}
```

Since the `interest` parameter is fixed for each loan, we set its value to the specified number in the constructor.

Finally, we define the `calculateInterest` method in the constructor of each loan like so:

```
this.calculateInterest = function(){
    return this.amount*this.interest*this.duration
}
```

Using the formula provided in the question, it multiplies the `amount`, the `interest`, and the `duration` of the current `loan` instance to calculate the final interest amount. 

Now that the abstract pattern has been implemented, all you have to do to create an instance of a loan is:


```
var loan = new Loans()
var homeLoan = loan.getloan('home',3200,5)
```


After creating an instance of `Loans`, invoke the `getloan` method on it with the parameter that specifies the type of loan you want. This method will take care of the rest and create the required loan. You won’t need to use the `new` operator to create different types of loans.


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