FileManager — qué es, trabajo con el sistema de archivos de iOS

Qué es FileManager

FileManager es una clase singleton del framework Foundation que proporciona una API unificada para interactuar con el sistema de archivos en todas las plataformas Apple. Está disponible a través de FileManager.default o creando una instancia con un delegado personalizado.

Las principales capacidades de la clase incluyen: verificar la existencia de archivos (fileExists), crear directorios (createDirectory), copiar y mover (copyItem, moveItem), eliminar (removeItem), obtener atributos (attributesOfItem) y contenidos de directorios (contentsOfDirectory). FileManager está estrechamente relacionado con NSData, String y JSONEncoder/Decoder para la serialización de datos.

FileManager es seguro para subprocesos: Apple garantiza llamadas seguras a métodos desde diferentes hilos. Sin embargo, las operaciones del sistema de archivos pueden ser lentas en archivos grandes, por lo que Apple recomienda realizarlas en una cola en segundo plano (DispatchQueue.global) y llamar a los métodos de FileManagerDelegate para informar el progreso.

let fileManager = FileManager.default
let documentsURL = fileManager.urls(
    for: .documentDirectory,
    in: .userDomainMask
).first!

let fileURL = documentsURL.appendingPathComponent("data.plist")

if fileManager.fileExists(atPath: fileURL.path) {
    print("File exists at \(fileURL.path)")
}

Principales directorios de aplicaciones iOS

Cada aplicación iOS tiene tres directorios principales accesibles a través de FileManager dentro del Sandbox: Documents, Library y tmp. Cada uno tiene su propio propósito y reglas de copia de seguridad que es fundamental cumplir para pasar la revisión de App Store.

Documents — para datos de usuario que deben conservarse entre inicios y respaldarse en iCloud. Library — para archivos de la aplicación: cachés (Caches), configuraciones (Preferences), bases de datos (Application Support). tmp — para archivos temporales que el sistema puede eliminar en cualquier momento entre los inicios de la aplicación.

Regla de Apple: si un archivo se puede recuperar de internet o recrear — debe almacenarse en Caches (sin copia de seguridad). Si un archivo contiene datos de usuario — Documents (con copia de seguridad). La colocación incorrecta de archivos es una de las razones comunes de rechazo de aplicaciones, ya que Apple verifica el cumplimiento de las Directrices de Almacenamiento y Copia de Seguridad de iCloud.

Lectura y escritura de archivos

FileManager en sí mismo no proporciona métodos para leer el contenido de los archivos — para eso use NSData(contentsOf), String(contentsOf) o los métodos de FileHandle. FileManager es responsable de gestionar archivos: verificar existencia, mover, copiar, eliminar.

Para escribir datos use el método createFile(atPath:contents:attributes:) o APIs de alto nivel — data.write(to:), JSONEncoder.encode y PropertyListEncoder. FileManager también proporciona FileHandle para lectura y escritura en streaming de archivos grandes, que no carga todo el archivo en memoria.

struct UserSettings: Codable {
    let username: String
    let isDarkMode: Bool
    let fontSize: Int
}

let settings = UserSettings(
    username: "developer",
    isDarkMode: true,
    fontSize: 16
)

// Write JSON to Documents
let encoder = JSONEncoder()
encoder.outputFormatting = .prettyPrinted
let data = try encoder.encode(settings)
let url = documentsURL.appendingPathComponent("settings.json")
try data.write(to: url, options: .atomic)

// Read JSON
let loadedData = try Data(contentsOf: url)
let loadedSettings = try JSONDecoder()
    .decode(UserSettings.self, from: loadedData)

Al escribir, use options: .atomic — esto garantiza que el archivo no se corrompa si falla la escritura: los datos se guardan primero en un archivo temporal, luego se mueven atómicamente a la ruta de destino. Para leer archivos grandes, use FileHandle con .readingMode y lea datos en fragmentos, controlando el consumo de memoria.

Gestión de directorios

FileManager proporciona métodos para la gestión completa de directorios: createDirectory (creando todas las carpetas intermedias mediante withIntermediateDirectories), contentsOfDirectory (obtener lista de archivos), enumeratorAt (recorrido recursivo) y subpathsOfDirectory (todas las rutas dentro de un directorio).

El método enumeratorAt devuelve un DirectoryEnumerator, que permite recorrer eficientemente directorios grandes sin cargar todo el contenido en memoria. Admite filtrado mediante skipDescendants y proporciona atributos de cada elemento sin una consulta adicional al sistema de archivos.

// Recursive directory traversal
if let enumerator = fileManager.enumerator(
    at: documentsURL,
    includingPropertiesForKeys: [.fileSizeKey, .isDirectoryKey]
) {
    for case let fileURL as URL in enumerator {
        let attrs = try fileURL.resourceValues(
            for: [.fileSizeKey, .isDirectoryKey]
        )
        if attrs.isDirectory == false {
            let size = attrs.fileSize ?? 0
            print("File: \(fileURL.lastPathComponent), Size: \(size) bytes")
        }
    }
}

Para eliminar un directorio use removeItem(at:). Advertencia: eliminar un directorio en iOS es irreversible — los archivos no van a la papelera como en macOS. Antes de eliminar, asegúrese de que ya no necesita los archivos de ese directorio, y realice la operación en un hilo en segundo plano, ya que eliminar muchos archivos puede bloquear la interfaz de usuario.

FileManager e iCloud

FileManager se integra con iCloud Drive a través del método URLForUbiquityContainerIdentifier, que devuelve la URL del directorio de iCloud para la aplicación. Esto requiere habilitar la capacidad de iCloud en el proyecto y agregar el entitlement correspondiente.

Los archivos de iCloud se sincronizan automáticamente, pero FileManager proporciona métodos para el control manual: startDownloadingUbiquitousItem fuerza la descarga, evictUbiquitousItem elimina la copia local y urlOfItem(at:) devuelve la URL local para un archivo de iCloud. NSMetadataQuery se usa para buscar archivos en iCloud.

Limitación crítica: iCloud Drive no es compatible con archivos en el directorio Documents — solo para archivos en ubiquityContainer. No intente sincronizar Documents a través de iCloud; para eso use NSUbiquitousKeyValueStore para pequeñas cantidades de datos o Core Data con CloudKit para estructuras complejas.

Rendimiento de FileManager

Las operaciones con FileManager pueden ser costosas, especialmente en dispositivos con memoria flash lenta. Las principales recomendaciones de Apple incluyen realizar todas las operaciones de archivos en colas en segundo plano, minimizar la cantidad de llamadas a fileExistsAtPath y almacenar en caché los resultados.

El método fileExists realiza una llamada al sistema stat(), que es relativamente lenta. Si verifica la existencia de un archivo antes de leerlo, es mejor simplemente intentar leerlo y manejar el error — esto realiza el mismo stat pero evita una doble llamada al sistema. Para comprobaciones masivas, use enumeratorAt con resourceValues.

Para optimizar el trabajo con grandes volúmenes de datos:

• Use FileHandle para procesamiento en streaming de archivos grandes
• Almacene en caché los resultados de fileManager.urls para directorios de uso frecuente
• Realice operaciones por lotes en una cola granulada, evitando bloquear el hilo principal
• Use CoordinatedFileManager para acceso seguro desde múltiples hilos

Apple Instruments proporciona la plantilla File Activity para perfilar operaciones de archivos. Úsela para identificar cuellos de botella — por ejemplo, llamadas frecuentes a fileExists en un bucle u operaciones de escritura en el hilo principal. Los problemas de rendimiento más comunes están relacionados con la escritura síncrona de archivos grandes cuando la aplicación se suspende.