How to Use the Symfony Filesystem Component

In this article, we're going to explore the Symfony Filesystem component, which provides useful methods to interact with a file system. After installation and configuration, we'll create a few real-world examples of how to use it.

The Symfony Filesystem Component

More often than not, you'll need to interact with a file system if you're dealing with PHP applications. In most cases, you either end up using the core PHP functions or create your own custom wrapper class to achieve the desired functionality. Either way, it's difficult to maintain over a longer period of time. So what you need is a library which is well maintained and easy to use. That's where the Symfony Filesystem component comes in.

The Symfony Filesystem component provides useful wrapper methods that make the file system interaction a breeze and a fun experience. Let's quickly look at what it's capable of:

• creating a directory
• creating a file
• editing file contents
• changing the owner and group of a file or directory
• creating a symlink
• copying a file or directory
  
• removing a file or directory
• and more

In this article, I'll show you how to unleash the power of the Symfony Filesystem component. As usual, we'll start with installation and configuration instructions, and then we'll implement a few real-world examples to demonstrate the key concepts.

Installation and Configuration

In this section, we're going to install the Symfony Filesystem component. I assume that you've already installed Composer in your system as we'll need it to install the Filesystem component available at Packagist.

So go ahead and install the Filesystem component using the following command.

$composer require symfony/filesystem

That should have created a composer.json file, which should look like this:

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

So that's the installation part, but how are you supposed to use it? In fact, it's just a matter of including the autoload.php file created by Composer in your application, as shown in the following snippet.

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

// application code
?>

A Real-World Example

In this section, we'll create an example which demonstrates how you could use the Filesystem component in your applications to perform various filesystem operations.

To start with, let's go ahead and create the index.php file with the following contents.

<?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

Here, we've initialized the Filesystem object to $fsObject and saved the current directory to $current_dir_path. In the upcoming sections, we'll use $fsObject to perform different operations.

Make a New Directory

First, we'll create a new directory.

//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();
}

Here, we've used the exists method to check if the foo directory already exists before creating it.

Next, we used the mkdir method to create the foo directory with the 0775 permissions, which means readable and executable by all, but only writable by the file owner and their group. (This is the octal notation for filesystem permissions—to learn more, check out this breakdown of octal notation.) Further, we've used the chown and chgrp methods to change the owner and group of the foo directory.

Create a New File and Add Contents

In this section, we'll create a new file and add contents to that file.

// 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();
}

Here, we've used the touch method to create a new file and then used chmod to set its permissions to 0777—globally readable, writable, and executable.

Once the file is created, you can use the dumpFile method to add contents in that file. On the other hand, if you want to add contents to the already existing file, you can use the appendToFile method, as shown in the above example.

Copy a Directory

So far, we've created the foo directory and the bar.txt file using the $fsObject object. In this section, we'll see how to copy a directory along with the contents.

//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();
}

As you can see, first we built the path names with string concatenation. Then, once we made sure the directory didn't already exist using the exists method, we used the mirror method to copy the foo directory into the foo_copy directory.

Remove a Directory

Finally, let's see how to remove a directory.

//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();
}

Again, it's pretty straightforward—to delete a directory, you just use the remove method.

You can find the complete code to index.php in our GitHub repo.

Conclusion

So that's a brief introduction to the Symfony Filesystem component. The Symfony Filesystem component provides methods that make interaction with a file system a breeze. We looked at how to install the component, and we created a handful of examples to demonstrate various aspects of the component.

I hope that you've enjoyed this article, and feel free to post your thoughts using the feed below!

by Sajal Soni via Envato Tuts+ Code