根据我的观察，你不可能改变一个观点的转变而不改变它的身份。一旦视图出现了一个过渡，你不能告诉它消失与另一个过渡。
所以解决这个问题的一种方法是有 * 两个 * X按钮，一个带有.opacity转换，另一个带有.move。使用@State来决定显示哪个按钮：
范例：

@State var showButtons = false
@State var shouldMove = false

var body: some View {
    VStack {
        // imagine this is your text field
        Rectangle().frame(width: 100, height: 100).onTapGesture {
            withAnimation {
                showButtons = true
            }
        }
        Spacer()
        if showButtons {
            // make buttons with different transitions
            // if shouldMove, show the button with the move transition
            // otherwise show the button with the opacity transition
            if shouldMove {
                makeButton(transition: .asymmetric(insertion: .opacity, removal: .move(edge: .trailing)))
            } else {
                makeButton(transition: .opacity)
            }
            
            Button("Cancel") {
                shouldMove = true
                withAnimation {
                    showButtons.toggle()
                }
            }
        }
    }.frame(height: 300)
}

@ViewBuilder func makeButton(transition: AnyTransition) -> some View {
    Button("X") {
        shouldMove = false
        withAnimation {
            showButtons.toggle()
        }
    }.transition(transition)
}

另一种方法是在每次想要更改过渡时为X按钮提供一个新的id，从而创建一个“新”视图。

@State var showButtons = false
@State var transition: AnyTransition = .opacity
@State var buttonId = UUID()

var body: some View {
    VStack {
        Rectangle().frame(width: 100, height: 100).onTapGesture {
            withAnimation {
                showButtons = true
            }
        }
        Spacer()
        if showButtons {
            Button("X") {
                transition = .opacity
                buttonId = UUID() // new id!
                withAnimation {
                    showButtons.toggle()
                }
            }
            .transition(transition)
            .id(buttonId)
            
            Button("Cancel") {
                transition = .asymmetric(insertion: .opacity, removal: .move(edge: .trailing))
                buttonId = UUID() // new id!
                withAnimation {
                    showButtons.toggle()
                }
            }
        }
    }.frame(height: 300)
}

解决这个问题的一种方法是在物品周围放置多层容器。不同的容器可以具有不同的过渡。
这表明它正在工作：

struct ContentView: View {

    enum ExitTransitionType {
        case opacity
        case move
    }

    @State private var exitType: ExitTransitionType?

    var body: some View {
        VStack {
            HStack {
                if exitType != .move {
                    HStack {
                        if exitType != .opacity {
                            HStack {
                                Spacer()
                                Button("Cancel") { exitType = .move }
                            }
                            .overlay {
                                Button { exitType = .opacity } label: {
                                    Image(systemName: "xmark")
                                        .resizable()
                                        .scaledToFit()
                                        .padding(12)
                                        .foregroundColor(Color(UIColor.secondaryLabel))
                                        .frame(width: 44, height: 44)
                                        .contentShape(Rectangle())
                                        .accessibilityAddTraits(.isButton)
                                }
                            }
                            .padding(30)
                            .transition(.opacity)
                        }
                    }
                    .transition(.move(edge: .trailing))
                }
            }
            .frame(minHeight: 100)

            if exitType != nil {
                Button("Reset") { exitType = nil }
                    .buttonStyle(.borderedProminent)
                    .transition(.scale)
            }
        }
        .animation(.easeInOut(duration: 0.8), value: exitType)
    }
}

在不透明度过渡的情况下，周围的容器（将具有移动过渡）仍然存在，但为空。如果你也想隐藏它，那么你可以有一个额外的布尔标志，比如containersAreVisible，你可以在嵌套内容的onDisappear回调中将其设置为false。
如果您只希望部分内容消失（比如X按钮，而不是Cancel按钮），那么您可以将Cancel按钮移动到更高一级的容器中，以便它包含在一个过渡中，但从另一个过渡中排除。
另一个例子是这个方法的实际应用，参见SwiftUI bi-directional move transition moving the wrong way in certain cases的解决方案。