How Do YOU Handle Functions With Tons o' Variables

mTorbin

Hey all,

I had a question that I thought I'd pose to the group to see what other developers do. Let's say you're writing a function that takes in at least 15 or more variables from different sources (let's not get too specific yet). Do you or don't you do anything special when writing/calling your functions:

function doSomething($apple,$carrot,$banana,$soda,$sugar,$flour,$brocolli,$pear,$grapes,$celeri,$crackers,$beef,$chicken,$fish,$duck) {

}
.
.
.
.
doSomething($apple,$carrot,$banana,$soda,$sugar,$flour,$brocolli,$pear,$grapes,$celeri,$crackers,$beef,$chicken,$fish,$duck);

Does the LOOOOONG string of variables in the parenthesis bother you or not? Inquiring minds want to know!

NogDog

Functionally it makes me nervous. My first thought would be whether or not many/all those things should be packaged up in an object, and that object could be passed as a parameter. Second choice would be to wrap them up into an associative array which could then be passed in.

Stylistically, if stuck with many parameters I prefer to list them line by line when they get to be too much for one line:

function doSomething(
   $arg1,
   $arg2,
   $arg3,
   $arg4,
   $arg5
) {
   // function body...
}

doSomething(
   $red,
   $orange,
   $yellow,
   $green,
   $blue
);

Piranha

I would say that if you need that many variables you have a design flaw in your code. I work in Java, that is 100% object oriented, and normally don't need more than 4 variables. With somewhat correct design I have never had the need to use more than 7 or 8 variables, althrough I have used more with poorly designed methods/functions.

The problem is not now, the problem is when you look in this application a year from now and realize that you can't follow the logic because of all the variables. 3 variables is ok, so is 4. But after that it starts to become tricky to follow the logic.

Another problem with that many variables is that the function tend to do to much. Ideally a function should have one clear function. Let's say that you want to receive a form, validate the inputs and then write it to a database. You should then have one validating function for strings, another for ints and another for doubles, one function for writing to the database, and that function should itself use other functions. Then you call different functions to handle it all.

What you have to ask yourself is: Can I design this in a way that makes the function do just one thing? Is it possible to divide this task into subtasks? Do I need to use all the variables in the function? Can I redesign the function to take less variables?

Installer

That's all good advice from NogDog and Piranha. The first thing I'd explore is, as Piranha implies, whether doSomething() should be renamed to doTooManyThings().

NogDog

Installer;10897526 wrote:
That's all good advice from NogDog and Piranha. The first thing I'd explore is, as Piranha implies, whether doSomething() should be renamed to doTooManyThings().

I think this is one of the things that OOP has helped me with, in part because keeping objects in general and their methods in specific narrowly focused is preached by all the OOP gurus, and in part because OOP gives you the tools to help achieve this aim. (I cannot yet claim to be an OOP expert, but the more I work at learning about it the more I find myself writing better organized code.)

mTorbin

I like the concept of packaging it into an object. There actually is a real world reason I asked this question. I'm in the process writing a script that reads in an RSS feed and creating an XML document (or on some cases several documents) from the contents of that RSS feed. I am passing all of the values of the nodes to the function which is creating the xml and writing the file. The function itself is very small. I guess technically I could declare all of the values I needed as global within the function and pull them in instead of pass them in. Thoughts?

Piranha

Don't use global variables, that is worse than using too many variables. It just gets confusing.

You would be better off creating an object with variables for each of the values. Then pass that object into a function that creates the xml. Then pass the xml into a function that is writing a file. That way you can write different files with that same function. And you can use different functions to create different xml files from the same data. If there is a change in the rss, or in the xml specifications, you can change just one function to change it all.

walterquez

I agree with NogDog and Piranha.

Like Piranha, I think in many cases it is poor programming. There are exception of course, like passing demographic data which has many fields.

If you must pass multiple parameters, like NogDog suggested, pass the parameters in an object or array.

mTorbin

I really appreciate the responses. I've come across this type of situation only once before and I remember thinking there is probably a better way to do this. Glad I found it.

bradgrafelman

Another suggestion I'd like to throw in:

Are all of the variables related in some manner, e.g. were they all gathered from the same source? While you can't do something like:

doSomething($param1 = 'value1', $param2 = 'value2', ...);

in PHP, you can do:

$options = array('param1' => 'value2', 'param2' => 'value2', ... );
doSomething($options);

