Mot-clé Groovy def

1. Vue d'ensemble

Dans ce rapide tutoriel, nous explorerons le concept du mot-clé def dans Groovy. Il fournit une fonction de saisie facultative à ce langage JVM dynamique.

2. Signification du mot-clé def

Le mot-clé def est utilisé pour définir une variable ou une fonction non typée dans Groovy, car il s'agit d'un langage typé facultativement.

Lorsque nous ne sommes pas sûrs du type d'une variable ou d'un champ, nous pouvons tirer parti de def pour laisser Groovy décider des types au moment de l'exécution en fonction des valeurs attribuées:

def firstName = "Samwell" def listOfCountries = ['USA', 'UK', 'FRANCE', 'INDIA'] 

Ici, firstName sera une chaîne et listOfCountries sera une ArrayList .

Nous pouvons également utiliser le mot-clé def pour définir le type de retour d'une méthode:

def multiply(x, y) { return x*y }

Ici, multiplier peut renvoyer n'importe quel type d'objet, selon les paramètres que nous lui passons.

3. def Variables

Comprenons comment def fonctionne pour les variables.

Lorsque nous utilisons def pour déclarer une variable, Groovy la déclare comme un NullObject et lui attribue une valeur nulle :

def list assert list.getClass() == org.codehaus.groovy.runtime.NullObject assert list.is(null) 

Au moment où nous attribuons une valeur à la liste , Groovy définit son type en fonction de la valeur assignée:

list = [1,2,4] assert list instanceof ArrayList 

Disons que nous voulons que notre type de variable soit dynamique et change avec une affectation:

int rate = 20 rate = [12] // GroovyCastException rate = "nill" // GroovyCastException

Nous ne pouvons pas affecter List ou String à une variable typée int , car cela lèvera une exception d'exécution .

Donc, pour surmonter ce problème et invoquer la nature dynamique de Groovy, nous utiliserons le mot-clé def :

def rate assert rate == null assert rate.getClass() == org.codehaus.groovy.runtime.NullObject rate = 12 assert rate instanceof Integer rate = "Not Available" assert rate instanceof String rate = [1, 4] assert rate instanceof List

4. def Méthodes

Le mot clé def est également utilisé pour définir le type de retour dynamique d'une méthode. Ceci est pratique lorsque nous pouvons avoir différents types de valeurs de retour pour une méthode:

def divide(int x, int y) { if (y == 0) { return "Should not divide by 0" } else { return x/y } } assert divide(12, 3) instanceof BigDecimal assert divide(1, 0) instanceof String

Nous pouvons également utiliser def pour définir une méthode sans retour explicite:

def greetMsg() { println "Hello! I am Groovy" }

5. def contre type

Discutons de certaines des meilleures pratiques concernant l'utilisation de def .

Bien que nous puissions utiliser à la fois def et type ensemble lors de la déclaration d'une variable:

def int count assert count instanceof Integer

Le mot-clé def y sera redondant, nous devrions donc utiliser def ou un type.

De plus, nous devons éviter d'utiliser def pour les paramètres non typés dans une méthode.

Par conséquent, au lieu de:

void multiply(def x, def y)

Nous devrions préférer:

void multiply(x, y)

De plus, nous devons éviter d'utiliser def lors de la définition des constructeurs.

6. Groovy def contre objet Java

Comme nous avons vu la plupart des fonctionnalités du mot-clé def et ses utilisations à travers des exemples, nous pourrions nous demander s'il est similaire à déclarer quelque chose en utilisant la classe Object en Java. Oui, def peut être considéré comme similaire à Object :

def fullName = "Norman Lewis"

De même, nous pouvons utiliser Object en Java:

Object fullName = "Norman Lewis";

7. def contre @TypeChecked

Comme beaucoup d'entre nous appartiendraient au monde des langages strictement typés, nous pouvons nous demander comment forcer la vérification de type à la compilation dans Groovy . Nous pouvons facilement y parvenir en utilisant l' annotation @TypeChecked .

Par exemple, nous pouvons utiliser @TypeChecked sur une classe pour activer la vérification de type pour toutes ses méthodes et propriétés:

@TypeChecked class DefUnitTest extends GroovyTestCase { def multiply(x, y) { return x * y } int divide(int x, int y) { return x / y } }

Ici, la classe DefUnitTest sera vérifiée de type et la compilation échouera en raison de la non- typage de la méthode de multiplication . Le compilateur Groovy affichera une erreur:

[Static type checking] - Cannot find matching method java.lang.Object#multiply(java.lang.Object). Please check if the declared type is correct and if the method exists.

Donc, pour ignorer une méthode, nous pouvons utiliser TypeCheckingMode.SKIP :

@TypeChecked(TypeCheckingMode.SKIP) def multiply(x, y)

8. Conclusion

Dans ce tutoriel rapide, nous avons vu comment utiliser le mot-clé def pour appeler la fonctionnalité dynamique du langage Groovy et lui faire déterminer les types de variables et de méthodes lors de l'exécution.

Ce mot-clé peut être utile pour écrire du code dynamique et robuste.

Comme d'habitude, les implémentations de code de ce tutoriel sont disponibles sur le projet GitHub.