Principais erros de desenvolvedores Swift iniciantes e como evitá-los

Introdução

Swift é uma linguagem de programação poderosa e intuitiva da Apple que está ganhando rapidamente popularidade entre desenvolvedores iOS e macOS. No entanto, mesmo com sua sintaxe elegante e tipagem forte, iniciantes frequentemente cometem os mesmos erros. Neste artigo, vamos detalhar os 4 erros mais comuns cometidos por desenvolvedores Swift iniciantes e mostrar como evitá-los. Você aprenderá a trabalhar corretamente com optionals, evitar vazamentos de memória, gerenciar closures e não confundir structs com classes.

1. Uso Excessivo de Force Unwrapping

Um dos erros mais comuns é usar o ponto de exclamação ! para forçar o desempacotamento de optionals. Isso pode causar uma falha no programa se o valor for nil.

Exemplo do erro:

let optionalString: String? = nilprint(optionalString!) // Erro fatal: nil encontrado inesperadamente ao desempacotar um valor Optional

Como corrigir:

Use métodos seguros de desempacotamento: if let, guard let ou o operador ?? (nil-coalescing).

// Desempacotamento seguro com if letif let unwrappedString = optionalString {    print(unwrappedString)} else {    print("A String é nil")}

// Ou usando guard let em uma funçãofunc printString(_ str: String?) {    guard let safeString = str else { return }    print(safeString)}

// Usando nil-coalescinglet result = optionalString ?? "Valor padrão"print(result)

Dica: Use ! apenas em casos onde você tem absoluta certeza de que o valor não é nil (por exemplo, ao trabalhar com IBOutlet no UIKit após a view ter sido carregada).

2. Ignorando Gerenciamento de Memória e Vazamentos em Closures

Swift usa Contagem Automática de Referências (ARC) para gerenciamento de memória. No entanto, closures podem criar ciclos de referência fortes se você não usar weak ou unowned.

Exemplo de vazamento de memória:

class ViewController: UIViewController {    var closure: (() -> Void)?        func setupClosure() {        closure = {            // Referência forte a self            self.view.backgroundColor = .red        }    }}

Neste exemplo, a closure captura self fortemente, e self (ViewController) mantém a closure. Isso cria um ciclo de referência.

Como corrigir:

class ViewController: UIViewController {    var closure: (() -> Void)?        func setupClosure() {        closure = { [weak self] in            guard let self = self else { return }            self.view.backgroundColor = .red        }    }}

Dica: Sempre use [weak self] em closures que possam sobreviver ao objeto. Se o objeto tiver garantia de viver mais que a closure, você pode usar [unowned self], mas tome cuidado — acessar um objeto desalocado causará uma falha.

3. Uso Incorreto de Structs e Classes

Iniciantes frequentemente não entendem a diferença entre structs (tipos de valor) e classes (tipos de referência), o que leva a bugs inesperados.

Erro típico:

struct User {    var name: String    var age: Int}

class UserManager {    var user = User(name: "João", age: 25)        func updateUser() {        var newUser = user        newUser.name = "Pedro"        // user.name continua sendo "João" — a struct foi copiada!        print(user.name) // João    }}

Se você esperava que a alteração afetasse o objeto original, estava enganado. Structs são passadas por valor.

Como corrigir:

Use uma classe se precisar de estado compartilhado. Use uma struct