Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.geeksforgeeks.org/javascript/lambda-expressions-in-javascript/ below:

Lambda Expressions in JavaScript - GeeksforGeeks

Last Updated : 07 Jun, 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.

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.

Now let's understand with the help of an example

let mul = (a, b) => a * b;
console.log(mul(5, 9));

Below are the some examples of arrow functions:

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

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

console.log(add(5, 3));  

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

const mul = (a, b) => a * b;
console.log(mul(4, 5)); 

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

const greet = () => "Hello, World!";
console.log(greet());  

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

const square = x => x * x;
console.log(square(6));

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

const num = [1, 2, 3, 4, 5];
const doubled = num.map(num => num * 2);
console.log(doubled);  

Output

[2, 4, 6, 8, 10]

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

const button = document.querySelector("button");
button.addEventListener("click", () => {
    console.log(this);  
});

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

setTimeout(() => {
    console.log("Hello after 1 second!");
}, 1000);

• 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.

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.

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;

Lambda expressions in JavaScript, realized via arrow functions, offer a modern, compact, and efficient way to write functions. They are particularly powerful when working with functional programming techniques or when you want to maintain the this context without binding manually.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4