Retornando Valores de uma Função em 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