web-dev-qa-db-fra.com

Quand utiliser def dans Groovy?

Je développe dans Groovy depuis un petit moment maintenant et je me demande à quelle fréquence je devrais utiliser le casting dynamique def? Un de mes collègues pense que nous devrions toujours l'utiliser car cela aide Groovy d'une manière que je ne comprends pas.

Actuellement, lors de la déclaration des types de retour de méthode et des arguments, j'aime indiquer délibérément quels objets doivent être récupérés et recrachés (pour la lisibilité du code et je viens d'un Java arrière-plan, cela a du sens pour moi)) exemple:

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

Donc je suppose que ma question est juste une préférence de quand utiliser def ou y a-t-il un réel avantage à l'utiliser tout le temps? (J'ai ajouté le dernier exemple parce que je sentais qu'il cadrait avec la question comme une option viable pour Groovy)

code-qualitygroovygrails
24
PJT

En tant que bonne pratique de programmation (même de script), pensez toujours à spécifier un type défini (mais pas nécessairement concret) pour une variable. Utilisez def uniquement s'il n'y a pas de type défini applicable à la variable.

Puisque l'OP connaît Java, ce n'est pas différent de spécifier un type de Object (bien qu'il semble y avoir un différence mineure ). La réponse à cette question ne sera donc pas différente de la réponse à une question comme: "pourquoi ne pas toujours utiliser le type Object en Java?"

Être aussi précis sur les types que possible réduit les risques de bogues et sert même d'auto-documentation. Alors que si l'on implémente délibérément une logique dynamique, l'utilisation de def peut avoir beaucoup de sens. C'est en fait l'une des plus grandes forces de Groovy; le programme peut être aussi typé dynamiquement ou statiquement qu'on en a besoin! Ne laissez pas la paresse être la raison d'utiliser def ;-)

Par exemple. cette méthode est logique avec un type d'argument défini et un type de retour:

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

alors que cette méthode est logique avec le type 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")
    }
}
21
Gaurav Thapa

Chaque fois que le code que vous écrivez sera utilisé par d'autres en tant qu'API publique, vous devriez toujours favoriser l'utilisation de la frappe forte, cela aide à rendre le contrat plus fort, évite les éventuelles erreurs de type d'arguments passés, donne une meilleure documentation et aide également le IDE avec complétion de code. Chaque fois que le code est pour votre usage uniquement, comme les méthodes privées, ou lorsque le IDE peut facilement déduire le type, alors vous ' re plus libre de décider quand taper ou non.

0
ASKAR