Lección 1 · Autoevaluación

En el servidor. El navegador pide una dirección, el servidor ejecuta el código y devuelve el resultado —casi siempre HTML—. El usuario recibe solo el resultado, nunca el programa.

La prueba está al alcance: «ver código fuente» en el navegador no muestra ninguna línea de PHP.

Que el archivo no se está ejecutando. No es un error de sintaxis. Las causas habituales son tres: se abrió como archivo local —la dirección empieza con file:///—, el archivo está fuera de la carpeta del sitio, o el servidor está apagado.

Se arregla pidiéndolo por http://localhost/… con Apache y PHP encendidos.

Las dos formas ejecutan el mismo código, pero cambia el entorno:

• En la terminal el resultado sale por la consola, no hay navegador ni HTML, y no existen las superglobales propias de la web.
• Desde el navegador el resultado es una respuesta HTTP: hay cabeceras, hay petición, y el navegador interpreta el HTML que recibe.

Cualquier carácter después de ?> —un espacio, una línea en blanco, el salto de línea final del editor— se envía al navegador como salida. Si ese archivo se incluye en otro que después quiere mandar una cabecera, el error es «headers already sent», y encontrar el espacio culpable puede llevar horas.

Sin etiqueta de cierre, el problema no existe.

echo 'Producto: $nombre';   // Producto: $nombre
echo "Producto: $nombre";   // Producto: Yerba mate 1 kg

Los escapes como \n también funcionan solo en las dobles.

Para delimitar el nombre de la variable. Sin las llaves, PHP busca una variable llamada $codigoA, que no existe.

Hacen falta siempre que después del nombre venga un carácter que pueda confundirse con parte de él: una letra, un número o un guion bajo.

Verdadero. El texto «0» está en la lista de valores vacíos, junto con 0, "", [], null y false.

Es un problema cuando el cero es un valor válido —un producto de obsequio con precio 0—: la validación lo rechaza como si el campo estuviera en blanco. En ese caso se compara con === ''.

isset es falso cuando el valor es null; array_key_exists es verdadero porque lo que pregunta es si la clave está.

En el catálogo la diferencia es real: con isset parecería que el dato no existe, cuando en realidad el producto está incompleto.

var_dump(0.1 + 0.2);        // float(0.30000000000000004)
var_dump(0.1 + 0.2 == 0.3); // bool(false)

Se compara con una tolerancia: abs($a - $b) < 0.00001. Con dinero, además, no se redondea en el medio del cálculo: se redondea al final.

Desactiva las conversiones automáticas. Va como primera instrucción del archivo, antes de cualquier otra cosa, y afecta a las llamadas que se hacen desde ese archivo.

Con eso, un precio que llega como texto en lugar de número avisa ahí mismo y no tres pantallas después.

Se usa === siempre, salvo motivo concreto. La conversión automática de == produce resultados que sorprenden: 10 == "10" es verdadero, y en un control de acceso esa diferencia es la que deja pasar a quien no corresponde.

Imprime 3050. La concatenación tiene menos precedencia que la suma, así que primero se resuelve $a + $b y después se concatena con el texto. Como el texto no es numérico, el resultado termina siendo el número.

Para el total con texto hay que usar paréntesis: 'Total: ' . ($a + $b).

$a = true and false;   // $a vale true: primero se asigna
$b = true && false;    // $b vale false

Por eso se usan siempre && y ||.

+ suma y . concatena. Es el error típico al armar un código a partir de partes: se quiere unir y se termina sumando, o al revés.

Devuelve -1, 0 o 1: negativo si el izquierdo es menor, cero si son iguales, positivo si es mayor.

Es exactamente lo que espera usort(). Para textos conviene strcmp(), porque el operador depende de la configuración regional.

La primera cuya condición sea verdadera, y después se sale. Las demás no se evalúan aunque también lo sean.

Por eso el orden importa: si se pregunta primero $stock > 0, nunca se llega a la rama de $stock > 10.

match compara con ===, devuelve un valor y, si ningún caso coincide y no hay default, lanza un error en lugar de seguir de largo.

Consecuencia práctica: si el dato llega como texto —de un formulario, siempre— hay que convertirlo antes, porque 2 y "2" no son iguales con ===.

• for: cantidad conocida (tres cuotas, diez productos).
• while: depende de una condición que cambia adentro.
• foreach: recorrer un array completo. Es el más usado.

do…while se usa cuando el bloque tiene que ejecutarse al menos una vez.

La variable del foreach queda apuntando al último elemento. Si después se recorre el mismo array con otro foreach normal, la última vuelta pisa ese elemento con el valor anterior.

Se evita liberando la variable con unset($valor) al terminar.

Arrays que PHP crea y que están disponibles en cualquier parte, sin declararlos ni pasarlos como parámetro.

Las de todos los días: $_GET, $_POST, $_SESSION, $_FILES y $_SERVER.

Para que el navegador muestre el texto en lugar de interpretarlo. Si no se escapa, un enlace armado con HTML o JavaScript se ejecuta en el navegador de quien lo abre: es el ataque XSS.

Y se escapa al mostrar, no al guardar: escapar al guardar ensucia la base con entidades y rompe cualquier otro uso del dato.

