O que são dicionários em Swift afinal?

• Você acessa o valor usando sua chave única.

• Diferente de um Array, o acesso não é feito por um índice numérico baseado na posição. A partir do Swift 5, a ordem de inserção dos elementos é preservada durante a iteração mas o foco principal do dicionário é a rápida associação chave-valor.

• Todas as chaves devem ser do mesmo tipo e únicas dentro do dicionário.

• Todos os valores devem ser do mesmo tipo.

Criando seu primeiro dicionário Swift

1. Iniciando um dicionário vazio:

// Dicionário para guardar a pontuação dos alunos em desafios
// Chave: String (nome do aluno), Valor: Int (pontuação)
var pontuacaoAlunos: [String: Int] = [:]

pontuacaoAlunos["Mayk"] = 100 // Adicionando um item
print(pontuacaoAlunos) // Saída: ["Mayk": 100]

// Outra forma de declarar um dicionário vazio
var tecnologiasPorStack = [String: String]()

2. Criando com valores iniciais (literais):

// Exemplo: Instrutores por Trilha principal na Rocketseat
var instrutoresTrilha: [String: String] = [
    "React Native": "Rodrigo",
    "Full-stack": "Mayk",
    "React": "Diego",
    "Swift": "Mateus" 
]

print("Nossos incríveis instrutores: \(instrutoresTrilha)")
// Saída: (a ordem pode variar!) ["React": "Diego", "Full-stack": "Mayk", "React Native": "Rodrigo", "Swift": "Mateus"]

3. Inferência de tipo:

// Swift olha para as chaves ("Node.js", "API", "Servidor") e vê que são Strings.
// Olha para os valores ("JavaScript/TypeScript", "Go", "Java") e vê que também são Strings.
// Automaticamente, ele infere que linguagensBackend é do tipo [String: String].
var linguagensBackend = ["Node.js": "JavaScript/TypeScript", "API": "Go", "Servidor": "Java"]

print("Algumas linguagens de backend: \(linguagensBackend)")
// Isso torna o código mais conciso quando os tipos são óbvios a partir dos valores iniciais.

Manipulando dicionários: ler, adicionar, atualizar e remover (CRUD)

1. Lendo dados (read)

// Tentando acessar o instrutor da trilha "Full-stack" (chave existe)
let chaveFullStack = "Full-stack"

// Usando if let (recomendado!) para desempacotar com segurança
if let instrutor = instrutoresTrilha[chaveFullStack] {
    // Este bloco só executa se a chave existir e o valor não for nil
    // A variável 'instrutor' aqui dentro é do tipo String (não Optional)
    print("✅ O mestre do \(chaveFullStack) é: \(instrutor)") // Saída: ✅ O mestre do Full-stack é: Mayk
} else {
    // Este bloco executa se a chave "Full-stack" não for encontrada
    print("❌ Trilha de \(chaveFullStack) não encontrada.")
}

// Tentando acessar uma chave inexistente ("Ruby")
let chaveRuby = "Ruby"
if let instrutorRuby = instrutoresTrilha[chaveRuby] {
    print("Instrutor de Ruby: \(instrutorRuby)")
} else {
    // Como a chave "Ruby" não existe em instrutoresTrilha, este bloco será executado.
    print("❌ Ops! Instrutor para a trilha \(chaveRuby) não definido.") // Saída esperada
}

// Acesso com valor padrão (default): uma forma elegante de lidar com ausência
// Se a chave "iOS" não existir, ele retorna o valor default "Mateus Coelho".
// Se existir, retorna o valor associado à chave "iOS".
let instrutorIos = instrutoresTrilha["iOS", default: "Mateus Coelho"]
print("Instrutor de iOS: \(instrutorIos)") // Saída: Instrutor de iOS: Mateus Coelho (porque "iOS" não estava no dicionário original)
// É uma ótima alternativa ao if let quando você só precisa de um valor garantido.

2. Adicionando e atualizando dados (create/update):

// Adicionando a trilha de iOS com o Mateus. Como "iOS" não existia, é uma adição.
instrutoresTrilha["iOS"] = "Mateus"
print("Adicionamos iOS: \(instrutoresTrilha)") // Agora o dicionário inclui "iOS": "Mateus"

// Atualizando o instrutor de React Native (era Rodrigo, agora Isabela). Como "React Native" já existia, é uma atualização.
// O método `updateValue(_:forKey:)` faz o mesmo, mas tem um bônus:
// ele retorna o VALOR ANTIGO associado à chave (como um Optional), antes da atualização.
// Útil se você precisar saber qual era o valor anterior.
let antigoInstrutorMobile = instrutoresTrilha.updateValue("Isabela", forKey: "React Native")

