On this page

JavaScript Arrow Functions

Enrico Hochkoeppler Profile

By Enrico Hochkoeppler

Web Developer & TutoriaLibre Founder

Arrow functions, introduced in modern JavaScript (ES6), provide a concise way to write function expressions. They are highly popular in modern development because they reduce the amount of code required to perform simple tasks and improve the readability of complex logic.

Syntax Comparison​

The most visible change in an arrow function is the removal of the function keyword and the addition of the "fat arrow" => between the parameters and the function body.


// Traditional Function Expression

const multiply = function (a, b) {

  return a * b;

};



// Arrow Function

const multiplyArrow = (a, b) => {

  return a * b;

};

Parameter Rules​

Arrow functions allow for even further simplification depending on the number of parameters being used.


// No parameters

const sayHello = () => console.log("Hello!");



// Single parameter (no parentheses needed)

const square = (x) => x * x;



// Multiple parameters (parentheses required)

const add = (a, b) => a + b;

Implicit and Explicit Returns​

One of the most powerful features of arrow functions is the ability to return a value automatically. This behavior depends on how the function body is written.

Explicit Return (Block Body)​

If the function body is wrapped in curly braces {}, it is known as a block body. In this format, the function behaves like a traditional function: it will only return a value if the return keyword is explicitly used.


const addNumbers = (a, b) => {

  const result = a + b;

  return result; // Keyword must be present

};

Implicit Return (Concise Body)​

If the function consists of a single expression, the curly braces and the return keyword can be removed. This is a concise body. JavaScript will automatically "return" the result of that expression to the code that called it.


const addNumbers = (a, b) => a + b; // Automatically returns the sum

Returning Object Literals​

There is a specific rule to follow when using an implicit return to send back an object literal. Because JavaScript uses curly braces {} for both function blocks and objects, an object must be wrapped in parentheses () to avoid a syntax error.


// This will cause an error or return undefined

const createPoint = (x, y) => { x: x, y: y };



// This correctly returns the object

const createPointCorrect = (x, y) => ({ x: x, y: y });

Implementation Strategy​

While arrow functions are modern and clean, they are best used in specific scenarios. They are exceptionally useful as "one-liners" for mathematical operations or as arguments passed into other functions. However, for large, complex functions involving many lines of logic, a traditional function or a named function declaration may still be preferred to maintain code clarity.

Found this helpful? Share the knowledge...

... or support this project to keep it alive!

Buy Me a Coffee

Previous

Declaration & Syntax

Next

Scope Introduction