

This is part 2 of the Interview series. See also [Part 1: CSS, HTML & Accessibility](/blog/interview-questions-part-1) and [Part 3: React](/blog/interview-questions-react).

## Core JavaScript Concepts

###accordion: What is an IIFE and why are they used?

An IIFE (Immediately Invoked Function Expression) is a function that runs as soon as it's defined:

```javascript
// Traditional IIFE
(function() {
  console.log("This runs immediately!");
})();

// Arrow function IIFE
(() => {
  console.log("Arrow IIFE too!");
})();

// With parameters
((name) => {
  console.log(`Hello, ${name}!`);
})("World");
```

**Why use IIFEs?**
- Create private scope and avoid polluting global namespace
- Execute initialization code immediately
- Module pattern implementation
- Async IIFEs for top-level await in older environments

###accordion: What is Closure?

A closure is a function that has access to variables in its outer (enclosing) scope even after the outer function has returned:

```javascript
function createCounter() {
  let count = 0; // This variable is "closed over"
  
  return function() {
    count++; // Still has access to count
    return count;
  };
}

const counter = createCounter();
console.log(counter()); // 1
console.log(counter()); // 2
console.log(counter()); // 3

// Practical example: private variables
function createBankAccount(initialBalance) {
  let balance = initialBalance;
  
  return {
    deposit: (amount) => {
      balance += amount;
      return balance;
    },
    withdraw: (amount) => {
      if (amount <= balance) {
        balance -= amount;
        return balance;
      }
      return "Insufficient funds";
    },
    getBalance: () => balance
  };
}
```

###accordion: Difference between var and let

**Scope:**
- `var` - Function scoped
- `let` - Block scoped (curly braces)

**Hoisting:**
- `var` - Hoisted with undefined initial value
- `let` - Hoisted but not initialized (TDZ)

**Re-declaration:**
- `var` - Can be re-declared
- `let` - Cannot be re-declared in same scope

```javascript
function testVar() {
  if (true) {
    var x = 1;
  }
  console.log(x); // 1 (function scoped)
}

function testLet() {
  if (true) {
    let y = 1;
  }
  console.log(y); // ReferenceError (block scoped)
}
```

###accordion: Difference between map, filter and reduce

**map:** Transforms each element, returns new array of same length

```javascript
const numbers = [1, 2, 3, 4];
const doubled = numbers.map(x => x * 2); // [2, 4, 6, 8]
```

**filter:** Returns elements that pass a condition

```javascript
const numbers = [1, 2, 3, 4, 5, 6];
const evens = numbers.filter(x => x % 2 === 0); // [2, 4, 6]
```

**reduce:** Reduces array to single value

```javascript
const numbers = [1, 2, 3, 4];
const sum = numbers.reduce((acc, x) => acc + x, 0); // 10

// Group by category
const people = [
  { name: 'Alice', age: 25, department: 'Engineering' },
  { name: 'Bob', age: 30, department: 'Engineering' },
  { name: 'Charlie', age: 35, department: 'Sales' }
];

const byDepartment = people.reduce((acc, person) => {
  const dept = person.department;
  if (!acc[dept]) acc[dept] = [];
  acc[dept].push(person);
  return acc;
}, {});
```

## Asynchronous JavaScript

###accordion: What are Promises?

A Promise represents the eventual completion (or failure) of an asynchronous operation:

```javascript
// Creating a promise
const fetchData = () => {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      const success = true;
      if (success) {
        resolve({ data: "Some data", timestamp: Date.now() });
      } else {
        reject(new Error("Failed to fetch data"));
      }
    }, 1000);
  });
};

// Using promises
fetchData()
  .then(result => {
    console.log("Success:", result);
    return result.data;
  })
  .then(data => {
    console.log("Processed:", data);
  })
  .catch(error => {
    console.error("Error:", error.message);
  })
  .finally(() => {
    console.log("Cleanup");
  });

// Promise methods
Promise.all([fetchData(), fetchData()])
  .then(results => console.log("All done", results));

Promise.race([fetchData(), timeout(500)])
  .then(result => console.log("First completed", result));
```

###accordion: Async/Await

Syntactic sugar for working with promises:

