Swift: Operações de Arquivo e Dados do Swift

// Wrong approach: data only lives in memory
var todos: [TodoItem] = [
    TodoItem(title: "Buy coffee"),
    TodoItem(title: "Write weekly report"),
]

struct TodoItem: Codable {
    let title: String
    var isDone: false
}
let encoder = JSONEncoder()
if let data = try? encoder.encode(todos) {
    let url = FileManager.default.documentsDirectory.appendingPathComponent("todos.json")
    try? data.write(to: url)
}

// ============================================
// Getting common directory paths and creating subdirectories
// ============================================
import Foundation
let fm = FileManager.default
// 1. Get the documents directory
let docs = fm.urls(for: .documentDirectory, in: .userDomainMask).first!
print("Documents directory: \(docs.path)")
// 2. Get the caches directory
let caches = fm.urls(for: .cachesDirectory, in: .userDomainMask).first!
print("Caches directory: \(caches.path)")
// 3. Create a subdirectory
let dataDir = docs.appendingPathComponent("MyAppData")
if !fm.fileExists(atPath: dataDir.path) {
    try? fm.createDirectory(at: dataDir, withIntermediateDirectories: true)
    print("Created directory: \(dataDir.path)")
}

// ============================================
// Writing and reading a text file
// ============================================
import Foundation
let fm = FileManager.default
let docs = fm.urls(for: .documentDirectory, in: .userDomainMask).first!
// 1. Write text
let fileURL = docs.appendingPathComponent("note.txt")
let content = "Hello, Swift File I/O!"
try? content.write(to: fileURL, atomically: true, encoding: .utf8)
print("Write successful: \(fileURL.lastPathComponent)")
// 2. Read text
if let readContent = try? String(contentsOf: fileURL, encoding: .utf8) {
    print("Read content: \(readContent)")
}
// 3. Check if file exists
print("File exists: \(fm.fileExists(atPath: fileURL.path))")
// 4. Get file attributes
if let attrs = try? fm.attributesOfItem(atPath: fileURL.path) {
    let size = attrs[.size] as? Int ?? 0
    print("File size: \(size) bytes")
}

// ============================================
// Using Codable to JSON encode/decode a Person
// ============================================
import Foundation
struct Person: Codable {
    let name: String
    let age: Int
    let email: String
}
// 1. Encode object to JSON
let alice = Person(name: "Alice", age: 28, email: "alice@example.com")
let encoder = JSONEncoder()
encoder.outputFormatting = .prettyPrinted
if let jsonData = try? encoder.encode(alice),
   let jsonString = String(data: jsonData, encoding: .utf8) {
    print("Encoded JSON:")
    print(jsonString)
}
// 2. Decode from JSON to object
let json = """
{"name":"Bob","age":35,"email":"bob@example.com"}
""".data(using: .utf8)!
let decoder = JSONDecoder()
if let bob = try? decoder.decode(Person.self, from: json) {
    print("\nDecoded object: \(bob.name), age \(bob.age)")
}

// ============================================
// Nested object + custom JSON key name mapping
// ============================================
import Foundation
struct User: Codable {
    let id: Int
    let fullName: String
    let address: Address
    let tags: [String]
    // Custom key name mapping (JSON snake_case -> Swift camelCase)
    enum CodingKeys: String, CodingKey {
        case id
        case fullName = "full_name"
        case address
        case tags
    }
}
struct Address: Codable {
    let city: String
    let country: String
}
let json = """
{
    "id": 1001,
    "full_name": "Charlie Wang",
    "address": { "city": "Shanghai", "country": "China" },
    "tags": ["developer", "swift"]
}
""".data(using: .utf8)!
let decoder = JSONDecoder()
if let user = try? decoder.decode(User.self, from: json) {
    print("User: \(user.fullName) (ID: \(user.id))")
    print("City: \(user.address.city)")
    print("Tags: \(user.tags.joined(separator: ", "))")
}

// ============================================
// Saving user preferences with UserDefaults
// ============================================
import Foundation
let defaults = UserDefaults.standard
// 1. Save settings
defaults.set("Alice", forKey: "username")
defaults.set(true, forKey: "isLoggedIn")
defaults.set(3, forKey: "launchCount")
defaults.set(23.5, forKey: "lastTemperature")
// 2. Read settings
let username = defaults.string(forKey: "username") ?? "Guest"
let isLoggedIn = defaults.bool(forKey: "isLoggedIn")
let launchCount = defaults.integer(forKey: "launchCount")
let temperature = defaults.double(forKey: "lastTemperature")
print("User: \(username)")
print("Logged in: \(isLoggedIn)")
print("Launch count: \(launchCount)")
print("Last temperature: \(temperature)°C")
// 3. Remove a key
defaults.removeObject(forKey: "lastTemperature")
print("After removal: \(defaults.double(forKey: "lastTemperature"))")

// ============================================
// Codable + UserDefaults for storing complex objects
// ============================================
import Foundation
struct Settings: Codable {
    var theme: String = "light"
    var fontSize: Int = 14
    var enableNotifications: Bool = true
}
let defaults = UserDefaults.standard
let encoder = JSONEncoder()
let decoder = JSONDecoder()
// Save
var settings = Settings()
settings.theme = "dark"
settings.fontSize = 16
if let data = try? encoder.encode(settings) {
    defaults.set(data, forKey: "appSettings")
    print("Settings saved")
}
// Read
if let data = defaults.data(forKey: "appSettings"),
   let loaded = try? decoder.decode(Settings.self, from: data) {
    print("Theme: \(loaded.theme)")
    print("Font size: \(loaded.fontSize)")
    print("Notifications: \(loaded.enableNotifications)")
}

