CalebK's questions

我正在创建一个应用，其主 UI 是 WKWebView，SwiftUI 仅用于应用的零散部分。我在使用 SwiftUI 系统 UI 时遇到了一些问题TabView。运行此示例应用时，出现了一些我无法解释的行为。

enum Page: String, Hashable, CaseIterable, Identifiable {
    case settings = "gear"
    case radio = "radio"
    case connect = "dot.radiowaves.right"
    
    var id: String { rawValue }
}

struct RandomColorHostedWebView: UIViewRepresentable {
    let webView: WKWebView
    
    init() {
        // Clear cache to be extra sure https://stackoverflow.com/a/34376943/3833632
        WKWebsiteDataStore.default().removeData(ofTypes: [WKWebsiteDataTypeDiskCache, WKWebsiteDataTypeMemoryCache], modifiedSince: Date(timeIntervalSince1970: 0), completionHandler:{ })
        let webConfiguration = WKWebViewConfiguration()
        self.webView = WKWebView(frame: .zero, configuration: webConfiguration)
        let urlRequest = URLRequest(url: URL(string: "https://randomcolour.com")!)
        self.webView.load(urlRequest)
    }
    
    func makeUIView(context: Context) -> UIView {
        return webView
    }

    func updateUIView(_ uiView: UIView, context: Context) {
    }
}



struct ContentView: View {
    let pages = Page.allCases
    
    let randomColor: RandomColorHostedWebView
    init() {
        randomColor = RandomColorHostedWebView()
    }
    
    var body: some View {
        TabView {
            ForEach(pages) { page in
                randomColor
                    .tag(page)
                    .tabItem {
                        Label(page.rawValue, systemImage: page.rawValue)
                    }
            }
        }
    }
}

运行此程序，你会发现每次点击标签页都会触发刷新动画，但不会加载新的颜色。此外，当你返回之前访问过的标签页时，页面会显示空白。

我无法解释这种现象。 （我很想知道为什么会发生这种情况）

话虽如此，我假设原因是 SwiftUI 不知道每个 tabItem 父视图都是相同的视图，因为它们具有不同的结构标识。

因此，我只能寻找一种解决方法，要么使 TabView 的背景清晰，以便我可以使用ZStack，要么将TabView高度限制为仅限选项卡内容，以便我可以使用VStack，或者其他方法。

现有的解决方案尝试移除 TabView 的背景，但似乎无效。我同意一位评论者的观点，即该解决方案在更高版本的操作系统中似乎已失效。

   var body: some View {
        ZStack {
            randomColor
            TabView {
                ForEach(pages) { page in
                    Color.clear
                        // https://stackoverflow.com/questions/63178381/make-tabview-background-transparent
                        .background(BackgroundHelper())
                        .tag(page)
                        .tabItem {
                            Label(page.rawValue, systemImage: page.rawValue)
                        }
                }
            }
        }
    }

此示例应用程序在 macOS 15.4 上运行时，打开和关闭侧边栏时会表现出奇怪的动画行为。

您需要做的就是删除该.frame(minWidth: 805, minHeight: 525)行以修复它，但这意味着您无法限制窗口的大小。

我希望我的应用程序有一个最小尺寸，但这defaultSize()行不通。

enum Page: String, Hashable {
    case settings = "Settings"
    case radio = "Radio"
    case connect = "Connect"
    
    var systemImageName: String {
        switch self {
        case .settings:
            return "gear"
        case .radio:
            return "radio"
        case .connect:
            return "dot.radiowaves.right"
        }
    }
}

struct ContentView: View {
    @State var pages = [Page.settings, Page.radio, Page.connect]
    
    var body: some View {
        NavigationSplitView {
            List(pages, id: \.self) { page in
                Label(page.rawValue.capitalized, systemImage: page.systemImageName)
            }
        } detail: {
            Text("Content")
        }
    }
}

@main
struct NavigationTestsApp: App {
    var body: some Scene {
        Window("Navigation", id: "H") {
            Group {
                ContentView()
                    // Without this line this animation bug does not happen
                    .frame(minWidth: 805, minHeight: 525)
            }
        }
    }
}

我是 CoreData 的新手，但我创建了一个对象，打算在 SwiftUI 中的 ForEach 循环内使用该数组。

在实体编辑器中，我添加了一个 UUID 属性stored_id。然后在扩展中我写了以下内容：

extension Item: Identifiable {
    public var id: UUID {
        guard let stored_id else {
            assertionFailure("No stored ID")
            return UUID()
        }
        return stored_id
    }
    
}

我觉得这很奇怪，原因有很多，比如根据 CoreData 的语义，stored_id 是可选的。出于某种原因，这难道不是不好的做法吗？

我正在尝试遵循此处列出的一些最佳实践。我特别想确保我进行了绝对导入。我对 Node 和 Typescript 还不太熟悉，所以我预计我会经常移动文件。

因此我tsconfig.json使用建议的配置了我的文件

