Swift Academy · Aula

Valores projetados com $binding

Exponha um projectedValue para oferecer funcionalidades adicionais por meio do prefixo $.

Valores projetados com $binding é 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.

Boas-vindas

Os valores projetados, acessados por meio de `$`, fornecem aos invólucros de propriedades uma interface secundária — usada pelo `@State` e pelo `@Published` do SwiftUI para expor `Binding` e `Publisher`.

Adicionando projectedValue

```swift @propertyWrapper struct Toggle { var wrappedValue: Bool = false var projectedValue: String { wrappedValue ? "ON" : "OFF" } } struct Model { @Toggle var active } var m = Model() print(m.$active) // "OFF" — projected value accessed with $ ```

Tipo de projectedValue

O valor projetado pode ser de qualquer tipo — um `Binding`, um `Publisher`, uma `String` ou um tipo personalizado. O `@State` do SwiftUI projeta um `Binding` que permite um fluxo de dados bidirecional.

Exemplo de projeção de vinculação

```swift // @State projects Binding: @State var isOn = false Toggle(isOn: $isOn) // $isOn is Binding ```

Projeção de vinculação personalizada

```swift @propertyWrapper struct Validated { var wrappedValue: String var projectedValue: Bool { !wrappedValue.isEmpty } } struct Form { @Validated var email = "" } var f = Form() f.email = "hi@example.com" print(f.$email) // true — projected Bool ```

Projeção de @Published

```swift class VM: ObservableObject { @Published var score = 0 } let vm = VM() let cancellable = vm.$score // Publisher .sink { print("Score: \($0)") } vm.score = 10 // "Score: 10" ```

Acessando projectedValue dentro do invólucro

```swift @propertyWrapper struct History { private var current: T private(set) var projectedValue: [T] = [] var wrappedValue: T { get { current } set { projectedValue.append(current); current = newValue } } init(wrappedValue: T) { current = wrappedValue } } ```

Usando o invólucro History

```swift struct Counter { @History var count = 0 } var c = Counter() c.count = 1; c.count = 5; c.count = 3 print(c.$count) // [0,1,5] — history of old values ```

Desambiguando a sintaxe de $

```swift struct Form { @State var text = "" var body: some View { TextField("Enter", text: $text) // $text is Binding } } // text → String (wrappedValue) // $text → Binding (projectedValue) ```

Considerações de projeto

• `projectedValue` é opcional — adicione-o somente quando uma interface secundária for necessária • O tipo pode ser completamente diferente de `wrappedValue` • Use `$` no local da chamada para acessar o valor projetado • Os valores projetados são excelentes para publicadores do Combine e vinculações do SwiftUI

Verificação rápida

Como acessar o `projectedValue` de um invólucro de propriedades?

Recapitulação

Principais conclusões: • `projectedValue` fornece aos invólucros uma API secundária por meio de `$` • Pode ser de qualquer tipo — Binding, Publisher, Bool, Array • `@State` projeta `Binding`; `@Published` projeta `Publisher` • Acesse-o com `$propertyName` tanto no corpo quanto no local da chamada • Adicione-o somente quando uma segunda interface trouxer um benefício real Próximo: @Published e Combine.

Perguntas Frequentes

A aula “Valores projetados com $binding” é grátis?

Sim — o texto completo de “Valores projetados com $binding” é 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 “Valores projetados com $binding”?

Exponha um projectedValue para oferecer funcionalidades adicionais por meio do prefixo $. 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 “Valores projetados com $binding”?

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

Criação de um wrapper de propriedade personalizado
Valores projetados com $binding
@Published e observação no Combine
Composição de vários wrappers de propriedade

← Voltar para Swift Academy