Parametrii funcției

Funcția în JavaScript poate primi parametri. Parametrii reprezintă modul de transmitere a datelor către o funcție. Parametrii sunt specificați în paranteze după numele funcției.

De exemplu, să definim o funcție simplă care primește un singur parametru:

function print(message){
   console.log(message);
}

print("Hello JavaScript");
print("Hello FDC.COM");
print("Function in JavaScript");

Funcția print() primește un singur parametru - message. Prin urmare, la apelul funcției, putem furniza o valoare pentru acesta, de exemplu, un șir de caractere:

print("Hello JavaScript");

Valorile transmise parametrilor sunt numite și argumente.

Spre deosebire de unele limbaje de programare, în principiu, nu suntem obligați să transmitem valori parametrilor în JavaScript. De exemplu:

function print(message){
   console.log(message);
}
print();

Dacă nu se furnizează o valoare parametrului, acesta va avea valoarea undefined.

Dacă o funcție primește mai mulți parametri, aceștia sunt enumerați prin virgulă:

function sum(a, b){
   const result = a + b;
   console.log(result);
}

sum(2, 6);          // 8
sum(4, 5);          // 9
sum(109, 11);       // 120

La apelul funcției cu mai mulți parametri, valorile sunt transmise parametrilor pe baza poziției. Cu alte cuvinte, prima valoare este transmisă primului parametru, a doua valoare - celui de-al doilea, și tot așa. De exemplu, în apelul:

sum(2, 6);

Numărul 2 este transmis parametrului a, iar numărul 6 - parametrului b.

Transmiterea unui array ca parametru și operatorul spread

Este convenabil să ținem datele legate de ceva într-un array. Și, eventual, ne-ar putea fi necesar să transmitem întregul set de date către o funcție. În general, putem transmite un array ca parametru și în interiorul funcției să ne referim la elementele sale:

function printPerson(person) {
   console.log("Nume:", person[0]);
   console.log("Vârstă:", person[1]);
   console.log("Email:", person[2]);
   console.log("=========================");
}

const tom = ["Tom", 39, "tom@example.com"];
const bob = ["Bob", 43, "bob@example.com"];

printPerson(tom);
printPerson(bob);

În acest caz, funcția printPerson primește un array, care se presupune că are trei elemente. Și în interiorul funcției are loc referirea la aceste elemente.

Dar să examinăm o altă situație, când funcția primește date sub formă de parametri separați. În acest caz, este mai convenabil să utilizăm operatorul spread:

function printPerson(username, age, email) {
   console.log("Nume:", username);
   console.log("Vârstă:", age);
   console.log("Email:", email);
   console.log("=========================");
}

const tom = ["Tom", 39, "tom@example.com"];
const bob = ["Bob", 43, "bob@example.com"];

printPerson(...tom);
printPerson(...bob);

Pentru a transmite în mod consecutiv elementele array-ului ca parametri pentru funcție, înaintea numelui array-ului se specifică operatorul spread:

printPerson(...tom);

Acest lucru este echivalent cu a scrie:

printPerson(tom[0], tom[1], tom[2]);

Doar că operatorul spread permite o transmitere mai concisă a valorilor.

Parametri opționali și valori implicite

O funcție poate să primească mai mulți parametri, dar unele sau toate acestea pot fi opționale. Dacă nu se furnizează valori pentru parametri, atunci implicit aceștia vor avea valoarea "undefined". Cu toate acestea, uneori este necesar ca parametrii să aibă cu siguranță anumite valori, cum ar fi valori implicite. Înainte de standardul ES6, era nevoie să verificăm valorile parametrilor pentru a vedea dacă sunt "undefined":

function sum(x, y){
   if(y === undefined) y = 5;
   if(x === undefined) x = 8;
   const z = x + y;
   console.log(z);
}

sum();          // 13
sum(6);         // 11
sum(6, 4)       // 10

Aici, funcția sum() primește doi parametri. La apelul funcției, putem verifica valorile lor. Cu toate acestea, la apelul funcției, nu este necesar să furnizăm valori pentru acești parametri. Pentru a verifica existența valorilor parametrilor, se folosește comparația cu "undefined".

De asemenea, putem defini direct valori implicite pentru parametri:

function sum(x = 8, y = 5){
   const z = x + y;
   console.log(z);
}

sum();      // 13
sum(6);     // 11
sum(6, 4)   // 10

Dacă nu se furnizează valori pentru parametrii x și y, aceștia vor primi valorile 5 și, respectiv, 10. Acest mod de a face lucrurile este mai concis și intuitiv decât comparația cu "undefined".

În același timp, valoarea implicită a parametrului poate fi derivată și poate reprezenta o expresie:

function sum(x = 8, y = 10 + x){
   const z = x + y;
   console.log(z);
}