So for example, if all of these variables contain data you gathered from an RSS feed, then it would make sense to keep them collected as a single associative array.

mTorbin

Yeah, I think for this project I'm going to go the array route though I'm trying to learn the OOP method.

nrg_alpha

Piranha;10897522 wrote:
I would say that if you need that many variables you have a design flaw in your code. I work in Java, that is 100% object oriented, and normally don't need more than 4 variables. With somewhat correct design I have never had the need to use more than 7 or 8 variables, althrough I have used more with poorly designed methods/functions.

The problem is not now, the problem is when you look in this application a year from now and realize that you can't follow the logic because of all the variables. 3 variables is ok, so is 4. But after that it starts to become tricky to follow the logic.

Another problem with that many variables is that the function tend to do to much. Ideally a function should have one clear function. Let's say that you want to receive a form, validate the inputs and then write it to a database. You should then have one validating function for strings, another for ints and another for doubles, one function for writing to the database, and that function should itself use other functions. Then you call different functions to handle it all.

What you have to ask yourself is: Can I design this in a way that makes the function do just one thing? Is it possible to divide this task into subtasks? Do I need to use all the variables in the function? Can I redesign the function to take less variables?

Unless I am misunderstanding something here (and I sense this may be the case), with all due respect, I can't say I completely agree with that is being said here, Piranha.

I can grab an entire season of bowling game stats (3 per night x 72) off of a database and store this as an indexed array. So this can be considered one variable (from the context of all game scores grouped into the array).
But now I may need more variables:

an array for nightly crosses (sum of all 3 games of each night bowled).
an array for nightly averages.
an array that stores + or - difference in nightly averages compared to the previous night's average.
an array for the amount of spares picked up during the night.
an array for amount of strikes picked up during the night.

These are just some examples..(I have 6 variables thus far, with room for more).
I could tackle this issue from multiple points (by storing all these calulations into the database as it is being updated, or store them in objects.. but they all still need to be represented by a variable in one manner or another.

I would imagine that in real sports statistics by example, there is probably a boat-load of variables (even in an assumed well written, well structured system). I'm not desputing on designing things intelligently to reduce 'variable bloat' (as I am in complete agreement with you there), but I do question where the hard number of 4-8 comes from.

Again, I may be misunderstanding something here.. and if so, please fill me in.

Cheers

Weedpacket

nrg_alpha wrote:
Again, I may be misunderstanding something here.. and if so, please fill me in.

Well, the same thing still applies; if they really are all related to each other, then that relationship should be exhibited by the data structure. Conversely, if they're not all related to each other then what are they all doing piling into the one function?

Generally, putting the smarts into the data structure makes for cleaner and more reliable code than a lot of arbitrary variables and lots of code to pull them all together.

Mark_Cunningham

When I use functions I tend to place a few default variables with NULL value in my functions so if I have no need of some the variables placed in the parentheses then it wont cause an error.

Also remember you can use your super global POST GET in there too I know its not best practice but I find it very useful

function some_function($first=null,$second="twice")
{
if($_GET[value])
{
do something
}
}

My humble PHP tutorial site
www.ziggy-design.co.uk

nrg_alpha

Weedpacket;10897631 wrote:
Well, the same thing still applies; if they really are all related to each other, then that relationship should be exhibited by the data structure. Conversely, if they're not all related to each other then what are they all doing piling into the one function?

Generally, putting the smarts into the data structure makes for cleaner and more reliable code than a lot of arbitrary variables and lots of code to pull them all together.

WP, I'm not arguing the idea of creating clean, unified data structure, as this makes sense and good use of coding practices. What I am wondering is why the hard limit of 4 to 8 variables? (again, I like the idea of reduction in variable bloat.. don't get me wrong...) I can also definitly understand how one approaches the deisgn / creation of variables has an impact on things (and we know there are very good coders out there, and very poor ones, [<----- which I lump myself in the latter category, but I digress]).

I would gather that in real world applications (say some form of statistics by example), this imposed limit could easily be busted. Does this mean that the design in question is terrible? I would image not necessarily so. It can still be exceptionally well structured and organized, yet exceed this limit. This is what I was getting at.

mTorbin

The more I think about this, I really think I should pursue an OOP methodology which I am just getting into learning. Thanks for all of the insight.

johnpeace

You'll be glad you did.

Especially when the variables change in a few months and you're having to rewrite it.

Weedpacket

