Foro - Perl en Español

por **pablgonz** » 2015-11-26 13:36 @608

Hola a todos en el foro.

Estoy escribiendo un pequeño script para extraer/copiar bloques de texto de un archivo latex, y deseo agregarle opciones mediante Getopt::Long.

Mi idea es poder usar el script al estilo Linux script [opciones] archivo pero me he topado con un pequeño dilema. Me explico: Al correr el script sobre un archivo deseo que acepte solo las extensiones .tex y .ltx; si el archivo no tiene extensión o es otra, dar un mensaje y salir.
Si el archivo de entrada es test.tex y se usa la opción --output que no esté seguida de una cadena, el valor por defecto sería test-out.tex, algo así:

Sintáxis: [ Descargar ] [ Ocultar ]

script --output test.tex

produciría test-out.tex como salida, y

Sintáxis: [ Descargar ] [ Ocultar ]

script --output otro test.tex

produciría otro.tex como salida.

En esto es donde me pierdo: deseo validar el archivo de entrada y salida, para que el archivo de entrada tenga solo la extensión válida y el nombre del archivo de salida no contenga la extensión ni sea el mismo nombre que el archivo de entrada.

No sé si es posible lo de asignarle un valor por defecto si se pasa la opción --output. De no ser así, mostrar un mensaje de error y salir.

El tema es que añadiré más opciones dentro del mismo script.

Dejo el código que llevo a la fecha:

Sintáxis: [ Descargar ] [ Ocultar ]

Using perl Syntax Highlighting

eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}' && eval 'exec perl -S $0 $argv:q' if 0;
use v5.18;
use File::Basename;           # 
use Getopt::Long qw(:config bundling_override require_order); # 
use autodie;                  # 
 
#------------------------ Constantes -----------------------------------
my $imageDir    = "images";             # 
my $other       = "other";              # 
my $BPL         = '\begin{postscript}';
my $EPL         = '\end{postscript}';
my $sipgf       = 'pgfpicture';
my $nopgf       = 'pgfinterruptpicture'; 
 
#---------------- Creamos el directorio para las imágenes -------------#
-e $imageDir or mkdir($imageDir,0744) or die "No puedo crear $imageDir: $!\n";
 
my $usage = <<"END_OF_USAGE";
Uso: programa [opt] archivo.tex
END_OF_USAGE
 
my $output; # archivo de salida 
 
my $result=GetOptions (
                'output|o=s'    => \$output,            # nombre archivo de salida 
                'help|h'        => \$::opt_help,        # muestra ayuda
        ) or die $usage;
 
# help 
if ($::opt_help) {
    print $usage;
    exit(0);
}
 
#--------------------- Arreglo de la extensión -------------------------
my @SuffixList = ('.tex', '', '.ltx');    # posibles 
my ($name, $path, $ext) = fileparse($ARGV[0], @SuffixList);
$ext = '.tex' if not $ext;
 
# nombre del archivo de salida
if ($output eq '') {
        $output = "$name-out";
    print "El nombre de es $output";
}
 
#------------------- Abrimos el archivo -------------------------------
open my $ENTRADA, '<', "$name$ext";
my $archivo;
{
    local $/;
    $archivo = <$ENTRADA>;
}
close   $ENTRADA;
 
#--------------------- Dividimos el archivo de entrada -----------------
my($cabeza,$cuerpo,$final) = $archivo =~ m/\A (.+?) (\\begin\{document\} .+?)(\\end\{document\}.*)\z/msx;
 
# \pspicture to \begin{pspicture}
$cuerpo =~ s/\\pspicture(\*)?(.+?)\\endpspicture/\\begin{pspicture$1}$2\\end{pspicture$1}/gmsx;
 
# Verbatim environments
my $VERBATIM  = qr/(?: (v|V)erbatim\*?| PSTexample | aling)/xi;
 
# postscript environment 
my $POSTSCRIPT = qr/(?: postscript)/xi;
 
