Are formal parameters greater than actual parameters in JavaScript?

In JavaScript, function parameters are a very important part. When a function is called, you can pass arguments to change the function's behavior. But what happens if your function parameters are larger than the actual parameters? In this article, we will explore this issue and address some of the issues that may arise.

First, let's look at a simple function example that has two parameters:

function add(a, b) {
  return a + b;
}

In this example, we define a function named "add", which The function accepts two parameters a and b and returns their sum.

Now, if we call this function and pass two parameters as follows:

add(2, 4);

Then, we will get a result which is 6. This is because we called the "add" function and passed two parameters, they were added and the result was returned.

But what happens if we call this function but pass only one parameter?

add(2);

In this case, parameter "a" will be assigned as 2, but "b" has no parameters passed. In this case, the value of "b" will be undefined, and the sum of "a" and "b" will be NaN. This is because in JavaScript, adding any numeric value to undefined will return NaN.

Now, if we redefine the "add" function to have only one parameter (i.e. a) as follows:

function add(a) {
  return a + 2;
}

Then try to call it again:

add(2, 4);

In this case, the problem of actual parameters being greater than formal parameters does not exist. Even if we pass two parameters, the JavaScript engine will only accept the first parameter.

However, in some cases, the function definition may have larger parameters than you want to pass. In this case, you might be wondering how JavaScript handles the case where the actual parameter is smaller than the formal parameter.

When the actual parameter is smaller than the formal parameter, the unpassed parameter will be assigned as undefined. This is because in JavaScript, function parameters have a default value of undefined. When you pass only part of the parameters, the unpassed parameters will automatically be assigned undefined. For example:

function add(a, b, c) {
  return a + b + c;
}
add(2);

In this example, we defined a function "add" that accepts three parameters, but we only passed one parameter. b and c will automatically be assigned undefined, and their sum will be NaN.

However, in some cases, you may want to know how to handle the case where the actual parameter is smaller than the formal parameter. JavaScript beginners may not know how to solve this problem, but there are some tricks you can use. Here are some of them:

1. Use default parameters:

In ES6, you can use default parameters to provide default values ​​for function definitions. Default parameters are attributes within parentheses added when defining a function. When the actual parameters are smaller than the formal parameters, the unpassed parameters will use the predefined default values. For example:

function add(a, b = 0, c = 0) {
  return a + b + c;
}
add(2);

In this example, we have provided a default value of 0 for the b and c parameters, so when we pass only one parameter, the return value will be 2.

2. Check whether the parameters are undefined:

To avoid NaN, you can check whether all parameters are undefined in the function body. You can then try them as needed. For example:

function add(a, b, c) {
  if (a === undefined) a = 0;
  if (b === undefined) b = 0;
  if (c === undefined) c = 0;
  return a + b + c;
}
add(2);

In this case, when we pass only one parameter, the function will automatically assign a as 2, while b and c will be assigned as 0. The result returned will be 2.

Conclusion

So, in the JavaScript environment, when the formal parameter is greater than the actual parameter, the unpassed parameter will be assigned to undefined. When the actual parameters are smaller than the formal parameters, unpassed parameters will also be assigned undefined. If you don't want NaNs in these cases, consider using default parameters or a trick that checks if the parameter is undefined.

The above is the detailed content of Are formal parameters greater than actual parameters in JavaScript?. For more information, please follow other related articles on the PHP Chinese website!