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 necesita buscar archivos en el disco, utilice 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 ya 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 padre. 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 a $target. 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 ya 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 separadores del sistema operativo actual.

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

unixSlashes (string $path): string

Convierte las barras invertidas a barras / 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 sistemas.

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

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

Resuelve la ruta final a partir de la ruta $path relativa al directorio base $basePath. Las rutas absolutas (/foo, C:/foo) se dejan sin cambios (solo se normalizan las barras), las rutas relativas se concatenan a la ruta base.

// En Windows, las barras en la salida serían invertidas (\)
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 poder reemplazar fácilmente la clase por otra (por ejemplo, un mock para fines de prueba), úsela de forma no estática:

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

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

	...
}