# tikzpicture environment 
my $ENVIRONMENT    = qr/(?: tikzpicture | pspicture\*?)/xi;
 
# falla izquierda (*SKIP)(*F)| acepta la derecha <img src="http://perlenespanol.com/foro/images/smilies/icon_smile.gif" alt=":)" title="Smile" />
# tikz/pst to Postscript
$cuerpo =~ s/\\begin\{$POSTSCRIPT\}.+?\\end\{$POSTSCRIPT\}(*SKIP)(*F)|
        (
        (?:\\(psset|tikzset)(\{(?:\{.*?\}|[^\{])*\}).*?)?  # si está lo guardo
        (\\begin\{($ENVIRONMENT)\} (.*?)  \\end\{\g{-2}\})
    )
    /$BPL\n$1\n$EPL/gmsx;
 
# pgfpicture to Postscript
$cuerpo =~ s/\\begin\{$POSTSCRIPT\}.+?\\end\{$POSTSCRIPT\}(*SKIP)(*F)|
    (
        \\begin\{$sipgf\}
            .*?
            (
                \\begin\{$nopgf\}
                .+?
                \\end\{$nopgf\}
                .*?
            )*?
        \\end\{$sipgf\}
    )
    /$BPL\n$1\n$EPL/gmsx;
 
# other to PostScript
my $EXPORT  = qr/(forest|ganttchart|tikzcd|circuitikz|dependency|$other\*?)/x;
 
$cuerpo =~ s/\\begin\{$POSTSCRIPT\}.+?\\end\{$POSTSCRIPT\}(*SKIP)(*F)|
        (\\begin\{($EXPORT)\} (.*?)  \\end\{\g{-2}\})
        /$BPL\n$1\n$EPL/gmsx;
 
# escribir la salida
open my $SALIDA, '>', "$output$ext";
    print $SALIDA <<"EOC";
$cabeza$cuerpo$final
EOC
close $SALIDA;
 
__END__
 
Coloreado en 0.005 segundos,  usando GeSHi 1.0.8.4

Y el archivo test:

Sintáxis: [ Descargar ] [ Ocultar ]

Using latex Syntax Highlighting

\documentclass{article}
\usepackage{lmodern}
\usepackage{pstricks-add}
\begin{document}
 
texto\begin{pspicture}(-0.5,-0.5)(5,3.5)
Deberia quedar dentro de postricpt
\end{pspicture}texto
 
\section{NO Anidados}
PSPICTURE
 
\psset{
unit=1.0cm,
}
\begin{pspicture}(-0.5,-0.5)(5,3.5)
Deberia quedar dentro de postricpt
\end{pspicture}
PGF
 
\begin{pgfpicture}
Deberia quedar dentro de postcript
\end{pgfpicture}
 
TIKZ
\tikzset{
algo
}
\begin{tikzpicture}
\shadedraw [shading=ball] (0,0) circle (2cm);
\end{tikzpicture}
 
\section{Otros}
 
\begin{forest}
FOREST
\end{forest}
 
\begin{ganttchart}
ganttchart
\end{ganttchart}
 
\begin{tikzcd}
tikzcd
\end{tikzcd}
 
\begin{circuitikz}
circuitikz
\end{circuitikz}
 
\begin{dependency}
dependency
\end{dependency}
 
\section{Otros anidados en postscript}
 
\begin{postscript}
\begin{forest}
FOREST
\end{forest}
\end{postscript}
 
\begin{postscript}
\begin{ganttchart}
ganttchart
\end{ganttchart}
\end{postscript}
 
\begin{postscript}
\begin{tikzcd}
tikzcd
\end{tikzcd}
\end{postscript}
 
\begin{postscript}
\begin{circuitikz}
circuitikz
\end{circuitikz}
\end{postscript}
 
\begin{postscript}
\begin{dependency}
dependency
\end{dependency}
\end{postscript}
 
\section{Otros anidados en tikzpicture}
 
\begin{tikzpicture}
\begin{forest}
FOREST
\end{forest}
\end{tikzpicture}
 
\begin{tikzpicture}
\begin{ganttchart}
ganttchart
\end{ganttchart}
\end{tikzpicture}
 
\begin{tikzpicture}
\begin{tikzcd}
tikzcd
\end{tikzcd}
\end{tikzpicture}
 
\begin{tikzpicture}
\begin{circuitikz}
circuitikz
\end{circuitikz}
\end{tikzpicture}
 
\begin{tikzpicture}
\begin{dependency}
dependency
\end{dependency}
\end{tikzpicture}
 
\section{Anidados}
PGF
\begin{postscript}
\begin{pgfpicture}
PGF anidado queda de la misma manera
\end{pgfpicture}
\end{postscript}
 
PSPICTURE
\begin{postscript}
\begin{pspicture}(-0.5,-0.5)(5,3.5)
pspicture anidaddo queda de la misma manera
\end{pspicture}
\end{postscript}
 
TIKZpicture
\begin{postscript}
\begin{tikzpicture}
\shadedraw [shading=ball] (0,0) circle (2cm);
\end{tikzpicture}
\end{postscript}
 
\end{document}
 
 
\begin{pspicture}(-0.5,-0.5)(5,3.5)
IGNORAR
\end{pspicture}
 
Coloreado en 0.002 segundos,  usando GeSHi 1.0.8.4

Agradecido de antemano.
Saludos

No entiendo muy bien cuál es el problema.

Si se trata de comprobar las entradas recibidas, consistirá en hacer expresiones regulares para comprobar si los archivos tienen o no las extensiones solicitadas. Y reaccionar según sea el caso.

En la documentación sí que se ve que se puede asignar una referencia a una subrutina o incluso una subrutina anónima de forma directa, a cada opción de GetOptions(), para que se ejecuten cuando se encuentre la opción correspondiente. Por ejemplo:

Sintáxis: [ Descargar ] [ Ocultar ]

Using perl Syntax Highlighting

my $verbose = '';   # option variable with default value (false)
GetOptions ('verbose' => \$verbose,
            'quiet'   => sub { $verbose = 0 });
Coloreado en 0.001 segundos,  usando GeSHi 1.0.8.4

Ahí vemos dos cosas: en la primera línea declaramos la variable $verbose y la definimos con un valor inicial, que puede ser el valor por defecto que quieres tener en tu programa.

Y dentro de GetOptions() ves la subrutina anónima que se ajusta al valor 'quiet', que se ejecutará cuando se encuentre esa opción en la línea de comandos.

Las subrutinas reciben dos o tres argumentos: el nombre de la opción y luego siguen los posibles valores recibidos pasados en la línea de comandos.

por **pablgonz** » 2015-11-28 12:32 @564

Gracias por la respuesta

explorer escribiste:No entiendo muy bien cuál es el problema.

Si se trata de comprobar las entradas recibidas, consistirá en hacer expresiones regulares para comprobar si los archivos tienen o no las extensiones solicitadas. Y reaccionar según sea el caso.

En efecto es eso lo que deseo hacer, es decir siendo test.tex el archivo de entrada quiero que el comportamiento del script sea algo así:

1. Si ingreso script -o salida test.tex debería chequear si "salida" es un nombre valido para el archivo de salida, no comenzar por "-" o "." y ser distinto del nombre de entrada (test), si cumple con estos requisitos ejecutar $outfile para escribir el archivo de salida.
2. Si ingreso script -o test.tex debería crear el nombre de salida por defecto (test-out) y ejecutar $outfile para escribir el archivo de salida, de no ser posible hacer esto, mostrar un mensaje de que el nombre de salida es obligatorio (y sin extensión) y luego salir.
3. Si ingreso script test.tex no debería crear salida.

Actualice a la versión 5.22 y modifique el código dejándolo de la siguiente manera:

Sintáxis: [ Descargar ] [ Ocultar ]

Using perl Syntax Highlighting

eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}' && eval 'exec perl -S $0 $argv:q' if 0;
use v5.22;
use File::Basename;           #
use Getopt::Long qw(:config bundling_override require_order); #
use autodie;                  #
 
