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