Why Facebook Limits Arrow Functions: Hidden Pitfalls Every Frontend Engineer Should Know

JavaScript arrow function syntax is concise and readable, which should make it popular among developers. However, Facebook deliberately restricts arrow function usage in its massive codebase, based on real‑world experience with numerous pitfalls.

The Trouble with Context Binding

Arrow functions do not bind their own this; they inherit the this value from the surrounding scope, which can become a major hidden risk.

const obj = {
  data: 42,
  regularMethod: function() {
    console.log(this.data); // 42
  },
  arrowMethod: () => {
    console.log(this.data); // undefined
  }
};

In object methods, prototype methods, or any scenario that requires a dynamic this, arrow functions often lead to hard‑to‑track bugs.

Prototype Method Dilemma

When an arrow function is used as a prototype method in a class or constructor, each instance creates its own copy of the function instead of sharing a single reference, increasing memory consumption.

Cannot be Constructed

Arrow functions cannot be used as constructors; using the new operator throws an error.

const Person = (name) => {
  this.name = name;
};
const john = new Person('John'); // TypeError: Person is not a constructor

Missing arguments Object

Arrow functions do not bind the arguments object, which is inconvenient when handling a variable number of parameters.

function regular() {
  console.log(arguments);
}
const arrow = () => {
  console.log(arguments); // Reference error or outer arguments
};

Two Sides of Code Readability

While arrow functions improve brevity in simple scenarios, overusing them in complex logic can reduce code readability and maintainability.

Balancing Approach for Senior Developers

To avoid these pitfalls, developers usually follow these principles:

Use arrow functions for simple function expressions, callbacks, and array methods.

Prefer traditional functions when this binding, arguments object, or constructor behavior is needed.

Avoid arrow functions in class methods and object methods.

Choose flexibly based on team conventions and project context.

Contributions and additional insights are welcome.