Superglobales de PHP

En PHP existen varias variables superglobales que están siempre disponibles en cualquier parte del script. Todas comienzan con $_.

Superglobal $_GET[...]

La superglobal $_GET se utiliza en PHP para acceder a los datos que se envían en la URL después del signo ?. Es muy común usarla para pasar parámetros entre páginas, como identificadores de usuario, artículos, filtros de búsqueda, etc.

Características principales

• Los datos viajan en la URL, visibles para el usuario.
• Se usa principalmente con el método GET de formularios o con enlaces.
• Se accede mediante la sintaxis $_GET['nombre_campo'].
• No es recomendable enviar datos sensibles (ejemplo: contraseñas).

Ejemplo de URL con parámetros

pagina.php?usuario=Pablo&edad=30

Ejemplo de código PHP

<?php
// Capturar valores enviados por GET
$usuario = $_GET['usuario'];
$edad    = $_GET['edad'];

// Mostrar resultados
echo "Usuario: " . $usuario;
echo "Edad: " . $edad;
?>

Ejemplo de enlace con parámetros

<a href="pagina.php?usuario=Ana&edad=25">Ver datos de Ana</a>

Ejemplo de formulario con GET

<form action="pagina.php" method="get">
  <label>Usuario:</label>
  <input type="text" name="usuario">

  <label>Edad:</label>
  <input type="number" name="edad">

  <button type="submit">Enviar</button>
</form>

Superglobal $_POST[...]

La superglobal $_POST se utiliza en PHP para acceder a los datos que se envían desde un formulario mediante el método POST. Es ideal para enviar información sensible (como contraseñas) porque los datos no se muestran en la URL.

Características principales

• Los datos viajan en el cuerpo de la petición HTTP, no visibles en la URL.
• Se usa principalmente con formularios method="post".
• Se accede mediante la sintaxis $_POST['nombre_campo'].
• Permite enviar gran cantidad de información (a diferencia de GET que tiene límite en la URL).

Ejemplo de formulario con POST

<form action="pagina.php" method="post">
  <label>Usuario:</label>
  <input type="text" name="usuario">

  <label>Contraseña:</label>
  <input type="password" name="clave">

  <button type="submit">Enviar</button>
</form>

Ejemplo de código PHP

<?php
// Capturar valores enviados por POST
$usuario = $_POST['usuario'];
$clave   = $_POST['clave'];

// Mostrar resultados (nunca mostrar contraseñas en un sistema real)
echo "Usuario: " . $usuario;
echo "Clave: " . $clave;
?>

Tabla comparativa rápida

Superglobal $_REQUEST[...]

La superglobal $_REQUEST en PHP permite acceder a datos enviados por GET, POST y COOKIE. Es como un contenedor que mezcla esas tres fuentes en un solo array asociativo.

Características principales

• Contiene los valores de $_GET, $_POST y $_COOKIE.
• Útil si no importa cómo se envían los datos (aunque es mejor usar $_GET o $_POST directamente para mayor claridad).
• Se accede igual que los demás: $_REQUEST['campo'].
• El orden de prioridad depende de la configuración de php.ini (directiva variables_order).

Ejemplo de formulario

<form action="pagina.php" method="post">
  <label>Usuario:</label>
  <input type="text" name="usuario">

  <label>Edad:</label>
  <input type="number" name="edad">

  <button type="submit">Enviar</button>
</form>

Ejemplo de código PHP

<?php
// Capturar valores enviados por GET, POST o COOKIE
$usuario = $_REQUEST['usuario'];
$edad    = $_REQUEST['edad'];

echo "Usuario: " . $usuario;
echo "Edad: " . $edad;
?>

Tabla comparativa rápida

Superglobal $_COOKIE[...]

La superglobal $_COOKIE permite acceder a las cookies que el navegador envía al servidor. Una cookie es un pequeño archivo de texto que el servidor guarda en el navegador del usuario, y que luego se reenvía automáticamente en cada petición.

Características principales

• Las cookies se crean con la función setcookie() en PHP.
• Almacenadas en el navegador del usuario.
• Pueden tener fecha de expiración.
• No son seguras para guardar datos sensibles sin cifrado.
• Se accede a ellas mediante $_COOKIE['nombre'].

Ejemplo de crear y leer una cookie

<?php
// Crear una cookie llamada "usuario" con valor "Pablo"
// Expira en 1 hora (3600 segundos)
setcookie("usuario", "Pablo", time() + 3600);

// Leer la cookie (estará disponible en la próxima carga de página)
if (isset($_COOKIE['usuario'])) {
    echo "Bienvenido, " . $_COOKIE['usuario'];
} else {
    echo "No hay cookie de usuario.";
}
?>