```javascript
// Async function
async function fetchUserData(userId) {
  try {
    const response = await fetch(`/api/users/${userId}`);
    const user = await response.json();
    
    const posts = await fetch(`/api/users/${userId}/posts`);
    const userPosts = await posts.json();
    
    return { user, posts: userPosts };
  } catch (error) {
    console.error("Failed to fetch user data:", error);
    throw error;
  }
}

// Using async/await
const userData = await fetchUserData(123);

// Parallel execution with Promise.all
async function fetchMultipleUsers(userIds) {
  const promises = userIds.map(id => fetchUserData(id));
  const results = await Promise.all(promises);
  return results;
}

// Error handling
async function example() {
  try {
    await riskyOperation();
  } catch (error) {
    // Handle error
  } finally {
    // Always runs
  }
}
```

## JavaScript Fundamentals

###accordion: What's the difference between null, undefined or undeclared?

**undefined:** Variable declared but not assigned

```javascript
let x;
console.log(x); // undefined
console.log(typeof x); // "undefined"
```

**null:** Explicit absence of value

```javascript
let y = null;
console.log(y); // null
console.log(typeof y); // "object" (JavaScript bug)
```

**undeclared:** Variable never declared

```javascript
console.log(z); // ReferenceError: z is not defined
```

**Best practices:**
- Use `undefined` for "no value yet"
- Use `null` for "intentionally empty"
- Always declare variables to avoid undeclared errors

###accordion: What is the 'this' keyword and how is it used?

`this` refers to the execution context:

```javascript
// Global context
console.log(this); // Window object (in browser)

// Function context
function showThis() {
  console.log(this);
}
showThis(); // Window (non-strict) or undefined (strict)

// Method context
const obj = {
  name: "Object",
  showThis() {
    console.log(this.name); // "Object"
  }
};

// Constructor context
function Person(name) {
  this.name = name; // Refers to new instance
}

// Arrow function context
const arrowObj = {
  name: "Object",
  showThis: () => {
    console.log(this.name); // undefined (inherits from outer scope)
  }
};

// Explicit binding
const person = { name: "John" };
function greet() {
  console.log(`Hello, ${this.name}!`);
}
greet.call(person); // "Hello, John!"
greet.apply(person); // "Hello, John!"
const boundGreet = greet.bind(person);
boundGreet(); // "Hello, John!"
```

## Coding Challenges

###accordion: Write function that checks if the number is prime

```javascript
function isPrime(n) {
  // Handle edge cases
  if (n <= 1) return false;
  if (n <= 3) return true;
  if (n % 2 === 0 || n % 3 === 0) return false;
  
  // Check divisors up to sqrt(n)
  for (let i = 5; i * i <= n; i += 6) {
    if (n % i === 0 || n % (i + 2) === 0) {
      return false;
    }
  }
  
  return true;
}

// Test cases
console.log(isPrime(2));   // true
console.log(isPrime(17));  // true
console.log(isPrime(25));  // false
console.log(isPrime(97));  // true

// Optimized version with memoization
const isPrimeMemo = (() => {
  const cache = new Map();
  
  return (n) => {
    if (cache.has(n)) return cache.get(n);
    
    let result;
    if (n <= 1) result = false;
    else if (n <= 3) result = true;
    else if (n % 2 === 0 || n % 3 === 0) result = false;
    else {
      result = true;
      for (let i = 5; i * i <= n; i += 6) {
        if (n % i === 0 || n % (i + 2) === 0) {
          result = false;
          break;
        }
      }
    }
    
    cache.set(n, result);
    return result;
  };
})();
```

###accordion: FizzBuzz

```javascript
// Classic FizzBuzz solution
function fizzBuzz(n) {
  const result = [];
  
  for (let i = 1; i <= n; i++) {
    if (i % 15 === 0) {
      result.push("FizzBuzz");
    } else if (i % 3 === 0) {
      result.push("Fizz");
    } else if (i % 5 === 0) {
      result.push("Buzz");
    } else {
      result.push(i.toString());
    }
  }
  
  return result;
}

// Functional approach
const fizzBuzzFunctional = (n) => 
  Array.from({ length: n }, (_, i) => i + 1)
    .map(num => {
      const fizz = num % 3 === 0 ? "Fizz" : "";
      const buzz = num % 5 === 0 ? "Buzz" : "";
      return fizz + buzz || num.toString();
    });

// One-liner (for interviews)
const fizzBuzzOneLiner = (n) => 
  [...Array(n).keys()].map(i => {
    i++;
    return (i % 15 ? i % 3 ? i % 5 ? i : "Buzz" : "Fizz" : "FizzBuzz");
  });

// Test
console.log(fizzBuzz(15));
// ["1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8", "Fizz", "Buzz", "11", "Fizz", "13", "14", "FizzBuzz"]
```

