在 Swift 中的数组之间是否有更好的选择方法？

Question

我有一个包含函数的结构，该函数使用由某个变量决定的数据集。我有一个解决方案，但似乎会有更好的方法来解决这个问题。

下面是一些示例代码：

struct TextStyles {
    let format: UTType

    static var asm: [NSRegularExpression: NSColor] = [: /* ... */]
    static var txt: [NSRegularExpression: NSColor] = [: /* ... */]
    
    func getAppropriateDataset() -> [NSRegularExpression: NSColor] {
        switch format {
            case "asm": return TextStyles.asm
            case "txt": return TextStyles.txt
            // returns empty
            default: return .init()
        }
    }
}

struct HighlightDelegate {
    let format: UTType
    lazy var styleSelector: TextStyles(format: format)

    func applyHighlights(for text: String) -> NSAttributedString {
        // Should always produce the same key/value list, because `format` never changes
        styleSelector.getAppropriateDataset()
    }
}

创建这样的单例有什么通用的做法吗？该函数总是生成相同的列表，那么是否有任何本机或“更好”的方法来解决这个问题？如果能这样写就好了：

struct HighlightDelegate {
    let format: UTType
    lazy var styleUsed = TextStyles.getStyleArray(forFormat: format)
    // or even better, perhaps?: TextStyles(forFormat: format)

    func applyHighlights(for text: String) -> NSAttributedString {
        // `styleUsed` is the array for this HighlightDelegate
    }
}

Answer 1

我不完全理解你的问题，但我使用的是答案而不是评论，这样我就可以很好地包含代码。

如果我能猜到的话，我认为你正在争取延期。

extension UTType {
    var styles: [NSRegularExpression: NSColor] {
        switch self {
            ...
        }
    }
}

struct HighlightDelegate {
    let format: UTType

    func applyHighlights(for text: String) -> NSAttributedString {
        ...
        format.styles
        ...
    }
}

如果你真的想让styles成为HighlightDelegate的属性，你可以

struct HighlightDelegate {
    let format: UTType
    var styles: [NSRegularExpression: NSColor] { format.styles }

    func applyHighlights(for text: String) -> NSAttributedString {
        ...
        styles
        ...
    }
}

或者如果你真的想缓存样式（对我来说似乎没有必要，但你可以）

class HighlightDelegate {
    let format: UTType
    lazy var styles = format.styles

    func applyHighlights(for text: String) -> NSAttributedString {
        ...
        styles
        ...
    }

    init(format: UTType) {
        self.format = format
    }
}

在这种情况下，您经常使用 class 因为访问结构的惰性属性是变异的（它将在第一次访问时更改结构的位）。

如果保留 TextStyles 类型很重要，您可以相应地修改此代码。如果这不是您想要的，请发表评论。

Answer 2

我想我可以在数组之间使用 enum 到 select，以及 returns 其中一个值的静态方法。

enum TextStyles {
    static let asm: [NSRegularExpression: NSColor] = [: /* ... */]
    static let txt: [NSRegularExpression: NSColor] = [: /* ... */]
    
    static func getAppropriateDataset(for format: UTType) -> [NSRegularExpression: NSColor] {
        switch format {
            case .asm: return TextStyles.asm
            case .txt: return TextStyles.txt
            // returns empty
            default: return [:]
        }
    }
}

示例用法：

struct HighlightDelegate {
    let format: UTType
    lazy var style = TextStyles.getAppropriateDataset(for: format)

    // ...
}

在 Swift 中的数组之间是否有更好的选择方法？

Is there a better way of selecting between arrays in Swift?

arrays

singleton

swift