Glosario PHP de la A a la Z — PHP

Glosario PHP — 124 definiciones

Todos los términos definidos en las 25 secciones de la guía, ordenados alfabéticamente.
Consejo: pulsa Ctrl + F para buscar un término en la página.

«En mi máquina funciona»: El problema que Docker resuelve (frecuente en PHP: versiones, extensiones, configuración, mayúsculas Windows/Linux): el contenedor incluye su entorno y funciona igual en todas partes.
== vs === / comillas: `==` compara con conversión de tipo (laxa, sorprendente); `===` compara valor Y tipo (estricta, preferible). Las comillas dobles interpretan las variables; las simples = literal.
$_GET vs $_POST: GET: datos en la URL (visibles, para búsquedas/filtros/enlaces). POST: datos en el cuerpo (no visibles, para formularios que modifican, datos sensibles).
API REST: Interfaz que expone datos (en JSON) consumidos por otros programas (front, móvil, servicios); recursos vía URL, métodos HTTP semánticos, códigos de estado.
Arquitectura limpia: Separación de capas, desacoplamiento, depender de abstracciones, código legible; produce un código mantenible, flexible, testeable y evolutivo.
Aserciones: Comprobaciones que realiza un test: assertEquals(esperado, resultado), assertTrue, assertNull…; fallan si la realidad no coincide con lo esperado.
Autenticación por tokens: Para las API (sin estado, front separado/móvil): tras el login, el servidor emite un TOKEN que el cliente devuelve en cada petición (cabecera Authorization) y que el servidor verifica.
Autenticación por sesión: Conexión: verificar identificador + contraseña, guardar la identidad en sesión; páginas protegidas: verificar la sesión; desconexión: destruir la sesión.
Autoloading (PSR-4): Carga AUTOMÁTICAMENTE el archivo de una clase al usarla (se acabaron las inclusiones manuales), mediante una convención (PSR-4) que asocia namespaces y estructura de carpetas.
Etiquetas PHP: El código PHP va entre ``; fuera de las etiquetas = HTML (enviado tal cual), dentro = código PHP (ejecutado). Permite mezclar PHP y HTML.
Base de datos / MySQL: Sistema que almacena datos de forma duradera (usuarios, productos…). MySQL/MariaDB: base RELACIONAL (tablas, filas, columnas) consultada en SQL (SELECT/INSERT/UPDATE/DELETE = CRUD).
Ventajas de Docker: Reproducibilidad (idéntico en todas partes), aislamiento (versiones de PHP distintas sin conflictos), portabilidad, despliegue fácil, incorporación rápida (docker compose up).
Ventajas de los tests: Confianza (el código hace lo que debe), NO REGRESIÓN (detectar lo que un cambio rompe), documentación (comportamiento esperado), mejor diseño (código testeable = mejor estructurado), detección temprana de errores.
Blade (plantillas): El motor de plantillas de Laravel: sintaxis limpia ({{ }}, @foreach, @if) con ESCAPE AUTOMÁTICO (protección XSS por defecto) y layouts reutilizables (herencia).
Bucle: Repite un tratamiento en lugar de duplicar código; imprescindible para manipular colecciones o repetir una acción.
break / continue: break: SALE del bucle inmediatamente. continue: PASA a la siguiente iteración. Cuidado con los bucles INFINITOS (condición que nunca se vuelve falsa).
CI/CD (GitHub Actions): Automatizar código → producción: CI (en cada push, probar/verificar — PHPUnit), CD (desplegar automáticamente si las verificaciones pasan). GitHub Actions/GitLab CI crean estos pipelines.
Closures / funciones nativas: Funciones anónimas (closures) y de flecha: sin nombre, almacenables/pasables (callbacks). PHP tiene cientos de funciones nativas (strlen, array_map…) — consulta la documentación.
Comentarios: Texto ignorado por PHP para explicar el código: `//` o `#` (una línea), `/* ... */` (varias líneas); esenciales para la legibilidad.
Componentes de Symfony: Symfony está hecho de componentes independientes (enrutado, formularios, seguridad, consola…) utilizables por separado; muchos proyectos (incluido Laravel) los usan por debajo.
Composer: Gestor de DEPENDENCIAS de PHP (equivalente a npm): instalar bibliotecas externas y gestionar sus versiones; transformó el ecosistema PHP.
composer.json / vendor: composer.json declara las dependencias; `composer install` las descarga (carpeta vendor/, no versionada, regenerable) y genera el autoloader (vendor/autoload.php). composer.lock fija las versiones.
Concatenación (.): En PHP, las cadenas se unen con el PUNTO `.` (no con `+`): `'Hola ' . $nombre`.
Configuración y secretos: Parámetros y SECRETOS (identificadores de base, claves) proporcionados por el entorno de producción, NUNCA en el código/repositorio Git (variables de entorno, .env fuera del repositorio).
Controlador (Controller): Hace de ENLACE: recibe la petición, llama al Modelo para los datos, elige la Vista a mostrar con esos datos; orquesta modelo y vista.
Cookies ($_COOKIE): Pequeños datos almacenados en el NAVEGADOR, devueltos en cada petición (setcookie / $_COOKIE); del lado del cliente (modificables) — opciones de seguridad HttpOnly, Secure, SameSite.
Lado del servidor vs lado del cliente: Servidor (PHP): ejecuta la lógica (formularios, base, autenticación) y genera las páginas. Cliente (navegador): muestra el HTML/CSS y ejecuta JavaScript.
CRUD: Las cuatro operaciones básicas: Create (INSERT), Read (SELECT), Update (UPDATE), Delete (DELETE); realizadas con PDO y consultas preparadas, con recuperación (fetch/fetchAll).
CSRF → tokens: Obligar a un usuario conectado a ejecutar una acción sin saberlo (petición forjada); protección: tokens CSRF (único por formulario, verificado) y cookie SameSite.
Ciclo petición → PHP → HTML: El usuario pide una página → el servidor ejecuta el código PHP → PHP genera HTML → el navegador lo muestra. Este ciclo se repite en cada petición.
Fechas (DateTime): El PHP moderno maneja las fechas con la clase DateTime/DateTimeImmutable: crear, FORMATEAR para mostrar (->format), calcular diferencias (->diff), sumar/restar.
Despliegue / hosting: Hacer funcionar la aplicación PHP en un servidor accesible en Internet. Opciones: hosting compartido (simple, económico), PaaS (simplificado), VPS (control + responsabilidades), nube.
Patrones de diseño: Soluciones PROBADAS a problemas de diseño recurrentes (recetas de organización validadas); dan un vocabulario común. Ej.: Factory, Repository, Strategy, Observer, Dependency Injection.
Criterio (vs sobreingeniería): Aplicar patrones y SOLID con MEDIDA según el problema; la sobreingeniería (estructura excesiva innecesaria) es una trampa, como la infraingeniería (desorden). Encontrar el nivel justo.
Docker / contenedores: Herramienta que empaqueta una aplicación CON todo su entorno (PHP, extensiones, configuración, dependencias) en un contenedor aislado y portable, que funciona igual en todas partes.
Docker Compose (stack PHP): Archivo docker-compose.yml que define varios contenedores (PHP/Nginx + MySQL + Redis…) y sus relaciones, lanzados juntos (docker compose up); describe todo el stack PHP.
Doctrine (ORM): El ORM asociado a Symfony: manipular ENTIDADES (objetos) en lugar de SQL, consultas preparadas automáticas, relaciones, migraciones; enfoque «Data Mapper» (vs Active Record de Eloquent).
Carpeta raíz web / localhost: Carpeta donde colocar tus archivos .php (htdocs, www) para que se sirvan; se accede vía http://localhost (tu propia máquina).
echo: Construcción para MOSTRAR (producir salida): `echo 'Hola';` genera texto/HTML en la página. La herramienta fundamental de salida (también `print`).
Eloquent (ORM): El ORM de Laravel: tablas ↔ clases (modelos), filas ↔ objetos; manipular la base vía objetos/métodos (Producto::all()) en lugar de SQL, con consultas preparadas automáticas y gestión de relaciones.
Encapsulación / visibilidad: Agrupar datos y comportamientos, y controlar el acceso vía la visibilidad: public (todas partes), private (solo la clase), protected (clase + descendientes). Propiedades private + getters/setters para proteger el estado.
Entorno local (AMP): Lo necesario para ejecutar PHP y una base en tu máquina para desarrollar/probar. AMP = servidor web (Apache), PHP, base (MySQL) — a menudo instalados juntos vía un pack.
Envío de e-mails: La función nativa mail() es básica/poco fiable; usar bibliotecas dedicadas (PHPMailer, Symfony Mailer) para la fiabilidad. No inyectar nunca datos no controlados en las cabeceras.
Esenciales de producción PHP: HTTPS, errores NO mostrados (registrados), OPcache activado, autoloader de Composer optimizado, migraciones ejecutadas al desplegar, entornos separados (dev/staging/prod).
Expresiones regulares (regex): Minilenguaje que describe patrones en el texto; preg_match (¿coincide?), preg_replace (reemplazar). Potentes pero difíciles.
filter_var para validar: Para las validaciones comunes (email, URL…), preferir filter_var (FILTER_VALIDATE_EMAIL…) a una regex casera — más fiable. Reservar las regex para patrones específicos.
Función: Bloque de código reutilizable que realiza una tarea: `function saludar($nombre) { return ... }`, llamada por su nombre. Evita la duplicación, mejora legibilidad y mantenimiento.
Funciones de arrays/cadenas: Cientos de funciones nativas: arrays (count, in_array, array_map/filter/reduce, sort, implode/explode…), cadenas (strlen, str_replace, substr, trim, str_contains…).
Funciones multibyte (mb_): Para tratar correctamente Unicode (caracteres acentuados/no latinos): mb_strlen, mb_substr…; las funciones clásicas trabajan con bytes (problema en UTF-8).
for: Bucle con contador, cuando se conoce el número de repeticiones: `for ($i = 0; $i < 10; $i++) { ... }` (inicialización; condición; incremento).
foreach: Bucle para RECORRER un array (el más usado): `foreach ($arr as $valor)` (cada valor) o `foreach ($arr as $clave => $valor)` (pares clave → valor).
Formulario / superglobales: Los formularios envían datos al servidor, que PHP recupera vía superglobales (arrays especiales disponibles en todas partes): $_GET, $_POST, $_FILES, $_SESSION…
Zona horaria y formato de almacenamiento: Puntos de vigilancia: configurar la ZONA horaria (si no, horas falsas); ALMACENAR las fechas en un formato estándar (ISO AAAA-MM-DD) y FORMATEARLAS solo al mostrar.
Gestión de archivos: Leer/escribir archivos del servidor: file_get_contents, file_put_contents, fopen/fread/fwrite, file_exists, unlink (eliminar).
Git para desplegar: Desplegar vía Git (el servidor recupera el código desde el repositorio) en lugar de transferir los archivos a mano (FTP) — más fiable y trazable.
Hash / HTTPS / secretos: Contraseñas HASHEADAS (password_hash/verify, nunca en claro); HTTPS (cifrado); secretos fuera del código (variables de entorno); errores no mostrados en producción; dependencias actualizadas.
Herencia: Una clase hereda de otra (`class Admin extends User`): obtiene sus propiedades/métodos, puede añadir o REDEFINIR; permite reutilización y especialización.
HTTP sin estado (stateless): Cada petición HTTP es independiente, el servidor no recuerda las anteriores; cookies y sesiones añaden una «memoria» entre páginas.
if / elseif / else: Ejecuta un bloque SI una condición es verdadera; else (si no), elseif (si no, si, varias condiciones en cascada). La condición se evalúa a true/false.
Imagen / Dockerfile / contenedor: Imagen: plantilla fija de la app + entorno, definida por un Dockerfile (receta: imagen PHP base, extensiones, código, dependencias Composer). Contenedor: instancia en ejecución.
include / require: Insertan el contenido de un archivo en otro. require: error FATAL si no se encuentra (archivos indispensables). include: aviso y continúa (opcionales).
Inyección SQL: Fallo CRÍTICO: concatenar datos de usuario en una consulta SQL permite a un atacante inyectar SQL malicioso (leer/modificar/destruir la base). A evitar absolutamente.
Inyección SQL → consultas preparadas: Inyectar SQL vía datos concatenados; protección: SIEMPRE consultas preparadas (PDO), nunca concatenación en el SQL.
Interfaces / traits: Interfaz: «contrato» de métodos que una clase debe implementar (programar por contrato, desacoplar). Trait: reutilizar métodos en varias clases sin herencia (uso compartido horizontal).
Intérprete PHP: El programa que ejecuta el código PHP en el servidor; el visitante nunca ve el código PHP, solo el HTML resultante.
JWT (JSON Web Token): Token FIRMADO criptográficamente (autocontenido, sin almacenamiento en servidor), muy común para las API; devuelto en cada petición y verificado. Adecuado para fronts separados y móvil.
Laravel: El framework PHP más popular (elegante, productivo, vasto ecosistema); implementa el MVC y proporciona herramientas potentes que aplican las buenas prácticas. La referencia del PHP moderno.
Laravel vs Symfony: Dos excelentes frameworks maduros: Laravel más accesible/productivo; Symfony más riguroso/modular/empresarial. Mismos conceptos (MVC, ORM, plantillas) — transferibles.
Migraciones: Sistema que versiona la estructura de la base (crear/modificar tablas vía código PHP versionado): estructura reproducible, evolución trazable — esencial en equipo y al desplegar.
Puesta en caché (Redis): Almacenar resultados costosos (consultas frecuentes, cálculos, páginas) para no rehacerlos; Redis (o Memcached) = almacenamiento EN MEMORIA rápido usado como caché. A menudo la palanca más impactante.
Modelo (Model): Gestiona los DATOS y la LÓGICA DE NEGOCIO: acceso a la base, entidades (Usuario, Producto), reglas de negocio — independientemente de la visualización.
MVC (Modelo-Vista-Controlador): Patrón de arquitectura que separa la aplicación en tres responsabilidades: Modelo (datos/lógica de negocio), Vista (visualización), Controlador (coordinación). La base de los frameworks web.
Namespaces (espacios de nombres): Organizan las clases en «espacios» lógicos y evitan CONFLICTOS de nombres (dos `User` coexisten en namespaces distintos). Declaración `namespace App\Models;`, importación con `use`.
No confiar nunca en las entradas: Todo dato de usuario (formulario, URL) es potencialmente erróneo o malicioso; validar y sanear siempre del LADO DEL SERVIDOR antes de usarlo.
No optimizar prematuramente: Código correcto y claro primero, MEDIR cuando surja un problema, luego optimizar de forma SELECTIVA. Optimizar demasiado pronto hace perder tiempo y complica innecesariamente.
Niveles de tests: Unitarios (una función/clase aislada), de integración (varias partes juntas, ej. con la base), funcionales/de extremo a extremo (la aplicación como un usuario).
Fusión null ?? / match: `??` devuelve la izquierda si existe y no es null, si no la derecha (valores por defecto). `match` (PHP 8+) = switch moderno, estricto, que devuelve un valor.
OPcache: Extensión que guarda en CACHÉ el bytecode PHP compilado: la compilación solo se hace una vez (en lugar de en cada petición) — gran ganancia de rendimiento casi gratis. A activar, sobre todo en producción.
Operadores: Aritméticos (+ - * / % **), asignación (=, +=…), comparación (==, ===, !=, <, >…), lógicos (&& || !).
Optimización de la base: A menudo el verdadero cuello de botella: consultas lentas/sin índices, problema N+1 (una consulta por elemento — a corregir con eager loading). Indexar y optimizar las consultas suele tener el mayor impacto.
Organización por inclusiones: Dividir el código en archivos lógicos (config, funciones, header/footer, páginas) ensamblados por inclusiones; primer paso hacia una arquitectura limpia (MVC, autoloading).
Pack todo en uno: Instalación que agrupa servidor web + PHP + base de datos: XAMPP (multiplataforma), Laragon, WampServer (Windows), MAMP (macOS) — lo más simple para empezar.
Packagist / ecosistema: El repositorio de paquetes PHP (vía Composer): un inmenso ecosistema de bibliotecas reutilizables — instalar componentes probados en lugar de codificarlo todo.
Página dinámica: Página generada por el servidor, a menudo personalizada (según usuario, datos); frente a una página HTML estática siempre idéntica.
Parámetros / retorno: Parámetros: datos pasados como entrada (con posibles valores por defecto). Retorno (vía `return`): el resultado devuelto. Las entradas y salidas de la función.
Patrones comunes (PHP): Singleton (una sola instancia, usar con moderación), Factory (crear objetos), Repository (centralizar el acceso a los datos), Dependency Injection (proporcionar las dependencias desde fuera) — usados por los frameworks.
PDO: PHP Data Objects: interfaz moderna, unificada y segura para conectarse a las bases y ejecutar consultas; funciona con varios tipos de bases (abstracción).
PHP: Lenguaje de programación del lado del servidor diseñado para la Web (PHP: Hypertext Preprocessor); se ejecuta en el servidor y genera HTML enviado al navegador.
phpinfo(): Función que muestra la información de configuración PHP; un archivo info.php con phpinfo() verifica que el entorno funciona y muestra la versión instalada.
phpMyAdmin: Interfaz web (incluida en los packs) para crear y gestionar bases de datos MySQL sin línea de comandos.
Punto y coma: Termina cada instrucción PHP (`;`); olvidarlo provoca un error de sintaxis — el error de principiante más frecuente.
Polimorfismo / abstracción: Polimorfismo: objetos de clases distintas responden al mismo método de forma diferente. Abstracción: ocultar la complejidad tras interfaces simples.
POO / Clase / Objeto: Paradigma que organiza el código alrededor de OBJETOS (datos + comportamientos). Una CLASE es un modelo (propiedades + métodos); un OBJETO es una instancia (`new User()`). $this = el objeto actual; __construct = constructor (inicialización).
Alcance (scope): Una variable definida en una función es LOCAL (invisible fuera); una variable externa no es accesible dentro de la función. Aislamiento buscado — pasar los datos como PARÁMETROS.
Perfilado / medir antes de optimizar: Identificar los verdaderos cuellos de botella mediante la MEDICIÓN (perfilado) antes de optimizar (regla de oro); evitar optimizar a ciegas o prematuramente.
Consulta preparada: Consulta con MARCADORES (? o :nombre) donde los datos se pasan POR SEPARADO (prepare y luego execute); la base los trata como datos puros — la inyección SQL se vuelve imposible.
require_once / include_once: Garantizan que un archivo solo se incluye UNA vez (evita inclusiones múltiples y redefiniciones) — a menudo preferibles.
Recursos y métodos (API): GET /api/productos (listar), GET /{id} (leer), POST (crear, 201), PUT/PATCH (modificar), DELETE (eliminar); respuestas JSON con los códigos adecuados (200, 201, 400, 401, 404…).
Enrutado / controladores / Artisan: Enrutado: asociar URL a acciones (Route::get). Controladores: clases que tratan las peticiones. Artisan: línea de comandos (generar código, migraciones…).
Enrutado / flujo MVC: El enrutado dirige la petición al controlador adecuado; flujo: petición → enrutado → controlador → modelo (datos) → vista (visualización). Separa datos, visualización y coordinación.
Seguridad de API: Autenticación por tokens seguros, HTTPS (imprescindible — los tokens circulan), validación de entradas, autorización (permisos), gestión de errores limpia (códigos/JSON), rate limiting.
Seguridad de sesión: Contraseñas HASHEADAS (password_hash/verify), regenerar el ID al conectar (contra la fijación), cookies seguras (HttpOnly/Secure/SameSite), HTTPS y control de acceso (autorización).
Sesiones ($_SESSION): Estado almacenado DEL LADO DEL SERVIDOR (no modificable por el usuario), el navegador solo guarda un identificador de sesión. session_start() y luego $_SESSION. El mecanismo seguro.
SOLID: Cinco principios de diseño OO: Single Responsibility (una responsabilidad), Open/Closed (extensión sin modificación), Liskov, Interface Segregation, Dependency Inversion (depender de abstracciones).
switch: Compara UNA variable con varios valores (case), más legible que una cascada de elseif; el `break` sale del switch (olvidarlo cae en el case siguiente); default para los demás casos.
Symfony: El otro gran framework PHP (junto a Laravel), conocido como riguroso, modular, apreciado en empresa y en grandes proyectos; arquitectura en COMPONENTES reutilizables.
Sintaxis corta <?= ?>: Equivalente de `<?php echo ... ?>`: `<?= $variable ?>` muestra una variable, práctico en las plantillas HTML. Las variables distinguen mayúsculas (pero las palabras clave no).
Array asociativo: Colección cuyos elementos se acceden por una CLAVE de texto: `$persona = ['nombre' => 'Alicia']; $persona['nombre']`. Omnipresente (datos estructurados).
Array indexado: Colección cuyos elementos se acceden por un ÍNDICE numérico (desde 0): `$frutas = ['manzana', 'plátano']; $frutas[0]`.
Array multidimensional: Arrays DENTRO de arrays (ej. una lista de usuarios, cada uno un array asociativo); representa datos complejos.
TDD (Test-Driven Development): Escribir los tests ANTES del código (el test define lo que el código debe hacer, luego se escribe para que pase); una disciplina que mejora el diseño.
Ternario: Atajo if/else que devuelve un valor: `condición ? valorSiVerdadero : valorSiFalso`. Práctico para asignaciones condicionales cortas.
Tests automatizados / PHPUnit: Código que PRUEBA tu código (re-ejecutable a voluntad), en lugar de verificar a mano. PHPUnit es el framework de test estándar de PHP (instalado vía Composer).
Twig (plantillas): El motor de plantillas de Symfony: sintaxis limpia y segura ({{ }}, {% for %}, {% if %}) con escape automático (XSS) y herencia; apreciado más allá de Symfony.
Tipado de parámetros/retorno: Declarar los tipos (`function f(int $a): int`) documenta, captura errores y hace el código robusto — muy recomendado en PHP moderno.
Tipado dinámico: PHP determina el tipo según el valor (sin declaración previa); una variable puede cambiar de tipo. Tipos: string, int, float, bool, array, null, object.
Subidas ($_FILES) — seguridad: Archivos enviados por el usuario ($_FILES), a tratar con precaución: verificar tipo/tamaño, RENOMBRAR, almacenar fuera de la raíz/sin ejecución PHP, limitar las extensiones. Fuente clásica de fallos.
Valores «falsy»: Valores que PHP considera «falsos» en una condición: false, 0, cadena vacía, '0', null, array vacío; el resto es «verdadero».
Validación del lado del servidor obligatoria: La validación del lado del cliente (JavaScript) mejora la experiencia pero es burlable; la validación del lado del servidor (PHP) es obligatoria — es la que protege de verdad.
Validar: Verificar que los datos tienen el formato esperado (email válido, número positivo, campo requerido) y rechazar si no; filter_var() ayuda (email, URL, entero…).
Variable ($): Almacena un dato; empieza siempre por `$` (`$nombre`), asignada con `=` (`$edad = 30;`). Nombre sensible a mayúsculas, a elegir claro y expresivo.
Vista (View): Gestiona la VISUALIZACIÓN: el HTML, lo que ve el usuario; recibe datos preparados y los presenta, sin lógica de negocio.
while / do...while: while: repite MIENTRAS una condición es verdadera (número desconocido). do...while: ejecuta al menos una vez (prueba al final).
XSS → htmlspecialchars: Inyectar JavaScript que se ejecuta en otros usuarios (mostrar datos sin escapar); protección: ESCAPAR al mostrar con htmlspecialchars().