No, there is no standard guideline
But there are some techniques that can make a function with a lot of parameters more bearable.
You could use a list-if-args parameter (args*) or a dictionary-of-args parameter (kwargs
For instance, in python:
// Example definition
def example_function(normalParam, args*, kwargs**):
for i in args:
print 'args' + i + ': ' + args[i]
for key in kwargs:
print 'keyword: %s: %s' % (key, kwargs[key])
somevar = kwargs.get('somevar','found')
missingvar = kwargs.get('somevar','missing')
// Example usage
example_function('normal parameter', 'args1', args2,
Or you could use object literal definition syntax
If you take a look at jQuery's ajax class there are a lot (approximately 30) more properties that can be set; mostly because ajax communications are very complex. Fortunately, the object literal syntax makes life easy.
C# intellisense provides active documentation of parameters so it's not uncommon to see very complex arrangements of overloaded methods.
I prefer object literal definitions (even in C#) for managing complex methods because you can explicitly see which properties are being set when an object is instantiated. You'll have to do a little more work to handle default arguments but in the long run your code will be a lot more readable. With object literal definitions you can break your dependence on documentation to understand what your code is doing at first glance.
IMHO, overloaded methods are highly overrated.
Note: If I remember right readonly access control should work for object literal constructors in C#. They essentially work the same as setting properties in the constructor.
It's can be scary first to break your reliance on parameters for the end-all, be-all approach to function/method initialization but you will learn to do so much more with your code without having to add unnecessary complexity.
I probably should have provided examples to demonstrate use in a statically typed language but I'm not currently thinking in a statically typed context. Basically, I've been doing too much work in a dynamically typed context to suddenly switch back.
What I do know is object literal definition syntax is completely possible in statically typed languages (at least in C# and Java) because I have used them before. In statically typed languages they're called 'Object Initializers'. Here are some links to show their use in Java and C#.