Let JavaScript easily support function overloading (Part 2 - Implementation)_javascript skills

Recognizing text signatures
Let’s first review the Overload use case mentioned in the previous article:

Copy code The code is as follows:

var extend = Overload
.add("*, ...",
function(target) { })
.add("Boolean, *, ...",
function(deep, target) { });

We allow the user to enter a string representing a certain key contained signature. When the user calls the function, we need to compare the parameter instance input by the user with each parameter type in the signature, so we need to convert the string into a type array first. That is, the string "Boolean, Number, Array" should be converted to the array [Boolean, Number, Array].

Before converting, we must first consider processing two special types, namely "*" representing any type, and "..." representing any number. We can define two proprietary types for them to make special compatibility processing for them within Overload:

Copy code The code is as follows:

Overload.Any = function() {};
Overload.More = function() {};

After having these two types, the string "Boolean, *, ..." will be correctly converted into an array [Boolean, Overload.Any, Overload.More]. Since Overload.Any and Overload.More are both functions, they can naturally be regarded as types.

After these two types are handled correctly, we can start writing the conversion function that recognizes text signatures:

Copy code The code is as follows:

if (signature.replace(/(^s |s $)/ig, "") == "") {
signature = [];
} else {
signature = signature.split(",");
for (var i = 0; i < signature.length; i ) {
var typeExpression = signature[i].replace(/(^s |s $)/ig, "");
var type = null;
if (typeExpression == "*") {
type = Overload. Any;
} else if (typeExpression == "...") {
type = Overload.More;
} else {
type = eval("(" typeExpression ")");
}
signature[i] = type;
}
}

I think this code is pretty easy to understand, so I won’t explain it anymore. When I first wrote this code, I forgot to write the first if above. As a result, the blank signature string "" could not be correctly recognized as a blank signature array []. Fortunately, my unit test code discovered this flaw immediately. . It seems that writing unit test code is still very important.

Match function signature
After we get the type array of function signature, we can use it to match the instance array of input parameters to find the correct repetition load. Before discussing how to match function signatures, let's first take a look at how languages ​​like C# or VB.NET handle function overload matching. The process of function overload matching in general languages ​​is as follows:

Number of parameters - Overloads with incorrect number of parameters will be excluded
Parameter type - Parameter types cannot be implicitly converted into signatures Types will be excluded
Number of matches - After exclusion, the number of remaining matching signatures will be processed differently.
0 matches - no hits
1 match - this is a hit Matches
2 or more matches - if a best match can be found among these matches, then the best match is hit; otherwise no match is hit
In this section, we deal with the process first In the first two steps, remove signatures with inconsistent parameter numbers or parameter types:

Copy code The code is as follows :

var matchSignature = function(argumentsArray, signature) {
if (argumentsArray.length < signature.length) {
return false;
} else if (argumentsArray. length > signature.length && !signature.more) {
return false;
}
for (var i = 0; i < signature.length; i ) {
if (!( signature[i] == Overload.Any
|| argumentsArray[i] instanceof signature[i]
|| argumentsArray[i].constructor == signature[i])) {
return false;
}
}
return true;
};

In order to compare the length, we need to add "..." indicating any number of parameters outside this function. Make some special processing:

Copy the code The code is as follows:

if (signature[signature.length - 1] == Overload.More) {
signature.length = signature.length - 1;
signature.more = true;
}

This piece of code will be integrated at the end of the conversion function in the first section, so that the matchSignature function can easily determine whether the parameters and signature match. In the most ideal case, we match 0 or 1 overload for the input parameter type, so that we can easily determine which overload is hit. But if there are 2 or more overload matches, then we have to choose the optimal one, which is what will be discussed in the next section.

Handling multiple matches
For information on how C# selects more matching overloads from multiple matches, you can read the relevant chapters in the C# Language Specification. I think three simple examples can illustrate the problem:

Copy code The code is as follows:

long Sum(int x, int y) { return x y; }
long Sum(long x, long y) { return x y; }
Sum(0, 1);

Since the two parameters 0 and 1 will be understood by the compiler as int type, they do not need to be type converted for the first overload, and they must be type converted for the second overload. , so the first overload is better.

Copy code The code is as follows:

long Sum(int x, long y) { return x y; }
long Sum(long x, int y) { return x y; }
Sum(0, 1);

on the 1st parameter , the first overload is better; on the second parameter, the second overload is better. In this case, no overload is better than the other, and the compiler will report an error if it cannot find a better overload.

Copy code The code is as follows:

long Sum(int x, int y) { return x y; }
long Sum(int x, long y) { return x y; }
long Sum(long x, int y) { return x y; }
Sum(0, 1);

On the first parameter, the first overload is better than the third overload and is the same as the second overload; on the second parameter, the first The overloading is better than the 2nd overloading and is no different from the 3rd overloading. Although the second overload is indistinguishable from the third overload, we can be sure that the first overload is better than them all, so the compiler chose the first overload.

Suppose we have a comparison function of overloadComparator that can compare the pros and cons between any two signatures. Do we need to compare the signatures only pairwise to find the optimal overload? In fact, it is not necessary. We can use the sort method of Array and let it call overloadComparator for sorting. After sorting, just verify the relationship between the top two - if they are tied, neither one will be hit; if there is a priority, , then the first one is hit.

The specific overloadComparator code is not given here. It relies on another comparison function called inheritanceComparator to compare the parameter types of the two signatures which one is closer to the actual parameter type passed in. It is used inside A more clever way to determine whether two types have an inheritance relationship, and who inherits from whom.

Summary
Now we have a JavaScript function overloading library. For the complete code, please see here: Function Overloading Library Overload. I hope this library can effectively help everyone improve the readability of JavaScript code and reduce the maintenance cost of large-scale Ajax projects.