Système de fichiers
Nette\Utils\FileSystem est une classe contenant des fonctions utiles pour travailler avec le système de fichiers. L'un des avantages par rapport aux fonctions natives de PHP est qu'elles lèvent des exceptions en cas d'erreur.
Si vous avez besoin de rechercher des fichiers sur le disque, utilisez Finder.
Installation :
composer require nette/utils
Les exemples suivants supposent qu'un alias a été créé :
use Nette\Utils\FileSystem;
Manipulation
copy (string $origin, string $target, bool $overwrite=true): void
Copie un fichier ou un répertoire entier. Par défaut, écrase les fichiers et répertoires existants. Si le paramètre
$overwrite
est défini sur false
, une exception Nette\InvalidStateException
est levée si
le fichier ou le répertoire cible $target
existe. En cas d'erreur, une exception Nette\IOException
est levée.
FileSystem::copy('/path/to/source', '/path/to/dest', overwrite: true);
createDir (string $dir, int $mode=0777): void
Crée un répertoire s'il n'existe pas, y compris les répertoires parents. En cas d'erreur, une exception
Nette\IOException
est levée.
FileSystem::createDir('/path/to/dir');
delete (string $path): void
Supprime un fichier ou un répertoire entier s'il existe. Si le répertoire n'est pas vide, son contenu est d'abord supprimé.
En cas d'erreur, une exception Nette\IOException
est levée.
FileSystem::delete('/path/to/fileOrDir');
makeWritable (string $path, int $dirMode=0777, int $fileMode=0666): void
Définit les permissions du fichier sur $fileMode
ou du répertoire sur $dirMode
. Parcourt
récursivement et définit également les permissions pour tout le contenu du répertoire.
FileSystem::makeWritable('/path/to/fileOrDir');
open (string $path, string $mode): resource
Ouvre un fichier et retourne une ressource. Le paramètre $mode
fonctionne de la même manière que la fonction
native fopen()
. En cas d'erreur, une exception
Nette\IOException
est levée.
$res = FileSystem::open('/path/to/file', 'r');
read (string $file): string
Retourne le contenu du fichier $file
. En cas d'erreur, une exception Nette\IOException
est levée.
$content = FileSystem::read('/path/to/file');
readLines (string $file, bool $stripNewLines=true): \Generator
Lit le contenu du fichier ligne par ligne. Contrairement à la fonction native file()
, elle ne charge pas tout le
fichier en mémoire, mais le lit progressivement, ce qui permet de lire des fichiers plus volumineux que la mémoire disponible.
$stripNewLines
indique si les caractères de fin de ligne \r
et \n
doivent être
supprimés. En cas d'erreur, une exception Nette\IOException
est levée.
$lines = FileSystem::readLines('/path/to/file');
foreach ($lines as $lineNum => $line) {
echo "Line $lineNum: $line\n";
}
rename (string $origin, string $target, bool $overwrite=true): void
Renomme ou déplace un fichier ou un répertoire $origin
. Par défaut, écrase les fichiers et répertoires
existants. Si le paramètre $overwrite
est défini sur false
, une exception
Nette\InvalidStateException
est levée si le fichier ou le répertoire cible $target
existe. En cas
d'erreur, une exception Nette\IOException
est levée.
FileSystem::rename('/path/to/source', '/path/to/dest', overwrite: true);
write (string $file, string $content, int $mode=0666): void
Écrit la chaîne $content
dans le fichier $file
. En cas d'erreur, une exception
Nette\IOException
est levée.
FileSystem::write('/path/to/file', $content);
Chemins
isAbsolute (string $path): bool
Vérifie si le chemin $path
est absolu.
FileSystem::isAbsolute('../backup'); // false
FileSystem::isAbsolute('/backup'); // true
FileSystem::isAbsolute('C:/backup'); // true
joinPaths (string …$segments): string
Joint tous les segments du chemin et normalise le résultat.
FileSystem::joinPaths('a', 'b', 'file.txt'); // 'a/b/file.txt'
FileSystem::joinPaths('/a/', '/b/'); // '/a/b/'
FileSystem::joinPaths('/a/', '/../b'); // '/b'
normalizePath (string $path): string
Normalise ..
et .
ainsi que les séparateurs de répertoires dans le chemin vers les séparateurs
système.
FileSystem::normalizePath('/file/.'); // '/file/'
FileSystem::normalizePath('\file\..'); // '/file'
FileSystem::normalizePath('/file/../..'); // '/..'
FileSystem::normalizePath('file/../../bar'); // '/../bar'
unixSlashes (string $path): string
Convertit les barres obliques en /
utilisés dans les systèmes Unix.
$path = FileSystem::unixSlashes($path);
platformSlashes (string $path): string
Convertit les barres obliques en caractères spécifiques à la plateforme actuelle, c'est-à-dire \
sous Windows
et /
ailleurs.
$path = FileSystem::platformSlashes($path);
resolvePath (string $basePath, string $path): string
Déduit le chemin final à partir du chemin $path
par rapport au répertoire de base $basePath
. Les
chemins absolus (/foo
, C:/foo
) sont laissés inchangés (seuls les slashes sont normalisés), les
chemins relatifs sont ajoutés au chemin de base.
// Sous Windows, les slashes dans la sortie seraient inversés (\)
FileSystem::resolvePath('/base/dir', '/abs/path'); // '/abs/path'
FileSystem::resolvePath('/base/dir', 'rel'); // '/base/dir/rel'
FileSystem::resolvePath('base/dir', '../file.txt'); // 'base/file.txt'
FileSystem::resolvePath('base', ''); // 'base'
Accès statique vs non statique
Afin de pouvoir facilement remplacer la classe par une autre (un mock) à des fins de test, par exemple, utilisez-la de manière non statique :
class AnyClassUsingFileSystem
{
public function __construct(
private FileSystem $fileSystem,
) {
}
public function readConfig(): string
{
return $this->fileSystem->read(/* ... */);
}
...
}