Home » Guías » Los cambios en Swift 3 (II): Subcadenas
Swift 3 Cambios (II)

Los cambios en Swift 3 (II): Subcadenas

Continuamos con nuestro especial sobre los cambios en Swift 3, explicando caso por caso, los cambios más importantes o significativos del lenguaje. Después de hablar en nuestra última entrega de GCD (Grand Central Dispatch) ahora vamos a hablar de subcadenas.

En esencia, una subcadena es el trozo de una cadena con la que podemos querer trabajar. Extraer, buscar, cortar… multitud de operaciones en una forma similar al trabajo con un array (ya que las cadenas no dejan de ser internamente un array de tipo carácter).

En Swift 2 se nos planteaba el problema de la obligación del uso de un tipo propio de la cadena para trabajar con las posiciones internas de la misma. En vez de usar valores enteros como en otros lenguajes, en Swift se usa un tipo de dato llamado String.Index que como tal es un tipo que forma parte del tipo en sí (un subtipo). En Swift 3 seguimos teniendo la obligación de usar este, pero la forma de trabajar con él ha variado y algo más cómoda.

Subcadenas en Swift 2

En la versión 2 teníamos que usar dos posibles métodos para obtener una subcadena desde el inicio o desde el fin de la misma, a saber substringFromIndex o substringToIndex, ambos métodos del tipo String. Como valor, al tener que pasar un tipo String.Index la única forma de construirlo era usar el método advancedBy que tenía el mismo tipo String.Index.

¿Y cómo creábamos un tipo de estas características? Usábamos las propiedades startIndex y endIndex de la propia cadena que devolvían las posiciones de inicio y fin respectivamente en un tipo String.Index, al que luego aplicábamos el método advancedBy del mismo para avanzar o retroceder en la cadena consiguiendo un tipo String.Index que pudiéramos devolver. Ciertamente, es un poco lioso. Veamos el ejemplo:

La cosa se volvía realmente compleja cuando queríamos extraer una subcadena a partir de un rango: de una posición x a una y, donde ni x ni y eran el inicio o fin de la cadena. Se usaba el método substringWithRange al que había que pasar un tipo Range que debíamos construir igualmente usando los tipos String.Index, las propiedades startIndex y endIndex, así como el método del tipo advancedBy.

Subcadenas en Swift 3

La cosa ahora cambia por tres motivos. El primero por el cambio en las nomenclaturas en esta nueva versión. Ya no hay tres métodos diferentes si no uno solo con diferentes nombres de parámetro. Ahora solo existe un único método llamado substring al que si llamamos con el parámetro to: devolverá desde el inicio de la cadena hasta la posición dada, con el parámetro from: desde la posición dada al final de la cadena y con with: devolverá el rango que le enviemos. Por lo tanto, como en otros cambios en Swift 3, pasamos de varios métodos a uno solo aplicando el polimorfismo, lo que es mucho más práctico.

El segundo gran cambio son los rangos. En Swift 3 no hay que usar el método Range para construirlos, porque se usan los operadores de rango y ..<. Estos permiten generar rangos y guardarlos en variables, sea cual sea el tipo de dato (siempre y cuando sea el mismo tipo de dato en ambos límites del rango). El tercer cambio es el método advancedBy que ya no existe. Ahora las cadenas tienen un método index con otros parámetros como offsetBy, before o after que cambia la forma de operar.

Por lo tanto, los ejemplos que hemos visto en Swift 2 quedarían de la siguiente forma en Swift 3:

Si hacemos uso de before o after, obtendremos la posición inmediatamente anterior o posterior al índice dado.

Más práctico, aproximadamente

El trabajo con subcadenas sigue siendo un poco engorroso en Swift por la obligación de usar el tipo String.Index, pero los añadidos y cambios en la versión 3 han mejorado sustancialmente la forma de trabajar. No es perfecta, pero sin duda es más lógica e intuitiva, lo que mejorará nuestro trabajo con este dato.

Os invitamos a probarlo y aprovechamos para recordar que hemos convocado un curso intensivo de Swift 3 para programadores, para la semana del 12 al 16 de diciembre en Madrid. De 19 a 22 horas para compatibilizar con el horario laboral y donde cualquier programador con conocimientos en orientación a objetos (aunque sea en otros lenguajes) podrá dar el salto a Swift 3 en un curso intensivo de 15 horas de la mano del que escribe, Julio César Fernández. Podéis ver la información, pulsando aquí. Un saludo y, como siempre, Good Apple Coding.

Acerca de Julio César Fernández

Analista, consultor y periodista tecnológico, desarrollador, empresario, productor audiovisual, actor de doblaje e ingeniero de vídeo y audio.

Otras recomendaciones

ARKit

Analizando ARKit

Realizamos un análisis de ARKit, sus posibilidades, cómo funciona y lo comparamos con las Microsoft Hololens para ver el alcance de sus posibilidades. Un análisis en detalle incluyendo algunas pruebas en vídeo que hemos realizado mientras preparamos el curso de ARKit en Apple Coding Academy que verá la luz en septiembre, una vez tengamos versión final de esta interesante plataforma.

  • Antonio Rodríguez

    Acabo de encontrar este blog y estoy encantado. Por fin un blog sobre programación en swift actualizado y al día. Ahora voy a ponerme a escuchar los podcasts!!