Question 1

How do you handle errors in JavaScript? Explain try/catch/finally and how to handle async errors.

Accepted Answer

## Basic Error Handling: try/catch/finally

```javascript
try {
  // Code that might throw an error
  const result = riskyOperation();
  console.log(result);
} catch (error) {
  // Handle the error
  console.error("Something went wrong:", error.message);
} finally {
  // Always runs, regardless of error
  cleanup();
}
```

### The Error Object

```javascript
try {
  throw new Error("Something failed");
} catch (error) {
  console.log(error.name);     // "Error"
  console.log(error.message);  // "Something failed"
  console.log(error.stack);    // Stack trace
}
```

Question 2

Explain the 'this' keyword in JavaScript. How does its value change in different contexts?

Accepted Answer

## Overview

The `this` keyword refers to the object that is executing the current function. Its value depends on **how** the function is called, not where it's defined.

## Different Contexts

### 1. Global Context
```javascript
console.log(this);  // window (browser) or global (Node.js)
```

### 2. Object Method
```javascript
const user = {
  name: "Alice",
  greet() {
    console.log(this.name);  // "Alice" - this = user object
  }
};
user.greet();
```

### 3. Regular Function (standalone)
```javascript
function showThis() {
  console.log(this);  // window (non-st

Question 3

What is the Virtual DOM? How does React use it to improve performance?

Accepted Answer

## What is the Virtual DOM?

The Virtual DOM is a **lightweight JavaScript representation** of the actual DOM. It's a programming concept where a virtual representation of the UI is kept in memory and synced with the real DOM.

```javascript
// Virtual DOM representation (simplified)
{
  type: 'div',
  props: { className: 'container' },
  children: [
    { type: 'h1', props: {}, children: ['Hello'] },
    { type: 'p', props: {}, children: ['World'] }
  ]
}
```

## How React Uses It

**1. Initial Render**
- React creates a Virtual DOM tree
- Converts it to real DOM and displ

Question 4

What are the different ways to implement conditional rendering in React?

Accepted Answer

## 1. If/Else with Early Return Best for rendering completely different components: ```javascript function Greeting({ isLoggedIn }) { if (isLoggedIn) { return ; } return ; } ``` ## 2. Ternary Operator Best for inline conditions with two outcomes: ```javascript function Greeting({ isLoggedIn }) { return (

{isLoggedIn ? : }

); } ``` ## 3. Logical AND (&&) Best when you only want to render something or nothing: ```javascript function Notifications({ count }

Question 5

What are the main security concerns when building a Node.js/Express API? How do you protect against common vulnerabilities?

Accepted Answer

## Main Security Concerns

1. **Injection attacks** (SQL, NoSQL, Command)
2. **Cross-Site Scripting (XSS)**
3. **Broken authentication**
4. **Sensitive data exposure**
5. **Security misconfiguration**

## 1. Use Helmet for HTTP Headers

```javascript
const helmet = require('helmet');

app.use(helmet()); // Sets various HTTP headers

// Helmet includes:
// - X-Content-Type-Options: nosniff
// - X-Frame-Options: DENY
// - X-XSS-Protection: 1; mode=block
// - Strict-Transport-Security
// - And more...
```

## 2. Input Validation & Sanitization

**Never trust user input!**

Question 6

What is Node.js? How does it differ from JavaScript running in a browser?

Accepted Answer

## What is Node.js?

Node.js is an **open-source, cross-platform JavaScript runtime environment** that allows you to run JavaScript code outside of a web browser. It's built on Chrome's V8 JavaScript engine, written in C++.

```javascript
// You can run this in Node.js (not in browser)
const fs = require('fs');
const data = fs.readFileSync('file.txt', 'utf8');
console.log(data);
```

## Key Characteristics

**1. Server-Side JavaScript**
- Run JavaScript on the server
- Build APIs, web servers, CLI tools
- Access file system, network, databases

**2. Non-Blocking I/O**
- Hand

Question 7

What are ACID properties in databases? Why are they important for transactions?

Accepted Answer

## What is ACID?

ACID is a set of properties that guarantee **reliable database transactions**. It's essential for maintaining data integrity, especially in systems like banking, e-commerce, and inventory management.

## The Four Properties

### Atomicity - "All or Nothing"

A transaction is treated as a single unit. Either **all operations complete** or **none do**.

```sql
-- Bank transfer: must complete both or neither
BEGIN TRANSACTION;
  UPDATE accounts SET balance = balance - 100 WHERE id = 1;  -- Debit
  UPDATE accounts SET balance = balance + 100 WHERE id = 2;  -- Credit

Question 8

What are database constraints? Explain the different types and when to use them.

Accepted Answer

## What are Constraints?

Constraints are **rules that enforce data integrity** at the database level. They ensure that data in your tables meets specific criteria.

## Types of Constraints

### 1. PRIMARY KEY

Uniquely identifies each row. Combines UNIQUE + NOT NULL.

```sql
CREATE TABLE users (
  id SERIAL PRIMARY KEY,
  email VARCHAR(255)
);

-- Or composite primary key
CREATE TABLE enrollments (
  student_id INT,
  course_id INT,
  PRIMARY KEY (student_id, course_id)
);
```

### 2. FOREIGN KEY

Enforces referential integrity between tables.

```sql
CREATE TABLE

Question 9

What is mocking in testing? How do you mock functions, modules, and API calls in Jest?

Accepted Answer

## What is Mocking?

Mocking is **replacing real implementations with controlled fake versions** to:
- Isolate the code under test
- Control external dependencies
- Make tests faster and deterministic
- Avoid side effects (API calls, database writes)

## Mock Functions (jest.fn)

```javascript
// Create a mock function
const mockCallback = jest.fn();

// Use it
[1, 2, 3].forEach(mockCallback);

// Assert how it was called
expect(mockCallback).toHaveBeenCalledTimes(3);
expect(mockCallback).toHaveBeenCalledWith(1, 0, [1, 2, 3]);
expect(mockCallback).toHaveBeenLastCalledWith(3

Question 10

What are the different types of software testing? Explain the difference between unit, integration, and end-to-end tests.

Accepted Answer

## Types of Software Testing

### Unit Testing

Tests **individual functions or components in isolation**. The smallest testable parts of an application.

```javascript
// Function to test
function add(a, b) {
  return a + b;
}

// Unit test
test('add returns sum of two numbers', () => {
  expect(add(2, 3)).toBe(5);
  expect(add(-1, 1)).toBe(0);
});
```

**Characteristics:**
- Fast execution (milliseconds)
- Tests one thing at a time
- Dependencies are mocked
- Catches bugs early

### Integration Testing

Tests how **multiple components work together**. Verifies that

Full-Stack Developer

Topics

JavaScript/TypeScript Fundamentals

React/Vue/Angular

Node.js/Express

Database Design

Testing & QA

Mock Interview

Quick Stats