nrg_alpha;10897646 wrote:
WP, I'm not arguing the idea of creating clean, unified data structure, as this makes sense and good use of coding practices. What I am wondering is why the hard limit of 4 to 8 variables? (again, I like the idea of reduction in variable bloat.. don't get me wrong...) I can also definitly understand how one approaches the deisgn / creation of variables has an impact on things (and we know there are very good coders out there, and very poor ones, [<----- which I lump myself in the latter category, but I digress]).

I would gather that in real world applications (say some form of statistics by example), this imposed limit could easily be busted. Does this mean that the design in question is terrible? I would image not necessarily so. It can still be exceptionally well structured and organized, yet exceed this limit. This is what I was getting at.

I at least never said anything about a hard limit. It's perfectly possible to write programs in which no function takes more than one argument. But if you're having to pass a dozen or so arguments then it should be treated as a warning sign suggesting those problems cited may be affecting you.

Your bowling example, for example. You've got an array of all those results. By calculating all those summary statistics and passing piles of results to one function, you've introduced a very strong dependency between the calling function and the called function - to the extent that the latter one probably can't be used anywhere else and then you might as well skip having the function at all.

On the other hand you could just pass the original array to the function and have it calculate the statistics (by calling one function for each set, passing the array to each one in turn).

On the other hand, in an object-oriented environment, those would probably be properties of an object that contains the raw data and also caches those results as they're requested. Or if the data is stored in the database, then the place to calculate them would be in the database.

Remember, too, that we're not just talking about how many variables there are; we're talking about how many parameters a function has. imagecopyresampled($dst_image, $src_image, $dst_x, $dst_y, $src_x, $src_y, $dst_w, $dst_h, $src_w, $src_h) is getting a bit on the bulky side: the standard libraries of most OOP languages (Java, C#, C++) have "Point" and/or "Dimension" or at least subclassable "Pair" objects for storing pairs of coordinates, and if PHP was an OOP language with such a standard library the function signature would look like $dst_image->imagecopyresampled($src_image, $dst_corner, $src_corner, $dst_size, $src_size).

Piranha

nrg_alpha;10897607 wrote:
I'm not desputing on designing things intelligently to reduce 'variable bloat' (as I am in complete agreement with you there), but I do question where the hard number of 4-8 comes from.

There is no hard limit, but it is hard to understand if I say "Use as few as possible", especially for people who are new to OOP. How many are as few as possible? Is it 2 or 10 or 100? The number 4 and 8 is what I regard as a maximum in normal applications, but of course there are always exceptions. The really important thing is to think if there is some way to structure it better when you use more than a couple of variables, the chances are you can. But it is good that you are sceptical (is that how it's spelled?) about what you read, it shows that you have aquired quite a bit of skill and want to learn. 🙂

nrg_alpha;10897607 wrote:
These are just some examples..(I have 6 variables thus far, with room for more).
I could tackle this issue from multiple points (by storing all these calulations into the database as it is being updated, or store them in objects.. but they all still need to be represented by a variable in one manner or another.

You only have half an example here. You have an example with 6 variables that you want to send in to a function, but nowhere you state what the function should do. Please provide me with a description of what the function does and I'll have the possibility to respond to that part of the question as well.

nrg_alpha

@ Piranha & Weedpacket

Both of you mention passing a massive collection of variables through a function. I wasn't actually referfing to functions and passing variables, just the potential need to create more variables, and kept wondering why you guys brought that up (but I just realised that the initial post contains a function passing many variables, so I now understand). Sorry for the misunderstanding. So yes, I do agree with you guys that if something is structured in such a way as to need passing large amounts of variables through a function, it makes one question the design and will inevitably lead to rethinking one's strategy.

As for the term hard limit.. this is admittedly a very bad choice of words on my part, as no one ever said anything about hard limits... I simply took the 4-8 maximum variables and just termed it that way.. My mistake. I was just rather taken back a little by 'restricting one's self to a finite number of variables' (that sounds better than 'hard limits').

I do understand that coming up with a design that intelligently uses the least amount of data to perform the job well is just good'ol coding practice. This mentality is pretty much universal within computing in general it seems, from game engine code to the amount of polygons that make up a character to websites and such... Make it as efficient as possible by using the leanest methods possible.

So in closing;
a) it's spelled skeptical 😉
b) just out of curiosity WP, do you not structure function names like imagecopyresampled as imageCopyResampled? The former makes my eyes backtrack a bit to make sure I read it properly.