Bite-sized JavaScript: Arrow function expressions

Bite-sized JavaScript: Arrow function expressions
Photo by Tim Mossholder / Unsplash

JavaScript arrow function expressions have been a popular feature since their introduction in ECMAScript 6 (ES6). They provide a concise syntax for creating anonymous functions that are more readable and easy to write than traditional function expressions. In this blog, we'll explore the syntax and benefits of using arrow functions with code examples.


The syntax for arrow functions is pretty straightforward. Here's an example:

const myArrowFunction = (parameter1, parameter2) => {
  // function body goes here

The function parameters are specified inside the parentheses, followed by the arrow operator =>. The function body is enclosed in curly braces {}. If the function body consists of a single statement, the curly braces and the return keyword can be omitted:

const myArrowFunction = (parameter1, parameter2) => statement;

For example:

const addNumbers = (num1, num2) => num1 + num2;

This function takes two parameters, num1 and num2, and returns their sum.

Arrow functions can also be used as callbacks or inline functions. For example:

const numbers = [1, 2, 3, 4, 5];
const squaredNumbers = => num ** 2);

Here, we're using the map() method to create a new array of squared numbers from the original numbers array. The arrow function takes a single parameter, num, and returns its square using the exponentiation operator **.


Arrow functions offer several benefits over traditional function expressions. Here are a few:

Concise syntax

Arrow functions provide a more concise syntax compared to traditional function expressions. The parentheses and curly braces can be omitted if the function body consists of a single statement. This makes the code more readable and easier to understand.

Implicit this

Arrow functions don't have their own this binding, unlike traditional functions. Instead, they inherit the this value from the enclosing lexical scope. This eliminates the need to use bind(), call(), or apply() methods to bind this to the correct value.

For example:

const person = {
  firstName: "John",
  lastName: "Doe",
  getFullName: function() {
    return `${this.firstName} ${this.lastName}`;
  getFullNameArrow: () => `${this.firstName} ${this.lastName}`

console.log(person.getFullName()); // "John Doe"
console.log(person.getFullNameArrow()); // "undefined undefined"

In the example above, getFullName() returns the full name of the person using this to refer to the firstName and lastName properties of the person object. However, getFullNameArrow() returns undefined undefined because arrow functions don't have their own this binding and this refers to the global object instead of the person object.

Implicit return

Arrow functions also have an implicit return feature. If the function body consists of a single expression, that expression is automatically returned without the need to specify the return keyword.

For example:

const square = num => num ** 2;

console.log(square(5)); // 25


JavaScript arrow functions provide a concise and more readable syntax for creating anonymous functions. They offer several benefits over traditional function expressions, including an implicit this binding, implicit return, and a more concise syntax. By using arrow functions, you can write cleaner and more efficient code, making your JavaScript code easier to read and maintain.

That being said, it's important to note that arrow functions aren't a replacement for traditional functions. There are still scenarios where traditional functions are more appropriate, such as when you need access to the arguments object or when you need to use the this keyword in a non-lexical scope.

Overall, arrow functions are a powerful tool in your JavaScript toolkit and should be used where appropriate to improve the readability and efficiency of your code.