Por qué utilizar inyección de dependencias
Separe la construcción del uso para facilitar las pruebas.
Por qué utilizar inyección de dependencias es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 1 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.
Por qué usar la inyección de dependencias
La inyección de dependencias (DI) consiste en proporcionar a un objeto lo que necesita desde el exterior, en lugar de permitir que lo cree por sí mismo. Esto desacopla los componentes y facilita las pruebas.
El problema: acoplamiento fuerte
Cuando un tipo construye sus propios colaboradores, queda vinculado a esas clases concretas y no se puede reconfigurar ni probar de forma aislada.
class Logger {
func log(_ m: String) { print("LOG: \(m)") }
}
class Service {
let logger = Logger() // hard-coded dependency
func run() { logger.log("running") }
}
Service().run()El acoplamiento dificulta las pruebas
Como Service siempre crea un Logger real, una prueba no puede capturar ni simular la salida del registro. La dependencia es invisible desde el exterior.
class Logger { func log(_ m: String) { print(m) } }
class Service {
let logger = Logger()
func run() { logger.log("hello") }
}
// No way to swap Logger here.
Service().run()La idea: inyectarla
En su lugar, pase la dependencia. La persona que realiza la llamada decide qué implementación proporcionar, de modo que Service deja de preocuparse por ello.
class Logger { func log(_ m: String) { print("LOG: \(m)") } }
class Service {
let logger: Logger
init(logger: Logger) { self.logger = logger }
func run() { logger.log("running") }
}
Service(logger: Logger()).run()Ventajas del desacoplamiento
Con la inyección, el mismo Service funciona con distintos registradores, tanto en producción como en las pruebas, sin cambiar su código.
class Logger { var lines: [String] = []
func log(_ m: String) { lines.append(m) } }
class Service {
let logger: Logger
init(logger: Logger) { self.logger = logger }
func run() { logger.log("event") }
}
let l = Logger()
Service(logger: l).run()
print(l.lines)Responsabilidad única
La DI favorece el principio de responsabilidad única: un tipo se centra en su función y delega las demás responsabilidades en los colaboradores inyectados.
struct Mailer { func send(_ to: String) { print("Mail to \(to)") } }
struct SignupFlow {
let mailer: Mailer
func register(_ email: String) { mailer.send(email) }
}
SignupFlow(mailer: Mailer()).register("a@b.com")Flexibilidad
Puede recombinar los objetos de nuevas formas. El ensamblado se realiza en los extremos de la app, lo que mantiene flexible el núcleo.
struct Engine { let power: Int }
struct Car {
let engine: Engine
func describe() { print("Power: \(engine.power)") }
}
Car(engine: Engine(power: 200)).describe()
Car(engine: Engine(power: 90)).describe()Dependencias explícitas
Un inicializador que enumera sus dependencias documenta exactamente lo que necesita el tipo. Las dependencias ocultas y creadas internamente esconden ese contrato.
struct Repo { func load() -> [Int] { [1, 2, 3] } }
struct Report {
let repo: Repo // visible dependency
func total() -> Int { repo.load().reduce(0, +) }
}
print(Report(repo: Repo()).total())Composición en lugar de construcción
La DI favorece la composición externa de los objetos. Una pequeña raíz de composición ensambla el grafo; el resto del código simplemente recibe lo que necesita.
struct DB { func count() -> Int { 42 } }
struct Stats { let db: DB; func show() { print(db.count()) } }
// Composition root:
let app = Stats(db: DB())
app.show()No solo para apps grandes
Incluso los programas pequeños se benefician: inyectar una dependencia permite intercambiar el comportamiento y deja claras las intenciones sin añadir frameworks.
struct Clock { func now() -> Int { 12 } }
struct Greeter {
let clock: Clock
func greet() { print(clock.now() < 12 ? "Morning" : "Afternoon") }
}
Greeter(clock: Clock()).greet()No se necesita ningún framework
La DI en Swift no necesita ninguna biblioteca. Los inicializadores sencillos y los protocolos son suficientes. En las próximas lecciones verá la inyección por constructor, los protocolos y los mocks.
struct Adder { func add(_ a: Int, _ b: Int) -> Int { a + b } }
struct Calc {
let adder: Adder
func run() { print(adder.add(2, 3)) }
}
Calc(adder: Adder()).run()Comprobación rápida
¿Cuál es la idea central de la inyección de dependencias?
Resumen
La inyección de dependencias proporciona los colaboradores desde el exterior en lugar de construirlos internamente, lo que reduce el acoplamiento, hace explícitas las dependencias y permite realizar pruebas. En Swift no necesita ningún framework. A continuación verá la forma más habitual: la inyección por constructor.
Preguntas frecuentes
¿La lección «Por qué utilizar inyección de dependencias» es gratis?
Sí — el texto completo de «Por qué utilizar inyección de dependencias» 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 «Por qué utilizar inyección de dependencias»?
Separe la construcción del uso para facilitar las pruebas. 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 1 de 4.
¿Cuánto tiempo toma la lección «Por qué utilizar inyección de dependencias»?
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
- Por qué utilizar inyección de dependencias
- Inyección mediante inicializador
- Abstracciones basadas en protocolos
- Simulación de dependencias en pruebas