Save Array of Strings to CoreData

My suggestion is to encode/decode the array to JSON and use a computed property. From the Swift perspective this is probably more efficient than a transformable attribute which bridges the array to the Objective-C runtime and uses heavier NSCoding.

@NSManaged public var imageUrls: String

var urls : [String] {
    get {
        let data = Data(imageUrls.utf8)
        return (try? JSONDecoder().decode([String].self, from: data)) ?? []
    }
    set {
        guard let data = try? JSONEncoder().encode(newValue),
            let string = String(data: data, encoding: .utf8) else { imageUrls = "" }
        imageUrls = string
    }
}

Another benefit is that a JSON string is searchable

check the attachement below for declration in ".xcdatamodelId" file. After that declare below line in CoreDataProperties.swift file

@NSManaged public var thumbnail: [String]?

Now, we can initialised string array into thumnail variable.

You will have to save it to the core data as String and split the array with a seperator. The thing is that you have to be sure that the string will no include that seperator.

For example if you used the seperator ", " on saving your array to the core data you will have to save it like

coreData.arrayToStringValue = array.joined(separator: ", ")

and when you read your data you will have to read it like:

let arrayFromStringValue:[String] = coreDataValue.split(separator: ", ")

Change type of imageUrl to BinaryData, then convert your list to data and save.

let urls = NSKeyedArchiver.archivedData(withRootObject: imageUrls)
manageObject.setValue(urls, forKey: "imageUrls")

Swift 5

I found vadian's answer very helpful. I Used the same idea, But in a different way. Giving my code hoping that it may help.

• Select the Type of the attribute that you want to store the array as String

// save to core data

var quizManagedObject : [NSManagedObject] = []

func save(question: String, answers: [String]) {

    guard let data = try? JSONEncoder().encode(answers),
    let answersEncodedString = String(data: data, encoding: .utf8) else { return }

    guard let appDelegate = UIApplication.shared.delegate as? AppDelegate else { return }
    let managedContext = appDelegate.persistentContainer.viewContext

    let entity = NSEntityDescription.entity(forEntityName: "Quiz", in: managedContext)!
    let quiz = NSManagedObject(entity: entity, insertInto: managedContext)

    quiz.setValue(question, forKeyPath: "question")
    quiz.setValue(answersEncodedString, forKeyPath: "answers")

    do {
        quizManagedObject.append(quiz)
        try managedContext.save()
    } catch let error as NSError {
        print("Could not save. \(error), \(error.userInfo)")
    }
}

// fetch from core data

func fetchCoreData() {

    guard let appDelegate = UIApplication.shared.delegate as? AppDelegate else { return }
    let managedContext = appDelegate.persistentContainer.viewContext
    let fetchRequest = NSFetchRequest<NSManagedObject>(entityName: "Quiz")

    do {
        quizManagedObject = try managedContext.fetch(fetchRequest)

        for i in quizManagedObject {
            if let decodedAnswerString = i.value(forKey: "answers") as? String {
                let data = Data(decodedAnswerString.utf8)
                let answerArray = try? JSONDecoder().decode([String].self, from: data)
                let question = i.value(forKey: "question") as! String

                print("Q : ", question)
                print("A : ", answerArray ?? [""])
            }
        }
    } catch let error as NSError {
        print("Could not fetch. \(error), \(error.userInfo)")
    }
}

If your object is transformable without any custom class you might either want to cast it to [NSObject] and save it like that as it's the Transformable base-type. But you probably should make it [String] as the base class.

There are also no indication of you ever saving the data to core data? What you have displayed is just assigning a variable in a model. Which you really never should do as they should be immutable and not mutable.