JASON is a JSON deserializer written in Swift. It offers a nice and comprehensive API without sacrificing performance. The implementation is minimal and easily extendable; the library is tested and thoughtfully documented. JASON is fast. JASON is installable through Carthage.

Features • Usage • Installation • License

• Built for performance - benchmarks
• User-friendly API
• Fully tested and documented
• Installation via Carthage
• Extensions available - extensions

JASON can be initialized with an instance of AnyObject? or NSData?.

let jsonFromAnyObject = JSON(object) // where object is an instance of AnyObject?
let jsonFromNSData = JSON(data) // where data is an instance of AnyData?

JASON implements literal convertible protocols and can be initialized from the following types:

• Dictionary
• Array
• String
• Integer
• Float
• Bool
• the value nil

For instance:

let brandon: JSON = [
    "name": "Brandon Walsh",
    "city": "Beverly Hills",
    "age" 17
]

You can access JSON values by using subscripts.

Use a subscript with an integer or a string key depending on whether the JSON is an array or a dictionary.

let friends: JSON = [
    "title": "Friends",
    "characters": [
        ["first_name": "Chandler", "last_name": "Bing"],
        ["first_name": "Phoebe", "last_name": "Buffay"],
        ["first_name": "Rachel", "last_name": "Green"],
        ["first_name": "Joey", "last_name": "Tribbiani"],
        ["first_name": "Monica", "last_name": "Geller"],
        ["first_name": "Ross", "last_name": "Geller"]
    ]
]

friends["title"]

Each subscript call returns an instance of JASON.JSON to allow chaining.

friends["characters"][0]["first_name"]

It will never break if the key doesn't exist or the index is out of bounds.

friends["whatever"][42]["whatever"][42] // that's fine too

If the underlying JSON object is an array, you can iterate over it.

for character in friends["characters"] {
    character["first_name"]
}

Next, you will want to convert a JASON.JSON object to a more appropriate type.

You can do so by casting it's internal value like so:

let maybeName: String? = friends["characters"][0]["first_name"].object as? String
let name: String = friends["characters"][0]["first_name"].object as? String ?? ""

JASON provides a set of computed properties to make anyone's job easier:

let maybeName = friends["characters"][0]["first_name"].string
let name = friends["characters"][0]["first_name"].stringValue

These getters come by two, json.<type> and json.<type>Value, and returns an optional or a non-optional type, respectively.

If the value can't be converted to the given type, the optional getter will return nil and the non-optional one a default value.

You can find more getters on the extensions branch

JASON defines three custom operators.

1. <?

variable <? json is the equivalent of variable = json.<type>.

let json: JSON = ["name": "sophie"]
var name: String?

name <? json["wrong"]
name // nil

name <? json["name"]
name // sophie

2. <!

variable <! json is the equivalent of variable = json.<type>Value.

let json: JSON = ["age": 23]
var age: Int!

age <! json["wrong"]
age // 0

age <! json["age"]
age // 23

3. <|

variable <| json is the equivalent of if let value = json.<type> { variable = value }.

let json: JSON = ["name": "sophie"]
var name = "margot"

name <| json["wrong"]
name // margot

name <| json["name"]
name // sophie

Here is a complete example:

struct User {
    var firstName: String!
    var lastName: String?
    var nickname = "none"

    init(_ json: JSON) {
        firstName <! json["first_name"]
        lastName  <? json["last_name"]
        nickName  <| json["nickname"]
    }
}

let json: JSON = [
    "first_name": "Rachel",
    "nickname": "Vintage Rachel"
]

let user = User(json)
user.firstName // Rachel
user.lastName // nil
user.nickname // Vintage Rachel

Carthage is a decentralized dependency manager that automates the process of adding frameworks to your Cocoa application.

You can install Carthage with Homebrew using the following command:

$ brew update
$ brew install carthage

To integrate JASON into your Xcode project using Carthage, specify it in your Cartfile:

github "delba/JASON" >= 1.0

CocoaPods is a dependency manager for Cocoa projects.

You can install it with the following command:

$ gem install cocoapods

To integrate JASON into your Xcode project using CocoaPods, specify it in your Podfile:

use_frameworks!

pod 'JASON', '~> 1.0'

Copyright (c) 2015 Damien (http://delba.io)

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.