KakaJSON

中文教程

Integration

CocoaPods

pod 'KakaJSON', '~> 1.1.2' 

Carthage

github "kakaopensource/KakaJSON" ~> 1.1.2

Swift Package Manager

Usages

Coding

// file path (can be String or URL)
let file = "/Users/mj/Desktop/test.data"
/****************** String ******************/
let string1 = "123"
// wrtite String to file
write(string1, to: file)
// read String from file
let string2 = read(String.self, from: file)
XCTAssert(string2 == string1)
// read Int from file
XCTAssert(read(Int.self, from: file) == 123)
/****************** Date ******************/
let date1 = Date(timeIntervalSince1970: 1565922866)
// wrtite Date to file
write(date1, to: file)
 
// read Date from file
let date2 = read(Date.self, from: file)
XCTAssert(date2 == date1)
 
// read Int from file
XCTAssert(read(Int.self, from: file) == 1565922866)
/****************** Array ******************/
let array1 = ["Jack", "Rose"]
// wrtite [String] to file
write(array1, to: file)
 
// read [String] from file
let array2 = read([String].self, from: file)
XCTAssert(array2 == array1)
// Also support Set\Dictionary
/****************** Model ******************/
struct Book: Convertible {
 var name: String = ""
 var price: Double = 0.0
}
 
struct Car: Convertible {
 var name: String = ""
 var price: Double = 0.0
}
 
struct Dog: Convertible {
 var name: String = ""
 var age: Int = 0
}
 
struct Person: Convertible {
 var name: String = "Jack"
 var car: Car? = Car(name: "Bently", price: 106.666)
 var books: [Book]? = [
 Book(name: "Fast C++", price: 666.6),
 Book(name: "Data Structure And Algorithm", price: 666.6),
 ]
 var dogs: [String: Dog]? = [
 "dog0": Dog(name: "Wang", age: 5),
 "dog1": Dog(name: "ErHa", age: 3),
 ]
}
 
// wrtite Person to file
write(Person(), to: file)
 
// read Person from file
let person = read(Person.self, from: file)
 
XCTAssert(person?.name == "Jack")
XCTAssert(person?.car?.name == "Bently")
XCTAssert(person?.car?.price == 106.666)
XCTAssert(person?.books?.count == 2)
XCTAssert(person?.dogs?.count == 2)
/****************** Model Array ******************/
struct Car: Convertible {
 var name: String = ""
 var price: Double = 0.0
}
 
let models1 = [
 Car(name: "BMW", price: 100.0),
 Car(name: "Audi", price: 70.0)
]
// wrtite [Car] to file
write(models1, to: file)
 
// read [Car] from file
let models2 = read([Car].self, from: file)
XCTAssert(models2?.count == models1.count)
XCTAssert(models2?[0].name == "BMW")
XCTAssert(models2?[0].price == 100.0)
XCTAssert(models2?[1].name == "Audi")
XCTAssert(models2?[1].price == 70.0)
/****************** Model Set ******************/
struct Car: Convertible, Hashable {
 var name: String = ""
 var price: Double = 0.0
}
 
let models1: Set<Car> = [
 Car(name: "BMW", price: 100.0),
 Car(name: "Audi", price: 70.0)
]
 
// wrtite Set<Car> to file
write(models1, to: file)
 
// read Set<Car> from file
let models2 = read(Set<Car>.self, from: file)!
XCTAssert(models2.count == models1.count)
for car in models2 {
 XCTAssert(["BMW", "Audi"].contains(car.name))
 XCTAssert([100.0, 70.0].contains(car.price))
}
/****************** Model Dictionary ******************/
struct Car: Convertible {
 var name: String = ""
 var price: Double = 0.0
}
 
let models1 = [
 "car0": Car(name: "BMW", price: 100.0),
 "car1": Car(name: "Audi", price: 70.0)
]
 
// wrtite [String: Car] to file
write(models1, to: file)
 
// read [String: Car] from file
let models2 = read([String: Car].self, from: file)
XCTAssert(models2?.count == models1.count)
 
let car0 = models2?["car0"]
XCTAssert(car0?.name == "BMW")
XCTAssert(car0?.price == 100.0)
 
let car1 = models2?["car1"]
XCTAssert(car1?.name == "Audi")
XCTAssert(car1?.price == 70.0)

JSON To Model_01_Basic Usage

Simple Model

struct Cat: Convertible {
 var name: String = ""
 var weight: Double = 0.0
}
// json can also be NSDictionary, NSMutableDictionary
let json: [String: Any] = [
 "name": "Miaomiao",
 "weight": 6.66
]
let cat1 = json.kj.model(Cat.self)
XCTAssert(cat1.name == "Miaomiao")
XCTAssert(cat1.weight == 6.66)
// you can call global function `model`
let cat2 = model(from: json, Cat.self)
// support type variable
var type: Convertible.Type = Cat.self
let cat3 = json.kj.model(type: type) as? Cat
let cat4 = model(from: json, type: type) as? Cat

