Structs em Swift: guia completo para iniciantes

O que são structs em Swift

Sintaxe básica das structs

struct DevRocketseat {
    let nome: String       // propriedade constante (não muda após inicialização)
    var stack: String      // propriedade variável (pode mudar depois)
    var experiencia: Int   // anos de experiência ou nível do desenvolvedor
}

Criando e usando instâncias

var dev = DevRocketseat(nome: "Diego", stack: "Mobile iOS", experiencia: 5)
// Usamos o "memberwise initializer" gerado automaticamente.

// Acessando propriedades:
print(dev.nome)         // Diego
print(dev.stack)        // Mobile iOS

// Modificando uma propriedade (porque "dev" é var e stack é var):
dev.stack = "Fullstack"
// dev.nome = "Diego Fernandes" // Isto seria erro, pois nome é let (imutável)

// Depois da modificação:
print(dev.stack)        // Fullstack

A mágica do tipo por valor

var dev1 = DevRocketseat(nome: "Mayk", stack: "Mobile", experiencia: 3)
var dev2 = dev1  // Aqui, dev2 recebe uma CÓPIA de dev1

// Vamos modificar dev2.stack:
dev2.stack = "Data Science"

// Valores atuais:
print(dev1.stack)  // Mobile
print(dev2.stack)  // Data Science

Adicionando comportamento com métodos

struct DevRocketseat {
    let nome: String
    var stack: String
    var experiencia: Int

    // Método não-mutante (não altera o estado)
    func saudacao() {
        print("Oi! Eu sou \(nome) e trabalho com \(stack).")
    }

    // Método mutante (altera o estado da struct)
    mutating func concluirProjeto() {
        experiencia += 1
        print("Projeto concluído! \(nome) agora tem \(experiencia) de experiência.")
    }
}

var devMayk = DevRocketseat(nome: "Mayk", stack: "Mobile", experiencia: 2)
devMayk.saudacao()        // Chama método normal
devMayk.concluirProjeto() // Chama método que altera o estado
print(devMayk.experiencia) // 3 (valor foi incrementado pelo método mutante)

Structs vs. classes em Swift

Quando usar structs e quando usar classes

Quando optar por structs em Swift:

• Para dados relativamente simples e imutáveis, ou que representam um valor em si. Por exemplo, coordenadas (x,y), cores (r,g,b), ou mesmo modelos de dados como Usuario, Produto, etc., onde faz sentido cada instância ser independente. (Muitos exemplos de struct no Swift seguem essa ideia, inclusive os tipos básicos Int, String, Array e Dictionary são structs.)

• Quando você não precisa de herança ou hierarquia de tipos. Structs são ótimas para agrupar dados e comportamentos específicos sem a sobrecarga de um sistema de herança.

• Quando cópias são preferíveis a referências compartilhadas – isto é, você quer evitar efeitos colaterais. Se duas partes do código devem trabalhar com os mesmos dados sem interferir uma na outra, passar uma struct vai garantir isolamento.

• Para aproveitar a segurança de thread e consistência: structs imutáveis especialmente são thread-safe por natureza, pois não existe condição de corrida em algo que não muda. Múltiplas cópias podem ser manipuladas em paralelo sem problemas.

• Desempenho: structs são alocadas na stack (pilha) em vez de no heap, quando possível, o que costuma ser mais eficiente (menos carga de GC/ARC). Para tipos pequenos, isso traz benefícios de performance. Além disso, o Swift pode otimizar cópias de structs eliminando duplicações desnecessárias (copy-on-write é usado em coleções, por exemplo), tornando o uso de structs bastante eficiente na prática.

Quando optar por classes em Swift:

• Quando você precisa de herança ou polimorfismo. Se seu modelo naturalmente exige uma classe base e especializações (subclasses) que estendem ou modificam comportamento, então classe é a escolha (já que struct não permite herança). Por exemplo: estruturas de dados hierárquicas, modelos em que faz sentido um tipo ser substituível por outro em tempo de execução.

