Système de fichiers

Nette\Utils\FileSystem est une classe avec des fonctions utiles pour travailler avec le système de fichiers. L'un des avantages par rapport aux fonctions PHP natives est qu'en cas d'erreur, elles lèvent des exceptions.

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. Avec le paramètre $overwrite défini sur false, lève une exception Nette\InvalidStateException si le fichier ou le répertoire cible $target existe. En cas d'erreur, lève une exception Nette\IOException.

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, lève une exception Nette\IOException.

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, supprime d'abord son contenu. En cas d'erreur, lève une exception Nette\IOException.

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 les permissions pour tout le contenu du répertoire également.

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, lève une exception Nette\IOException.

$res = FileSystem::open('/path/to/file', 'r');

read (string $file): string

Retourne le contenu du fichier $file. En cas d'erreur, lève une exception Nette\IOException.

$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(), ne charge pas tout le fichier en mémoire, mais le lit au fur et à mesure, ce qui permet de lire des fichiers plus grands 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, lève une exception Nette\IOException.

$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. Avec le paramètre $overwrite défini sur false, lève une exception Nette\InvalidStateException si le fichier ou le répertoire cible $target existe. En cas d'erreur, lève une exception Nette\IOException.

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, lève une exception Nette\IOException.

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 de 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 . et 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 joints 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(/* ... */);
	}

	...
}