工具函数中箭头函数替代普通函数的时机及选型原因探讨

Great question—this isn’t just about personal preference, though team style conventions do matter! Let’s break down the technical differences that should guide your choice, and when to reach for arrow functions over regular functions for utility code.

核心技术差异（不止是偏好） #

These are the key factors that make one choice better than the other in specific scenarios:

• this 绑定规则
  Regular functions have dynamic this—its value depends on how the function is called (e.g., as an object method, with call()/apply(), or as a callback). Arrow functions use lexical this—they inherit the this value from the surrounding scope where they’re defined.

  For utility functions, which are often pure or stateless, dynamic this is usually unnecessary and can lead to bugs if you accidentally reference this without realizing its context. Arrow functions eliminate this risk entirely.

• 构造函数能力
  Regular functions can be invoked with new to create instances. Arrow functions cannot—trying to do so throws an error. If your utility function is never meant to be used as a constructor (which is almost always the case for utilities), arrow functions prevent accidental misuse.

• arguments 对象
  Regular functions have access to the arguments object, which contains all passed parameters. Arrow functions do not—instead, you’ll need to use rest parameters (...args) to handle variable-length argument lists. Rest parameters are actually more modern and explicit, so this is rarely a downside for arrow functions.

• 函数名与调试
  Regular functions have a name property that matches their declared name, which helps with debugging stack traces. Arrow functions inherit their name from the variable they’re assigned to (e.g., const myFunc = () => {} will have myFunc.name = 'myFunc'). As long as you name your arrow function variables clearly, debugging remains straightforward.

工具函数场景下，何时选择箭头函数？ #

Opt for arrow functions when:

• You want to guarantee a consistent this value (or don’t need this at all) to avoid context-related bugs.
• You’re writing short, pure utility functions where brevity improves readability—like single-expression returns:

  export const calculateTotal = (items) => items.reduce((sum, item) => sum + item.price, 0);
  

• You want to prevent the function from being used as a constructor (adding an extra layer of safety for utility code).
• You need to capture the this value from an outer scope (e.g., if your utility function is nested inside a class method or another function where lexical this is useful).

何时仍需使用普通函数？ #

Stick to regular functions if:

• Your utility function needs dynamic this binding (though this is rare for pure utilities).
• You rely on the arguments object (though rest parameters are generally preferred now).
• You’re building a utility that’s intended to be used as a constructor (e.g., a helper class factory).

总结 #

While personal or team style preferences play a role, the choice between regular and arrow functions for utilities is often driven by technical needs. Arrow functions are generally safer and more concise for stateless, pure utility code, but regular functions still have their place in specific edge cases.

内容的提问来源于stack exchange，提问作者overdub60