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.
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.
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 usedchmod
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 theappendToFile
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 themirror
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!
Powered by WPeMatico