Cadenas y caracteres en Swift

Una cadena es una serie de caracteres, como "Hola, mundo" o "Aprender Swift". Usamos la palabra clave String para crear variables de tipo String.

Para crear una cadena de texto de una sola línea

let str = "Hola, mundo"

Cadenas de multiple-línea

Si necesita una cadena que contiene varias líneas, utilice un literal de cadena de varias líneas, pon el contenido rodeado por tres comillas dobles """

let quest = """
El Conejo Blanco se puso las gafas. "¿Por dónde empezar? por favor, Su Majestad? ”preguntó. "Empiece por el principio", dijo el Rey con gravedad, "y continúe hasta que llegues al final; luego se detiene."
"""

Si el contenido tiene uns alto de linea, se respectará su estructura como tambien tabulación de parrafos.

let texto="""

Está cadena comienza con un salto de línea.
    Está línea empieza con un tabulador.
También termina con un salto de línea.

"""

Delimitadores de cadena extendidos

Puede colocar un literal de cadena dentro de delimitadores extendidos para incluir caracteres especiales en una cadena sin invocar su efecto.

Por ejemplo si dentro del contenido queremos usar " lo debemos hacer con su caracter de escape \"

let threeDoubleQuotationMarks = """
Escapar de la primera comilla \"""
Escapar de las tres comillas \"\"\"
"""

Usando la delimitación de cadena extendido

let threeMoreDoubleQuotationMarks = #"""
Aquí hay tres comillas dobles más: """
"""#

Representación de caracteres especiales

El contenido de la cadenas de caracteres pueden contener caracteres especiales y caracteres unicode

Los caracteres especiales de escape
\n Salto de línea
\b Retroceso
\t Tabulación horizontal
\v Tabulación vertical
\\ Contrabarra
\f Salto de página
\' Apóstrofe
\" Comillas dobles
\0 Fin de una cadena de caracteres

print("Me llamo \"Pickachu\" soy un pokémon")
print("\nPokedex\\25")
print("\nN. japonés: \'ピカチュウ\'")
print("\rRetroceso")
print("\n\tEsto ha sido todo")

Ejecuta el código en SwiftFiddle y comprueba el resultado

Los caracteres unicode UTF-8
Para usar un caracter Unicode, se debe inicar con \u{ hexa_code }, donde hexa_code es el identificador hexadecimal de 1 a 8 dígitos.

Por ejemplo el código U+F8FF representa la manzana de Apple

let utf8Apple =  "\u{F8FF}" // , unicode U+F8FF
let dollarSign = "\u{24}" // $, unicode U+0024
let blackHeart = "\u{2665}" // ♥, Unicode U+2665
let sparklingHeart = "\u{1F496}" // 💖, unicode U+1F496

Inicializar una cadena vacía

Para crear una cadena vacia o inicializar la cadena

var emptyString = "" // Cadena vacia
var anotherEmptyString = String() // Usando constructor
// estas dos cadenas están vacías y son equivalentes entre sí

Mutabilidad de cadenas

Si una Cadena en particular se requiere modificar (o mutar) asignándola a una variable, recuerde que si se asigna en una constante no puede mutar.

var variableString = "Caballo"
variableString = "Caballo y carruaje"
// variableString ahora es "Caballo y carruaje"

Concatenación de cadenas

Para unir cadenas lo podemos hacer usando el operador + y +=

let string1 = "Aprendiendo"
let string2 = " Swift"
var welcome = string1 + string2
// welcome ahora será "Aprendiendo Swift"

y si a continuación hacemos

welcome += ", Hola Mundo!"
print(welcome)
// Outpu "Aprendiendo Swift, Hola Mundo!"

Interpolación de cadenas

La interpolación de cadenas de carácter es simplemente combinar variables y constantes dentro de una cadena de carácteres mediante un marcador de posición.

let learn =  "Swift"
let message =  "Estoy aprendiendo \(learn)"
print(message)
//Estoy aprendiendo Swift

Se podria tambien recurrir a

let message =  "Estoy aprendiendo "  + learn

Pero se recomienda usar la interplación en Swift si especialmente se requiere combinar múltiples variables:

var barName =  "Taberna de Moe"
var maxCapacity =  100
var currentCapacity =  36.166667

let str =  "En la \(barName), la capacidad actual es de \(currentCapacity), su máximo es de \(maxCapacity)"
print(str)
//En la Taberna de Moe, la capacidad actual es de 36.166667, su máximo es de 100

Caracteres de una cadena

Se puede acceder a los valores de caracteres individuales que conforman una cadena

for character in "Gato!🐈" {
  print(character)
}
// G
// a
// t
// o
// !
// 🐈

Operar con los caracteres de la cadena

Podemos acceder a una posición concreta para extraer el caracter correspondiente, pero para ello se debe usar la siguiente extensión de Swift

extension String {

    var length: Int {
        return count
    }

    subscript (i: Int) -> String {
        return self[i ..< i + 1]
    }

    func substring(fromIndex: Int) -> String {
        return self[min(fromIndex, length) ..< length]
    }

    func substring(toIndex: Int) -> String {
        return self[0 ..< max(0, toIndex)]
    }

    subscript (r: Range<Int>) -> String {
        let range = Range(uncheckedBounds: (lower: max(0, min(length, r.lowerBound)),
                                            upper: min(length, max(0, r.upperBound))))
        let start = index(startIndex, offsetBy: range.lowerBound)
        let end = index(start, offsetBy: range.upperBound - range.lowerBound)
        return String(self[start ..< end])
    }
}

y luego podemos operar con los caracteres que conforman las cadenas de texto

let str =  "abcdef"
print( str[1 ..< 3] ) // "bc"
print( str[5] ) // "f"
print( str[80] ) // ""
print( str.substring(fromIndex:  3) ) // "def"
print( str.substring(toIndex: str.length  -  2) ) // "abcd"