Quando usar def no Groovy?

23

Estou desenvolvendo o Groovy há um tempo e estou me perguntando com que frequência devo usar o casting dinâmico def. Um colega de trabalho meu acredita que devemos usá-lo sempre, pois ajuda o Groovy de alguma forma que eu não entendo.

Atualmente, ao declarar tipos e argumentos de retorno de método, gosto de declarar deliberadamente quais objetos devem ser inseridos e cuspidos (para facilitar a leitura do código e eu venho de um plano de fundo Java que faz sentido para mim) exemplo:

String doSomething(String something){
    //code
}
// vs
def doSomething(def somthing){
    //code
}
// vs 
def doSomething(somthing){
    // code
}

Então, acho que minha pergunta é apenas uma preferência de quando usar defou há uma vantagem real em usá-lo o tempo todo? (Adicionei o último exemplo porque achava que ele se encaixa na pergunta como uma opção viável para o Groovy)

code-quality groovy grails

— PJT
fonte

3

Veja aqui em que seu colega de trabalho acredita: stackoverflow.com/questions/184002/… .

— Remigijus Pankevičius

Eu vi essa pergunta e a resposta antes de decidir fazer essa pergunta. "A boa prática em scripts maiores é sempre usar a palavra-chave" def "para que você não tenha problemas de escopo estranhos ou interfira nas variáveis que não pretende." -Ted Naleid. O que me parece bom ao decidir entre omitir qualquer tipo ou usar def em scripts, mas e quanto a declarar tipos de retorno de método e tipos de argumento? O que é uma boa prática?

— PJT

1

OK, entendo seu ponto agora. É uma pergunta sobre programação fortemente tipada vs dinâmica. Tipo de discussão que eu tento evitar devido às guerras de chamas à frente :)

— Remigijus Pankevičius

20

Como boa prática de programação (mesmo de script), sempre considere especificar um tipo definido (embora não necessariamente concreto) para uma variável. Use defapenas se não houver um tipo definido aplicável à variável.

Como o OP conhece Java, não é diferente de especificar um tipo de Object(embora pareça haver uma pequena diferença ). A resposta a esta pergunta não será diferente de responder a uma pergunta como: "por que nem sempre usar o Objecttipo em Java?"

Ser o mais definitivo possível sobre os tipos reduz as chances de erros e até serve como auto-documentação. Considerando que, se alguém estiver implementando deliberadamente uma lógica dinâmica, o uso defpoderá fazer muito sentido. Essa é, de fato, uma das maiores forças do Groovy; o programa pode ser digitado dinamicamente ou estaticamente como se precisa! Só não deixe a preguiça ser a razão para usar def;-)

Por exemplo, esse método faz sentido com um tipo de argumento definido e um tipo de retorno:

// def val or Object val, opens up the possibility
// of the caller sending a non-numeric value 
Number half(Number val) {  
    val/2
}

enquanto esse método faz sentido com o tipo def

// I'd let them pass an argument of any type; 
// type `Object` makes sense too
def getIdProperty(def val) {   
    if(val?.hasProperty('id')) {
        // I don't know the type of this returned 
        // value and I don't really need to care 
        return val.id            
    }
    else {
        throw new IllegalArgumentException("Argument doesn't have an 'id' property")
    }
}

— Gaurav Thapa
fonte

-1

Sempre que o código que você está escrevendo for usado por outras pessoas como uma API pública, você sempre deve favorecer o uso de digitação forte, isso ajuda a tornar o contrato mais forte, evita possíveis erros de digitação de argumentos passados, fornece melhor documentação e também ajuda o IDE com conclusão de código. Sempre que o código for apenas para seu uso, como métodos particulares ou quando o IDE puder inferir facilmente o tipo, você estará mais livre para decidir quando digitar ou não.

— ASKAR
fonte