Sistemul de fișiere

Nette\Utils\FileSystem este o clasă cu funcții utile pentru lucrul cu sistemul de fișiere. Unul dintre avantaje față de funcțiile native PHP este că aruncă excepții în caz de eroare.

Dacă aveți nevoie să căutați fișiere pe disc, utilizați Finder.

Instalare:

composer require nette/utils

Următoarele exemple presupun crearea unui alias:

use Nette\Utils\FileSystem;

Manipulare

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

Copiază un fișier sau un întreg director. În mod implicit, suprascrie fișierele și directoarele existente. Cu parametrul $overwrite setat la valoarea false, aruncă excepția Nette\InvalidStateException dacă fișierul sau directorul țintă $target există. În caz de eroare, aruncă excepția Nette\IOException.

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

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

Creează un director dacă nu există, inclusiv directoarele părinte. În caz de eroare, aruncă excepția Nette\IOException.

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

delete (string $path): void

Șterge un fișier sau un întreg director dacă există. Dacă directorul nu este gol, șterge mai întâi conținutul său. În caz de eroare, aruncă excepția Nette\IOException.

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

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

Setează permisiunile fișierului la $fileMode sau directorului la $dirMode. Parcurge recursiv și setează permisiunile și pentru întregul conținut al directorului.

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

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

Deschide un fișier și returnează resursa. Parametrul $mode funcționează la fel ca la funcția nativă fopen(). În caz de eroare, aruncă excepția Nette\IOException.

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

read (string $file): string

Returnează conținutul fișierului $file. În caz de eroare, aruncă excepția Nette\IOException.

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

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

Citește conținutul fișierului rând cu rând. Spre deosebire de funcția nativă file(), nu încarcă întregul fișier în memorie, ci îl citește continuu, astfel încât este posibil să citiți și fișiere mai mari decât memoria disponibilă. $stripNewLines indică dacă trebuie eliminate caracterele de sfârșit de rând \r și \n. În caz de eroare, aruncă excepția 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

Redenumește sau mută fișierul sau directorul $origin. În mod implicit, suprascrie fișierele și directoarele existente. Cu parametrul $overwrite setat la valoarea false, aruncă excepția Nette\InvalidStateException dacă fișierul sau directorul țintă $target există. În caz de eroare, aruncă excepția Nette\IOException.

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

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

Scrie șirul $content în fișierul $file. În caz de eroare, aruncă excepția Nette\IOException.

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

Căi

isAbsolute (string $path): bool

Verifică dacă calea $path este absolută.

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

joinPaths (string …$segments): string

Unește toate segmentele căii și normalizează rezultatul.

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

Normalizează .. și . și separatoarele de directoare în cale la cele de sistem.

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

unixSlashes (string $path): string

Convertește slash-urile la / utilizate în sistemele Unix.

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

platformSlashes (string $path): string

Convertește slash-urile la caracterele specifice platformei curente, adică \ în Windows și / în altă parte.

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

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

Derivează calea finală din calea $path relativ la directorul de bază $basePath. Căile absolute (/foo, C:/foo) le lasă neschimbate (doar normalizează slash-urile), căile relative le anexează la calea de bază.

// Pe Windows, slash-urile din ieșire ar fi inverse (\)
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'

Acces static vs nestatic

Pentru a putea înlocui ușor clasa cu alta (mock) în scopuri de testare, de exemplu, utilizați-o nestatic:

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

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

	...
}