• Quando é necessário que múltiplas partes do código compartilhem a mesma instância e reflitam mudanças umas para as outras. Ou seja, um caso de estado compartilhado. Por exemplo, um objeto único de configuração da aplicação, ou um controlador que várias telas acessam – cenários onde ter cópias separadas causaria inconsistências. Nesse caso, classes (referência) fazem sentido. (Mas lembre-se: estado compartilhado demais pode aumentar complexidade e exigir sincronização de mudanças.)

• Interoperabilidade com código Objective-C ou frameworks do iOS que exigem classes. Muitos elementos do UIKit/AppKit são classes (UIView, UIViewController, etc.), e espera-se que você os subclassifique para customizar comportamento. Se você está trabalhando com APIs que pedem herdar de uma classe específica ou usar referências (delegates tradicionais, por exemplo), não há muito o que fazer: use classes.

• Quando você precisa de algum recurso específico de classes, como identidade única (por exemplo, implementar um pattern Singleton ou comparar objetos pelo ponteiro), ou um deinit para liberar recursos externos (arquivos, sockets) quando o objeto for desalocado.

• Em alguns casos de desempenho ou design, pode ser preferível usar classe para evitar cópias muito custosas. Por exemplo, se seu objeto carrega um grande volume de dados que seria pesado duplicar em memória, uma classe permite passar apenas a referência. (Entretanto, avalie bem – copiar por valor às vezes é menos custoso do que parece, graças a otimizações do Swift.)

Boas práticas com structs

• Imutabilidade é sua amiga: sempre que possível, defina as propriedades de uma struct como let (imutáveis). Isso faz com que cada instância seja criada já com valores que não mudarão, tornando seu código mais previsível e seguro. No nosso exemplo DevRocketseat, fizemos nome como let porque não esperamos que o nome mude – essa decisão de design previne alterações acidentais. Além disso, tente manter instâncias de struct também como constantes (let) sempre que não precisar modificá-las. Imutabilidade elimina uma classe de bugs relacionados a estado variando ao longo do tempo. Caso precise mudar alguma propriedade, então sim, use var, mas conscientemente. Lembre-se: em Swift, valor imutável até que precise ser mutável é um mantra importante.

• Conformar a protocolos úteis: structs podem adotar protocolos para ganhar funcionalidades extras ou se adequar a certas interfaces. Três protocolos muito úteis são Equatable, Codable e Hashable:
• Equatable: permite comparar duas instâncias da sua struct com o operador ==. Ao conformar sua struct a Equatable, o Swift (desde Swift 4.1) geralmente consegue sintetizar automaticamente a implementação do ==, comparando todas as propriedades para você. Ou seja, basta declarar struct DevRocketseat: Equatable { ... } que você já pode fazer dev1 == dev2 para verificar se todas as propriedades são iguais, sem escrever uma linha de código extra. É uma boa prática tornar structs Equatable quando fizer sentido compará-las – isso “as faz se comportar como valores”, assim como tipos básicos (por exemplo, você espera que dois Ints possam ser comparados com ==, o mesmo deve valer para duas instâncias de um modelo seu).
• Codable: possibilita facilmente codificar/decodificar a struct para formatos externos, como JSON. Marcando sua struct como Codable (que é basicamente Encodable & Decodable), o Swift também gera automaticamente o código para converter suas propriedades para JSON e vice-versa, desde que todos os tipos internos também sejam Codable. Isso é super útil para enviar/receber dados de APIs ou salvar configurações. Por exemplo, você poderia converter um DevRocketseat em um dicionário/JSON para enviar a um servidor ou persistir localmente, tudo isso com pouquíssimo esforço graças ao Codable.
• Hashable: faz com que a struct possa ser usada em contextos que requerem hashing, como chaves de Dictionary ou elementos de um Set. Assim como Equatable, o Hashable pode ser sintetizado automaticamente pelo compilador para suas structs. Basta declarar conformância e pronto – agora você pode colocar instâncias da sua struct em um conjunto ou usar como chave de dicionário sem implementar manualmente o cálculo de hash. (Detalhe: em Swift, ao marcar uma struct como Hashable, ela ganha Equatable automaticamente, pois é requisito.)
Esses protocolos aumentam o poder das suas structs sem muito trabalho. Como boa prática, avalie quais fazem sentido para cada novo tipo que você criar. Por exemplo, se você tem uma struct Podcast com propriedades título e host, talvez queira que ela seja Equatable (para saber se dois podcasts são iguais) e Codable (para facilmente salvar ou enviar seus dados). Adicionar isso é tão simples quanto adicionar : Equatable, Codable na declaração.