Class Type

class Cat: Convertible {
 var weight: Double = 0.0
 var name: String = ""
 // The protocol `Convertible` required an init constructor
 // for initializing an instance completely.
 required init() {}
}
let json = ...
let cat = json.kj.model(Cat.self)
// a class inherit from NSObject
class Person: NSObject, Convertible {
 var name: String = ""
 var age: Int = 0
 // must add `override` because NSObject has `init`
 required override init() {}
}
let person = json.kj.model(Person.self)
struct Dog: Convertible {
 var weight: Double = 0.0
 var name: String = ""
 // This struct don't need to implement init because compiler generates init for it
}
struct Pig: Convertible {
 var weight: Double
 var name: String
 // This struct need to implement init to initialize all the stored properties.
 init() {
 name = ""
 weight = 0.0
 }
}

Inheritance

class Person: Convertible {
 var name: String = ""
 var age: Int = 0
 required init() {}
}
 
class Student: Person {
 var score: Int = 0
 var no: String = ""
}
 
let json: [String: Any] = [
 "name": "jack",
 "age": 18,
 "score": 98,
 "no": "9527"
]
 
let student = json.kj.model(Student.self)

let

struct Cat: Convertible {
 // let of integer type is very restricted in release mode
 // please user `private(set) var` instead of `let`
 private(set) var weight: Double = 0.0
 let name: String = ""
}
let json = ...
let cat = json.kj.model(Cat.self)

NSNull

struct Cat: Convertible {
 var weight: Double = 0.0
 var name: String = "xx"
 var data: NSNull?
}
let json: [String: Any] = [
 "name": NSNull(),
 "weight": 6.6,
 "data": NSNull()
]
let cat = json.kj.model(Cat.self)
// convert failed, keep default value
XCTAssert(cat.name == "xx")
XCTAssert(cat.weight == 6.6)
XCTAssert(cat.data == NSNull())

JSONString

// jsonString can alse be NSString, NSMutableString
let jsonString = """
{
"name": "Miaomiao",
"weight": 6.66
}
"""
 
let cat1 = jsonString.kj.model(Cat.self)
let cat2 = model(from: jsonString, Cat.self)
var type: Convertible.Type = Cat.self
let cat3 = jsonString.kj.model(type: type) as? Cat
let cat4 = model(from: jsonString, type: type) as? Cat

JSONData

// jsonData can alse be NSData, NSMutableData
let jsonData = """
{
"name": "Miaomiao",
"weight": 6.66
}
""".data(using: .utf8)!
 
let cat1 = jsonData.kj.model(Cat.self)
let cat2 = model(from: jsonData, Cat.self)
var type: Convertible.Type = Cat.self
let cat3 = jsonData.kj.model(type: type) as? Cat
let cat4 = model(from: jsonData, type: type) as? Cat

Nested Model 1

// let all the models comform to Convertible
struct Book: Convertible {
 var name: String = ""
 var price: Double = 0.0
}
 
struct Car: Convertible {
 var name: String = ""
 var price: Double = 0.0
}
 
struct Dog: Convertible {
 var name: String = ""
 var age: Int = 0
}
 
struct Person: Convertible {
 var name: String = ""
 var car: Car?
 var books: [Book]?
 var dogs: [String: Dog]?
}
 
let json: [String: Any] = [
 "name": "Jack",
 "car": ["name": "BMW7", "price": 105.5],
 "books": [
 ["name": "Fast C++", "price": 666.6],
 ["name": "Data Structure And Algorithm", "price": 1666.6]
 ],
 "dogs": [
 "dog0": ["name": "Larry", "age": 5],
 "dog1": ["name": "ErHa", "age": 2]
 ]
]
 
let person = json.kj.model(Person.self)
XCTAssert(person.car?.name == "BMW7")
XCTAssert(person.books?[1].name == "Data Structure And Algorithm")
XCTAssert(person.dogs?["dog0"]?.name == "Larry")

Nested Model 2

struct Book: Convertible, Hashable {
 var name: String = ""
 var price: Double = 0.0
}
 
struct Person: Convertible {
 var name: String = ""
 var books: Set<Book>?
}
 
let json: [String: Any] = [
 "name": "Jack",
 "books": [
 ["name": "Fast C++", "price": 666.6]
 ]
]
 
let person = json.kj.model(Person.self)
XCTAssert(person.name == "Jack")
 
XCTAssert(person.books?.count == 1)
let book = person.books?.randomElement()
XCTAssert(book?.name == "Fast C++")
XCTAssert(book?.price == 666.6)

Nested Model 3

