Inyección mediante inicializador
Pase las dependencias mediante inicializadores.
Inyección mediante inicializador 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.
Inyección por constructor
El estilo de DI más habitual pasa las dependencias a través de un inicializador. El objeto recibe todo lo que necesita al crearse y lo almacena.
Un init básico
Declare una propiedad almacenada y asígnele un valor en init. Quien realice la llamada debe proporcionar la dependencia para crear el objeto.
struct Greeter { func hi() -> String { "Hi" } }
struct View {
let greeter: Greeter
init(greeter: Greeter) { self.greeter = greeter }
func show() { print(greeter.hi()) }
}
View(greeter: Greeter()).show()Dependencias inmutables
Usar let para las propiedades inyectadas las hace inmutables, por lo que una dependencia no se puede sustituir después de la construcción.
struct Engine { let hp: Int }
struct Car {
let engine: Engine // cannot change later
init(engine: Engine) { self.engine = engine }
}
let c = Car(engine: Engine(hp: 150))
print(c.engine.hp)Varias dependencias
Enumere varios parámetros para inyectar más de un colaborador. El inicializador documenta el conjunto completo de requisitos.
struct DB { func get() -> Int { 7 } }
struct Cache { func put(_ v: Int) { print("cached \(v)") } }
struct Service {
let db: DB
let cache: Cache
init(db: DB, cache: Cache) { self.db = db; self.cache = cache }
func run() { cache.put(db.get()) }
}
Service(db: DB(), cache: Cache()).run()Valores predeterminados de los parámetros
Un valor predeterminado permite omitir una dependencia en producción y, al mismo tiempo, reemplazarla en las pruebas.
struct Logger { func log(_ m: String) { print(m) } }
struct Service {
let logger: Logger
init(logger: Logger = Logger()) { self.logger = logger }
func run() { logger.log("go") }
}
Service().run() // uses defaultInyección por constructor en clases
Las clases siguen el mismo patrón. El inicializador asigna cada dependencia antes de que la instancia se pueda utilizar.
class Mailer { func send() { print("sent") } }
class Signup {
let mailer: Mailer
init(mailer: Mailer) { self.mailer = mailer }
func go() { mailer.send() }
}
Signup(mailer: Mailer()).go()Inyectar valores
Las dependencias no tienen por qué ser objetos. También puede inyectar valores de configuración, como una URL base o un indicador, de la misma manera.
struct Client {
let baseURL: String
init(baseURL: String) { self.baseURL = baseURL }
func endpoint(_ p: String) -> String { baseURL + p }
}
print(Client(baseURL: "https://api").endpoint("/users"))Raíz de composición
Un único lugar cercano al punto de entrada de la app ensambla todo el grafo de objetos. El resto simplemente recibe dependencias ya preparadas.
struct DB { func count() -> Int { 3 } }
struct Repo { let db: DB; func n() -> Int { db.count() } }
struct App { let repo: Repo; func run() { print(repo.n()) } }
// Composition root:
let app = App(repo: Repo(db: DB()))
app.run()Evitar los globales ocultos
La inyección por constructor sustituye el acceso a globales ocultos. Cada dependencia es explícita, por lo que puede seguir el flujo de los datos.
struct Settings { let theme: String }
struct Screen {
let settings: Settings
func render() { print("Theme: \(settings.theme)") }
}
Screen(settings: Settings(theme: "dark")).render()Obligatorias frente a opcionales
Si una dependencia es realmente opcional, represéntela con un tipo opcional; de lo contrario, hágala obligatoria para que un objeto nunca pueda existir con una configuración incompleta.
struct Analytics { func track() { print("tracked") } }
struct Flow {
let analytics: Analytics?
func step() { analytics?.track() }
}
Flow(analytics: Analytics()).step()
Flow(analytics: nil).step()Por qué usar la inyección por constructor
Garantiza que el objeto esté completamente inicializado, hace visibles las dependencias y funciona con la inmutabilidad de let. Es la opción predeterminada recomendada en Swift.
struct Adder { func add(_ a: Int, _ b: Int) -> Int { a + b } }
struct Calc {
let adder: Adder
init(adder: Adder) { self.adder = adder }
}
print(Calc(adder: Adder()).adder.add(4, 5))Comprobación rápida
¿Por qué se suele preferir la inyección por constructor?
Resumen
La inyección por constructor pasa las dependencias mediante init y las almacena, normalmente como propiedades let inmutables. Puede inyectar objetos o valores, proporcionar valores predeterminados y ensamblarlo todo en una raíz de composición. A continuación inyectará protocolos en lugar de tipos concretos.
Preguntas frecuentes
¿La lección «Inyección mediante inicializador» es gratis?
Sí — el texto completo de «Inyección mediante inicializador» 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 «Inyección mediante inicializador»?
Pase las dependencias mediante inicializadores. 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 «Inyección mediante inicializador»?
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