经典（非 js）重载方法：
function myFunc(){
//code
}
function myFunc(overloaded){
//other code
}
Javascript 不会让多个函数被定义为同名。因此，出现这样的事情：
function myFunc(options){
if(options["overloaded"]){
//code
}
}
除了传递带有重载的对象之外，是否有更好的解决 javascript 函数重载的方法？
传入重载会很快导致函数变得过于冗长，因为每个可能的重载都需要一个条件语句。使用函数来完成//code这些条件语句的内部可能会导致作用域出现棘手的情况。
Javascript 中的参数重载有多个方面：
可变参数- 您可以传递不同的参数集（类型和数量），函数的行为方式将与传递给它的参数相匹配。
默认参数- 如果未传递参数，您可以为其定义默认值。
命名参数- 参数顺序变得无关紧要，您只需命名要传递给函数的参数即可。
下面是关于这些类型的参数处理中的每一个的部分。
由于 javascript 没有对参数或所需参数数量进行类型检查，因此您可以myFunc()通过检查参数的类型、存在或数量来适应传递给它的参数的一种实现。
jQuery 一直这样做。您可以将一些参数设为可选，或者您可以根据传递给它的参数在您的函数中进行分支。
在实现这些类型的重载时，您可以使用几种不同的技术：
undefined。arguments.length。arguments伪数组访问任何给定的参数arguments[i]。这里有些例子：
我们来看看jQuery的obj.data()方法。它支持四种不同的使用形式：
obj.data("key");
obj.data("key", value);
obj.data();
obj.data(object);
每个都会触发不同的行为，如果不使用这种动态形式的重载，则需要四个独立的函数。
以下是人们如何用英语区分所有这些选项，然后我会将它们全部组合在代码中：
// get the data element associated with a particular key value
obj.data("key");
如果传递给的第一个参数.data()是字符串而第二个参数是undefined，则调用者必须使用这种形式。
// set the value associated with a particular key
obj.data("key", value);
如果第二个参数不是未定义的，则设置特定键的值。
// get all keys/values
obj.data();
如果没有传递参数，则返回返回对象中的所有键/值。
// set all keys/values from the passed in object
obj.data(object);
如果第一个参数的类型是普通对象，则设置该对象的所有键/值。
以下是将所有这些组合到一组 javascript 逻辑中的方法：
// method declaration for .data()
data: function(key, value) {
if (arguments.length === 0) {
// .data()
// no args passed, return all keys/values in an object
} else if (typeof key === "string") {
// first arg is a string, look at type of second arg
if (typeof value !== "undefined") {
// .data("key", value)
// set the value for a particular key
} else {
// .data("key")
// retrieve a value for a key
}
} else if (typeof key === "object") {
// .data(object)
// set all key/value pairs from this object
} else {
// unsupported arguments passed
}
},
此技术的关键是确保您要接受的所有参数形式都是唯一可识别的，并且永远不会混淆调用者正在使用哪种形式。这通常需要适当地对参数进行排序，并确保参数的类型和位置具有足够的唯一性，以便您始终可以判断正在使用哪种形式。
例如，如果您有一个接受三个字符串参数的函数：
obj.query("firstArg", "secondArg", "thirdArg");
您可以轻松地将第三个参数设为可选，并且可以轻松检测到该条件，但您不能只将第二个参数设为可选，因为您无法判断调用者要传递的参数是哪一个，因为无法确定第二个参数是否为参数是第二个参数，或者第二个参数被省略，所以第二个参数的位置实际上是第三个参数：
obj.query("firstArg", "secondArg");
obj.query("firstArg", "thirdArg");
由于所有三个参数都是相同的类型，因此您无法区分不同参数之间的区别，因此您不知道调用者的意图。使用这种调用方式，只有第三个参数可以是可选的。如果您想省略第二个参数，则必须将其作为null（或其他一些可检测值）传递，您的代码将检测到：
obj.query("firstArg", null, "thirdArg");
这是可选参数的 jQuery 示例。两个参数都是可选的，如果没有传递则采用默认值：
clone: function( dataAndEvents, deepDataAndEvents ) {
dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
return this.map( function () {
return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
});
},
这是一个 jQuery 示例，其中可以缺少参数或三种不同类型中的任何一种，它为您提供四种不同的重载：
html: function( value ) {
if ( value === undefined ) {
return this[0] && this[0].nodeType === 1 ?
this[0].innerHTML.replace(rinlinejQuery, "") :
null;
// See if we can take a shortcut and just use innerHTML
} else if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
(jQuery.support.leadingWhitespace || !rleadingWhitespace.test( value )) &&
!wrapMap[ (rtagName.exec( value ) || ["", ""])[1].toLowerCase() ] ) {
value = value.replace(rxhtmlTag, "<$1></$2>");
try {
for ( var i = 0, l = this.length; i < l; i++ ) {
// Remove element nodes and prevent memory leaks
if ( this[i].nodeType === 1 ) {
jQuery.cleanData( this[i].getElementsByTagName("*") );
this[i].innerHTML = value;
}
}
// If using innerHTML throws an exception, use the fallback method
} catch(e) {
this.empty().append( value );
}
} else if ( jQuery.isFunction( value ) ) {
this.each(function(i){
var self = jQuery( this );
self.html( value.call(this, i, self.html()) );
});
} else {
this.empty().append( value );
}
return this;
},
其他语言（如 Python）允许传递命名参数作为仅传递一些参数并使参数独立于它们传入的顺序的一种方式。Javascript 不直接支持命名参数的特性。一种常用的设计模式是传递属性/值的映射。这可以通过传递具有属性和值的对象来完成，或者在 ES6 及更高版本中，您实际上可以传递 Map 对象本身。
这是一个简单的 ES5 示例：
jQuery$.ajax()接受一种使用形式，您只需将单个参数传递给它，该参数是具有属性和值的常规 Javascript 对象。传递给它的属性决定了传递给 ajax 调用的参数/选项。有些可能是必需的，许多是可选的。由于它们是对象的属性，因此没有特定的顺序。事实上，可以在该对象上传递 30 多种不同的属性，只需要一个（url）。
下面是一个例子：
$.ajax({url: "http://www.example.com/somepath", data: myArgs, dataType: "json"}).then(function(result) {
// process result here
});
在$.ajax()实现内部，它可以查询传入对象上传递的属性，并将这些属性用作命名参数。这可以通过使用for (prop in obj)或通过将所有属性放入数组Object.keys(obj)然后迭代该数组来完成。
当有大量参数和/或许多参数是可选的时，这种技术在 Javascript 中非常常用。注意：这给实现函数带来了责任，以确保存在最小的有效参数集，并在传递的参数不足时向调用者提供一些调试反馈（可能通过抛出带有有用错误消息的异常） .
在 ES6 环境中，可以使用解构为上述传递的对象创建默认属性/值。本参考文章对此进行了更详细的讨论。
这是那篇文章中的一个例子：
function selectEntries({ start=0, end=-1, step=1 } = {}) {
···
};
然后，您可以像以下任何一个一样调用它：
selectEntries({start: 5});
selectEntries({start: 5, end: 10});
selectEntries({start: 5, end: 10, step: 2});
selectEntries({step: 3});
selectEntries();
您未在函数调用中列出的参数将从函数声明中获取它们的默认值。
这将创建默认属性和值start，end并step传递到一个对象的属性selectEntries()的功能。
在 ES6 中，Javascript 为参数的默认值添加了内置语言支持。
例如：
function multiply(a, b = 1) {
return a*b;
}
multiply(5); // 5
可以通过多种方式在 JavaScript 中重载函数。所有这些都涉及一个单一的主功能，该功能要么执行所有流程，要么委托给子功能/流程。
最常见的简单技术之一涉及一个简单的开关：
function foo(a, b) {
switch (arguments.length) {
case 0:
//do basic code
break;
case 1:
//do code with `a`
break;
case 2:
default:
//do code with `a` & `b`
break;
}
}
一种更优雅的技术是使用数组（或对象，如果您没有为每个参数计数进行重载）：
fooArr = [
function () {
},
function (a) {
},
function (a,b) {
}
];
function foo(a, b) {
return fooArr[arguments.length](a, b);
}
前面的例子不是很优雅，任何人都可以修改fooArr，如果有人将超过 2 个参数传递给foo，它就会失败，所以更好的形式是使用module模式和一些检查：
var foo = (function () {
var fns;
fns = [
function () {
},
function (a) {
},
function (a, b) {
}
];
function foo(a, b) {
var fnIndex;
fnIndex = arguments.length;
if (fnIndex > foo.length) {
fnIndex = foo.length;
}
return fns[fnIndex].call(this, a, b);
}
return foo;
}());
当然，您的重载可能想要使用动态数量的参数，因此您可以为fns集合使用一个对象。
var foo = (function () {
var fns;
fns = {};
fns[0] = function () {
};
fns[1] = function (a) {
};
fns[2] = function (a, b) {
};
fns.params = function (a, b /*, params */) {
};
function foo(a, b) {
var fnIndex;
fnIndex = arguments.length;
if (fnIndex > foo.length) {
fnIndex = 'params';
}
return fns[fnIndex].apply(this, Array.prototype.slice.call(arguments));
}
return foo;
}());
我个人的偏好往往是switch，尽管它确实增加了主功能。我将使用此技术的一个常见示例是访问器/修改器方法：
function Foo() {} //constructor
Foo.prototype = {
bar: function (val) {
switch (arguments.length) {
case 0:
return this._bar;
case 1:
this._bar = val;
return this;
}
}
}
您不能进行严格意义上的方法重载。不像java或 中支持的方式c#。
问题是 JavaScript 本身不支持方法重载。因此，如果它看到/解析两个或多个具有相同名称的函数，它只会考虑最后定义的函数并覆盖之前的函数。
我认为适合大多数情况的方法之一如下 -
假设你有方法
function foo(x)
{
}
您可以定义一个新方法，而不是重载在 javascript 中不可能的方法
fooNew(x,y,z)
{
}
然后修改第一个函数如下 -
function foo(x)
{
if(arguments.length==2)
{
return fooNew(arguments[0], arguments[1]);
}
}
如果您有许多这样的重载方法，请考虑使用switch而不仅仅是if-else语句。
（更多详细信息） PS：上面的链接转到我的个人博客，其中包含有关此的更多详细信息。
我根据参数数量使用了一些不同的重载方法。不过我相信约翰福西特的方法也很好。这里的示例，代码基于 John Resig（jQuery 的作者）的解释。
// o = existing object, n = function name, f = function.
function overload(o, n, f){
var old = o[n];
o[n] = function(){
if(f.length == arguments.length){
return f.apply(this, arguments);
}
else if(typeof o == 'function'){
return old.apply(this, arguments);
}
};
}
可用性：
var obj = {};
overload(obj, 'function_name', function(){ /* what we will do if no args passed? */});
overload(obj, 'function_name', function(first){ /* what we will do if 1 arg passed? */});
overload(obj, 'function_name', function(first, second){ /* what we will do if 2 args passed? */});
overload(obj, 'function_name', function(first,second,third){ /* what we will do if 3 args passed? */});
//... etc :)
我试图为这里描述的这个问题开发一个优雅的解决方案。您可以在此处找到演示。用法如下所示：
var out = def({
'int': function(a) {
alert('Here is int '+a);
},
'float': function(a) {
alert('Here is float '+a);
},
'string': function(a) {
alert('Here is string '+a);
},
'int,string': function(a, b) {
alert('Here is an int '+a+' and a string '+b);
},
'default': function(obj) {
alert('Here is some other value '+ obj);
}
});
out('ten');
out(1);
out(2, 'robot');
out(2.5);
out(true);
用于实现此目的的方法：
var def = function(functions, parent) {
return function() {
var types = [];
var args = [];
eachArg(arguments, function(i, elem) {
args.push(elem);
types.push(whatis(elem));
});
if(functions.hasOwnProperty(types.join())) {
return functions[types.join()].apply(parent, args);
} else {
if (typeof functions === 'function')
return functions.apply(parent, args);
if (functions.hasOwnProperty('default'))
return functions['default'].apply(parent, args);
}
};
};
var eachArg = function(args, fn) {
var i = 0;
while (args.hasOwnProperty(i)) {
if(fn !== undefined)
fn(i, args[i]);
i++;
}
return i-1;
};
var whatis = function(val) {
if(val === undefined)
return 'undefined';
if(val === null)
return 'null';
var type = typeof val;
if(type === 'object') {
if(val.hasOwnProperty('length') && val.hasOwnProperty('push'))
return 'array';
if(val.hasOwnProperty('getDate') && val.hasOwnProperty('toLocaleTimeString'))
return 'date';
if(val.hasOwnProperty('toExponential'))
type = 'number';
if(val.hasOwnProperty('substring') && val.hasOwnProperty('length'))
return 'string';
}
if(type === 'number') {
if(val.toString().indexOf('.') > 0)
return 'float';
else
return 'int';
}
return type;
};