Unha cadea é unha serie de caracteres, tales como "Ola, mundo" ou "mazá". En Swift, as cadeas están representadas mediante o tipo String.

• É posible acceder ao contido dunha cadea de varias formas, mesmo como unha colección de valores de tipo Character.
• Podes incluír valores predeterminados de tipo String no teu código como unha secuencia de caracteres encerrada en comiñas dobres (").

let algunaCadena = "Un valor cualquiera para un literal de cadena"

Aquí tedes o código fonte de todos os exemplos empregados nesta sección:

Cadeas de varias liñas #

Se necesitamos múltiples liñas, rodea a secuencia de caracteres da cadea por tres comiñas dobres («»»):

let cita = """
El Conejo Blanco se puso sus gafas. «¿Por dónde debo empezar,
con la venia de Su Majestad?», preguntó.

«Empieza por el principio», dijo el rey con gravedad, «y sigue
hasta llegar al final; allí te detienes.
"""

let cadenaDeUnaSolaLinea = "Estas cadenas son iguales."
let cadenaDeVariasLineas = """
Estas cadenas son iguales.
"""

Caracteres especiais en cadeas #

As cadeas poden incluír os seguintes caracteres especiais:

• \0 (carácter nulo)
• \\ (barra investida)
• \t (tabulador)
• \n (salto de liña)
• \r (retorno de carro)
• \" (comilla dobre)
• \' (comilla simple)
• Un valor Unicode, escrito como \u{*n*}, onde n é un número hexadecimal Unicode.

Exemplos:

let palabrasSabias = "\"La imaginación es más importante que el conocimiento.\" — Einstein"
// "La imaginación es más importante que el conocimiento." — Einstein
let signoDolar = "$"         // $, Escalar Unicode U+0024
let corazonNegro = "♥"      // ♥, Escalar Unicode U+26655
let corazonBrillante = "💖"  // 💖, Escalar Unicode U+1F496

Cadea vacía #

var cadenaVacia = ""            var otraCadenaVacia = String()  
// Estas dos cadenas están vacías y son equivalentes entre sí.

Verifica se un valor de tipo String está baleiro, ao avaliar a súa propiedade booleana isEmpty:

if cadenaVacia.isEmpty {
    print("Nada que ver por aquí.")
}
// Imprime "Nada que ver por aquí."

Constantes (let) vs Variables (var) #

Podes definir unha cadea de dúas formas:

• Podes asignala a unha variable (nese caso, poderá ser modificada).
• Podes asignala a unha constante (nese caso, non poderá ser modificada).

var cadeaModificable = "Cabalo"

cadeaModificable += " e carruaxe"
// cadeaModificable es ahora "Cabalo e carruaxe"

let cadea_NON_Modificable = "Highlander"

cadea_NON_Modificable += " e outro Highlander"
// Esto resulta nun erro en tempo de compilación:
// unha cadea constante non pode ser modificada

Carácteres #

Podes acceder aos valores carácteres individuais dunha cadea mediante un ciclo for-in:

for caracter in "¡Perro!🐶" {
    print(caracter)
}
// ¡
// P
// e
// r
// r
// o
// !
// 🐶

Concatenación #

Podes xuntar (ou «concatenar») cadeas co operador (+). Tamén podes engadir un carácter empregando o médodo append():

let cadena1 = "Buenos"
let cadena2 = " días"
var saludo = cadena1 + cadena2
// saludo es ahora igual a "Buenos días"

var instruccion = "deletrea la palabra"
instruccion += cadena2
// instruccion es ahora igual a "deletrea la palabra días"

let punto: Character = "."
saludo.append(punto)
// saludo es ahora igual a "Buenos días."

Interpolación de cadeas #

A interpolación de cadeas combina cadeas con constantes, variables e expresións.

Cada elemento que queiras inserir na cadea, vai rodeado por paréntese e precedido por unha barra invertida (\()):

let multiplicador = 3
let mensaje = "\(multiplicador) por 2.5 es \(Double(multiplicador) * 2.5)"
// mensaje es "3 por 2.5 es 7.5"

# #

Podes usar # para crear cadeas que conteñan caracteres que, doutra maneira, serían tratados como interpolación de cadeas. Por exemplo:

print(#"Escribe una cadena interpolada en Swift usando \(multiplicador)."#)
// Imprime "Escribe una cadena interpolada en Swift usando \(multiplicador)."

print(#"6 por 7 es \#(6 * 7)."#)
// Imprime "6 por 7 es 42."

Número total de carácteres da cadea #

Para obter a conta de valores tipo Character nunha cadea, usa a propiedade count da cadea:

let animalesDomesticos = "Gato 🐈, Perro 🐕, Vaca 🐄, Caballo 🐎"

print("animalesDomesticos tiene \(animalesDomesticos.count) caracteres")
// Imprime "animalesDomesticos tiene 34 caracteres"

var palabra = "cafe"

print("El número de caracteres en «\(palabra)» es \(palabra.count)")
// Imprime "El número de caracteres en «cafe» es 4"

Acceso e modificación dunha cadea #

Índices #

• Usa a propiedade startIndex para acceder á posición do primeiro Character dunha cadea.
• A propiedade endIndex é a posición que lle segue ao último carácter dunha cadea.
• Podes acceder aos índices anterior e posterior a un índice dado, usando os métodos index(before:) e index(after:) do tipo String.
• Para acceder a un índice máis aló do índice dado, podes usar o método index(_:offsetBy:) en lugar de chamar algún dos métodos anteriores múltiples veces.

let saludo = "¡Buenos dias!"

saludo[saludo.startIndex]  // ¡
saludo[saludo.index(before: saludo.endIndex)] // !
saludo[saludo.index(after: saludo.startIndex)] // B

let index = saludo.index(saludo.startIndex, offsetBy: 8)

saludo[index] // d

Se tentas acceder a un índice fora do rango da cadea, xerarás un erro de tempo de execución.

saludo[saludo.endIndex] // Error
saludo.index(after: saludo.endIndex) // Error

Usa a propiedade indices para acceder a todos os índices dos caracteres individuais dunha cadea.

for index in saludo.indices {
    print("\(saludo[index]) ", terminator: "")
}
// Imprime "¡ B u e n o s  d i a s ! "r

Insertar e remover #

• Para inserir un só carácter nunha cadea nun índice en específico, usa o método insert(_:at:)
• Para inserir o contido doutra cadea nun índice en específico, usa o método insert(contentsOf:at:).

var bienvenida = "Buenas"
bienvenida.insert("!", at: bienvenida.endIndex)
// bienvenida es ahora igual a «Buenas!»

bienvenida.insert(contentsOf: " tardes", at: bienvenida.index(before: bienvenida.endIndex))
// bienvenida es ahora igual a «Buenas tardes!»

• Para remover un só carácter dunha cadea nun índice en particular, usa o método remove(at:)
• Para remover unha subcadena nun rango específico, usa o método removeSubrange(_:).

bienvenida.remove(at: bienvenida.index(before: bienvenida.endIndex))
// bienvenida es ahora igual a «Buenas tardes»

let range = bienvenida.index(bienvenida.endIndex, offsetBy: -7)..<bienvenida.endIndex

bienvenida.removeSubrange(range)
// bienvenida es ahora igual a «Buenas»

Comparación #

A igualdade de cadeas e caracteres verifícase mediante os operadores «igual que» (==) e «non igual que» (!=), como se describe en Operadores de comparación:

let frase = "Somos muy parecidos. Tú y yo."
let mismaFrase = "Somos muy parecidos. Tú y yo."

if frase == mismaFrase {
    print("Estas dos cadenas son consideradas iguales.")
}
// Imprime "Estas dos cadenas son consideradas iguales."

Prefixo e sufixo #

Para verificar se unha cadea ten un prefixo ou sufijo de cadea en particular, chama aos métodos hasPrefix(:) e *hasSuffix(*:) da cadea, ambos dos cales toman un só argumento de tipo String e devolven un valor booleano.

let romeoYJulieta = [
    "Acto 1 Escena 1: Verona. Una plaza pública.",
    "Acto 1 Escena 2: La mansión Capuleto.",
    "Acto 1 Escena 3: Un cuarto en la mansión Capuleto.",
    "Acto 1 Escena 4: Una calle afuera de la mansión Capuleto.",
    "Acto 1 Escena 5: El Gran Salón en la mansión Capuleto.",
    "Acto 2 Escena 1: Afuera de la mansión Capuleto.",
    "Acto 2 Escena 2: El jardín de Capuleto.",
    "Acto 2 Escena 3: Afuera de la celda del hermano Lorenzo.",
    "Acto 2 Escena 4: Una calle en Verona.",
    "Acto 2 Escena 5: La mansión Capuleto.",
    "Acto 2 Escena 6: La celda del hermano Lorenzo."
]

var conteoDeEscenasDelActo1 = 0

for escena in romeoYJulieta {
    if escena.hasPrefix("Acto 1 ") {
        conteoDeEscenasDelActo1 += 1
    }
}

print("Hay \(conteoDeEscenasDelActo1) escenas en el Acto 1.")
// Imprime «Hay 5 escenas en el Acto 1.»