¿Cómo obtengo la ruta completa a un script de Perl que se está ejecutando?

Hay algunas maneras:

• $0 es el script que se está ejecutando actualmente como lo proporciona POSIX, relativo al directorio de trabajo actual si el script está en o por debajo del CWD
• Además, cwd(), getcwd() and abs_path() are provided by the Cwd module and tell you where the script is being run from
• El módulo FindBin proporciona la $Bin & $RealBin variables que normalmente son la ruta al script de ejecución; este módulo también proporciona $Script & $RealScript ese es el nombre del script
• __FILE__ es el archivo real con el que el intérprete de Perl trata durante la compilación, incluyendo su ruta completa.

He visto los tres primeros ($0, las Cwd módulo y el FindBin module) falla bajo mod_perl espectacularmente, produciendo una salida sin valor como '.' o una cadena vacía. En tales entornos, utilizo __FILE__ y obtener el camino de que el uso de las File::Basename módulo:

use File::Basename;
my $dirname = dirname(__FILE__);

Use File::Spec;
File::Spec->rel2abs( __FILE__ );

Http://perldoc.perl.org/File/Spec/Unix.html

Creo que el módulo que estás buscando es FindBin:

#!/usr/bin/perl
use FindBin;

$0 = "stealth";
print "The actual path to this is: $FindBin::Bin/$FindBin::Script\n";

Podrías usar FindBin, Cwd, File:: Basename , o una combinación de ellos. Están todos en la distribución base de Perl IIRC.

Usé Cwd en el pasado:

Cwd:

use Cwd qw(abs_path);
my $path = abs_path($0);
print "$path\n";

Obtener la ruta absoluta a $0 o __FILE__ es lo que quieres. El único problema es que si alguien hizo un chdir() y el $0 era relativo you entonces necesitas obtener el camino absoluto en un BEGIN{} para evitar sorpresas.

FindBin intenta hacer algo mejor y arrastrarse en el $PATH para algo que coincida con el basename($0), pero hay veces en que eso hace cosas demasiado sorprendentes (específicamente: cuando el archivo está "justo en frente de usted" en el cwd.)

File::Fu tiene File::Fu->program_name y File::Fu->program_dir por esto.

Algunos antecedentes cortos:

Desafortunadamente la API de Unix no proporciona un programa en ejecución con la ruta completa al ejecutable. De hecho, el programa que ejecuta el suyo puede proporcionar lo que quiera en el campo que normalmente le dice a su programa lo que es. Hay, como todas las respuestas señalan, varias heurísticas para encontrar candidatos probables. Pero nada menos que buscar en todo el sistema de archivos siempre funcionará, e incluso eso fallará si el ejecutable se mueve o quitar.

Pero no quieres el ejecutable de Perl, que es lo que realmente se está ejecutando, sino el script que está ejecutando. Y Perl necesita saber dónde está el script para encontrarlo. Almacena esto en __FILE__, mientras que $0 es de la API de Unix. Esto todavía puede ser un camino relativo, así que toma la sugerencia de Mark y canonízala con File::Spec->rel2abs( __FILE__ );

¿Has intentado:

$ENV{'SCRIPT_NAME'}

O

use FindBin '$Bin';
print "The script is located in $Bin.\n";

Realmente depende de cómo se llama y si es CGI o si se ejecuta desde un shell normal, etc.

Para obtener la ruta al directorio que contiene mi script utilicé una combinación de respuestas ya dadas.

#!/usr/bin/perl
use strict;
use warnings;
use File::Spec;
use File::Basename;

my $dir = dirname(File::Spec->rel2abs(__FILE__));

Perlfaq8 responde a una pregunta muy similar con el uso de la función rel2abs() en $0. Esa función se puede encontrar en File:: Spec.

No es necesario utilizar módulos externos, con una sola línea puede tener el nombre del archivo y la ruta relativa. Si está utilizando módulos y necesita aplicar una ruta relativa al directorio script, la ruta relativa es suficiente.

$0 =~ m/(.+)[\/\\](.+)$/;
print "full path: $1, file name: $2\n";

#!/usr/bin/perl -w
use strict;


my $path = $0;
$path =~ s/\.\///g;
if ($path =~ /\//){
  if ($path =~ /^\//){
    $path =~ /^((\/[^\/]+){1,}\/)[^\/]+$/;
    $path = $1;
    }
  else {
    $path =~ /^(([^\/]+\/){1,})[^\/]+$/;
    my $path_b = $1;
    my $path_a = `pwd`;
    chop($path_a);
    $path = $path_a."/".$path_b;
    }
  }
else{
  $path = `pwd`;
  chop($path);
  $path.="/";
  }
$path =~ s/\/\//\//g;



print "\n$path\n";

: DD

¿Estás buscando esto?:

my $thisfile = $1 if $0 =~
/\\([^\\]*)$|\/([^\/]*)$/;