#------------------------ Constantes -----------------------------------
my $imageDir    = "images";             #
my $other       = "other";              #
my $BPL         = '\begin{postscript}';
my $EPL         = '\end{postscript}';
my $sipgf       = 'pgfpicture';
my $nopgf       = 'pgfinterruptpicture';
 
#---------------- Creamos el directorio para las imágenes -------------#
-e $imageDir or mkdir($imageDir,0744) or die "No puedo crear $imageDir: $!\n";
 
my $usage = <<"END_OF_USAGE";
Uso: programa [opt] archivo.tex
END_OF_USAGE
 
my $outfile   = 0; # creamos el archivo de salida
 
my $output=""; # nombre del archivo de salida
 
my $result=GetOptions (
    "outfile"    => \$outfile, # ejecuta la escritura de salida
    'help|h'     => \$::opt_help, # muestra ayuda
    'output|o=s' => sub { $outfile = 1}, # Si se ingresa -o ejecuta $outfile
    ) or die $usage;
 
# help
if ($::opt_help) {
    print $usage;
    exit(0);
}
 
# help functions
sub errorUsage { die "@_ (use script --help)\n"; }
 
@ARGV > 0 or errorUsage "Falta ingresar el nombre del archivo de entrada";
@ARGV < 2 or errorUsage "Opción desconocida o varios archivos de entrada";
 
