Improvement of Function.prototype.toString()

ECMAScript 10 introduced significant improvements to Function.prototype.toString(), standardizing its behavior. These enhancements address historical inconsistencies, ensuring a more accurate and consistent string representation of function source code. Below are the specific details and practical applications.

Standardized Output of Function Source Code

Prior to ECMAScript 10, implementations of Function.prototype.toString() varied across browsers. Some engines omitted comments, whitespace, or even altered the function body. The ES10 specification mandates that engines must return the complete, original source code of the function, including comments and whitespace.

function sayHello() {
  // This is a comment
  console.log('Hello');
}

console.log(sayHello.toString());
// Output:
// "function sayHello() {
//   // This is a comment
//   console.log('Hello');
// }"

Handling Dynamically Generated Functions

For dynamically generated functions (e.g., those created via the Function constructor or eval), ES10 requires that a syntactically valid function declaration string be returned. If the original source code cannot be retrieved, the engine must generate a standardized, parseable string.

const dynamicFunc = new Function('a', 'b', 'return a + b;');
console.log(dynamicFunc.toString());
// Output: "function anonymous(a, b) { return a + b; }"

Improvements for Arrow Functions and Methods

The toString() behavior for arrow functions and methods (including shorthand methods) has also been standardized. Arrow functions retain the => syntax, and method declarations preserve their shorthand form.

const arrowFunc = (x, y) => x + y;
console.log(arrowFunc.toString()); 
// Output: "(x, y) => x + y"

const obj = {
  method() { return 42; }
};
console.log(obj.method.toString());
// Output: "method() { return 42; }"

Handling Edge Cases

ES10 clarifies the return values for special scenarios. For example, built-in functions or those provided by the host environment may return "function () { [native code] }", while functions of proxy objects must determine their output based on the proxied target.

console.log(Array.isArray.toString());
// Possible output: "function isArray() { [native code] }"

const proxyFunc = new Proxy(() => {}, {});
console.log(proxyFunc.toString());
// Output: "() => {}"

Practical Applications

The standardized toString() can be used for code analysis, serialization, or dynamic code generation. For example, extracting function parameter lists or inspecting implementation details:

function extractParams(func) {
  const str = func.toString();
  const paramStart = str.indexOf('(') + 1;
  const paramEnd = str.indexOf(')');
  return str.slice(paramStart, paramEnd).split(',').map(p => p.trim());
}

const example = (name, age = 20) => {};
console.log(extractParams(example)); // ["name", "age = 20"]

Interaction with Other Features

The improvements to toString() do not affect other language features. For instance, a function's name is determined by the name property, while toString() focuses solely on the source code text. The two can be used together:

function demo() {}
console.log(demo.name); // "demo"
console.log(demo.toString().startsWith('function demo')); // true