Lección 4 · Autoevaluación

Una ruta relativa como 'datos/catalogo.csv' se resuelve contra el directorio de trabajo del proceso, que cambia según cómo se llame al script.

Con __DIR__ la ruta es absoluta en ejecución y relativa al archivo al escribirla, así que el proyecto se puede mover sin tocar nada.

PHP corre como el usuario del servidor web —www-data en Debian y Ubuntu—, y para escribir necesita permiso sobre el archivo y sobre la carpeta.

Se corrige dándole la carpeta a ese usuario. Lo que no se hace nunca es chmod 777: deja el archivo escribible por cualquiera.

false, y además un warning. Por eso la comprobación correcta es === false: un archivo vacío y un archivo que no se pudo abrir son cosas distintas.

Sin FILE_IGNORE_NEW_LINES, cada elemento del array termina en \n, y eso arruina las comparaciones con ===: "1042\n" !== "1042".

La segunda descarta las líneas vacías, que en un archivo generado a mano suelen sobrar.

Con fgets() se lee línea por línea y el archivo grande nunca se carga entero en memoria. file_get_contents() devuelve todo de una vez, y sirve para archivos chicos: una plantilla, un JSON de configuración.

Bloquea el archivo durante la escritura. Sin eso, dos peticiones simultáneas pueden escribir al mismo tiempo y dejar una línea mezclada con otra.

Se usa junto con FILE_APPEND en cualquier archivo de registro.

FILE_APPEND. Sin esa bandera, file_put_contents() reemplaza todo el contenido del archivo.

PHP_EOL es solo el salto de línea del sistema; LOCK_EX es el bloqueo.

Que count($campos) sea el esperado. Si la línea tiene menos campos, la desestructuración avisa; si tiene más, el sobrante se pierde sin que nadie lo note.

En una importación de 200 líneas, ese chequeo es la diferencia entre detectar el problema y publicar datos incompletos.

Saltarla con continue y anotarla. Una línea mala no tiene que invalidar las otras 199.

Y el informe tiene que decir en qué línea fue: es lo único que le permite a quien tiene el archivo encontrarla.

Las líneas de Windows terminan en \r\n, así que el último campo de cada fila queda con un \r. Se ve como un espacio invisible y rompe las comparaciones.

array_map('trim', $campos) resuelve el problema de una vez.

Sin enctype="multipart/form-data" el archivo no viaja: en el servidor llega solo el nombre como texto.

Es el primer error de todo el que empieza con subidas, y el formulario se ve perfecto igual.

size lo mide el servidor, así que ese dato sirve. name y type los manda el cliente y se pueden falsear: alguien puede subir un .php diciendo que es image/jpeg.

El tipo real se comprueba leyendo el contenido con getimagesize() o finfo_file().

Confirma que la ruta es de un archivo subido en esta petición y no cualquier archivo del servidor. Sin esa comprobación, alguien podría hacer que el programa copie /etc/passwd.

Se usa junto con move_uploaded_file(), que hace una verificación parecida por dentro.

El nombre original lo escribió el cliente: puede tener ../ para salir de la carpeta, caracteres raros o una extensión ejecutable.

Generar el nombre en el servidor —por ejemplo, el código del producto más la extensión deducida del contenido— elimina el problema.

Un SVG es un documento con etiquetas y puede incluir <script>. Al abrirlo, el navegador lo ejecuta en el contexto del sitio.

Para fotos de producto alcanza con JPEG y PNG.

No se muestran, pero se registran todos. Un mensaje en pantalla revela rutas, nombres de tablas y hasta fragmentos de claves.

Lo que cambia es dónde va el mensaje, no si se guarda.

No. Los warning no son excepciones: se imprimen, el programa sigue y el valor de retorno es false.

Por eso hay que comprobar lo que devuelve la función. Desde PHP 8 los errores graves sí se lanzan como Error, que sí se puede atrapar.

Se ejecuta siempre: tanto si el try terminó bien como si saltó a un catch. Sirve para cerrar un archivo o liberar un recurso.

Se evalúan en orden y se ejecuta el primero que coincide. Como toda excepción hereda de Exception, un catch (Exception $e) puesto primero atrapa todo y los demás nunca se ejecutan.

Lo específico primero, Throwable al final.

Lanza la excepción: la ejecución normal se corta en ese punto y salta al catch que corresponda, o termina con un error fatal si nadie la atrapa.

No confundir con return false: eso no avisa nada, y quien llama tiene que acordarse de comprobarlo.

El error desaparece: no se registra, no se muestra y el programa continúa con datos que no son válidos. El síntoma aparece mucho después y lejos de la causa.

Lo correcto es registrar el detalle y decidir qué se le muestra al usuario.

El mensaje de una excepción está escrito para quien programa, no para el usuario: suele traer rutas absolutas, nombres de tablas y hasta fragmentos de consultas.

Va al registro; a la pantalla va un texto que se entienda, como «No se pudo cargar el catálogo, probá más tarde».

Un registro se copia, se manda por correo para revisar y queda en el servidor durante meses: cualquier cosa que se escriba ahí deja de estar protegida.

La fecha, la línea y el archivo, en cambio, son justamente lo que sirve para diagnosticar.

false, y emite un aviso. Si escribe bien, devuelve la cantidad de bytes escritos.

Comprobar ese valor es lo que separa un sistema que avisa «no se pudo guardar» de uno que pierde el dato en silencio.

function contarLineas(string $ruta): ?int
{
    if (!is_readable($ruta)) {
        return null;
    }

    $lineas = file($ruta, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);

    return $lineas === false ? null : count($lineas);
}

is_readable() evita el warning. Y el retorno de file() se comprueba igual, porque entre una cosa y la otra el archivo puede desaparecer.

