Obtenir le chemin absolu du script exécuté initialement

J'ai cherché haut et bas et j'obtiens beaucoup de différentes solutions et variables contenant des informations pour obtenir le chemin absolu. Mais ils semblent fonctionner dans certaines conditions et pas dans d'autres. Existe-t-il une solution miracle pour obtenir le chemin absolu du script exécuté en PHP? Pour moi, le script s'exécutera à partir de la ligne de commande, mais une solution devrait fonctionner aussi bien si elle est exécutée dans Apache, etc.

Clarification: le script initialement exécuté, pas nécessairement le fichier où la solution est codée.

La bonne solution consiste à utiliser la get_included_filesfonction:

list($scriptPath) = get_included_files();

Cela vous donnera le chemin absolu du script initial même si:

• Cette fonction est placée dans un fichier inclus
• Le répertoire de travail actuel est différent du répertoire du script initial
• Le script est exécuté avec la CLI, comme chemin relatif

Voici deux scripts de test; le script principal et un fichier inclus:

# C:\Users\Redacted\Desktop\main.php
include __DIR__ . DIRECTORY_SEPARATOR . 'include.php';
echoScriptPath();

# C:\Users\Redacted\Desktop\include.php
function echoScriptPath() {
    list($scriptPath) = get_included_files();
    echo 'The script being executed is ' . $scriptPath;
}

Et le résultat; notez le répertoire courant:

C:\>php C:\Users\Redacted\Desktop\main.php
The script being executed is C:\Users\Redacted\Desktop\main.php

__FILE__ constante vous donnera un chemin absolu vers le fichier actuel.

Mise à jour :

La question a été modifiée pour demander comment récupérer le script initialement exécuté au lieu du script en cours d'exécution. La seule (??) manière fiable de le faire est d'utiliser la debug_backtracefonction.

$stack = debug_backtrace();
$firstFrame = $stack[count($stack) - 1];
$initialFile = $firstFrame['file'];

La réponse a été déplacée ici - https://stackoverflow.com/a/26944636/2377343

echo realpath(dirname(__FILE__));

Si vous le placez dans un fichier inclus, il imprime le chemin d'accès à cette inclusion. Pour obtenir le chemin du script parent, remplacez __FILE__par $_SERVER['PHP_SELF']. Mais sachez que PHP_SELF est un risque pour la sécurité!

__DIR__

Du manuel :

Le répertoire du fichier. S'il est utilisé dans une inclusion, le répertoire du fichier inclus est retourné. C'est équivalent à dirname(__FILE__). Ce nom de répertoire n'a pas de barre oblique de fin sauf s'il s'agit du répertoire racine.

__FILE__ contient toujours un chemin absolu avec des liens symboliques résolus alors que dans les versions plus anciennes (que 4.0.2) il contenait un chemin relatif dans certaines circonstances.

Remarque : a __DIR__été ajouté en PHP 5.3.0.

Si vous souhaitez obtenir le répertoire de travail actuel, utilisezgetcwd()

http://php.net/manual/en/function.getcwd.php

__FILE__renverra le chemin avec le nom de fichier par exemple sur XAMPP C:\xampp\htdocs\index.phpau lieu deC:\xampp\htdocs\

dirname(__FILE__) 

donnera l' itinéraire absolu du fichier courant à partir duquel vous demandez l'itinéraire, l'itinéraire de votre répertoire de serveur.

fichiers d'exemple:

www / http / html / index.php; si vous placez ce code dans votre index.php, il renverra:

<?php echo dirname(__FILE__); // this will return: www/http/html/

www / http / html / class / myclass.php; si vous placez ce code dans votre myclass.php, il renverra:

<?php echo dirname(__FILE__); // this will return: www/http/html/class/

Utilisez simplement ci-dessous:

echo __DIR__;

`realpath(dirname(__FILE__))` 

il vous donne le répertoire du script actuel (le script dans lequel vous avez placé ce code) sans barre oblique de fin. c'est important si vous voulez inclure d'autres fichiers avec le résultat

Si vous recherchez le chemin absolu par rapport à la racine du serveur, j'ai trouvé que cela fonctionne bien:

$_SERVER['DOCUMENT_ROOT'] . dirname($_SERVER['SCRIPT_NAME'])