struct Car: Convertible {
 var name: String = ""
 var price: Double = 0.0
}
class Dog: Convertible {
 var name: String = ""
 var age: Int = 0
 required init() {}
 init(name: String, age: Int) {
 self.name = name
 self.age = age
 }
}
struct Person: Convertible {
 var name: String = ""
 // KakaJSON will use your defaultValue instead of creating a new model
 // KakaJSON will not creat a new model again if you already have a default model value
 var car: Car = Car(name: "Bently", price: 106.5)
 var dog: Dog = Dog(name: "Larry", age: 5)
}
let json: [String: Any] = [
 "name": "Jake",
 "car": ["price": 305.6],
 "dog": ["name": "Wangwang"]
]
let person = json.kj.model(Person.self)
XCTAssert(person.name == "Jake")
// keep defaultValue
XCTAssert(person.car.name == "Bently")
// use value from json
XCTAssert(person.car.price == 305.6)
// use value from json
XCTAssert(person.dog.name == "Wangwang")
// keep defaultValue
XCTAssert(person.dog.age == 5)

Recursive

class Person: Convertible {
 var name: String = ""
 var parent: Person?
 required init() {}
}
 
let json: [String: Any] = [
 "name": "Jack",
 "parent": ["name": "Jim"]
]
 
let person = json.kj.model(Person.self)
XCTAssert(person.name == "Jack")
XCTAssert(person.parent?.name == "Jim")

Generic

struct NetResponse<Element>: Convertible {
 let data: Element? = nil
 let msg: String = ""
 private(set) var code: Int = 0
}
 
struct User: Convertible {
 let id: String = ""
 let nickName: String = ""
}
 
struct Goods: Convertible {
 private(set) var price: CGFloat = 0.0
 let name: String = ""
}
 
let json1 = """
{
"data": {"nickName": "KaKa", "id": 213234234},
"msg": "Success",
"code" : 200
}
"""
let response1 = json1.kj.model(NetResponse<User>.self)
XCTAssert(response1?.msg == "Success")
XCTAssert(response1?.code == 200)
XCTAssert(response1?.data?.nickName == "KaKa")
XCTAssert(response1?.data?.id == "213234234")
let json2 = """
{
"data": [
 {"price": "6199", "name": "iPhone XR"},
 {"price": "8199", "name": "iPhone XS"},
 {"price": "9099", "name": "iPhone Max"}
 ],
"msg": "Success",
"code" : 200
}
"""
let response2 = json2.kj.model(NetResponse<[Goods]>.self)
XCTAssert(response2?.msg == "Success")
XCTAssert(response2?.code == 200)
XCTAssert(response2?.data?.count == 3)
XCTAssert(response2?.data?[0].price == 6199)
XCTAssert(response2?.data?[0].name == "iPhone XR")
XCTAssert(response2?.data?[1].price == 8199)
XCTAssert(response2?.data?[1].name == "iPhone XS")
XCTAssert(response2?.data?[2].price == 9099)
XCTAssert(response2?.data?[2].name == "iPhone Max")

Model Array

struct Car: Convertible {
 var name: String = ""
 var price: Double = 0.0
}
 
// json can also be NSArray, NSMutableArray
let json: [[String: Any]] = [
 ["name": "Benz", "price": 98.6],
 ["name": "Bently", "price": 305.7],
 ["name": "Audi", "price": 64.7]
]
 
 
let cars1 = json.kj.modelArray(Car.self)
XCTAssert(cars1[1].name == "Bently")
 
let cars2 = modelArray(from: json, Car.self)
var type: Convertible.Type = Car.self
let cars3 = json.kj.modelArray(type: type) as? [Car]
let cars4 = modelArray(from: json, type: type) as? [Car]
 
// jsonString -> Model Array
let jsonString = "...."
let cars5 = jsonString.kj.modelArray(Car.self)
let cars6 = modelArray(from: jsonString, Car.self)
let cars7 = jsonString.kj.modelArray(type: type) as? [Car]
let cars8 = modelArray(from: jsonString, type: type) as? [Car]

Model Array In Dictionary

struct Book: Convertible {
 var name: String = ""
 var price: Double = 0.0
}
struct Person: Convertible {
 var name: String = ""
 var books: [String: [Book?]?]?
}
let name = "Jack"
let mobileBooks = [
 (name: "iOS", price: 10.5),
 (name: "Android", price: 8.5)
]
let serverBooks = [
 (name: "Java", price: 20.5),
 (name: "Go", price: 18.5)
]
let json: [String: Any] = [
 "name": name,
 "books": [
 "mobile": [
 ["name": mobileBooks[0].name, "price": mobileBooks[0].price],
 ["name": mobileBooks[1].name, "price": mobileBooks[1].price]
 ],
 "server": [
 ["name": serverBooks[0].name, "price": serverBooks[0].price],
 ["name": serverBooks[1].name, "price": serverBooks[1].price]
 ]
 ]
]
let person = json.kj.model(Person.self)
XCTAssert(person.name == name)
let books0 = person.books?["mobile"]
XCTAssert(books0??.count == mobileBooks.count)
for i in 0..<mobileBooks.count {
 XCTAssert(books0??[i]?.name == mobileBooks[i].name);
 XCTAssert(books0??[i]?.price == mobileBooks[i].price);
}
let books1 = person.books?["server"]
XCTAssert(books1??.count == serverBooks.count)
for i in 0..<serverBooks.count {
 XCTAssert(books1??[i]?.name == serverBooks[i].name);
 XCTAssert(books1??[i]?.price == serverBooks[i].price);
}

