Wie erhalte ich den vollständigen Pfad zu einem ausgeführten Perl-Skript?

Ich habe Perl-Skript und muss den vollständigen Pfad und Dateinamen des Skripts während der Ausführung ermitteln. Ich habe festgestellt, dass das Skript je nach Aufruf $0unterschiedlich ist und manchmal das fullpath+filenameund manchmal nur das Skript enthält filename. Da auch das Arbeitsverzeichnis variieren kann, kann ich mir keine Möglichkeit vorstellen, fullpath+filenamedas Skript zuverlässig abzurufen.

Hat jemand eine Lösung?

Es gibt einige Möglichkeiten:

• $0 ist das aktuell ausgeführte Skript, wie es von POSIX bereitgestellt wird, relativ zum aktuellen Arbeitsverzeichnis, wenn sich das Skript im oder unter dem CWD befindet
• Darüber hinaus cwd(), getcwd()und abs_path()werden von dem mitgelieferten CwdModul und Ihnen sagen , wo das Skript aus betrieben wird
• Das Modul FindBinstellt die $Bin& $RealBinVariablen zur Verfügung, die normalerweise den Pfad zum ausführenden Skript darstellen. Dieses Modul bietet auch $Script& $RealScriptdas sind die Namen des Skripts
• __FILE__ ist die eigentliche Datei, mit der sich der Perl-Interpreter während der Kompilierung befasst, einschließlich des vollständigen Pfads.

Ich habe gesehen, dass die ersten drei ( $0, das CwdModul und das FindBinModul) mod_perlspektakulär versagen und wertlose Ausgaben wie '.'oder eine leere Zeichenfolge erzeugen . In solchen Umgebungen verwende __FILE__ich den Pfad und erhalte ihn mithilfe des File::BasenameModuls:

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

$ 0 ist normalerweise der Name Ihres Programms. Wie wäre es damit?

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

Mir scheint, dass dies funktionieren sollte, da abs_path weiß, ob Sie einen relativen oder absoluten Pfad verwenden.

Update Für alle, die dies Jahre später lesen, sollten Sie Drews Antwort lesen . Es ist viel besser als meins.

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

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

Ich denke, das Modul, das Sie suchen, ist FindBin:

#!/usr/bin/perl
use FindBin;

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

Sie können FindBin , Cwd , File :: Basename oder eine Kombination davon verwenden. Sie sind alle in der Basisdistribution von Perl IIRC enthalten.

Ich habe in der Vergangenheit Cwd verwendet:

Cwd:

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

Den absoluten Weg zu $0oder zu finden, __FILE__ist das, was Sie wollen. Das einzige Problem ist, wenn jemand einen gemacht hat chdir()und der $0relativ war - dann müssen Sie den absoluten Pfad in a finden BEGIN{}, um Überraschungen zu vermeiden.

FindBinversucht, besser zu werden und in der Suche $PATHnach etwas Passendem zu suchen basename($0), aber es gibt Zeiten, in denen dies viel zu überraschende Dinge bewirkt (insbesondere: wenn die Datei im cwd "direkt vor Ihnen" liegt).

File::Fuhat File::Fu->program_nameund File::Fu->program_dirdafür.

Einige kurze Hintergrundinformationen:

Leider bietet die Unix-API kein laufendes Programm mit dem vollständigen Pfad zur ausführbaren Datei. Tatsächlich kann das Programm, das Ihr Programm ausführt, alles bereitstellen, was es in dem Feld möchte, das Ihrem Programm normalerweise sagt, was es ist. Wie alle Antworten zeigen, gibt es verschiedene Heuristiken, um wahrscheinliche Kandidaten zu finden. Die Suche im gesamten Dateisystem funktioniert jedoch immer, und selbst das schlägt fehl, wenn die ausführbare Datei verschoben oder entfernt wird.

