Arrow Functions
Concise function syntax with implicit returns and lexical this binding for callbacks.
What you'll learn
- Arrow function syntax: single and multi-expression bodies
- Implicit return without the return keyword
- Why arrow functions have no own this, arguments, or prototype
- When arrow functions are ideal (callbacks, transformations)
- When to avoid arrow functions (object methods, constructors)
Concept
Concise Syntax
Arrow functions, introduced in ES6, offer a shorter way to write function expressions. A simple transformation like function(x) { return x * 2; } becomes (x) => x * 2. When the body is a single expression, the return keyword and braces are optional — the expression is returned implicitly. For a single parameter, the parentheses around the parameter can also be dropped: x => x * 2.
Implicit Return
The implicit-return form is perfect for short callbacks passed to map, filter, and sort. It keeps code horizontal and readable. When you need multiple statements, use a block body with braces and an explicit return. Returning an object literal implicitly requires parentheses around it, so the braces are not mistaken for a function block: () => ({ key: value }).
Lexical this
The most important semantic difference is that arrow functions do not have their own this. They inherit this from the enclosing scope (lexical binding). This eliminates the old pattern of var self = this or .bind(this) in callbacks. Inside an arrow function, this is whatever it was where the arrow was defined.
No arguments, No prototype
Arrow functions also lack their own arguments object and cannot be used as constructors with new. Use rest parameters (...args) instead of arguments. Attempting new (() => {}) throws a TypeError.
When to Avoid Them
Because they lack their own this, arrow functions are a poor choice for object methods that need to access the object via this, and for prototype methods on classes. Use regular function expressions or method shorthand in those cases. Arrow functions shine as callbacks, event handlers bound to a component, and short pure transformations.
Example
// Concise syntax with implicit return
const square = (n) => n * n;
const cube = (n) => n * n * n;
console.log(square(5), cube(3)); // 25 27
// Implicit return of an object — wrap in parentheses
const makeUser = (name, age) => ({ name, age, active: true });
console.log(makeUser("Ada", 36));
// Arrow functions as callbacks — no .bind(this) needed
class Counter {
constructor() {
this.count = 0;
}
start() {
// 'this' inside the arrow refers to the Counter instance
setInterval(() => {
this.count++;
console.log("tick", this.count);
}, 1000);
}
}
// Sorting with a concise comparator
const nums = [3, 1, 4, 1, 5, 9, 2, 6];
nums.sort((a, b) => a - b);
console.log("Sorted:", nums);
// Block body when you need multiple statements
const process = (items) => {
const filtered = items.filter((x) => x != null);
const total = filtered.reduce((sum, x) => sum + x, 0);
return { count: filtered.length, total };
};
console.log(process([1, null, 2, 3, null]));
Shows implicit return, returning an object literal with parentheses, lexical this in a class callback (no bind needed), a concise sort comparator, and a block body with multiple statements.
Try it
- Math Evaluator
Arrow functions often wrap math logic — evaluate expressions live.
- Regex Tester
Arrow functions are commonly used as regex test callbacks.
Common mistakes
The mistake
Using an arrow function as an object method and losing this
The fix
Arrow functions inherit this from the surrounding scope, not the object. For methods that need this, use method shorthand ({ method() { ... } }) or a regular function expression.
The mistake
Forgetting parentheses when implicitly returning an object literal
The fix
() => { key: value } is parsed as a block body, not an object. Write () => ({ key: value }) so the braces are treated as an object literal.
Related Resources
Related Cheatsheets
- JavaScript Cheatsheet
Arrow function syntax, this binding, and common patterns.
Look up unfamiliar terms
A beginner-friendly glossary explains jargon in plain English — variables, functions, DOM, Promise, and more.
Build real projects
Apply what you learned by building guided projects with starter code and solutions.
Decode error messages
Plain-English explanations of common errors — what they mean, why they happen, and how to fix them.