Funkcje systemu plików

Nette\Utils\FileSystem to klasa z przydatnymi funkcjami do pracy z systemem plików. Jedną z jej zalet nad natywnymi funkcjami PHP jest to, że przy błędach zgłasza wyjątki.

Jeśli potrzebujesz wyszukiwać pliki na dysku, użyj Findera.

Instalacja:

composer require nette/utils

Poniższe przykłady zakładają, że zdefiniowany jest następujący alias klasy:

use Nette\Utils\FileSystem;

Manipulacja

copy (string $origin, string $target, bool $overwrite=true): void

Kopiuje plik albo cały katalog. Domyślnie nadpisuje istniejące pliki i katalogi. Jeśli $overwrite ma wartość false, a docelowy plik albo katalog $target już istnieje, zgłasza Nette\InvalidStateException. Przy błędzie zgłasza Nette\IOException.

FileSystem::copy('/path/to/source', '/path/to/dest', overwrite: true);

createDir (string $dir, int $mode=0777): void

Tworzy katalog, jeśli nie istnieje, wraz z katalogami nadrzędnymi. Przy błędzie zgłasza Nette\IOException.

FileSystem::createDir('/path/to/dir');

delete (string $path): void

Usuwa plik albo cały katalog, jeśli istnieje. Jeśli katalog nie jest pusty, najpierw usuwa jego zawartość. Przy błędzie zgłasza Nette\IOException.

FileSystem::delete('/path/to/fileOrDir');

makeWritable (string $path, int $dirMode=0777, int $fileMode=0666): void

Ustawia uprawnienia pliku na $fileMode albo uprawnienia katalogu na $dirMode. Rekurencyjnie przechodzi po całej zawartości katalogu i ustawia uprawnienia również dla niej.

FileSystem::makeWritable('/path/to/fileOrDir');

open (string $path, string $mode): resource

Otwiera plik i zwraca uchwyt do zasobu. Parametr $mode działa tak samo jak w natywnej funkcji fopen(). Przy błędzie zgłasza Nette\IOException.

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

read (string $file): string

Wczytuje zawartość pliku $file. Przy błędzie zgłasza Nette\IOException.

$content = FileSystem::read('/path/to/file');

readLines (string $file, bool $stripNewLines=true): \Generator

Wczytuje zawartość pliku wiersz po wierszu. W odróżnieniu od natywnej funkcji file() nie ładuje całego pliku do pamięci, lecz czyta go na bieżąco, dzięki czemu możesz czytać pliki większe niż dostępna pamięć. $stripNewLines określa, czy usuwać znaki końca wiersza \r i \n. Przy błędzie zgłasza 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

Zmienia nazwę albo przenosi plik lub katalog wskazany przez $origin do $target. Domyślnie nadpisuje istniejące pliki i katalogi. Jeśli $overwrite ma wartość false, a docelowy plik albo katalog $target już istnieje, zgłasza Nette\InvalidStateException. Przy błędzie zgłasza Nette\IOException.

FileSystem::rename('/path/to/source', '/path/to/dest', overwrite: true);

write (string $file, string $content, ?int $mode=0666): void

Zapisuje string $content do pliku $file. Jeśli katalog nadrzędny nie istnieje, zostaje utworzony automatycznie. Domyślnie ustawia też uprawnienia pliku; podaj null jako $mode, aby pominąć wywołanie chmod. Przy błędzie zgłasza Nette\IOException.

FileSystem::write('/path/to/file', $content);

writeAtomic (string $file, string $content, ?int $mode=0666): void

Zapisuje string $content do pliku $file atomowo: treść jest najpierw zapisywana do pliku tymczasowego, który następnie w jednym kroku zastępuje plik docelowy. Czytelnik sięgający po plik w tym samym momencie nigdy nie zobaczy go więc zapisanego do połowy ani obciętego. Poza tym zachowuje się dokładnie tak jak write(). Przy błędzie zgłasza Nette\IOException.

FileSystem::writeAtomic('/path/to/file', $content);

Ścieżki

isAbsolute (string $path): bool

Ustala, czy ścieżka $path jest bezwzględna.

FileSystem::isAbsolute('../backup'); // false
FileSystem::isAbsolute('/backup');   // true
FileSystem::isAbsolute('C:/backup'); // true

isValidFilename (string $name): bool

Sprawdza, czy $name jest prawidłową, wieloplatformową nazwą pliku bez informacji o ścieżce. Odrzuca puste stringi, . i .., znaki sterujące, znaki <>:"|?*\/, nazwy kończące się kropką albo spacją oraz nazwy zarezerwowane w Windows (CON, NUL, COM1, …).

FileSystem::isValidFilename('photo.jpg');    // true
FileSystem::isValidFilename('../photo.jpg'); // false
FileSystem::isValidFilename('CON');          // false

joinPaths (string …$segments): string

Łączy wszystkie segmenty ścieżki i normalizuje wynik.

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

Normalizuje w ścieżce .., . i separatory katalogów do standardu systemu.

FileSystem::normalizePath('/file/.');        // '/file'
FileSystem::normalizePath('\file\..');       // '/'
FileSystem::normalizePath('/file/../..');    // '/..'
FileSystem::normalizePath('file/../../bar'); // '../bar'

unixSlashes (string $path): string

Konwertuje ukośniki na / używane w systemach uniksowych.

$path = FileSystem::unixSlashes($path);

platformSlashes (string $path): string

Konwertuje ukośniki na znaki właściwe dla bieżącej platformy, czyli \ w Windows i / gdzie indziej.

$path = FileSystem::platformSlashes($path);

resolvePath (string $basePath, string $path): string

Wyznacza ostateczną ścieżkę z $path względem katalogu bazowego $basePath. Ścieżki bezwzględne (/foo, C:/foo) pozostają bez zmian (normalizowane są tylko ukośniki), ścieżki względne dołączane są do ścieżki bazowej.

// w Windows ukośniki w wyniku byłyby odwrócone (\)
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'

Podejście statyczne kontra niestatyczne

Aby na potrzeby testów łatwo zastąpić klasę inną (np. mockiem), używaj jej niestatycznie:

class AnyClassUsingFileSystem
{
	public function __construct(
		private FileSystem $fileSystem,
	) {
	}

	public function readConfig(): string
	{
		return $this->fileSystem->read(/* ... */);
	}

	// ...
}