What is function overloading?

We need a utility function formatDate that can accept either a Date object or a timestamp number. How would you implement it so callers can use either form?

If you call a JavaScript function with more arguments than it declares, what happens? How can you use that behavior to simulate overloading?

Our team has a function calculate(a, b, options) that originally took two numbers, but we now need to support an optional third parameter for a callback. The recent bug shows the callback is being treated as a number. Walk me through how you'd refactor the function to handle both signatures safely.

During a code review you notice a library that uses arguments.length to differentiate behavior. What are the pros and cons of this approach, and how would you improve it for maintainability?

We're designing a public API for a charting library where drawChart can be called with either a config object or separate width, height, and data parameters. How would you design the function to support these overloads while keeping type safety and performance in mind?

Our microservice exposes a JSON-RPC endpoint that forwards calls to internal JavaScript functions which emulate overloading via runtime checks. At high load we see increased latency. What could be causing the slowdown, and how would you redesign the overload handling to be more efficient?

The company is migrating a large legacy codebase that heavily relies on custom overload patterns using arguments and manual type checks. As a staff engineer, outline a migration strategy to replace these patterns with a more maintainable approach, considering backward compatibility and cross-team impact.

We plan to expose a TypeScript definition file for a JavaScript library that currently simulates overloads at runtime. How would you document and enforce overload signatures to aid downstream teams and tooling, and what trade-offs does this introduce?