Chuleta de PHP

Resumen de consulta rápida con lo esencial de PHP 8.4. Cada apartado enlaza a la lección donde se explica con calma.

Sintaxis y echo

Código	Qué hace
`<?php ... ?>`	Abre y cierra un bloque de PHP (en archivos solo PHP no se cierra)
`echo "Hola";`	Muestra un texto en la página
`echo "a", "b";`	Muestra varios valores seguidos
`<?= $nombre ?>`	Atajo de `echo` dentro del HTML
`print_r($lista);`	Muestra un array de forma legible
`var_dump(5.5);`	Muestra tipo y valor → `float(5.5)`
`// comentario`	Comentario de una línea
`/* comentario */`	Comentario de varias líneas
`php -S localhost:8000`	Arranca el servidor de desarrollo
`php archivo.php`	Ejecuta un archivo desde la terminal

<?php
declare(strict_types=1);

echo "Hola, mundo\n";

Más en: ¿Qué es PHP? · Instalación · Sintaxis

Variables y tipos

Código	Qué hace
`$edad = 30;`	Crea una variable (empieza por `$`)
`const IVA = 0.21;`	Constante
`define("APP", "Tienda");`	Constante creada en tiempo de ejecución
`gettype(3.5)`	`"double"`
`is_int($x)`, `is_string($x)`	Comprueban el tipo → `true` o `false`
`isset($x)`	`true` si existe y no es `null`
`empty($x)`	`true` si es `""`, `0`, `[]`, `null` o `false`
`(int) "42abc"`	`42`
`(float) "3.5"`	`3.5`
`(string) 10`	`"10"`
`(bool) "0"`	`false`
`intval("12")`	`12`
`unset($x);`	Borra la variable

Tipo	Ejemplo
`int`	`42`, `1_000_000`
`float`	`3.14`
`string`	`"hola"`, `'hola'`
`bool`	`true`, `false`
`array`	`[1, 2, 3]`
`null`	`null` (sin valor)

Más en: Variables y tipos

Operadores

Código	Resultado
`7 % 3`	`1` (resto)
`intdiv(7, 2)`	`3` (división entera)
`2 ** 10`	`1024`
`$x += 5;`	`$x = $x + 5;`
`"a" . "b"`	`"ab"` (concatena)
`$t .= "más";`	Añade texto al final
`5 == "5"`	`true` (compara convirtiendo)
`5 === "5"`	`false` (estricta: úsala siempre)
`3 <=> 5`	`-1` (nave espacial: -1, 0 o 1)
`$a ?? "defecto"`	`$a`, o `"defecto"` si no existe o es `null`
`$a ??= 10;`	Asigna solo si es `null`
`$u?->nombre`	`null` si `$u` es `null` (nullsafe)
`$edad >= 18 ? "adulto" : "menor"`	Operador ternario
`&&`, `\|\|`, `!`	Y, O, NO

Más en: Operadores

Cadenas

Código	Resultado
`"Hola $nombre"`	Interpola la variable (solo con comillas dobles)
`"Total: {$p['precio']} €"`	Interpola una posición de array
`'Hola $nombre'`	Texto literal, no interpola
`strlen("hola")`	`4` (bytes)
`mb_strlen("año")`	`3` (caracteres)
`strtoupper("hola")`	`"HOLA"`
`mb_strtoupper("año")`	`"AÑO"`
`ucfirst("hola")`	`"Hola"`
`trim(" hola ")`	`"hola"`
`str_contains("casa", "as")`	`true`
`str_starts_with("casa", "ca")`	`true` (también `str_ends_with`)
`strpos("banana", "n")`	`2` (`false` si no está)
`substr("PHP moderno", 0, 3)`	`"PHP"`
`str_replace("o", "0", "hola")`	`"h0la"`
`explode(",", "a,b,c")`	`["a", "b", "c"]`
`implode("-", ["a", "b"])`	`"a-b"`
`str_pad("7", 3, "0", STR_PAD_LEFT)`	`"007"`
`number_format(1234.5, 2, ",", ".")`	`"1.234,50"`
`sprintf("%05.1f", 3.14159)`	`"003.1"`
`str_repeat("ab", 3)`	`"ababab"`

