Wann sollte man def in Groovy verwenden?

Ich entwickle mich seit einiger Zeit in Groovy und frage mich, wie oft ich das dynamische Casting verwenden soll def. Ein Kollege von mir ist der Meinung, wir sollten es immer verwenden, da es Groovy irgendwie hilft, was ich nicht verstehe.

Derzeit möchte ich beim Deklarieren von Methodenrückgabetypen und Argumenten bewusst angeben, welche Objekte aufgenommen und ausgespuckt werden sollen (aus Gründen der Codelesbarkeit und weil ich einen Java-Hintergrund habe, ist dies für mich sinnvoll). Beispiel:

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

Ich schätze, meine Frage ist es nur eine Präferenz, wann man es benutzt, defoder gibt es einen wirklichen Vorteil, wenn man es die ganze Zeit benutzt? (Ich habe das letzte Beispiel hinzugefügt, weil ich der Meinung bin, dass es mit der Frage als praktikable Option für Groovy übereinstimmt.)

Als gute Programmierpraxis (auch für Skripte) sollten Sie immer einen bestimmten (wenn auch nicht unbedingt konkreten) Typ für eine Variable angeben. Verwenden Sie defnur , wenn es keine bestimmten Typ für die Variable ist.

Da das OP Java kennt, unterscheidet es sich nicht von der Angabe eines Typs Object(obwohl es einen geringfügigen Unterschied zu geben scheint ). Die Antwort auf diese Frage unterscheidet sich dann nicht von der Beantwortung einer Frage wie: "Warum nicht immer den ObjectTyp in Java verwenden?"

Wenn Sie so genau wie möglich über die Typen Bescheid wissen, verringert sich das Risiko von Fehlern und es dient sogar zur Selbstdokumentation. Wenn man dagegen bewusst eine dynamische Logik implementiert, kann die Verwendung von defsehr viel Sinn machen. Das ist in der Tat eine der größten Stärken von Groovy. Das Programm kann so dynamisch oder statisch geschrieben werden, wie es sein muss! Lass einfach nicht zu, dass Faulheit der Grund ist def;-)

Diese Methode ist zB bei einem bestimmten Argumenttyp und Rückgabetyp sinnvoll:

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

während diese Methode mit Typ sinnvoll ist 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")
    }
}

Wann immer der Code, den Sie schreiben, von anderen als öffentliche API verwendet wird, sollten Sie immer die Verwendung von starker Typisierung bevorzugen. Dies stärkt den Vertrag, vermeidet mögliche Fehler bei der Übergabe von Argumenten, bietet eine bessere Dokumentation und hilft auch die IDE mit Code-Vervollständigung. Wann immer der Code wie private Methoden nur für Sie bestimmt ist oder wenn die IDE leicht auf den Typ schließen kann, können Sie selbst entscheiden, wann Sie ihn eingeben möchten oder nicht.