Quando usare def in Groovy?

Question

Quando usare def in Groovy?

#1 da (20 voti)
#2 da (-1 voti)

21

Da qualche tempo sto sviluppando in Groovy e mi chiedo quanto spesso dovrei usare il casting dinamico def ? Un mio collega crede che dovremmo usarlo sempre in quanto aiuta Groovy in un modo che non capisco.

Attualmente, quando dichiaro il metodo restituisce i tipi e gli argomenti, mi piace dichiarare deliberatamente quali oggetti devono essere presi e sputati (per la leggibilità del codice e provengo da uno sfondo Java per me ha senso) esempio:

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

Quindi immagino che la mia domanda sia solo una preferenza su quando usare def o c'è un reale vantaggio nell'utilizzarlo tutto il tempo? (Ho aggiunto l'ultimo esempio perché ho ritenuto che fosse adatto alla domanda come opzione valida per Groovy)

code-quality groovy grails

posta PJT 24.04.2015 - 20:11

fonte

2 risposte

-1

Ogni volta che il codice che stai scrivendo verrà utilizzato da altri come API pubblica, dovresti sempre favorire l'uso della tipizzazione strong, aiuta a rafforzare il contratto, evita possibili errori di tipo passato, fornisce una documentazione migliore, e aiuta anche l'IDE con il completamento del codice. Ogni volta che il codice è solo per uso personale, come i metodi privati, o quando l'IDE può facilmente dedurre il tipo, sei più libero di decidere quando scrivere o meno.

risposta data 12.06.2017 - 10:09

fonte

Leggi altre domande sui tag code-quality groovy grails

che cosa è un modo efficace per trovare il decimale ricorrente Come refactoring quando tutto il tuo sviluppo è sui rami?

score 20 · Accepted Answer

Come buona pratica di programmazione (anche di scripting), considera sempre di specificare un tipo definito (anche se non necessariamente concreto) per una variabile. Usa def solo se non esiste un tipo definito applicabile alla variabile.

Dato che l'OP conosce Java, non è diverso dalla specifica di un tipo di Object (anche se sembra esserci una piccola differenza ). La risposta a questa domanda non sarà diversa dalla risposta a una domanda del tipo: "perché non utilizzare sempre il tipo Object in Java?"

Essere il più preciso possibile sui tipi riduce le possibilità di bug e serve anche come auto-documentazione. Mentre, se si sta deliberatamente implementando una logica dinamica, usare def potrebbe avere molto senso. Questo è in effetti uno dei maggiori punti di forza di Groovy; il programma può essere digitato in modo dinamico o statico come è necessario! Non lasciare che la pigrizia sia la ragione per usare def ; -)

es. questo metodo ha senso con un tipo di argomento definito e tipo di ritorno:

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

mentre questo metodo ha senso con 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")
    }
}