Cuidado: strlen cuenta bytes. Con tildes y eñes usa las funciones mb_.

Más en: Cadenas

Arrays

Código (`$n = [5, 3, 8]`)	Resultado
`$n[0]`	`5`
`$n[] = 1;`	Añade al final
`count($n)`	`3`
`array_push($n, 7, 9)`	Añade varios al final
`array_pop($n)`	Quita y devuelve el último
`array_shift($n)`	Quita y devuelve el primero
`array_unshift($n, 0)`	Añade al principio
`in_array(3, $n, true)`	`true` (con `true` compara estricto)
`array_search(8, $n)`	`2` (posición, o `false`)
`array_slice($n, 1, 2)`	`[3, 8]`
`[...$n, 1]`	Copia y amplía con spread
`[$a, $b] = [1, 2];`	Desestructura
`$ed = ["Ana" => 34];`	Array asociativo
`$ed["Luis"] = 22;`	Añade o cambia
`$ed["Zoe"] ?? 0`	`0` (valor por defecto)
`array_key_exists("Ana", $ed)`	`true`
`array_keys($ed)` / `array_values($ed)`	Claves / valores
`unset($ed["Ana"]);`	Borra una clave
`$m[1][0]`	Elemento de un array anidado

Más en: Arrays

Funciones de arrays

Código	Resultado
`array_map(fn($n) => $n * 2, [1, 2, 3])`	`[2, 4, 6]`
`array_filter([1, 2, 3, 4], fn($n) => $n % 2 === 0)`	`[1 => 2, 3 => 4]` (conserva claves)
`array_values(array_filter(...))`	Reindexa: `[2, 4]`
`array_reduce([1, 2, 3], fn($a, $n) => $a + $n, 0)`	`6`
`array_sum([1, 2, 3])`	`6`
`max([4, 9, 2])` / `min([4, 9, 2])`	`9` / `2`
`array_unique([1, 2, 2, 3])`	`[0 => 1, 1 => 2, 3 => 3]`
`array_merge([1], [2, 3])`	`[1, 2, 3]`
`array_column($filas, "nombre")`	Lista con esa columna de cada fila
`array_combine(["a", "b"], [1, 2])`	`["a" => 1, "b" => 2]`
`array_reverse([1, 2, 3])`	`[3, 2, 1]`
`range(1, 5)`	`[1, 2, 3, 4, 5]`
`array_find($n, fn($x) => $x > 4)`	Primer elemento que cumple (PHP 8.4)
`array_any($n, fn($x) => $x > 4)`	`true` si alguno cumple (PHP 8.4)
`array_all($n, fn($x) => $x > 0)`	`true` si todos cumplen (PHP 8.4)
`sort($n)` / `rsort($n)`	Ordena el propio array (menor a mayor / al revés)
`asort($ed)` / `ksort($ed)`	Ordena por valor / por clave, conservando pares
`usort($n, fn($a, $b) => $a <=> $b)`	Ordena con tu propio criterio

Más en: Funciones de arrays

Condicionales y match

if ($nota >= 9) {
    echo "Sobresaliente";
} elseif ($nota >= 5) {
    echo "Aprobado";
} else {
    echo "Suspenso";
}

$texto = match (true) {
    $nota >= 9 => "Sobresaliente",
    $nota >= 5 => "Aprobado",
    default    => "Suspenso",
};

Código	Qué hace
`match ($dia) { 1, 7 => "finde", default => "semana" }`	Devuelve un valor; compara con `===`
`match` sin `default`	Lanza `UnhandledMatchError` si nada coincide
`switch ($x) { case 1: ...; break; }`	Forma clásica (necesita `break`)
`$x ?: "vacío"`	Operador Elvis: usa el valor si es truthy

Más en: Condicionales

Bucles