Sie möchten jedoch nicht die ausführbare Perl-Datei, die tatsächlich ausgeführt wird, sondern das Skript, das sie ausführt. Und Perl muss wissen, wo sich das Skript befindet, um es zu finden. Es speichert dies in __FILE__, während $0es von der Unix-API stammt. Dies kann immer noch ein relativer Weg sein, also nimm Marks Vorschlag und kanonisiere ihn mitFile::Spec->rel2abs( __FILE__ );

Hast du es versucht:

$ENV{'SCRIPT_NAME'}

oder

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

Es hängt wirklich davon ab, wie es aufgerufen wird und ob es CGI ist oder von einer normalen Shell usw. ausgeführt wird.

Um den Pfad zu dem Verzeichnis zu erhalten, das mein Skript enthält, habe ich eine Kombination von bereits gegebenen Antworten verwendet.

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

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

perlfaq8 beantwortet eine sehr ähnliche Frage mit der rel2abs()Funktion on $0. Diese Funktion finden Sie in File :: Spec.

Es müssen keine externen Module verwendet werden. Mit nur einer Zeile können Sie den Dateinamen und den relativen Pfad angeben. Wenn Sie Module verwenden und einen Pfad relativ zum Skriptverzeichnis anwenden müssen, reicht der relative Pfad aus.

$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

Suchst du das?:

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

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

Die Ausgabe sieht folgendermaßen aus:

You are running MyFileName.pl now.

Es funktioniert sowohl unter Windows als auch unter 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 

Das Problem mit __FILE__ ist, dass der Pfad des Kernmoduls ".pm" gedruckt wird, nicht unbedingt der Skriptpfad ".cgi" oder ".pl", der ausgeführt wird. Ich denke, es hängt davon ab, was Ihr Ziel ist.

Es scheint mir, dass Cwdnur für mod_perl aktualisiert werden muss. Hier ist mein Vorschlag:

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;

Bitte fügen Sie Vorschläge hinzu.

Ohne externe Module, gültig für Shell, funktioniert auch mit '../' gut:

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

Prüfung:

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

Das Problem bei der Verwendung dirname(__FILE__)ist, dass es keinen Symlinks folgt. Ich musste dies für mein Skript verwenden, um dem Symlink zum tatsächlichen Speicherort der Datei zu folgen.

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

Alle bibliotheksfreien Lösungen funktionieren nicht auf mehr als ein paar Arten, um einen Pfad zu schreiben (denken Sie an ../ oder /bla/x/../bin/./x/../ usw. Meine Lösung sieht so aus Ich habe eine Besonderheit: Ich habe nicht die geringste Ahnung, warum ich die Ersetzungen zweimal ausführen muss. Wenn ich das nicht tue, bekomme ich ein falsches "./" oder "../". Abgesehen davon scheint mir ziemlich robust zu sein.

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

Keine der "Top" -Antworten war richtig für mich. Das Problem bei der Verwendung von FindBin '$ Bin' oder Cwd besteht darin, dass sie den absoluten Pfad zurückgeben, wobei alle symbolischen Links aufgelöst sind. In meinem Fall brauchte ich den genauen Pfad mit vorhandenen symbolischen Links - genau wie der Unix-Befehl "pwd" und nicht "pwd -P". Die folgende Funktion bietet die Lösung:

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));
}

Unter Windows funktionierte die Verwendung von dirnameund abs_pathzusammen am besten für mich.

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

hier ist der Grund:

# 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";

Was ist los mit $^X?

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

Würde Ihnen den vollständigen Pfad zur verwendeten Perl-Binärdatei geben.

Evert

Unter * nix haben Sie wahrscheinlich den Befehl "whereis", der Ihren $ PATH nach einer Binärdatei mit einem bestimmten Namen durchsucht. Wenn $ 0 nicht den vollständigen Pfadnamen enthält, sollten Sie durch Ausführen von whereis $ scriptname und Speichern des Ergebnisses in einer Variablen feststellen, wo sich das Skript befindet.