0Pricing
Swift Academy · Lección

map y flatMap en Result

Encadene transformaciones sobre valores correctos sin anidar instrucciones switch.

map y flatMap en Result es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 2 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.

Introducción

`map` y `flatMap` en `Result` permiten transformar los valores correctos sin instrucciones switch anidadas, manteniendo el código plano y legible.

map en Result

```swift let r: Result = .success(5) let doubled = r.map { $0 * 2 } // .success(10) let failed: Result = .failure(MyError.bad) let same = failed.map { $0 * 2 } // .failure(MyError.bad) ```

mapError en Result

```swift let r: Result = .failure(URLError(.notConnectedToInternet)) let mapped = r.mapError { AppError.network($0) } // Result ```

flatMap — encadenar operaciones que pueden fallar

```swift func parseJSON(_ data: Data) -> Result { ... } func validate(_ user: User) -> Result { ... } let result: Result = fetchResult .flatMap { parseJSON($0) } .flatMap { validate($0).mapError { $0 as Error } } ```

flatMapError

```swift func recover(_ e: NetworkError) -> Result { .success(cachedData) } let result = networkResult.flatMapError { recover($0) } ```

map frente a flatMap en Result

• `map`: transforma el valor correcto; si la transformación devuelve `T`, el resultado es `Result` • `flatMap`: la transformación devuelve `Result`; evita anidar `Result,E>`

Encadenar tres operaciones

```swift fetchData(url) .map { parse($0) } .flatMap { validate($0) } .map { transform($0) } // Each step only runs if previous succeeded ```

Comparación con el encadenamiento de opcionales

El encadenamiento de Result es similar al encadenamiento de opcionales para los errores: ```swift // Optional chain: name?.uppercased()?.prefix(5) // Result chain: result.map { $0.uppercased() }.map { $0.prefix(5) } ```

Convertir a un opcional

```swift let opt = result.success // Value? — nil on failure let val = try? result.get() // Value? — nil on failure ```

Recuperarse con un patrón similar a ??

```swift let value = (try? result.get()) ?? defaultValue ```

Comprobación rápida

¿Qué hace `result.flatMap { transform($0) }` cuando `result` es `.failure`?

Resumen

Puntos clave: • `map` transforma el éxito y deja pasar el fallo • `mapError` transforma el tipo del fallo • `flatMap` encadena operaciones que devuelven Result • Evita instrucciones switch anidadas • Permite crear cadenas limpias que propagan errores Siguiente tema: tipos de error personalizados.

Preguntas frecuentes

¿La lección «map y flatMap en Result» es gratis?

Sí — el texto completo de «map y flatMap en Result» 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 «map y flatMap en Result»?

Encadene transformaciones sobre valores correctos sin anidar instrucciones switch. 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 2 de 4.

¿Cuánto tiempo toma la lección «map y flatMap en Result»?

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. Fundamentos de Result
  2. map y flatMap en Result
  3. Tipos de error personalizados con LocalizedError
  4. Puente entre Result y async/await
← Volver a Swift Academy