Modern functions

Arrow functions

Arrow functions are the most concise way to write functions in modern JavaScript. Introduced in ES6, they have special rules:

• They do not have their own this (they inherit from the parent scope)
• They do not have arguments (use rest parameters instead)
• They cannot be used as constructors (new)

Concise vs block syntax

// Implicit return (single expression)
const square = x => x * x;

// Implicit return of object (needs parentheses)
const createPoint = (x, y) => ({ x, y });

// Block with explicit return
const calculate = (a, b) => {
  const result = a + b;
  return result;
};

Default parameters

Parameters with default values avoid manual undefined checks:

// Before ES6
function old(name) {
  name = name || 'Anonymous';
}

// ES6+
function modern(name = 'Anonymous') {
  // name already has a default value
}

Rest parameters

The rest operator (...) captures a variable number of arguments into a real array (unlike the old arguments):

function largest(...numbers) {
  return Math.max(...numbers);
}
largest(3, 7, 2, 9); // 9

Closures

A closure is a function that remembers the variables from the scope where it was created, even when it is executed outside that scope. It is one of the most powerful concepts in JavaScript:

• They allow you to create private state
• They are the foundation of patterns like factory functions and modules
• Each closure has its own copy of the captured variables

Higher-order functions

A higher-order function is one that receives functions as arguments or returns functions. They are fundamental in functional programming:

IIFE

An IIFE (Immediately Invoked Function Expression) executes immediately upon definition. It is useful for creating an isolated scope:

const api = (() => {
  let state = 'ready';
  return {
    getState: () => state,
    execute: () => { state = 'running'; },
  };
})();

Practice

1. Create an arrow function with default parameters: Write a function calculateFinalPrice that receives price and discount = 0 and returns the price with the discount applied. Test it with and without the second argument.
2. Implement a closure counter: Create a function createCounter that returns a function. Each time the returned function is called, it should increment and return an internal counter. Verify that two separately created counters are independent.
3. Build a factory function: Write a function createMultiplier(factor) that returns another function which multiplies any number by factor. Create double and triple from it and test them.

In the next lesson we will explore objects and arrays in depth.