JSON, Codable, Image, trying to encode array of struct that include image by converting image to base64

Storing images as Base64 is very expensive, in storage space, memory, and computation. I do not recommend it unless there's a particular need. If you want a static JSON file, then I would recommend storing images in separate files (as PNGs or JPGs or whatever they are) and storing their URLs in the JSON if necessary. If all you're storing is the name and image, then I would just put them in a directory and let the name be the filename. Then the filesystem is your database. There's no need for JSON in that case. Small mounts of metadata can also be put in the filename if needed.

If you want to store everything in a single file, look at binary property lists. They can store Data directly without the wasteful conversion to Base64, and support Codeable directly.

If this is also your server protocol, as opposed to just the persistence model that you described, and you prefer to manage it as Base64-encoded JSON rather than a more efficient binary protocol, than Codable can handle that directly.

extension P: Codable {
    enum CodingKeys: String, CodingKey {
        case image, name
    }

    func encode(to encoder: Encoder) throws {
        var container = encoder.container(keyedBy: CodingKeys.self)
        try container.encode(name, forKey: .name)
        try container.encodeIfPresent(image?.pngData()?.base64EncodedString(), forKey: .image)
    }

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.name = try container.decode(String.self, forKey: .name)
        let imageB64 = try container.decode(String.self, forKey: .image)
        if let imageData = Data(base64Encoded: imageB64) {
            self.image = UIImage(data: imageData)
        }
    }
}

Encoding this way locally for persistent storage is pretty inefficient, but as you say, iPhones can handle the computation. It's a lot of disk churn, though, if there are many small changes (which will degrade the user's flash storage, which has a finite number of writes), but it should work.

This solution uses userdefault and it is not a good choice for large amounts of data.

struct p: Codable {
    var imgData: Data
    var name: String
    
    public init(img: UIImage,name: String) {
        self.imgData = img.pngData()!
        self.name = name
    }
}

Use Userdefault Helper like this to store and get data:

class UserDefaultsHandler: NSObject {
    static let shared = UserDefaultsHandler()
    let userDefaults: UserDefaults?
    
    private override init() {
        userDefaults = UserDefaults.standard
    }
    
    func set<T>(obj: T?, forKey key: String) where T: Encodable {
          guard let tempValue = obj else {
              userDefaults?.set(nil, forKey: key)
              return
          }
          let jsonEncoder = JSONEncoder()
          guard let jsonData = try? jsonEncoder.encode(tempValue) else {
              userDefaults?.set(nil, forKey: key)
              return
          }
          let json = String(data: jsonData, encoding: .utf8)
          userDefaults?.set(json, forKey: key)
      }
     
      func get<T: Decodable>(key: String, type: T.Type) -> T? {
          let jsonString = userDefaults?.object(forKey: key) as? String
          let jsonData = jsonString?.data(using: .utf8)
          let decoder = JSONDecoder()
          return try? decoder.decode(type, from: jsonData ?? Data())
      }
}

// Set an Get Example

  let arr = [p(img: img, name: "Apple"), p(img: img, name: "Mango"), p(img: img, name: "Pinapple")]
                UserDefaultsHandler.shared.set(obj: arr, forKey: "ImageArray")


 guard let arr = UserDefaultsHandler.shared.get(key: "ImageArray", type: [p].self) else { return }