## Additional JavaScript Topics

### List ES6 features

- Arrow functions
- Template literals
- Destructuring assignment
- Default parameters
- Rest and spread operators
- Let and const
- Classes
- Modules (import/export)
- Promises
- Symbol type
- Iterators and generators
- Map and Set data structures

### List JavaScript data types

**Primitive types:**
- Number
- String
- Boolean
- Undefined
- Null
- Symbol (ES6)
- BigInt (ES2020)

**Reference types:**
- Object
- Array
- Function
- Date
- RegExp
- Map, Set, WeakMap, WeakSet

### How JavaScript's runtime works? Describe an event loop mechanism

JavaScript runs on a single-threaded event loop:

1. **Call Stack:** Executes synchronous code
2. **Heap:** Memory allocation for objects
3. **Web APIs:** Browser APIs for async operations
4. **Callback Queue:** Queues callbacks from async operations
5. **Event Loop:** Moves callbacks from queue to stack when stack is empty

**How many threads does JavaScript have?**
- **Main thread:** 1 (single-threaded)
- **Web Workers:** Multiple additional threads for background processing

### What are Web Workers?

Web Workers allow running JavaScript in background threads:

```javascript
// main.js
const worker = new Worker('worker.js');
worker.postMessage('Hello from main');
worker.onmessage = function(e) {
  console.log('Message from worker:', e.data);
};

// worker.js
self.onmessage = function(e) {
  console.log('Message from main:', e.data);
  self.postMessage('Hello from worker');
};
```

**Benefits:**
- Run heavy computations without blocking UI
- True parallel processing
- Separate memory space

**Limitations:**
- No direct DOM access
- Limited access to Web APIs
- Communication via message passing

## Summary

This is part 2 of the Interview series. Continue with [Part 1: CSS, HTML & Accessibility](/blog/interview-questions-part-1) and [Part 3: React](/blog/interview-questions-react). You may also find [Popular Acronyms](/blog/popular-acronyms) useful for interview preparation.
## Revers string

## Useful link and resources

You may also find [Popular Acronyms](/blog/popular-acronyms) helpful — knowing YAGNI, KISS, DRY and SOLID comes up in interviews too.


Interview questions part 2: JavaScript


# Popular Acronyms

## Welcome to my third post.

I must admit that I start to enjoy writing more than ever before and I hope I'll keep momentum.

This time I'd like to focus on acronyms that are commonly used in software engineering. Most likely you already develop using some of the principles that are represented here without even being aware of it.

There are quite a few acronyms commonly used in software methodologies. Some less serious than others (eg. HDD - Hype Driven Development) but in this article, I'd like to focus only on the following 4:

```
HDD
```

Y.A.G.N.I., K.I.S.S., D.R.Y., & S.O.L.I.D. Knowing those will help you not only write better code but also during the [interview process](/blog/interview-questions-part-1) where you might be asked to decode either the entire shortening or particular letter.

Do not confuse acronyms with abbreviations as some sites/articles do as those two are quite distinct.
- Abbreviation form new words eg Dr for Doctor
- acronym typically contains a set of initial letters eg. ASAP As Soon As Possible

```
Dr
```


```
ASAP
```

## Y.A.G.N.I - You Ain't Gonna Need It

YAGNI is a principle of Extreme Programming (XP) that sets that a programmer should not add functionality until deemed necessary. In my view, this principle should go before the K.I.S.S principle where you should think twice if you really going to need certain functionality if yes keep it simple.

## K.I.S.S - Keep it Simple, Stupid

## D.R.Y - Don't Repeat Yourself

## S.O.L.I.D

## Useful resources:


#programming

Interview questions part 2: JavaScript

Popular Acronyms