Frontend Developer Interview Questions and Answers

Ques 7. Explain the purpose of the 'rem' unit in CSS and how it differs from 'em'.

'rem' (root em) is relative to the font-size of the root element, while 'em' is relative to the font-size of the nearest parent element with a font-size. 'rem' is not affected by the parent element's font-size.

Example:

```css
html {
  font-size: 16px;
}

body {
  font-size: 1.5rem; /* 24px */
}
```

Ques 8. Explain the difference between 'cookie', 'sessionStorage', and 'localStorage'.

'cookie' is a small piece of data stored on the client's computer, 'sessionStorage' stores data for the duration of a page session, and 'localStorage' persists data even after the browser is closed.

Ques 9. Explain the concept of 'event bubbling' in JavaScript.

'Event bubbling' is the process where the event starts from the target element and bubbles up the DOM hierarchy until it reaches the root. It allows for delegating event handling to a common ancestor.

Ques 10. What is the purpose of the 'transition' property in CSS?

The 'transition' property in CSS is used to create smooth transitions between property values over a specified duration. It is commonly used for animations and effects.

Example:

```css
/* Example of using transition */
.element {
  transition: width 0.5s ease-in-out;
}
```

Ques 11. What is the role of the 'viewport' meta tag in HTML?

The 'viewport' meta tag in HTML is used to control the layout viewport of the browser, ensuring that the webpage is displayed correctly on various devices by setting the initial scale, width, and zoom level.

Example:

```html

```

Ques 12. What is the difference between `let`, `const`, and `var` in JavaScript?

The main difference lies in their scoping and hoisting behavior. `let` has block scope, `const` is used for constants, and `var` has function scope and is hoisted.

Example:

```javascript
// Example using let
let x = 10;

// Example using const
const PI = 3.14;

// Example using var
var y = 5;
```

Ques 13. Explain the box model in CSS.

The box model consists of content, padding, border, and margin. It defines how these components contribute to the overall size of an element.

Example:

```css
.box {
  width: 200px;
  padding: 20px;
  border: 2px solid #000;
  margin: 10px;
}```

Ques 14. Explain the difference between `==` and `===` in JavaScript.

`==` is the equality operator that performs type coercion, while `===` is the strict equality operator that checks both value and type without coercion.

Example:

```javascript
console.log(5 == '5'); // true
console.log(5 === '5'); // false
```

Ques 15. What is the purpose of the 'async' and 'defer' attributes in a script tag?

'async' loads the script asynchronously, allowing it to execute while the page continues parsing. 'defer' loads the script asynchronously but ensures it executes in order after HTML parsing.

Example:

```html


```

Ques 16. Explain the concept of CORS (Cross-Origin Resource Sharing) and how to handle it in JavaScript.

CORS is a security feature implemented by web browsers to restrict web pages from making requests to a different domain than the one that served the web page. In JavaScript, you can handle CORS by setting appropriate headers on the server or using JSONP for cross-origin requests.

Example:

```javascript
// Example using Fetch API with CORS
fetch('https://api.example.com/data', { mode: 'cors' })
  .then(response => response.json())
  .then(data => console.log(data));
```

Ques 17. How does the 'this' keyword work in JavaScript?

The 'this' keyword refers to the current execution context. In a function, 'this' depends on how the function is called. It can refer to the global object, the object the method is called on, or be explicitly set using methods like 'call', 'apply', or 'bind'.

Example:

```javascript
function sayHello() {
  console.log('Hello, ' + this.name);
}

const person = { name: 'John' };
sayHello.call(person); // Outputs: Hello, John
```

Ques 18. Explain the purpose of the 'box-sizing' property in CSS.

The 'box-sizing' property determines how the total width and height of an element are calculated. 'content-box' includes only the content, while 'border-box' includes padding and border in the calculation.

Example:

```css
/* Using box-sizing: border-box */
div {
  box-sizing: border-box;
  width: 200px;
  padding: 10px;
  border: 5px solid #000;
}```

