Transférer des informations entre les vues¶
Transférer des informations de la vue parent vers une vue enfant (initialisation de propriétés)¶
Une vue parent peut transmettre de l'information à la vue enfant vers laquelle elle navigue.
Ceci est particulièrement intéressant dans une liste d'items qui permet d'afficher la page de détail de chaque item à partir d'une même vue enfant.
D'abord, la vue enfant définiera les propriétés dont elle a besoin.
struct VueDetail: View {
var description: String
var inventaire: Int
var body: some View {
...
}
}
Ensuite, la vue parent initialisera ces variables lors de l'appel de la vue enfant.
NavigationLink(destination: VueDetail(description: "Item XYZ", inventaire: 36)) {
Text("Item XYZ")
}
Pour plus d'information¶
« View Communication Patterns in SwiftUI ». Vadim Bulavin. https://www.vadimbulavin.com/passing-data-between-swiftui-views/
De la vue enfant vers la vue parent (@Binding et @Bindable))¶
Une vue enfant peut récolter des informations qu'elle doit rendre à la vue parent.
Variable d'état créée dans la vue parent¶
Voici comment le transfert d'informations se déroulera.
Lorsqu'une variable est déclarée avec l'attribut @Binding (en anglais, on dit que c'est un property wrapper), ceci indique que la variable appartient à la vue parent mais qu'elle peut être modifiée autant par la vue parent que par la vue enfant. Il s'agit d'une liaison bidirectionnelle.
Le parent la transmet à l'enfant en la faisant précéder par le signe $.
struct VueParent: View {
@State private var maVariable: String = "valeur initiale" // la variable appartient à cette vue
var body: some View {
NavigationStack {
VStack {
Text(maVariable)
.padding()
NavigationLink(destination: VueEnfant(etat: $maVariable)) {
Text("Vue enfant")
}
}
}
}
}
struct VueEnfant: View {
@Binding var etat: String // la variable appartient à la vue parent et elle peut être modifiée ici
var body: some View {
Button("Changer la valeur") {
etat = "valeur modifiée" // cette valeur affectera maVariable dans la vue parent
}
}
}
Le résultat de cette application de démonstration n'est pas esthétique mais on y voit bien le fonctionnement du @Binding.
| Voici la vue parent avant d'afficher la vue enfant. | La vue enfant contient un bouton qui permet de modifier la valeur de la variable du parent. | Voici à nouveau la vue parent après que l'usager ait cliqué sur le bouton dans la vue enfant. | ||
| Avant de cliquer sur le bouton | Avant de cliquer sur le bouton | Après avoir cliqué sur le bouton |
Variable observable sans liaison¶
Une variable est observable dans différentes situations, par exemple :
- une propriété d'une classe ou structure décorée avec
@Observable - une variable dont les valeurs sont tirées de la base de données grâce à SwiftData et
@Query
Lorsqu'une variable est observable, les modification qui lui sont apportées se reflètent automatiquement partout dans l'application.
Une vue enfant peut travailler avec cette variable, qu'elle recevra en paramètre.
struct VueParent: View {
@Query(sort: \Item.code) var items: [Item] // la variable est observable
var body: some View {
NavigationStack {
List(items) { item in
VStack(alignment: .leading) {
HStack {
Text("\(item.code) - \(item.titre)")
Spacer()
NavigationLink(destination: VueEnfant(unItem: item)) { // pas besoin de $ devant le paramètre
Image(systemName: "pencil.line")
}
.buttonStyle(.bordered)
...
}
}
}
}
}
}
struct VueEnfant: View {
var unItem: Item
var body: some View {
Button("Changer la valeur") {
item.titre = "valeur modifiée" // l'item sera modifié partout dans l'application
}
}
}
Variable observable avec liaison¶
Dans le cas où le paramètre observable doit être utilisé dans une liaison, par exemple dans un TextField, il faut le décorer avec @Bindable dans la vue enfant.
Remarquez que lorsqu'une vue enfant reçoit un paramètre décoré avec @Bindable, la vue parent n'a pas besoin de faire précéder le paramètre par le signe $ lorsqu'elle appelle la vue enfant.
La vue parent sera identique au cas où la variable observable n'a pas besoin de liaison (voir ci-haut).
La vue enfant sera modifiée comme suit :
struct VueEnfant: View {
@Bindable var unItem: Item // la variable est déclarée ailleurs, elle est observable et doit être utilisée dans un binding
var body: some View {
TextField("Nom", text: $unItem.nom) // l'item sera modifié partout dans l'application
...
}
}
Pour plus d'information¶
« Managing Data Flow in SwiftUI ». Swift with Majid. https://swiftwithmajid.com/2019/07/03/managing-data-flow-in-swiftui/
« What's the difference between @Bindable and @Binding? ». Hacking with Swift. https://www.hackingwithswift.com/quick-start/swiftdata/whats-the-difference-between-bindable-and-binding
Variables globales (@Environment et @EnvironmentObject)¶
Si l'application a besoin de passer un objet entre des vues qui ne sont pas directement liées, par exemple de la vue parent vers l'enfant de son enfant, il est possible de travailler avec l'attribut (property wrapper) @Environment lorsque la classe est décorée avec @Observable ou @EnvironmentObject si vous utilisez l'ancienne technique qui consiste à conformer la classe au protocole ObservableObject.
Prenons l'exemple de cette classe observable.
@Observable
class MaClasse {
var options = ["Option 1", "Option 2", "Option 3"]
...
}
Un objet de cette classe peut être injecté dans l'environnement afin d'être partagé entre plusieurs vues. Il doit être déclaré dans le plus proche parent des vues qui en ont besoin.
Dans cet exemple, l'objet est déclaré dans le ContentView.
struct ContentView: View {
@State private var monObjet = MaClasse()
var body: some View {
NavigationStack {
...
NavigationLink(destination: VueSelection()) {
Text("Choisir une option")
}
}
.environment(monObjet)
}
}
La vue enfant (ou ses descendants) pourront accéder à l'objet à l'aide de @Environment.
struct VueSelection: View {
@Environment(MaClasse.self) var monObjet
@State private var optionChoisie: String?
var body: some View {
VStack {
...
HStack {
Text("Option: ")
Picker("", selection: $optionChoisie) {
Text("Veuillez choisir...").tag(nil as String?)
ForEach(monObjet.options, id: \.self) { option in
Text(option).tag(option as String?)
}
}
}
}
}
}
Pour plus d'information¶
« How to use @EnvironmentObject to share data between views ». Hacking with Swift. https://www.hackingwithswift.com/quick-start/swiftui/how-to-use-environmentobject-to-share-data-between-views
« The power of Environment in SwiftUI ». Swift with Majid. https://swiftwithmajid.com/2019/08/21/the-power-of-environment-in-swiftui/
« @EnvironmentObject explained for sharing data between views in SwiftUI ». SwiftLee. https://www.avanderlee.com/swiftui/environmentobject/