What's the difference between return and console.log?

console.log prints to the console (for debugging). return sends a value back to the code that called the function. The caller can store and use the returned value; console.log just displays it.

Can I have multiple return statements?

Yes! But only one will execute per function call. Use multiple returns for different conditions (early returns, branching logic). Once any return executes, the function exits immediately.

Why does my function return undefined?

Three common causes: 1) No return statement at all. 2) return; with no value. 3) A newline after 'return' — JavaScript inserts a semicolon: return\\n{} becomes return;\\n{}. Put the value on the same line or use parentheses.

Should every function have a return value?

No. Functions that perform actions (logging, DOM updates, sending requests) often don't need to return anything. Functions that compute/transform data should return the result.

JavaScript Return Values

Get results back from functions. The output of computation.

Return Basics

return sends a value back to the caller and stops execution.

function multiply(a, b) {
  return a * b; // sends result back
  // code after return NEVER runs
}

let result = multiply(4, 5);
console.log(result); // 20

Key rules:

• return immediately exits the function
• Code after return is unreachable
• A function without return gives undefined
• return; with no value also gives undefined

function noReturn() {
  console.log("hello");
  // no return statement
}

let x = noReturn();
console.log(x);

Visualize

→ "hello" undefined

Early Return

Exit early to avoid deep nesting. A clean code pattern.

Deeply nested

function process(user) {
  if (user) {
    if (user.active) {
      if (user.verified) {
        return doWork(user);
      }
    }
  }
  return null;
}

Early return

function process(user) {
  if (!user) return null;
  if (!user.active) return null;
  if (!user.verified) return null;

  return doWork(user);
}

// Guard clauses — check invalid cases first:
function divide(a, b) {
  if (b === 0) return "Cannot divide by zero";
  return a / b;
}

function getAge(birthYear) {
  if (!birthYear) return null;
  if (birthYear > 2026) return null;
  return 2026 - birthYear;
}

Returning Objects

Functions often return complex values.

function createUser(name, age) {
  return {
    name: name,
    age: age,
    isAdult: age >= 18,
  };
}

const user = createUser("Alice", 25);
console.log(user.name);    // "Alice"
console.log(user.isAdult); // true

// Return arrays:
function getMinMax(arr) {
  return [Math.min(...arr), Math.max(...arr)];
}
const [min, max] = getMinMax([3, 1, 7, 2]);
// min = 1, max = 7

Return an array and destructure the result for clean multi-value returns.

1 / 2

Multiple Return Values

JavaScript can only return one thing — but that thing can contain many values.

// Pattern 1: Return an object
function getStats(numbers) {
  return {
    min: Math.min(...numbers),
    max: Math.max(...numbers),
    avg: numbers.reduce((a, b) => a + b) / numbers.length,
  };
}
const { min, max, avg } = getStats([1, 2, 3, 4, 5]);

// Pattern 2: Return an array
function divide(a, b) {
  return [Math.floor(a / b), a % b];
}
const [quotient, remainder] = divide(17, 5);
// quotient = 3, remainder = 2

💡 Prefer objects when returning named values (self-documenting). Use arrays when values have a natural order (like coordinates).

FAQ

Common questions about return values.

// Guard clauses — check invalid cases first: function divide(a, b) { if (b === 0) return "Cannot divide by zero"; return a / b; } function getAge(birthYear) { if (!birthYear) return null; if (birthYear > 2026) return null; return 2026 - birthYear; }

function createUser(name, age) { return { name: name, age: age, isAdult: age >= 18, }; } const user = createUser("Alice", 25); console.log(user.name); // "Alice" console.log(user.isAdult); // true

// Pattern 1: Return an object function getStats(numbers) { return { min: Math.min(...numbers), max: Math.max(...numbers), avg: numbers.reduce((a, b) => a + b) / numbers.length, }; } const { min, max, avg } = getStats([1, 2, 3, 4, 5]); // Pattern 2: Return an array function divide(a, b) { return [Math.floor(a / b), a % b]; } const [quotient, remainder] = divide(17, 5); // quotient = 3, remainder = 2