Como passar na entrevista de Swift: principais perguntas e respostas

Introdução

A entrevista para a posição de desenvolvedor iOS/macOS não é apenas uma verificação de conhecimento dos frameworks UIKit ou SwiftUI. Em primeiro lugar, o empregador avalia sua compreensão da linguagem Swift: sua sintaxe, características de gerenciamento de memória, trabalho com multithreading e sistema de tipos. Mesmo que você escreva aplicativos com confiança, sem uma base teórica é fácil fracassar em uma entrevista técnica.

Neste artigo, reunimos as principais perguntas que são mais frequentemente feitas em entrevistas de Swift em 2025. Cada pergunta é acompanhada por uma explicação detalhada e um exemplo de código. O material será útil tanto para juniors quanto para desenvolvedores experientes que desejam atualizar seus conhecimentos.

1. Tipos Opcionais (Optionals) e Segurança

Por que o Swift usa Optionals?

Swift é uma linguagem com tipagem forte, e os tipos opcionais são seu recurso chave para trabalhar com segurança com nil. Diferente do Objective-C, onde nil é apenas um ponteiro nulo, em Swift Optional é uma enumeração (enum) com dois casos: none (nil) e some(Wrapped). Isso força o desenvolvedor a lidar explicitamente com a ausência de valor, prevenindo crashes.

Como extrair o valor de um Optional?

Existem várias maneiras:

• Force unwrapping — operador !. Usado apenas quando você tem certeza absoluta de que o valor não é nil.
• Optional binding — construção if let ou guard let.
• Nil-coalescing operator — ?? para definir um valor padrão.

var name: String? = "Alice"

// Force unwrapping (perigoso!)
print(name!)

// Optional binding
if let unwrappedName = name {
    print("Hello, \(unwrappedName)")
}

// Nil-coalescing
let displayName = name ?? "Guest"
print(displayName)

O que são Implicitly Unwrapped Optionals (IUO)?

É um tipo opcional que é extraído automaticamente quando acessado. É declarado com ! após o tipo. Usado principalmente para propriedades que são inicializadas após o init (por exemplo, IBOutlet no UIKit). No entanto, no Swift moderno (5.x), IUOs se comportam como Optionals comuns, e o compilador alerta sobre os riscos.

2. Gerenciamento de Memória: ARC e Ciclos de Referência Forte

Como o ARC funciona no Swift?

Automatic Reference Counting (ARC) é um mecanismo de contagem de referências. Cada instância de classe tem um contador de referências. Quando o contador cai para zero, o objeto é removido da memória. ARC funciona apenas com reference types (classes, closures). Value types (structs, enums) são armazenados na pilha e gerenciados por cópia.

O que é um ciclo de referência forte (retain cycle)?

Um ciclo ocorre quando dois objetos referenciam um ao outro através de referências fortes, e o ARC não consegue liberá-los. Isso leva a vazamentos de memória. A solução é usar referências fracas (weak) ou não possuídas (unowned).

class Person {
    let name: String
    var apartment: Apartment?
    init(name: String) { self.name = name }
    deinit { print("\(name) desalocado") }
}

class Apartment {
    let unit: String
    weak var tenant: Person?  // weak — previne o ciclo
    init(unit: String) { self.unit = unit }
    deinit { print("Apartamento \(unit) desalocado") }
}

var john: Person? = Person(name: "John")
var unit4A: Apartment? = Apartment(unit: "4A")

john?.apartment = unit4A
unit4A?.tenant = john

john = nil
unit4A = nil
// Ambos os objetos serão liberados

Quando usar weak e quando usar unowned?

• weak — sempre optional, torna-se automaticamente nil quando o objeto é liberado. Usado quando o tempo de vida da referência pode ser mais curto que o do proprietário.
• unowned — non-optional, pressupõe que o objeto viverá tanto ou mais. Perigoso: se o objeto for liberado, o acesso