# Compresión Automática de Imágenes antiguas en WordPress con PHP

- Link: https://binariocero.com/php/compresion-automatica-de-imagenes-antiguas-en-wordpress-con-php
- Published: 2025-07-06T09:58:30+02:00
- Author: Juan José Fernández Durán

![Loading](https://binariocero.com/wp-content/plugins/page-views-count/ajax-loader-
2x.gif)

En sitios WordPress con alto volumen de contenido multimedia, las imágenes suelen
representar un gran porcentaje del peso total del sitio web. Para mejorar el rendimiento,
reducir el consumo de ancho de banda y mejorar los tiempos de carga, la compresión
de imágenes se convierte en una tarea esencial.

En este artículo te presentamos un **script PHP independiente** que puede ser ejecutado
tanto desde navegador como desde la línea de comandos, permitiendo comprimir automáticamente
todas las imágenes en el directorio `wp-content/uploads`.

    ```wp-block-code
    <?php
    // comprimir-imagenes.php
    // Ejecutar desde navegador o CLI: php comprimir-imagenes.php > salida.txt

    set_time_limit(0);
    $uploads_dir = __DIR__ . '/wp-content/uploads'; // Ajusta si estás fuera de WordPress
    $calidad = 80; // Valor entre 0 y 100
    $delete_original = false; // Cambia a true para eliminar originales (no recomendado en este script)

    echo "<pre>";
    echo "Iniciando compresión en: $uploads_dir\n\n";

    function comprimir_imagen($file_path, $calidad, $delete_original = false) {
        $ext = strtolower(pathinfo($file_path, PATHINFO_EXTENSION));
        if (!in_array($ext, ['jpg', 'jpeg', 'png', 'webp'])) return;

        $original_size = filesize($file_path);
        $img = false;

        switch ($ext) {
            case 'jpg':
            case 'jpeg':
                $img = @imagecreatefromjpeg($file_path);
                break;
            case 'png':
                $img = @imagecreatefrompng($file_path);
                imagepalettetotruecolor($img);
                imagealphablending($img, true);
                imagesavealpha($img, true);
                break;
            case 'webp':
                $img = @imagecreatefromwebp($file_path);
                break;
        }

        if (!$img) {
            echo "Error cargando: $file_path\n";
            return;
        }

        $tmp_file = $file_path . '.tmp';

        switch ($ext) {
            case 'jpg':
            case 'jpeg':
                imagejpeg($img, $tmp_file, $calidad);
                break;
            case 'png':
                $png_compression = 9 - round($calidad / 11.111); // convierte 0-100 → 0-9
                imagepng($img, $tmp_file, $png_compression);
                break;
            case 'webp':
                imagewebp($img, $tmp_file, $calidad);
                break;
        }

        imagedestroy($img);

        if (!file_exists($tmp_file)) {
            echo "Error al escribir: $file_path\n";
            return;
        }

        $compressed_size = filesize($tmp_file);
        $ahorro = round((1 - $compressed_size / $original_size) * 100, 2);

        if ($delete_original) unlink($file_path);
        rename($tmp_file, $file_path);

        echo "Comprimido: " . basename($file_path) . "\n";
        echo " - Original: " . round($original_size / 1024, 2) . " KB\n";
        echo " - Comprimido: " . round($compressed_size / 1024, 2) . " KB\n";
        echo " - Ahorro: $ahorro %\n\n";
    }

    function recorrer_y_comprimir($dir, $calidad, $delete_original = false) {
        $rii = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($dir));
        foreach ($rii as $file) {
            if ($file->isDir()) continue;
            $path = $file->getPathname();
            if (preg_match('/\.(jpe?g|png|webp)$/i', $path)) {
                comprimir_imagen($path, $calidad, $delete_original);
            }
        }
    }

    recorrer_y_comprimir($uploads_dir, $calidad, $delete_original);
    echo "Proceso completado.\n";
    echo "</pre>";
    ```

## ¿Qué hace este script?

Este script realiza las siguientes funciones:

 * Recorre recursivamente todos los subdirectorios dentro de `wp-content/uploads`.
 * Detecta imágenes con extensión `.jpg`, `.jpeg`, `.png` o `.webp`.
 * Comprime las imágenes aplicando un nivel de calidad configurable.
 * Muestra estadísticas detalladas de ahorro de espacio por cada archivo procesado.
 * Permite la opción de **reemplazar el archivo original** o conservarlo.

## Requisitos

 * PHP 7.0 o superior.
 * Extensiones de PHP habilitadas: `gd` (para manipulación de imágenes).
 * Permisos de escritura en el directorio `uploads`.

## Instalación y Uso

### 1. Coloca el archivo en la raíz de tu instalación WordPress

Guarda el siguiente archivo como `comprimir-imagenes.php` en el mismo directorio
donde se encuentra tu `wp-config.php`:

    ```wp-block-preformatted
    // contenido del script (ver más abajo)
    ```

### 2. Configura los parámetros

Dentro del script, puedes ajustar los siguientes valores:

    ```wp-block-preformatted
    $calidad = 80; // Calidad de compresión (0 a 100)$delete_original = false; // true para eliminar los originales tras comprimir
    ```

> **Nota**: Se recomienda mantener `$delete_original = false` para evitar pérdidas
> accidentales.

### 3. Ejecuta el script

#### Desde el navegador:

    ```wp-block-preformatted
    https://tusitio.com/comprimir-imagenes.php
    ```

#### Desde la línea de comandos:

    ```wp-block-preformatted
    php comprimir-imagenes.php > salida.txt
    ```

## Ejemplo de salida

    ```wp-block-preformatted
    Iniciando compresión en: /var/www/html/wp-content/uploadsComprimido: foto1.jpg - Original: 254.18 KB - Comprimido: 145.33 KB - Ahorro: 42.83 %Comprimido: captura.png - Original: 310.94 KB - Comprimido: 210.66 KB - Ahorro: 32.26 %Proceso completado.
    ```

## ¿Cómo funciona?

El script utiliza la biblioteca GD de PHP para:

 * Cargar imágenes en memoria (`imagecreatefromjpeg`, `imagecreatefrompng`, etc.).
 * Ajustar la calidad al guardarlas (`imagejpeg`, `imagepng`, `imagewebp`).
 * Comparar el tamaño antes y después.
 * Reemplazar el archivo original si se ha generado correctamente una versión comprimida.

Además, aplica una lógica de compresión para PNG basada en la conversión del rango
0–100 a 0–9 para el nivel de compresión nativo de este formato.

## Seguridad y recomendaciones

 * Asegúrate de proteger este script si lo alojas en un entorno público (por ejemplo,
   bloqueándolo mediante `.htaccess` o eliminándolo tras su uso).
 * Haz una copia de seguridad del directorio `uploads` antes de comprimir en modo
   destructivo.
 * Ideal para tareas puntuales o como parte de un proceso de mantenimiento por cron.

## ¿Por qué usar esto en lugar de un plugin?

 * Evita sobrecargar el WordPress con plugins adicionales.
 * No necesita configuración en el panel de administración.
 * Es rápido, directo y altamente personalizable.
 * Ideal para entornos donde se requiere optimización masiva tras una migración 
   o importación.

## Extensiones futuras posibles

 * Conversión automática a WebP.
 * Exclusión de directorios concretos.
 * Log detallado a fichero externo.
 * Interfaz web segura con autenticación.