Quando usare def in Groovy?

23

Sto sviluppando in Groovy da un po 'di tempo e mi chiedo con quale frequenza dovrei usare il casting dinamico def? Un mio collega ritiene che dovremmo usarlo sempre perché aiuta Groovy in un modo che non capisco.

Attualmente, nel dichiarare i tipi e gli argomenti di ritorno del metodo, mi piace dichiarare deliberatamente quali oggetti dovrebbero essere presi e sputati (per leggibilità del codice e vengo da un background Java ha senso per me) esempio:

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

Quindi suppongo che la mia domanda sia solo una preferenza su quando usare defo c'è un vero vantaggio nell'usarlo tutto il tempo? (Ho aggiunto l'ultimo esempio perché sentivo che si adattava alla domanda come opzione praticabile per Groovy)

code-quality groovy grails

— PJT
fonte

3

Vedi qui in cosa crede il tuo collega: stackoverflow.com/questions/184002/… .

— Remigijus Pankevičius,

Ho visto quella domanda e la risposta prima di decidere di porre questa domanda. "La buona pratica negli script più grandi è quella di utilizzare sempre la parola chiave" def "in modo da non incorrere in strani problemi di scoping o interferire con le variabili che non si intende." -Ted Naleid. Ciò suona bene per me quando decido di omettere qualsiasi tipo o usare def negli script, ma per quanto riguarda la dichiarazione dei tipi di ritorno del metodo e dei tipi di argomento? Che cos'è una buona pratica?

— PJT,

1

OK, vedo il tuo punto ora. È una domanda sulla programmazione fortemente tipizzata vs dinamica. Tipo di discussione che cerco di evitare a causa di guerre di fiamma avanti :)

— Remigijus Pankevičius

20

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

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

Essere il più precisi possibile sui tipi riduce le possibilità di bug e funge anche da autocertificazione. Considerando che, se si sta implementando deliberatamente una logica dinamica, l'uso defpotrebbe 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 si deve! Non lasciare che la pigrizia sia la ragione per usare def;-)

Ad esempio, questo metodo ha senso con un tipo di argomento definito e un tipo restituito:

// 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 il 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

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

— ASKAR
fonte