Obtenga la ruta absoluta del script ejecutado inicialmente

He buscado arriba y abajo y obtengo muchas soluciones y variables diferentes que contienen información para obtener la ruta absoluta. Pero parecen funcionar en algunas condiciones y no en otras. ¿Hay una forma de bala de plata para obtener la ruta absoluta del script ejecutado en PHP? Para mí, el script se ejecutará desde la línea de comandos, pero una solución debería funcionar igual de bien si se ejecuta dentro de Apache, etc.

Aclaración: El script ejecutado inicialmente, no necesariamente el archivo donde se codifica la solución.

La solución correcta es usar la get_included_filesfunción:

list($scriptPath) = get_included_files();

Esto le dará la ruta absoluta de la secuencia de comandos inicial, incluso si:

• Esta función se coloca dentro de un archivo incluido
• El directorio de trabajo actual es diferente del directorio del script inicial
• El script se ejecuta con la CLI, como una ruta relativa

Aquí hay dos scripts de prueba; El guión principal y un archivo incluido:

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

Y el resultado; observe el directorio actual:

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

__FILE__ constante le dará la ruta absoluta al archivo actual.

Actualización :

La pregunta se cambió para preguntar cómo recuperar el script ejecutado inicialmente en lugar del script actualmente en ejecución. La única (??) forma confiable de hacerlo es usar la debug_backtracefunción.

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

La respuesta se ha movido aquí: https://stackoverflow.com/a/26944636/2377343

echo realpath(dirname(__FILE__));

Si coloca esto en un archivo incluido, imprime la ruta a esta inclusión. Para obtener la ruta del script principal, reemplace __FILE__con $_SERVER['PHP_SELF']. ¡Pero tenga en cuenta que PHP_SELF es un riesgo de seguridad!

__DIR__

Del manual :

El directorio del archivo. Si se usa dentro de un include, se devuelve el directorio del archivo incluido. Esto es equivalente a dirname(__FILE__). Este nombre de directorio no tiene una barra inclinada final a menos que sea el directorio raíz.

__FILE__ siempre contiene una ruta absoluta con enlaces simbólicos resueltos, mientras que en versiones anteriores (que 4.0.2) contenía una ruta relativa en algunas circunstancias.

Nota : __DIR__se agregó en PHP 5.3.0.

Si quieres obtener el directorio de trabajo actual, usegetcwd()

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

__FILE__devolverá la ruta con el nombre del archivo, por ejemplo, en XAMPP en C:\xampp\htdocs\index.phplugar deC:\xampp\htdocs\

dirname(__FILE__) 

dará la ruta absoluta del archivo actual desde el que solicita la ruta, la ruta del directorio de su servidor.

archivos de ejemplo:

www / http / html / index.php; si coloca este código dentro de su index.php devolverá:

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

www / http / html / class / myclass.php; si coloca este código dentro de su myclass.php devolverá:

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

Solo use a continuación:

echo __DIR__;

`realpath(dirname(__FILE__))` 

le da el directorio actual del script (el script dentro del cual colocó este código) sin barra diagonal final. Esto es importante si desea incluir otros archivos con el resultado

Si está buscando la ruta absoluta relativa a la raíz del servidor, descubrí que esto funciona bien:

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

Aquí hay una útil función PHP que escribí para esto precisamente. Como aclara la pregunta original, devuelve la ruta desde la que se ejecutó el script inicial , no el archivo en el que estamos actualmente.

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

prueba esto en tu script

echo getcwd() . "\n";

realpath($_SERVER['SCRIPT_FILENAME'])

Para la secuencia de comandos ejecutada en el servidor web $_SERVER['SCRIPT_FILENAME']contendrá la ruta completa a la secuencia de comandos inicialmente llamada, por lo que probablemente su index.php.realpath()No es necesario en este caso.

Para el script ejecutado desde la consola $_SERVER['SCRIPT_FILENAME'], contendrá la ruta relativa a su script inicialmente llamado desde su directorio de trabajo actual. Entonces, a menos que haya cambiado el directorio de trabajo dentro de su script, se resolverá en la ruta absoluta.

Esto es lo que uso y funciona en entornos Linux. No creo que esto funcione en una máquina con 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']);
}

Una manera simple de tener la ruta absoluta del guión inicialmente ejecutado , en esa secuencia de comandos y cualquier otra secuencia de comandos se incluye con include, require, require_oncees mediante el uso de una constante y almacenar allí la ruta del script actual al inicio del script principal :

define( 'SCRIPT_ROOT', __FILE__ );

La solución anterior es adecuada cuando hay un solo script "principal" que includees cualquier otro script necesario, como en la mayoría de las aplicaciones web.

Si ese no es el caso y puede haber varios "guiones iniciales", para evitar redefiniciones y tener la ruta correcta almacenada dentro de la constante, cada guión puede comenzar con:

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

Una nota sobre la respuesta (actualmente) aceptada :

la respuesta indica que la ruta de script ejecutada inicialmente es el primer elemento de la matriz devuelta por get_included_files() .

Esta es una solución inteligente y simple y, al momento de escribir, (estamos casi en PHP 7.4.0) funciona .

Sin embargo, al mirar la documentación no se menciona que el script ejecutado inicialmente es el primer elemento de la matriz devuelto porget_included_files() .

Solo leemos

El script llamado originalmente se considera un "archivo incluido", por lo que se enumerará junto con los archivos a los que hace referencia include y family.

Al momento de escribir, el " script originalmente llamado " es el primero en la matriz pero, técnicamente , no hay garantía de que esto no cambie en el futuro.

Una nota acerca realpath(), __FILE__y __DIR__:

Otros han sugerido en sus respuestas al uso de __FILE__, __DIR__, dirname(__FILE__), realpath(__DIR__)...

dirname(__FILE__)es igual a __DIR__(introducido en PHP 5.3.0), así que solo use__DIR__ .

Ambos __FILE__y __DIR__siempre son caminos absolutos, por lo que realpath()es innecesario.