Spanish (Español) translation by Ana Paulina Figueroa (you can also view the original English article)
En esta publicación, te daré una hoja de referencia de consulta rápida con todas las variables superglobales disponibles en PHP.
¿Qué es una variable superglobal?
Echemos un vistazo a la definición de las variables superglobales.
Las superglobales son variables incorporadas que siempre están disponibles en todos los ámbitos.
Si eres un desarrollador de PHP experimentado, o un novato en el desarrollo con PHP, de una manera u otra ya habrás trabajado con estas variables superglobales. En PHP existen diversas variables predefinidas que se consideran superglobales, lo que significa que no es necesario que utilices la palabra reservada global para acceder a ellas. Las variables superglobales están disponibles en todos los ámbitos de un script.
Echemos un vistazo rápido a las variables superglobales en PHP:
$GLOBALS$_SERVER$_GET$_POST$_FILES$_COOKIE$_SESSION$_REQUEST$_ENV
El objetivo de este artículo es analizar todas las variables superglobales de PHP y explicar cada una brevemente.
Referencia rápida a las superglobales de PHP
$GLOBALS
La variable superglobal $GLOBALS se utiliza para acceder a todas las variables globales en PHP. Básicamente es un arreglo asociativo que contiene todas la variables definidas en el ámbito global.
Echemos un vistazo al siguiente ejemplo para comprender cómo funciona.
1 |
<?php
|
2 |
// variable defined in the global scope
|
3 |
$website_name = 'tutsplus.com'; |
4 |
|
5 |
function displayWebsiteName() { |
6 |
// PHP Notice: Undefined variable: website_name
|
7 |
echo 'Website: ' . $website_name; |
8 |
|
9 |
// outputs “Website: tutsplus.com”
|
10 |
echo $GLOBALS['website_name']; |
11 |
}
|
12 |
|
13 |
displayWebsiteName(); |
En primer lugar, hemos definido la variable $website_name en el ámbito global.
Ahora, cuando intentamos acceder a la variable $website_name en la función displayWebsiteName, dicha función intentaría encontrar la variable $website_name en el ámbito local. Y dado que no se ha definido en la función displayWebsiteName, verías un aviso de PHP quejándose de que estás intentando acceder a la variable indefinida.
A continuación, cuando intentamos acceder a ella con la variable superglobal $GLOBALS, este proceso funciona, ya que la variable $GLOBALS contiene referencias a todas las variables globales.
$_SERVER
La variable superglobal $_SERVER contiene la información del servidor web y del entorno de ejecución. Específicamente, es inicializada por un servidor web con cabeceras HTTP, rutas y ubicaciones de scripts.
Echemos un vistazo a la salida del comando print_r($_SERVER).
1 |
Array
|
2 |
(
|
3 |
[USER] => ubuntu |
4 |
[HOME] => /var/www |
5 |
[HTTP_UPGRADE_INSECURE_REQUESTS] => 1 |
6 |
[HTTP_COOKIE] => _ga=GA1.1.19480044.1597729890; _hjid=41b3ce18-a24c-41d4-ac7f-dc5d9066120d; _ga_17Y2VJYG6X=GS1.1.1606729885.14.1.1606730391.0; __gads=ID=4fad16ec33ad9598:T=1606730074:S=ALNI_MaYqS1Ftx7eMR2naLutOqRPT1LytQ |
7 |
[HTTP_CONNECTION] => keep-alive |
8 |
[HTTP_ACCEPT_ENCODING] => gzip, deflate |
9 |
[HTTP_ACCEPT_LANGUAGE] => en-US,en;q=0.5 |
10 |
[HTTP_ACCEPT] => text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8 |
11 |
[HTTP_USER_AGENT] => Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:78.0) Gecko/20100101 Firefox/78.0 |
12 |
[HTTP_HOST] => localhost |
13 |
[REDIRECT_STATUS] => 200 |
14 |
[SERVER_NAME] => localhost |
15 |
[SERVER_PORT] => 80 |
16 |
[SERVER_ADDR] => 127.0.0.1 |
17 |
[REMOTE_PORT] => 39482 |
18 |
[REMOTE_ADDR] => 127.0.0.1 |
19 |
[SERVER_SOFTWARE] => nginx/1.14.0 |
20 |
[GATEWAY_INTERFACE] => CGI/1.1 |
21 |
[REQUEST_SCHEME] => http |
22 |
[SERVER_PROTOCOL] => HTTP/1.1 |
23 |
[DOCUMENT_ROOT] => /web/demoproject |
24 |
[DOCUMENT_URI] => /server.php |
25 |
[REQUEST_URI] => /server.php |
26 |
[SCRIPT_NAME] => /server.php |
27 |
[CONTENT_LENGTH] => |
28 |
[CONTENT_TYPE] => |
29 |
[REQUEST_METHOD] => GET |
30 |
[QUERY_STRING] => |
31 |
[SCRIPT_FILENAME] => /web/demoproject/server.php |
32 |
[FCGI_ROLE] => RESPONDER |
33 |
[PHP_SELF] => /server.php |
34 |
[REQUEST_TIME_FLOAT] => 1613665334.6422 |
35 |
[REQUEST_TIME] => 1613665334 |
36 |
)
|
En su mayoría contiene la información específica del servidor, como el nombre del servidor, el puerto del servidor, el nombre del script, la raíz de documentos, etcétera. Aparte de eso, también puede contener información sobre el entorno cliente, como el agente del usuario, la dirección IP remota, cookies y más.
Lo importante es que no hay garantía de que todos los servidores web vayan a inicializar toda esta información. Además, si estás ejecutando un script desde la línea de comandos, ninguna de las variables SERVER_* serán inicializadas, ya que son específicas del servidor.
$_GET
Cuando un usuario envía un formulario con el método GET, los datos del formulario que se envían a un servidor están disponibles en la variable $_GET. La variable superglobal $_GET contiene un arreglo de variables que se envían al script mediante una cadena de consulta. Básicamente, cualquier cosa que se envíe como parte de la cadena de consulta de URL estará disponible en la variable superglobal $_GET.
Echemos un vistazo al siguiente fragmento de código.
1 |
<form action = "/search.php" method = "GET"> |
2 |
Search Keyword: <input type = "text" name = "keyword" /> |
3 |
<input type = "submit" value=”Search”/> |
4 |
</form>
|
En el ejemplo anterior, cuando un usuario envía el formulario de búsqueda, el valor del campo "keyword" se enviaría a un servidor a través de una cadena de consulta.
1 |
/search.php?keyword=PHP |
Del lado del servidor, puedes acceder a él de esta manera:
1 |
<?php
|
2 |
If (isset($_GET['keyword'])) { |
3 |
$search_keyword = filter_var($_GET['keyword'], FILTER_SANITIZE_STRING); |
4 |
}
|
5 |
?>
|
Es importante mencionar que debes desinfectar la entrada de un usuario antes de que sea procesada o mostrada de nuevo en el navegador, y es por eso que hemos usado la función filter_var para desinfectar el valor de la variable $_GET[‘keyword’].
$_POST
Cuando se usa la variable superglobal $_GET para recopilar los datos de un formulario enviado con el método GET, la variable superglobal $_POST se usa para obtener los datos del formulario para el método POST. Los datos POST del formulario no se mostrarán en el URL, sino que estarán disponibles como parte del cuerpo de la solicitud.
Echemos un vistazo al siguiente fragmento de código.
1 |
<form action="/login.php" method="POST"> |
2 |
Username: <input type="text" name="username" /> |
3 |
Password: <input type="password" name="password" /> |
4 |
<input type="submit" value="Login"/> |
5 |
</form>
|
En el ejemplo anterior, cuando un usuario envía el formulario de búsqueda, puedes acceder a los valores de campo en el lado del servidor de esta manera.
1 |
<?php
|
2 |
If (isset($_POST['username']) && isset($_POST['password'])) { |
3 |
$username = $_POST['username']; |
4 |
$password = $_POST['password']; |
5 |
}
|
6 |
?>
|
Cuando trabajas con los datos $_POST, debes asegurarte de que estás tomando las medidas suficientes para desinfectar los datos entrantes; de lo contrario, esto podría causar posibles ataques en tu sitio.
$_FILES
Cuando un usuario envía un formulario que permite la carga de archivos, la información de los archivos que se cargan será asignada a la variable superglobal $_FILES. Se trata de un arreglo bidimensional que contiene los siguientes atributos relacionados con los archivos cargados.
- name: nombre del archivo
- type: tipo del archivo
- size: tamaño del archivo
- tmp_name: ruta en el servidor del archivo cargado
- error: error en caso de que se produzca un error en la carga del archivo
Echemos un vistazo al siguiente ejemplo para ver cómo funcionan las cargas de archivos en PHP.
1 |
<!DOCTYPE html>
|
2 |
<html>
|
3 |
<body>
|
4 |
<div>
|
5 |
<form action="upload.php" method="POST" enctype="multipart/form-data"> |
6 |
Upload File:<input type="file" name="document"> |
7 |
<input type="submit" value="Upload" name="Submit"> |
8 |
</form>
|
9 |
</div>
|
10 |
</body>
|
11 |
</html>
|
En el ejemplo anterior, hemos establecido el valor del atributo enctype en multipart/form-data y, por lo tanto, permite la carga de archivos. Cuando un usuario lo envía, puedes usar la variable superglobal $_FILES para acceder a la información del archivo cargado, como se muestra en el siguiente fragmento de código.
1 |
<?php
|
2 |
if ($_SERVER["REQUEST_METHOD"] == "POST") { |
3 |
if (isset($_FILES["document"]) && $_FILES["document"]["error"] === UPLOAD_ERR_OK) { |
4 |
$fileName = $_FILES["document"]["name"]; |
5 |
$fileType = $_FILES["document"]["type"]; |
6 |
$fileSize = $_FILES["document"]["size"]; |
7 |
$fileTmpName = $_FILES["document"]["tmp_name"]; |
8 |
|
9 |
$fileNameCmps = explode(".", $fileName); |
10 |
$fileExtension = strtolower(end($fileNameCmps)); |
11 |
|
12 |
// sanitize file-name
|
13 |
$newFileName = md5(time() . $fileName) . '.' . $fileExtension; |
14 |
|
15 |
// check if file has one of the following extensions
|
16 |
$allowedfileExtensions = array('jpg', 'gif', 'png', 'zip', 'txt', 'xls', 'doc'); |
17 |
|
18 |
if (in_array($fileExtension, $allowedfileExtensions)) |
19 |
{
|
20 |
$uploadFileDir = './uploaded_files/'; |
21 |
$dest_path = $uploadFileDir . $newFileName; |
22 |
|
23 |
if(move_uploaded_file($fileTmpPath, $dest_path)) |
24 |
{
|
25 |
$message ='File is successfully uploaded.'; |
26 |
}
|
27 |
else
|
28 |
{
|
29 |
$message = 'There was some error moving the file to upload directory. Please make sure the upload directory is writable by web server.'; |
30 |
}
|
31 |
}
|
32 |
else
|
33 |
{
|
34 |
$message = 'Upload failed. Allowed file types: ' . implode(',', $allowedfileExtensions); |
35 |
}
|
36 |
echo $message; |
37 |
} else { |
38 |
echo 'There was some error uploading the file:' . $_FILES["document"]["error"]; |
39 |
}
|
40 |
}
|
41 |
?>
|
El aspecto importante es que la variable $_FILES["document"]["tmp_name"] contiene la ruta del archivo cargado, la cual puedes usar para mover dicho archivo a la ubicación que desees. Si ocurre algún error, esa información será asignada a la variable $_FILES["document"]["error"].
$_COOKIE
Como el nombre lo sugiere, la variable superglobal $_COOKIE se usa para leer cookies que se encuentren disponibles para el script actual. Básicamente te permite acceder a cookies que ya estén configuradas con la función setcookie en PHP. La variable $_COOKIE es un arreglo asociado que contiene todas las variables de cookies que se envían a través de cookies HTTP.
Supongamos que ya has creado la cookie lastVisitedSection con el siguiente fragmento de código.
1 |
<?php
|
2 |
setcookie('lastVisitedSection', 'codeTutsPlus', time() + 3600, "/"); |
3 |
?>
|
Ahora puedes acceder a la cookie lastVisitedSection como se muestra en el fragmento de código a continuación.
1 |
<?php
|
2 |
if(isset($_COOKIE['lastVisitedSection'])) { |
3 |
echo 'Last visited section:' . htmlspecialchars($_COOKIE['lastVisitedSection']); |
4 |
} else { |
5 |
echo 'We encourage you to explore different sections of tutsplus.com!'; |
6 |
}
|
7 |
?>
|
Así es como puedes acceder a las cookies en tu script.
$_SESSION
Si ya has trabajado con sesiones en PHP, ya sabrás de la variable superglobal $_SESSION. Una variable de sesión te permite compartir información a través de las diferentes páginas de un solo sitio o aplicación, por lo que ayuda a mantener el estado. La variable $_SESSION contiene un arreglo asociativo de variables de sesión que están disponibles para el script actual.
Echemos un vistazo al siguiente ejemplo, que ejemplifica cómo configurar y obtener una variable de sesión.
1 |
<?php
|
2 |
session_start(); |
3 |
|
4 |
// set a session variable
|
5 |
$_SESSION['loggedInUserName'] = 'John'; |
6 |
|
7 |
// get a session variable later in the script or in subsequent requests
|
8 |
If (isset($_SESSION['loggedInUserName'])) { |
9 |
echo 'Hello, '. $_SESSION['loggedInUserName']; |
10 |
} else { |
11 |
echo 'Login Now!'; |
12 |
}
|
13 |
?>
|
El aspecto importante es que la función session_start debe ser llamada al comienzo del script, con el fin de iniciar una sesión e inicializar la variable $_SESSION.
$_REQUEST
La variable superglobal $_REQUEST es un arreglo asociativo que contiene variables de solicitud HTTP. Básicamente es una combinación de las variables superglobales $_GET, $_POST y $_COOKIE. Por lo tanto, es conveniente usar la variable $_REQUEST, específicamente si no deseas usar las variables superglobales mencionadas anteriormente.
La presencia y el orden de las variables en este arreglo dependen de los valores de las directivas de configuración request_order y variables_order en el archivo php.ini. Siempre debes tener cuidado al usar la variable $_REQUEST, y de hecho se recomienda que elijas $_GET, $_POST y $_COOKIE en lugar de usar esta variable superglobal.
$_ENV
La variable superglobal $_ENV es un arreglo asociativo de variables que se envía al script a través del método del entorno. Es útil cuando quieres configurar diferentes valores para entornos distintos, como el local, el de puesta en escena y el de producción. En tu aplicación, debes tener credenciales de base de datos y variables de configuración que son diferentes para cada entorno y, por lo tanto, puedes usar la variable $_ENV para acceder a ellas en tu script, ya que se inicializan dinámicamente. Existen diferentes métodos que puedes usar para establecer las variables de entorno.
En PHP puedes usar la función putenv para inicializar la variable, como se muestra en el siguiente fragmento de código.
1 |
putenv('HOSTNAME=localhost'); |
Por otro lado, si quieres establecer el valor de una variable de entorno en el archivo de host virtual de Apache, usa lo siguiente:
1 |
SetEnv HOSTNAME localhost |
Siempre debes preferir la función getenv para obtener el valor de una variable de entorno.
1 |
$hostname = getenv('HOSTNAME'); |
Lo importante es que siempre debes usar la función getenv para obtener el valor de una variable de entorno, ya que la variable $_ENV podría estar vacía si no la has habilitado a través de la directiva de configuración variables_order en el archivo php.ini. La directiva de configuración variables_order define el orden en el que las variables EGPCS (Entorno, Get, Post, Cookie y Servidor) serán inicializadas.
Conclusión
En este artículo hemos analizado todas las variables superglobales disponibles en PHP. Para cada variable, proporcioné un ejemplo breve pero significativo que debería ayudarte a comprender su propósito. Y espero que puedas usar este artículo como una guía de consulta rápida o una hoja de referencia en tu desarrollo diario con PHP.
By
