Rezultatul funcției

Funcția poate returna un rezultat. Pentru acest lucru se utilizează instrucțiunea return, după care se specifică valoarea returnată:

function sum (a, b) {
   const result = a + b;
   return result;
}

În acest caz, funcția sum() primește doi parametri și returnează suma lor. După instrucțiunea return, urmează valoarea returnată. În acest caz, este valoarea constantei result, în realitate, aceasta poate fi orice expresie, inclusiv rezultatul unei alte funcții.

După obținerea rezultatului funcției, îl putem atribui unei alte variabile sau constante:

function sum (a, b) {
 return a + b;
}
let num1 = sum(2, 4);
console.log(num1);  // 6

const num2 = sum(6, 34);
console.log(num2);  // 40

Funcția poate returna doar o singură valoare. Dacă dorim să returnăm mai multe valori, le putem returna sub formă de array:

function rectangle(width, height) {
   const perimetru = width* 2 + height* 2;
   const arie = width* height;
   return [perimetru, arie];
}

const dateDreptunghi = rectangle(20, 30);
console.log(dateDreptunghi[0]);  // 100 - perimetrul dreptunghiului
console.log(dateDreptunghi[1]);  // 600 - aria dreptunghiului

În acest exemplu, funcția `rectangle` primește lățimea și înălțimea unui dreptunghi, iar în interiorul funcției, pe baza acestor date, se calculează perimetrul și aria, returnându-le sub formă de array.

Ca alternativă, putem plasa datele multiple într-un singur obiect:

function rectangle(width, height) {
   const perimetru = width* 2 + height* 2;
   const arie = width* height;
   return {perimetru: perimetru, arie: arie};
}

const dateDreptunghi = rectangle(20, 30);
console.log("Perimetru:", dateDreptunghi.perimetru);  // 100 - perimetrul dreptunghiului
console.log("Arie:", dateDreptunghi.arie);  // 600 - aria dreptunghiului

Revenirea unei funcții dintr-o funcție

O funcție poate returna o altă funcție:

function menu(n){
   if(n==1) return function(x, y){ return x + y;}
   else if(n==2) return function(x, y){ return x - y;}
   else if(n==3) return function(x, y){ return x * y;}
   return function(){ return 0;}
}

const action = menu(1);         // alegem prima opțiune - adunarea
const result = action(2, 5);    // apelăm funcția și obținem rezultatul în constanta result
console.log(result);            // 7

În acest caz, funcția menu() returnează una dintre cele trei funcții sau o funcție goală, care pur și simplu returnează numărul 0, în funcție de valoarea transmisă. Ulterior, apelăm funcția menu și obținem rezultatul acestei funcții - o altă funcție în constanta action.

const action = menu(1);

Deci, aici, action va reprezenta o funcție care primește doi parametri și returnează un număr. Apoi, prin intermediul numelui constantei, putem apela această funcție și obține rezultatul în constanta result:

const result = action(2, 5);

Similar, putem obține și alte funcții returnate.

function menu(n){
 
   if(n==1) return function(x, y){ return x + y;}
   else if(n==2) return function(x, y){ return x - y;}
   else if(n==3) return function(x, y){ return x * y;}
   return function(){ return 0;};
}

let action = menu(1);
console.log(action(2, 5));          // 7

action = menu(2);
console.log(action(2, 5));          // -3

action = menu(3);
console.log(action(2, 5));          // 10

action = menu(190);
console.log(action(2, 5));          // 0

La fel, poți returna funcții folosind un nume:

function sum(x, y){ return x + y;}
function subtract(x, y){ return x - y;}
function multiply(x, y){ return x * y;}
function zero(){ return 0;}

function menu(n){
 
   switch(n){
       case 1: return sum;
       case 2: return subtract;
       case 3: return multiply;
       default: return zero;
   }
   
}
 
let action = menu(1);
console.log(action(5, 4));          // 9
 
action = menu(2);
console.log(action(5, 4));          // 1
 
action = menu(3);
console.log(action(5, 4));          // 20
 
action = menu(190);
console.log(action(5, 4));          // 0