Si alguien pide /productos.php/<script>…, eso aparece en PHP_SELF. Usarlo sin escapar en el action es un XSS servido en bandeja.

SCRIPT_NAME devuelve solo la ruta del archivo.

require para lo que el programa necesita —configuración, conexión, una clase—; include para lo opcional.

El sufijo _once evita incluir dos veces, y se usa siempre que el archivo defina funciones o clases: declararlas dos veces es error fatal.

__DIR__ es la carpeta del archivo actual, así que la inclusión funciona sin importar desde dónde se ejecute el programa.

Con una ruta relativa como 'encabezado.php', el resultado depende del directorio de trabajo y cambia según cómo se llame al script.

<?php

declare(strict_types=1);

const IVA = 0.21;

$tienda = 'Tienda La Esquina';
$nombre = 'Yerba mate 1 kg';
$precio = 1850.50;

$final = round($precio * (1 + IVA), 2);

echo $tienda . " - " . date('d/m/Y') . "\n";
echo $nombre . ": $" . number_format($final, 2, ',', '.');

Lo que se evalúa: constante en mayúsculas, variables con nombres claros, number_format para el precio y round al final.

• $a / $b → 3.5: la división no redondea.
• $a % $b → 1: el resto.
• $a . $b → 72: concatena.
• 'R: ' . $a + $b → 9: la suma se resuelve antes que la concatenación.

<?php

declare(strict_types=1);

$codigo = $_GET['codigo'] ?? '';

if ($codigo === '' || !ctype_digit($codigo)) {
    echo 'Código inválido';
} else {
    echo 'Producto ' . htmlspecialchars($codigo, ENT_QUOTES, 'UTF-8');
}

Dos detalles: ?? evita el aviso de clave inexistente, y ctype_digit rechaza "1042 OR 1=1", que es texto válido para PHP.

<?php
$etapas = [1, 2, 3];
?>
<table class="table">
    <tbody>
        <?php foreach ($etapas as $etapa): ?>
            <tr>
                <td>Etapa <?= $etapa ?></td>
                <td><?= match ($etapa) {
                    1 => 'Cerrada',
                    2 => 'Abierta',
                    3 => 'Pendiente',
                    default => '—',
                } ?></td>
            </tr>
        <?php endforeach; ?>
    </tbody>
</table>

match devuelve un valor, así que se puede usar directamente dentro de la etiqueta de salida.

for ($i = 1; $i <= 20; $i++) {
    if ($i % 3 === 0) {
        continue;
    }

    if ($i > 17) {
        break;
    }

    echo $i . "\n";
}

El orden de las dos comprobaciones importa: continue salta la vuelta, break corta el bucle entero.

$carrito = [
    'Yerba mate' => 1850.50,
    'Azúcar'    => 1200,
    'Fideos'    => null,
    'Arroz'     => 1350,
];

$total = 0.0;

foreach ($carrito as $producto => $precio) {
    if ($precio === null) {
        continue;
    }

    $total += $precio;
}

echo 'Total: ' . number_format($total, 2, ',', '.');

El null se compara con ===: con == se confundiría con 0, y un producto sin precio no es un producto gratis.

<?php

declare(strict_types=1);

$precio = $_POST['precio'] ?? '';

if ($precio === '' || !is_numeric($precio)) {
    echo 'Precio inválido';
} elseif ((float) $precio === 0.0) {
    echo 'Gratis';
}

• Faltaba el punto y coma.
• $_POST[precio] va con comillas: sin ellas precio se interpreta como constante y falla.
• = asigna, no compara: hay que usar ===.
• Falta comprobar que el dato llegó y que es numérico antes de usarlo.

<?php
// encabezado.php
?>
<!DOCTYPE html>
<html lang="es">
<head>
    <meta charset="utf-8">
    <title><?= htmlspecialchars($titulo, ENT_QUOTES, 'UTF-8') ?></title>
</head>
<body>

<?php
// catalogo.php
$titulo = 'Catálogo';
$productos = ['Yerba mate', 'Azúcar', 'Fideos'];

require __DIR__ . '/encabezado.php';
?>
    <ul>
        <?php foreach ($productos as $producto): ?>
            <li><?= htmlspecialchars($producto, ENT_QUOTES, 'UTF-8') ?></li>
        <?php endforeach; ?>
    </ul>
</body>
</html>

<?php

declare(strict_types=1);

$nombre = trim($_POST['nombre'] ?? '');

if ($nombre === '') {
    echo 'Falta el nombre del producto';
} else {
    $nombre = mb_convert_case($nombre, MB_CASE_TITLE, 'UTF-8');

    echo 'Producto: ' . htmlspecialchars($nombre, ENT_QUOTES, 'UTF-8');
}

Se normaliza con mb_* porque ucfirst trabaja con bytes y rompe los acentos. Y se escapa después de formatear, no antes.

• include: PHP emite un warning y el programa sigue. En una página con datos sensibles, sigue mostrando la mitad de la información.
• require: emite un error fatal y detiene la ejecución. Es lo que corresponde cuando sin ese archivo el programa no tiene sentido.
• require_once: igual, pero si el archivo ya se incluyó no lo vuelve a incluir. Necesario cuando define funciones o clases.