Código	Qué hace
`for ($i = 0; $i < 5; $i++) { ... }`	Repite con contador (0 a 4)
`while ($i < 5) { ... }`	Repite mientras se cumpla
`do { ... } while ($i < 5);`	Se ejecuta al menos una vez
`foreach ($lista as $x) { ... }`	Recorre los valores
`foreach ($ed as $nombre => $edad) { ... }`	Recorre claves y valores
`foreach ($lista as &$x)`	Modifica cada elemento (acaba con `unset($x);`)
`break`	Sale del bucle
`continue`	Salta a la siguiente vuelta
`foreach ($filas as ["id" => $id])`	Desestructura en el bucle

$notas = [4, 8, 6];
$suma = 0;
foreach ($notas as $nota) {
    $suma += $nota;
}
echo $suma / count($notas); // 6

Más en: Bucles

Funciones con tipos

function precioFinal(float $precio, float $iva = 0.21): float
{
    return round($precio * (1 + $iva), 2);
}

echo precioFinal(100);              // 121
echo precioFinal(100, iva: 0.10);   // 110

Código	Qué hace
`function f(int $a): int`	Tipo de parámetro y de retorno
`function f(): void`	No devuelve nada
`function f(?string $x)`	Acepta `string` o `null`
`function f(int\|string $x)`	Acepta uno de varios tipos
`function f(): never`	Nunca termina (lanza o hace `exit`)
`function f(int ...$nums)`	Recibe cualquier número de argumentos
`f(...$lista)`	Desempaqueta un array al llamar
`f(iva: 0.1)`	Argumento con nombre
`fn($x) => $x * 2`	Función flecha (hereda variables de fuera)
`function ($x) use ($y) { ... }`	Función anónima con variable de fuera
`static $contador = 0;`	Variable que conserva su valor entre llamadas
`declare(strict_types=1);`	Primera línea: no convierte tipos solo

Consejo: pon siempre tipos y strict_types. Los errores aparecen antes y con mensajes claros.

Más en: Funciones

include y require

Código	Qué hace
`require "config.php";`	Incluye el archivo; si falta, error fatal
`require_once "config.php";`	Igual, pero solo una vez
`include "cabecera.php";`	Incluye el archivo; si falta, solo un aviso
`include_once "pie.php";`	Igual, pero solo una vez
`require __DIR__ . "/lib/util.php";`	Ruta segura desde la carpeta actual
`$datos = require "config.php";`	Recoge el `return` del archivo
`require "vendor/autoload.php";`	Carga las clases de Composer

// config.php
return ['host' => 'localhost', 'bd' => 'tienda'];

// index.php
$config = require __DIR__ . '/config.php';
echo $config['bd']; // tienda

Más en: include y require · Composer

Formularios y validación

<?php
$errores = [];
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    $email = trim($_POST['email'] ?? '');
    if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
        $errores[] = 'Correo no válido';
    }
}
?>
<form method="post">
    <input name="email" value="<?= htmlspecialchars($email ?? '') ?>">
    <button>Enviar</button>
</form>

Código	Qué hace
`$_POST['campo'] ?? ''`	Dato enviado por POST (siempre texto)
`$_GET['q'] ?? ''`	Dato de la URL: `?q=php`
`$_SERVER['REQUEST_METHOD']`	`"GET"` o `"POST"`
`$_FILES['foto']`	Datos de un archivo subido
`htmlspecialchars($texto)`	Convierte `<` y `>` en entidades: evita XSS al mostrar
`trim($_POST['nombre'] ?? '')`	Quita espacios sobrantes
`filter_var($e, FILTER_VALIDATE_EMAIL)`	Devuelve el correo o `false`
`filter_var($n, FILTER_VALIDATE_INT)`	Devuelve el entero o `false`
`filter_input(INPUT_POST, "edad", FILTER_VALIDATE_INT)`	Lee y valida a la vez
`header("Location: gracias.php"); exit;`	Redirige tras guardar

Cuidado: valida siempre en el servidor. Lo que se comprueba en el navegador se puede saltar.

Más en: Formularios · Validar formularios · Seguridad

Sesiones y cookies

