Parámetros con Nombre

Introducción

When calling a method you can pass in named parameters. Parameter names and values are separated by a colon (like the Map syntax) though the parameter names are identifiers rather than Strings.

Currently this kind of method passing is only implemented for calling methods which take a Map or for constructing JavaBeans.

A JavaBean is a Java Object that is

• serializable,
• has a default nullary constructor, and
• allows access to properties using getter and setter methods.

El siguiente programa muestra un ejemplo de llamada en la que los parámetros tienen nombres:

~/Lgroovy/objects$ cat -n namedPar.groovy 
     1  #!/usr/bin/env groovy
     2  def bean = new Expando(name:"James", location:"London", id:123)
     3  println "name = " + bean.name
     4  println "id   = ${bean.id}"

El resultado de la ejecución es:

~/Lgroovy/objects$ ./namedPar.groovy 
name = James
id   = 123

Sintáxis de una LLamada Usando Parámetros con Nombre

• Named arguments requires the following method signature

                   def foo(T t, p1, p2, ..., pn)
  

  The type T can be Object, Map or no explicit type.

• The real work is done by the compiler where the method call is defined. A method call

                   foo(p1:e1, p2:e2, ..., pn:en, q1, q2, ..., qm)
  

  will always be transformed to

                   foo([p1:e1, p2:e2, ..., pn:en], q1, q2, ..., qm)
  

• If - in the call- you mix the positions of the p$_i$ (named) and q$_i$ (unnamed) elements, then the compiler will still force the same transformed signature.

Ejemplo

Cuando se ejecuta este programa:

~/Lgroovy/objects$ cat -n namedPar3.groovy 
     1  def foo(x,y,z) {[x,y,z]}
     2  println foo(a:1,b:2,3,4)
     3  println foo(a:1,3,b:2,4)
     4  println foo(3,4,a:1,b:2)
     5  
     6  println foo(4,3,b:2,a:1)

Se obtienen las siguientes salidas:

~/Lgroovy/objects$ groovy namedPar3.groovy 
[[a:1, b:2], 3, 4]
[[a:1, b:2], 3, 4]
[[a:1, b:2], 3, 4]
[[b:2, a:1], 4, 3]

Llamadas con Nombre y Número de Argumentos

En el siguiente programa la llamada foo(x:1,y:2, 8) es correcta porque foo(x, y) espera dos parámetros y es llamada con dos argumentos.

La llamada tutu(x:1,y:2) produce una excepción ya que tutu(x, y) se declara con dos parámetros y está siendo llamada con un sólo argumento.

~/Lgroovy/objects$ cat -n namedPar4.groovy 
     1  def foo(x,y){
     2    println "<$x> <$y>"
     3  }
     4  
     5  def tutu(x,y){
     6    println "<$x> <$y>"
     7  }
     8  foo(x:1,y:2, 8)
     9  try {
    10    tutu(x:1,y:2)
    11  }
    12  catch (e) {
    13    println e.class
    14  }

El resultado de la ejecución es:

~/Lgroovy/objects$ groovy namedPar4.groovy 
<[x:1, y:2]> <8>
class groovy.lang.MissingMethodException

Estructura Típica de un Método que usa Parámetros con Nombres

La estructura habitual de un método que usa parámetros con nombres consiste en una primera fase en la que se comprueban que argumentos con nombre han sido definidos. A los que no figuran se les da un valor por defecto:

~/Lgroovy/objects$ cat -n namedPar5.groovy 
   1  class SomeClass {
   2    def TypicalNamedMethod(Map args) {
   3      args.get('a', 'default for a')
   4      args.get('b', 'default for b')
   5      args.get('c', 'default for c')
   6  
   7      return "<$args.a> <$args.b> <$args.c>"
   8    }
   9  }
  10  
  11  def x = new SomeClass()
  12  
  13  println x.TypicalNamedMethod(a:1, b:1);
  14  println x.TypicalNamedMethod(a:1, b:1, c:1);
  15  println x.TypicalNamedMethod(c:1, b:1);

Este es el resultado de ejecutar el script anterior:

~/Lgroovy/objects$ groovy namedPar5.groovy 
<1> <1> <default for c>
<1> <1> <1>
<default for a> <1> <1>