---
title: 07. Cadeas
description: "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…"
url: "https://www.drodicio.com/docs/swift/tema-1-comezando-con-swift/cadeas/"
updated: "2024-11-06"
category: Tema 1. Comezando con Swift
---

# 07. Cadeas

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 (`"`).

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

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

[https://swiftfiddle.com/2vnxuysdl5gljnf5645333a44u/embedded/](https://swiftfiddle.com/2vnxuysdl5gljnf5645333a44u/embedded/)

## 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:

- ` ` (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:

```swift
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

```swift
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`:

```swift
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`:

```swift
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.

```swift
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.

```swift
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(_:)`.

```swift
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.

```swift
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.»
```
