Palabra clave groovy def

1. Información general

En este tutorial rápido, exploraremos el concepto de la palabra clave def en Groovy. Proporciona una función de escritura opcional para este lenguaje JVM dinámico.

2. Significado de la palabra clave def

La palabra clave def se utiliza para definir una variable sin tipo o una función en Groovy, ya que es un lenguaje de tipo opcional.

Cuando no estamos seguros del tipo de variable o campo, podemos aprovechar def para permitir que Groovy decida los tipos en tiempo de ejecución en función de los valores asignados:

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

Aquí, firstName será una cadena y listOfCountries será una ArrayList .

También podemos usar la palabra clave def para definir el tipo de retorno de un método:

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

Aquí, multiplicar puede devolver cualquier tipo de objeto, dependiendo de los parámetros que le pasemos.

3. Def Variables

Entendamos cómo def funciona para las variables.

Cuando usamos def para declarar una variable, Groovy la declara como un NullObject y le asigna un valor nulo :

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

En el momento en que asignamos un valor a la lista , Groovy define su tipo en función del valor asignado:

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

Digamos que queremos que nuestro tipo de variable sea dinámico y cambiar con una asignación:

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

No podemos asignar List o String a una variable con tipo int , ya que esto generará una excepción en tiempo de ejecución .

Entonces, para superar este problema e invocar la naturaleza dinámica de Groovy, usaremos la palabra clave 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. métodos def

La palabra clave def se usa además para definir el tipo de retorno dinámico de un método. Esto es útil cuando podemos tener diferentes tipos de valores de retorno para un método:

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

También podemos usar def para definir un método sin retornos explícitos:

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

5. def vs. Type

Analicemos algunas de las mejores prácticas relacionadas con el uso de def .

Aunque podemos usar def y type juntos al declarar una variable:

def int count assert count instanceof Integer

La palabra clave def será redundante allí, por lo que deberíamos usar def o un tipo.

Además, debemos evitar el uso de def para parámetros sin tipo en un método.

Por lo tanto, en lugar de:

void multiply(def x, def y)

Deberíamos preferir:

void multiply(x, y)

Además, debemos evitar usar def al definir constructores.

6. Groovy def vs. Objeto Java

Como hemos visto la mayoría de las características de la palabra clave def y sus usos a través de ejemplos, podríamos preguntarnos si es similar a declarar algo usando la clase Object en Java. Sí, def puede considerarse similar a Object :

def fullName = "Norman Lewis"

Del mismo modo, podemos usar Object en Java:

Object fullName = "Norman Lewis";

7. def vs. @TypeChecked

Como muchos de nosotros perteneceríamos al mundo de los lenguajes de tipo estricto, podemos preguntarnos cómo forzar la verificación de tipos en tiempo de compilación en Groovy . Podemos lograr esto fácilmente usando la anotación @TypeChecked .

Por ejemplo, podemos usar @TypeChecked sobre una clase para habilitar la verificación de tipos para todos sus métodos y propiedades:

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

Aquí, se comprobará el tipo de la clase DefUnitTest y la compilación fallará debido a que el método de multiplicación no está escrito . El compilador Groovy mostrará un error:

[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.

Entonces, para ignorar un método, podemos usar TypeCheckingMode.SKIP :

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

8. Conclusión

En este tutorial rápido, hemos visto cómo usar la palabra clave def para invocar la función dinámica del lenguaje Groovy y hacer que determine los tipos de variables y métodos en tiempo de ejecución.

Esta palabra clave puede ser útil para escribir código dinámico y robusto.

Como es habitual, las implementaciones de código de este tutorial están disponibles en el proyecto GitHub.