graph TDA[View初始化] --> B(监测使用了那些状态)B -->|针对使用了propertywrapper的属性| C[当状态发生变化]C --> D[重新计算body]

@available(iOS 13.0, macOS 10.15, tvOS 13.0, watchOS 6.0, *)public protocol ObservableObject : AnyObject {
    /// The type of publisher that emits before the object has changed.    associatedtype ObjectWillChangePublisher : Publisher = ObservableObjectPublisher where Self.ObjectWillChangePublisher.Failure == Never
    /// A publisher that emits before the object has changed.    var objectWillChange: Self.ObjectWillChangePublisher { get }}

@available(iOS 13.0, macOS 10.15, tvOS 13.0, watchOS 6.0, *)extension ObservableObject where Self.ObjectWillChangePublisher == ObservableObjectPublisher {
    /// A publisher that emits before the object has changed.    public var objectWillChange: ObservableObjectPublisher { get }}

/// A publisher that publishes changes from observable objects.@available(iOS 13.0, macOS 10.15, tvOS 13.0, watchOS 6.0, *)final public class ObservableObjectPublisher : Publisher {
    /// The kind of values published by this publisher.    public typealias Output = Void
    /// The kind of errors this publisher might publish.    ///    /// Use `Never` if this `Publisher` does not publish errors.    public typealias Failure = Never
    /// Creates an observable object publisher instance.    public init()
    /// Attaches the specified subscriber to this publisher.    ///    /// Implementations of ``Publisher`` must implement this method.    ///    /// The provided implementation of ``Publisher/subscribe(_:)-4u8kn``calls this method.    ///    /// - Parameter subscriber: The subscriber to attach to this ``Publisher``, after which it can receive values.    final public func receive<S>(subscriber: S) where S : Subscriber, S.Failure == ObservableObjectPublisher.Failure, S.Input == ObservableObjectPublisher.Output
    final public func send()}

class UserAuthentication: ObservableObject {    let objectWillChange = ObservableObjectPublisher()  //可选
    var username = "" {        willSet {            //保存到UerDefault中            //条件过滤            //.......            objectWillChange.send()        }    }}
struct ContentView: View {    @StateObject var settings = UserAuthentication()
    var body: some View {        VStack {            TextField("Username", text: $settings.username)                .textFieldStyle(RoundedBorderTextFieldStyle())
            Text("Your username is: \(settings.username)")        }    }}

@propertyWrapper @frozen public struct ObservedObject<ObjectType> : DynamicProperty where ObjectType : ObservableObject {
    /// A wrapper of the underlying observable object that can create bindings to    /// its properties using dynamic member lookup.    @dynamicMemberLookup @frozen public struct Wrapper {
        /// Returns a binding to the resulting value of a given key path.        ///        /// - Parameter keyPath  : A key path to a specific resulting value.        ///        /// - Returns: A new binding.        public subscript<Subject>(dynamicMember keyPath: ReferenceWritableKeyPath<ObjectType, Subject>) -> Binding<Subject> { get }    }
    /// Creates an observed object with an initial value.    ///    /// - Parameter initialValue: An initial value.    public init(initialValue: ObjectType)
    /// Creates an observed object with an initial wrapped value.    ///    /// You don't call this initializer directly. Instead, declare a property    /// with the `@ObservedObject` attribute, and provide an initial value.    ///    /// - Parameter wrappedValue: An initial value.    public init(wrappedValue: ObjectType)
    /// The underlying value referenced by the observed object.    ///    /// This property provides primary access to the value's data. However, you    /// don't access `wrappedValue` directly. Instead, you use the property    /// variable created with the `@ObservedObject` attribute.    ///    /// When a mutable value changes, the new value is immediately available.    /// However, a view displaying the value is updated asynchronously and may    /// not show the new value immediately.    public var wrappedValue: ObjectType
    /// A projection of the observed object that creates bindings to its    /// properties using dynamic member lookup.    ///    /// Use the projected value to pass a binding value down a view hierarchy.    /// To get the `projectedValue`, prefix the property variable with `$`.    public var projectedValue: ObservedObject<ObjectType>.Wrapper { get }}

final class PodcastPlayer: ObservableObject {    @Published private(set) var isPlaying: Bool = false  //private(set)，setter方法私有，getter方法默认等级
    func play() {        isPlaying = true    }
    func pause() {        isPlaying = false    }}
struct EpisodesView: View {    @ObservedObject var player: PodcastPlayer    var body: some View {        List {            Button(                action: {                    if self.player.isPlaying {                        self.player.pause()                    } else {                        self.player.play()                    }            }, label: {                    Text(player.isPlaying ? "Pause": "Play")                }            )        }    }}

struct LibraryView: View {    @StateObject var book = Book()        var body: some View {        BookView(book: book)    }}
VStack {    LibraryView()    LibraryView()}

@frozen @propertyWrapper public struct StateObject<ObjectType> : DynamicProperty where ObjectType : ObservableObject {
    /// Creates a new state object with an initial wrapped value.    ///    /// You don’t call this initializer directly. Instead, declare a property    /// with the `@StateObject` attribute in a ``SwiftUI/View``,    /// ``SwiftUI/App``, or ``SwiftUI/Scene``, and provide an initial value:    ///    ///     struct MyView: View {    ///         @StateObject var model = DataModel()    ///    ///         // ...    ///     }    ///    /// SwiftUI creates only one instance of the state object for each    /// container instance that you declare. In the code above, SwiftUI    /// creates `model` only the first time it initializes a particular instance    /// of `MyView`. On the other hand, each different instance of `MyView`    /// receives a distinct copy of the data model.    ///    /// - Parameter thunk: An initial value for the state object.    @inlinable public init(wrappedValue thunk: @autoclosure @escaping () -> ObjectType)
    /// The underlying value referenced by the state object.    ///    /// The wrapped value property provides primary access to the value's data.    /// However, you don't access `wrappedValue` directly. Instead, use the    /// property variable created with the `@StateObject` attribute:    ///    ///     @StateObject var contact = Contact()    ///    ///     var body: some View {    ///         Text(contact.name) // Accesses contact's wrapped value.    ///     }    ///    /// When you change a property of the wrapped value, you can access the new    /// value immediately. However, SwiftUI updates views displaying the value    /// asynchronously, so the user interface might not update immediately.    public var wrappedValue: ObjectType { get }
    /// A projection of the state object that creates bindings to its    /// properties.    ///    /// Use the projected value to pass a binding value down a view hierarchy.    /// To get the projected value, prefix the property variable with `$`. For    /// example, you can get a binding to a model's `isEnabled` Boolean so that    /// a ``SwiftUI/Toggle`` view can control the value:    ///    ///     struct MyView: View {    ///         @StateObject var model = DataModel()    ///    ///         var body: some View {    ///             Toggle("Enabled", isOn: $model.isEnabled)    ///         }    ///     }    public var projectedValue: ObservedObject<ObjectType>.Wrapper { get }}

//首先定义了一个类对象模型StateObjectClass，遵循ObservableObjectclass StateObjectClass:ObservableObject{    let type:String    let id:Int    @Published var count = 0    //    init(type:String){        self.type = type        self.id = Int.random(in: 0...1000)        print("type:\(type) id:\(id) init")    }    deinit {        print("type:\(type) id:\(id) deinit")    }}//使用不同的propertywrapper修饰相同的StateObjectClass对象//1，使用StateObjectstruct CountViewState:View{    @StateObject var state = StateObjectClass(type:"StateObject")//1    var body: some View{        VStack{            Text("@StateObject count :\(state.count)")            Button("+1"){                state.count += 1            }        }    }}//2，使用ObservedObjectstruct CountViewObserved:View{    @ObservedObject var state = StateObjectClass(type:"Observed")//2    var body: some View{        VStack{            Text("@Observed count :\(state.count)")            Button("+1"){                state.count += 1            }        }    }}

struct Test1: View {    @State var count = 0    var body: some View {        VStack{            Text("刷新CounterView计数 :\(count)")            Button("刷新"){                count += 1            }
            CountViewState()                .padding()
            CountViewObserved()                .padding()
        }    }}

type:Observed id:537 inittype:StateObject id:886 inittype:Observed id:873 inittype:Observed id:537 deinit

struct Test2: View {    @State var count = 0    var body: some View {        NavigationView{            List{                NavigationLink("@StateObject", destination: CountViewState())                NavigationLink("@ObservedObject", destination: CountViewObserved())            }        }    }}

struct Test3: View {    @State private var showStateObjectSheet = false    @State private var showObservedObjectSheet = false    var body: some View {        List{            Button("Show StateObject Sheet"){                showStateObjectSheet.toggle()            }            .sheet(isPresented: $showStateObjectSheet) {                CountViewState()            }            Button("Show ObservedObject Sheet"){                showObservedObjectSheet.toggle()            }            .sheet(isPresented: $showObservedObjectSheet) {                CountViewObserved()            }        }    }}

class Student: ObservableObject {    @Published var name:String = "xiaoming"    @Published var count:Int = 0    init() {        print("Student init")  //1 只走一次    }}
struct ContentView: View {    @StateObject var student = Student()        init() {        print("init")    //2 数据更新，每次View重新绘制，会走    }    var body: some View {        Button(action: {            student.count += 1   //3         }) {            VStack{                Text("name=\(student.name)")                Text("count=\(student.count)")                Text("+1")            }        }    }}

(lldb) p student2020-07-07 17:16:31.140496+0800 stateExplorer[76800:4929521] [SwiftUI] Accessing StateObject's object without being installed on a View. This will create a new instance each time.(stateExplorer.Student) $R0 = 0x00006000034d6340 (_name = Combine.Published<Swift.String> @ 0x00006000034d6350, _count = Combine.Published<Swift.Int> @ 0x00006000034d6368)(lldb) p student2020-07-07 17:16:33.305996+0800 stateExplorer[76800:4929521] [SwiftUI] Accessing StateObject's object without being installed on a View. This will create a new instance each time.(stateExplorer.Student) $R2 = 0x0000600003497b00 (_name = Combine.Published<Swift.String> @ 0x0000600003497b10, _count = Combine.Published<Swift.Int> @ 0x0000600003497b28)(lldb) 

(lldb) p student(stateExplorer.Student) $R6 = 0x00006000034c24c0 (_name = Combine.Published<Swift.String> @ 0x00006000034c24d0, _count = Combine.Published<Swift.Int> @ 0x00006000034c24e8)(lldb) p student(stateExplorer.Student) $R8 = 0x00006000034c24c0 (_name = Combine.Published<Swift.String> @ 0x00006000034c24d0, _count = Combine.Published<Swift.Int> @ 0x00006000034c24e8)

(lldb) p student(stateExplorer.Student) $R10 = 0x00006000034c24c0 (_name = Combine.Published<Swift.String> @ 0x00006000034c24d0, _count = Combine.Published<Swift.Int> @ 0x00006000034c24e8)

//Counter对象Modelclass Counter: ObservableObject {    @Published var count: Int        init(_ initialCount: Int) {        self.count = initialCount    }        func increment() {        count += 1    }        func decrement() {        count -= 1    }}//Counters是父视图，包含两个StateObject，counter1和counter2，count的初始值都是0struct Counters: View {    @State var useFirstCounter = true    @StateObject var counter1 = Counter(0)    @StateObject var counter2 = Counter(0)        var body: some View {        VStack {            Counter1(counter: useFirstCounter ? counter1 : counter2)            Counter2(counter: useFirstCounter ? counter1 : counter2)            Button("Switch Counter") {                useFirstCounter.toggle()            }        }    }}
//子视图Counter1，从父ViewCounters接受参数传入，其内部counter使用@ObservedObjectstruct Counter1: View {    @ObservedObject var counter: Counter        init(counter: Counter) {        self.counter = counter    }        var body: some View {        HStack {            Button { counter.decrement() } label: { Image(systemName: "minus.circle") }            Text("\(counter.count)")            Button { counter.increment() } label: { Image(systemName: "plus.circle") }        }    }}
//子视图Counter2，从父ViewCounters接受参数传入，其内部counter使用@StateObject，意味着在以后的视图更新中，它会每次都使用相同的实例，//甚至如果父视图随后传入一个不同的counter，也不会变化。struct Counter2: View {    @StateObject var counter: Counter        init(counter: Counter) {        self._counter = StateObject(wrappedValue: counter)    }        var body: some View {        HStack {            Button { counter.decrement() } label: { Image(systemName: "minus.circle") }            Text("\(counter.count)")            Button { counter.increment() } label: { Image(systemName: "plus.circle") }        }    }}

@StateObject var counter: Counter = Counter（） //1

    @StateObject var counter: Counter        init(counter: Counter) {        self._counter = StateObject(wrappedValue: counter)  //2       //self.counter = counter   //3    }

class SearchDelayer: ObservableObject {    //用户每次输入内容都会更新inputText    @Published var inputText: String        //查询输入结果，当用户输入后，延时500毫秒后赋值给当前参数，这期间可能发生多次变化，但是只会把最终的值赋给query    @Published var query: String    init(text: String) {        inputText = text        query = text        $inputText            .debounce(for: .milliseconds(500), scheduler: DispatchQueue.main)            .assign(to: $query)    }}

struct GameSearchScreen: View {  @StateObject private var searchDelayer = SearchDelayer(text: "")}

struct GameSearchScreen: View {  @StateObject private var searchDelayer: SearchDelayer  init(initialQuery: String = "") {      _searchDelayer = StateObject(wrappedValue: SearchDelayer(text: initialQuery))  }    // ...}