Ques 19. What is the difference between 'throttling' and 'debouncing' in JavaScript?

'Throttling' limits the number of times a function can be called within a specified time frame, while 'debouncing' ensures that a function is only called after a certain amount of time has passed since the last invocation.

Ques 20. What is the purpose of the 'requestAnimationFrame' function in JavaScript?

'requestAnimationFrame' is a method that tells the browser that you wish to perform an animation and requests that the browser call a specified function to update an animation before the next repaint.

Example:

```javascript
function animate() {
  // Animation logic goes here
  requestAnimationFrame(animate);
}

// Start the animation
animate();
```

Ques 21. What is the purpose of the 'pointer-events' property in CSS?

The 'pointer-events' property controls under what circumstances an element can become the target of pointer events. It is used to make elements non-interactive or to allow pointer events to pass through an element.

Example:

```css
/* Make the element non-interactive */
.non-interactive {
  pointer-events: none;
}```

Ques 22. What is the purpose of the 'webpack' module bundler in frontend development?

'Webpack' is a module bundler that takes assets, such as JavaScript, CSS, and images, and transforms them into a format that can be efficiently served to the browser. It also enables code splitting and other optimizations.

Ques 23. Explain the concept of 'polyfill' in web development.

A 'polyfill' is a piece of code (usually JavaScript) that provides modern functionality on older browsers that do not support that feature. It 'fills in' the gaps to ensure compatibility.

Ques 24. Explain the concept of 'hoisting' in JavaScript.

'Hoisting' is a JavaScript behavior where variable and function declarations are moved to the top of their containing scope during the compilation phase. However, only the declarations are hoisted, not the initializations.

Example:

```javascript
console.log(x); // Outputs: undefined
var x = 5;
```

Ques 25. Explain the concept of closures in JavaScript.

Closures allow a function to access variables from its outer (enclosing) scope even after the outer function has finished executing. They help in creating private variables and methods.

Example:

```javascript
function outer() {
  let x = 10;
  function inner() {
    console.log(x);
  }
  return inner;
}

const closureExample = outer();
closureExample(); // Outputs 10
```

Ques 26. How does CSS specificity work?

Specificity is a set of rules that determines which style declarations are applied to an element. It is based on the importance, specificity, and source order of CSS rules.

Example:

```css
#id-selector {
  color: red; /* higher specificity */
}

.class-selector {
  color: blue;
}
```

Ques 27. Explain the concept of event delegation in JavaScript.

Event delegation involves attaching a single event listener to a common ancestor rather than individual elements. It leverages event bubbling to handle events on multiple child elements.

Example:

```javascript
// HTML: 
Item 1
Item 2

const list = document.getElementById('myList');
list.addEventListener('click', function(event) {
  if (event.target.tagName === 'LI') {
    console.log('Clicked on:', event.target.textContent);
  }
});
```

Ques 28. What is the Virtual DOM, and how does it improve performance in frameworks like React?

The Virtual DOM is a lightweight copy of the actual DOM. React uses it to optimize updates by comparing the virtual DOM with the real DOM and making minimal changes. This reduces the number of manipulations needed on the actual DOM, improving performance.

Ques 29. What is a closure in the context of JavaScript's event handling?

In the context of event handling, a closure allows a function to retain access to variables in its lexical scope even after the outer function has finished executing. This is often used to maintain state across multiple event callbacks.

Example:

```javascript
function createCounter() {
  let count = 0;
  return function() {
    console.log(count++);
  };
}

const counter = createCounter();
counter(); // Outputs: 0
counter(); // Outputs: 1
```

Ques 30. Explain the 'callback hell' phenomenon in JavaScript and how to mitigate it.

'Callback hell' occurs when multiple nested callbacks make the code hard to read and maintain. Mitigate it by using named functions, promises, or async/await syntax to improve code readability and maintainability.