#--------------------- Arreglo de la extensión -------------------------
my @SuffixList = ('.tex', '', '.ltx');    # posibles
my ($name, $path, $ext) = fileparse($ARGV[0], @SuffixList);
$ext = '.tex' if not $ext;
 
# revisamos el nombre del archivo de salida
if ($output eq "$name") {
    die "El nombre del archivo de salida no puede ser igual al del archivo de entrada\n";
}
if ($output =~ /(^\-|^\.).*?/){
    die "$output no es un nombre valido para el archivo de salida\n";
}
 
print "El nombre de salida es $output\n";
 
#------------------- Abrimos el archivo -------------------------------
open my $ENTRADA, '<', "$name$ext";
my $archivo;
{
    local $/;
    $archivo = <$ENTRADA>;
}
close   $ENTRADA;
 
#--------------------- Dividimos el archivo de entrada -----------------
my($cabeza,$cuerpo,$final) = $archivo =~ m/\A (.+?) (\\begin\{document\} .+?)(\\end\{document\}.*)\z/msx;
 
# \pspicture to \begin{pspicture}
$cuerpo =~ s/\\pspicture(\*)?(.+?)\\endpspicture/\\begin{pspicture$1}$2\\end{pspicture$1}/gmsx;
 
# Verbatim environments
my $VERBATIM  = qr/(?: (v|V)erbatim\*?| PSTexample | aling)/xi;
 
# postscript environment
my $POSTSCRIPT = qr/(?: postscript)/xi;
 
# tikzpicture environment
my $ENVIRONMENT    = qr/(?: tikzpicture | pspicture\*?)/xi;
 
