JavaScript Functions

// Function Declaration
function greet(name) {
  return "Hello, " + name + "!";
}

// Can be called before declaration (hoisted)
sayHello(); // Works!

function sayHello() {
  console.log("Hello!");
}

// Parameters and return value
function add(a, b) {
  return a + b;  // Returns the sum
}

const result = add(2, 3);  // result = 5

// Function Expression
const greet = function(name) {
  return "Hello, " + name + "!";
};

// Named function expression (useful for recursion/debugging)
const factorial = function fact(n) {
  if (n <= 1) return 1;
  return n * fact(n - 1);
};

// Cannot be called before definition
// multiply(2, 3); // Error!
const multiply = function(a, b) {
  return a * b;
};

// Arrow Function (ES6)
const greet = (name) => {
  return "Hello, " + name + "!";
};

// Short syntax (implicit return)
const add = (a, b) => a + b;

// Single parameter (parentheses optional)
const double = x => x * 2;

// No parameters (parentheses required)
const sayHi = () => "Hi!";

// Returning an object (wrap in parentheses)
const createUser = (name) => ({ name, id: Date.now() });

// Arrow functions and "this"
const obj = {
  name: "Alice",
  // Regular function - "this" is obj
  greet: function() {
    console.log("Hello, " + this.name);
  },
  // Arrow - "this" is inherited (not obj!)
  greetArrow: () => {
    console.log("Hello, " + this.name); // this.name is undefined
  }
};

// Explicit return
function add(a, b) {
  return a + b;  // Execution stops here
  console.log("Never runs");
}

// No return = undefined
function noReturn() {
  console.log("Hello");
  // Implicitly returns undefined
}

// Early return for validation
function divide(a, b) {
  if (b === 0) {
    return "Error: Division by zero";
  }
  return a / b;
}

// Return multiple values (use object or array)
function getMinMax(arr) {
  return {
    min: Math.min(...arr),
    max: Math.max(...arr)
  };
}
const { min, max } = getMinMax([1, 5, 3, 9, 2]);

// Function Declaration
function greet(name) {
  return "Hello, " + name + "!";
}
console.log(greet("Alice"));

// Function Expression
const add = function(a, b) {
  return a + b;
};
console.log("2 + 3 =", add(2, 3));

// Arrow Function
const multiply = (a, b) => a * b;
console.log("4 * 5 =", multiply(4, 5));

// Arrow function with block body
const divide = (a, b) => {
  if (b === 0) return "Cannot divide by zero";
  return a / b;
};
console.log("10 / 2 =", divide(10, 2));

// Function with default parameters
function greetWithDefault(name = "Guest") {
  return "Welcome, " + name + "!";
}
console.log(greetWithDefault());
console.log(greetWithDefault("Bob"));

// Functions as arguments (callbacks)
function processArray(arr, callback) {
  const result = [];
  for (const item of arr) {
    result.push(callback(item));
  }
  return result;
}

// Using with different callbacks
const numbers = [1, 2, 3, 4, 5];

const doubled = processArray(numbers, x => x * 2);
console.log("Doubled:", doubled);

const squared = processArray(numbers, x => x * x);
console.log("Squared:", squared);

// Built-in array methods with callbacks
const filtered = numbers.filter(x => x > 2);
console.log("Filtered (>2):", filtered);

const sum = numbers.reduce((acc, x) => acc + x, 0);
console.log("Sum:", sum);

// setTimeout callback
console.log("Starting timer...");
setTimeout(() => {
  console.log("Timer finished!");
}, 1000);

// Immediately Invoked Function Expression (IIFE)
(function() {
  console.log("I run immediately!");
})();

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

// IIFE with parameters
(function(name) {
  console.log("Hello, " + name);
})("Alice");

// Use case: Create private scope
const counter = (function() {
  let count = 0;  // Private variable
  return {
    increment: () => ++count,
    decrement: () => --count,
    get: () => count
  };
})();

counter.increment();  // 1
counter.increment();  // 2
counter.get();        // 2