How do you return two values from a single method?

Question

When your in a situation where you need to return two things in a single method, what is the best approach?

I understand the philosophy that a method should do one t

Answer 1

In the C/C++ world it would actually be quite common to pass two variables by reference (an example, your no. 2).

Answer 2

Python (like Lisp) also allows you to return any number of values from a function, including (but not limited to) none, one, two

def quadcube (x):
     return x**2, x**3

a, b = quadcube(3)

Answer 3

I think it all depends on the scenario.

Thinking from a C# mentality:

1: I would avoid globals as a solution to this problem, as it is accepted as bad practice.

4: If the two return values are uniquely tied together in some way or form that it could exist as its own object, then you can return a single object that holds the two values. If this object is only being designed and used for this method's return type, then it likely isn't the best solution.

3: A collection is a great option if the returned values are the same type and can be thought of as a collection. However, if the specific example needs 2 items, and each item is it's 'own' thing -> maybe one represents the beginning of something, and the other represents the end, and the returned items are not being used interchangably, then this may not be the best option.

2: I like this option the best, if 4, and 3 do not make sense for your scenario. As stated in 3, if you wanted to get two objects that represent the beginning and end items of something. Then I would use parameters by reference (or out parameters, again, depending on how it's all being used). This way your parameters can explicitly define their purpose: MethodCall(ref object StartObject, ref object EndObject)

Answer 4

I would create data transfer objects. If it is a group of information (first and last name) I would make a Name class and return that. #4 is the way to go. It seems like more work up front (which it is), but makes it up in clarity later.

If it is a list of records (rows in a database) I would return a Collection of some sort.

I would never use globals unless the app is trivial.

Answer 5

Personally I try to use languages that allow functions to return something more than a simple integer value.

First, you should distinguish what you want: an arbitrary-length return or fixed-length return.

If you want your method to return an arbitrary number of arguments, you should stick to collection returns. Because the collections--whatever your language is--are specifically tied to fulfill such a task.

But sometimes you just need to return two values. How does returning two values--when you're sure it's always two values--differ from returning one value? No way it differs, I say! And modern languages, including perl, ruby, C++, python, ocaml etc allow function to return tuples, either built-in or as a third-party syntactic sugar (yes, I'm talking about boost::tuple). It looks like that:

tuple<int, int, double> add_multiply_divide(int a, int b) {
  return make_tuple(a+b, a*b, double(a)/double(b));
}

Specifying an "out parameter", in my opinion, is overused due to the limitations of older languages and paradigms learned those days. But there still are many cases when it's usable (if your method needs to modify an object passed as parameter, that object being not the class that contains a method).

The conclusion is that there's no generic answer--each situation has its own solution. But one common thing there is: it's not violation of any paradigm that function returns several items. That's a language limitation later somehow transferred to human mind.

Answer 6

As much as it pains me to do it, I find the most readable way to return multiple values in PHP (which is what I work with, mostly) is using a (multi-dimensional) array, like this:

function doStuff($someThing)
{
    // do stuff
    $status  = 1;
    $message = 'it worked, good job';

    return array('status' => $status, 'message' => $message);
}

Not pretty, but it works and it's not terribly difficult to figure out what's going on.