Convert

struct Cat: Convertible {
 var name: String = ""
 var weight: Double = 0.0
}
 
let json: [String: Any] = [
 "name": "Miaomiao",
 "weight": 6.66
]
 
var cat = Cat()
// fill a cat instance with json
// .kj_m is a mutable version of .kj
cat.kj_m.convert(json)
XCTAssert(cat.name == "Miaomiao")
XCTAssert(cat.weight == 6.66)

Listen

struct Car: Convertible {
 var name: String = ""
 var age: Int = 0
 
 // call when will begin to convert from json to model
 mutating func kj_willConvertToModel(from json: JSONObject) {
 print("Car - kj_willConvertToModel")
 }
 
 // call when did finish converting from json to model
 mutating func kj_didConvertToModel(from json: JSONObject) {
 print("Car - kj_didConvertToModel")
 }
}
 
let name = "Benz"
let age = 100
let car = ["name": name, "age": age].kj.model(Car.self)
// Car - kj_willConvertToModel
// Car - kj_didConvertToModel
XCTAssert(car.name == name)
XCTAssert(car.age == age)
 
/*************************************************************/
 
class Person: Convertible {
 var name: String = ""
 var age: Int = 0
 required init() {}
 
 func kj_willConvertToModel(from json: JSONObject) {
 print("Person - kj_willConvertToModel")
 }
 
 func kj_didConvertToModel(from json: JSONObject) {
 print("Person - kj_didConvertToModel")
 }
}
 
class Student: Person {
 var score: Int = 0
 
 override func kj_willConvertToModel(from json: JSONObject) {
 // call super's implementation if necessary
 super.kj_willConvertToModel(from: json)
 
 print("Student - kj_willConvertToModel")
 }
 
 override func kj_didConvertToModel(from json: JSONObject) {
 // call super's implementation if necessary
 super.kj_didConvertToModel(from: json)
 
 print("Student - kj_didConvertToModel")
 }
}
 
let name = "jack"
let age = 10
let score = 100
let student = ["name": name, "age": age, "score": score].kj.model(Student.self)
// Person - kj_willConvertToModel
// Student - kj_willConvertToModel
// Person - kj_didConvertToModel
// Student - kj_didConvertToModel
XCTAssert(student.name == name)
XCTAssert(student.age == age)
XCTAssert(student.score == score)

JSON To Model_02_Data Type

Int

struct Student: Convertible {
 var age1: Int8 = 6
 var age2: Int16 = 0
 var age3: Int32 = 0
 var age4: Int64 = 0
 var age5: UInt8 = 0
 var age6: UInt16 = 0
 var age7: UInt32 = 0
 var age8: UInt64 = 0
 var age9: UInt = 0
 var age10: Int = 0
 var age11: Int = 0
}
 
let json: [String: Any] = [
 "age1": "suan8fa8",
 "age2": "6suan8fa8",
 "age3": "6",
 "age4": 6.66,
 "age5": NSNumber(value: 6.66),
 "age6": Int32(6),
 "age7": true,
 "age8": "FALSE", 
 "age9": Decimal(6.66),
 "age10": NSDecimalNumber(value: 6.66),
 "age11": Date(timeIntervalSince1970: 1565922866)
]
 
let student = json.kj.model(Student.self)
// convert failed,keep defualt value
XCTAssert(student.age1 == 6) 
XCTAssert(student.age2 == 6) 
XCTAssert(student.age3 == 6)
XCTAssert(student.age4 == 6)
XCTAssert(student.age5 == 6)
XCTAssert(student.age6 == 6)
// true is 1,false is 0
XCTAssert(student.age7 == 1) 
// "true"\"TRUE"\"YES"\"yes" is 1,"false"\"FALSE"\"NO"\"no" is 0
XCTAssert(student.age8 == 0) 
XCTAssert(student.age9 == 6)
XCTAssert(student.age10 == 6)
XCTAssert(student.age11 == 1565922866)

Float

struct Student: Convertible {
 var height1: Float = 0.0
 var height2: Float = 0.0
 var height3: Float = 0.0
 var height4: Float = 0.0
 var height5: Float = 0.0
 var height6: Float = 0.0
 var height7: Float = 0.0
 var height8: Float = 0.0
 var height9: Float = 0.0
}
 