if let antigo = antigoInstrutorMobile {
    // 'antigo' aqui contém o valor "Rodrigo"
    print("Atualizamos React Native. Instrutor(a) anterior era: \(antigo)") // Saída: Atualizamos React Native. Instrutor(a) anterior era: Rodrigo
}
print("Instrutores atualizados: \(instrutoresTrilha)") // Agora "React Native" tem o valor "Isabela"

3. Removendo dados (delete):

// Removendo a trilha de Full-stack usando removeValue(forKey:)
// Este método também retorna o valor que foi removido (como Optional),
// ou nil se a chave não existia.
let instrutorRemovido = instrutoresTrilha.removeValue(forKey: "Full-stack") // Corrigido para uma chave que existe no exemplo atual

if let removido = instrutorRemovido {
    // 'removido' aqui contém "Mayk"
    print("Trilha Full-stack removida. Instrutor(a) era: \(removido)") // Saída: Trilha Full-stack removida. Instrutor(a) era: Mayk
} else {
    print("Chave 'Full-stack' não encontrada para remoção.")
}
print("Após remover Full-stack: \(instrutoresTrilha)") // O par "Full-stack": "Mayk" não está mais lá

// Outra forma comum de remover é atribuir 'nil' à chave.
// 'nil' em Swift representa a ausência de valor. Ao atribuir nil
// a uma chave de dicionário, você está dizendo "não há mais valor aqui",
// o que efetivamente remove o par chave-valor.
instrutoresTrilha["React"] = nil
print("Após remover React atribuindo nil: \(instrutoresTrilha)") // O par "React": "Diego" também foi removido.

Iterando sobre dicionários Swift: percorrendo chaves e valores

print("\n--- Trilhas e Instrutores Atuais na Rocketseat ---")
// A cada volta do loop, 'trilha' recebe uma chave e 'instrutor' recebe o valor correspondente.
for (trilha, instrutor) in instrutoresTrilha {
    print("\(trilha) -> Instrutor(a): \(instrutor)")
}

// Iterando apenas sobre as chaves (útil se você só precisa dos identificadores)
// .keys retorna uma coleção apenas com as chaves.
print("\n--- Apenas as Trilhas ---")
for trilha in instrutoresTrilha.keys {
    print(trilha)
}

// Iterando apenas sobre os valores (útil se você só precisa dos dados associados)
// .values retorna uma coleção apenas com os valores.
print("\n--- Apenas os Instrutores ---")
for instrutor in instrutoresTrilha.values {
    print(instrutor)
}

// Se você PRECISA de uma ordem específica, pode ordenar as chaves antes de iterar:
print("\n--- Trilhas Ordenadas Alfabeticamente ---")
for trilha in instrutoresTrilha.keys.sorted() {
    // Acessa o valor usando a chave ordenada (lembre-se do Optional!)
    if let instrutor = instrutoresTrilha[trilha] {
        print("\(trilha) -> Instrutor(a): \(instrutor)")
    }
}

Dicionários e optionals: a dupla inseparável do Swift!

• if let: para executar um bloco de código apenas se o valor existir.

• guard let: similar ao if let, mas útil para saídas antecipadas em funções.

• Operador de coalescência nula (??): para fornecer um valor padrão caso o Optional seja nil.

• Acesso com defaultValue: como vimos (dicionario["chave", default: valorPadrao]), uma forma limpa de obter um valor ou um padrão.

// Exemplo seguro com ??
let nomeTrilha = "DevOps"
let instrutorDevOps = instrutoresTrilha[nomeTrilha] ?? "Trilha de \(nomeTrilha) em planejamento!"
print(instrutorDevOps) // Saída: Trilha de DevOps em planejamento!

// Exemplo perigoso (NÃO FAÇA ISSO!)
let instrutorCrash = instrutoresTrilha["NaoExiste"]! // Isso causaria um crash!

Boas práticas: usando dicionários Swift da forma certa

• Tipagem clara: sempre que possível, declare explicitamente os tipos (var meuDict: [String: Int] = [:]). Ajuda na leitura e evita erros.

• Prefira imutabilidade: se o dicionário não vai mudar depois de criado, declare-o com let em vez de var. É mais seguro e eficiente.

• Saiba quando usar: dicionários são ideais quando a ordem não importa e você precisa de acesso rápido por um identificador único (chave). Se a ordem for crucial ou você acessa por posição numérica, um Array pode ser melhor.

• Abrace os optionals: entenda e use as técnicas seguras de desempacotamento (if let, guard let, ??, defaultValue). Elas são suas amigas!

• Consistência nas chaves: use tipos consistentes e significativos para suas chaves.

Conclusão: decolando com o poder dos dicionários em Swift!