Comment obtenir le chemin complet d'un script Perl en cours d'exécution?

J'ai un script Perl et je dois déterminer le chemin complet et le nom de fichier du script pendant l'exécution. J'ai découvert que selon la façon dont vous appelez le script $0varie et contient parfois le fullpath+filenameet parfois juste filename. Parce que le répertoire de travail peut également varier, je ne peux pas penser à un moyen d'obtenir de manière fiable fullpath+filenamele script.

Quelqu'un a-t-il une solution?

Il existe plusieurs façons:

• $0 est le script en cours d'exécution tel que fourni par POSIX, par rapport au répertoire de travail actuel si le script est au niveau ou en dessous du CWD
• De plus, cwd(), getcwd()et abs_path()sont fournis par le Cwdmodule et vous dire où le script est exécuté à partir
• Le module FindBinfournit les variables $Bin& $RealBinqui sont généralement le chemin vers le script en cours d'exécution; ce module fournit également $Script& $RealScriptqui sont le nom du script
• __FILE__ est le fichier réel traité par l'interpréteur Perl lors de la compilation, y compris son chemin complet.

J'ai vu les trois premiers ( $0, le Cwdmodule et le FindBinmodule) échouer de façon mod_perlspectaculaire, produisant une sortie sans valeur telle qu'une '.'chaîne vide. Dans de tels environnements, j'utilise __FILE__et j'obtiens le chemin à partir de celui en utilisant le File::Basenamemodule:

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

$ 0 est généralement le nom de votre programme, alors qu'en est-il de cela?

use Cwd 'abs_path';
print abs_path($0);

Il me semble que cela devrait fonctionner car abs_path sait si vous utilisez un chemin relatif ou absolu.

Mise à jour Pour quiconque lira ces années plus tard, vous devriez lire la réponse de Drew . C'est bien mieux que le mien.

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

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

Je pense que le module que vous recherchez est FindBin:

#!/usr/bin/perl
use FindBin;

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

Vous pouvez utiliser FindBin , Cwd , File :: Basename ou une combinaison de ceux-ci. Ils sont tous dans la distribution de base de Perl IIRC.

J'ai utilisé Cwd dans le passé:

Cwd:

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

Obtenir le chemin absolu vers $0ou __FILE__est ce que vous voulez. Le seul problème est que si quelqu'un a fait un chdir()et que le $0était relatif - alors vous devez obtenir le chemin absolu dans a BEGIN{}pour éviter toute surprise.

FindBinessaie de faire mieux et de ramper dans le $PATHpour quelque chose qui correspond à basename($0), mais il y a des moments où cela fait des choses beaucoup trop surprenantes (en particulier: lorsque le fichier est "juste devant vous" dans le cwd.)

File::Fua File::Fu->program_nameet File::Fu->program_dirpour cela.

Quelques brèves informations:

Malheureusement, l'API Unix ne fournit pas de programme en cours d'exécution avec le chemin complet de l'exécutable. En fait, le programme qui exécute le vôtre peut fournir tout ce qu'il veut sur le terrain qui indique normalement à votre programme ce qu'il est. Il existe, comme toutes les réponses le soulignent, diverses heuristiques pour trouver des candidats probables. Mais rien de moins qu'une recherche dans tout le système de fichiers fonctionnera toujours, et même cela échouera si l'exécutable est déplacé ou supprimé.

Mais vous ne voulez pas de l'exécutable Perl, qui est ce qui est en cours d'exécution, mais du script qu'il exécute. Et Perl a besoin de savoir où se trouve le script pour le trouver. Il stocke cela dans __FILE__, alors qu'il $0provient de l'API Unix. Cela peut encore être un chemin relatif, alors prenez la suggestion de Mark et canonisez-la avecFile::Spec->rel2abs( __FILE__ );

As-tu essayé:

$ENV{'SCRIPT_NAME'}

ou

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

Cela dépend vraiment de la façon dont il est appelé et si c'est CGI ou exécuté à partir d'un shell normal, etc.

Afin d'obtenir le chemin vers le répertoire contenant mon script, j'ai utilisé une combinaison de réponses déjà données.

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

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

perlfaq8 répond à une question très similaire en utilisant la rel2abs()fonction on $0. Cette fonction peut être trouvée dans File :: Spec.

Il n'est pas nécessaire d'utiliser des modules externes, avec une seule ligne, vous pouvez avoir le nom du fichier et le chemin relatif. Si vous utilisez des modules et devez appliquer un chemin relatif au répertoire de script, le chemin relatif est suffisant.

$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

Vous cherchez cela?:

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

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

La sortie ressemblera à ceci:

You are running MyFileName.pl now.

Cela fonctionne à la fois sous Windows et 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 

Le problème avec __FILE__est qu'il affichera le chemin du module principal ".pm" pas nécessairement le chemin du script ".cgi" ou ".pl" en cours d'exécution. Je suppose que cela dépend de votre objectif.

Il me semble qu'il Cwdsuffit de mettre à jour mod_perl. Voici ma suggestion:

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;

Veuillez ajouter des suggestions.

Sans aucun module externe, valable pour le shell, fonctionne bien même avec '../':

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

tester:

$ /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

Le problème avec la simple utilisation dirname(__FILE__)est qu'il ne suit pas les liens symboliques. J'ai dû l'utiliser pour que mon script suive le lien symbolique vers l'emplacement réel du fichier.

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

Toutes les solutions sans bibliothèque ne fonctionnent pas pour plus de quelques façons d'écrire un chemin (pensez ../ ou /bla/x/../bin/./x/../ etc. Ma solution ressemble à ci-dessous. J'ai une particularité: je n'ai pas la moindre idée de la raison pour laquelle je dois exécuter les remplacements deux fois. Sinon, j'obtiens un faux "./" ou "../". À part cela, il me semble assez robuste.

  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/;

Aucune des réponses «top» ne me convenait. Le problème avec l'utilisation de FindBin '$ Bin' ou Cwd est qu'ils renvoient un chemin absolu avec tous les liens symboliques résolus. Dans mon cas, j'avais besoin du chemin exact avec les liens symboliques présents - le même que celui qui renvoie la commande Unix "pwd" et non "pwd -P". La fonction suivante fournit la solution:

sub get_script_full_path {
    use File::Basename;
    use File::Spec;
    use Cwd qw(chdir cwd);
    my $curr_dir = cwd();
    chdir(dirname($0));
    my $dir = $ENV{PWD};
    chdir( $curr_dir);
    return File::Spec->catfile($dir, basename($0));
}

Sur Windows, l'utilisation dirnameet abs_pathensemble fonctionnaient mieux pour moi.

use File::Basename;
use Cwd qw(abs_path);

# absolute path of the directory containing the executing script
my $abs_dirname = dirname(abs_path($0));
print "\ndirname(abs_path(\$0)) -> $abs_dirname\n";

Voici pourquoi:

# this gives the answer I want in relative path form, not absolute
my $rel_dirname = dirname(__FILE__); 
print "dirname(__FILE__) -> $rel_dirname\n"; 

# this gives the slightly wrong answer, but in the form I want 
my $full_filepath = abs_path($0);
print "abs_path(\$0) -> $full_filepath\n";

Quel est le problème avec $^X?

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

Vous donnerait le chemin complet du binaire Perl utilisé.

Evert

Sur * nix, vous avez probablement la commande "whereis", qui recherche votre $ PATH à la recherche d'un binaire avec un nom donné. Si $ 0 ne contient pas le nom du chemin complet, exécuter whereis $ scriptname et enregistrer le résultat dans une variable devrait vous indiquer où se trouve le script.