Voici une fonction PHP utile que j'ai écrite pour cela précisément. Comme la question d'origine le clarifie, elle renvoie le chemin à partir duquel le script initial a été exécuté - pas le fichier dans lequel nous sommes actuellement.

/**
 * Get the file path/dir from which a script/function was initially executed
 * 
 * @param bool $include_filename include/exclude filename in the return string
 * @return string
 */ 
function get_function_origin_path($include_filename = true) {
    $bt = debug_backtrace();
    array_shift($bt);
    if ( array_key_exists(0, $bt) && array_key_exists('file', $bt[0]) ) {
        $file_path = $bt[0]['file'];
        if ( $include_filename === false ) {
            $file_path = str_replace(basename($file_path), '', $file_path);
        }
    } else {
        $file_path = null;
    }
    return $file_path;
}

essayez ceci sur votre script

echo getcwd() . "\n";

realpath($_SERVER['SCRIPT_FILENAME'])

Pour le script exécuté sous le serveur Web $_SERVER['SCRIPT_FILENAME'], le chemin d'accès complet au script initialement appelé sera contenu, donc probablement votre index.php. realpath()n'est pas requis dans ce cas.

Pour le script exécuté à partir de la console, $_SERVER['SCRIPT_FILENAME']il contiendra un chemin d'accès relatif à votre script initialement appelé à partir de votre répertoire de travail actuel. Donc, à moins que vous n'ayez modifié le répertoire de travail dans votre script, il se résoudra en chemin absolu.

C'est ce que j'utilise et cela fonctionne dans les environnements Linux. Je ne pense pas que cela fonctionnerait sur une machine Windows ...

//define canonicalized absolute pathname for the script
if(substr($_SERVER['SCRIPT_NAME'],0,1) == DIRECTORY_SEPARATOR) {
    //does the script name start with the directory separator?
    //if so, the path is defined from root; may have symbolic references so still use realpath()
    $script = realpath($_SERVER['SCRIPT_NAME']);
} else {
    //otherwise prefix script name with the current working directory
    //and use realpath() to resolve symbolic references
    $script = realpath(getcwd() . DIRECTORY_SEPARATOR . $_SERVER['SCRIPT_NAME']);
}

Une façon simple d'avoir le chemin absolu du script exécuté d' abord , dans ce script et tout autre script inclus avec include, require, require_onceest à l'aide d' une constante et le stockage il le chemin du script en cours au début du script principal :

define( 'SCRIPT_ROOT', __FILE__ );

La solution ci-dessus convient quand il existe un seul script "principal" qui correspond à includetous les autres scripts nécessaires, comme dans la plupart des applications Web.

Si ce n'est pas le cas et qu'il peut y avoir plusieurs "scripts initiaux", alors pour éviter les redéfinitions et pour avoir le chemin correct stocké dans la constante, chaque script peut commencer par:

if( ! defined( 'SCRIPT_ROOT' ) ) {
    define( 'SCRIPT_ROOT`, __FILE__ );
}

Une note sur la réponse (actuellement) acceptée :

la réponse indique que le chemin du script initialement exécuté est le premier élément du tableau renvoyé par get_included_files().

Il s'agit d'une solution intelligente et simple et -au moment de l'écriture- (nous sommes presque à PHP 7.4.0) cela fonctionne .

Cependant, en regardant la documentation, il n'est pas mentionné que le script initialement exécuté est le premier élément du tableau retourné par get_included_files().

Nous lisons seulement

Le script appelé à l'origine est considéré comme un "fichier inclus", il sera donc répertorié avec les fichiers référencés par include et family.

Au moment de l'écriture, le " script appelé à l'origine " est le premier du tableau mais - techniquement - il n'y a aucune garantie que cela ne changera pas à l'avenir.

Une note sur realpath(), __FILE__et __DIR__:

D' autres ont suggéré dans leurs réponses l'utilisation de __FILE__, __DIR__, dirname(__FILE__), realpath(__DIR__)...

dirname(__FILE__)est égal à __DIR__(introduit en PHP 5.3.0), il suffit donc de l'utiliser __DIR__.

Les deux __FILE__et __DIR__sont toujours des chemins absolus, il realpath()n'est donc pas nécessaire.