Nueva vida de las cadenas en Swift: adiós, substring, hola, slicing

Cómo dejar de temer a lo obsoleto y amar el slicing en Swift

Si alguna vez has escrito código en Swift e intentado extraer una parte de una cadena, seguramente te has topado con este mensaje aterrador: 'substring(to:)' is deprecated: Please use String slicing subscript with a 'partial range from' operator. ¿Suena como una sentencia? En realidad, es una invitación a un mundo nuevo, más seguro y potente para trabajar con cadenas. Analicemos qué sucedió, por qué Apple decidió cambiar la API habitual y cómo "cortar" cadenas correctamente ahora en Swift 4 y versiones posteriores.

¿Por qué substring quedó en el pasado?

El viejo y querido substring(to:) funcionaba, pero... no era muy inteligente. Devolvía un nuevo objeto Substring que, en esencia, era solo una "ventana" a la cadena original. Esto generaba confusión: pensabas que estabas trabajando con una cadena independiente, pero en realidad mantenías una referencia a la memoria antigua. En Swift 4 decidieron poner orden: ahora todas las operaciones con subcadenas devuelven el tipo Substring, y para obtener una cadena completa debes convertir explícitamente el resultado. ¿Suena más complicado? En la práctica, es mucho más claro y seguro.

Conoce: String slicing subscript

El nuevo enfoque utiliza subíndices (subscripts) y rangos (ranges). En lugar de los métodos substring(to:), substring(from:) y substring(with:), ahora escribes código que se parece a trabajar con arreglos. Aquí tienes una analogía básica:

let fullString = "¡Hola, mundo!"// Forma antigua (obsoleta)// let oldResult = fullString.substring(to: fullString.index(fullString.startIndex, offsetBy: 6))

// Nueva formalet newResult = fullString[..<fullString.index(fullString.startIndex, offsetBy: 6)]print(newResult) // "¡Hola"

¿Ves el operador ..<? Ese es el famoso partial range from operator — un rango parcial "desde el inicio hasta el índice indicado, sin incluirlo". ¿Poderoso? Sin duda.

Los tres pilares del nuevo enfoque: from, to, through

Analicemos los tres escenarios principales que antes cubrían los métodos substring.

1. substring(to:) → prefix(upTo:) o rango parcial

¿Quieres tomar todo hasta un índice determinado? Usa ..< (half-open range) o el método prefix(upTo:):

let str = "Hola, Swift"let index = str.firstIndex(of: ",") ?? str.endIndex

// Opción con subíndicelet result1 = str[..<index]print(result1) // "Hola"

// Opción con métodolet result2 = str.prefix(upTo: index)print(result2) // "Hola"

2. substring(from:) → suffix(from:) o rango parcial

¿Necesitas tomar todo desde un índice hasta el final? Usa ... (closed range) omitiendo el inicio:

let startIndex = str.index(str.startIndex, offsetBy: 5)let result3 = str[startIndex...]print(result3) // "Swift"

// O mediante el métodolet result4 = str.suffix(from: startIndex)print(result4) // "Swift"

3. substring(with:) → rango normal

¿Quieres extraer un fragmento específico? Simplemente indica el rango:

let range = str.index(str.startIndex, offsetBy: 5)..<str.endIndexlet result5 = str[range]print(result5) // "Swift"

// O mediante closed rangelet closedRange = str.index(str.startIndex, offsetBy: 5)...str.index(before: str.endIndex)let result6 = str[closedRange]print(result6) // "Swift"

Ten en cuenta: todas estas operaciones devuelven Substring, no String. Si necesitas una cadena completa, simplemente envuelve el resultado en String():

let newString = String(result1)print(type(of: newString)) // String

¿Y qué pasa con prefix y suffix? ¡No están obsoletos!

Sí, los métodos prefix(_:), suffix