page - Obtén la URL completa en PHP

request_uri

Question

Yo uso este código para obtener la URL completa:

$actual_link = ''http://''.$_SERVER[''HTTP_HOST''].$_SERVER[''PHP_SELF''];

El problema es que uso algunas máscaras en mi .htaccess , por lo que lo que vemos en la URL no siempre es la ruta real del archivo.

Lo que necesito es obtener la URL, lo que está escrito en la URL, nada más y nada menos, la URL completa.

Necesito saber cómo aparece en la barra de navegación en el navegador web, y no en la ruta real del archivo en el servidor.

Answer 1

Versión corta al enlace de salida en una página web

$url =  "//{$_SERVER[''HTTP_HOST'']}{$_SERVER[''REQUEST_URI'']}";

$escaped_url = htmlspecialchars( $url, ENT_QUOTES, ''UTF-8'' );
echo ''<a href="'' . $escaped_url . ''">'' . $escaped_url . ''</a>'';

Aquí hay algunos detalles más sobre los problemas y casos de borde del formato //example.com/path/

Versión completa

function url_origin( $s, $use_forwarded_host = false )
{
    $ssl      = ( ! empty( $s[''HTTPS''] ) && $s[''HTTPS''] == ''on'' );
    $sp       = strtolower( $s[''SERVER_PROTOCOL''] );
    $protocol = substr( $sp, 0, strpos( $sp, ''/'' ) ) . ( ( $ssl ) ? ''s'' : '''' );
    $port     = $s[''SERVER_PORT''];
    $port     = ( ( ! $ssl && $port==''80'' ) || ( $ssl && $port==''443'' ) ) ? '''' : '':''.$port;
    $host     = ( $use_forwarded_host && isset( $s[''HTTP_X_FORWARDED_HOST''] ) ) ? $s[''HTTP_X_FORWARDED_HOST''] : ( isset( $s[''HTTP_HOST''] ) ? $s[''HTTP_HOST''] : null );
    $host     = isset( $host ) ? $host : $s[''SERVER_NAME''] . $port;
    return $protocol . ''://'' . $host;
}

function full_url( $s, $use_forwarded_host = false )
{
    return url_origin( $s, $use_forwarded_host ) . $s[''REQUEST_URI''];
}

$absolute_url = full_url( $_SERVER );
echo $absolute_url;

Esta es una versión muy modificada de http://snipplr.com/view.php?codeview&id=2734 .

Estructura de URL:

esquema: // nombre de usuario: contraseña @dominio: puerto / ruta de acceso? query_string # fragment_id

Las partes en negrita no serán incluidas por la función.

Notas:

• Esta función no incluye el username:password de una URL completa o el fragmento (hash).
• No mostrará el puerto predeterminado 80 para HTTP y el puerto 443 para HTTPS.
• Solo probado con los esquemas http y https.
• El #fragment_id no es enviado al servidor por el cliente (navegador) y no se agregará a la URL completa.
• $_GET solo contendrá foo=bar2 para una URL como /example?foo=bar1&foo=bar2 .
• Algunos CMS y entornos reescribirán $_SERVER[''REQUEST_URI''] y devolverán /example?foo=bar2 para una URL como /example?foo=bar1&foo=bar2 , use $_SERVER[''QUERY_STRING''] en este caso.
• Tenga en cuenta que un URI = URL + URN , pero debido al uso popular, URL ahora significa tanto URI como URL.
• Debe eliminar HTTP_X_FORWARDED_HOST si no planea usar proxies o balanceadores.
• La spec dice que el encabezado del Host debe contener el número de puerto a menos que sea el número predeterminado.

Variables controladas por el cliente (navegador):

• $_SERVER[''REQUEST_URI''] . Los caracteres no compatibles están codificados por el navegador antes de ser enviados.
• $_SERVER[''HTTP_HOST''] y no siempre está disponible de acuerdo con los comentarios en el manual de PHP: http://php.net/manual/en/reserved.variables.php
• $_SERVER[''HTTP_X_FORWARDED_HOST''] se establece mediante balanceadores y no se menciona en la lista de variables $_SERVER en el manual de PHP.

Variables controladas por el servidor:

• $_SERVER[''HTTPS''] . El cliente elige usar esto, pero el servidor devuelve el valor real de vacío o "encendido".
• $_SERVER[''SERVER_PORT''] . El servidor solo acepta números permitidos como puertos.
• $_SERVER[''SERVER_PROTOCOL''] . El servidor solo acepta ciertos protocolos.
• $_SERVER[''SERVER_NAME''] . Se configura manualmente en la configuración del servidor y no está disponible para IPv6 de acuerdo con kralyk .

Relacionado:

HTTP_HOST vs. SERVER_NAME
¿Se requiere el número de puerto en el parámetro de encabezado "host" de HTTP?
https://stackoverflow.com/a/28049503/175071

Answer 2

Aquí está mi solución: el código está inspirado en Tracy Debugger . Se cambió para soportar diferentes puertos de servidor. Puede obtener la URL actual completa incluyendo $_SERVER[''REQUEST_URI''] o solo la URL básica del servidor. Revisa mi función:

function getCurrentUrl($full = true) {
    if (isset($_SERVER[''REQUEST_URI''])) {
        $parse = parse_url(
            (isset($_SERVER[''HTTPS'']) && strcasecmp($_SERVER[''HTTPS''], ''off'') ? ''https://'' : ''http://'') .
            (isset($_SERVER[''HTTP_HOST'']) ? $_SERVER[''HTTP_HOST''] : (isset($_SERVER[''SERVER_NAME'']) ? $_SERVER[''SERVER_NAME''] : '''')) . (($full) ? $_SERVER[''REQUEST_URI''] : null)
        );
        $parse[''port''] = $_SERVER["SERVER_PORT"]; // Setup protocol for sure (80 is default)
        return http_build_url('''', $parse);
    }
}

Aquí está el código de prueba:

// Follow $_SERVER variables was set only for test
$_SERVER[''HTTPS''] = ''off''; // on
$_SERVER[''SERVER_PORT''] = ''9999''; // Setup
$_SERVER[''HTTP_HOST''] = ''some.crazy.server.5.name:8088''; // Port is optional there
$_SERVER[''REQUEST_URI''] = ''/150/tail/single/normal?get=param'';

echo getCurrentUrl();
// http://some.crazy.server.5.name:9999/150/tail/single/normal?get=param

echo getCurrentUrl(false);
// http://some.crazy.server.5.name:9999/

Answer 3

Aquí hay una solución que usa una declaración ternaria , manteniendo el código mínimo:

$url = "http" . (($_SERVER[''SERVER_PORT''] == 443) ? "s" : "") . "://" . $_SERVER[''HTTP_HOST''] . $_SERVER[''REQUEST_URI''];

Esta es la forma más pequeña y fácil de hacer esto, asumiendo que el servidor web de uno está usando el puerto estándar 443 para HTTPS .

Answer 4

Borrar código, trabajando en todos los servidores web (Apache, nginx, IIS, ...):

$url = (isset($_SERVER[''HTTPS'']) && $_SERVER[''HTTPS''] !== ''off'' ? ''https'' : ''http'') . ''://'' . $_SERVER[''HTTP_HOST''] . $_SERVER[''REQUEST_URI''];

Answer 5

Echa un vistazo a $_SERVER[''REQUEST_URI''] , es decir

$actual_link = "http://$_SERVER[HTTP_HOST]$_SERVER[REQUEST_URI]";

(Tenga en cuenta que la sintaxis de cadena entre comillas dobles es perfectamente correcta )

Si desea admitir HTTP y HTTPS, puede usar

$actual_link = (isset($_SERVER[''HTTPS'']) && $_SERVER[''HTTPS''] === ''on'' ? "https" : "http") . "://$_SERVER[HTTP_HOST]$_SERVER[REQUEST_URI]";

Nota del editor: el uso de este código tiene implicaciones de seguridad . El cliente puede configurar HTTP_HOST y REQUEST_URI en cualquier valor arbitrario que desee.

Answer 6

Ejemplos de URL: https://example.com/subFolder/myfile.php?k=blaa#12345

// ======= PATHINFO ====== //
$x = pathinfo($url);
$x[''dirname'']      🡺 https://example.com/subFolder
$x[''basename'']     🡺                               myfile.php?
$x[''extension'']    🡺                                      php?k=blaa#12345  // SECURITY HOLE !!!
$x[''filename'']     🡺                               myfile

// ======= PARSE_URL ====== //
$x = parse_url($url);
$x[''scheme'']       🡺 https
$x[''host'']         🡺         example.com
$x[''path'']         🡺                    /subFolder/myfile.php
$x[''query'']        🡺                                          k=blaa
$x[''fragment'']     🡺                                                 12345 // BUT ! about hashtag part, read notice in post bottom

//=================================================== //
//========== self-defined SERVER variables ========== //
//=================================================== //
$_SERVER["DOCUMENT_ROOT"]  🡺 /home/user/public_html
$_SERVER["SERVER_ADDR"]    🡺 143.34.112.23
$_SERVER["SERVER_PORT"]    🡺 80(or 443 etc..)
$_SERVER["REQUEST_SCHEME"] 🡺 https                                         //similar: $_SERVER["SERVER_PROTOCOL"] 
$_SERVER[''HTTP_HOST'']      🡺         example.com (or with WWW)             //similar: $_SERVER["ERVER_NAME"]
$_SERVER["REQUEST_URI"]    🡺                       /subFolder/myfile.php?k=blaa
$_SERVER["QUERY_STRING"]   🡺                                             k=blaa
__FILE__                   🡺 /home/user/public_html/subFolder/myfile.php
__DIR__                    🡺 /home/user/public_html/subFolder              //same: dirname(__FILE__)
$_SERVER["REQUEST_URI"]    🡺                       /subFolder/myfile.php?k=blaa
parse_url($_SERVER["REQUEST_URI"], PHP_URL_PATH)🡺  /subFolder/myfile.php 
$_SERVER["PHP_SELF"]       🡺                       /subFolder/myfile.php

// ==================================================================//
//if "myfile.php" is included in "PARENTFILE.php" , and you visit  "PARENTFILE.PHP?abc":
$_SERVER["SCRIPT_FILENAME"]🡺 /home/user/public_html/parentfile.php
$_SERVER["PHP_SELF"]       🡺                       /parentfile.php
$_SERVER["REQUEST_URI"]    🡺                       /parentfile.php?abc
__FILE__                   🡺 /home/user/public_html/subFolder/myfile.php

// =================================================== //
// ================= handy variables ================= //
// =================================================== //
//If site uses HTTPS:
$HTTP_or_HTTPS = ((!empty($_SERVER[''HTTPS'']) && $_SERVER[''HTTPS'']!==''off'') || $_SERVER[''SERVER_PORT'']==443) ? ''https://'':''http://'' );            //in some cases, you need to add this condition too: if (''https''==$_SERVER[''HTTP_X_FORWARDED_PROTO''])  ...

//To trim values to filename, i.e. 
basename($url)             🡺 myfile.php

//excellent solution to find origin
$debug_files = debug_backtrace();     $initial_called_file = count($debug_files) ? $debug_files[count($debug_files) - 1][''file''] : __FILE__;

¡Darse cuenta!:

• DIRECTORY_SEPARATOR devuelve / para hostings tipo Windows, en lugar de / .
• las partes del hashtag ( #xyz.. ) no pueden ser detectadas por los lenguajes SERVER-SIDE (como PHP). Entonces, recuerde, que las variables $_SERVER no pueden detectar las partes de HASHTAG (JavaScript lo hace), por lo que tiene que proporcionarlas manualmente en código php .
  

Para WordPress

//(let''s say, if wordpress is installed in subdirectory:  http://example.com/wpdir/)
home_url()                      🡺 http://example.com/wpdir/        //if is_ssl() is true, then it will be "https"
get_stylesheet_directory_uri()  🡺 http://example.com/wpdir/wp-content/themes/THEME_NAME  [same: get_bloginfo(''template_url'') ]
get_stylesheet_directory()      🡺 /home/user/public_html/wpdir/wp-content/themes/THEME_NAME
plugin_dir_url(__FILE__)        🡺 http://example.com/wpdir/wp-content/themes/PLUGIN_NAME
plugin_dir_path(__FILE__)       🡺 /home/user/public_html/wpdir/wp-content/plugins/PLUGIN_NAME/  

Answer 7

He hecho esta clase para manejar mi URI

<?php
/** -------------------------------------------------------------------------------------------------------------------
 * URI CLASS
 * URI management class
 *
 * @author Sandu Liviu Catalin
 * @email slc(dot)universe(at)gmail(dot)com
 * @license Public Domain
**/
abstract class _URI
{
    /** ---------------------------------------------------------------------------------------------------------------
     *  - BASE PARAMETERS
     * $_Script_Hidden - Hide the script name from the returned URI
     * $_Public_Path - Location where public resources are stored
     * $_Public_Relative - Return the relative path version of public location
     * $_Public_Skin - Is the skin directory located in the public directory
     * $_Skin_Path - Location where skins are stored
     * $_Skin_Relative - Return the relative path version of skin location
     * $_Skin_Default - Use this as the default system skin
     * $_Fallback_Base - Use this base URL if you can''t extract the current URL
     * $_Fallback_Scheme - Use this scheme if you can''t find it automatically
     * $_Fallback_User - Use this user name if you can''t find it automatically
     * $_Fallback_Passwd - Use this password if you can''t find it automatically
     * $_Fallback_Host - Use this host if you can''t find it automatically
     * $_Fallback_Port - Use this port number if you can''t find it automatically
     * $_Fallback_Script - Use this script name if you can''t find it automatically
     * $_Separator_Scheme - Use this to separate the scheme from the rest of the url
     * $_Separator_Credentials - Use this to separate the user name from the password
     * $_Separator_Auth - Use this to separate the user name and password from host
     * $_Separator_Port - Use this to separate the port number from host
     * $_Separator_Query - Use this to separate the query data from base URL
     * $_Separator_Fragment - Use this to separate the fragment data from query data
    */
    protected static $_Script_Hidden;
    protected static $_Public_Path;
    protected static $_Public_Relative;
    protected static $_Public_Skin;
    protected static $_Skin_Path;
    protected static $_Skin_Relative;
    protected static $_Skin_Default;
    protected static $_Fallback_Base;
    protected static $_Fallback_Scheme;
    protected static $_Fallback_User;
    protected static $_Fallback_Passwd;
    protected static $_Fallback_Host;
    protected static $_Fallback_Port;
    protected static $_Fallback_Script;
    protected static $_Separator_Scheme;
    protected static $_Separator_Credentials;
    protected static $_Separator_Auth;
    protected static $_Separator_Port;
    protected static $_Separator_Query;
    protected static $_Separator_Fragment;

    /** ----------------------------------------------------------------------------------------------------------------
     * CACHED BASES
     * Precompiled common URLs for quick retrieval
    */
    protected static $Base_Host;
    protected static $Base_App;
    protected static $Base_Script;
    protected static $Base_Current;
    protected static $Base_Public;
    protected static $Base_Skin;

    /** ----------------------------------------------------------------------------------------------------------------
     * DATA CONTAINERS
     * Raw URI segments saved from extracted data
    */
    protected static $__Segments = array(
        ''SCHEME'' => '''',
        ''USER'' => '''',
        ''PASSWD'' => '''',
        ''HOST'' => '''',
        ''PORT'' => '''',
        ''PATH'' => '''',
        ''SCRIPT'' => '''',
        ''INFO'' => '''',
        ''QUERY'' => '''',
    );

    /** ----------------------------------------------------------------------------------------------------------------
     * PARSER KEYWORDS
     * URI data asigned to specific keywords.
    */
    protected static $__Parsers;

    /** ----------------------------------------------------------------------------------------------------------------
     * CLASS INITIALIZER
     * Initialize the class
     *
     * @access public
     * @param $Params [array] - An associative array of supported parrameters
     * @return void
    */
    public static function __Init($Params=array())
    {
        // Configure the class
        self::$_Script_Hidden = (isset($Params[''Script_Hidden''])) ? $Params[''Script_Hidden''] : FALSE;
        self::$_Public_Path = (isset($Params[''Public_Path''])) ? $Params[''Public_Path''] : ''public'';
        self::$_Public_Relative = (isset($Params[''Public_Relative''])) ? $Params[''Public_Relative''] : TRUE;
        self::$_Public_Skin = (isset($Params[''Public_Skin''])) ? $Params[''Public_Skin''] : TRUE;
        self::$_Skin_Path = (isset($Params[''Skin_Path''])) ? $Params[''Skin_Path''] : ''themes'';
        self::$_Skin_Relative = (isset($Params[''Skin_Relative''])) ? $Params[''Skin_Relative''] : TRUE;
        self::$_Skin_Default = (isset($Params[''Skin_Default''])) ? $Params[''Skin_Default''] : ''default'';
        self::$_Fallback_Base = (isset($Params[''Fallback_Base''])) ? $Params[''Fallback_Base''] : ''127.0.0.1'';
        self::$_Fallback_Scheme = (isset($Params[''Fallback_Scheme''])) ? $Params[''Fallback_Scheme''] : ''http'';
        self::$_Fallback_User = (isset($Params[''Fallback_User''])) ? $Params[''Fallback_User''] : '''';
        self::$_Fallback_Passwd = (isset($Params[''Fallback_Passwd''])) ? $Params[''Fallback_Passwd''] : '''';
        self::$_Fallback_Host = (isset($Params[''Fallback_Host''])) ? $Params[''Fallback_Host''] : ''127.0.0.1'';
        self::$_Fallback_Port = (isset($Params[''Fallback_Port''])) ? $Params[''Fallback_Port''] : '''';
        self::$_Fallback_Script = (isset($Params[''Fallback_Script''])) ? $Params[''Fallback_Script''] : ''index.php'';
        self::$_Separator_Scheme = (isset($Params[''Separator_Scheme''])) ? $Params[''Separator_Scheme''] : ''://'';
        self::$_Separator_Credentials = (isset($Params[''Separator_Credentials''])) ? $Params[''Separator_Credentials''] : '':'';
        self::$_Separator_Auth = (isset($Params[''Separator_Auth''])) ? $Params[''Separator_Auth''] : ''@'';
        self::$_Separator_Port = (isset($Params[''Separator_Port''])) ? $Params[''Separator_Port''] : '':'';
        self::$_Separator_Query = (isset($Params[''Separator_Query''])) ? $Params[''Separator_Query''] : ''?'';
        self::$_Separator_Fragment = (isset($Params[''Separator_Fragment''])) ? $Params[''Separator_Fragment''] : ''#'';
        // Do some clean up of the configurations
        self::$_Public_Path = implode(''/'', explode(''/'', str_replace(array(''/'', ''//'), ''/'', self::$_Public_Path)));
        self::$_Skin_Path = implode(''/'', explode(''/'', str_replace(array(''/'', ''//'), ''/'', self::$_Skin_Path)));
        // Extract the URL information
        self::Extract();
        // Precompile common bases
        self::$Base_Host = self::Compile(''HOST'');
        self::$Base_App = self::Compile(''PATH'');
        self::$Base_Script = self::$Base_App.(self::$_Script_Hidden ? '''' : ''/''.self::$__Segments[''SCRIPT'']);
        self::$Base_Current = self::$Base_Script.(empty(self::$__Segments[''INFO'']) ? '''' : ''/''.self::$__Segments[''INFO'']);
        self::$Base_Public = self::$_Public_Relative ? self::$_Public_Path : self::$Base_App.''/''.self::$_Public_Path;
        self::$Base_Skin = self::$_Skin_Relative ? self::$_Skin_Path : self::$Base_Public.''/''.self::$_Skin_Path;
        self::$Base_Skin .= ''/''.self::$_Skin_Default;
        // Setup the parsers
        self::$__Parsers[''SR_Key''][] = ''%HostBase%'';
        self::$__Parsers[''SR_Data''][] =& self::$Base_Host;
        self::$__Parsers[''SR_Key''][] = ''%AppBase%'';
        self::$__Parsers[''SR_Data''][] =& self::$Base_App;
        self::$__Parsers[''SR_Key''][] = ''%ScriptBase%'';
        self::$__Parsers[''SR_Data''][] =& self::$Base_Script;
        self::$__Parsers[''SR_Key''][] = ''%CurrentBase%'';
        self::$__Parsers[''SR_Data''][] =& self::$Base_Current;
        self::$__Parsers[''SR_Key''][] = ''%PublicBase%'';
        self::$__Parsers[''SR_Data''][] =& self::$Base_Public;
        self::$__Parsers[''SR_Key''][] = ''%SkinBase%'';
        self::$__Parsers[''SR_Data''][] =& self::$Base_Skin;
        self::$__Parsers[''SR_Data''][] =& self::$__Segments[''SCHEME''];
        self::$__Parsers[''SR_Key''][] = ''%UserSegment%'';
        self::$__Parsers[''SR_Data''][] =& self::$__Segments[''USER''];
        self::$__Parsers[''SR_Key''][] = ''%PasswdSegment%'';
        self::$__Parsers[''SR_Data''][] =& self::$__Segments[''PASSWD''];
        self::$__Parsers[''SR_Key''][] = ''%HostSegment%'';
        self::$__Parsers[''SR_Data''][] =& self::$__Segments[''HOST''];
        self::$__Parsers[''SR_Key''][] = ''%PortSegment%'';
        self::$__Parsers[''SR_Data''][] =& self::$__Segments[''PORT''];
        self::$__Parsers[''SR_Key''][] = ''%PathSegment%'';
        self::$__Parsers[''SR_Data''][] =& self::$__Segments[''PATH''];
        self::$__Parsers[''SR_Key''][] = ''%ScriptSegment%'';
        self::$__Parsers[''SR_Data''][] =& self::$__Segments[''SCRIPT''];
        self::$__Parsers[''SR_Key''][] = ''%InfoSegment%'';
        self::$__Parsers[''SR_Data''][] =& self::$__Segments[''INFO''];
        self::$__Parsers[''SR_Key''][] = ''%QuerySegment%'';
        self::$__Parsers[''SR_Data''][] =& self::$__Segments[''QUERY''];
        self::$__Parsers[''SR_Key''][] = ''%PublicPath%'';
        self::$__Parsers[''SR_Data''][] =& self::$_Public_Path;
        self::$__Parsers[''SR_Key''][] = ''%SkinPath%'';
        self::$__Parsers[''SR_Data''][] =& self::$_Skin_Path;
        self::$__Parsers[''SR_Key''][] = ''%DefaultSkin%'';
        self::$__Parsers[''SR_Data''][] =& self::$_Skin_Default;
        // Everything OK so far
    }

    /** ----------------------------------------------------------------------------------------------------------------
     * URI EXTRACTOR
     * Try every posibility to obtain all the segments of the current URL
     *
     * @access public
     * @return array
    */
    public static function Extract()
    {
        // No point in executing twice to get the same result
        if (!empty(self::$__Segments[''HOST''])) return self::$__Segments;
        // Let''s try to have a falback for most basic data
        $Script_URI = (isset($_SERVER[''SCRIPT_URI''])) ? parse_url($_SERVER[''SCRIPT_URI'']) : array();
        if (empty($Script_URI)) {
            $Script_URI = parse_url(self::$_Fallback_Base);
        }
        // Try ever possibility to obtain the data that surounds the script name
        if (isset($_SERVER[''PHP_SELF''])) {
            $Script_Path = $_SERVER[''PHP_SELF''];
        } elseif (isset($_SERVER[''REQUEST_URI''])) {
            $Script_Path = preg_replace(''//?.*/'', '''', $_SERVER[''REQUEST_URI'']);
        } elseif (isset($Script_URI[''path''])) {
            $Script_Path = $Script_URI[''path''];
        } elseif (isset($_SERVER[''SCRIPT_NAME''])) {
            $Script_Path = isset($_SERVER[''SCRIPT_NAME'']).(isset($_SERVER[''PATH_INFO'']) ? $_SERVER[''PATH_INFO''] : '''');
        } elseif (isset($_SERVER[''DOCUMENT_ROOT'']) && isset($_SERVER[''SCRIPT_FILENAME''])) {
            $Script_Path = substr($_SERVER[''SCRIPT_FILENAME''], strlen($_SERVER[''DOCUMENT_ROOT'']),
                                    (strlen($_SERVER[''SCRIPT_FILENAME''])-strlen($_SERVER[''DOCUMENT_ROOT''])));
            $Script_Path .= (isset($_SERVER[''PATH_INFO'']) ? $_SERVER[''PATH_INFO''] : '''');
        } else {
            $Script_Path = '''';
        }
        // Explode the previously extracted data
        if (strlen($Script_Path) > 0) {
            $Script_Path = preg_split(''/[//]/'', $Script_Path, -1, PREG_SPLIT_NO_EMPTY);
        } else {
            $Script_Path = array();
        }
        // Try to obtain the name of the currently executed script
        if (isset($_SERVER[''SCRIPT_FILENAME''])) {
            $Script_Name = basename($_SERVER[''SCRIPT_FILENAME'']);
        } elseif (isset($_SERVER[''SCRIPT_NAME''])) {
            $Script_Name = basename($_SERVER[''SCRIPT_NAME'']);
        } else {
            $Script_Name = self::$_Fallback_Script;
        }
        // Try to find the name of the script in the script path
        $Script_Split = (is_string($Script_Name)) ? array_search($Script_Name, $Script_Path, TRUE) : NULL;
        // Try to obtain the request scheme
        if (isset($_SERVER[''REQUEST_SCHEME''])) {
            self::$__Segments[''SCHEME''] = $_SERVER[''REQUEST_SCHEME''];
        } elseif (isset($_SERVER[''SERVER_PROTOCOL''])) {
            self::$__Segments[''SCHEME''] = strtolower($_SERVER[''SERVER_PROTOCOL'']);
            self::$__Segments[''SCHEME''] = substr(self::$__Segments[''SCHEME''], 0, strpos(self::$__Segments[''SCHEME''], ''/''));
            self::$__Segments[''SCHEME''] .= (isset($_SERVER["HTTPS"]) && $_SERVER["HTTPS"] == ''on'') ? ''s'' : '''';
        } elseif (isset($Script_URI[''scheme''])) {
            self::$__Segments[''SCHEME''] = $Script_URI[''scheme''];
        } else {
            self::$__Segments[''SCHEME''] = self::$_Fallback_Scheme;
        }
        // Try to obtain the user name (if one was used)
        if (isset($_SERVER[''PHP_AUTH_USER''])) {
            self::$__Segments[''USER''] = $_SERVER[''PHP_AUTH_USER''];
        } elseif (isset($Script_URI[''user''])) {
            self::$__Segments[''USER''] = $Script_URI[''user''];
        } else {
            self::$__Segments[''USER''] = self::$_Fallback_User;
        }
        // Try to obtain the user password (if one was used)
        if (isset($_SERVER[''PHP_AUTH_PW''])) {
            self::$__Segments[''PASSWD''] = $_SERVER[''PHP_AUTH_PW''];
        } elseif (isset($Script_URI[''pass''])) {
            self::$__Segments[''PASSWD''] = $Script_URI[''pass''];
        } else {
            self::$__Segments[''PASSWD''] = self::$_Fallback_Passwd;
        }
        // Try to obtai the host name
        if (isset($_SERVER[''SERVER_NAME''])) {
            self::$__Segments[''HOST''] = $_SERVER[''SERVER_NAME''];
        } elseif (isset($_SERVER[''HTTP_HOST''])) {
            self::$__Segments[''HOST''] = $_SERVER[''HTTP_HOST''];
        } elseif (isset($Script_URI[''host''])) {
            self::$__Segments[''HOST''] = $Script_URI[''host''];
        } else {
            self::$__Segments[''HOST''] = self::$_Fallback_Host;
        }
        // Try to obtain the port number (if one was used)
        if (isset($Script_URI[''port''])) {
            self::$__Segments[''PORT''] = $Script_URI[''port''];
        } else {
            self::$__Segments[''PORT''] = self::$_Fallback_Port;
        }
        // Try to obtain the path to the script
        if (is_numeric($Script_Split)) {
            self::$__Segments[''PATH''] = implode(''/'', array_slice($Script_Path, 0, $Script_Split, TRUE));
        } else {
            self::$__Segments[''PATH''] = '''';
        }
        // Try to obtain the Script name
        if (is_string($Script_Name)) {
            self::$__Segments[''SCRIPT''] = $Script_Name;
        } else {
            self::$__Segments[''SCRIPT''] = '''';
        }
        // Try to obtain any passed info
        if (isset($_SERVER[''PATH_INFO''])) {
            self::$__Segments[''INFO''] = implode(''/'', preg_split(''/[//]/'', $_SERVER[''PATH_INFO''], -1, PREG_SPLIT_NO_EMPTY));
        } elseif (is_numeric($Script_Split)) {
            self::$__Segments[''INFO''] = implode(''/'', array_slice($Script_Path, $Script_Split+1));
        } else {
            self::$__Segments[''INFO''] = '''';
        }
        // -----Pending Feature: Try to also extract the query string

        // Return the extracted URI segments
        return self::$__Segments;

    }

    /** ----------------------------------------------------------------------------------------------------------------
     * URI COMPILER
     * Compile raw URI segments into a usable URL
     *
     * @access public
     * @param $Until [string] - The name of the segment where compilation should stop and return
     * @return string
    */
    public static function Compile($Until=NULL)
    {
        $URI= '''';
        $Until = (is_string($Until)) ? strtoupper($Until) : $Until;
        if ($Until === ''SCHEME'') {
            return $URI .= (self::$__Segments[''SCHEME''] !== '''') ? self::$__Segments[''SCHEME''].self::$_Separator_Scheme : '''';
        } else {
            $URI .= (self::$__Segments[''SCHEME''] !== '''') ? self::$__Segments[''SCHEME''].self::$_Separator_Scheme : '''';
        }
        if ($Until === ''USER'') {
            return $URI .= (self::$__Segments[''USER''] !== '''') ? self::$__Segments[''USER''].self::$_Separator_Credentials : '''';
        } else {
            $URI .= (self::$__Segments[''USER''] !== '''') ? self::$__Segments[''USER''] : '''';
        }
        $URI .= (self::$__Segments[''USER''] !== '''' || self::$__Segments[''PASSWD''] !== '''') ? self::$_Separator_Credentials : '''';
        if ($Until === ''PASSWD'') {
            return $URI .= (self::$__Segments[''PASSWD''] !== '''') ? self::$__Segments[''PASSWD''].self::$_Separator_Auth : '''';
        } else {
            $URI .= (self::$__Segments[''PASSWD''] !== '''') ? self::$__Segments[''PASSWD''] : '''';
        }
        $URI .= (self::$__Segments[''USER''] !== '''' || self::$__Segments[''PASSWD''] !== '''') ? self::$_Separator_Auth : '''';
        if ($Until === ''HOST'') {
            return $URI .= (self::$__Segments[''HOST''] !== '''') ? self::$__Segments[''HOST''] : '''';
        } else {
            $URI .= (self::$__Segments[''HOST''] !== '''') ? self::$__Segments[''HOST''] : '''';
        }
        if ($Until === ''PORT'') {
            return $URI .= (self::$__Segments[''PORT''] !== '''') ? self::$_Separator_Port.self::$__Segments[''PORT''] : '''';
        } else {
            $URI .= (self::$__Segments[''PORT''] !== '''') ? self::$_Separator_Port.self::$__Segments[''PORT''] : '''';
        }
        if ($Until === ''PATH'') {
            return $URI .= (self::$__Segments[''PATH''] !== '''') ? ''/''.self::$__Segments[''PATH''] : '''';
        } else {
            $URI .= (self::$__Segments[''PATH''] !== '''') ? ''/''.self::$__Segments[''PATH''] : '''';
        }
        if ($Until === ''SCRIPT'') {
            return $URI .= (self::$__Segments[''SCRIPT''] !== '''') ? ''/''.self::$__Segments[''SCRIPT''] : '''';
        } else {
            $URI .= (self::$__Segments[''SCRIPT''] !== '''') ? ''/''.self::$__Segments[''SCRIPT''] : '''';
        }
        if ($Until === ''INFO'') {
            return $URI .= (self::$__Segments[''INFO''] !== '''') ? ''/''.self::$__Segments[''INFO''] : '''';
        } else {
            $URI .= (self::$__Segments[''INFO''] !== '''') ? ''/''.self::$__Segments[''INFO''] : '''';
        }
        return $URI;
    }

    /** ----------------------------------------------------------------------------------------------------------------
     * SEGMENT RETRIEVER
     * Return a specific URI segment
     *
     * @access public
     * @param $Name [string] - The name of the segment you want
     * @return string (on success) bool (on failure)
    */
    public static function Segment($Name)
    {
        if (isset(self::$__Segments[$Name])) {
            return self::$__Segments[$Name];
        } return FALSE;
    }

    /** ----------------------------------------------------------------------------------------------------------------
     * BASE RETRIEVER
     * Return a specific precompiled base
     *
     * @access public
     * @param $Name [string] - The name of the base you want
     * @return mixed (on success) boolean (on failure)
    */
    public static function Base($Name)
    {
        switch ($Name) {
            case ''Host'':
            case ''Domain'':
                return self::$Base_Host;
            break;
            case ''App'':
            case ''Base'':
                return self::$Base_App;
            break;
            case ''Script'':
            case ''Index'':
                return self::$Base_Script;
            break;
            case ''Current'':
            case ''This'':
                return self::$Base_Current;
            break;
            case ''Public'':
            case ''Web'':
                return self::$Base_Public;
            break;
            case ''Skin'':
            case ''Theme'':
                return self::$Base_Skin;
            break;
            case ''All'':
                return array(
                    ''Host''=>self::$Base_Host,
                    ''App''=>self::$Base_App,
                    ''Script''=>self::$Base_Script,
                    ''Current''=>self::$Base_Current,
                    ''Public''=>self::$Base_Public,
                    ''Skin''=>self::$Base_Skin,
                );
            break;
        } return FALSE;
    }

    /** ----------------------------------------------------------------------------------------------------------------
     * STRING PARSER
     * Replace known keywords in the specified string with current URI data
     *
     * @access public
     * @param $String [string] - A string that you want to parse
     * @return void
    */
    public static function Parse($String)
    {
        if (is_string($String)) {
            return str_replace(self::$__Parsers[''SR_Key''], self::$__Parsers[''SR_Data''], $String);
        } elseif (is_array($String)) {
            foreach ($String as $K => $V) {
                $Parsed[$K] = self::$replace($V);
            } return $Parsed;
        } return FALSE;
    }
}
if (isset($_URI_Params)) {
    _URI::__Init($_URI_Params);
} else {
    _URI::__Init();
} 

¡Por supuesto que tienes que adaptarlo a tus necesidades y sistema!

<?php
// Change a few parameters before loading the class.
$_URI_Params = array(
    ''Public_Relative'' => FALSE,
    ''Skin_Relative'' => FALSE,
    ''Skin_Default'' => ''classic'',
    // etc.
);
// Get the URI class
require(''uri.php'');
// Output all extracted URI segments
echo ''<pre>'';
var_dump(_URI::Extract());
echo ''</pre>'';
// Output extracted segments individually
echo ''Scheme: ''._URI::Segment(''SCHEME'').''<br/>'';
echo ''User: ''._URI::Segment(''USER'').''<br/>'';
echo ''Password: ''._URI::Segment(''PASSWD'').''<br/>'';
echo ''Host: ''._URI::Segment(''HOST'').''<br/>'';
echo ''Port: ''._URI::Segment(''PORT'').''<br/>'';
echo ''Path: ''._URI::Segment(''PATH'').''<br/>'';
echo ''Script: ''._URI::Segment(''SCRIPT'').''<br/>'';
echo ''Info: ''._URI::Segment(''INFO'').''<br/>'';
// Compile extracted segments into a usable URL
echo ''<br/>'';
echo ''Full Compiled URI: ''._URI::Compile().''<br/>'';
echo ''<br/>'';
// Output precompiled common bases for a faster result and better performance
echo ''Host Base: ''._URI::Base(''Host'').''<br/>'';
echo ''Application Base: ''._URI::Base(''App'').''<br/>'';
echo ''Running Script: ''._URI::Base(''Script'').''<br/>'';
echo ''Current URI Base: ''._URI::Base(''Current'').''<br/>'';
echo ''Public Folder Base: ''._URI::Base(''Public'').''<br/>'';
echo ''Skin Folder Base: ''._URI::Base(''Skin'').''<br/>'';
// Get all the precompiled bases in an associative array
echo ''<pre>'';
var_dump(_URI::Base(''All''));
echo ''</pre>'';
// Parse an example string and replace known keys with actual URI data.
echo _URI::Parse(''This is my current domain: %HostBase%
And the current application is here: %AppBase%
I load my skins form: %SkinBase%
etc.
''); 

Todavía necesita ser perfeccionado pero es una solución divina para un sistema URI centralizado: D

Answer 8

He hecho esta función para manejar la URL:

 <?php
     function curPageURL()
     {
         $pageURL = ''http'';
         if ($_SERVER["HTTPS"] == "on") {$pageURL .= "s";}
         $pageURL .= "://";
         if ($_SERVER["SERVER_PORT"] != "80") {
             $pageURL .=
             $_SERVER["SERVER_NAME"].":".$_SERVER["SERVER_PORT"].$_SERVER["REQUEST_URI"];
         }
         else {
             $pageURL .= $_SERVER["SERVER_NAME"].$_SERVER["REQUEST_URI"];
         }
         return $pageURL;
     }
 ?>

Answer 9

La misma técnica que la respuesta aceptada, pero con soporte HTTPS , y más legible:

$current_url = sprintf(
    ''%s://%s/%s'',
    isset($_SERVER[''HTTPS'']) ? ''https'' : ''http'',
    $_SERVER[''HTTP_HOST''],
    $_SERVER[''REQUEST_URI'']
);

Answer 10

Mi método favorito de multiplataforma para encontrar la URL actual es:

$url = (isset($_SERVER[''HTTPS'']) ? "https" : "http") . "://$_SERVER[HTTP_HOST]$_SERVER[REQUEST_URI]";

Answer 11

Para eso, solo eche un vistazo a toda la matriz con print_r($_SERVER) , verá todo lo que necesita allí :)

Answer 12

Prueba esto:

$pageURL = $_SERVER[''HTTPS''] == ''on'' ? ''https://'' : ''http://'';
$pageURL .= $_SERVER[''SERVER_PORT''] != ''80'' ? $_SERVER["SERVER_NAME"].":".$_SERVER["SERVER_PORT"].$_SERVER["REQUEST_URI"] : $_SERVER[''SERVER_NAME''] . $_SERVER[''REQUEST_URI''];
echo $pageURL;

Answer 13

Prueba esto:

print_r($_SERVER);

$_SERVERes una matriz que contiene información como encabezados, rutas y ubicaciones de script. Las entradas en esta matriz son creadas por el servidor web. No hay garantía de que cada servidor web proporcione alguno de estos; los servidores pueden omitir algunos o proporcionar otros que no figuran en esta lista. Dicho esto, una gran cantidad de estas variables se tienen en cuenta en la »especificación CGI / 1.1, por lo que debería poder esperarlas.

$HTTP_SERVER_VARSContiene la misma información inicial, pero no es un superglobal. (Tenga en cuenta que $HTTP_SERVER_VARSy $_SERVERson variables diferentes y que PHP las maneja como tales)

Answer 14

Simplemente use:

$uri = $_SERVER[''REQUEST_SCHEME''] . ''://'' . $_SERVER[''HTTP_HOST''].$_SERVER[''REQUEST_URI'']

Answer 15

Utilice esta herramienta de una línea para encontrar la URL de la carpeta principal (si no tiene acceso a http_build_url () que viene con pecl_http):

$url = (isset($_SERVER[''HTTPS'']) ? ''https://'' : ''http://'').$_SERVER[''SERVER_NAME''].str_replace($_SERVER[''DOCUMENT_ROOT''], '''', dirname(dirname(__FILE__)));

Answer 16

Creo que este método es bueno ... probarlo

if($_SERVER[''HTTP_HOST''] == "localhost"){
    define(''SITEURL'', ''http://'' . $_SERVER[''HTTP_HOST'']);
    define(''SITEPATH'', $_SERVER[''DOCUMENT_ROOT'']);
    define(''CSS'', $_SERVER[''DOCUMENT_ROOT''] . ''/css/'');
    define(''IMAGES'', $_SERVER[''DOCUMENT_ROOT''] . ''/images/'');
}
else{
    define(''SITEURL'', ''http://'' . $_SERVER[''HTTP_HOST'']);
    define(''SITEPATH'', $_SERVER[''DOCUMENT_ROOT'']);
    define(''TEMPLATE'', $_SERVER[''DOCUMENT_ROOT''] . ''/incs/template/'');
    define(''CSS'', $_SERVER[''DOCUMENT_ROOT''] . ''/css/'');
    define(''IMAGES'', $_SERVER[''DOCUMENT_ROOT''] . ''/images/'');
}

Answer 17

Esta es la solución para su problema:

//Fetch page URL by this

$url = $_SERVER[''REQUEST_URI''];
echo "$url<br />";

//It will print
//fetch host by this

$host=$_SERVER[''HTTP_HOST''];
echo "$host<br />";

//You can fetch the full URL by this

$fullurl = "http://".$_SERVER[''HTTP_HOST''].$_SERVER[''REQUEST_URI''];
echo $fullurl;

Answer 18

Esto funciona tanto para HTTP como para HTTPS.

echo ''http'' . (($_SERVER[''HTTPS''] == ''on'') ? ''s'' : '''') . ''://'' . $_SERVER[''HTTP_HOST''] . $_SERVER[''REQUEST_URI''];

Salida algo como esto.

https://example.com/user.php?token=3f0d9sickc0flmg8hnsngk5u07&access_level=application

Answer 19

He usado el siguiente código y está funcionando bien para mí, en ambos casos, HTTP y HTTPS.

function curPageURL() {
  if(isset($_SERVER["HTTPS"]) && !empty($_SERVER["HTTPS"]) && ($_SERVER["HTTPS"] != ''on'' )) {
        $url = ''https://''.$_SERVER["SERVER_NAME"];//https url
  }  else {
    $url =  ''http://''.$_SERVER["SERVER_NAME"];//http url
  }
  if(( $_SERVER["SERVER_PORT"] != 80 )) {
     $url .= $_SERVER["SERVER_PORT"];
  }
  $url .= $_SERVER["REQUEST_URI"];
  return $url;
}

echo curPageURL();

Demo

Answer 20

Uso muy simple:

function current_url() {
    $current_url  = ( $_SERVER["HTTPS"] != ''on'' ) ? ''http://''.$_SERVER["SERVER_NAME"] :  ''https://''.$_SERVER["SERVER_NAME"];
    $current_url .= ( $_SERVER["SERVER_PORT"] != 80 ) ? ":".$_SERVER["SERVER_PORT"] : "";
    $current_url .= $_SERVER["REQUEST_URI"];

    return $current_url;
}

Answer 21

Utilicé esta declaración.

$base = "http://$_SERVER[SERVER_NAME]:$_SERVER[SERVER_PORT]$my_web_base_path";
$url = $base . "/" . dirname(dirname(__FILE__));

Espero que esto ayude.

Answer 22

Aquí está la base de una versión más segura de la respuesta aceptada, utilizando la función filter_input de PHP , que también compensa la posible falta de $_SERVER[''REQUEST_URI'']:

$protocol_https = filter_input(INPUT_SERVER, ''HTTPS'', FILTER_SANITIZE_STRING);
$host = filter_input(INPUT_SERVER, ''HTTP_HOST'', FILTER_SANITIZE_URL);
$request_uri = filter_input(INPUT_SERVER, ''REQUEST_URI'', FILTER_SANITIZE_URL);
if(strlen($request_uri) == 0)
{
    $request_uri = filter_input(INPUT_SERVER, ''SCRIPT_NAME'', FILTER_SANITIZE_URL);
    $query_string = filter_input(INPUT_SERVER, ''QUERY_STRING'', FILTER_SANITIZE_URL);
    if($query_string)
    {
        $request_uri .= ''?'' . $query_string;
    }
}
$full_url = ($protocol_https ? ''https'' : ''http'') . ''://'' . $host . $request_uri;

Podrías usar algunos filters diferentes para ajustarlo a tu gusto.

Answer 23

Desde que mi edit de la mejor respuesta se ha revertido, lo estoy publicando como una respuesta separada:

HTTP_HOST y REQUEST_URI deben estar entre comillas, de lo contrario, arroja un error en PHP 7.2

Utilizar:

$actual_link = ''https://''.$_SERVER[''HTTP_HOST''].$_SERVER[''REQUEST_URI''];

Si quieres soportar tanto HTTP como HTTPS:

$actual_link = (isset($_SERVER[''HTTPS'']) ? ''https'' : ''http'').''://''.$_SERVER[''HTTP_HOST''].$_SERVER[''REQUEST_URI''];

Answer 24

Esto es bastante fácil de hacer con sus variables de entorno de Apache. Esto solo funciona con Apache 2, que asumo que estás usando.

Simplemente usa el siguiente código PHP:

<?php
    $request_url = apache_getenv("HTTP_HOST") . apache_getenv("REQUEST_URI");
    echo $request_url;
?>

Answer 25

Puede usar http_build_url sin argumentos para obtener la URI completa de la página actual:

$url = http_build_url();

Answer 26

Puede utilizar HTTP_ORIGINcomo se ilustra en el fragmento de código a continuación:

if ( ! array_key_exists( ''HTTP_ORIGIN'', $_SERVER ) ) {
    $this->referer = $_SERVER[''SERVER_NAME''];
} else {
    $this->referer = $_SERVER[''HTTP_ORIGIN''];
}

Answer 27

$base_dir = __DIR__; // Absolute path to your installation, ex: /var/www/mywebsite
$doc_root = preg_replace("!{$_SERVER[''SCRIPT_NAME'']}$!", '''', $_SERVER[''SCRIPT_FILENAME'']); # ex: /var/www
$base_url = preg_replace("!^{$doc_root}!", '''', $base_dir); # ex: '''' or ''/mywebsite''
$base_url = str_replace(''//', ''/'', $base_url);//On Windows
$base_url = str_replace($doc_root, '''', $base_url);//On Windows
$protocol = empty($_SERVER[''HTTPS'']) ? ''http'' : ''https'';
$port = $_SERVER[''SERVER_PORT''];
$disp_port = ($protocol == ''http'' && $port == 80 || $protocol == ''https'' && $port == 443) ? '''' : ":$port";
$domain = $_SERVER[''SERVER_NAME''];
$full_url = "$protocol://{$domain}{$disp_port}{$base_url}"; # Ex: ''http://example.com'', ''https://example.com/mywebsite'', etc. 

fuente: http://blog.lavoie.sl/2013/02/php-document-root-path-and-url-detection.html

Answer 28

$page_url = (isset($_SERVER[''HTTPS'']) ? "https" : "http") . "://$_SERVER[HTTP_HOST]$_SERVER[REQUEST_URI]";

Para más información: https://codeupweb.wordpress.com/2017/10/11/how-to-get-the-full-url-of-page-using-php/

Answer 29

function full_path()
{
    $s = &$_SERVER;
    $ssl = (!empty($s[''HTTPS'']) && $s[''HTTPS''] == ''on'') ? true:false;
    $sp = strtolower($s[''SERVER_PROTOCOL'']);
    $protocol = substr($sp, 0, strpos($sp, ''/'')) . (($ssl) ? ''s'' : '''');
    $port = $s[''SERVER_PORT''];
    $port = ((!$ssl && $port==''80'') || ($ssl && $port==''443'')) ? '''' : '':''.$port;
    $host = isset($s[''HTTP_X_FORWARDED_HOST'']) ? $s[''HTTP_X_FORWARDED_HOST''] : (isset($s[''HTTP_HOST'']) ? $s[''HTTP_HOST''] : null);
    $host = isset($host) ? $host : $s[''SERVER_NAME''] . $port;
    $uri = $protocol . ''://'' . $host . $s[''REQUEST_URI''];
    $segments = explode(''?'', $uri, 2);
    $url = $segments[0];
    return $url;
}

Nota: Acabo de hacer una actualización del código de "Timo Huovinen", por lo que no obtendrás ningún acceso a la URL. Esta URL es simple y elimina cosas como "? Hi = i & am = a & get".

Ejemplo:

http://www.website.com/index?get=information

se mostrará como:

http://www.website.com/index

A menos que uses Get''s para definir un contenido específico, ¡entonces usa su código! :-)

Answer 30

public static function getCurrentURL()
{
    $protocol = strpos(strtolower($_SERVER[''SERVER_PROTOCOL'']), ''https'') === false ? ''http'' : ''https'';
    $host = $_SERVER[''HTTP_HOST''];
    $script = $_SERVER[''SCRIPT_NAME''];
    $params = $_SERVER[''QUERY_STRING''] == '''' ? '''' : ''?'' . $_SERVER[''QUERY_STRING''];

    return $protocol . ''://'' . $host . $script . $params;
}