Funções de linha única chamadas apenas uma vez

Considere uma função sem parâmetros ( editar: não necessariamente) que executa uma única linha de código e é chamada apenas uma vez no programa (embora não seja impossível que seja necessário novamente no futuro).

Pode realizar uma consulta, verificar alguns valores, fazer algo que envolva regex ... qualquer coisa obscura ou "hacky".

A lógica por trás disso seria evitar avaliações dificilmente legíveis:

if (getCondition()) {
    // do stuff
}

Onde getCondition()é a função de uma linha.

Minha pergunta é simples: essa é uma boa prática? Parece bom para mim, mas não sei a longo prazo ...

Depende dessa linha. Se a linha é legível e concisa por si só, a função pode não ser necessária. Exemplo simplista:

void printNewLine() {
  System.out.println();
}

OTOH, se a função der um bom nome a uma linha de código que contém, por exemplo, uma expressão complexa e de difícil leitura, é perfeitamente justificada (para mim). Exemplo artificial (dividido em várias linhas para facilitar a leitura aqui):

boolean isTaxPayerEligibleForTaxRefund() {
  return taxPayer.isFemale() 
        && (taxPayer.getNumberOfChildren() > 2 
        || (taxPayer.getAge() > 50 && taxPayer.getEmployer().isNonProfit()));
}

Sim, isso pode ser usado para satisfazer as melhores práticas. Por exemplo, é melhor que uma função com nome claro faça algum trabalho, mesmo que tenha apenas uma linha, do que ter essa linha de código em uma função maior e precisar de um comentário em uma linha explicando o que faz. Além disso, as linhas de código vizinhas devem executar tarefas no mesmo nível de abstração. Um contraexemplo seria algo como

startIgnition();
petrolFlag |= 0x006A;
engageChoke();

Nesse caso, é definitivamente melhor mover a linha do meio para uma função com nome sensato.

Eu acho que, em muitos casos, essa função é de bom estilo, mas você pode considerar uma variável booleana local como alternativa nos casos em que você não precisa usar essa condição em algum lugar em outros lugares, por exemplo:

bool someConditionSatisfied = [complex expression];

Isso dará uma dica para o leitor de código e evitará a introdução de uma nova função.

Além da resposta de Peter , se essa condição precisar ser atualizada em algum momento no futuro, encapsulando a maneira como você sugere que você teria apenas um único ponto de edição.

Seguindo o exemplo de Pedro, se este

boolean isTaxPayerEligibleForTaxRefund() {
  return taxPayer.isFemale() 
        && (taxPayer.getNumberOfChildren() > 2 
        || (taxPayer.getAge() > 50 && taxPayer.getEmployer().isNonProfit()));
}

torna-se isso

boolean isTaxPayerEligibleForTaxRefund() {
  return taxPayer.isMutant() 
        && (taxPayer.getNumberOfThumbs() > 2 
        || (taxPayer.getAge() > 123 && taxPayer.getEmployer().isXMan()));
}

Você faz uma única edição e é atualizada universalmente. Manutenção sábio, este é um plus.

Em termos de desempenho, a maioria dos compiladores otimizadores removerá a chamada de função e alinhará o pequeno bloco de código de qualquer maneira. A otimização de algo assim pode reduzir o tamanho do bloco (excluindo as instruções necessárias para a chamada de função, retorno, etc.), portanto é normalmente seguro fazer isso mesmo em condições que poderiam impedir a inclusão.

Além da legibilidade (ou em complemento), isso permite escrever funções no nível adequado de abstração.

Depende. Às vezes, é melhor encapsular uma expressão em uma função / método, mesmo que seja apenas uma linha. Se é complicado ler ou você precisar dele em vários lugares, considero uma boa prática. A longo prazo, é mais fácil manter, pois você introduziu um único ponto de mudança e melhor legibilidade .

No entanto, às vezes é apenas algo que você não precisa. Quando a expressão é fácil de ler de qualquer maneira e / ou aparece em um só lugar, não a envolva.

Eu acho que se você tiver apenas alguns deles, tudo bem, mas o problema surge quando há muitos deles no seu código. E quando o compilador é executado ou o interpitor (dependendo do idioma que você usa), está indo para essa função na memória. Então, digamos que você tenha três deles, acho que o computador não notará, mas se você começar a ter centenas dessas pequenas coisas, o sistema precisará registrar funções na memória que são chamadas apenas uma vez e depois não destruídas.

Recentemente, fiz exatamente isso em um aplicativo que refatorei, para tornar explícito o significado real do código sem comentários:

protected void PaymentButton_Click(object sender, EventArgs e)
    Func<bool> HaveError = () => lblCreditCardError.Text == string.Empty && lblDisclaimer.Text == string.Empty;

    CheckInputs();

    if(HaveError())
        return;

    ...
}

Mover essa linha para um método bem nomeado facilita a leitura do código. Muitos outros já mencionaram isso ("código de auto-documentação"). A outra vantagem de movê-lo para um método é que facilita o teste de unidade. Quando é isolado em seu próprio método e testado por unidade, você pode ter certeza de que se / quando um bug for encontrado, ele não estará nesse método.

Já existem muitas respostas boas, mas há um caso especial que vale a pena mencionar .

Se a sua declaração de uma linha precisar de um comentário e você conseguir identificar claramente (o que significa: nome) seu objetivo, considere extrair uma função enquanto aprimora o comentário no documento da API. Dessa forma, você torna a chamada de função mais fácil e rápida de entender.

Curiosamente, o mesmo pode ser feito se atualmente não houver nada a fazer, mas um comentário lembrando as expansões necessárias (em um futuro muito próximo ¹⁾ ), então,

def sophisticatedHello():
    # todo set up
    say("hello")
    # todo tear down

poderia muito bem mudou para isso

def sophisticatedHello():
    setUp()
    say("hello")
    tearDown()

¹⁾ você deve ter certeza disso (consulte o princípio YAGNI )

Se o idioma suportar, eu normalmente uso funções anônimas rotuladas para fazer isso.

someCondition = lambda p: True if [complicated expression involving p] else False
#I explicitly write the function with a ternary to make it clear this is a a predicate
if (someCondition(p)):
    #do stuff...

IMHO, esse é um bom compromisso, pois oferece o benefício de legibilidade por não ter a expressão complicada bagunçando a ifcondição, evitando bagunçar o espaço de nomes global / pacote com pequenos rótulos descartáveis. Tem o benefício adicional de que a função "definição" esteja exatamente onde está sendo usada, facilitando a modificação e a leitura da definição.

Não precisa ser apenas funções predicadas. Também gosto de envolver repetidamente a placa da caldeira em pequenas funções como esta (funciona particularmente bem na geração de listas python sem sobrecarregar a sintaxe do colchete). Por exemplo, o seguinte exemplo simplificado ao trabalhar com PIL em python

#goal - I have a list of PIL Image objects and I want them all as grayscale (uint8) numpy arrays
im_2_arr = lambda im: array(im.convert('L')) 
arr_list = [im_2_arr(image) for image in image_list]