Ejemplo práctico de uso

• Recordar el nombre del usuario en un login.
• Guardar el idioma seleccionado en una web.
• Mantener las preferencias de tema (oscuro/claro).

Tabla resumen

Superglobal $_SESSION en PHP — Manual Completo

$_SESSION permite guardar datos del usuario en el servidor durante su navegación. A diferencia de las cookies, la información no viaja en cada request: el servidor la relaciona con el usuario mediante un session ID (típicamente en la cookie PHPSESSID).

Iniciar, escribir y leer sesión

<?php
// Iniciar la sesión (debe ir antes de cualquier echo/HTML)
session_start();

// Escribir valores
$_SESSION['user_id'] = 123;
$_SESSION['usuario'] = 'Pablo';
$_SESSION['rol']     = 'admin';

// Leer valores
echo $_SESSION['usuario']; // Pablo
?>

¿Cómo verifico si la sesión está abierta?

1) Con session_status() (recomendado)

<?php
if (session_status() === PHP_SESSION_ACTIVE) {
  echo "La sesión está abierta ✅";
} else {
  echo "No hay sesión activa ❌";
}
?>

2) Comprobando session_id() (tras intentar abrirla)

<?php
session_start();               // intenta abrir/crear sesión
if (session_id() !== "") {
  echo "Hay una sesión activa ✅";
} else {
  echo "No hay sesión activa ❌";
}
?>

3) Revisando si hay variables en $_SESSION

<?php
session_start();
if (!empty($_SESSION)) {
  echo "Sesión abierta y con datos:";
  var_dump($_SESSION);
} else {
  echo "No hay variables en la sesión.";
}
?>

Nota: el método 3 verifica que haya datos guardados, no solo que la sesión exista. Para saber si la sesión está activa, preferí session_status().

Destruir sesión (logout)

<?php
session_start();

// Quitar variables
session_unset();

// Destruir la sesión en el servidor
session_destroy();

// (Opcional) Borrar cookie de sesión en el cliente
if (ini_get("session.use_cookies")) {
  $params = session_get_cookie_params();
  setcookie(session_name(), '', time() - 42000,
    $params["path"], $params["domain"],
    $params["secure"], $params["httponly"]
  );
}

// Redirigir al inicio (opcional)
// header("Location: /");
?>

Buenas prácticas y seguridad

• Invocá session_start() al comienzo del script (antes de cualquier salida).
• Después de un login exitoso, regenerá el ID: session_regenerate_id(true) (previene fijación de sesión).
• No guardes contraseñas ni datos sensibles en texto plano dentro de la sesión.
• Validá rol/permisos antes de páginas protegidas.
• Cerrá sesión al salir (logout) y, si aplica, borrá la cookie de sesión.

Mini flujo de login (esquema de ejemplo)

<?php
session_start();

if ($_SERVER['REQUEST_METHOD'] === 'POST') {
  $user = $_POST['usuario'] ?? '';
  $pass = $_POST['clave']   ?? '';

  // (Ejemplo simplificado; en producción: consultar BD + password_verify)
  if ($user === 'admin' && $pass === '1234') {
    session_regenerate_id(true);
    $_SESSION['user_id'] = 1;
    $_SESSION['usuario'] = $user;
    $_SESSION['rol']     = 'admin';
    echo "Login OK ✅";
  } else {
    echo "Credenciales inválidas ❌";
  }
}
?>

Tabla comparativa: $_SESSION vs $_COOKIE

Atajos útiles

• session_name(): nombre de la sesión (cookie).
• session_get_cookie_params(): parámetros de la cookie de sesión.
• ini_get('session.save_path'): directorio donde se guardan archivos de sesión.

Superglobal $_FILES[...]

$_FILES es una superglobal que contiene la información de los archivos subidos mediante un formulario con method="post" y enctype="multipart/form-data". Cada input de tipo file genera una entrada en $_FILES.

¿Qué contiene $_FILES?

Para un input <input type="file" name="foto">, se obtiene:

Formulario de ejemplo (POST + multipart)

<form action="subir.php" method="post" enctype="multipart/form-data">
  <label>Seleccioná una imagen:</label>
  <input type="file" name="foto" accept="image/*">
  <button type="submit">Subir</button>
</form>

PHP básico para recibir el archivo

<?php
// subir.php
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
  if (isset($_FILES['foto']) && $_FILES['foto']['error'] === UPLOAD_ERR_OK) {
    $tmp  = $_FILES['foto']['tmp_name'];
    $name = basename($_FILES['foto']['name']); // OJO: sanitizar
    $dest = __DIR__ . '/uploads/' . $name;

    // Crear carpeta si no existe
    if (!is_dir(__DIR__ . '/uploads')) {
      mkdir(__DIR__ . '/uploads', 0775, true);
    }

    if (move_uploaded_file($tmp, $dest)) {
      echo "✅ Archivo subido a: " . $dest;
    } else {
      echo "❌ No se pudo mover el archivo.";
    }
  } else {
    echo "❌ Error en la subida: " . ($_FILES['foto']['error'] ?? 'sin archivo');
  }
}
?>

