Swift开发macOS应用：字符串相似度计算函数无响应问题求助

问题1：双重循环导致逻辑错误+性能隐患 #

你当前的双重循环是把fileName里的每一个字符，和appName里的所有字符逐一比对，这完全不是在计算文件名与应用名的「语义相似性」——比如fileName是"Chrome"、appName是"Chromium"，你的逻辑会把'C'和"Chromium"的每个字符比一遍，'h'再重复一遍这个过程，最后统计的只是两个字符串中所有相同字符的总出现次数，完全不符合名称匹配的需求。

如果遇到较长的字符串，这种O(n*m)复杂度的循环会瞬间产生大量计算，直接阻塞主线程，导致应用无响应。

问题2：整数除法导致结果失真 #

sameCharacterCounter和counter都是Int类型，sameCharacterCounter/counter会执行整数除法——比如3次匹配、总次数5次，结果会是0而非0.6，转成Double后依然是0.0，完全达不到你要的「平均值」预期。

修复方案 #

方案1：按位置比较字符（适合名称长度相近的场景） #

如果你的需求是比较两个名称对应位置的字符匹配度，可以改成单循环，只比对相同索引的字符：

func similarity(fileName: String, appName: String) -> Double {
    let fileNameChars = Array(fileName)
    let appNameChars = Array(appName)
    let minLength = min(fileNameChars.count, appNameChars.count)
    var sameCount = 0
    
    for i in 0..<minLength {
        if fileNameChars[i] == appNameChars[i] {
            sameCount += 1
        }
    }
    
    // 先转成Double再计算，避免整数除法失真
    let similarity = Double(sameCount) / Double(minLength)
    print(similarity)
    return similarity
}

方案2：更合理的名称相似度计算（推荐） #

实际场景中，文件名和应用名可能存在大小写差异、后缀差异（比如.app）或长度不同，建议先做预处理，再用更贴合需求的算法（比如计算最长公共子序列占比）：

func similarity(fileName: String, appName: String) -> Double {
    // 预处理：统一小写、移除常见后缀和特殊字符
    func preprocess(_ str: String) -> String {
        var processed = str.lowercased()
        // 移除.app后缀
        processed = processed.replacingOccurrences(of: ".app", with: "")
        // 移除空格和非字母数字字符
        processed = processed.components(separatedBy: CharacterSet.alphanumerics.inverted).joined()
        return processed
    }
    
    let processedFileName = preprocess(fileName)
    let processedAppName = preprocess(appName)
    
    guard !processedFileName.isEmpty, !processedAppName.isEmpty else {
        return 0.0
    }
    
    // 计算最长公共子序列长度
    func longestCommonSubsequenceLength(_ a: String, _ b: String) -> Int {
        let aChars = Array(a)
        let bChars = Array(b)
        var dp = Array(repeating: Array(repeating: 0, count: bChars.count+1), count: aChars.count+1)
        
        for i in 1...aChars.count {
            for j in 1...bChars.count {
                if aChars[i-1] == bChars[j-1] {
                    dp[i][j] = dp[i-1][j-1] + 1
                } else {
                    dp[i][j] = max(dp[i-1][j], dp[i][j-1])
                }
            }
        }
        return dp[aChars.count][bChars.count]
    }
    
    let lcsLength = longestCommonSubsequenceLength(processedFileName, processedAppName)
    let maxLength = max(processedFileName.count, processedAppName.count)
    let similarity = Double(lcsLength) / Double(maxLength)
    print(similarity)
    return similarity
}

额外建议 #

如果要批量处理大量文件和应用，建议把计算逻辑放到后台线程执行，避免阻塞主线程导致应用无响应，示例代码：

DispatchQueue.global().async {
    let sim = similarity(fileName: "Chrome.app", appName: "Google Chrome")
    // 回到主线程更新UI或处理结果
    DispatchQueue.main.async {
        // 这里处理计算结果
    }
}

内容的提问来源于stack exchange，提问作者user_767_