# falla izquierda (*SKIP)(*F)| acepta la derecha <img src="http://perlenespanol.com/foro/images/smilies/icon_smile.gif" alt=":)" title="Smile" />
# tikz/pst to Postscript
$cuerpo =~ s/\\begin\{$POSTSCRIPT\}.+?\\end\{$POSTSCRIPT\}(*SKIP)(*F)|
        (
        (?:\\(psset|tikzset)(\{(?:\{.*?\}|[^\{])*\}).*?)?  # si está lo guardo
        (\\begin\{($ENVIRONMENT)\} (.*?)  \\end\{\g{-2}\})
    )
    /$BPL\n$1\n$EPL/gmsx;
 
# pgfpicture to Postscript
$cuerpo =~ s/\\begin\{$POSTSCRIPT\}.+?\\end\{$POSTSCRIPT\}(*SKIP)(*F)|
    (
        \\begin\{$sipgf\}
            .*?
            (
                \\begin\{$nopgf\}
                .+?
                \\end\{$nopgf\}
                .*?
            )*?
        \\end\{$sipgf\}
    )
    /$BPL\n$1\n$EPL/gmsx;
 
# other to PostScript
my $EXPORT  = qr/(forest|ganttchart|tikzcd|circuitikz|dependency|$other\*?)/x;
 
$cuerpo =~ s/\\begin\{$POSTSCRIPT\}.+?\\end\{$POSTSCRIPT\}(*SKIP)(*F)|
        (\\begin\{($EXPORT)\} (.*?)  \\end\{\g{-2}\})
        /$BPL\n$1\n$EPL/gmsx;
 
# escribir la salida
if ($outfile) {
print "Creamos $output$ext\n";
 
open my $SALIDA, '>', "$output$ext";
    print $SALIDA <<"EOC";
$cabeza$cuerpo$final
EOC
close $SALIDA;
 
}# cerramos 
__END__
 
Coloreado en 0.004 segundos,  usando GeSHi 1.0.8.4

pero, no logro dar con lo que deseo, $output queda con el nombre por defecto. He revisado varios ejemplos en el foro y en la red y no logro dar con el código correcto.
Agradecido por todo.
Pablo

por **explorer** » 2015-11-30 01:13 @092

Hay un problema:

El primer punto y el segundo son, esencialmente, la misma entrada.

Quiero decir que '-o' está precediendo a un nombre de archivo, por lo que Getopt::Long los meterá en la misma variable $output.

Desde luego que se puede resolver, pero hay que poner varias líneas para resolver las distintas excepciones. Es mucho mejor simplificar el problema añadiendo opciones o simplificando las reglas de entrada.

Por ejemplo, podemos decir:

1- si al programa se le dan dos nombres de archivo, el primero siempre será el de entrada y el segundo, el de salida.

2- si se le pasan argumentos, se hace que sea obligatorio que sean acompañados de un parámetro. Así, un '-i' antecede al nombre de un archivo de entrada. Y '-o' al de salida.

Estos dos puntos te lo resuelve Getoptions(). Luego puedes hacer las siguientes comprobaciones:

1- si solo se pasa un parámetro, es el archivo de entrada. Entonces al de salida se le da un nombre por defecto.

2- comprobamos el nombre de los archivos de entrada y de salida. Si no son válidos, terminamos con error.

3- procesar.

4- ¡beneficios!

por **pablgonz** » 2015-11-30 11:00 @500

Gracias por la respuesta.

Tienes razón básicamente el punto 1 y 2 son idénticos.

De la forma en la cual tengo escrito el código ahora, no guarda en $output el valor ingresado en la línea de comandos para luego ejecutar $outfile y escribir el archivo de salida.

Obviando las comprobaciones para al archivo de salida, que se resumen esencialmente a que no tenga el mismo nombre del archivo de entrada (lo de la extensión lo puedo saltear dejando salida.tex.tex), ¿qué debo modificar para que $outfile se ejecute solo si está presente -o salida?

Seguiré intentando.
Agradecido,
Pablo

por **pablgonz** » 2015-12-08 20:27 @894

Tomando las ideas que me diste, logré mi cometido.

Al final lo dejé así:

Sintáxis: [ Descargar ] [ Ocultar ]

script [opciones] entrada [salida]

usando defined veo si está presente ARGV[1] y si está, hago las comprobaciones y ejecuto lo que deseo. El código quedo así:

Sintáxis: [ Descargar ] [ Ocultar ]

Using perl Syntax Highlighting

eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}' && eval 'exec perl -S $0 $argv:q' if 0;
use v5.22;
use File::Basename;           #
use Getopt::Long qw(:config bundling_override require_order); #
use autodie;                  #
 