• Inicializadores customizados: Embora o Swift nos dê o memberwise initializer, muitas vezes é útil definir um init customizado para uma struct. Você pode querer adicionar alguma lógica de validação ou conveniência na criação dos objetos. Por exemplo, poderíamos querer impedir que experiencia seja negativa ao criar um DevRocketseat – poderíamos escrever um init que faz self.experiencia = max(0, experiencia) garantindo isso. Ou talvez fornecer um jeito de criar um DevRocketseat com valor default para experiência, facilitando a vida: init(nome: String, stack: String) { self.nome = nome; self.stack = stack; self.experiencia = 0 }. Inicializadores customizados tornam o uso da struct mais seguro e expressivo. Só tome cuidado: ao definir um init custom, o inicializador automático padrão deixa de ser gerado pelo Swift. Então, se você ainda quiser o memberwise initializer além do seu customizado, terá que implementá-lo manualmente ou usar uma extension para não sobrescrever completamente os inits gerados. Em resumo, use inicializadores customizados quando precisar garantir consistência dos dados ou oferecer formas alternativas de criar instâncias.

• Documentação e legibilidade: como structs muitas vezes representam modelos de dados importantes da sua aplicação, documente-as e nomeie propriedades claramente. Dê preferência a nomes descritivos e, se necessário, adicione comentários ou use a sintaxe de documentação do Swift para explicar partes não óbvias. Assim como fizemos nos exemplos, deixar claras as intenções (o que é constante, o que pode mudar, o significado de cada propriedade) ajuda outros desenvolvedores – e você no futuro – a entenderem o código rapidamente.

Conclusão

• Structs são tipos por valor: cada instância carrega seus próprios dados, e cópias são independentes. Vimos como isso previne efeitos colaterais, pois alterar uma instância não afeta outra cópia.

• Classes são tipos por referência: instâncias compartilhadas, onde múltiplas referências apontam para o mesmo objeto. Útil para certos cenários, mas exige cuidado com compartilhamento de estado.

• Aprendemos a sintaxe de declaração de uma struct, a usar propriedades let e var de forma apropriada, e a criar instâncias usando o memberwise initializer automático. Também vimos como modificar propriedades (ou não modificar, no caso de constantes).

• Praticamos com métodos, incluindo o uso do mutating para permitir que uma struct modifique seu próprio estado dentro de um método – entendendo a diferença de mutabilidade entre structs e classes.

• Comparando Struct vs Classe, destacamos as principais diferenças: semântica de valor vs referência, imutabilidade, herança, inicialização e gerenciamento de memória.

• Discutimos quando usar structs e quando usar classes. A recomendação geral é começar com struct e só recorrer a classe se houver motivo forte.

• Por fim, listamos boas práticas: favorecer imutabilidade, aproveitar protocolos como Equatable/Codable/Hashable para dar super poderes às structs, criar inicializadores customizados quando necessário e escrever código limpo e bem documentado.

Ah, e antes de terminar, um último recado importante:

Aprenda Swift e iOS na Rocketseat

• Aprendizado na prática: nada de teoria seca; você codifica apps de verdade, passo a passo, ganhando experiência do mundo real.

• Conteúdo 100% online e flexível: assista às aulas gravadas quando e onde quiser, no seu ritmo. Concilie os estudos com sua rotina numa boa.

• Tutoria e comunidade: conte com nosso time e a comunidade de devs para tirar dúvidas e receber aquele help nos desafios. Você nunca estará sozinho nessa jornada.

• Certificação reconhecida: ao final, conquiste um certificado de conclusão para turbinar seu portfólio.

• Diferenciais Rocketseat: metodologia focada em trabalho e colaboração, desafios práticos, eventos e networking com outros devs – uma experiência de aprendizado única.

Bora codar e alcançar altos voos no iOS!