// ============================================
// Full example: Persistent to-do list manager
// Features: CRUD + JSON file persistence
// ============================================
import Foundation
// 1. To-do item model
struct TodoItem: Codable {
    let id: UUID
    var title: String
    var isCompleted: Bool
    let createdAt: Date
    init(title: String) {
        self.id = UUID()
        self.title = title
        self.isCompleted = false
        self.createdAt = Date()
    }
}
// 2. To-do manager
class TodoManager {
    private var items: [TodoItem] = []
    private let fileURL: URL
    init() {
        let docs = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!
        fileURL = docs.appendingPathComponent("todos.json")
        load()
    }
    func add(title: String) {
        items.append(TodoItem(title: title))
        save()
    }
    func toggle(id: UUID) {
        if let index = items.firstIndex(where: { $0.id == id }) {
            items[index].isCompleted.toggle()
            save()
        }
    }
    func showAll() {
        for item in items {
            let status = item.isCompleted ? "Done" : "Todo"
            print("[\(status)] \(item.title)")
        }
    }
    private func save() {
        let encoder = JSONEncoder()
        encoder.outputFormatting = .prettyPrinted
        if let data = try? encoder.encode(items) {
            try? data.write(to: fileURL)
        }
    }
    private func load() {
        if let data = try? Data(contentsOf: fileURL),
           let decoded = try? JSONDecoder().decode([TodoItem].self, from: data) {
            items = decoded
        }
    }
}
// 3. Usage example
let manager = TodoManager()
manager.add(title: "Learn Swift Codable")
manager.add(title: "Write file I/O tutorial")
manager.add(title: "Publish app update")
manager.showAll()
print("--- One completed ---")
// In practice, you'd toggle an item here
> Saída:
> ```text
> [Todo] Learn Swift Codable
> [Todo] Write file I/O tutorial
> [Todo] Publish app update
> --- One completed ---
> ```
---
## ❓ Perguntas Frequentes
> **P: Como escolher entre UserDefaults e armazenamento em arquivo?** **R: UserDefaults é adequado para pares chave-valor simples abaixo de 100KB (preferências do usuário, tokens). Use armazenamento em arquivo (JSON/banco de dados) para dados estruturados ou acima de 100KB. UserDefaults tem desempenho ruim e não suporta atualizações parciais.**
> **P: Como controlar o formato de saída do JSONEncoder?** **R: Defina encoder.outputFormatting como .prettyPrinted (legível por humanos), .sortedKeys (ordenação estável) ou .withoutEscapingSlashes (escape reduzido).**
> **P: Devo usar String ou URL para caminhos de arquivo?** **R: Sempre use URL. URL suporta concatenação de caminho com `appendingPathComponent`, recuperação de atributos de arquivo e compatibilidade multiplataforma. Caminhos String são propensos a erros e não têm esses recursos.**
> **P: Como devo usar try? e try! em operações de arquivo?** **R: Operações de arquivo têm alta probabilidade de falha (disco cheio, permissão negada, arquivo não encontrado). Sempre use `try?` ou do-catch. `try!` trava o app completamente em caso de falha.**
> **P: Quais informações o attributesOfItem do FileManager pode fornecer?** **R: Tamanho do arquivo, data de criação, data de modificação, permissões, proprietário, se é um diretório e mais. Acesse os valores com chaves como `attrs[.size]`, `attrs[.creationDate]`, etc.**
> **P: O que é o mecanismo de sandbox do iOS?** **R: Cada app só pode acessar seus próprios diretórios de sandbox (Documents, Caches, tmp) e não pode ler/escrever nos sistemas de arquivos de outros apps. URLs obtidas via FileManager estão dentro do escopo da sandbox.**
---
## 📖 Resumo
- FileManager fornece a interface do sistema de arquivos; os diretórios comuns são documents, caches e temporary
- Codable (Encodable + Decodable) permite codificação/decodificação JSON para tipos personalizados
- JSONEncoder/JSONDecoder suportam saída formatada e mapeamento de nomes de chave personalizados
- UserDefaults é adequado para armazenamento de pequenas preferências, mas não para dados complexos ou grandes
- Objetos complexos podem ser codificados para Data primeiro, depois armazenados no UserDefaults
- Operações de arquivo devem tratar erros -- disco cheio, permissão negada, etc. são sempre possíveis
---
## 📝 Exercícios
1. **Básico:** Use FileManager para criar um diretório "MinhasNotas" em documentDirectory, escreva um arquivo saudacao.txt com o conteúdo "Olá, E/S de Arquivos!" e depois leia e imprima.
2. **Intermediário:** Crie uma struct Livro (com titulo, autor, ano, isbn), salve-a em um arquivo usando JSONEncoder, depois leia de volta com JSONDecoder e verifique a consistência dos dados.
3. **Desafio:** Implemente um mecanismo simples de armazenamento KV `ArmazenamentoSimples` baseado em um arquivo JSON, suportando métodos genéricos `definir(chave: String, valor: Codable)` e `obter<T>(chave: String) -> T?`, com dados persistidos como um dicionário no arquivo.