parametros - perl $argv

¿Cómo pasar parámetros opcionales a una función de Perl?

Question

Quiero pasar varios parámetros, uno de los cuales es opcional, a una función. La única forma de hacerlo que conozco es usando una lista (@) como parámetro. Por lo tanto, no contiene nada o 1 elemento (nunca será undef), por lo que puedo usar el siguiente código:

sub someFunction($$@) {
    my ( $oblig_param1, $oblig_param2, $option_param ) = @_;
    ...
} 

Este código funciona, pero creo que tal vez no sea la mejor solución.
¿Hay alguna otra forma de hacerlo?
Gracias.

Answer 1

Es una buena idea agrupar los parámetros en un hashref de $parameter . Esto es especialmente útil si se deben proporcionar varias opciones (obligatorias u opcionales).

Para acceder a cualquier parámetro, simplemente use $parameter->{oblig1} o $$parameter{option2} .

El paso de hashrefs lo hace especialmente conveniente cuando se desarrolla, por lo que cuando surge la necesidad de $oblig3 , el orden de los argumentos no cambia ni en la persona que llama ni en el subdominio. Comparar antes y después:

# BEFORE $oblig3

--------------------------+-------------------------
# Caller                  | # Sub
--------------------------+-------------------------
someFunc( $oblig1,        | sub {
          $oblig2,        |   my ( $oblig1,
          $option1 );     |        $oblig2,
                          |        $option1 ) = @_;
                          | }
--------------------------+-------------------------

# AFTER $oblig3

--------------------------+-------------------------
# Caller                  | # Sub
--------------------------+-------------------------
someFunc( $oblig1,        | sub {
          $oblig2,        |   my ( $oblig1,
          $oblig3,        |        $oblig2,
          $option1 );     |        $oblig3,
                          |        $option1 ) = @_;
                          | }
--------------------------+-------------------------

El orden de los argumentos cambia tanto en la persona que llama como en el usuario secundario, por lo que el orden debe mantenerse y respetarse.

Usando hashrefs, no hay necesidad de preocuparse por el orden de los argumentos:

--------------------------+-------------------------
# Caller                  | # Sub
--------------------------+-------------------------
someFunc({ oblig1  => 1   | sub {
           oblig2  => 2   |   my ( $params ) = @_;
           option1 => 1   |   # No changes to    
           oblig3  => 7   |   # argument passing
         });              |  }    
                          | 
--------------------------+-------------------------

Dependiendo de las necesidades de diseño de la subrutina, se podrían utilizar los siguientes patrones de argumento de subrutina:

1. my ( $mandatory_parameters, $optional_parameters ) = @_;

   Este patrón es útil si hay varios de cada uno. La belleza de este enfoque es que $optional_parameters no está definido si no se pasa, por lo que el caso predeterminado podría ejecutarse if ! $optional_parameters; if ! $optional_parameters;

   Tenga en cuenta que los parámetros obligatorios deberán verificarse posteriormente:

   for ( qw/ a b c / ) { 
       die "Missing ''$_'' parameter/n"
         unless exists $mandatory_parameters->{$_};
   }

2. my ( $parameters ) = @_;

   Útil si hay pocos o ningún parámetro obligatorio.

   También es extremadamente efectivo si se pasan parámetros para modificar simplemente el comportamiento predeterminado. Al definir $default_parameters en el alcance del paquete, los valores predeterminados pueden ser cargados por una frase de línea subsiguiente a menos que un parámetro se haya pasado explícitamente:

   $parameters = { %$default_parameters, %$parameters };

Answer 2

Puede usar un punto y coma en el prototipo para indicar el final de los parámetros requeridos:

sub someFunction($$;$) {
  my ( $oblig_param1, $oblig_param2, $option_param ) = @_;
  ...
}

El ; es opcional antes de un @ o % , que, según los documentos , "engulle todo lo demás".

EDITAR: Como señala DVK en un comentario (y TLP enfatiza en otra respuesta aquí), probablemente esté mejor simplemente evitando los prototipos:

sub someFunction {
  my ( $oblig_param1, $oblig_param2, $option_param ) = @_;
  ...
}

Los prototipos de Perl tienen sus usos (principalmente para proporcionar coacción de contexto implícita a los argumentos, como hacen las funciones integradas de Perl). No deben usarse como un mecanismo para verificar que las funciones se llaman con el número y tipo de argumentos correctos.

Answer 3

Los prototipos (la parte ($$@) de su declaración secundaria) son opcionales por sí mismos. Tienen un uso muy específico, y si no sabes qué es, es mejor no usarlo. Desde perlsub:

... la intención de esta función es principalmente permitirle definir subrutinas que funcionan como funciones integradas

Simplemente elimine el prototipo de su declaración secundaria y podrá usar los argumentos que desee.

sub someFunction {
    my ( $oblig_param1, $oblig_param2, $option_param ) = @_;
    if (defined $option_param) {
        # do optional things
    }
    $option_param //= "default optional value";
    ....
}