Vistas de la cadena: escalares, UTF-8 y UTF-16

Si el grafema es la unidad que ve el usuario, tarde o temprano necesitarás las unidades que ven las otras partes del sistema: el protocolo de red que cuenta bytes, la tabla de Unicode que clasifica puntos de código, el marco de texto de Apple que mide en unidades de dieciséis bits. Swift no te obliga a elegir una sola vez ni a convertir la cadena para bajar de nivel. Expone la misma memoria a través de varias colecciones distintas, todas ellas proyecciones sin copia, y comparte entre ellas el mismo tipo de índice. Aprender a moverte entre esas alturas, y sobre todo a saber en cuál estás, es lo que separa el código que funciona con texto real del que funciona con ejemplos en inglés.

Una cadena, cuatro alturas

Un String no contiene cuatro copias de nada. Contiene un buffer de bytes en UTF-8, y cada vista es un tipo envoltorio que reinterpreta ese mismo buffer con otra unidad de iteración. Character agrupa escalares en clusters; unicodeScalars expone los puntos de código decodificados; utf8 expone los bytes tal cual están; utf16 los recodifica al vuelo. Crear cualquiera de estas vistas cuesta tiempo constante, y todas comparten el tipo String.Index, de modo que una posición obtenida en una vista puede usarse en otra.

let s = "Ñu🚀"

print(Array(s))                      // ["Ñ", "u", "🚀"]
print(Array(s.unicodeScalars))       // ["Ñ", "u", "🚀"] como escalares
print(Array(s.utf8))                 // [195, 145, 117, 240, 159, 154, 128]
print(Array(s.utf16))                // [209, 117, 55357, 56960]

print(s.count, s.unicodeScalars.count, s.utf8.count, s.utf16.count)
// 3 3 7 4

El emoji ilustra el punto entero: es un grafema, es un escalar, son cuatro bytes en UTF-8 y son dos unidades en UTF-16 porque su valor supera el plano básico y necesita un par sustituto. Cualquier código que trate esos cuatro números como intercambiables está roto; lo que cambia entre lenguajes es solo cuándo te enteras.

flowchart TD
ST[String con buffer UTF8] --> CH[Characters o grafemas]
ST --> US[unicodeScalars]
ST --> U8[utf8 vista nativa]
ST --> U16[utf16 vista recodificada]
CH --> IX[String Index compartido]
US --> IX
U8 --> IX
U16 --> IX

Que el índice sea compartido no significa que cualquier posición exista en todas las vistas. Un índice tomado en la vista de bytes puede caer en mitad de un escalar, y ese punto no corresponde a ninguna posición de la vista de grafemas. La biblioteca lo modela con una conversión que devuelve opcional: si la posición coincide con una frontera de la vista destino, obtienes el índice equivalente; si no, obtienes nulo y sabes que estabas mirando dentro de una unidad.

let s = "aé🚀"
let i = s.utf8.index(s.utf8.startIndex, offsetBy: 2)

print(i.samePosition(in: s.unicodeScalars) != nil)   // true, frontera de escalar
print(i.samePosition(in: s) != nil)                  // true, frontera de grafema

let dentro = s.utf8.index(after: i)
print(dentro.samePosition(in: s) == nil)             // true, cae dentro de un escalar

Escalares: donde vive Unicode

El estándar Unicode no define propiedades sobre grafemas ni sobre bytes: las define sobre puntos de código. Si necesitas saber si algo es una letra, un dígito, un signo de puntuación, una marca combinante o un emoji, la pregunta se hace en la vista de escalares, porque es la única altura donde el estándar tiene algo que decir. Unicode.Scalar.Properties expone ese catálogo completo, y es la herramienta correcta para escribir validadores que no sean ingenuos.

for escalar in "a1é🚀".unicodeScalars {
  let p = escalar.properties
  print(escalar, escalar.value, p.isAlphabetic, p.generalCategory, p.isEmoji)
}

// Construir un escalar a partir de un valor puede fallar:
// los sustitutos no son escalares validos
let valido = Unicode.Scalar(0x1F680)     // opcional con valor
let invalido = Unicode.Scalar(0xD800)    // nil

// Normalizacion explicita cuando el formato importa
let compuesta = "e\u{0301}".precomposedStringWithCanonicalMapping
print(compuesta.unicodeScalars.count)    // 1

Fíjate en el inicializador que devuelve opcional. No todos los enteros de veintiún bits son escalares: el rango de sustitutos está reservado para la codificación UTF-16 y Unicode lo declara inválido como punto de código. Swift lo modela con un opcional en lugar de aceptar el valor y explotar más tarde, que es exactamente la política que aplica en el resto del lenguaje.

UTF-8 es la representación nativa

Desde Swift 5, el almacenamiento interno de String es UTF-8. El cambio fue algo más que una optimización: alineó el tipo con el formato dominante de archivos, redes y sistemas de archivos, eliminó una transcodificación en el camino más frecuente y abarató radicalmente la entrega de bytes a una API en C. La consecuencia práctica es que utf8 no es una vista de conveniencia sino la vista barata, y que hay operaciones que ofrecen acceso directo al buffer sin copiar.

var texto = "cabecera"

texto.withUTF8 { buffer in
  enviarPorLaRed(buffer)        // sin copia, buffer contiguo garantizado
}

// De bytes a cadena, reparando lo invalido con el caracter de reemplazo
let bytes: [UInt8] = [0x68, 0x69, 0xFF]
let reparada = String(decoding: bytes, as: UTF8.self)
print(reparada)                  // hi seguido del rombo de reemplazo

// De bytes a cadena, rechazando lo invalido
if let estricta = String(validating: bytes, as: UTF8.self) {
  print(estricta)
} else {
  print("secuencia invalida")
}

La diferencia entre esos dos inicializadores es la diferencia entre una interfaz de usuario y un analizador de protocolo. El que repara nunca falla y sustituye cada secuencia mal formada por el carácter de reemplazo, que es lo que quieres para mostrar algo antes que nada; el que valida devuelve opcional y te deja decidir, que es lo que quieres cuando unos bytes corruptos significan que la trama entera es sospechosa. Elegir el primero por costumbre convierte errores de transmisión en rombos silenciosos.

UTF-16, el puente que no se ha ido

UTF-16 no está ahí por gusto. Es la representación de NSString, y con ella la de NSRange, NSAttributedString, NSRegularExpression, TextKit y buena parte del ecosistema de Apple. Mientras exista una sola API en Objective-C que reciba longitudes o rangos, la vista utf16 es la moneda de cambio, y mezclar sus posiciones con las de Swift es la causa número uno de cortes a mitad de emoji en aplicaciones reales.

let s = "Hola 🚀 mundo"

// De un rango de Swift a NSRange y vuelta, sin aritmetica manual
if let rango = s.range(of: "mundo") {
  let ns = NSRange(rango, in: s)
  if let devuelta = Range(ns, in: s) {
    print(s[devuelta])           // mundo
  }
}