swift-json

Even Swiftier JSON Handler

Usage

Workspace

View all the playgrounds and the project via JSON.xcworkspace!

Playground

Just open one of the playrounds and have fun!

In your project

Just add json/json.swift to your project.

in REPL

make repl and import JSON.

Synopsis

Turn your swift object to JSON like so:

let obj:[String:AnyObject] = [
    "array": [JSON.null, false, 0, "", [], [:]],
    "object":[
        "null":   JSON.null,
        "bool":   true,
        "int":    42,
        "double": 3.141592653589793,
        "string": "a α\t弾\n𪚲",
        "array":  [],
        "object": [:]
    ],
    "url":"http://blog.livedoor.com/dankogai/"
]

let json = JSON(obj)
json.toString()
// "{\"array\":[null,false,0,\"\",[],{}],
//  \"object\":{\"int\":42,\"double\":3.141592653589793,
//  \"string\":\"a α\t弾\n𪚲\",\"object\":{},\"null\":null,
//  \"bool\":true,\"array\":[]},
//  \"url\":\"http://blog.livedoor.com/dankogai/\"}"

...or string...

let json = JSON(string:"{\"array\":[...}")
// let json = JSON.parse("{\"array\":[...}")

...or URL.

let json = JSON(url:"http://api.dan.co.jp/jsonenv")
// let json = JSON.fromURL("http://api.dan.co.jp/jsonenv")

Tree Traversal

Just traverse elements via subscript:

json["object"]["null"].asNull       // NSNull()
json["object"]["bool"].asBool       // true
json["object"]["int"].asInt         // 42
json["object"]["double"].asDouble   // 3.141592653589793
json["object"]["string"].asString   // "a α\t弾\n𪚲"

json["array"][0].asNull             // NSNull()
json["array"][1].asBool             // false
json["array"][2].asInt              // 0
json["array"][3].asString           // ""

Error handling

Don't worry if the subscripted entry does not exist. Just like SwiftyJSON it simply turns into the error object. Call that NSError Chain :-?

if let b = json["noexistent"][1234567890]["entry"].asBool {
    // ....
} else {
    let e = json["noexistent"][1234567890]["entry"].asError
    println(e)
} // Error Domain=JSONErrorDomain Code=404 "["noexistent"] not found" UserInfo=0x10064bfc0 {NSLocalizedDescription=["noexistent"] not found}

Type Checking

What you see is what you get.

json["array"].type                  // "Array"
json["array"].isDictionary          // true
json["array"].isLeaf                // false
json["object"].type                 // "Dictionary"
json["object"].isDictionary         // true
json["object"].isLeaf               // false
json["url"].isLeaf                  // true

json["object"]["null"].type         // "NSNull"
json["object"]["null"].isNull       // true
json["object"]["bool"].type         // "Bool"
json["object"]["bool"].isBool       // true
json["object"]["bool"].isNumber     // false
json["object"]["int"].type          // "Int"
json["object"]["int"].isInt         // 42
json["object"]["int"].isNumber      // true
json["object"]["double"].type       // "Double"
json["object"]["double"].isDouble   // true
json["object"]["double"].isNumber   // true
json["object"]["string"].type       // "String"
json["object"]["string"].isString   // true

Iterating Nodes

Note that the iterator yields (k, v) pair for both array and dictionary:

for (i, v) in json["array"] {
   // i is NSNumber, v is another JSON object
}

for (k, v) in json["object"] {
   // k is NSString, v is another JSON object
}

Custom Accessors via Inheritance

But you still need subscripts to traverse an object (dictionary in Swift, that is). In JavaScript where JSON is originated, You don't need subscripts for string keys. They automagically turns into property names.

//json["object"]["string"] vs...
  json.object.string

4 characters for each array or object! Can't we teach Swift how to access via methods?

Yes, we can!

//// schema by subclassing
class MyJSON : JSON {
    override init(_ obj:AnyObject){ super.init(obj) }
    override init(_ json:JSON)  { super.init(json) }
    var null  :NSNull? { return self["null"].asNull }
    var bool  :Bool?   { return self["bool"].asBool }
    var int   :Int?    { return self["int"].asInt }
    var double:Double? { return self["double"].asDouble }
    var string:String? { return self["string"].asString }
    var url:   String? { return self["url"].asString }
    var array :MyJSON  { return MyJSON(self["array"])  }
    var object:MyJSON  { return MyJSON(self["object"]) }
}

Now do:

let myjson = MyJSON(obj)
myjson.object.null      // NSNull?
myjson.object.bool      // Bool?
myjson.object.int       // Int?
myjson.object.double    // Double?
myjson.object.string    // String?
myjson.url              // String?

This approach comes with bonus. You can't accidentaly access elements that was not supposed to be there. JSON is schemaless and that is what makes JSON rule today. But that is also what makes JSON so prone to errors. With Swift and this JSON class you get the best of both worlds -- flexibility of JSON and robustness of static typing.

Description

See wiki/Discussion.

Prerequisite

Swift 2.2 or better. OSX or iOS or tvOS. Linux is currently not supported since it lacks most of Foundation objects including NSJSONSerialization.

For Swift 1.x and below check the swift-1.x branch (which is no longer maintained)

sumitch / swift-json