Arrow functions vs Regular functions in JavaScript

Arrow functions and regular functions are both used to define functions in JavaScript, but they have some key differences. In this blog post, we'll explore those differences through a comparison table and a concrete example.

Arrow Functions vs Regular Functions in JavaScript

Arrow Functions

Arrow functions, introduced in ECMAScript 6 (ES6), provide a concise way to write functions. They have a shorter syntax and some differences in behavior compared to regular functions.

Example of an Arrow Function:
const multiply = (a, b) => a * b;

Regular Functions

Regular functions, also known as function expressions or function declarations, have been part of JavaScript since its inception.

Example of a Regular Function:
function multiply(a, b) {
  return a * b;

Comparison Table

Feature Arrow Functions Regular Functions
Syntax Shorter, concise syntax More verbose
'this' Binding No binding of this. Takes this from surrounding code Has its own this binding
Arguments Object Doesn't have arguments object Has arguments object
Constructors Cannot be used with new keyword Can be used as constructors
Prototype Property No prototype property Has prototype property
Implicit Return Allows implicit return in one-liner Requires explicit return statement

Example with Explanation

Consider the following code illustrating both types of functions:

Regular Function
const person = {
  name: 'Alice',
  age: 30,
  greet: function() {
    console.log('Hello, my name is ' +;

person.greet(); // Outputs 'Hello, my name is Alice'
In this regular function, this refers to the object that the function is a method of.

Arrow Function
const person = {
  name: 'Alice',
  age: 30,
  greet: () => {
    console.log('Hello, my name is ' +;

person.greet(); // Outputs 'Hello, my name is undefined'
In this arrow function, this doesn't bind to the person object but instead takes its value from the surrounding lexical context, leading to an undefined output.


The choice between arrow functions and regular functions depends on the specific requirements of your code. If you need a concise expression and don't require this binding, an arrow function might be the best choice. However, if you need to access the arguments object, utilize this binding, or use the function as a constructor, then a regular function would be more appropriate.

Understanding these differences ensures that you can select the correct function type for your particular use case, leading to cleaner and more maintainable code.