FileManager — vad är det, arbete med iOS filsystem

Vad är FileManager

FileManager — en singleton-klass från Foundation-ramverket som tillhandahåller ett enhetligt API för interaktion med filsystemet på alla Apple-plattformar. Den är tillgänglig via FileManager.default eller genom att skapa en instans med en anpassad delegat.

Klassens huvudsakliga funktioner inkluderar: kontroll av filens existens (fileExists), skapa kataloger (createDirectory), kopiera och flytta (copyItem, moveItem), ta bort (removeItem), hämta attribut (attributesOfItem) och kataloginnehåll (contentsOfDirectory). FileManager är nära kopplad till NSData, String och JSONEncoder/Decoder för serialisering av data.

FileManager är trådsäker: Apple garanterar säkerheten för metodanrop från olika trådar. Filsystemoperationer kan dock vara långsamma på stora filer, så Apple rekommenderar att de utförs i en bakgrundskö (DispatchQueue.global) och att FileManagerDelegate-metoder anropas för att informera om förloppet.

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)")
}

Huvudkataloger för iOS-app

Varje iOS-app har tre huvudkataloger tillgängliga via FileManager inom Sandbox: Documents, Library och tmp. Var och en har sitt syfte och regler för säkerhetskopiering, vars efterlevnad är avgörande för att godkännas i App Store-granskningen.

Documents — för användardata som ska bevaras mellan starter och säkerhetskopieras till iCloud. Library — för appfiler: cacheminnen (Caches), inställningar (Preferences), databaser (Application Support). tmp — för temporära filer som systemet kan ta bort när som helst mellan appstarter.

Apple-regel: om en fil kan återställas från internet eller återskapas — ska den lagras i Caches (utan säkerhetskopiering). Om en fil innehåller användardata — Documents (med säkerhetskopiering). Felaktig placering av filer är en av de vanligaste orsakerna till att appar avvisas, eftersom Apple kontrollerar efterlevnad av Storage & iCloud Backup Guidelines.

Läsa och skriva filer

FileManager själv tillhandahåller inte metoder för att läsa filinnehåll — för detta används NSData(contentsOf), String(contentsOf) eller FileHandle-metoder. FileManager ansvarar för hanteringen av filer: kontroll av existens, flytt, kopiering, borttagning.

För att skriva data används metoden createFile(atPath:contents:attributes:) eller högnivå-API:er — data.write(to:), JSONEncoder.encode och PropertyListEncoder. FileManager tillhandahåller också FileHandle för strömmande läsning och skrivning av stora filer, som inte laddar hela filen i minnet.

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

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

// Skriv JSON till 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)

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

Vid skrivning, använd options: .atomic — detta garanterar att filen inte skadas vid skrivfel: data sparas först i en temporär fil och flyttas sedan atomärt till målvägen. För att läsa stora filer, använd FileHandle med .readingMode och läs data i bitar, kontrollera minnesanvändningen.

Hantera kataloger

FileManager tillhandahåller metoder för fullständig kataloghantering: createDirectory (skapa alla mellanliggande mappar via withIntermediateDirectories), contentsOfDirectory (hämta fillista), enumeratorAt (rekursiv genomgång) och subpathsOfDirectory (alla sökvägar inom en katalog).

Metoden enumeratorAt returnerar en DirectoryEnumerator som möjliggör effektiv genomgång av stora kataloger utan att ladda hela innehållet i minnet. Den stöder filtrering via skipDescendants och tillhandahåller attribut för varje element utan ytterligare fråga till filsystemet.

// Rekursiv kataloggenomgång
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")
        }
    }
}

För att ta bort en katalog, använd removeItem(at:). Observera: borttagning av en katalog i iOS är oåterkallelig — filer hamnar inte i papperskorgen som på macOS. Innan borttagning, se till att du inte längre använder filer från denna katalog och utför operationen på en bakgrundstråd, eftersom borttagning av många filer kan blockera användargränssnittet.

FileManager och iCloud

FileManager integreras med iCloud Drive via metoden URLForUbiquityContainerIdentifier, som returnerar URL:en för iCloud-katalogen för appen. För att fungera krävs att iCloud capability aktiveras i projektet och att motsvarande entitlement läggs till.

iCloud-filer synkroniseras automatiskt, men FileManager tillhandahåller metoder för manuell kontroll: startDownloadingUbiquitousItem tvingar igång nedladdning, evictUbiquitousItem tar bort den lokala kopian och urlOfItem(at:) returnerar den lokala URL:en för iCloud-filen. NSMetadataQuery används för att söka efter filer i iCloud.

Kritisk begränsning: iCloud Drive stöds inte för filer i Documents-katalogen — endast för filer i ubiquityContainer. Försök inte synkronisera Documents via iCloud; använd istället NSUbiquitousKeyValueStore för små datamängder eller Core Data med CloudKit för komplexa strukturer.

FileManager-prestanda

Operationer med FileManager kan vara kostsamma, särskilt på enheter med långsamt flashminne. Apples huvudsakliga rekommendationer inkluderar att utföra alla filoperationer i bakgrundsköer, minimera antalet fileExistsAtPath-anrop och använda cachning av resultat.

Metoden fileExists utför ett systemanrop stat(), vilket är relativt långsamt. Om du kontrollerar om en fil finns innan du läser den, är det bättre att direkt försöka läsa den och hantera felet — detta utför samma stat men eliminerar ett dubbelt systemanrop. För masskontroller, använd enumeratorAt med resourceValues.

För att optimera arbete med stora datamängder:

• Använd FileHandle för strömmande bearbetning av stora filer
• Cachelagra resultaten av fileManager.urls för ofta använda kataloger
• Utför batchoperationer i en granulär kö, undvik blockering av huvudtråden
• Använd CoordinatedFileManager för säker åtkomst från flera trådar

Apple Instruments tillhandahåller mallen File Activity för profilering av filoperationer. Använd den för att identifiera flaskhalsar — till exempel frekventa fileExists-anrop i en loop eller skrivoperationer på huvudtråden. De vanligaste prestandaproblemen är relaterade till synkron skrivning av stora filer när appen minimeras.