let json: [String: Any] = [
 "height1": "6.66suan8fa8",
 "height2": "0.12345678",
 "height3": NSDecimalNumber(string: "0.12345678"),
 "height4": Decimal(string: "0.12345678") as Any,
 "height5": 666,
 "height6": true,
 "height7": "NO",
 "height8": CGFloat(0.12345678),
 "height9": Date(timeIntervalSince1970: 1565922866)
]
 
let student = json.kj.model(Student.self)
XCTAssert(student.height1 == 6.66)
XCTAssert(student.height2 == 0.12345678)
XCTAssert(student.height3 == 0.12345678)
XCTAssert(student.height4 == 0.12345678)
XCTAssert(student.height5 == 666.0)
// true is 1.0,false is 0.0
XCTAssert(student.height6 == 1.0)
// "true"\"TRUE"\"YES"\"yes" is 1.0,"false"\"FALSE"\"NO"\"no" is 0.0
XCTAssert(student.height7 == 0.0)
XCTAssert(student.height8 == 0.12345678)
XCTAssert(student.height9 == 1565922866)

Double

struct Student: Convertible {
 var height1: Double = 0.0
 var height2: Double = 0.0
 var height3: Double = 0.0
 var height4: Double = 0.0
 var height5: Double = 0.0
 var height6: Double = 0.0
 var height7: Double = 0.0
 var height8: Double = 0.0
 var height9: Double = 0.0
}
 
let json: [String: Any] = [
 "height1": "6.66suan8fa8",
 "height2": "0.1234567890123456",
 "height3": NSDecimalNumber(string: "0.1234567890123456"),
 "height4": Decimal(string: "0.1234567890123456") as Any,
 "height5": 666,
 "height6": true,
 "height7": "NO",
 "height8": CGFloat(0.1234567890123456),
 "height9": Date(timeIntervalSince1970: 1565922866)
]
 
let student = json.kj.model(Student.self)
XCTAssert(student.height1 == 6.66)
XCTAssert(student.height2 == 0.1234567890123456)
XCTAssert(student.height3 == 0.1234567890123456)
XCTAssert(student.height4 == 0.1234567890123456)
XCTAssert(student.height5 == 666.0)
// true is 1.0,false is 0.0
XCTAssert(student.height6 == 1.0)
// "true"\"TRUE"\"YES"\"yes" is 1.0,"false"\"FALSE"\"NO"\"no" is 0.0
XCTAssert(student.height7 == 0.0)
XCTAssert(student.height8 == 0.1234567890123456)
XCTAssert(student.height9 == 1565922866)

CGFloat

struct Student: Convertible {
 var height1: CGFloat = 0.0
 var height2: CGFloat = 0.0
 var height3: CGFloat = 0.0
 var height4: CGFloat = 0.0
 var height5: CGFloat = 0.0
 var height6: CGFloat = 0.0
 var height7: CGFloat = 0.0
 var height8: CGFloat = 0.0
 var height9: CGFloat = 0.0
}
 
let json: [String: Any] = [
 "height1": "6.66suan8fa8",
 "height2": "0.1234567890123456",
 "height3": NSDecimalNumber(string: "0.1234567890123456"),
 "height4": Decimal(string: "0.1234567890123456") as Any,
 "height5": 666,
 "height6": true,
 "height7": "NO", 
 "height8": 0.1234567890123456, 
 "height9": Date(timeIntervalSince1970: 1565922866)
]
 
let student = json.kj.model(Student.self)
XCTAssert(student.height1 == 6.66)
XCTAssert(student.height2 == CGFloat(0.1234567890123456))
XCTAssert(student.height3 == CGFloat(0.1234567890123456))
XCTAssert(student.height4 == CGFloat(0.1234567890123456))
XCTAssert(student.height5 == 666.0)
XCTAssert(student.height6 == 1.0)
XCTAssert(student.height7 == 0.0)
XCTAssert(student.height8 == CGFloat(0.1234567890123456))
XCTAssert(student.height9 == CGFloat(1565922866))

Bool

struct Student: Convertible {
 var rich1: Bool = false
 var rich2: Bool = false
 var rich3: Bool = false
 var rich4: Bool = false
 var rich5: Bool = false
 var rich6: Bool = false
}
 
let json: [String: Any] = [
 "rich1": 100,
 "rich2": 0.0,
 "rich3": "1",
 "rich4": NSNumber(value: 0.666),
 "rich5": "true",
 "rich6": "NO" 
]
 
let student = json.kj.model(Student.self)
// number 0 is false,not number 0 is true
XCTAssert(student.rich1 == true)
XCTAssert(student.rich2 == false)
XCTAssert(student.rich3 == true)
// 0.666 isn't 0,so true
XCTAssert(student.rich4 == true)
// "true"\"TRUE"\"YES"\"yes" is true
XCTAssert(student.rich5 == true)
// "false"\"FALSE"\"NO"\"no" is false
XCTAssert(student.rich6 == false)

