The problem is that in JavaScript, 0 is a falsy value. The condition !favoriteNumber will be true for any falsy value—including '', 0, null, undefined, and false. So when you call createUser with 0 as the favoriteNumber, the function returns early because !favoriteNumber is true, even though 0 should be a valid value.

To fix this, you should check specifically for undefined, or null:

function createUser(name, favoriteNumber) {
  if (name == null || favoriteNumber == null) return

  return {
    id: Math.random(),
    name,
    favoriteNumber,
  }
}

The easiest way would be to define default function parameters:

function printUser(user, { showName = false, showAge = false } = {}) {
  if (showName) {
    console.log(user.name)
  }
  if (showAge) {
    console.log(user.age)
  }
}

Another option would be using ||= to default values. This isn’t as ideal as it is more code and overwrites the original options object passed in.

function printUser(user, options) {
  options ||= {}
  options.showName ||= false
  options.showAge ||= false

  if (options.showName) {
    console.log(user.name)
  }
  if (options.showAge) {
    console.log(user.age)
  }
}

??= is a newer alternative that is ideal for null based values since it will only overwrite the value if it is null or undefined while || will overwrite any falsy value.

function printUser(user, options) {
  options ??= {}
  options.showName ??= false
  options.showAge ??= false

  if (options.showName) {
    console.log(user.name)
  }
  if (options.showAge) {
    console.log(user.age)
  }
}

?. is the optional chaining operator, which allows you to safely access deeply nested properties without having to check each level for existence. If any part of the chain is null or undefined, the expression short-circuits and returns undefined instead of throwing an error.

function printUser(user, options) {
  if (options?.showName) {
    console.log(user.name)
  }
  if (options?.showAge) {
    console.log(user.age)
  }
}

There are other ways to handle this, but these are the most common. Understanding the differences as well as when to use each is very important.

The original users array’s first object is being mutated as part of calling userAgeCheck which is not ideal. This happens because arrays and objects in JavaScript are reference types. The userAgeCheck function mutates the original user object by adding a new property, so both users[0] and isAdultUser point to the same object in memory. Any changes to one affect the other.

To avoid mutating the original object, you can create a shallow copy of the user object before adding the new property:

function userAgeCheck(user) {
  return { ...user, isAdult: user.age > 18 }
}

The main problem with this code is each request is ran in sequence, but they do not depend on each other. This means the total time taken is the sum of all three requests, which can lead to a poor user experience.

We can improve this by running the requests in parallel which means they will only take as long as the longest request to execute.

async function subscribeToUpdates(userId, abortSignal) {
  const fetchOptions = { signal: abortSignal }
  try {
    const [subscriptionRes, preferencesRes, notificationsRes] =
      await Promise.all([
        fetch(`/api/subscribe/${userId}`, { method: "POST", ...fetchOptions }),
        fetch(`/api/users/${userId}/preferences`, fetchOptions),
        fetch(`/api/notifications/${userId}`, fetchOptions),
      ])
    // ...
  } catch (error) {
    if (error.name === "AbortError") return
    throw error
  }
}
// Usage:
const controller = new AbortController()
subscribeToUpdates(userId, controller.signal)
// Cancel if needed:
controller.abort()

Here is a standard debounce implementation:

function debounce(func, delay) {
  let timeoutId
  return (...args) => {
    clearTimeout(timeoutId)
    timeoutId = setTimeout(func.bind(this, ...args), delay)
  }
}

How it works:

• Each time the debounced function is called, it resets the timer.
• Only after the delay passes with no new calls does the original function run.

Common mistakes:

• Not clearing the timeout, so the function runs multiple times.
• Not handling the this context correctly if used as a method.

You can use a Map to cache promises or results by id:

function memoizeAsync(fn) {
  const cache = new Map()

  return async function (id) {
    if (cache.has(id)) return cache.get(id)

    const promise = await fn(id)
    cache.set(id, promise)

    try {
      const result = await promise
      cache.set(id, result)
      return result
    } catch (e) {
      cache.delete(id)
      throw e
    }
  }
}
const getProductMemo = memoizeAsync(getProduct)

The reason we cache the promise is so that even if the function is called multiple times before the first promise resolves, it will return the same promise. This prevents unnecessary duplicate requests and ensures that all calls receive the same result.

Cache invalidation can be handled by:

• Time-based expiration (TTL)
• Manual cache clearing
• Event-based (e.g., when product data changes)

You can use a virtual DOM approach: build a virtual representation of the UI, diff it with the previous state, and only update changed elements in the real DOM. This reduces unnecessary DOM operations and improves responsiveness.

Example (simplified):

// Pseudocode for a virtual DOM diff
function renderVirtualChart(data, prevVdom) {
  const newVdom = data.map(item => ({
    key: item.id,
    value: item.value,
    label: item.label,
  }))
  // ...diff newVdom with prevVdom and update only changed nodes
}

Libraries like React, Vue, and others use this approach for efficient UI updates.

This code is vulnerable to race conditions: if two users (or even one user with a slow network) send updates in quick succession, the last response to return will overwrite previous changes, even if it was sent earlier. This can cause lost updates and inconsistent state.

To fix this, you can:

• Use version numbers or timestamps to track changes and prevent overwrites
• Implement server-side conflict resolution
• Batch or debounce updates on the client

A common memory leak occurs when you keep references to objects (like sockets) after they are no longer needed. For example:

const connections = new Set()

server.on("connection", socket => {
  connections.add(socket)
})

In this code, every socket is added to the connections set but never removed when the connection closes. This causes the set to grow indefinitely, leaking memory.

To fix this remove sockets from the set on ‘close’

socket.on("close", () => {
  connections.delete(socket)
})