Código	Qué hace
`session_start();`	Inicia o recupera la sesión (antes de cualquier salida)
`$_SESSION['usuario'] = "Ana";`	Guarda un dato en la sesión
`$_SESSION['usuario'] ?? null`	Lee un dato, o `null` si no existe
`unset($_SESSION['usuario']);`	Borra un dato
`session_regenerate_id(true);`	Cambia el id al iniciar sesión (evita fijación)
`session_destroy();`	Destruye la sesión (cerrar sesión)
`setcookie("tema", "oscuro", time() + 3600);`	Crea una cookie de una hora
`$_COOKIE['tema'] ?? 'claro'`	Lee una cookie
`setcookie("tema", "", time() - 3600);`	Borra una cookie

setcookie('recordar', '1', [
    'expires'  => time() + 86400,
    'path'     => '/',
    'secure'   => true,
    'httponly' => true,
    'samesite' => 'Lax',
]);

Más en: Sesiones y cookies

Clases y excepciones

class Cuenta
{
    public function __construct(
        public readonly string $titular,
        private float $saldo = 0,
    ) {}

    public function ingresar(float $cantidad): void
    {
        if ($cantidad <= 0) {
            throw new InvalidArgumentException("Cantidad no válida");
        }
        $this->saldo += $cantidad;
    }

    public function saldo(): float
    {
        return $this->saldo;
    }
}

try {
    $c = new Cuenta("Ana", 100);
    $c->ingresar(-5);
} catch (InvalidArgumentException $e) {
    echo $e->getMessage(); // Cantidad no válida
} finally {
    echo " (fin)";
}

Código	Qué hace
`new Cuenta("Ana")`	Crea un objeto
`$c->ingresar(50)`	Llama a un método
`public` / `protected` / `private`	Visibilidad
`public readonly string $id`	Se asigna una vez y no cambia
`public private(set) float $saldo`	Se lee desde fuera, se escribe solo dentro (PHP 8.4)
`public string $nombre { get => ucfirst($this->n); }`	Propiedad con hook (PHP 8.4)
`static function crear()` / `self::crear()`	Método de clase
`const MAX = 10;` → `Cuenta::MAX`	Constante de clase
`class Ahorro extends Cuenta`	Herencia
`parent::__construct($t)`	Llama al constructor del padre
`interface Pagable { ... }` / `implements`	Contrato que la clase debe cumplir
`enum Estado: string { case Activo = "a"; }`	Enumeración
`$x instanceof Cuenta`	`true` si es de esa clase
`throw new Exception("Fallo");`	Lanza una excepción
`catch (TypeError \| ValueError $e)`	Captura varias
`$e->getMessage()` / `getCode()`	Texto y código del error
`class SaldoError extends Exception {}`	Excepción propia

Más en: Clases · Herencia e interfaces · Excepciones

PDO, contraseñas y JSON

$pdo = new PDO(
    'mysql:host=localhost;dbname=tienda;charset=utf8mb4',
    'usuario',
    'clave',
    [PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
     PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC]
);

$stmt = $pdo->prepare('SELECT * FROM productos WHERE precio < :max');
$stmt->execute(['max' => 20]);
$productos = $stmt->fetchAll();

Código	Qué hace
`$pdo->prepare("... WHERE id = ?")`	Consulta preparada (evita inyección SQL)
`$stmt->execute([$id])`	Ejecuta con los valores
`$stmt->fetch()`	Una fila (o `false`)
`$stmt->fetchAll()`	Todas las filas
`$stmt->rowCount()`	Filas afectadas
`$pdo->lastInsertId()`	Id del último `INSERT`
`$pdo->beginTransaction()` / `commit()` / `rollBack()`	Transacción
`password_hash($clave, PASSWORD_DEFAULT)`	Genera el hash para guardar
`password_verify($clave, $hash)`	`true` si coincide
`json_encode($datos, JSON_UNESCAPED_UNICODE)`	Array a texto JSON
`json_decode($texto, true)`	Texto JSON a array
`json_decode($t, true, 512, JSON_THROW_ON_ERROR)`	Lanza excepción si el JSON es inválido
`header('Content-Type: application/json');`	Responde JSON desde un script
`file_get_contents("php://input")`	Cuerpo crudo de la petición

Cuidado: nunca pegues variables dentro del SQL ("... WHERE id = $id"). Usa siempre consultas preparadas.

Más en: PDO · CRUD · Seguridad · JSON y APIs

PHP · devschool.es/chuletas/php/