Dependency injection tramite inizializzatore
Passi le dipendenze attraverso gli inizializzatori.
Dependency injection tramite inizializzatore è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Swift Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Swift Academy include 4 lezioni in totale.
Iniezione tramite costruttore
Lo stile DI più comune consiste nel passare le dipendenze tramite un inizializzatore. L'oggetto riceve tutto ciò di cui ha bisogno al momento della creazione e lo conserva.
Un init di base
Dichiarate una proprietà memorizzata e assegnatele un valore in init. Per creare l'oggetto, i chiamanti devono fornire la dipendenza.
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()Dipendenze immutabili
L'uso di let per le proprietà iniettate le rende immutabili, quindi una dipendenza non può essere sostituita dopo la costruzione.
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)Più dipendenze
Elencate più parametri per iniettare più di un collaboratore. L'inizializzatore documenta l'insieme completo dei requisiti.
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()Valori predefiniti dei parametri
Un valore predefinito consente ai chiamanti di omettere una dipendenza in produzione, mantenendo comunque la possibilità di sostituirla nei test.
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 defaultIniezione tramite costruttore di una classe
Le classi seguono lo stesso schema. L'inizializzatore assegna ogni dipendenza prima che l'istanza possa essere utilizzata.
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()Iniezione di valori
Le dipendenze non devono necessariamente essere oggetti. È possibile iniettare allo stesso modo valori di configurazione, come un URL di base o un flag.
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"))Radice di composizione
Un unico punto vicino all'entry point dell'app collega l'intero grafo degli oggetti. Tutto il resto riceve semplicemente dipendenze già pronte.
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()Evitare i globali nascosti
L'iniezione tramite costruttore sostituisce l'accesso globale nascosto. Ogni dipendenza è esplicita, quindi è possibile seguire il flusso dei dati.
struct Settings { let theme: String }
struct Screen {
let settings: Settings
func render() { print("Theme: \(settings.theme)") }
}
Screen(settings: Settings(theme: "dark")).render()Obbligatorio o facoltativo
Se una dipendenza è davvero facoltativa, rappresentatela con un tipo opzionale; altrimenti rendetela obbligatoria, così un oggetto non potrà mai esistere configurato solo parzialmente.
struct Analytics { func track() { print("tracked") } }
struct Flow {
let analytics: Analytics?
func step() { analytics?.track() }
}
Flow(analytics: Analytics()).step()
Flow(analytics: nil).step()Perché usare l'iniezione tramite costruttore
Garantisce un oggetto completamente inizializzato, rende visibili le dipendenze e funziona con l'immutabilità di let. In Swift è l'impostazione predefinita consigliata.
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))Verifica rapida
Perché si preferisce spesso l'iniezione tramite costruttore?
Riepilogo
L'iniezione tramite costruttore passa le dipendenze tramite init e le memorizza, generalmente come proprietà let immutabili. È possibile iniettare oggetti o valori, fornire valori predefiniti e collegare tutto in una radice di composizione. Prossimo argomento: l'iniezione di protocolli anziché di tipi concreti.
Domande Frequenti
La lezione «Dependency injection tramite inizializzatore» è gratuita?
Sì — il testo completo di «Dependency injection tramite inizializzatore» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Swift Academy, passa a CoddyKit PRO. Il corso Swift Academy include 4 lezioni in totale.
Cosa imparerò in «Dependency injection tramite inizializzatore»?
Passi le dipendenze attraverso gli inizializzatori. Eserciti Swift Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Swift Academy?
Non è richiesta alcuna esperienza precedente. Swift Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.
Quanto tempo richiede la lezione «Dependency injection tramite inizializzatore»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Swift Academy?
Sì. Ogni lezione Swift Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Perché usare la dependency injection
- Dependency injection tramite inizializzatore
- Astrazioni basate sui protocolli
- Mock delle dipendenze nei test