Versions Compared


  • This line was added.
  • This line was removed.
  • Formatting was changed.


A Groovy Closure is like a "code block" or a method pointer. It is a piece of code that is defined and then executed at a later point. It has some special properties like implicit variables, support for currying and support for free variables (which we'll see later on). We'll ignore the nitty gritty details for now (see the formal definition if you want those) and look at some simple examples.


The -> token is optional and may be omitted if your Closure definition takes fewer than two parameters.

Parameter notes

A Closure without -> , i.e. {} , is a Closure with one argument that is implicitly named as 'it'. (see below for details) In some cases, you need to construct a Closure with zero arguments, e.g. using GString for templating, defining EMC Property etc. You have to explicity define your Closure as { -> } instead of just { }

varargs could be used You can also use varargs as parameters, refer to the Formal Guide for details. A JavaScript-style dynamic args could be simulated, refer to the Informal Guide.


Within a Groovy Closure, several variables are defined that have special meaning:


If you have a Closure that takes a single argument, you may omit the parameter definition of the Closure, like so:

Code Block
def clos = { print it }
clos( "hi there" )              //prints "hi there"

this, owner, and delegate

this : as in Java, this refers to the instance of the enclosing class where a Closure is defined
owner : the enclosing object (this or a surrounding Closure)
delegate : by default the same as owner, but changeable for example in a builder or ExpandoMetaClass


Groovy extends java.lang.Object and many of the Collection and Map classes with a number of methods that accept Closures as arguments. See GDK Extensions to Object for practical uses of Groovy's Closures.