#------------------------ Constantes -----------------------------------
my $imageDir    = "images";             #
my $other       = "other";              #
my $BPL         = '\begin{postscript}';
my $EPL         = '\end{postscript}';
my $sipgf       = 'pgfpicture';
my $nopgf       = 'pgfinterruptpicture';
 
#------------------------ Opciones y ayuda -----------------------------
 
my $usage = <<"END_OF_USAGE";
Uso: script [opciones] entrada.tex [salida]
END_OF_USAGE
 
# help functions
sub errorUsage { die "@_ (use script --help)\n"; }
 
my $result=GetOptions (
    'help|h'     => \$::opt_help, # muestra ayuda
    ) or die "use script --help para ver las opciones\n";
 
# help
if ($::opt_help) {
    print $usage;
    exit(0);
}
 
@ARGV > 0 or errorUsage "Falta ingresar el nombre del archivo de entrada";
@ARGV < 3 or errorUsage "Opción desconocida o varios archivos de entrada";
 
#--------------------- Arreglo de la extensión -------------------------
my @SuffixList = ('.tex', '', '.ltx');    # posibles
my ($name, $path, $ext) = fileparse($ARGV[0], @SuffixList);
$ext = '.tex' if not $ext;
 
#------------------- Abrimos el archivo -------------------------------
open my $ENTRADA, '<', "$name$ext";
my $archivo;
{
    local $/;
    $archivo = <$ENTRADA>;
}
close   $ENTRADA;
 
#---------------- Creamos el directorio para las imágenes -------------#
-e $imageDir or mkdir($imageDir,0744) or die "No puedo crear $imageDir: $!\n";
 
#--------------------- Dividimos el archivo de entrada -----------------
my($cabeza,$cuerpo,$final) = $archivo =~ m/\A (.+?) (\\begin\{document\} .+?)(\\end\{document\}.*)\z/msx;
 
# \pspicture to \begin{pspicture}
$cuerpo =~ s/\\pspicture(\*)?(.+?)\\endpspicture/\\begin{pspicture$1}$2\\end{pspicture$1}/gmsx;
 
# Verbatim environments
my $VERBATIM  = qr/(?: (v|V)erbatim\*?| PSTexample | aling)/xi;
 
# postscript environment
my $POSTSCRIPT = qr/(?: postscript)/xi;
 
# tikzpicture environment
my $ENVIRONMENT    = qr/(?: tikzpicture | pspicture\*?)/xi;
 