String

// Support String, NSString, NSMutableString
 
struct Student: Convertible {
 var name1: String = ""
 var name2: String = ""
 var name3: NSString = ""
 var name4: NSString = ""
 var name5: NSMutableString = ""
 var name6: NSMutableString = ""
 var name7: String = ""
 var name8: String = ""
 var name9: String = ""
}
 
let json: [String: Any] = [
 "name1": 666,
 "name2": NSMutableString(string: "777"),
 "name3": [1,[2,3],"4"],
 "name4": NSDecimalNumber(string: "0.123456789012345678901234567890123456789"),
 "name5": 6.66,
 "name6": false,
 "name7": NSURL(fileURLWithPath: "/users/mj/desktop"),
 "name8": URL(string: "http://www.520suanfa.com") as Any,
 "name9": Date(timeIntervalSince1970: 1565922866)
]
 
let student = json.kj.model(Student.self)
XCTAssert(student.name1 == "666")
XCTAssert(student.name2 == "777")
// call array's description
XCTAssert(student.name3 == "[1, [2, 3], \"4\"]")
XCTAssert(student.name4 == "0.123456789012345678901234567890123456789")
XCTAssert(student.name5 == "6.66")
XCTAssert(student.name6 == "false")
XCTAssert(student.name7 == "file:///users/mj/desktop")
XCTAssert(student.name8 == "http://www.520suanfa.com")
XCTAssert(student.name9 == "1565922866")

Decimal

struct Student: Convertible {
 var money1: Decimal = 0
 var money2: Decimal = 0
 var money3: Decimal = 0
 var money4: Decimal = 0
 var money5: Decimal = 0
 var money6: Decimal = 0
 var money7: Decimal = 0
 var money8: Decimal = 0
}
 
let json: [String: Any] = [
 "money1": 0.1234567890123456,
 "money2": true,
 "money3": NSDecimalNumber(string: "0.123456789012345678901234567890123456789"),
 "money4": "0.123456789012345678901234567890123456789",
 "money5": 666,
 "money6": "NO",
 "money7": CGFloat(0.1234567890123456),
 "money8": Date(timeIntervalSince1970: 1565922866)
]
 
let student = json.kj.model(Student.self)
XCTAssert(student.money1 == Decimal(string: "0.1234567890123456"))
XCTAssert(student.money2 == 1)
XCTAssert(student.money3 == Decimal(string: "0.123456789012345678901234567890123456789"))
XCTAssert(student.money4 == Decimal(string: "0.123456789012345678901234567890123456789"))
XCTAssert(student.money5 == 666)
XCTAssert(student.money6 == 0)
XCTAssert(student.money7 == Decimal(string: "0.1234567890123456"))
XCTAssert(student.money8 == Decimal(string: "1565922866"))

NSDecimalNumber

struct Student: Convertible {
 var money1: NSDecimalNumber = 0
 var money2: NSDecimalNumber = 0
 var money3: NSDecimalNumber = 0
 var money4: NSDecimalNumber = 0
 var money5: NSDecimalNumber = 0
 var money6: NSDecimalNumber = 0
 var money7: NSDecimalNumber = 0
 var money8: NSDecimalNumber = 0
}
 
let json: [String: Any] = [
 "money1": 0.1234567890123456,
 "money2": true,
 "money3": Decimal(string: "0.123456789012345678901234567890123456789") as Any,
 "money4": "0.123456789012345678901234567890123456789",
 "money5": 666.0,
 "money6": "NO",
 "money7": CGFloat(0.1234567890123456),
 "money8": Date(timeIntervalSince1970: 1565922866)
]
 
let student = json.kj.model(Student.self)
XCTAssert(student.money1 == NSDecimalNumber(string: "0.1234567890123456"))
XCTAssert(student.money2 == true)
XCTAssert(student.money2 == 1)
XCTAssert(student.money3 == NSDecimalNumber(string: "0.123456789012345678901234567890123456789"))
XCTAssert(student.money4 == NSDecimalNumber(string: "0.123456789012345678901234567890123456789"))
XCTAssert(student.money5 == 666)
XCTAssert(student.money6 == false)
XCTAssert(student.money6 == 0)
XCTAssert(student.money7 == NSDecimalNumber(string: "0.1234567890123456"))
XCTAssert(student.money8 == NSDecimalNumber(string: "1565922866"))

NSNumber

struct Student: Convertible {
 var money1: NSNumber = 0
 var money2: NSNumber = 0
 var money3: NSNumber = 0
 var money4: NSNumber = 0
 var money5: NSNumber = 0
 var money6: NSNumber = 0
 var money7: NSNumber = 0
 var money8: NSNumber = 0
}
 
