Optional em Swift: diferencie nil, texto vazio e zero

nil, uma string vazia e zero são estados diferentes. Substituir todo opcional por um padrão pode apagar a diferença entre não informar nada e informar zero. Decida primeiro se a ausência deve virar um valor normal ou um estado separado.

Mecanismo e decisão de projeto

Optional representa presença com some e none. Use if let para uso condicional local, guard let para saída antecipada e ?? quando houver um padrão adequado. O encadeamento retorna nil se faltar um elo; o desembrulhamento forçado falha com nil e não serve para falhas de entrada esperadas. Fonte primária

Código reproduzível

quantity retorna casos enum separados para ausência, entrada inválida e quantidade válida. São testados nil, texto vazio, cat, -1, 0 e 7. Uma função conta as avaliações do fallback de ??, e verificações separadas comparam strings vazias e ausentes.

Este exemplo independente foi executado em 2026-10-23 com Apple Swift 6.4 para arm64 macOS, no modo de linguagem Swift 6. Não requer rede nem pacotes adicionais.

Baixar o arquivo Swift completo

Execute o comando na pasta do download. As precondições interrompem a execução se uma verificação falhar. Não use -Ounchecked: essa opção remove as verificações.

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")

Saída registrada e interpretação

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

O resultado distingue uma entrada ausente, três inválidas e duas válidas. some(0) não chama o fallback; none o chama uma vez. A string vazia tem count 0, enquanto o encadeamento sobre uma ausente resulta em nil. Zero não significa ausência.

Escopo e limitações

Este validador rejeita quantidades negativas; não define toda política de entrada numérica. Acrescente espaços, decimais, formatos regionais e limites conforme os requisitos. String! também pode ser desembrulhado implicitamente quando o contexto exige, não obrigatoriamente em todo uso.

O que verificar em seguida

Decida se ausência e entrada inválida precisam de mensagens diferentes e siga o contrato do servidor. Se o chamador precisa de causas mais detalhadas, preserve o erro com throws ou Result em vez de substituí-lo silenciosamente por um valor padrão.

Experimento relacionado

Fontes e verificação

• The Swift Programming Language: The BasicsSwift.org · Documentação oficial · Consultado 23 de outubro de 2026Evidência: Fonte do contrato de implementação e da explicação. A saída foi verificada separadamente com o experimento incluído aqui.