THE PARAMETERS OF THE FUNCTIONS

ARGUMENTS, REST AND SPREAD

Parameters passed to a function are also available through the arguments object, it is an array-like object with which it is possible to access the elements passed as input. The following code clarifies this topic.

Copy to Clipboard

<!DOCTYPE html>
<html lang="it">
<head>
    <meta charset="UTF-8">
    <title>Arguments Rest and spread</title>
</head>
<body>
    <script type="rocketlazyloadscript">
        function test()
        {
            for(let param of arguments){
                console.log(param);
            }

}
        test(2,'Ciao',true);
        function calcola(a,b){
            console.log(a + b);
        }
        calcola(10,20,30,40);
        /*--Se passiamo più parametri di quelli che si aspetta la funzione
        semplicemente quelli eccedenti verranno ignorati. A volte in fase di definizione
        di una funzione non è possibile stabilire quanti parametri riceveremo
        in input. A tal proposito ci viene in aiuto l'identificatore rest ...*/
        function rest(p1,p2, ...numeri){
            let somma = 0;
            for(let numero of numeri){
                somma+=numero;
            }
            console.log('La somma dei parametri in input è: ' + (somma + p1 + p2));
        }
        rest(10,5,20,30);
        /*--Possiamo anche definire uno o più parametri in input, nell'esempio p1,p2. Il primo
        parametro conserverà il primo valore passato in input, 
        il secondo conserverà il secondo parametro passato in input e così via. rest
        tutti gli altri. A volte potrebbe esserci la necessità opposta, cioè ad esempio abbiamo 
        un array da passare ad una funzione che però non accetta array ma una serie
        di valori. Facciamo un esempio.*/
        let a = [10,20,20,1,4];
        let min = Math.min(...a);
        console.log('Minimo: ' + min);
        //... si chiama spread operator e può esssere usato anche 
        //per unire due array.
        let b = [1,2,3];
        let c = [4,5,6];
        let d = [...b, ...c];
        console.log(d);
    </script>
</body>
</html>

THE PARAMETERS OF THE FUNCTIONS

A JavaScript function does not perform any checks on parameter values (arguments). Earlier in this tutorial,

you learned that functions can have parameters:

function functionName(parameter1, parameter2, parameter3) {
// code to be executed
}

The function parameters are the names listed in the function definition. The arguments to the function are the real values passed (and received) by the function.

RULES OF PARAMETERS

The JavaScript function definitions do not specify data types for parameters. JavaScript functions do not perform type checking on passed arguments and do not check the number of arguments received.

DEFAULT PARAMETERS

If a function is called with missing arguments (fewer 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:

function myFunction(x, y) {
if (y === undefined) {
y = 2;
}
}

ECMAScript 2015 allows default parameter values in the function declaration:

function myFunction(x, y = 2) {
// function code
}

DEEPENING OF ARGUMENTS OBJECT

JavaScript functions have a built-in object called argument object. It contains an array of arguments used when the function was called (invoked). This way you can simply use a function to find (for example) the highest value in a list of numbers:

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;
}

let’s see another 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.

THE JAVASCRIPT LANGUAGE

LINK TO THE CODE ON GITHUB

GITHUB

THE PARAMETERS OF THE FUNCTIONS

ARGUMENTS, REST AND SPREAD