Retornando Valores de uma Função - JavaScript

Uma função pode retornar um resultado. Para isso, é utilizado o operador return, após o qual é especificado o valor de retorno:

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

Neste caso, a função sum() recebe dois parâmetros e retorna a soma deles. Após o operador return, segue o valor de retorno. Neste exemplo, é o valor da constante result, mas na realidade pode ser qualquer expressão, inclusive o resultado de outra função.

Após obter o resultado da função, podemos atribuí-lo a outra variável ou 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

Uma função pode retornar apenas um valor. Se precisarmos retornar vários valores, podemos fazê-lo na forma de um array:

function rectangle(width, height) {
    const perimeter = width * 2 + height * 2;
    const area = width * height;
    return [perimeter, area];
}
 
const rectangleData = rectangle(20, 30);
console.log(rectangleData[0]);  // 100 - perímetro do retângulo
console.log(rectangleData[1]);  // 600 - área do retângulo

Neste caso, a função rectangle recebe a largura e a altura do retângulo e, internamente, calcula o perímetro e a área do retângulo e retorna esses dados em forma de array.

Como alternativa, podemos colocar vários dados de retorno em um único objeto:

function rectangle(width, height) {
    const rectPerimeter = width * 2 + height * 2;
    const rectArea = width * height;
    return {perimeter: rectPerimeter, area: rectArea};
}
 
const rectangleData = rectangle(20, 30);
console.log("Perimeter:", rectangleData.perimeter);  // 100 - perímetro do retângulo
console.log("Area:", rectangleData.area);  // 600 - área do retângulo

Retorno de Função a partir de uma Função

Uma função pode retornar outra função:

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);         // selecionamos a primeira opção - adição
const result = action(2, 5);    // executamos a função e obtemos o resultado na constante result
console.log(result);            // 7

Neste caso, a função menu() retorna uma das três funções ou uma função vazia que simplesmente retorna 0, dependendo do valor passado para ela.

Continuamos chamando a função menu e obtendo o resultado desta função: outra função na constante action.

const action = menu(1);
const result = action(2, 5);

Podemos obter outras funções retornáveis de maneira semelhante:

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

De forma semelhante, podemos retornar funções por nome:

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