VOOZH about

URL: https://www.geeksforgeeks.org/javascript/lambda-expressions-in-javascript/

⇱ Lambda Expressions in JavaScript - GeeksforGeeks

  • Courses
  • Tutorials
  • Interview Prep

Lambda Expressions in JavaScript

Last Updated : 20 Dec, 2025

A lambda expression also known as arrow-function is a function without a name defined using the arrow => syntax introduced in ES6 (ECMAScript 2015). Unlike traditional function declarations or expressions, lambda expressions are shorter and come with some unique behavior, particularly around the this keyword.

  • It has a shorter and simpler syntax.
  • It makes small functions and callbacks easier to read.
  • It works well with methods like map, filter, and reduce that are used in functional programming.

Now let's understand with the help of an example


Output
45

Syntax

const functionName = (parameters) => { // function body };
  • functionName: The name of the function.
  • parameters: The values the function takes as input (can be one or more).
  • =>: The arrow symbol that separates the parameters from the function body.

Examples of Arrow Functions

Below are the some examples of arrow functions:

1. Basic Arrow Function

This is a typical arrow function that performs an operation (adding two numbers)


Output
8

2. Concise Arrow Function with Implicit Return

If the function contains only one expression, you can omit the curly braces and return statement. The result will be returned automatically


Output
20

3. Arrow Function with No Parameters

If the function has no parameters, simply use empty parentheses:


Output
Hello, World!

4. Arrow Function with One Parameter

If there is only one parameter, you can omit the parentheses:


Output
36

Use Cases for Arrow Functions

1. Using Arrow Functions with map()

Arrow functions are commonly used with array methods like map(), which require a callback function.

Output

[2, 4, 6, 8, 10]

2. Event Handlers

Arrow functions are often used in event listeners because they automatically bind this to the surrounding context.

3. Inline Functions

Arrow functions are often used for small, inline functions, where defining a function with a function keyword might seem excessive.

When to Use Lambda Expressions

  • Short functions: When you need simple one-liners.
  • Callbacks: For example, in array methods like .map(), .filter(), .reduce().
  • Functional programming: Composing functions and chaining operations.
  • Maintaining lexical this: Especially in event handlers, timers, or nested functions.

Limitations of Lambda Functions

Here are some limitations:

  • No own this context: Arrow functions inherit this from the surrounding context, so they cannot be used when a separate this context is needed, like in object methods.
  • Cannot be used as constructors: Arrow functions cannot be used with the new keyword to create instances.
  • No arguments object: Arrow functions do not have their own arguments object, which can be an issue when working with functions that need to handle dynamic arguments.

Differences Between Traditional Functions and Arrow Functions

Traditional Functions

Lambda Functions

Uses the function keyword.

Uses the => (fat arrow) syntax for a more concise function

The value of this is dynamically bound based on how the function is invoked.

this is lexically bound and takes the value from the surrounding context.

Has its own arguments object which contains all arguments passed to the function.

Does not have its own arguments object, instead inherits it from the surrounding function.

Can be used as a constructor with the new keyword to create instances.

Cannot be used as a constructor, will throw an error when used with new.

Functions have the prototype property and can be used to create methods on objects.

Arrow functions do not have a prototype property.

Suitable for functions where you need to work with this, constructors, or the arguments object.

Ideal for short functions, callbacks, and cases where this needs to be inherited from the surrounding context.

Example => function add(a, b) { return a + b; }

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

Comment