Swift中如何加速25MB数据文件的字节串替换操作？

问题背景 #

需要读取25MB的数据文件，将所有指定字符串替换为等长的目标字符串，再写入新子文件夹并保留原文件名。当前实现速度极慢：前4次匹配替换仅需数分之一秒，但后续遍历剩余内容耗时达10秒。已知当前有4个匹配项，但无法排除存在更多匹配的可能，因此提前退出的优化方式存在风险。

当前实现代码 #

public func edit(from: String, to: String, url: URL) -> Bool
{
    do
    {
        var bytes = [UInt8]()

        let data = try Data(contentsOf: self.url)

        var buffer = [UInt8](repeating: 0, count: data.count)
        data.copyBytes(to: &buffer, count: data.count)
        bytes = buffer
        
        var stringBytes = Array(from.utf8)
        var replaceBytes = Array(to.utf8)

        replaceAll(source: bytes, oldBytes: stringBytes, newBytes: replaceBytes)

        let newData = Data(bytes: &bytes, count: bytes.count)
        try newData.write(to: url)

        return true
    } catch
    {
        return false
    }
}

private func replaceAll(source: [UInt8], oldBytes: [UInt8], newBytes: [UInt8]) -> Void
{
    var source = source
    
    for i in 0..<(source.count - oldBytes.count + 1)
    {
        var match = true
        for j in 0..<oldBytes.count
        {
            if (source[i + j] != oldBytes[j])
            {
                match = false
                break
            }
        }
        if (match)
        {
            for j in 0..<newBytes.count
            {
                source[i+j] = newBytes[j]
            }
        }
    }
}

优化方案 #

1. 消除不必要的内存拷贝 #

当前代码存在多处冗余拷贝：

• Data转[UInt8]时，直接用Array(data)即可完成转换，避免初始化buffer再拷贝的额外操作。
• replaceAll函数的source参数是值传递，会拷贝整个25MB的数组，改为inout参数直接修改原数组，节省拷贝开销。

2. 优化匹配算法 #

原暴力匹配算法在数据量较大时效率极低，对于4-5字节的短模式，改用KMP算法减少重复比较次数。KMP通过预处理模式串生成跳转表，避免匹配失败时回溯主串，大幅提升匹配速度。

3. 直接操作Data类型 #

Swift的Data本身支持直接访问和修改字节，无需转成[UInt8]数组，进一步减少内存操作。用withUnsafeMutableBytes直接操作底层字节缓冲区，避免数组转换的开销。

优化后的代码示例 #

public func edit(from: String, to: String, url: URL) -> Bool {
    do {
        let oldBytes = Array(from.utf8)
        guard oldBytes.count == to.utf8.count else {
            // 等长替换校验，不符合直接返回失败
            return false
        }
        let newBytes = Array(to.utf8)
        guard !oldBytes.isEmpty else { return true }
        
        var data = try Data(contentsOf: self.url)
        replaceAll(in: &data, oldBytes: oldBytes, newBytes: newBytes)
        
        try data.write(to: url)
        return true
    } catch {
        return false
    }
}

private func replaceAll(in data: inout Data, oldBytes: [UInt8], newBytes: [UInt8]) {
    let patternLength = oldBytes.count
    guard patternLength <= data.count else { return }
    
    // KMP算法：生成部分匹配表
    var lps = [Int](repeating: 0, count: patternLength)
    var len = 0 // 最长相等前后缀长度
    var i = 1
    while i < patternLength {
        if oldBytes[i] == oldBytes[len] {
            len += 1
            lps[i] = len
            i += 1
        } else {
            if len != 0 {
                len = lps[len - 1]
            } else {
                lps[i] = 0
                i += 1
            }
        }
    }
    
    // 开始匹配替换
    var dataIndex = 0
    var patternIndex = 0
    data.withUnsafeMutableBytes { buffer in
        let bytes = buffer.baseAddress!.assumingMemoryBound(to: UInt8.self)
        while dataIndex < data.count {
            if bytes[dataIndex] == oldBytes[patternIndex] {
                dataIndex += 1
                patternIndex += 1
                
                if patternIndex == patternLength {
                    // 找到匹配，替换字节
                    for j in 0..<patternLength {
                        bytes[dataIndex - patternLength + j] = newBytes[j]
                    }
                    // 重置patternIndex，继续寻找下一个匹配
                    patternIndex = lps[patternIndex - 1]
                }
            } else {
                if patternIndex != 0 {
                    patternIndex = lps[patternIndex - 1]
                } else {
                    dataIndex += 1
                }
            }
        }
    }
}

额外优化建议 #

• 如果文件后续持续增大，可考虑分块读取处理，但需要处理跨块的匹配情况，实现复杂度会更高；25MB的文件一次性处理完全可行。
• 提前校验from和to的字节长度是否相等，避免无效操作。

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