Javascript parameter types in function

Functions can have parameters, of course they can also not have

1 functionName(parameter1, parameter2, parameter3)  2 Code to be executed 3 >

Function parameters (parameter)Refers to those listed in the function definitionname。

Function parameter (argument)Refers to the actual value passed to or received by the functionvalue。

Parameter rules

JavaScript function definitions do not specify data types for parameters.

The JavaScript function does not perform type checking on the passed argument (argument).

The JavaScript function does not check the number of arguments it accepts.

Parameter default

If the parameter is omitted (less than the number declared) when calling the parameter, the missing value is set to:undefined。

This is possible, but it is better to assign default values to the parameters. The following example checks that if the parameters are not defined, assign default values:

1 function myFunction(x, y)  2 if (y === undefined)  3 y = 0; 4 > 5 >

If you call too many parameters (more than declared), for example, your function defines two parameters (a, b) but when you call this, you enter three parameters (1, 2, 3), one more than the original , This is also allowed; since you can lose more, of course you can also lose less. If only one actual parameter (1) is input, then a = 1, b will have no value, it is aundefined, This is also mentioned above, this one will be emphasized again. But only the first two values will be taken, that is, a=1, b=2, and 3 is not required. How can you manipulate it to 3? can useargumentsObject to manipulate these parameters.

arguments object

JavaScript functions have a built-in object called the arguments object.

The arguments object contains an array of parameters used in the function call.

In this way, you can easily use this array to manipulate the actual parameters in the parameters.

The following is to find out the parametersmaximumValue:

 1 x = findMax(1, 123, 500, 115, 44, 88); 2 3 function findMax()  4 var i; 5 var max = -Infinity; 6 for (i = 0; i < arguments.length; i++)  7 if (arguments[i] > max)  8 max = arguments[i]; 9 > 10 > 11 return max; 12 >

As for what -Infinity is, Infinity is a constant in JavaScript.The text means: infinite.If it exceeds the range represented by JavaScript, I remember it seems to be the range of 64-bit binary numbers, and use it to represent it, and then add a minus sign in front, and the big numbers will become very small numbers. Since arguments is an array, it can definitely use the attribute of the array, here the attribute of the array length is used: length.

Let’s take a look again, create a function to calculate the sum of the parameters:

1 x = sumAll(1, 123, 500, 115, 44, 88); 2 3 function sumAll()  4 var i, sum = 0; 5 for (i = 0; i < arguments.length; i++)  6 sum += arguments[i]; 7 > 8 return sum; 9 >

Parameters are passed by value

The parameter in the function call is the argument of the function.

JavaScript parameters passvaluePassing: The function only knows the value, not the location of the parameter.

If the function changes the value of the parameter, it will not change the original value of the parameter.

The parameter changes are not visible outside the function.

Objects are passed by reference

In JavaScript, object references are values.

Because of this, objects behave like they passQuoteTo pass:

If the function changes the object properties, it also changes the original value.

Changes in object properties are visible outside the function.

Источник

JavaScript Function Parameters

A JavaScript function does not perform any checking on parameter values (arguments).

Function Parameters and Arguments

Earlier in this tutorial, you learned that functions can have parameters:

Function parameters are the names listed in the function definition.

Function arguments are the real values passed to (and received by) the function.

Parameter Rules

JavaScript function definitions do not specify data types for parameters.

JavaScript functions do not perform type checking on the passed arguments.

JavaScript functions do not check the number of arguments received.

Default Parameters

If a function is called with missing arguments (less than declared), the missing values are set to undefined .

Sometimes this is acceptable, but sometimes it is better to assign a default value to the parameter:

Example

Default Parameter Values

ES6 allows function parameters to have default values.

Example

If y is not passed or undefined, then y = 10.

Function Rest Parameter

The rest parameter (. ) allows a function to treat an indefinite number of arguments as an array:

Example

function sum(. args) <
let sum = 0;
for (let arg of args) sum += arg;
return sum;
>

let x = sum(4, 9, 16, 25, 29, 100, 66, 77);

The Arguments Object

JavaScript functions have a built-in object called the arguments object.

The argument object contains an array of the arguments used when the function was called (invoked).

This way you can simply use a function to find (for instance) the highest value in a list of numbers:

Example

x = findMax(1, 123, 500, 115, 44, 88);

function findMax() let max = -Infinity;
for (let i = 0; i < arguments.length; i++) if (arguments[i] > max) max = arguments[i];
>
>
return max;
>

Or create a function to sum all input values:

Example

x = sumAll(1, 123, 500, 115, 44, 88);

function sumAll() let sum = 0;
for (let i = 0; i < arguments.length; i++) sum += arguments[i];
>
return sum;
>

If a function is called with too many arguments (more than declared), these arguments can be reached using the arguments object.

Arguments are Passed by Value

The parameters, in a function call, are the function’s arguments.

JavaScript arguments are passed by value: The function only gets to know the values, not the argument’s locations.

If a function changes an argument’s value, it does not change the parameter’s original value.

Changes to arguments are not visible (reflected) outside the function.

Objects are Passed by Reference

In JavaScript, object references are values.

Because of this, objects will behave like they are passed by reference:

If a function changes an object property, it changes the original value.

Changes to object properties are visible (reflected) outside the function.

Источник