正确答案是JAVASCRIPT中没有重载。

检查/切换内部的功能不是过载。

超载的概念: 在某些编程语言中，函数重载或方法重载是用不同的实现创建多个同名方法的能力。对重载函数的调用将运行该函数的特定实现，适用于调用的上下文，允许一个函数调用根据上下文执行不同的任务。

例如，doTask()和doTask(object O)是重载方法。要调用后者，必须将对象作为参数传递，而前者不需要参数，并且使用空参数字段调用。一个常见的错误是将默认值赋给第二个方法中的对象，这将导致一个模糊的调用错误，因为编译器不知道使用两个方法中的哪一个。

https://en.wikipedia.org/wiki/Function_overloading

所有建议的实现都很棒，但说实话，JavaScript没有原生实现。

正确答案是JAVASCRIPT中没有重载。

检查/切换内部的功能不是过载。

超载的概念: 在某些编程语言中，函数重载或方法重载是用不同的实现创建多个同名方法的能力。对重载函数的调用将运行该函数的特定实现，适用于调用的上下文，允许一个函数调用根据上下文执行不同的任务。

例如，doTask()和doTask(object O)是重载方法。要调用后者，必须将对象作为参数传递，而前者不需要参数，并且使用空参数字段调用。一个常见的错误是将默认值赋给第二个方法中的对象，这将导致一个模糊的调用错误，因为编译器不知道使用两个方法中的哪一个。

https://en.wikipedia.org/wiki/Function_overloading

所有建议的实现都很棒，但说实话，JavaScript没有原生实现。

如果我需要一个函数与两个使用foo(x)和foo(x,y,z)哪种是最好的/首选的方式?

问题是JavaScript本身不支持方法重载。因此，如果它看到/解析了两个或多个同名的函数，它只会考虑最后定义的函数，并覆盖之前的函数。

我认为适用于大多数情况的一种方法是

假设你有方法

function foo(x)
{
} 

而不是重载方法，这在javascript中是不可能的，你可以定义一个新的方法

fooNew(x,y,z)
{
}

然后将第一个函数修改为-

function foo(arguments)
{
  if(arguments.length==2)
  {
     return fooNew(arguments[0],  arguments[1]);
  }
} 

如果你有很多这样的重载方法，考虑使用switch而不是If -else语句。

多年来，我一直在使用这个函数来美化我的重载:

function overload(){
  const fs = arguments, fallback = fs[fs.length - 1];
  return function(){
    const f = fs[arguments.length] || (arguments.length >= fs.length ? fallback : null);
    return f.apply(this, arguments);
  }
}

型:

function curry1(f){
  return curry2(f, f.length);
}

function curry2(f, minimum){
  return function(...applied){
    if (applied.length >= minimum) {
      return f.apply(this, applied);
    } else {
      return curry2(function(...args){
        return f.apply(this, applied.concat(args));
      }, minimum - applied.length);
    }
  }
}

export const curry = overload(null, curry1, curry2);

看看jQuery的off方法:

  function off( types, selector, fn ) {
    var handleObj, type;
    if ( types && types.preventDefault && types.handleObj ) {

        // ( event )  dispatched jQuery.Event
        handleObj = types.handleObj;
        jQuery( types.delegateTarget ).off(
            handleObj.namespace ?
                handleObj.origType + "." + handleObj.namespace :
                handleObj.origType,
            handleObj.selector,
            handleObj.handler
        );
        return this;
    }
    if ( typeof types === "object" ) {

        // ( types-object [, selector] )
        for ( type in types ) {
            this.off( type, selector, types[ type ] );
        }
        return this;
    }
    if ( selector === false || typeof selector === "function" ) {

        // ( types [, fn] )
        fn = selector;
        selector = undefined;
    }
    if ( fn === false ) {
        fn = returnFalse;
    }
    return this.each( function() {
        jQuery.event.remove( this, types, fn, selector );
    } );
  }

许多重载函数在优化性能时几乎不可读。你必须破译函数的头部。这可能比使用我提供的重载函数更快;但是，从人的角度来看，它在识别调用了哪个重载方面要慢一些。

JavaScript中没有真正的函数重载，因为它允许传递任意数量的任意类型的参数。你必须检查函数内部传递了多少参数以及它们的类型。

用形参重载函数的最好方法不是检查实参长度或类型;检查类型只会让你的代码变慢，你可以享受数组、空值、对象等的乐趣。

大多数开发人员所做的是将一个对象作为方法的最后一个参数。这个物体可以装任何东西。

function foo(a, b, opts) {
  // ...
  if (opts['test']) { } //if test param exists, do something.. 
}


foo(1, 2, {"method":"add"});
foo(3, 4, {"test":"equals", "bar":"tree"});

然后你可以在你的方法中任意处理它。[开关，if-else，等等]