Question

我制作了离线字典应用。现在，我将字典文件转换为领域数据库。

转换功能：

if let path = Bundle.main.path(forResource: "dictionary", ofType: "dsl") {
        do {
            let data = try String(contentsOfFile: path, encoding: .utf8)
            let myStrings = data.components(separatedBy: .newlines)

            for (index, row) in myStrings.enumerated() {

                if(row.containsChineseCharacters)
                {
                    let firstWord = CNDict()
                    firstWord.word = row
                    firstWord.pinyin = myStrings[index+1]
                    firstWord.translate = myStrings[index+2]

                    try! realm.write {
                        realm.add(firstWord)
                    }
                }
            }
            print("The task end.")
        } catch {
            print(error)
        }
     }

当我尝试立即转换字典时，数据库文件变得很大，并在中间崩溃了

将字典分成几部分是不可行的，因为大约有300万行。这将需要很多...（领域插件崩溃）

我需要有关崩溃时如何向数据库中添加尽可能多的值的帮助。

Answer 1

问题在于您的文件很大，此时，您将其加载到内存中：

        let data = try String(contentsOfFile: path, encoding: .utf8)

然后在此处将内存占用增加一倍：

        let myStrings = data.components(separatedBy: .newlines)

所以我的猜测是您收到了来自系统的内存不足信号。

您可以使用lazy集合，而不是将所有数据加载到内存中，也可以将数据翻倍。仅在需要写入时，它才会读取和解析该行。它不会一次加载所有行。 Swift中的惰性集合的一个缺点是它们无法提供我们习惯的所有功能。

这是解决您问题的游乐场的完整代码。您可以并且也许应该优化它的某些部分，但是无论如何，它只是显示如何使用lazy集合来完成它。（我更改了一些名称，但仍然是您想要的）。

import Foundation

extension String {
    var containsOneSymbol: Bool {
        return contains("1")
    }
}

extension Character {
    var isNewLine: Bool {
        let string = String(self)
        let set = CharacterSet(charactersIn: string)

        return !set.isDisjoint(with: CharacterSet.newlines)
    }
}


/// Add Object subclass for Realm
@objcMembers
final class CNDict {
    dynamic var word = ""
    dynamic var pinyin = ""
    dynamic var translate = ""
}

final class ModelWriterWrapper {
    private let bufferCapacity = 3
    private var buffer: [String] = []
    init() {
        buffer.reserveCapacity(bufferCapacity)
    }

    func proccess(line: String) {
        guard buffer.count == bufferCapacity else {
            assert(buffer.count < bufferCapacity, "Buffer failer count: \(buffer.count)!")
            buffer.append(line)
            return
        }

        if let firstLine = buffer.first, firstLine.containsOneSymbol {
            let dict = CNDict()
            dict.word = firstLine
            dict.pinyin = buffer[1]
            dict.translate = buffer[2]

            print("Ready for writing into DB \n word: \(dict.word) pinyin: \(dict.pinyin) translate: \(dict.translate)")
        }

        buffer.removeFirst()
        buffer.append(line)
    }
}

let data = stride(from: 0, to: 100_000, by: 1).map { "Line number \($0)\n"}.joined()

var line: String = ""
let myLines = data.lazy.map { char -> String in
    line.append(char)
    guard !char.isNewLine else {
        defer { line = "" }
        return line
    }

    return ""
}.filter { !$0.isEmpty }


let databaseWritter = ModelWriterWrapper()

myLines.forEach {
    databaseWritter.proccess(line: $0)
}

如果对代码有任何疑问，请询问。

迅捷的境界。如何在数据库中放置300万个对象

1 个答案: