为什么 ViewModifier 不应用 EnvironmentKey 的更改？

这是修饰符排序的问题。视图修饰符只会拾取在应用视图修饰符后设置的环境值。但是按照您的方式，环境值是在应用视图修饰符之前设置的。

您可以通过将.bordered()修饰符移入进行修复MyView：

// MyView

Text(value)
    .foregroundStyle(color)
    .bordered() // 👈 modifier inserted here
    .environment(\.borderColor, color)
    .environment(\.isBorderEnabled, border)

// ContentView

MyView(value: "Hello, world!", color: .red, border: true)
    // .bordered() // 👈 modifier removed from here

使其工作的另一种方法是稍微改变一下逻辑。

• 如果启用，子视图将确定边框所使用的颜色。
• 父视图决定边框是否启用。

事实上，您已经让父视图确定边框是否启用，因为您将布尔标志作为参数传递给子视图。

这里有更新的例子来展示它如何以这种方式工作。

• 父视图正在.isBorderEnabled通过View扩展设置环境变量bordered。
• 要关闭边框，请将其false作为参数提供给.bordered，或者根本不要调用它。
• 子视图通过新的扩展BorderedModifier来调用视图修饰符。ViewborderColor
• 颜色直接传递给视图修饰符，因此.borderColor不再需要环境键。

struct ContentView: View {
    var body: some View {
        VStack {
            MyView(value: "The quick brown fox", color: .red)
            MyView(value: "jumps over the lazy dog", color: .blue)
        }
        .bordered()
        // .bordered(false)
    }
}

struct MyView: View {
    let value: String
    let color: Color

    var body: some View {
        Text(value)
            .foregroundStyle(color)
            .borderColor(color: color)
    }
}

struct BorderedModifier: ViewModifier {
    let color: Color
    @Environment(\.isBorderEnabled) private var border

    func body(content: Content) -> some View {
        Group {
            if border {
                content
                    .padding(5.0)
                    .overlay(
                        RoundedRectangle(cornerRadius: 4)
                            .stroke(color, lineWidth: 2)
                    )
            } else {
                content
            }
        }
    }
}

extension View {
    func borderColor(color: Color = .black) -> some View {
        self.modifier(BorderedModifier(color: color))
    }

    func bordered(_ enabled: Bool = true) -> some View {
        self.environment(\.isBorderEnabled, enabled)
    }
}


private struct BorderEnabledKey: EnvironmentKey {
    static let defaultValue: Bool = false
}

extension EnvironmentValues {
    var isBorderEnabled: Bool {
        get { self[BorderEnabledKey.self] }
        set { self[BorderEnabledKey.self] = newValue }
    }
}

我找到了一种方法来停止重复输入父视图中已经存在的值。我使用的是 PreferenceKey。我看到的限制是我必须将此修饰符应用于我想要修改的视图。理想情况下，我希望将其应用于 VStack 一次，以便所有四个 MyView 实例都得到修改。目前，如果您将修饰符应用于 VStack，它会将 VStack 视为内容并仅应用一次修改。在最佳情况下，我希望修饰符通过 VStack 并影响所有 MyView 实例。

import SwiftUI

struct ContentView: View {
    var body: some View {
        
        VStack {
            MyView(value: "The quick brown fox", color: .red, border: false)
                .bordered()
            
            MyView(value: "jumps over the lazy dog", color: .blue, border: true)
                .bordered()
            
            MyView(value: "The quick brown fox", color: .green, border: false)
                .bordered()
            
            MyView(value: "jumps over the lazy dog", color: .yellow, border: true)
                .bordered()
        }
       
    }
}

struct MyView: View {
    
    let value: String
    let color: Color
    let border: Bool
    
    var body: some View {
        Text(value)
            .foregroundStyle(color)
            .preference(key: ColorPreferenceKey.self, value: color)
            .preference(key: BooleanPreferenceKey.self, value: border)

    }
}

struct BorderedModifier: ViewModifier {
    
    @State private var color: Color = Color.primary
    @State private var border: Bool = false

    func body(content: Content) -> some View {
        
      return Group {
            if (border) {
                content
                    .padding(5.0)
                    .overlay(
                        RoundedRectangle(cornerRadius: 4)
                            .stroke(color, lineWidth: 2)
                    )
            } else {
                content
            }
        }
        .onPreferenceChange(ColorPreferenceKey.self) { newValue in color = newValue }
        .onPreferenceChange(BooleanPreferenceKey.self) { newValue in border = newValue }

    }
}

extension View {
    func bordered() -> some View {
        self.modifier(BorderedModifier())
    }
}



struct ColorPreferenceKey: PreferenceKey {
    
    static var defaultValue: Color { get { return Color.primary } }
    static func reduce(value: inout Color, nextValue: () -> Color) { value = nextValue() }
    
}

struct BooleanPreferenceKey: PreferenceKey {
    
    static var defaultValue: Bool { get { return false } }
    static func reduce(value: inout Bool, nextValue: () -> Bool) { value = nextValue() }
    
}