Validaciones recomendadas

<?php
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
  $maxBytes = 2 * 1024 * 1024; // 2 MB
  $permitidos = ['image/jpeg','image/png','image/gif'];

  if (!isset($_FILES['foto']) || $_FILES['foto']['error'] !== UPLOAD_ERR_OK) {
    die("Error en la carga.");
  }

  // Tamaño
  if ($_FILES['foto']['size'] > $maxBytes) {
    die("Archivo demasiado grande (máx 2MB).");
  }

  // Tipo MIME (verificación doble: MIME + extensión)
  $finfo = new finfo(FILEINFO_MIME_TYPE);
  $mime = $finfo->file($_FILES['foto']['tmp_name']);
  if (!in_array($mime, $permitidos, true)) {
    die("Tipo no permitido.");
  }

  // Nombre seguro (evitar rutas y caracteres raros)
  $ext = pathinfo($_FILES['foto']['name'], PATHINFO_EXTENSION);
  $nombreSeguro = bin2hex(random_bytes(8)) . '.' . strtolower($ext);

  $dest = __DIR__ . '/uploads/' . $nombreSeguro;
  if (!is_dir(__DIR__ . '/uploads')) mkdir(__DIR__ . '/uploads', 0775, true);

  if (move_uploaded_file($_FILES['foto']['tmp_name'], $dest)) {
    echo "Subido como: " . htmlspecialchars($nombreSeguro);
  } else {
    echo "No se pudo guardar el archivo.";
  }
}
?>

Códigos de error comunes en $_FILES['campo']['error']

Ajustes del servidor (php.ini) a considerar

• file_uploads = On (habilita subidas).
• upload_max_filesize (tamaño máx. por archivo, ej. 8M).
• post_max_size (límite total del POST; debe ser ≥ upload_max_filesize).
• max_file_uploads (máximo de archivos por request).
• upload_tmp_dir (directorio temporal).

Buenas prácticas

• Usar siempre enctype="multipart/form-data" en el formulario.
• Validar tamaño, tipo MIME y extensión.
• Renombrar el archivo (ID aleatorio) y guardar fuera de public_html si es posible.
• Usar move_uploaded_file() (no rename()).
• Nunca confiar solo en $_FILES['type']; validar con finfo.
• Limitar tipos permitidos (lista blanca).

Superglobal $_SERVER[...]

$_SERVER es un array asociativo que contiene información sobre la petición HTTP, el servidor y el entorno de ejecución. Incluye datos como el método de la request, la URL, cabeceras, IP del cliente, nombre del host, ruta del script, etc.

Índices comunes de $_SERVER

Detectar método, URL y protocolo

<?php
$metodo   = $_SERVER['REQUEST_METHOD'] ?? '';
$uri      = $_SERVER['REQUEST_URI']    ?? '';
$protocolo= $_SERVER['SERVER_PROTOCOL'] ?? '';
echo "Método: $metodo\nURI: $uri\nProtocolo: $protocolo";
?>

¿La conexión es HTTPS?

<?php
$esHttps = false;

if (!empty($_SERVER['HTTPS']) && $_SERVER['HTTPS'] !== 'off') {
  $esHttps = true;
}
// Detrás de proxy/reverse proxy:
if (isset($_SERVER['HTTP_X_FORWARDED_PROTO']) && $_SERVER['HTTP_X_FORWARDED_PROTO'] === 'https') {
  $esHttps = true;
}

echo $esHttps ? "Conexión segura (HTTPS)" : "Conexión no segura (HTTP)";
?>

Obtener IP del cliente (considerando proxies)

<?php
function ipCliente(): string {
  $cabeceras = [
    'HTTP_CLIENT_IP',
    'HTTP_X_FORWARDED_FOR',
    'HTTP_X_FORWARDED',
    'HTTP_X_CLUSTER_CLIENT_IP',
    'HTTP_FORWARDED_FOR',
    'HTTP_FORWARDED',
    'REMOTE_ADDR'
  ];
  foreach ($cabeceras as $h) {
    if (!empty($_SERVER[$h])) {
      // X-Forwarded-For puede traer una lista de IPs
      $ips = explode(',', $_SERVER[$h]);
      foreach ($ips as $ip) {
        $ip = trim($ip);
        if (filter_var($ip, FILTER_VALIDATE_IP)) {
          return $ip;
        }
      }
    }
  }
  return 'desconocida';
}

