Arrays em Swift: a sequência ordenada (Array<Element>)

O que é um Array?

Declaração e inicialização:

// Criando um Array vazio de Strings
var nomesDevs: [String] = []
// Ou usando a sintaxe de inicializador
var equipeBackend = [String]()

// Criando um Array já com valores (tipo inferido como [String])
let equipeRocketseat = ["Diego", "Mayk", "Rodrigo", "Mayk"] // Note que "Mayk" aparece duas vezes!

// Criando um Array de Inteiros
var versoesSwift: [Int] = [1, 2, 3, 4, 5]

// Criando um Array com um valor padrão repetido
var tarefasStatus = Array(repeating: false, count: 5) // [false, false, false, false, false]

Acessando elementos:

let primeiroDev = equipeRocketseat[0] // "Diego"
let terceiroDev = equipeRocketseat[2] // "Rodrigo"

// Cuidado! Acessar um índice que não existe causa um erro (crash).
// Exemplo: let quintoDev = equipeRocketseat[4] // Isso causaria um erro!

// Para acessar o primeiro ou último de forma segura (retorna Optional)
if let ultimoDev = equipeRocketseat.last {
    print("O último dev da lista é: \(ultimoDev)") // Imprime "Mayk"
}

if let primeiroDevSeguro = equipeRocketseat.first {
    print("O primeiro dev é: \(primeiroDevSeguro)") // Imprime "Diego"
}

Adicionando elementos:

var alunos: [String] = ["Laís"]

// Adiciona no final
alunos.append("Fernanda") // ["Laís", "Fernanda"]

// Insere em uma posição específica
alunos.insert("Isabela", at: 1) // ["Laís", "Isabela", "Fernanda"]

// Adiciona múltiplos elementos de outra sequência
let novosAlunos = ["Mayk", "Rodrigo"]
alunos += novosAlunos // ["Laís", "Isabela", "Fernanda", "Mayk", "Rodrigo"]

Removendo elementos:

// Remove pelo índice (e retorna o elemento removido)
let alunaRemovida = alunos.remove(at: 2) // Remove "Fernanda"
print("Aluna removida: \(alunaRemovida)")
print(alunos) // ["Laís", "Isabela", "Mayk", "Rodrigo"]

// Remove o último elemento
let ultimoAlunoRemovido = alunos.removeLast() // Remove "Rodrigo"
print(alunos) // ["Laís", "Isabela", "Mayk"]

// Remove todos os elementos
// alunos.removeAll()
// print(alunos) // []

Modificando elementos:

var frameworks = ["React", "Vue", "Node.js"]
frameworks[1] = "Angular" // Substitui "Vue" por "Angular"
print(frameworks) // ["React", "Angular", "Node.js"]

Operações comuns:

// Quantidade de elementos
print("Total de alunos: \(alunos.count)") // 3

// Verificar se está vazio
if alunos.isEmpty {
    print("Nenhum aluno na lista.")
} else {
    print("Temos alunos cadastrados!")
}

// Iterar sobre os elementos
print("\nAlunos presentes:")
for aluno in alunos {
    print("- \(aluno)")
}

print("\nAlunos com forEach:")
alunos.forEach { aluno in
    print("* \(aluno)")
}

// Transformar elementos (map)
let nomesAlunosMaiusculos = alunos.map { $0.uppercased() }
print(nomesAlunosMaiusculos) // ["LAÍS", "ISABELA", "MAYK"]

// Filtrar elementos (filter)
let nomesComA = alunos.filter { $0.lowercased().contains("a") }
print(nomesComA) // ["Laís", "Isabela", "Mayk"] (Considerando 'a' minúsculo)

Sets em Swift: a coleção de elementos únicos (Set<Element>)

O que é um Set?

Declaração e inicialização:

// Criando um Set vazio de Strings
var emails: Set<String> = []
// Ou usando a sintaxe de inicializador
var tags = Set<String>()

// Criando um Set com valores (tipo inferido como Set<String>)
// Note que "Swift" é adicionado duas vezes, mas só aparecerá uma vez no Set!
var tecnologias: Set = ["Swift", "React Native", "Node.js", "Swift", "Kotlin"]
print(tecnologias) // A ordem pode variar! Ex: ["React Native", "Node.js", "Swift", "Kotlin"]

Adicionando elementos:

