¿Cuáles son las formas de manejar opcionales en el lenguaje Swift?

Desempaquetado forzado:

// Se usa ! si estás seguro de que el opcional contiene un valor.
let optionalValue: String? = "hola"
let unwrappedValue = optionalValue! // Peligroso, puede causar un crash si el valor es nil

Vinculación opcional (if let, guard let):

// if let - ejecuta el bloque de código si el opcional no es nil.
if let value = optionalValue {
    print(value)
}

// guard let - se usa para salir temprano de la función o bloque si el opcional es nil.
func processValue(_ value: String?) {
    guard let unwrappedValue = value else {
        print("El valor es nil")
        return
    }
    print(unwrappedValue)
}

Encadenamiento opcional:

// Permite llamar de forma segura a métodos, propiedades o subíndices en valores opcionales.
struct Company {
    var address: Address?
}

struct Address {
    var street: String?
}

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

Operador de fusión nula (??):

// Proporciona un valor por defecto si el opcional es nil.
let name: String? = nil
let displayName = name ?? "Anónimo" // Si name es nil, displayName será "Anónimo"

Opcionales implícitamente desempaquetados:

// Se detectan con ! después del tipo. El compilador no requiere desempaquetado explícito, pero puede causar un crash si es nil.
let implicitlyUnwrappedString: String! = "esto es una cadena"
print(implicitlyUnwrappedString.count) // No requiere ! para acceder a los miembros

Uso de if case let con coincidencia de patrones:

// Método más avanzado para verificar enums con valores asociados, incluyendo opcionales.
enum Result {
    case success(String)
    case failure
}

let result: Result? = .success("Operación completada")

if case let .success(message)? = result {
    print("Éxito con mensaje: \(message)")
}