let json: [String: Any] = [
 "money1": 0.1234567890123456,
 "money2": true,
 "money3": Decimal(string: "0.1234567890123456") as Any,
 "money4": "0.1234567890123456",
 "money5": 666.0,
 "money6": "NO",
 "money7": CGFloat(0.1234567890123456),
 "money8": Date(timeIntervalSince1970: 1565922866)
]
 
let student = json.kj.model(Student.self)
XCTAssert(student.money1 == NSNumber(value: 0.1234567890123456))
XCTAssert(student.money2 == true)
XCTAssert(student.money2 == 1)
XCTAssert(student.money2 == 1.0)
XCTAssert(student.money3 == NSNumber(value: 0.1234567890123456))
XCTAssert(student.money4 == NSNumber(value: 0.1234567890123456))
XCTAssert(student.money5 == 666)
XCTAssert(student.money5 == 666.0)
XCTAssert(student.money6 == false)
XCTAssert(student.money6 == 0)
XCTAssert(student.money6 == 0.0)
XCTAssert(student.money7 == NSNumber(value: longDouble))
XCTAssert(student.money8 == NSNumber(value: 1565922866))

Optional

// Support any number of ?
 
struct Student: Convertible {
 var rich1: Bool = false
 var rich2: Bool? = false
 var rich3: Bool?? = false
 var rich4: Bool??? = false
 var rich5: Bool???? = false
 var rich6: Bool????? = false
}
 
let rich1: Int????? = 100
let rich2: Double???? = 0.0
let rich3: String??? = "0"
let rich4: NSNumber?? = NSNumber(value: 0.666)
let rich5: String? = "true"
let rich6: String = "NO" 
 
let json: [String: Any] = [
 "rich1": rich1 as Any,
 "rich2": rich2 as Any,
 "rich3": rich3 as Any,
 "rich4": rich4 as Any,
 "rich5": rich5 as Any,
 "rich6": rich6
]
 
let student = json.kj.model(Student.self)
XCTAssert(student.rich1 == true)
XCTAssert(student.rich2 == false)
XCTAssert(student.rich3 == false)
XCTAssert(student.rich4 == true)
XCTAssert(student.rich5 == true)
XCTAssert(student.rich6 == false)

URL

// Support URL, NSURL
 
struct Student: Convertible {
 var url1: NSURL?
 var url2: NSURL?
 var url3: URL?
 var url4: URL?
}
 
let url = "http://520suanfa.com/红黑树"
let encodedUrl = "http://520suanfa.com/%E7%BA%A2%E9%BB%91%E6%A0%91"
 
let json: [String: Any] = [
 "url1": url,
 "url2": URL(string: encodedUrl) as Any,
 "url3": url,
 "url4": NSURL(string: encodedUrl) as Any
]
 
let student = json.kj.model(Student.self)
XCTAssert(student.url1?.absoluteString == encodedUrl)
XCTAssert(student.url2?.absoluteString == encodedUrl)
XCTAssert(student.url3?.absoluteString == encodedUrl)
XCTAssert(student.url4?.absoluteString == encodedUrl)

Data

// Support NSData, Data
 
struct Student: Convertible {
 var data1: NSData?
 var data2: NSData?
 var data3: Data?
 var data4: Data?
 var data5: NSMutableData?
 var data6: NSMutableData?
}
 
let utf8 = String.Encoding.utf8
let str = "RedBlackTree"
let data = str.data(using: utf8)!
 
let json: [String: Any] = [
 "data1": str,
 "data2": data,
 "data3": str,
 "data4": NSMutableData(data: data),
 "data5": str,
 "data6": data
]
 
let student = json.kj.model(Student.self)
XCTAssert(String(data: (student.data1)! as Data, encoding: utf8) == str)
XCTAssert(String(data: (student.data2)! as Data, encoding: utf8) == str)
XCTAssert(String(data: (student.data3)!, encoding: utf8) == str)
XCTAssert(String(data: (student.data4)!, encoding: utf8) == str)
XCTAssert(String(data: (student.data5)! as Data, encoding: utf8) == str)
XCTAssert(String(data: (student.data6)! as Data, encoding: utf8) == str)

Date

// Support Date, NSDate
 
struct Student: Convertible {
 var date1: NSDate?
 var date2: NSDate?
 var date3: Date?
 var date4: Date?
 var date5: Date?
 var date6: Date?
 var date7: Date?
}
 
let milliseconds: TimeInterval = 1565922866
 
let json: [String: Any] = [
 "date1": milliseconds,
 "date2": Date(timeIntervalSince1970: milliseconds),
 "date3": milliseconds,
 "date4": NSDate(timeIntervalSince1970: milliseconds),
 "date5": "\(milliseconds)",
 "date6": NSDecimalNumber(string: "\(milliseconds)"),
 "date7": Decimal(string: "\(milliseconds)") as Any
]
 