{
  "compilerOptions": {
    "baseUrl": ".",
    "paths": {
      "@/*": ["./src/*"]
    },

听起来它做的事情很简单。只需将“@/*”替换为相对于顶层的绝对源路径文件。这样，导入不会根据导入文件的位置而改变。

我的 VS 代码似乎能理解这一点。我不确定它是如何做到的，但 vscode 中有一个系统，如果我输入了错误的导入，就会出现这样的错误

但如果我输入正确，就不会出现错误

我的文件设置如下

但是当我运行时，npm start终端中运行的东西好像正在运行与 VSCode 中运行的不同的东西，因为替换似乎不起作用。我收到一个错误：

TS2307: Cannot find module '@/components/WebsiteTitles' or its corresponding type declarations.

或者

ERROR in ./src/App.tsx 6:0-54
Module not found: Error: Can't resolve '@/components/WebsiteTitles' in '/Users/main/Coding/portfolio-website/src'

如果有帮助的话，我的本地主机是一台 Mac。

例如这个代码：

func trigramSimilarity(to other: Set<String>) -> Double {
    let selfTrigram = trigrams()
    let total = selfTrigram.union(other)
    let common = selfTrigram.intersection(other)
    return total.isEmpty ? 0 : Double(common.count) / Double(total.count)
}

我希望编译器转换为

func trigramSimilarity(to other: Set<String>) -> Double {
    let selfTrigram = trigrams()
    let total = selfTrigram.union(other)
    return total.isEmpty ? 0 : Double(selfTrigram.intersection(other).count) / Double(total.count)
}

通过注意到，如果swift 编译器可以让我编写更简单的代码但避免不必要的计算，那么这let common是不需要的。total.isEmpty

但直接说出来是否更安全呢？

我正在尝试制作一个弹出窗口，其内容会根据上述选择动态扩展。我本来希望没有动画，或者理想情况下弹出窗口会逐渐扩展其新内容，但结果却像是我在弹出窗口中放置了一个滚动视图，您可以看到菜单重新加载。

有趣的是，如果您对按钮执行相同的操作，只是修改状态属性，则此动画不会发生。

我猜在某种意义上，我将动画系统与不稳定的 ID 混淆了，但我试过在所有内容上都放置 .id() 参数，但并没有解决问题。

struct DropdownTestView: View {
    @State var presentPopover: Bool = false
    @State var choice: Int = 0

    var body: some View {
        VStack {
            Button {
                presentPopover = true
            } label: {
                Text("Press To Choose")
            }
            .popover(isPresented: $presentPopover) {
                popoverView
                    .padding()
            }
            Spacer()
        }
        .padding()
    }

    var popoverView: some View {
        VStack(alignment: .leading) {
            Divider()

            Menu {
                ForEach(0..<6) { num in
                    Button {
                        choice = num
                    } label: {
                        Text("\(num)")
                    }
                }
            } label: {
                Text("Make A Choice")
            }

            if choice != 0 {
                Divider()
                HStack {
                    Text("WRONG CHOICE")
                }
            }
        }
        .frame(width: 220)
    }
}

我尝试过这样的事情：

HStack {
    Text("WRONG CHOICE")
}
.opacity(choice != 0 ? 1.0 : 0)
.frame(choice != 0 ? 30, 0)

但这也不起作用。

我正在尝试创建按钮，这些按钮在必要时会变宽到最大宽度，此时它们会使用“...”来截断标题。我知道按钮框架有一些不寻常的地方，比如在之前或之后应用框架的区别，.buttonStyle但这种行为让我感到惊讶。

似乎应用maxWidth会使按钮占用该宽度，即使它不需要。如果您应用为其提供背景的按钮样式，按钮周围就会有空白。

我发现这也适用Text()。

struct TestButton: View {
    let title: String

    var body: some View {
        Button {
            print(title)
        } label: {
            Text(title)
                .lineLimit(1)
        }
        .frame(maxWidth: 180)
        .background(.purple)
        .buttonStyle(PlainButtonStyle())
        .focusable()
    }
}
HStack {
    TestButton(title: "Bears")
    TestButton(title: "Battlestar Galactica")
}

我猜想如果错误更有帮助的话这将是显而易见的，但目前这是我试图编译的代码。

struct MultiselectFilterDropdown<C>: View where C : Identifiable, C.ID : Equatable, C.ID : CustomStringConvertible {
    var allItems: [C]

    var body: some View {
        VStack {
            ForEach(allItems) { item in
                Text(item.description)
            }
        }
    }
}

我不知道为什么编译器无法解决这个问题。我曾看到它说无法转换为Range<Int>，Binding<C>所以我猜编译器甚至不知道 ForEach 的哪个初始化器最相关。

我正在使用 List 来实现高度定制的界面。这主要是因为字段header以及在.plain模式下标题如何粘在内容上方。

问题是标题似乎有鲜艳效果。这是不理想的，因为在这种情况下，标题应该只是左侧的一个按钮。

有什么方法可以消除这种振动效果吗？或者我应该使用一些复杂的几何读取器逻辑来构建自己的粘性标头实现？

在我的应用中，我有各种按钮。它们有许多共同的特点，但颜色不同。我试图编写一个包含每个按钮样式的类，明确指出它们唯一的不同之处是颜色。

问题是我还想对其中一个使用 .tint。但那是一个ShapeStyle而不是一个 Color。

struct CommonButtonStyle: ButtonStyle {
    @Environment(\.isEnabled) var isEnabled: Bool
    
    @Environment(\.isFocused) var isFocused: Bool
    
    var labelColor: Color
    
    var enabledColor: some ShapeStyle
    var pressedColor: Color
    
    func makeBody(configuration: Configuration) -> some View {
        configuration.label
            .font(.system(size: 14, weight: .bold))
            .padding(.horizontal, 16)
            .padding(.vertical, 10)
            .foregroundStyle(labelColor)
            .frame(maxHeight: 40)
            .background((isEnabled && configuration.isPressed) ? pressedColor : enabledColor)
            .clipShape(Capsule())
            .containerShape(Capsule())
            .opacity(isEnabled ? 1 : 0.5)
            .focusable()
    }
}

这里的问题是不匹配的返回类型和声明，var enabledColor: some ShapeStyle因为编译器抱怨Property declares an opaque return type, but has no initializer expression from which to infer an underlying type

有没有办法让我得到这个变量来存储一个Color或一个，ShapeStyle以便我可以做

CommonButtonStyle(labelColor: .black, enabledColor: .tint, pressedColor: .white)

和

CommonButtonStyle(labelColor: .black, enabledColor: .blue, pressedColor: .white)

我试图实现一个相当简单的动画，其中列表中的选定项会应用背景。目标是选定项后面的灰色框能够平滑地从上一个位置变形到下一个位置。

我使用 来实现这一点，matchedGeometryEffect以便 SwiftUI 可以匹配两个状态之间的背景视图，即使从技术上讲它们具有不同的 ID 路径。然而，这一努力被以下因素所阻碍：List

这是示例项目。要中断动画，您只需将按钮放在列表中即可。

为什么 List 会破坏此动画？有什么方法可以解决这个问题吗？

struct AnimationButtonStyle: ButtonStyle {
    
    var isCurrent: Bool
    var animationNamespace: Namespace.ID
    
    var backgroundView: some View {
        Color.gray
        .cornerRadius(8)
        .matchedGeometryEffect(id: "Shape", in: animationNamespace)
    }
    
    func makeBody(configuration: Configuration) -> some View {
        configuration.label
            .background(
                isCurrent ? backgroundView : nil
            )
            .opacity(configuration.isPressed ? 0.5 : 1.0)
    }
}

struct ContentView: View {
    enum cases: String, CaseIterable {
        case foo = "Foo"
        case bar = "Barrrrrr"
        case bat = "Battttttttttttttt"
    }
    
    @Namespace private var animationNamespace
    @State var animatedCurrentCase: cases = .foo
    @State var currentCase: cases = .foo
    @State var isAnimating: Bool = false
    
    var body: some View {
        VStack {
            // Without the list this animation will work
            List {
                Section {
                    VStack(alignment: .leading, spacing: 0) {
                        ForEach(Array(cases.allCases.enumerated()), id: \.offset) { index, theCase in
                            var isCurrent: Bool { theCase == animatedCurrentCase }
                            Button {
                                isAnimating = true
                                Task { @MainActor in
                                    animatedCurrentCase = theCase
                                    try? await Task.sleep(nanoseconds: 200_000_000)
                                    currentCase = theCase
                                    isAnimating = false
                                }
                            } label: {
                                Label {
                                    Text(theCase.rawValue)
                                } icon: {
                                    VStack(alignment: .leading) {
                                        Text("\(index)")
                                    }
                                    .frame(width: isCurrent ? 16 + 4 : 16)
                                }
                            }
                            .disabled(isAnimating)
                            .buttonStyle(AnimationButtonStyle(isCurrent: isCurrent, animationNamespace: animationNamespace))
                            .animation(.smooth, value: animatedCurrentCase)
                        }
                    }
                }
            }
            Spacer().frame(height: 10)
            Text("Selected: \(currentCase.rawValue)")
                .font(.title)
        }
        .padding()
    }
}

我正在尝试编写一行，该行的计算结果为 bool，表示可选的 Date 对象是否在未来。

我写了以下声明

let dateIsInFuture = (optionalDate ?? .now) >= .now

我很好奇这是否是一种不好的形式。特别是因为如果第一个和第二个 .now 在不同时间评估，它们可能不再相等。当然，我现在可以拉出到另一行来消除这种歧义......但我很好奇这是否适用于 swift 编译和运行这行代码的方式。

我看到很多关于 AsyncImage 以及如何刷新它的问题。在这种情况下有点不同。图像 URL 保持不变，但图像会定期更改。因此，我希望有一个按钮来刷新它。

问题是oldUrl == newURL。我什至尝试了一些技巧，在父级上设置边框颜色来尝试欺骗 SwiftUI 刷新它，但这些都不起作用。现在我手动显示和隐藏视图来完成这项工作。这当然是不可取的。

可能还有其他办法吗？