Cómo usar el componente Filesystem de Symfony

Spanish (Español) translation by Ana Paulina Figueroa (you can also view the original English article)

En este artículo, vamos a explorar el componente Filesystem de Symfony, que proporciona métodos útiles para interactuar con un sistema de archivos. Después de su instalación y configuración, crearemos algunos ejemplos reales sobre cómo usarlo.

El componente Filesystem de Symfony

Si estás trabajando con aplicaciones PHP, con mucha frecuencia necesitarás interactuar con un sistema de archivos. En la mayoría de los casos terminas ya sea usando las funciones principales de PHP o creando tus propias clases contenedoras personalizadas para lograr la funcionalidad deseada. De cualquier manera, esto es difícil de mantener durante un período de tiempo más largo. Entonces, lo que necesitas es una biblioteca con buen mantenimiento y fácil de usar. Ahí es donde entra el componente Filesystem de Symfony.

El componente Filesystem de Symfony proporciona útiles métodos contenedores que permiten que la interacción con el sistema de archivos sea muy fácil y divertida. Veamos rápidamente de lo que es capaz:

crear un directorio
crear un archivo
editar el contenido de un archivo
cambiar el propietario y el grupo de un archivo o directorio
crear un enlace simbólico (o symlink)
copiar un archivo o directorio
eliminar un archivo o directorio
y más

En este artículo, te enseñaré cómo desatar el poder del componente Filesystem de Symfony. Como de costumbre, comenzaremos con las instrucciones para la instalación y la configuración, y luego implementaremos algunos ejemplos reales para demostrar los conceptos clave.

Instalación y configuración

En esta sección vamos a instalar el componente Filesystem de Symfony. Voy a suponer que ya has instalado Composer en tu sistema, ya que lo necesitaremos para instalar el componente Filesystem disponible en Packagist.

Así que sigue adelante e instala el componente Filesystem usando el comando a continuación.

1	$composer require symfony/filesystem

Eso debería haber creado un archivo composer.json, que debería verse así:

{
    "require": {
        "symfony/filesystem": "^4.1"
    }
}

Esa es la parte de la instalación, pero ¿cómo se supone que debes usar esto? De hecho, es solo cuestión de incluir el archivo autoload.php creado por Composer en tu aplicación, como se muestra en el siguiente fragmento de código.

<?php
require_once './vendor/autoload.php';

// application code
?>

Un ejemplo real

En esta sección, crearemos un ejemplo que demuestra cómo puedes usar el componente Filesystem en tus aplicaciones para realizar varias operaciones en el sistema de archivos.

Para comenzar, vayamos y creemos el archivo index.php con el siguiente contenido.

<?php
require_once './vendor/autoload.php';

use Symfony\Component\Filesystem\Filesystem;
use Symfony\Component\Filesystem\Exception\IOExceptionInterface;

// init file system
$fsObject = new Filesystem();
$current_dir_path = getcwd();

// make a new directory
// create a new file and add contents
// copy a directory
// remove a directory

Aquí, hemos inicializado el objeto Filesystem en $fsObject y hemos guardado el directorio actual en $current_dir_path. En las próximas secciones, usaremos $fsObject para llevar a cabo diferentes operaciones.

Crea un nuevo directorio

Primero, crearemos un nuevo directorio.

//make a new directory
try {
    $new_dir_path = $current_dir_path . "/foo";

    if (!$fsObject->exists($new_dir_path))
    {
        $old = umask(0);
        $fsObject->mkdir($new_dir_path, 0775);
        $fsObject->chown($new_dir_path, "www-data");
        $fsObject->chgrp($new_dir_path, "www-data");
        umask($old);
    }
} catch (IOExceptionInterface $exception) {
    echo "Error creating directory at". $exception->getPath();
}

Aquí hemos usado el método exists para verificar si el directorio foo ya existe antes de crearlo.

A continuación, usamos el método mkdir para crear el directorio foo con los permisos 0775, lo que significa que todos pueden leerlo y ejecutarlo, pero solamente el propietario del archivo y su grupo pueden escribir en él. (Esta es la notación octal para los permisos del sistema de archivos; para obtener más información, consulta este desglose de la notación octal). Además, hemos usado los métodos chown y chgrp para cambiar el propietario y el grupo del directorio foo.

Crea un nuevo archivo y agrégale contenido

En esta sección, crearemos un archivo nuevo y agregaremos contenido a dicho archivo.

// create a new file and add contents
try {
    $new_file_path = $current_dir_path . "/foo/bar.txt";

    if (!$fsObject->exists($new_file_path))
    {
        $fsObject->touch($new_file_path);
        $fsObject->chmod($new_file_path, 0777);
        $fsObject->dumpFile($new_file_path, "Adding dummy content to bar.txt file.\n");
        $fsObject->appendToFile($new_file_path, "This should be added to the end of the file.\n");
    }
} catch (IOExceptionInterface $exception) {
    echo "Error creating file at". $exception->getPath();
}

Aquí, hemos usado el método touch para crear un archivo nuevo y luego usamos chmod para establecer sus permisos en 0777: legible, editable y ejecutable globalmente.

Una vez creado el archivo, puedes usar el método dumpFile para agregar contenido a dicho archivo. Por otro lado, si quieres agregar contenido al archivo ya existente, puedes usar el método appendToFile, como se muestra en el ejemplo anterior.

Copia un directorio

Hasta ahora, hemos creado el directorio foo y el archivo bar.txt usando el objeto $fsObject. En esta sección veremos cómo copiar un directorio junto con su contenido.

//copy a directory
try {
    $src_dir_path = $current_dir_path . "/foo";
    $dest_dir_path = $current_dir_path . "/foo_copy";

    if (!$fsObject->exists($dest_dir_path))
    {
        $fsObject->mirror($src_dir_path, $dest_dir_path);
    }
} catch (IOExceptionInterface $exception) {
    echo "Error copying directory at". $exception->getPath();
}

Como puedes ver, primero creamos los nombres de las rutas usando la concatenación de cadenas. Luego, una vez que nos aseguramos de que el directorio no existía usando el método exists, usamos el método mirror para copiar el directorio foo en el directorio foo_copy.

Elimina un directorio

Finalmente, veamos cómo eliminar un directorio.

//remove a directory
try {
    $arr_dirs = array(
        $current_dir_path . "/foo",
        $current_dir_path . "/foo_copy"
    );

    $fsObject->remove($arr_dirs);
} catch (IOExceptionInterface $exception) {
    echo "Error deleting directory at". $exception->getPath();
}

Nuevamente, es bastante sencillo: para eliminar un directorio, simplemente debes usar el método remove.

Puedes encontrar el código completo para index.php en nuestro repositorio de GitHub.

Conclusión

Esa es una breve introducción al componente Filesystem de Symfony. El componente Filesystem de Symfony proporciona métodos que facilitan mucho la interacción con un sistema de archivos. Vimos cómo instalar el componente, y creamos un puñado de ejemplos para demostrar varios aspectos del mismo.

Espero que hayas disfrutado este artículo, ¡y no dudes en publicar lo que piensas usando el canal a continuación!