let student = json.kj.model(Student.self)
XCTAssert(student.date1?.timeIntervalSince1970 == milliseconds)
XCTAssert(student.date2?.timeIntervalSince1970 == milliseconds)
XCTAssert(student.date3?.timeIntervalSince1970 == milliseconds)
XCTAssert(student.date4?.timeIntervalSince1970 == milliseconds)
XCTAssert(student.date5?.timeIntervalSince1970 == milliseconds)
XCTAssert(student.date6?.timeIntervalSince1970 == milliseconds)
XCTAssert(student.date7?.timeIntervalSince1970 == milliseconds)

Enum

// let enum with rawValue conform to ConvertibleEnum
 
// String RawValue
enum Grade: String, ConvertibleEnum {
 case perfect = "A"
 case great = "B"
 case good = "C"
 case bad = "D"
}
 
struct Student: Convertible {
 var grade1: Grade = .perfect
 var grade2: Grade = .perfect
}
 
let json: [String: Any] = [
 "grade1": "C",
 "grade2": "D"
]
 
let student = json.kj.model(Student.self)
XCTAssert(student.grade1 == .good)
XCTAssert(student.grade2 == .bad)
 
// Double RawValue
enum Grade2: Double, ConvertibleEnum {
 case perfect = 8.88
 case great = 7.77
 case good = 6.66
 case bad = 5.55
}
 
struct Student2: Convertible {
 var grade1: Grade2 = .perfect
 var grade2: Grade2 = .perfect
 var grade3: Grade2 = .perfect
 var grade4: Grade2 = .perfect
}
 
let json2: [String: Any] = [
 "grade1": "5.55kaka",
 "grade2": 6.66,
 "grade3": NSNumber(value: 7.77),
 "grade4": NSDecimalNumber(string: "8.88")
]
 
let student2 = json2.kj.model(Student2.self)
XCTAssert(student2?.grade1 == .bad)
XCTAssert(student2?.grade2 == .good)
XCTAssert(student2?.grade3 == .great)
XCTAssert(student2?.grade4 == .perfect)

Enum In Array

enum Grade: String, ConvertibleEnum {
 case perfect = "A"
 case great = "B"
 case good = "C"
 case bad = "D"
}
struct Student: Convertible {
 var name: String?
 var grades: [Grade]?
}
let json: [String: Any] = [
 "name": "Jack",
 "grades": ["D", "B"]
]
let stu = json.kj.model(Student.self)
XCTAssert(stu.name == "Jack")
XCTAssert(stu.grades?[0] == .bad)
XCTAssert(stu.grades?[1] == .great)

Enum In Dictionary

enum Grade: String, ConvertibleEnum {
 case perfect = "A"
 case great = "B"
 case good = "C"
 case bad = "D"
}
struct Student: Convertible {
 var name: String?
 var grades: [String: Grade]?
}
let json: [String: Any] = [
 "name": "Jack",
 "grades": ["2019": "D", "2020": "B"]
]
let stu = json.kj.model(Student.self)
XCTAssert(stu.name == "Jack")
XCTAssert(stu.grades?["2019"] == .bad)
XCTAssert(stu.grades?["2020"] == .great)

Enum Array In Dictionary

enum Grade: String, ConvertibleEnum {
 case perfect = "A"
 case great = "B"
 case good = "C"
 case bad = "D"
}
struct Student: Convertible {
 var name: String?
 var grades: [String: [Grade?]]?
}
let json: [String: Any] = [
 "name": "Jack",
 "grades": ["2019": ["A", "B"], "2020": ["C", "D"]]
]
let stu = json.kj.model(Student.self)
XCTAssert(stu.name == "Jack")
XCTAssert(stu.grades?["2019"]?[0] == .perfect)
XCTAssert(stu.grades?["2019"]?[1] == .great)
XCTAssert(stu.grades?["2020"]?[0] == .good)
XCTAssert(stu.grades?["2020"]?[1] == .bad)

Array

// Support conversion between Array\NSArray\NSMutableArray and Set\NSSet\NSMutableSet
 
struct Person: Convertible {
 var array1: [Int]?
 var array2: NSArray?
 var array3: NSMutableArray?
 var array4: [Int]?
 var array5: NSArray?
 var array6: NSMutableArray?
}
 
let array = [1, 2, 3]
 
let json: [String: Any] = [
 "array1": NSMutableArray(array: array),
 "array2": array,
 "array3": array,
 "array4": NSMutableSet(array: array),
 "array5": NSSet(array: array),
 "array6": Set(array),
]
 
let person = json.kj.model(Person.self)
XCTAssert(person.array1 == array)
XCTAssert(person.array2 == array as NSArray)
XCTAssert(person.array3 == NSMutableArray(array: array))
 
for i in array {
 XCTAssert(person.array4?.contains(i) == true)
 XCTAssert(person.array5?.contains(i) == true)
 XCTAssert(person.array6?.contains(i) == true)
}