sum();      // 26
sum(6);     // 22
sum(6, 4)   // 10

În acest caz, valoarea parametrului y depinde de valoarea lui x.

Funcții cu un număr arbitrar de parametri

JavaScript permite definirea așa-numitelor funcții variadice sau funcții cu un număr arbitrar de parametri. Pentru aceasta, se pot utiliza câteva instrumente.

Obiectul arguments

Dacă este necesar, putem obține toți parametrii furnizați prin intermediul obiectului arguments, disponibil în interiorul funcției:

function sum(){
   let result = 0;
   for(const n of arguments)
       result += n;
   console.log(result);
}
sum(6);             // 6
sum(6, 4)           // 10
sum(6, 4, 5)        // 15

În acest caz, nu contează dacă am specificat sau nu parametri la definirea funcției; oricum putem furniza parametri și să le obținem valorile prin intermediul obiectului arguments.

În plus, putem să definim parametrii explicit:

function sum(a, b, c){
   console.log("a =", a);
   console.log("b =", b);
   console.log("c =", c);

   let result = 0;
   for(const n of arguments)
       result += n;
   console.log("result =", result);
}
sum(6, 4, 5, 8)     // 23

Cu toate că funcția este definită să primească doar 3 parametri, putem furniza un număr mai mare de argumente și să le obținem prin intermediul array-ului arguments. Rezultatul afișat în consolă:

a = 6
b = 4
c = 5
result = 23

Deși putem itera obiectul arguments ca pe un array, acesta nu este un array. Chiar dacă putem obține lungimea folosind proprietatea length și să accesezi argumentele furnizate funcției folosind un index:

function sum(nums){
   let result = 0;  // rezultatul funcției
   if(arguments.length >=1)     // dacă este furnizat cel puțin un parametru
   {    
       result = result + arguments[0]; // accesează primul parametru
   }
   if(arguments.length >=2) // dacă sunt furnizate cel puțin două parametri
   {    
       result = result + arguments[1]; // accesează al doilea parametru
   }
   console.log("result =", result);
}

sum(6)          // result = 6
sum(6, 5)       // result = 11
sum(6, 5, 4)    // result = 11 - al treilea parametru nu este luat în considerare

Operatorul rest (...)

Operatorul rest (...) poate fi folosit pentru a transmite un număr variabil de valori:

function sum(...numbers){
   let result = 0;
   for(const n of numbers)
       result += n;
   console.log(result);
}
sum(6, 4, 5)     // 15

În acest caz, parametrul ...numbers indică faptul că în locul său pot fi transmise diferite cantități de valori. În funcție, numbers reprezintă efectiv un array al valorilor transmise, pe care le putem obține. Cu toate acestea, în ciuda acestui fapt, atunci când apelăm funcția, nu transmitem un array, ci valori individuale.

Astfel de parametri rest pot fi combinați cu parametri obișnuiți:

function display(season, ...temps){
   console.log(season);
   for(index in temps){
       console.log(temps[index]);
   }
}
display("Primăvara", -2, -3, 4, 2, 5);
display("Vara", 20, 23, 31);

Aici, prima valoare transmisă funcției va fi interpretată ca valoare pentru parametrul season, iar toate celelalte valori vor merge către parametrul temps.

Ieșirea în consolă:

Primăvara -2 -3 4 2 5 Vara 20 23 31

Matrice ca parametru

A treia modalitate de a transmite o cantitate nedeterminată de date presupune transmiterea acestora printr-un parametru de tip matrice. Cu toate că formal avem un singur parametru (numărul de parametri este definit), totuși cantitatea specifică de date în această matrice este nedeterminată (la fel ca și în cazul array-ului arguments):

function sum(numbers){
   let result = 0;
   for(const n of numbers)
       result += n;
   console.log("result =", result);
}
const nums = [6, 4, 5, 8];
sum(nums)     // result = 23

Funcțiile în calitate de parametri

Funcțiile pot servi drept parametri pentru alte funcții:

function sum(x, y){
   return x + y;
}

function subtract(x, y){
   return x - y;
}

function operation(x, y, func){
 
   const result = func(x, y);
   console.log(result);
}

console.log("Sum");
operation(10, 6, sum);  // 16

console.log("Subtract");
operation(10, 6, subtract); // 4

Funcția operation primește trei parametri: x, y și func. func reprezintă o funcție, iar la momentul definirii funcției operation nu este important ce fel de funcție este aceasta. Singurul lucru cunoscut este că funcția func poate să primească doi parametri și să returneze o valoare, care este apoi afișată în consola browser-ului. Prin urmare, putem defini diverse funcții (de exemplu, funcțiile sum și subtract în acest caz) și să le pasăm în apelul funcției operation.