Shulou(Shulou.com)05/31 Report--

This article focuses on "how to achieve overloading and default parameters in js simulation". Interested friends may wish to take a look. The method introduced in this paper is simple, fast and practical. Next let the editor to take you to learn "js simulation how to achieve overloading and default parameters" bar!

Simulation implements overloading and default parameters

As we all know, js is a function that does not support overloading and default parameters, but we can use some other methods to simulate the implementation of this method.

First, take a look at the definition of overloading: the function name is the same, the parameter list of the function is different (including the number of parameters and parameter type), and the return type can be different.

And the definition of the default parameter: the default parameter refers to a value that is automatically used when the argument is omitted in the function call.

So how to achieve these two functions, a very simple way is to use arguments to simulate.

Let's first talk about the overloading method function overLoad () {/ / using this method to simulate overloaded if (arguments [0]) {/ / if there is the first parameter if (arguments [1]) {/ / if the first parameter exists / / to do... Alert (arguments [0] + arguments [1]);} else {/ / if there is only the first parameter alert (arguments [0]); / / to do... }} else {/ / if there is no parameter alert ("null"); / / to do... }} next is the method to implement the default parameter function defaultArg () {/ / simulate the default parameter var a = arguments [0]? arguments [0]: "hello"; / / the default value of the first parameter is hello var b = arguments [1]? arguments [1]: "world"; / / the default value of the second parameter is world / /. Alert (aquib);} next test / / overload test overLoad (); / / nulloverLoad ("hello"); / / hello overLoad ("hello", "world"); / / hello world// default parameter test defaultArg (); / / hello worlddefaultArg ("Hello"); / / Hello worlddefaultArg ("Hello", "World"); / / do the functions of js support overloading

Does the function of JavaScript support overloading? For this problem, there are two main points: first, the function of JavaScript; second, overloading.

First of all, let's talk about overloading. The so-called overloading, to put it simply, is the case in which the function or method has the same name, but the parameter list is not the same. The functions or methods with different parameters of the same name are called overloaded functions or methods. Therefore, overloading mainly requires two points: first, the same function name. Second, different function parameters.

With the definition of overloading clear, let's go back to JavaScript. Going back to the source, when we talk about JavaScript, we can think of ECMAScript, that is, the standard of JavaScript. So, what specifications are made for functions in this standard?

First of all, ECMAScript has no concept of a function signature because its parameters are represented by an array containing zero or more values. Without a function signature, real overloading is impossible.

Second, if two functions with the same name are defined in ECMAScript, the name belongs only to the later defined function, as follows:

Function add (num) {return num+1;} function add (num) {return num+2;} var result = add (4); / / result is 6

In the above example, the add () function is defined twice, however, when we call it, we call the second function directly, which means that in JavaScript, the later defined function overrides the previously defined function.

At this point, is it possible to determine that JavaScript does not support function overloading?

Let me introduce an arguments object in JavaScript. First of all, the parameters of the ECMAScript function are a little different from those of other languages. The ECMAScript function doesn't mind the number and type of parameters passed in. That is, after you define that the function accepts only two arguments, you can still pass zero or more arguments when calling. This will not be wrong. The reason lies in the arguments object. In ECMAScript, the parameters of a function are always stored in an array that can be accessed through the arguments object. Therefore, you only need to use the length attribute to determine how many parameters are passed when the function is called.

Speaking of which, we can try to write:

Function add (num1, num2) {if (arguments.length = = 1) {alert ("you entered only one number: + arguments [0] +" Please re-enter ");} else if (arguments.length = = 2) {alert (" the sum of the numbers you enter is: "+ arguments [0] + arguments [1]);}}

From this example, we can see that the JavaScript function can react differently by checking the number of parameters passed in the function, which can indirectly achieve the purpose of overloading.

Therefore, JavaScript can mimic the overloading of functions.

At this point, I believe you have a deeper understanding of "how to achieve overloading and default parameters in js simulation". You might as well do it in practice. Here is the website, more related content can enter the relevant channels to inquire, follow us, continue to learn!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.