mkdir¶

mkdir() creates a directory recursively. On POSIX filesystems, directories are created with a default mode value 0777. You can use the second argument to set your own mode:

$fs->mkdir('/tmp/photos', 0700);

exists¶

exists() checks for the presence of one or more files or directories and returns false if any of them is missing:

1
2
3
4
5

// this directory exists, return true
$fs->exists('/tmp/photos');

// rabbit.jpg exists, bottle.png does not exist, return false
$fs->exists(array('rabbit.jpg', 'bottle.png'));

copy¶

copy() makes a copy of a single file (use mirror() to copy directories). If the target already exists, the file is copied only if the source modification date is later than the target. This behavior can be overridden by the third boolean argument:

1
2
3
4
5

// works only if image-ICC has been modified after image.jpg
$fs->copy('image-ICC.jpg', 'image.jpg');

// image.jpg will be overridden
$fs->copy('image-ICC.jpg', 'image.jpg', true);

touch¶

touch() sets access and modification time for a file. The current time is used by default. You can set your own with the second argument. The third argument is the access time:

1
2
3
4
5
6

// set modification time to the current timestamp
$fs->touch('file.txt');
// set modification time 10 seconds in the future
$fs->touch('file.txt', time() + 10);
// set access time 10 seconds in the past
$fs->touch('file.txt', time(), time() - 10);

chown¶

chown() changes the owner of a file. The third argument is a boolean recursive option:

// set the owner of the lolcat video to www-data
$fs->chown('lolcat.mp4', 'www-data');
// change the owner of the video directory recursively
$fs->chown('/video', 'www-data', true);

chgrp¶

chgrp() changes the group of a file. The third argument is a boolean recursive option:

// set the group of the lolcat video to nginx
$fs->chgrp('lolcat.mp4', 'nginx');
// change the group of the video directory recursively
$fs->chgrp('/video', 'nginx', true);

chmod¶

chmod() changes the mode or permissions of a file. The fourth argument is a boolean recursive option:

// set the mode of the video to 0600
$fs->chmod('video.ogg', 0600);
// change the mod of the src directory recursively
$fs->chmod('src', 0700, 0000, true);

remove¶

remove() deletes files, directories and symlinks:

$fs->remove(array('symlink', '/path/to/directory', 'activity.log'));

rename¶

rename() changes the name of a single file or directory:

// rename a file
$fs->rename('/tmp/processed_video.ogg', '/path/to/store/video_647.ogg');
// rename a directory
$fs->rename('/tmp/files', '/path/to/store/files');

symlink¶

symlink() creates a symbolic link from the target to the destination. If the filesystem does not support symbolic links, a third boolean argument is available:

1
2
3
4
5

// create a symbolic link
$fs->symlink('/path/to/source', '/path/to/destination');
// duplicate the source directory if the filesystem
// does not support symbolic links
$fs->symlink('/path/to/source', '/path/to/destination', true);

readlink¶

readlink() read links targets.

PHP's readlink() function returns the target of a symbolic link. However, its behavior is completely different under Windows and Unix. On Windows systems, readlink() resolves recursively the children links of a link until a final target is found. On Unix-based systems readlink() only resolves the next link.

The readlink() method provided by the Filesystem component always behaves in the same way:

1
2
3
4
5

// returns the next direct target of the link without considering the existence of the target
$fs->readlink('/path/to/link');

// returns its absolute fully resolved final version of the target (if there are nested links, they are resolved)
$fs->readlink('/path/to/link', true);

Its behavior is the following:

public function readlink($path, $canonicalize = false)

• When $canonicalize is false:

  • if $path does not exist or is not a link, it returns null.
  • if $path is a link, it returns the next direct target of the link without considering the existence of the target.

• When $canonicalize is true:

  • if $path does not exist, it returns null.
  • if $path exists, it returns its absolute fully resolved final version.

makePathRelative¶

makePathRelative() takes two absolute paths and returns the relative path from the second path to the first one:

1
2
3
4
5
6
7

// returns '../'
$fs->makePathRelative(
    '/var/lib/symfony/src/Symfony/',
    '/var/lib/symfony/src/Symfony/Component'
);
// returns 'videos/'
$fs->makePathRelative('/tmp/videos', '/tmp')

mirror¶

mirror() copies all the contents of the source directory into the target one (use the copy() method to copy single files):

$fs->mirror('/path/to/source', '/path/to/target');

isAbsolutePath¶

isAbsolutePath() returns true if the given path is absolute, false otherwise:

1
2
3
4
5
6
7
8

// return true
$fs->isAbsolutePath('/tmp');
// return true
$fs->isAbsolutePath('c:\\Windows');
// return false
$fs->isAbsolutePath('tmp');
// return false
$fs->isAbsolutePath('../dir');

dumpFile¶

dumpFile() saves the given contents into a file. It does this in an atomic manner: it writes a temporary file first and then moves it to the new file location when it's finished. This means that the user will always see either the complete old file or complete new file (but never a partially-written file):

$fs->dumpFile('file.txt', 'Hello World');

The file.txt file contains Hello World now.

appendToFile¶

appendToFile() adds new contents at the end of some file:

$fs->appendToFile('logs.txt', 'Email sent to [email protected]');

If either the file or its containing directory doesn't exist, this method creates them before appending the contents.