Description
The following is an example of mapping a JSON text into a Swift Person structure.
JsonSwiftson alternatives and similar libraries
Based on the "JSON" category.
Alternatively, view A JSON parser with concise API written in Swift alternatives based on common mentions on social networks and blogs.
-
HandyJSON
A handy swift json-object serialization/deserialization library -
AlamofireObjectMapper
An Alamofire extension which converts JSON response data into swift objects using ObjectMapper -
Gloss
[Deprecated] A shiny JSON parsing library in Swift :sparkles: Loved by many from 2015-2021 -
EVReflection
Reflection based (Dictionary, CKRecord, NSManagedObject, Realm, JSON and XML) object mapping with extensions for Alamofire and Moya with RxSwift or ReactiveSwift -
Decodable
[Probably deprecated] Swift 2/3 JSON unmarshalling done (more) right -
JSONHelper
โ Convert anything into anything in one operation; JSON data into class instances, hex strings into UIColor/NSColor, y/n strings to booleans, arrays and dictionaries of these; anything you can make sense of! -
Himotoki
A type-safe JSON decoding library purely written in Swift -
CodableAlamofire
An extension for Alamofire that converts JSON data into Decodable objects. -
Genome
A simple, type safe, failure driven mapping library for serializing JSON to models in Swift 3.0 (Supports Linux) -
Elevate
Elevate is a JSON parsing framework that leverages Swift to make parsing simple, reliable and composable. -
JSONNeverDie
Auto reflection tool from JSON to Model, user friendly JSON encoder / decoder, aims to never die -
ModelRocket
An iOS framework for creating JSON-based models. Written in Swift. -
Tailor
:necktie:A super fast & convenient object mapper tailored for your needs -
AlamofireJsonToObjects
An Alamofire extension which converts JSON response data into swift objects using EVReflection -
Brick
:droplet: A generic view model for both basic and complex scenarios -
PPJSONSerialization
The Ultimate JSON Serialization for Swift. -
JSONParserSwift
Framework for easily parsing your JSON data directly to Swift object. -
SafeDecoder
A Codable extension to decode arrays and to catch & log all decoding failures
InfluxDB - Power Real-Time Data Analytics at Scale
* Code Quality Rankings and insights are calculated and provided by Lumnify.
They vary from L1 to L5 with "L5" being the highest.
Do you think we are missing an alternative of JsonSwiftson or a related project?
README
A JSON parser with concise API written in Swift
- Maps JSON attributes to different Swift types with just two methods:
map
andmapArrayOfObjects
. - The library can be used on any platform that runs Swift.
- Supports casting to optional types.
- Indicates if the mapping was successful.
- Can be used in Swift apps for Apple devices and in open source Swift programs on other platforms.
Example
The following is an example of mapping a JSON text into a Swift Person
structure.
struct Person {
let name: String
let age: Int
}
let mapper = JsonSwiftson(json: "{ \"name\": \"Peter\", \"age\": 41 }")
let person = Person(
name: mapper["name"].map() ?? "",
age: mapper["age"].map() ?? 0
)
if !mapper.ok { /* report error */ }
Setup (Swift 3.0)
There are four ways you can add JsonSwiftson into your project.
Add the source file (iOS 7+)
Simply add JsonSwiftson.swift file to your Xcode project.
Setup with Carthage (iOS 8+)
Alternatively, add github "evgenyneu/JsonSwiftson" ~> 4.0
to your Cartfile and run carthage update
.
Setup with CocoaPods (iOS 8+)
If you are using CocoaPods add this text to your Podfile and run pod install
.
use_frameworks!
target 'Your target name'
pod 'JsonSwiftson', git: 'https://github.com/evgenyneu/JsonSwiftson.git', tag: '4.0.0'
Setup with Swift Package Manager
Add the following text to your Package.swift file and run swift build
.
import PackageDescription
let package = Package(
name: "YourPackageName",
targets: [],
dependencies: [
.Package(url: "https://github.com/evgenyneu/JsonSwiftson.git",
versions: Version(3,0,0)..<Version(4,0,0))
]
)
Legacy Swift versions
Setup a previous version of the library if you use an older version of Swift.
Usage
1) Add import JsonSwiftson
to your source code if you used Carthage or CocoaPods setup.
2) Create an instance of JsonSwiftson
class and supply a JSON text for parsing.
let mapper = JsonSwiftson(json: "{ \"person\": { \"name\": \"Michael\" }}")
3) Supply the name of JSON attribute you want to get and call the map
method. The type of the JSON value is inferred from the context.
let name: String? = mapper["person"]["name"].map()
The example above mapped JSON to an optional String type. One can map to a non-optional by using the ??
operator and supplying a default value.
let name: String = mapper["person"]["name"].map() ?? "Default name"
4) Finally, check ok
property to see if mapping was successful.
if !mapper.ok { /* report error */ }
The ok
property will return false
if JSON parsing failed or the attribute with the given name was missing. You can allow the attribute to be missing by supplying the optional: true
argument to the map
method.
let name: String? = mapper["person"]["name"].map(optional: true)
Map to simple Swift types
Use the map
method to parse JSON to types like strings, numbers and booleans.
// String
let stringMapper = JsonSwiftson(json: "\"Hello World\"")
let string: String? = stringMapper.map()
// Integer
let intMapper = JsonSwiftson(json: "123")
let int: Int? = intMapper.map()
// Double
let doubleMapper = JsonSwiftson(json: "123.456")
let double: Double? = doubleMapper.map()
// Boolean
let boolMapper = JsonSwiftson(json: "true")
let bool: Bool? = boolMapper.map()
Map property by name
Use square brackets to reach JSON properties by name: mapper["name"]
.
let mapper = JsonSwiftson(json: "{ \"name\": \"Michael\" }")
let name: String? = mapper["name"].map()
One can use square brackets more than once to reach deeper JSON properties: mapper["person"]["name"]
.
let mapper = JsonSwiftson(json: "{ \"person\": { \"name\": \"Michael\" }}")
let name: String? = mapper["person"]["name"].map()
Map arrays of simple values
JsonSwiftson will automatically map to the arrays of strings, numbers and booleans.
// String
let stringMapper = JsonSwiftson(json: "[\"One\", \"Two\"]")
let string: [String]? = stringMapper.map()
// Integer
let intMapper = JsonSwiftson(json: "[1, 2]")
let int: [Int]? = intMapper.map()
// Double
let doubleMapper = JsonSwiftson(json: "[1.1, 2.2]")
let double: [Double]? = doubleMapper.map()
// Boolean
let boolMapper = JsonSwiftson(json: "[true, false]")
let bool: [Bool]? = boolMapper.map()
Map an array of objects
Use mapArrayOfObjects
with a closure to map array of objects.
struct Person {
let name: String
let age: Int
}
let mapper = JsonSwiftson(json:
"[ " +
"{ \"name\": \"Peter\", \"age\": 41 }," +
"{ \"name\": \"Ted\", \"age\": 51 }" +
"]")
let people: [Person]? = mapper.mapArrayOfObjects { j in
Person(
name: j["name"].map() ?? "",
age: j["age"].map() ?? 0
)
}
Tip: Use map
method instead of mapArrayOfObjects
for mapping arrays of simple values like strings, numbers and booleans.
Mapping to Swift structures
struct Person {
let name: String
let age: Int
}
let mapper = JsonSwiftson(json: "{ \"name\": \"Peter\", \"age\": 41 }")
let person = Person(
name: mapper["name"].map() ?? "",
age: mapper["age"].map() ?? 0
)
Check if mapping was successful
Verify the ok
property to see if mapping was successful.
Mapping fails for incorrect JSON and type casting problems.
Note: map
and mapArrayOfObjects
methods always return nil
if mapping fails.
let successMapper = JsonSwiftson(json: "\"Correct type\"")
let string: String? = successMapper.map()
if successMapper.ok { print("๐๐๐") }
let failMapper = JsonSwiftson(json: "\"Wrong type\"")
let number: Int? = failMapper.map()
if !failMapper.ok { print("๐") }
Allow missing values
Mapping fails by default if JSON value is null or attribute is missing.
Tip: Pass optional: true
parameter to allow missing JSON attributes and null values.
let mapper = JsonSwiftson(json: "{ }")
let string: String? = mapper["name"].map(optional: true)
if mapper.ok { print("๐๐๐") }
Allow missing objects
Use map
method with optional: true
parameter and a closure to allow empty objects.
struct Person {
let name: String
let age: Int
}
let mapper = JsonSwiftson(json: "null") // empty
let person: Person? = mapper.map(optional: true) { j in
Person(
name: j["name"].map() ?? "",
age: j["age"].map() ?? 0
)
}
if mapper.ok { print("๐๐๐") }
Tip: map to a non-optional type
Use ??
operator after the mapper if you need to map to a non-optional type like let number: Int
.
let numberMapper = JsonSwiftson(json: "123")
let number: Int = numberMapper.map() ?? 0
let arrayMapper = JsonSwiftson(json: "[1, 2, 3]")
let numbers: [Int] = arrayMapper.map() ?? []
Performance benchmark
The project includes a demo app that runs performance benchmark. It maps a large JSON file containing 100 records. The process is repeated 100 times.
Alternative solutions
Here is a list of excellent libraries that can help taming JSON in Swift.
License
JsonSwiftson is released under the [MIT License](LICENSE).
*Note that all licence references and agreements mentioned in the JsonSwiftson README section above
are relevant to that project's source code only.