JavaScript Return Values – Returning Data from Functions

function add(a, b) {
  return a + b; // Function ends here; value is sent back
  console.log("This never runs"); // Dead code after return
}

const result = add(5, 3);
console.log(result); // 8

// The returned value can be used anywhere
console.log(add(10, 20) * 2); // 60
const greeting = "Sum is: " + add(1, 2);
console.log(greeting); // Sum is: 3

// No return statement
function logMessage(msg) {
  console.log(msg);
  // Implicitly returns undefined
}

const x = logMessage("Hello"); // Hello
console.log(x); // undefined

// Bare return (used to exit early from a void function)
function printIfPositive(n) {
  if (n <= 0) return; // Exit immediately
  console.log("Positive: " + n);
}

printIfPositive(-1); // Prints nothing
printIfPositive(5);  // Positive: 5

// Return as array
function minMax(numbers) {
  const sorted = [...numbers].sort((a, b) => a - b);
  return [sorted[0], sorted[sorted.length - 1]];
}

const [min, max] = minMax([3, 1, 8, 2, 9, 4]);
console.log(`Min: ${min}, Max: ${max}`); // Min: 1, Max: 9

// Return as object — named, easier to read
function getStats(numbers) {
  const sum = numbers.reduce((a, b) => a + b, 0);
  return {
    count: numbers.length,
    sum,
    average: sum / numbers.length,
    min: Math.min(...numbers),
    max: Math.max(...numbers)
  };
}

const stats = getStats([5, 10, 15, 20]);
console.log(stats);
const { average, count } = getStats([2, 4, 6]);
console.log(`Average of ${count} items: ${average}`);

// Without early return — deeply nested
function getDiscount(user, cart) {
  let discount = 0;
  if (user) {
    if (cart.total > 0) {
      if (user.isPremium) {
        if (cart.total >= 100) {
          discount = 0.20;
        } else {
          discount = 0.10;
        }
      }
    }
  }
  return discount;
}

// With early return — flat and clear
function getDiscountClean(user, cart) {
  if (!user)           return 0;
  if (cart.total <= 0) return 0;
  if (!user.isPremium) return 0;
  return cart.total >= 100 ? 0.20 : 0.10;
}

const user = { isPremium: true };
console.log(getDiscountClean(user, { total: 150 })); // 0.2
console.log(getDiscountClean(null, { total: 150 })); // 0

// Factory function — returns a configured function
function createMultiplier(factor) {
  return function(number) {
    return number * factor;
  };
}

const double = createMultiplier(2);
const triple = createMultiplier(3);
const tenX   = createMultiplier(10);

console.log(double(5));  // 10
console.log(triple(5));  // 15
console.log(tenX(5));    // 50

// Practical: greeting factory
function createGreeter(greeting) {
  return (name) => `${greeting}, ${name}!`;
}

const sayHello = createGreeter("Hello");
const sayHowdy = createGreeter("Howdy");

console.log(sayHello("Alice")); // Hello, Alice!
console.log(sayHowdy("Bob"));   // Howdy, Bob!

// Method chaining (builder pattern)
class QueryBuilder {
  constructor() { this.query = {}; }

  where(field, value) {
    this.query[field] = value;
    return this; // Return 'this' enables chaining
  }

  limit(n) {
    this.query._limit = n;
    return this;
  }

  build() {
    return this.query;
  }
}

const q = new QueryBuilder()
  .where("status", "active")
  .where("role", "admin")
  .limit(10)
  .build();

console.log(q);

// Pure function — same input always → same output, no side effects
function calculateTax(price, taxRate) {
  return price * (1 + taxRate);
}

console.log(calculateTax(100, 0.1)); // 110 (always)
console.log(calculateTax(100, 0.1)); // 110 (same input → same output)

// Impure function — depends on external state
let taxRate = 0.1;
function calculateTaxImpure(price) {
  return price * (1 + taxRate); // Depends on external taxRate
}

taxRate = 0.2;
console.log(calculateTaxImpure(100)); // 120 (result changed!)