let resultadoInsert = tecnologias.insert("TypeScript")
print("TypeScript foi inserido? \(resultadoInsert.inserted)") // true
print("Elemento após inserir: \(resultadoInsert.memberAfterInsert)") // "TypeScript"
print(tecnologias) // Agora inclui "TypeScript"

// Tentando inserir um elemento que já existe
let resultadoRepetido = tecnologias.insert("Swift")
print("Swift (repetido) foi inserido? \(resultadoRepetido.inserted)") // false
print(tecnologias) // O Set não mudou

Removendo elementos:

// Remove um elemento específico (retorna o elemento se ele existia, ou nil)
if let tecnologiaRemovida = tecnologias.remove("Node.js") {
    print("\(tecnologiaRemovida) foi removida do Set.")
} else {
    print("Node.js não estava no Set.")
}
print(tecnologias)

// Remove todos os elementos
// tecnologias.removeAll()

Verificando pertinência (membership):

if tecnologias.contains("Swift") {
    print("Sim, dominamos Swift aqui na Rocketseat! 🚀")
}

if !tecnologias.contains("Ruby") {
    print("Ruby não está no nosso Set... ainda!")
}

Operações de conjuntos:

let stackDiego: Set = ["Node.js", "React", "React Native", "PostgreSQL"]
let stackMayk: Set = ["Node.js", "Elixir", "Phoenix", "PostgreSQL"]

// União: Todos os elementos de ambos os Sets, sem duplicatas
let skillsCombinadas = stackDiego.union(stackMayk)
print("Skills combinadas: \(skillsCombinadas)")
// Ex: ["React", "Node.js", "Elixir", "React Native", "Phoenix", "PostgreSQL"]

// Interseção: Elementos que existem EM AMBOS os Sets
let skillsEmComum = stackDiego.intersection(stackMayk)
print("Skills em comum: \(skillsEmComum)")
// Ex: ["Node.js", "PostgreSQL"]

// Subtração: Elementos que estão no primeiro Set, MAS NÃO no segundo
let skillsSoDoDiego = stackDiego.subtracting(stackMayk)
print("Skills que só o Diego tem (nesta comparação): \(skillsSoDoDiego)")
// Ex: ["React", "React Native"]

// Diferença Simétrica: Elementos que estão em um OU no outro, MAS NÃO EM AMBOS
let skillsExclusivas = stackDiego.symmetricDifference(stackMayk)
print("Skills exclusivas de cada um: \(skillsExclusivas)")
// Ex: ["React", "Elixir", "React Native", "Phoenix"]

Iteração:

print("\nTecnologias no Set (ordem indefinida):")
for tech in tecnologias {
    print("- \(tech)")
}

// Para iterar em ordem, use sorted()
print("\nTecnologias no Set (ordenadas):")
for tech in tecnologias.sorted() {
    print("- \(tech)")
}

Array vs. Set

Use um Array quando:

• ✅ A ordem dos elementos importa: como os passos de um tutorial, a sequência de telas visitadas ou uma lista de tarefas a fazer.

• ✅ Você precisa acessar elementos pela posição (índice) frequentemente.

• ✅ Elementos duplicados são permitidos e fazem sentido: como uma lista de todas as notas de um aluno ou todos os logins de um usuário.

Use um Set quando:

• ✅ A unicidade dos elementos é a chave: como garantir que um usuário não possa curtir o mesmo post duas vezes, ou armazenar uma lista de tags únicas para um artigo.

• ✅ A ordem dos elementos não é relevante.

• ✅ Você precisa verificar rapidamente se um item existe na coleção: como checar se um usuário tem uma determinada permissão ou se uma palavra já foi adicionada a um dicionário.

• ✅ Você precisa realizar operações de conjunto (união, interseção, etc.).

Indo além: coleções e a sua jornada no iOS com Swift

Conclusão:

• Arrays: para quando a ordem importa e duplicatas são aceitáveis. Acesso rápido por índice, vale reforçar que isso vale quando o índice é conhecido. Em buscas por valor, o custo é O(n).

• Sets: para quando a unicidade é crucial, a ordem não importa, e você precisa de velocidade na verificação de existência ou em operações de conjunto.

Lembre-se: escolher a coleção certa não é apenas um detalhe técnico; é um passo fundamental para escrever código mais limpo, mais eficiente e mais fácil de manter. É pensar na performance e na lógica da sua aplicação desde a base.