function registrar(string $mensaje): void
{
    $linea = date('Y-m-d H:i:s') . ' ' . $mensaje . PHP_EOL;

    file_put_contents(
        __DIR__ . '/../datos/registro.log',
        $linea,
        FILE_APPEND | LOCK_EX
    );
}

FILE_APPEND para no borrar lo anterior y LOCK_EX para que dos escrituras simultáneas no se mezclen.

function importar(string $ruta): array
{
    $manejador = fopen($ruta, 'r');

    if ($manejador === false) {
        throw new RuntimeException('No se pudo abrir el archivo.');
    }

    $productos = [];
    $rechazados = [];
    $numero = 0;

    while (($campos = fgetcsv($manejador, 0, ';')) !== false) {
        $numero++;

        if ($numero === 1) {
            continue;
        }

        if (count($campos) !== 3) {
            $rechazados[] = "Línea $numero: se esperaban 3 campos.";
            continue;
        }

        [$codigo, $nombre, $precio] = array_map('trim', $campos);

        if (!is_numeric($precio) || (float) $precio < 0) {
            $rechazados[] = "Línea $numero: precio inválido ($precio).";
            continue;
        }

        $productos[] = [
            'codigo' => (int) $codigo,
            'nombre' => $nombre,
            'precio' => (float) $precio,
        ];
    }

    fclose($manejador);

    return [$productos, $rechazados];
}

const MAX_BYTES = 1024 * 1024;

$archivo = $_FILES['foto'] ?? null;
$codigo  = (int) ($_POST['codigo'] ?? 0);

if ($archivo === null || $archivo['error'] === UPLOAD_ERR_NO_FILE) {
    exit('Elegí una foto.');
}

if ($archivo['error'] !== UPLOAD_ERR_OK) {
    exit('La subida falló.');
}

if (!is_uploaded_file($archivo['tmp_name']) || $archivo['size'] > MAX_BYTES) {
    exit('La imagen no es válida o pasa de 1 MB.');
}

$info = getimagesize($archivo['tmp_name']);

if ($info === false || !in_array($info[2], [IMAGETYPE_JPEG, IMAGETYPE_PNG], true)) {
    exit('La imagen tiene que ser JPEG o PNG.');
}

$extension = $info[2] === IMAGETYPE_PNG ? 'png' : 'jpg';
$destino = __DIR__ . '/../public/img/productos/' . $codigo . '.' . $extension;

if (!move_uploaded_file($archivo['tmp_name'], $destino)) {
    exit('No se pudo guardar la imagen.');
}

Las tres comprobaciones que no se saltean: is_uploaded_file, getimagesize sobre el contenido y el nombre generado en el servidor.

class ProductoInvalidoException extends RuntimeException
{
    public function __construct(
        string $mensaje,
        private int $codigoProducto,
    ) {
        parent::__construct($mensaje);
    }

    public function codigoProducto(): int
    {
        return $this->codigoProducto;
    }
}

function validarPrecio(int $codigo, float $precio): void
{
    if ($precio < 0) {
        throw new ProductoInvalidoException('Precio negativo.', $codigo);
    }
}

La propiedad se declara en el constructor y se expone con un método: así quien atrapa la excepción tiene el dato que necesita para informar.

try {
    importarCatalogo(__DIR__ . '/../datos/catalogo.csv');
} catch (RuntimeException $e) {
    registrar('Catálogo: ' . $e->getMessage());
    exit('No se pudo leer el archivo del catálogo.');
} catch (Throwable $e) {
    registrar('Catálogo, error inesperado: ' . $e->getMessage());
    exit('Ocurrió un error inesperado. Probá más tarde.');
}

El específico primero, el general al final. Y en los dos casos el mensaje de pantalla es distinto del que se registra.

$manejador = fopen($ruta, 'w');

if ($manejador === false) {
    exit('No se pudo crear el archivo.');
}

fputcsv($manejador, ['codigo', 'nombre', 'precio'], ';');

foreach ($catalogo as $producto) {
    fputcsv($manejador, [
        $producto['codigo'],
        $producto['nombre'],
        $producto['precio'],
    ], ';');
}

fclose($manejador);

Modo 'w' crea o reemplaza; 'a' agregaría al final. fputcsv pone las comillas donde hacen falta, si un nombre tiene el separador adentro.

$texto = file_get_contents(__DIR__ . '/config.json');

if ($texto === false) {
    exit('No se encontró la configuración.');
}

$config = json_decode($texto, true);

if (json_last_error() !== JSON_ERROR_NONE) {
    exit('La configuración tiene un error de formato: ' . json_last_error_msg());
}

echo 'IVA: ' . (float) $config['iva'];

No se comprueba si el resultado es null, porque null también es un JSON válido. Se comprueba json_last_error().

$manejador = fopen($ruta, 'r');

if ($manejador === false) {
    exit('No se pudo abrir el archivo.');
}

try {
    while (($linea = fgets($manejador)) !== false) {
        procesar(trim($linea));
    }
} finally {
    fclose($manejador);
}

finally se ejecuta siempre: si procesar() lanza una excepción, el archivo se cierra igual y la excepción sigue su camino hacia arriba.

• La ruta es relativa: depende del directorio de trabajo. Se arma con __DIR__.
• No se comprueba si file() pudo leer: hay que comparar con false.
• explode no respeta comillas ni comprueba la cantidad de campos: mejor fgetcsv con count().
• $precio llega como texto con salto de línea, así que $precio < 0 compara un texto: hay que trim() y validar con is_numeric antes de convertir.

Y el total incluye el encabezado y las líneas vacías, así que count($lineas) tampoco es el número de productos.