print "You are running $thisfile
now.\n";

La salida se verá así:

You are running MyFileName.pl now.

Funciona tanto en Windows como en Unix.

use strict ; use warnings ; use Cwd 'abs_path';
    sub ResolveMyProductBaseDir { 

        # Start - Resolve the ProductBaseDir
        #resolve the run dir where this scripts is placed
        my $ScriptAbsolutPath = abs_path($0) ; 
        #debug print "\$ScriptAbsolutPath is $ScriptAbsolutPath \n" ;
        $ScriptAbsolutPath =~ m/^(.*)(\\|\/)(.*)\.([a-z]*)/; 
        $RunDir = $1 ; 
        #debug print "\$1 is $1 \n" ;
        #change the \'s to /'s if we are on Windows
        $RunDir =~s/\\/\//gi ; 
        my @DirParts = split ('/' , $RunDir) ; 
        for (my $count=0; $count < 4; $count++) {   pop @DirParts ;     }
        my $ProductBaseDir = join ( '/' , @DirParts ) ; 
        # Stop - Resolve the ProductBaseDir
        #debug print "ResolveMyProductBaseDir $ProductBaseDir is $ProductBaseDir \n" ; 
        return $ProductBaseDir ; 
    } #eof sub 

El problema con __FILE__ es que imprimirá la ruta del módulo principal ".pm" no necesariamente la ".ruta del script cgi "o". pl " que se está ejecutando. Supongo que depende de cuál sea tu objetivo.

Me parece que Cwd sólo necesita ser actualizado para mod_perl. Aquí está mi sugerencia:

my $path;

use File::Basename;
my $file = basename($ENV{SCRIPT_NAME});

if (exists $ENV{MOD_PERL} && ($ENV{MOD_PERL_API_VERSION} < 2)) {
  if ($^O =~/Win/) {
    $path = `echo %cd%`;
    chop $path;
    $path =~ s!\\!/!g;
    $path .= $ENV{SCRIPT_NAME};
  }
  else {
    $path = `pwd`;
    $path .= "/$file";
  }
  # add support for other operating systems
}
else {
  require Cwd;
  $path = Cwd::getcwd()."/$file";
}
print $path;

Por favor, agregue cualquier sugerencia.

Sin ningún módulo externo, válido para shell, funciona bien incluso con '../':

my $self = `pwd`;
chomp $self;
$self .='/'.$1 if $0 =~/([^\/]*)$/; #keep the filename only
print "self=$self\n";

Prueba:

$ /my/temp/Host$ perl ./host-mod.pl 
self=/my/temp/Host/host-mod.pl

$ /my/temp/Host$ ./host-mod.pl 
self=/my/temp/Host/host-mod.pl

$ /my/temp/Host$ ../Host/./host-mod.pl 
self=/my/temp/Host/host-mod.pl

El problema con solo usar dirname(__FILE__) es que no sigue enlaces simbólicos. Tuve que usar esto para que mi script siguiera el enlace simbólico a la ubicación real del archivo.

use File::Basename;
my $script_dir = undef;
if(-l __FILE__) {
  $script_dir = dirname(readlink(__FILE__));
}
else {
  $script_dir = dirname(__FILE__);
}

Todas las soluciones libres de bibliotecas no funcionan realmente para más de unas pocas maneras de escribir una ruta (piense ../ o /bla/x/../recipiente/./x/../ sucesivamente. Mi solución se ve como abajo. Tengo una peculiaridad: no tengo la menor idea de por qué tengo que ejecutar los reemplazos dos veces. Si no lo hago, obtengo un espurio"./" o "../". Aparte de eso, me parece bastante robusto.

  my $callpath = $0;
  my $pwd = `pwd`; chomp($pwd);

  # if called relative -> add pwd in front
  if ($callpath !~ /^\//) { $callpath = $pwd."/".$callpath; }  

  # do the cleanup
  $callpath =~ s!^\./!!;                          # starts with ./ -> drop
  $callpath =~ s!/\./!/!g;                        # /./ -> /
  $callpath =~ s!/\./!/!g;                        # /./ -> /        (twice)

  $callpath =~ s!/[^/]+/\.\./!/!g;                # /xxx/../ -> /
  $callpath =~ s!/[^/]+/\.\./!/!g;                # /xxx/../ -> /   (twice)

  my $calldir = $callpath;
  $calldir =~ s/(.*)\/([^\/]+)/$1/;

¿Qué tiene de malo $^X?

#!/usr/bin/env perl<br>
print "This is executed by $^X\n";

Le daría la ruta completa al binario de Perl que se está utilizando.

Evert

En *nix, es probable que tenga el comando "whereis", que busca en su PATH PATH un binario con un nombre dado. Si $0 no contiene el nombre completo de la ruta, ejecutar whereis sc scriptname y guardar el resultado en una variable debería indicarle dónde se encuentra el script.