通常一个App会有多个View和数据组成，而数据需要被这些View修改和显示，那么如何进行数据的传递（数据绑定）呢，Swift提供了以下几个方式,

a. 当前View有效的属性，使用@State,@StateObject.

b. 父子View之间进行传递的 @Binding.

c. 各个View之间通过构造参数进行传递的@ObservedObject.

d. 全局参数@EnvironmentObject.

详细解释下几种方式

当前iew有效的方式:@State：SwiftUI通过@State跟踪当前view中的数值，当数值发生改变时自动刷新view，而且可以改变被@State修饰的变量，即使这个变量没有使用multi修饰，@State修饰基本类型Int,String，如果是对象/结构体，将无法跟踪类/结构体内的属性变化,这时需要使用 @StateObject,因为@State只跟踪当前对象，不跟踪对象属性，使用方式

• 定义一个实现ObservableObject协议的类。

• 在View中使用@StateObject修饰这个对象。

• 这个对象的生命周期和View一致，即重新进入View时，对象会被重新初始化(NavigationView使用时)。

代码

struct SettingView: View { 
    @StateObject var setting:Setting 
    @State var type="T1" 
    @EnvironmentObject var building:MyBuilding 
    var body: some View { 
        VStack(){ 
            HStack(){ 
                TextField("StateObject:",text: $setting.name) 
                TextField("State:",text: $type) 
                TextField("Environment",text: $building.name) }.padding() 
            } 
        } 
}

struct HomeView: View {
    var setting=Setting()
    var body: some View {
        GeometryReader{
            proxy in
            VStack(alignment: .leading){
                NavigationView(){
                    HStack(alignment:.bottom, spacing: 10){
                        Text("Home")
                        NavigationLink(destination: Text("Profile View")){
                            Text("Profile")
                        }
                        NavigationLink(destination: SettingView(setting: setting)){
                            Text("Setting")
                        }
                    }.navigationBarHidden(true).navigationTitle("主页")
                }
            }.frame(width: proxy.size.width , height: proxy.size.height, alignment: .leading)
        }
    }
}

进入时显示

 

点击Setting显示

 

其中每个字符都可以改变，但是，点主页返回，再进来时 只有Environment保留了修改，其他2个都初始化了，没有保留修改

1. 父子view之间传递数值的方法，@Binding,Swift变量的传递为值传递，如果父view只是简单的将数值传递给子view，传递的将是这个数值的一个copy，子view修改的也是这个copy，父view无法获取修改后的数值，所以子view需要将数值通过@Binding修饰起来，传递时需要使用$修饰,(Bingding的一个用法，Binding.constant(“数值”)生成一个Binding<>类型的数据,在previews中使用)这样子view可以将改变的数值传回父view中.

子view

struct ProfileView: View {     
    @Binding var type:String         
    var body: some View {         
        HStack(){             
            Spacer()             
            TextField("类型", text: $type)             
            Spacer()             
            Text("建筑面积").frame(maxWidth: 100)             
            Spacer()             
            Text("100")             
            Spacer()             
            Text("平方米")             
            Spacer()         
        }             
    } 
}

父view

struct HomeTabView: View {     
    @State var type:String     
    var body: some View {         
        TabView{             
            ProfileView(type:$type).tabItem{Text("Profile")}                    
            SettingView().tabItem{Text("Settting")
        }         
     }     
} 

1. View之间通过构造函数传递

使用 @ObserverdObject 修饰一个对象，这个对象的可以被很多的View使用，在View中使用@StateObject修饰对象,当View修改这个对象的变量时，所有使用到这个对象的view都会刷新。缺点，需要将对象一层层传递。具体的使用方式如下：

• 定义一个实现ObservableObject协议的类，并且对于需要跟踪的属性使用@Published 修饰

• 在View中使用这个类的对象，并且用@ObservedObject修饰

代码部分如下：

定义类MyBuilding，其中name被跟踪

final class MyBuilding:ObservableObject{     
    @Published var name="b1" 
}

Mainiew中显示name

struct MainView: View {     
    @ObservedObject var mybuilding:MyBuilding     
    var body: some View {         
        VStack(){             
            Text("name : \(mybuilding.name)")         
        }     
    } 
}

SettingView中修改name，切换到MainView显示出name修改后的数据

struct SettingView: View {     
    @ObservedObject var building:MyBuilding     
    var body: some View {         
        VStack(){             
            HStack(){                 
                Text("Name:")                 
                TextField("Name:",text: $building.name)             
            }.padding()         
        }             
     } 
}

 

1. 全局变量/环境变量

对于第3种方式，每个View都需要构造函数中传递变量是十分的麻烦， 我们可以将一个对象放置到全局环境中，在每个view中都获取这个对象。步骤

• 定义一个实现ObservableObject协议的类，需要跟踪的数值使用@Published 修饰

• 通过.envrionmentObject(对象)将一个对象放置到环境中

• 在view中使用这个对象,@EnvironmentObject修饰对象

• 注意，没有.envrionmentObject()设置环境中的对象，程序会崩溃。

代码，在app中添加对象

struct StudySwiftApp: App {     
    @StateObject private var building=MyBuilding()     
    var body: some Scene {         
        WindowGroup {             
            HomeTabView().environmentObject(building)         
        }     
     } 
}

在SettingView中使用，并且修改数值(name)

struct SettingView: View {     
    @EnvironmentObject var building:MyBuilding         
    var body: some View {         
        VStack(){             
            HStack(){                 
                Text("Name:")                 
                TextField("Name:",text: $building.name)             
            }.padding()         
        }     
    } 
} 

struct SettingView_Previews: PreviewProvider {     
        static var previews: some View { 
                    SettingView().environmentObject(MyBuilding())     
        } 
}

在MainView中获取对象的name属性，当SettingView修改时，MAinView可以刷新到修改后的数值

struct MainView: View {     
    @EnvironmentObject var mybuilding:MyBuilding     
    var body: some View {         
        VStack(){             
            Text("name : \(mybuilding.name)")         
        }     
    } 
} 

struct MainView_Previews: PreviewProvider {     
    static var previews: some View {    
             MainView().environmentObject(MyBuilding())     
    } 
}

在MainView和SettingView的Preview中，都需要MainView().environmentObject(MyBuilding())否则会崩溃

总结

1. 只在当前View中的数据，使用@State修饰就可以。

2. 当前View中是对象，或者结构体，使用@StateObject。

3. 父子View传递变量，子View的变量用@Binding修饰

4. 多个View之间传递,可以通过ObservableObject的方法，这个方法有一个缺点，View中的变量需要在构造时传入，所以当需要跨级调用View时，需要一层层的传递变量

5. 设置全局(环境)变量 ,通过@EnvironmentObject获取这个全局变量