SwiftUI: Why are init() called in reversed order?

I'm using environmentObject to update a string.

1. Why does does ContentView2's init called when no the environmentObject it's using was not updated?
2. In my mind, i would expect the init() calls to follow the hierarchy from contentView to view1 than view2, but instead ContentView's init() is called later? why is that so?

upon clicking "View1" Button, print output:

init View1
init ContentView

upon clicking "View2" Button, print output:

init View1
init View2
init ContentView

Here's the short sample code:
ContentView2.swift

import SwiftUI

class Model: ObservableObject {
    @Published var strA: String = "strA"
    @Published var strB: String = "strB"
    @Published var strC: String = "strC"
}
class Model2: ObservableObject {
    @Published var showView1: Bool = false
    @Published var showView2: Bool = false
}

struct ContentView2: View {
    @EnvironmentObject var model2: Model2
    init() {
        print("init ContentView")
    }

    var body: some View {
        VStack {
            Image(systemName: "globe")
                .imageScale(.large)
                .foregroundColor(.accentColor)

            HStack {
                if model2.showView1 {
                    ViewA()
                }
                if model2.showView2 {
                    ViewB()
                }
            }
            .border(.black)
            HStack {
                Button("View1") { model2.showView1.toggle() }
                Button("View2") { model2.showView2.toggle() }
            }
        }
        .padding()
    }
}

ViewA.swift

struct ViewA: View {
    @EnvironmentObject var model: Model

    init() {
        print("init View1")
    }

    var body: some View {
        Button("Click") {
            print("Click view1 button")
            model.strC = "strC Changed"
        }
        Text("viewA text : \(model.strB)")
    }
}

ViewB.swift

struct ViewB: View {
    @EnvironmentObject var model: Model

    init() {
        print("init View2")
    }

    var body: some View {
        VStack {
            Button("Click") {
                print("Click view2 button")
            }
            Text("viewB text : \(model.strC)")
        }
    }
}

My guess is you have put @StateObject in your App struct instead of using a singleton for your store object, e.g. .environmentObject(Model.shared). When you use these object wrappers, body is called regardless if a property is accessed or not. That's why you should try to use value types everywhere you can, e.g. with @State, body is only called when the state changes if it was previously read in body.

Don't worry, SwiftUI's use of structs for these View data descriptions means it is basically negligible to init them. Its like initing an int, you would never care about that. SwiftUI diffs them and it actually only does anything when something is different from last time. So these View structs are constantly being init and discarded, that's one reason why you shouldn't do anything heavy like init an object inside body.

To add to @malhal's answer: a View calling init doesn't necessarily imply the underlying view content is being reloaded.
The Views themself are an abstraction of the underlying visual objects that are actually being displayed on the screen.

SwiftUI might recreate a view for a non-obvious reason and then internally compare the elements of the view based on their explicit or structural identities (see WWDC21 talk #10022 for more info).
It will redraw a view (or parts of the view) if these have changed, and will try not to if there's no change.

Don't try to deduce anything about view redrawing based on when your views are created or discarded.
You should use the APIs provided (e.g. .id() on a view) and leave SwiftUI to decide what needs to update and when.
If you're running into performance issues use Instruments' SwiftUI tool to see which views are being redrawn too much and optimize from there.