echo "IP cliente: " . ipCliente();
?>

Leer cabeceras HTTP

<?php
// Si está disponible:
if (function_exists('getallheaders')) {
  $headers = getallheaders();
  foreach ($headers as $k => $v) {
    echo $k . ': ' . $v . "\n";
  }
} else {
  // Alternativa: recorrer $_SERVER con prefijo HTTP_
  foreach ($_SERVER as $k => $v) {
    if (strpos($k, 'HTTP_') === 0) {
      echo $k . ': ' . $v . "\n";
    }
  }
}
?>

Construir la URL completa actual

<?php
$esHttps = (!empty($_SERVER['HTTPS']) && $_SERVER['HTTPS'] !== 'off') 
           || (($_SERVER['HTTP_X_FORWARDED_PROTO'] ?? '') === 'https');
$scheme = $esHttps ? 'https' : 'http';
$host   = $_SERVER['HTTP_HOST']       ?? 'localhost';
$uri    = $_SERVER['REQUEST_URI']     ?? '/';

$urlActual = $scheme . '://' . $host . $uri;
echo $urlActual;
?>

Ruta del script y document root

<?php
$script = $_SERVER['SCRIPT_NAME']   ?? '';
$root   = $_SERVER['DOCUMENT_ROOT'] ?? '';
echo "SCRIPT_NAME: $script\nDOCUMENT_ROOT: $root";
?>

Buenas prácticas

• Comprobá existencia de índices con isset() o el operador null-coalescing ??.
• Detrás de proxies, preferí cabeceras estándar (ej. X-Forwarded-For, X-Forwarded-Proto) configuradas por tu proxy.
• No confíes ciegamente en $_SERVER['HTTP_*']: pueden ser manipuladas por el cliente si tu proxy/servidor no las filtra.
• Usá HTTPS siempre que sea posible; forzalo con redirecciones y cabeceras HSTS.

Superglobal $_ENV[...]

La superglobal $_ENV contiene variables de entorno disponibles para el script PHP. Estas variables suelen provenir del sistema operativo, de la configuración de php.ini o de archivos de configuración externos (por ejemplo, un .env en frameworks modernos).

Ejemplo de lectura de $_ENV

<?php
// Acceder a una variable de entorno
echo $_ENV['PATH'];

// O usando getenv()
echo getenv('PATH');
?>

Definir variables de entorno

• En Linux/macOS: export MI_VAR=hola
• En Windows (CMD): set MI_VAR=hola
• En php.ini: env[MI_VAR] = hola

Ejemplo práctico

<?php
// Archivo de configuración
$_ENV['DB_HOST'] = "localhost";
$_ENV['DB_USER'] = "root";
$_ENV['DB_PASS'] = "secreto";

// Uso en conexión
$host = $_ENV['DB_HOST'];
$user = $_ENV['DB_USER'];
$pass = $_ENV['DB_PASS'];

echo "Conectando a la BD en $host con usuario $user";
?>

Ventajas de usar $_ENV

• Separación entre código y configuración.
• No exponer contraseñas ni claves API en el repositorio.
• Permite cambiar parámetros según el entorno (desarrollo, testing, producción).

Comparación con otras superglobales

Superglobal $GLOBALS[...]

La superglobal $GLOBALS es un array asociativo que contiene todas las variables definidas en el ámbito global del script PHP. Permite acceder a variables globales desde funciones o métodos sin necesidad de usar la palabra clave global.

Ejemplo básico

<?php
$numero = 42;

function mostrarNumero() {
  echo $GLOBALS['numero']; // Accede a $numero desde dentro de la función
}

mostrarNumero(); // 42
?>

Comparación con usar global

<?php
$mensaje = "Hola mundo";

// Usando global
function ejemplo1() {
  global $mensaje;
  echo $mensaje;
}

// Usando $GLOBALS
function ejemplo2() {
  echo $GLOBALS['mensaje'];
}

ejemplo1(); // Hola mundo
ejemplo2(); // Hola mundo
?>

Uso típico

• Acceder a variables globales dentro de funciones.
• Depurar el estado global del script (ej: var_dump($GLOBALS)).
• Casos puntuales donde se requiera compartir valores sin pasarlos como parámetros.

Ejemplo de depuración con $GLOBALS

<?php
$usuario = "Pablo";
$rol     = "admin";

var_dump($GLOBALS);
/*
array( ... ) {
  ["usuario"] => string(5) "Pablo"
  ["rol"] => string(5) "admin"
  ["GLOBALS"] => &array(...) // referencia a sí mismo
}
*/
?>

Tabla resumen