Sistema de archivos

Nette\Utils\FileSystem es una clase con funciones útiles para trabajar con el sistema de archivos. Una de las ventajas sobre las funciones nativas de PHP es que lanzan excepciones en caso de error.

Si necesitas buscar archivos en el disco, usa Finder.

Instalación:

composer require nette/utils

Los siguientes ejemplos asumen que se ha creado un alias:

use Nette\Utils\FileSystem;

Manipulación

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

Copia un archivo o un directorio completo. Por defecto, sobrescribe los archivos y directorios existentes. Con el parámetro $overwrite establecido en false, lanza una excepción Nette\InvalidStateException si el archivo o directorio de destino $target existe. En caso de error, lanza una excepción Nette\IOException.

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

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

Crea un directorio si no existe, incluyendo los directorios padres. En caso de error, lanza una excepción Nette\IOException.

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

delete (string $path): void

Elimina un archivo o un directorio completo si existe. Si el directorio no está vacío, elimina primero su contenido. En caso de error, lanza una excepción Nette\IOException.

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

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

Establece los permisos del archivo a $fileMode o del directorio a $dirMode. Recorre recursivamente y establece los permisos también para todo el contenido del directorio.

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

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

Abre un archivo y devuelve un resource. El parámetro $mode funciona igual que en la función nativa fopen(). En caso de error, lanza una excepción Nette\IOException.

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

read (string $file): string

Devuelve el contenido del archivo $file. En caso de error, lanza una excepción Nette\IOException.

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

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

Lee el contenido del archivo línea por línea. A diferencia de la función nativa file(), no carga todo el archivo en memoria, sino que lo lee continuamente, por lo que es posible leer archivos más grandes que la memoria disponible. $stripNewLines indica si se deben eliminar los caracteres de fin de línea \r y \n. En caso de error, lanza una excepción 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

Renombra o mueve un archivo o directorio $origin. Por defecto, sobrescribe los archivos y directorios existentes. Con el parámetro $overwrite establecido en false, lanza una excepción Nette\InvalidStateException si el archivo o directorio de destino $target existe. En caso de error, lanza una excepción Nette\IOException.

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

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

Escribe la cadena $content en el archivo $file. En caso de error, lanza una excepción Nette\IOException.

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

Rutas

isAbsolute (string $path): bool

Determina si la ruta $path es absoluta.

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

joinPaths (string …$segments): string

Une todos los segmentos de la ruta y normaliza el resultado.

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

Normaliza .. y . y los separadores de directorios en la ruta a los del sistema.

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

unixSlashes (string $path): string

Convierte las barras a / utilizadas en los sistemas Unix.

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

platformSlashes (string $path): string

Convierte las barras a los caracteres específicos de la plataforma actual, es decir, \ en Windows y / en otros lugares.

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

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

Deriva la ruta final de la ruta $path con respecto al directorio base $basePath. Las rutas absolutas (/foo, C:/foo) se dejan sin cambios (solo se normalizan las barras), las rutas relativas se adjuntan a la ruta base.

// En Windows, las barras en la salida serían opuestas (\)
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'

Acceso estático vs no estático

Para que, por ejemplo, para fines de prueba, puedas reemplazar fácilmente la clase por otra (un mock), úsala de forma no estática:

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

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

	...
}