15 Popular Common Frontend Interview Questions
Tags: webdev, javascript, interview, frontend
Published: 2023-09-17 11:58:44

## Introduction
Expertise in common frontend topics and the ability to implement the necessary skills for a business is important for a Frontend developer, it sets you apart as a candidate for your dream job. This article covers 15 most common frontend interview questions in a 'question: answer' format that I encountered during Frontend Developer job interviews.

### 1. What is HTTP?
HTTP stands for **HyperText Transfer Protocol**. It is an application protocol that allows for the transfer of data. HTTP enables the retrieval of resources, such as HTML pages, images, videos, etc., from servers to browsers. It follows a client-server model, where a client (such as a web browser) sends requests to a server, and the server responds with the requested resources. HTTP uses various methods to perform different actions on resources.

[Learn more](https://developer.mozilla.org/en-US/docs/Web/HTTP/Overview)

### 2. What does an HTTP request consist of?
Each HTTP request consists of three parts, which are transmitted in the specified order:
- Starting line: defines the type of the message.
- Headers: characterize the message body, transmission parameters, and other information.
- Message body: contains the actual data of the message. It must be separated from the headers by an empty line.

### 3. What HTTP request methods do you know?
- The **GET** method requests a representation of a resource. Requests using this method can only retrieve data.
- **HEAD** requests a resource in the same way as the GET method, but without the response body.
- **POST** is used to send entities to a specific resource. It often causes a change in state or some other side effects on the server.
- **PUT** replaces all current representations of the resource with the request data.
- **DELETE** removes the specified resource.
- **CONNECT** establishes a tunnel to the server identified by the resource.
- **OPTIONS** is used to describe the communication options for the resource.
- **TRACE** performs a message loop-back test along the path to the target resource.
- **PATCH** is used for partial modification of a resource.

[Learn more](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods)

### 4. What is the semantic difference between PUT and PATCH?
PATCH updates a resource partially, for example, rewriting one field in a database, while PUT completely replaces the resource.

### 5. What are Websockets?
Websockets are a communication protocol that provides full-duplex communication channels over a single TCP connection. Unlike HTTP, which follows a request-response model. Websockets allow for real-time, bidirectional communication between a client and a server. This means that both the client and server can send data to each other at any time without the need for a new HTTP request. Websockets are commonly used in applications that require instant updates or real-time data, such as chat applications, collaborative editing tools, and live streaming services.

[Learn more](https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API)

### 6. What is REST API?
**REST API** stands for **REpresentational State Transfer Application Programming Interface**. It is a software architectural style that defines a set of rules and constraints for building web services. It is based on the principles of simplicity, scalability, and statelessness. REST APIs use standard HTTP methods to perform operations on resources identified by URLs. These APIs enable clients to interact with servers and access or modify data using a uniform interface

[Learn more](https://www.redhat.com/en/topics/api/what-is-a-rest-api)

### 7. What is WebRTC?
**WebRTC** stands for **Web Real-Time Communication**. It is a free and open-source project that enables real-time communication capabilities within browsers and applications. It provides protocols and APIs for peer-to-peer audio, video, and data sharing without the need for additional plugins or software installations. WebRTC allows users to have seamless voice and video calls, as well as share screens and transfer files directly from their web browsers. It has become popular for building applications such as video conferencing, live streaming, and real-time collaboration tools.

[Learn more](https://developer.mozilla.org/en-US/docs/Web/API/WebRTC_API)

### 8. What is Git?
**Git** is a **distributed version control system** used for tracking changes in the code. Git allows multiple developers to work on a project simultaneously, keeping track of all modifications made to the code. Git provides features like **branching**, **merging**, and **reverting changes**, making it easier to collaborate and manage codebase efficiently.
[Learn more](https://git-scm.com/book/en/v2/Getting-Started-What-is-Git%3F)

### 9. How to commit in Git?
A commit in Git is a **snapshot of the changes** made to a repository. It is a way to save and track the progress of your work.
Each commit has a unique identifier and contains information about the changes made, such as **added**, **modified**, or **deleted files**.

**To commit in Git:**
1. Make sure you are in the root directory of your Git repository.
2. Use the command `git add <file>` to stage the changes you want to commit. You can also use `git add .` to stage all changes.
3. Use the command `git commit -m "Some commit message"` to create a new commit with a descriptive message explaining the changes made.
4. You can push the commit to a remote repository using `git push origin <branch>`. This step is only necessary if you want to share your changes with others or store them remotely.

Remember to provide a meaningful commit message that accurately describes the changes made in the commit.

[Learn more](https://git-scm.com/docs/git-commit)

### 10. How to create a new branch and switch to it in Git?
Branches are used to create separate lines of development. They allow you to work on different features or versions of your project simultaneously without interfering with each other. Each branch has its own commit history and can be merged back into the main branch (usually called "master" or "main") when the changes are ready.

**To create a new branch, use the following command:**

`git branch <branch_name>`

This will create a new branch with the specified name but will not switch to it. **To switch to the newly created branch, use the following command**:

`git checkout <branch_name>`

**Alternatively, you can combine both steps into a single command using:**

`git checkout -b <branch_name>`

This command creates a new branch and switches to it in one step.

Once you have switched to a branch, any commits or changes you make will be recorded in that branch's commit history. **You can switch between branches at any time** using the `git checkout` command followed by the branch name.

**It's important to note that creating and switching to a new branch does not automatically push it to a remote repository.** If you want to share your branch with others or collaborate on it, you will need to push it using the `git push` command.
[Learn more](https://git-scm.com/book/en/v2/Git-Branching-Branches-in-a-Nutshell)

### 11. What are the differences between `git merge` and `git rebase`?
`Git merge` and `git rebase` are two different ways to integrate changes from one branch into another. 

`Git merge` **combines the changes** from one branch into another by creating a new commit that incorporates the changes from both branches. This creates a **merge commit** in the commit history, which shows that the branches were merged at a certain point in time. The merge commit preserves the entire history of both branches, making it easy to trace the changes and understand how they were integrated.

`Git rebase`, on the other hand, **moves or combines a sequence of commits** from one branch onto another. It essentially replays the commits on top of the target branch, creating a linear history **without any merge commits**. This can make the commit history cleaner and easier to follow, as it appears as if the changes were made directly on the target branch.

The main difference between `git merge` and `git rebase` is how they integrate the changes. `Git merge` **preserves the commit history of both branches and creates a merge commit**, while `git rebase` **rewrites the commit history by replaying the commits on top of the target branch.**

In summary, `git merge` is typically used for integrating branches with a shared history, while `git rebase` is used for creating a linear history and incorporating changes from one branch onto another.

[Learn more](https://git-scm.com/book/en/v2/Git-Branching-Rebasing)
[Learn more](https://git-scm.com/book/en/v2/Appendix-C:-Git-Commands-Branching-and-Merging)

### 12. On what principles is the OOP based?
Object-oriented programming (OOP) is based on four key principles:

1. **Encapsulation**: This principle involves bundling data and the methods that operate on that data into objects. It allows for data hiding, meaning that the internal state of an object is not directly accessible from outside, and only specific methods can interact with the object's data. Encapsulation helps in achieving modularity, as objects can be treated as black boxes with well-defined interfaces.

2. **Inheritance**: Inheritance allows for the creation of new classes (derived or child classes) that inherit properties and behaviors from existing classes (base or parent classes). This principle promotes code reuse and enables the creation of hierarchical relationships between classes. Derived classes can add or modify functionality while inheriting the common attributes and methods from their parent classes.

3. **Polymorphism**: Polymorphism allows objects of different classes to be treated as objects of a common base class. It enables the use of a single interface to represent multiple related objects, providing flexibility and extensibility in code design. Polymorphism is often achieved through method overriding (redefining a method in a derived class) and method overloading (having multiple methods with the same name but different parameters).

4. **Abstraction**: Abstraction focuses on representing essential features and behaviors of real-world entities in a simplified manner. It involves creating abstract classes or interfaces that define common characteristics and methods without specifying their implementation details. Abstraction allows for the creation of reusable code templates, promoting modular design and reducing code duplication.

These principles guide the design and structure of object-oriented programs, promoting code organization, maintainability, and flexibility.

[Learn more](https://www.freecodecamp.org/news/object-oriented-javascript-for-beginners/#:~:text=about%20this%20topic.-,The%20Four%20Principles%20of%20OOP,%2C%20encapsulation%2C%20abstraction%20and%20polymorphism)

### 13. What design patterns do you use most often?
1. **Model-View-Controller (MVC)**: This pattern separates the application into three interconnected components - the model (data and business logic), the view (user interface), and the controller (handles user input and updates the model and view). It promotes separation of concerns and modularity.

2. **Observer**: The observer pattern allows for one-to-many dependency relationships between objects. It defines a subject (observable) and multiple observers. When the subject's state changes, it notifies all its observers, allowing them to update accordingly. This pattern is useful for implementing event-driven architectures.

3. **Singleton**: The singleton pattern restricts the instantiation of a class to a single object. It ensures that only one instance of the class exists throughout the application and provides a global point of access to that instance. Singletons are often used for managing shared resources or maintaining global state.

4. **Factory**: The factory pattern provides an interface for creating objects, but delegates the responsibility of instantiation to subclasses or specialized factory methods. It abstracts the object creation process and allows for flexible object creation without tightly coupling the code to specific classes.

5. **Module**: The module pattern organizes code into self-contained modules, encapsulating related variables, functions, and objects. It helps in achieving modularity, reducing namespace pollution, and providing a clear structure for code organization. Modules can be implemented using IIFE (Immediately Invoked Function Expression) or modern JavaScript module systems like ES6 modules.

6. **Decorator**: The decorator pattern allows for dynamically adding additional behaviors or responsibilities to objects at runtime by wrapping them in decorator objects. It provides a flexible alternative to subclassing for extending functionality without modifying existing code.

These are just a few examples of design patterns commonly used in frontend development. The choice of design patterns depends on the specific requirements of the project and the problem being solved.
[Learn more](https://www.patterns.dev/posts)

### 14. What is `package.json` for?
The `package.json` file is a **metadata file**. It serves as a manifest for the project, containing various information such as the project name, version, dependencies, scripts, and other configurations.

**Here are some key purposes and functionalities of the package.json file:**

1. **Dependency Management**: The package.json file is used to specify the project's dependencies, including both runtime dependencies and development dependencies. These dependencies are listed under the "dependencies" and "devDependencies" fields, respectively. It allows developers to easily manage and install the required packages for their project using package managers like npm or Yarn.

2. **Versioning**: The package.json file includes the version number of the project, which helps in tracking and managing different versions of the project over time. It allows for proper version control and ensures that developers can work with specific versions of the project.

3. **Scripts**: The package.json file can define custom scripts that can be executed using the package manager. These scripts can be used for various purposes such as building the project, running tests, starting a development server, or deploying the application. They provide a convenient way to automate common development tasks.

4. **Configuration**: The package.json file can include various configuration options for the project. For example, it can specify the entry point of the application, define build configurations, set environment variables, or specify linters and code formatters.

5. **Metadata**: The package.json file contains metadata about the project, including the project name, description, author, license, repository URL, and other relevant information. This metadata helps in providing context and documentation for the project.

Overall, the package.json file is an essential part of the projects, providing important information and configurations needed for proper project setup, dependency management, and development workflow.
[Learn more](https://docs.npmjs.com/cli/v9/configuring-npm/package-json)

### 15. Tell us about the principles of SOLID.
The principles of SOLID are a set of five design principles that aim to make software more maintainable, flexible, and scalable. These principles were introduced by Robert C. Martin (also known as Uncle Bob) and are widely used in object-oriented programming. Here's an overview of each principle:

1. **Single Responsibility Principle (SRP)**: This principle states that a class should have only one reason to change. In other words, a class should have a single responsibility or purpose. By adhering to this principle, you can make your code more modular and easier to understand, test, and maintain.

2. **Open-Closed Principle (OCP)**: The OCP principle states that software entities (classes, modules, functions, etc.) should be open for extension but closed for modification. This means that you should be able to add new functionality to your code without modifying existing code. This principle promotes the use of abstraction, inheritance, and interfaces to achieve flexibility and avoid breaking existing code.

3. **Liskov Substitution Principle (LSP)**: The LSP principle states that objects of a superclass should be replaceable with objects of its subclasses without affecting the correctness of the program. In simpler terms, this means that any derived class should be able to be used in place of its base class without causing unexpected behavior. Adhering to this principle helps ensure that your code is designed with proper inheritance and polymorphism.

4. **Interface Segregation Principle (ISP)**: The ISP principle states that clients should not be forced to depend on interfaces they do not use. It promotes the idea of having smaller and more specific interfaces rather than large and general ones. By following this principle, you can avoid unnecessary dependencies and make your code more modular and cohesive.

5. **Dependency Inversion Principle (DIP)**: The DIP principle states that high-level modules should not depend on low-level modules; both should depend on abstractions. It also states that abstractions should not depend on details; details should depend on abstractions. This principle encourages the use of interfaces or abstract classes to decouple modules and promote loose coupling and easier testing.

By following these SOLID principles, you can create code that is easier to understand, maintain, and extend. These principles help in achieving code that is more robust, flexible, and scalable, making it easier to adapt to changing requirements and reducing the chances of introducing bugs.

## Conclusion
Preparing for these common questions, studying the topics covered, and reviewing relevant resources can improve your chances of successfully passing the interview. This post is the third part of a series of post on interview questions.

I look forward to your reactions and comments.
Good luck in your interview!