Optional en Swift: distingue nil, texto vacío y cero

nil, una cadena vacía y cero son estados distintos. Sustituir todo opcional por un valor predeterminado puede borrar la diferencia entre no escribir nada e introducir cero. Decide antes si la ausencia es un valor normal o un estado separado.

Mecanismo y decisión de diseño

Optional representa presencia con some y none. Usa if let para uso condicional local, guard let para salida temprana y ?? si existe un valor predeterminado adecuado. El encadenamiento devuelve nil al faltar un enlace; el desempaquetado forzado falla con nil y no sirve para errores de entrada esperados. Fuente primaria

Código reproducible

quantity devuelve casos enum distintos para ausencia, entrada inválida y cantidad válida. Se prueban nil, texto vacío, cat, -1, 0 y 7. Una función cuenta las evaluaciones del valor alternativo de ??, y se comparan los conteos de cadenas vacías y ausentes.

Este ejemplo independiente se ejecutó el 2026-10-23 con Apple Swift 6.4 para arm64 macOS, en modo de lenguaje Swift 6. No necesita red ni paquetes adicionales.

Descargar el archivo Swift completo

Ejecuta el comando en la carpeta de descarga. Las precondiciones detienen la ejecución si falla una comprobación. No uses -Ounchecked: elimina estas comprobaciones.

swift -swift-version 6 swift-optional-enum-unwrapping.swift

enum Quantity: Equatable { case missing, invalid, value(Int) }
func quantity(_ raw: String?) -> Quantity {
    guard let raw else { return .missing }
    guard let value = Int(raw), value >= 0 else { return .invalid }
    return .value(value)
}

let cases: [(String?, Quantity)] = [
    (nil, .missing), ("", .invalid), ("cat", .invalid),
    ("-1", .invalid), ("0", .value(0)), ("7", .value(7))
]
for (raw, expected) in cases { precondition(quantity(raw) == expected) }

var fallbackCalls = 0
@MainActor func fallback() -> Int { fallbackCalls += 1; return 99 }
let present: Int? = 0
let absent: Int? = nil
precondition((present ?? fallback()) == 0 && fallbackCalls == 0)
precondition((absent ?? fallback()) == 99 && fallbackCalls == 1)

let empty: String? = ""
let missing: String? = nil
precondition(empty?.count == 0 && missing?.count == nil)
print("inputs=6 missing=1 invalid=3 valid=2 fallback-calls=1 empty-count=0 missing-count=nil")

Salida registrada e interpretación

inputs=6 missing=1 invalid=3 valid=2 fallback-calls=1 empty-count=0 missing-count=nil

Se distingue una entrada ausente, tres inválidas y dos válidas. some(0) no llama al valor alternativo; none lo llama una vez. La cadena vacía tiene count 0; encadenar sobre una ausente produce nil. Un valor cero no significa ausencia.

Alcance y limitaciones

Este validador rechaza cantidades negativas; no define toda política de entrada numérica. Añade espacios, decimales, formato regional y máximos según requisitos. String! también puede desempaquetarse implícitamente cuando el contexto lo exige, no obligatoriamente en cada uso.

Qué comprobar después

Decide si ausencia e invalidez necesitan mensajes distintos y respeta el contrato del servidor. Si el llamador necesita causas más precisas, conserva el error con throws o Result en lugar de sustituirlo silenciosamente por un valor predeterminado.

Experimento relacionado

Fuentes y verificación

• The Swift Programming Language: The BasicsSwift.org · Documentación oficial · Consultado 23 de octubre de 2026Respalda: Fuente del contrato de implementación y de la explicación. La salida se comprobó por separado con el experimento incluido aquí.