0Pricing
Swift Academy · Lección

Fundamentos de String e interpolación

Cree cadenas de texto, use la interpolación de cadenas con \(variable) y realice operaciones básicas.

Fundamentos de String e interpolación es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Swift Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Swift Academy incluye 4 lecciones en total.

Bienvenido

Las cadenas son fundamentales en casi cualquier app. El tipo `String` de Swift es compatible correctamente con Unicode, tiene semántica de valor y es extremadamente potente. Aprendamos lo esencial.

Literales de cadena

Los literales de cadena usan comillas dobles: ```swift let greeting = "Hello, World!" var city = "Istanbul" ``` Para las cadenas multilínea, use comillas triples: ```swift let poem = """ Roses are red, Swift is great. """ ```

Concatenación de cadenas

Combine cadenas con el operador `+` o `+=`: ```swift let first = "Hello" let second = " World" let full = first + second // "Hello World" var msg = "Hi" msg += " there" // "Hi there" ```

Interpolación de cadenas

Inserte cualquier expresión dentro de una cadena con `\(expression)`: ```swift let name = "Alice" let score = 95 print("Player \(name) scored \(score) points") // Player Alice scored 95 points ``` La interpolación es más segura y legible que la concatenación manual.

isEmpty y count

Compruebe si una cadena está vacía u obtenga el número de caracteres que contiene: ```swift var text = "" print(text.isEmpty) // true text = "Swift" print(text.count) // 5 ``` Use `.isEmpty` en lugar de `text == ""`: es una forma más idiomática de escribir Swift.

Métodos habituales de String

```swift let str = "Hello, Swift!" str.uppercased() // "HELLO, SWIFT!" str.lowercased() // "hello, swift!" str.contains("Swift") // true str.hasPrefix("Hello") // true str.hasSuffix("!") // true str.replacingOccurrences(of: "Swift", with: "World") ```

Mutabilidad de las cadenas

Las cadenas de Swift son *tipos de valor*. Una cadena declarada con `var` es mutable; una cadena declarada con `let` es inmutable: ```swift var mutable = "Hello" mutable.append(" World") // ✓ let immutable = "Hello" immutable.append(" World") // ❌ compile error ```

Comparación de cadenas

Compare cadenas con los operadores `==`, `<` y `>` (compatibles con Unicode): ```swift let a = "apple" let b = "banana" print(a == b) // false print(a < b) // true (lexicographic order) ``` De forma predeterminada, las comparaciones no dependen de la configuración regional.

Cadenas sin formato

Use `#"..."#` para desactivar las secuencias de escape; resulta útil para patrones de expresiones regulares o rutas: ```swift let pattern = #"\d{3}-\d{4}"# // The backslashes are literal, not escape sequences let path = #"C:\Users\Alice"# ``` La interpolación sigue funcionando con `\#(value)` dentro de las cadenas sin formato.

Conversión entre String y otros tipos

```swift let num = 42 let str = String(num) // "42" let back = Int(str) // Optional(42) let invalid = Int("abc") // nil ``` La conversión de `String` a tipos numéricos devuelve un `Optional`, ya que la cadena podría no representar un número válido.

Comprobación rápida

¿Qué sintaxis inserta el valor de una variable dentro de un literal de cadena de Swift?

Resumen

Ideas clave: • Los literales de cadena usan `"..."`; las cadenas multilínea usan `"""` • Interpole con `\(expression)`: es la forma más clara de construir cadenas • Las cadenas declaradas con `var` son mutables; las declaradas con `let` son inmutables • Use `.isEmpty`, `.count`, `.contains()`, `.hasPrefix()` y `.hasSuffix()` • Convertir de String a tipos numéricos devuelve un Optional Siguiente lección: bucles for-in con rangos.

Preguntas frecuentes

¿La lección «Fundamentos de String e interpolación» es gratis?

Sí — el texto completo de «Fundamentos de String e interpolación» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Swift Academy, actualiza a CoddyKit PRO. El curso de Swift Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Fundamentos de String e interpolación»?

Cree cadenas de texto, use la interpolación de cadenas con \(variable) y realice operaciones básicas. Practicas Swift Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Swift Academy?

No se requiere experiencia previa. Swift Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Fundamentos de String e interpolación»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Swift Academy?

Sí. Cada lección de Swift Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. let frente a var: constantes y variables
  2. Inferencia de tipos y tipos explícitos
  3. Números, booleanos y caracteres
  4. Fundamentos de String e interpolación
← Volver a Swift Academy