Não, não há nenhuma diretriz padrão
Mas existem algumas técnicas que podem tornar uma função com muitos parâmetros mais suportáveis.
Você pode usar um parâmetro list-if-args (args *) ou um parâmetro dictionary-of-args (kwargs **
)
Por exemplo, em 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')
print somevar
print missingvar
// Example usage
example_function('normal parameter', 'args1', args2,
somevar='value', missingvar='novalue')
Saídas:
args1
args2
somevar:value
someothervar:novalue
value
missing
Ou você pode usar a sintaxe de definição literal do objeto
Por exemplo, aqui está uma chamada JavaScript jQuery para iniciar uma solicitação AJAX GET:
$.ajax({
type: 'GET',
url: 'http://someurl.com/feed',
data: data,
success: success(),
error: error(),
complete: complete(),
dataType: 'jsonp'
});
Se você der uma olhada na classe ajax do jQuery, há um lote (aproximadamente 30) mais propriedades que podem ser definidas; principalmente porque as comunicações ajax são muito complexas. Felizmente, a sintaxe literal do objeto facilita a vida.
O intellisense C # fornece documentação ativa de parâmetros, portanto não é incomum ver arranjos muito complexos de métodos sobrecarregados.
Linguagens dinamicamente tipificadas como python / javascript não têm essa capacidade, por isso é muito mais comum ver argumentos de palavra-chave e definições de literal de objeto.
Eu prefiro definições literais de objeto ( mesmo em C # ) para gerenciar métodos complexos porque você pode ver explicitamente quais propriedades estão sendo definidas quando um objeto é instanciado. Você terá que fazer um pouco mais de trabalho para lidar com argumentos padrão, mas no longo prazo seu código será muito mais legível. Com as definições de literal de objeto, você pode quebrar sua dependência de documentação para entender o que seu código está fazendo à primeira vista.
IMHO, os métodos sobrecarregados são altamente superestimados.
Nota: Se bem me lembro direito readonly controle de acesso deve funcionar para construtores de literal de objeto em c #. Eles essencialmente funcionam da mesma forma que as propriedades de configuração no construtor.
Se você nunca escreveu nenhum código não-trivial em uma linguagem baseada em javaScript dinamicamente tipificada (python) e / ou funcional / prototype, sugiro experimentá-lo. Pode ser uma experiência esclarecedora.
Pode ser assustador primeiro quebrar sua confiança em parâmetros para a abordagem final, tudo, para a inicialização de função / método, mas você aprenderá a fazer muito mais com seu código sem precisar adicionar complexidade desnecessária.
Atualização:
Provavelmente deveria ter fornecido exemplos para demonstrar o uso em uma linguagem de tipagem estática, mas não estou pensando em um contexto estaticamente tipado. Basicamente, tenho trabalhado muito em um contexto digitado dinamicamente para voltar de repente.
O que eu faço sabe é que a sintaxe de definição literal do objeto é completamente possível em linguagens estaticamente tipadas (pelo menos em C # e Java) porque as usei antes. Em linguagens estaticamente tipadas, elas são chamadas de 'Inicializadores de objeto'. Aqui estão alguns links para mostrar seu uso em Java e C # .