Swift Academy · Aula

Injeção pelo Inicializador

Passe dependências pelos inicializadores.

Injeção pelo Inicializador é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Swift Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Swift Academy inclui 4 aulas no total.

Injeção pelo Construtor

O estilo mais comum de DI passa as dependências por um inicializador. O objeto recebe tudo de que precisa no momento da criação e armazena esses recursos.

Um Inicializador Básico

Declare uma propriedade armazenada e atribua-lhe um valor em init. Quem chama deve fornecer a dependência para criar o 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()

Dependências Imutáveis

Usar let nas propriedades injetadas torna-as imutáveis, de modo que uma dependência não possa ser trocada após a construção.

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)

Várias Dependências

Liste vários parâmetros para injetar mais de um colaborador. O inicializador documenta o 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 Padrão para Parâmetros

Um valor padrão permite que quem chama omita uma dependência em produção, sem impedir substituições nos testes.

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 default

Injeção pelo Construtor de Classes

As classes seguem o mesmo padrão. O inicializador atribui cada dependência antes que a instância possa ser usada.

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()

Injetando Valores

As dependências não precisam ser objetos. Você pode injetar valores de configuração, como uma URL base ou um sinalizador, da mesma maneira.

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"))

Raiz de Composição

Um único local próximo ao ponto de entrada do app conecta todo o grafo de objetos. Todo o restante apenas recebe dependências prontas.

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()

Evitando Globais Ocultos

A injeção pelo construtor substitui o acesso a globais ocultos. Cada dependência é explícita, para que você possa acompanhar o fluxo dos dados.

struct Settings { let theme: String }
struct Screen {
    let settings: Settings
    func render() { print("Theme: \(settings.theme)") }
}
Screen(settings: Settings(theme: "dark")).render()

Obrigatória vs. Opcional

Se uma dependência for realmente opcional, represente-a com um tipo opcional; caso contrário, torne-a obrigatória para que um objeto nunca possa existir configurado pela metade.

struct Analytics { func track() { print("tracked") } }
struct Flow {
    let analytics: Analytics?
    func step() { analytics?.track() }
}
Flow(analytics: Analytics()).step()
Flow(analytics: nil).step()

Por Que Usar a Injeção pelo Construtor

Ela garante um objeto totalmente inicializado, torna as dependências visíveis e funciona com a imutabilidade de let. É a opção padrão recomendada no 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))

Verificação Rápida

Por que a injeção pelo construtor costuma ser preferida?

Recapitulação

Injeção pelo construtor passa as dependências por init e as armazena, geralmente como propriedades imutáveis let. Você pode injetar objetos ou valores, fornecer padrões e conectar tudo em uma raiz de composição. A seguir, você injetará protocolos em vez de tipos concretos.

Perguntas Frequentes

A aula “Injeção pelo Inicializador” é grátis?

Sim — o texto completo de “Injeção pelo Inicializador” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Swift Academy, atualize para CoddyKit PRO. O curso de Swift Academy inclui 4 aulas no total.

O que vou aprender em “Injeção pelo Inicializador”?

Passe dependências pelos inicializadores. Você pratica Swift Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Swift Academy?

Nenhuma experiência prévia é necessária. Swift Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Injeção pelo Inicializador”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Swift Academy?

Sim. Cada aula de Swift Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Swift Academy