# tikz/pst to Postscript
$cuerpo =~ s/\\begin\{$POSTSCRIPT\}.+?\\end\{$POSTSCRIPT\}(*SKIP)(*F)|
        (
        (?:\\(psset|tikzset)(\{(?:\{.*?\}|[^\{])*\}).*?)?  # si está lo guardo
        (\\begin\{($ENVIRONMENT)\} (.*?)  \\end\{\g{-2}\})
    )
    /$BPL\n$1\n$EPL/gmsx;
 
# pgfpicture to Postscript
$cuerpo =~ s/\\begin\{$POSTSCRIPT\}.+?\\end\{$POSTSCRIPT\}(*SKIP)(*F)|
    (
        \\begin\{$sipgf\}
            .*?
            (
                \\begin\{$nopgf\}
                .+?
                \\end\{$nopgf\}
                .*?
            )*?
        \\end\{$sipgf\}
    )
    /$BPL\n$1\n$EPL/gmsx;
 
# other to PostScript
my $EXPORT  = qr/(forest|ganttchart|tikzcd|circuitikz|dependency|$other\*?)/x;
 
$cuerpo =~ s/\\begin\{$POSTSCRIPT\}.+?\\end\{$POSTSCRIPT\}(*SKIP)(*F)|
        (\\begin\{($EXPORT)\} (.*?)  \\end\{\g{-2}\})
        /$BPL\n$1\n$EPL/gmsx;
 
# El nombre del archivo de salida se guarda en $ARGV[1]
my $output = $ARGV[1];
 
# Si $output está presente, validamos
if (defined $output) {
# No comienze por -, -- o .
if ($output =~ /(^\-|^\.).*?/){
    die "$output no es un nombre valido para el archivo de salida\n";
    } #
# Si $output es igual al nombre de entrada agregamos -out
if ($output eq "$ARGV[0]" or $output eq "$name") {
    $output = "$name-out$ext";  
    } #
# Si la última extensión es .ltx o .tex la quitamos
if ($output =~ /.*?$ext/){
    $output =~ s/(.+?)$ext/$1/gms;
    } #
# Escribir la salida
 
print "Creamos $output$ext\n";
open my $SALIDA, '>', "$output$ext";
    print $SALIDA <<"EOC";
$cabeza$cuerpo$final
EOC
close $SALIDA;
} # cerramos defined 
 
__END__
 
Coloreado en 0.004 segundos,  usando GeSHi 1.0.8.4

Quizás se pueda hacer más corto, pero es lo que buscaba.
Agradecido,
Pablo

por **explorer** » 2015-12-09 01:22 @098

O sea, que solo usas GetOptions para saber si el usuario pide ayuda o no... un poco más, y no lo necesitas en absoluto.

Es una lástima que no lo uses para lo que quieres. Bastaría con añadir las líneas que tienes de comprobación del nombre de salida, dentro de GetOptions. Otra cosa es que puedas (a lo peor no tienes toda la información en ese momento), en cuyo caso estás obligado a hacerlo más tarde, como lo tienes ahora.

Otra cosa: no entiendo para qué quieres usar la primera línea.

Esa configuración que muestra la primera línea es para cuando ocurre el extraño caso de que un intérprete, distinto de perl -normalmente el shell-, intente ejecutarlo, y en ese caso, obligarle a ejecutar perl.

Pero eso se hacía hace diez años o más. Hoy en día no es necesario: en sistemas Unix/Linux, el propio sistema sabe qué intérprete debe lanzar basado en la línea shebang (#!/usr/bin/perl...). Y en sistemas Windows, basta con configurar bien el sistema para que asocie la extensión '.pl' al intérprete perl.

por **pablgonz** » 2015-12-09 06:50 @326

explorer escribiste:O sea, que solo usas GetOptions para saber si el usuario pide ayuda o no... un poco más, y no lo necesitas en absoluto.

En realidad uso GetOptions para añadir todo el resto de las opciones dentro del script, ésta es solo una parte (no coloqué todo el código, para que quedara más corto el mensaje), puse algo así como un MWE.

explorer escribiste:...Bastaría con añadir las líneas que tienes de comprobación del nombre de salida, dentro de GetOptions. Otra cosa es que puedas (a lo peor no tienes toda la información en ese momento), en cuyo caso estás obligado a hacerlo más tarde, como lo tienes ahora.

Traté de hacerlo así y no hubo caso...

, de todas maneras, me gusta cómo quedó.

explorer escribiste:Otra cosa: no entiendo para qué quieres usar la primera línea.

Esa configuración que muestra la primera línea es para cuando ocurre el extraño caso de que un intérprete, distinto de perl -normalmente el shell-, intente ejecutarlo, y en ese caso, obligarle a ejecutar perl.
Pero eso se hacía hace diez años o más...

Tienes razón, el primer script que con el que empecé a interesarme en Perl tenía esa primera línea y tiene más de diez años, la actualizaré.

Saludos

Foro - Perl en Español

Opciones usando Getopt::Long

Opciones usando Getopt::Long

Publicidad

Re: Opciones usando Getopt::Long

Re: Opciones usando Getopt::Long

Re: Opciones usando Getopt::Long

Re: Opciones usando Getopt::Long

Re: Opciones usando Getopt::Long

Re: Opciones usando Getopt::Long

Re: Opciones usando Getopt::Long

¿Quién está conectado?