Functions.
Package logic. Reuse it everywhere.

// 1. Function declaration — hoisted, callable before definition
function greet(name) {
return "Hello, " + name + "!";
}
console.log(greet("Alice")); // "Hello, Alice!"

// 2. Function expression — assigned to a variable
const add = function(a, b) {
return a + b;
};
console.log(add(3, 5)); // 8

// 3. Arrow function — ES6, shorter syntax
const double = (x) => x * 2;
console.log(double(5)); // 10

// Arrow with multiple params
const multiply = (a, b) => a * b;
console.log(multiply(3, 4)); // 12

// Arrow with no params
const getRandom = () => Math.random();
console.log(getRandom());

// Arrow with a block body — needs explicit return
const subtract = (a, b) => {
const result = a - b;
return result;
};
console.log(subtract(10, 3)); // 7

// Traditional function
function square1(x) {
return x * x;
}

// Arrow function — one param, no parens needed
const square2 = x => x * x;

// Arrow with parens (optional for one param, required for 0 or 2+)
const square3 = (x) => x * x;

// Return object literal — wrap in parens
const makeUser = (name) => ({ name: name, active: true });
console.log(makeUser("Alice")); // { name: "Alice", active: true }

// Multi-line arrow — must use return
const greet = (name) => {
const greeting = "Hello, " + name;
return greeting + "!";
};

// Arrow functions in array methods (the most common use)
const nums = [1, 2, 3, 4, 5];
const doubled = nums.map(n => n * 2);
const evens = nums.filter(n => n % 2 === 0);
const total = nums.reduce((sum, n) => sum + n, 0);

// Chain them
const result = nums
.filter(n => n > 2)
.map(n => n * 10)
.reduce((a, b) => a + b, 0);
console.log(result); // 120 (30 + 40 + 50)

// Default parameters — used when the caller doesn't pass a value
function greet(name = "World") {
return "Hello, " + name + "!";
}
console.log(greet()); // "Hello, World!"
console.log(greet("Alice")); // "Hello, Alice!"

// Defaults can reference earlier params
const createUser = (name, role = name === "admin" ? "admin" : "user") => ({ name, role });

// Rest parameters — collect extra args into an array
function sum(...numbers) {
return numbers.reduce((a, b) => a + b, 0);
}
console.log(sum(1, 2, 3)); // 6
console.log(sum(1, 2, 3, 4, 5)); // 15

// Spread operator — expand an array into arguments
const values = [1, 2, 3, 4];
console.log(sum(...values)); // 10

// Destructuring parameters — extract properties from an object
function createUserDestructured({ name, age, email = "none" }) {
return { name, age, email };
}
console.log(createUserDestructured({ name: "Alice", age: 30 }));
// { name: "Alice", age: 30, email: "none" }

// Destructuring with rename
const showUser = ({ name: userName, age }) => userName + " (" + age + ")";
console.log(showUser({ name: "Alice", age: 30 })); // "Alice (30)"

// Implicit return — arrow function without braces
const double = x => x * 2;

// Explicit return — required with braces
const double2 = x => {
return x * 2;
};

// No return — returns undefined
const logIt = x => {
console.log(x);
// no return statement
};
console.log(logIt("hi")); // undefined

// Return exits the function immediately
function checkAge(age) {
if (age < 0) return "invalid";
if (age < 18) return "minor";
return "adult";
// anything here is unreachable
}
console.log(checkAge(-5)); // "invalid"
console.log(checkAge(15)); // "minor"
console.log(checkAge(30)); // "adult"

// Return multiple values via an object
function minMax(nums) {
return {
min: Math.min(...nums),
max: Math.max(...nums),
};
}
const { min, max } = minMax([3, 1, 4, 1, 5]);
console.log(min, max); // 1 5

// Return multiple values via an array
function minMaxArr(nums) {
return [Math.min(...nums), Math.max(...nums)];
}
const [lo, hi] = minMaxArr([3, 1, 4]);
console.log(lo, hi); // 1 4

// A function that returns a function — creates a closure
function makeCounter() {
let count = 0;
return function() {
count += 1;
return count;
};
}

const counter1 = makeCounter();
const counter2 = makeCounter();

console.log(counter1()); // 1
console.log(counter1()); // 2
console.log(counter1()); // 3

console.log(counter2()); // 1 (separate closure)
console.log(counter2()); // 2

// What happened? counter1 and counter2 each captured their OWN count.
// Even though makeCounter() returned, count stayed alive in memory.

// Closure over parameters
function multiplier(factor) {
return x => x * factor;
}

const double = multiplier(2);
const triple = multiplier(3);

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

// Practical use — a function that only runs once
function once(fn) {
let called = false;
return function(...args) {
if (called) return undefined;
called = true;
return fn(...args);
};
}

const init = once(() => console.log("initialized"));
init(); // "initialized"
init(); // (nothing — called is true)

// Practical use — a simple cache
function memoize(fn) {
const cache = {};
return function(n) {
if (n in cache) return cache[n];
const result = fn(n);
cache[n] = result;
return result;
};
}

const slowSquare = n => {
console.log("computing...");
return n * n;
};
const fastSquare = memoize(slowSquare);
console.log(fastSquare(5)); // "computing..." then 25
console.log(fastSquare(5)); // 25 (no computing — cached)