Classical (non-js) approach to overloading:
function myFunc(){ //code } function myFunc(overloaded){ //other code }
Javascript wont let more than one function be defined with the same name. As such, things like this show up:
function myFunc(options){ if(options["overloaded"]){ //code } }
Is there a better workaround for function overloading in javascript other than passing an object with the overloads in it?
Passing in overloads can quickly cause a function to become too verbose because each possible overload would then need a conditional statement. Using functions to accomplish the //code
inside of those conditional statements can cause tricky situations with scopes.
Unlike the other programming languages, JavaScript Does not support Function Overloading.
You overload a function name f by declaring more than one function with the name f in the same scope. The declarations of f must differ from each other by the types and/or the number of arguments in the argument list.
Overloaded functions enable you to supply different semantics for a function, depending on the types and number of its arguments. For example, consider a print function that takes a std::string argument. This function might perform very different tasks than a function that takes an argument of type double .
JavaScript does not support overloading. JavaScript supports overriding, so if you define two functions with the same name, the last one defined will override the previously defined version and every time a call will be made to the function, the last defined one will get executed.
There are multiple aspects to argument overloading in Javascript:
Variable arguments - You can pass different sets of arguments (in both type and quantity) and the function will behave in a way that matches the arguments passed to it.
Default arguments - You can define a default value for an argument if it is not passed.
Named arguments - Argument order becomes irrelevant and you just name which arguments you want to pass to the function.
Below is a section on each of these categories of argument handling.
Because javascript has no type checking on arguments or required qty of arguments, you can just have one implementation of myFunc()
that can adapt to what arguments were passed to it by checking the type, presence or quantity of arguments.
jQuery does this all the time. You can make some of the arguments optional or you can branch in your function depending upon what arguments are passed to it.
In implementing these types of overloads, you have several different techniques you can use:
undefined
.arguments.length
.arguments
pseudo-array to access any given argument with arguments[i]
.Here are some examples:
Let's look at jQuery's obj.data()
method. It supports four different forms of usage:
obj.data("key"); obj.data("key", value); obj.data(); obj.data(object);
Each one triggers a different behavior and, without using this dynamic form of overloading, would require four separate functions.
Here's how one can discern between all these options in English and then I'll combine them all in code:
// get the data element associated with a particular key value obj.data("key");
If the first argument passed to .data()
is a string and the second argument is undefined
, then the caller must be using this form.
// set the value associated with a particular key obj.data("key", value);
If the second argument is not undefined, then set the value of a particular key.
// get all keys/values obj.data();
If no arguments are passed, then return all keys/values in a returned object.
// set all keys/values from the passed in object obj.data(object);
If the type of the first argument is a plain object, then set all keys/values from that object.
Here's how you could combine all of those in one set of javascript logic:
// 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 } },
The key to this technique is to make sure that all forms of arguments you want to accept are uniquely identifiable and there is never any confusion about which form the caller is using. This generally requires ordering the arguments appropriately and making sure that there is enough uniqueness in the type and position of the arguments that you can always tell which form is being used.
For example, if you have a function that takes three string arguments:
obj.query("firstArg", "secondArg", "thirdArg");
You can easily make the third argument optional and you can easily detect that condition, but you cannot make only the second argument optional because you can't tell which of these the caller means to be passing because there is no way to identify if the second argument is meant to be the second argument or the second argument was omitted so what's in the second argument's spot is actually the third argument:
obj.query("firstArg", "secondArg"); obj.query("firstArg", "thirdArg");
Since all three arguments are the same type, you can't tell the difference between different arguments so you don't know what the caller intended. With this calling style, only the third argument can be optional. If you wanted to omit the second argument, it would have to be passed as null
(or some other detectable value) instead and your code would detect that:
obj.query("firstArg", null, "thirdArg");
Here's a jQuery example of optional arguments. both arguments are optional and take on default values if not passed:
clone: function( dataAndEvents, deepDataAndEvents ) { dataAndEvents = dataAndEvents == null ? false : dataAndEvents; deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents; return this.map( function () { return jQuery.clone( this, dataAndEvents, deepDataAndEvents ); }); },
Here's a jQuery example where the argument can be missing or any one of three different types which gives you four different overloads:
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; },
Other languages (like Python) allow one to pass named arguments as a means of passing only some arguments and making the arguments independent of the order they are passed in. Javascript does not directly support the feature of named arguments. A design pattern that is commonly used in its place is to pass a map of properties/values. This can be done by passing an object with properties and values or in ES6 and above, you could actually pass a Map object itself.
Here's a simple ES5 example:
jQuery's $.ajax()
accepts a form of usage where you just pass it a single parameter which is a regular Javascript object with properties and values. Which properties you pass it determine which arguments/options are being passed to the ajax call. Some may be required, many are optional. Since they are properties on an object, there is no specific order. In fact, there are more than 30 different properties that can be passed on that object, only one (the url) is required.
Here's an example:
$.ajax({url: "http://www.example.com/somepath", data: myArgs, dataType: "json"}).then(function(result) { // process result here });
Inside of the $.ajax()
implementation, it can then just interrogate which properties were passed on the incoming object and use those as named arguments. This can be done either with for (prop in obj)
or by getting all the properties into an array with Object.keys(obj)
and then iterating that array.
This technique is used very commonly in Javascript when there are large numbers of arguments and/or many arguments are optional. Note: this puts an onus on the implementating function to make sure that a minimal valid set of arguments is present and to give the caller some debug feedback what is missing if insufficient arguments are passed (probably by throwing an exception with a helpful error message).
In an ES6 environment, it is possible to use destructuring to create default properties/values for the above passed object. This is discussed in more detail in this reference article.
Here's one example from that article:
function selectEntries({ start=0, end=-1, step=1 } = {}) { ··· };
Then, you can call this like any of these:
selectEntries({start: 5}); selectEntries({start: 5, end: 10}); selectEntries({start: 5, end: 10, step: 2}); selectEntries({step: 3}); selectEntries();
The arguments you do not list in the function call will pick up their default values from the function declaration.
This creates default properties and values for the start
, end
and step
properties on an object passed to the selectEntries()
function.
In ES6, Javascript adds built-in language support for default values for arguments.
For example:
function multiply(a, b = 1) { return a*b; } multiply(5); // 5
Further description of the ways this can be used here on MDN.
Overloading a function in JavaScript can be done in many ways. All of them involve a single master function that either performs all the processes, or delegates to sub-functions/processes.
One of the most common simple techniques involves a simple switch:
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; } }
A more elegant technique would be to use an array (or object if you're not making overloads for every argument count):
fooArr = [ function () { }, function (a) { }, function (a,b) { } ]; function foo(a, b) { return fooArr[arguments.length](a, b); }
That previous example isn't very elegant, anyone could modify fooArr
, and it would fail if someone passes in more than 2 arguments to foo
, so a better form would be to use a module pattern and a few checks:
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; }());
Of course your overloads might want to use a dynamic number of parameters, so you could use an object for the fns
collection.
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; }());
My personal preference tends to be the switch
, although it does bulk up the master function. A common example of where I'd use this technique would be a accessor/mutator method:
function Foo() {} //constructor Foo.prototype = { bar: function (val) { switch (arguments.length) { case 0: return this._bar; case 1: this._bar = val; return this; } } }
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With