Retornar mais de um valor de um método

[evsasse]

Exemplo: https://github.com/zygotecnologia/bonuz-api/pull/2968

Vejo três possibilidades:

def example_a
   return 1, 2
end

def example_b
   return [1, 2]
end

def example_c
   return OpenStruct.new(foo: 1, bar: 2)
end

---

Os retornos de example_a e example_b são os mesmos.

example_a # `[1, 2]`
example_b # `[1, 2]`
example_a.class # `Array`
example_b.class # `Array`

---

Se o objetivo é simplesmente fazer a "desestruturação" do valor que está sendo retornado por um método privado da classe, acho a opção example_a mais óbvio.

z, y = example_a

---

Mas se começamos a fazer algo como um ternário com o valor que queremos retornar, não é possível escrever o método como no example_a. Precisamos colocar os [].

def example_d(b)
  return b ? 1,2 : 3,4
# `SyntaxError: unexpected ',', expecting ':'`

def example_d(b)
  return b ? [1,2] : [3,4]
end

z, y = example_d(true)
w, x = example_d(false)

Para tornar isso mais consistente, independente de estarmos fazendo algo como um ternário ou não, acho a opção example_b melhor.

---

Mas, acho as opções example_a e exampl_b apenas válidas para métodos privados de uma classe. Acho estranho dependermos de saber a posição dos retornos dos métodos do lado de fora dela. Para isso acho o example_c mais claro.

class GameStatsCalculator
  def call_a
    goals, winner, ball_possession, fouls
  end

  def call_b
    [goals, winner, ball_possession, fouls]
  end

  def call_c
    OpenStruct.new(goals: goals,
                   winner: winner,
                   ball_possession: ball_possession,
                   fouls: fouls)
  end
  ...
end

[leandroh]

Além dessas 3, gostaria de acrescentar mais uma:

def example_d
   return { foo: 1, bar: 2 }
end

[leandroh]

Também gosto da ideia de sabermos "as chaves" que estão sendo passadas. Assim como uma API, etc.