Quais são as formas de lidar com opcionais na linguagem Swift?

Desempacotamento forçado:

// Usa ! se estiver seguro de que o opcional contém um valor.
let optionalValue: String? = "olá"
let unwrappedValue = optionalValue! // Perigoso, pode causar crash se o valor for nil

Ligação opcional (if let, guard let):

// if let - executa o bloco de código se o opcional não for nil.
if let value = optionalValue {
    print(value)
}

// guard let - usado para sair cedo de uma função ou bloco se o opcional for nil.
func processValue(_ value: String?) {
    guard let unwrappedValue = value else {
        print("Valor é nil")
        return
    }
    print(unwrappedValue)
}

Encadeamento opcional:

// Permite chamar métodos, propriedades ou subscript de forma segura em valores opcionais.
struct Company {
    var address: Address?
}

struct Address {
    var street: String?
}

let company: Company? = Company(address: Address(street: "Main Street"))
let street = company?.address?.street // O resultado será uma String opcional?

Operador de coalescência nula (??):

// Fornece um valor padrão se o opcional for nil.
let name: String? = nil
let displayName = name ?? "Anónimo" // Se name for nil, displayName será "Anónimo"

Opcional implícito desembrulhado:

// Detectado com ! após o tipo. O compilador não requer desembrulhamento explícito, mas pode causar crash se nil.
let implicitlyUnwrappedString: String! = "isto é uma string"
print(implicitlyUnwrappedString.count) // Não requer ! para acessar membros

Usando if case let com correspondência de padrão:

// Método mais avançado para verificar enums com valores associados, incluindo opcionais.
enum Result {
    case success(String)
    case failure
}

let result: Result? = .success("Operação concluída")

if case let .success(message)? = result {
    print("Sucesso com mensagem: \(message)")
}