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

	...
}