How to set an Array<Object> inside a Dictionary<String, AnyObject> - Swift3

First of all don't cast types up and don't annotate types unless the compiler complains.

Second of all a JSON dictionary is [String:Any] in Swift 3.

Further the recommended syntax to create an empty collection object is

var myDict = Dictionary<String, Any>()

Assuming your array – actually a dictionary – is

let myArray = [
    0: ["key1": "a", "key2": "b", "name": "c", "link": "d"],
    1: ["key1": "e", "key2": "f", "name": "j", "link": "h"]
]

just assign it:

myDict["links"] = myArray

Even if there is a struct

struct Link {
    var key1, key2, name, link : String
}

and the array dictionary is

let linkDictionary = [
    0: Link(key1:"a", key2: "b", name: "c", link: "d"),
    1: Link(key1:"e", key2: "f", name: "g", link: "h")]

you can assign it if the value type is Any

myDict["links"] = linkDictionary

Assuming, for a second, that links really was an array, it would be:

var dictionary: [String: Any] = [
    "id": "blabla",
    "links": [
        ["key1": "a", "key2": "b", "name": "c", "link": "d"],
        ["key1": "e", "key2": "f", "name": "j", "link": "h"]
    ]
]

// retrieve links, or initialize it if not found

var links = dictionary["links"] as? [[String: String]] ?? [[String: String]]()

// add your new link to local dictionary

links.append(["key1": "k", "key2": "l", "name": "m", "link": "n"])

// update original structure

dictionary["links"] = links

Personally, though, when I see a repeating dictionary structure like your links, this screams for a real model for these objects. For example:

struct Foo {
    let id: String
    var links: [Link]?
}

struct Link {
    let key1: String
    let key2: String
    let name: String
    let link: String
}

var foo = Foo(id: "blabla", links: [
    Link(key1: "a", key2: "b", name: "c", link: "d"),
    Link(key1: "e", key2: "f", name: "j", link: "h") 
])

foo.links?.append(Link(key1: "k", key2: "l", name: "m", link: "n"))

Now, in this latter example, I assumed that links was really an array, not a dictionary, but that's not really my point here. My key observation is that code is more readable and robust if you use proper custom types rather than just arrays and dictionaries.

And if you need to send and receive these model objects to some web service, you then map this model object to and from JSON. But use custom types for your actual model.

If you want to make the above types easily converted to and from JSON, you can use one of the object mapping libraries out there, so you can do something yourself, e.g.:

protocol Jsonable {
    var jsonObject: Any { get }
    init?(jsonObject: Any)
}

extension Foo: Jsonable {
    var jsonObject: Any {
        return [
            "id": id,
            "links": links?.map { $0.jsonObject } ?? [Any]()
        ]
    }

    init?(jsonObject: Any) {
        guard let dictionary = jsonObject as? [String: Any],
            let id = dictionary["id"] as? String else { return nil }

        var links: [Link]?
        if let linksDictionary = dictionary["links"] as? [Any] {
            links = linksDictionary.map { Link(jsonObject: $0)! }
        }

        self.init(id: id, links: links)
    }
}

extension Link: Jsonable {
    var jsonObject: Any { return [ "key1": key1, "key2": key2, "name": name, "link": link ] }

    init?(jsonObject: Any) {
        guard let dictionary = jsonObject as? [String: Any],
            let key1 = dictionary["key1"] as? String, 
            let key2 = dictionary["key2"] as? String, 
            let name = dictionary["name"] as? String, 
            let link = dictionary["link"] as? String else {
                return nil
        }
        self.init(key1: key1, key2: key2, name: name, link: link)
    }
}

Then you can do stuff like:

let object = try JSONSerialization.jsonObject(with: data)
var foo = Foo(jsonObject: object)!

Or:

foo.links?.append(Link(key1: "j", key2: "k", name: "l", link: "m"))

let data = try! JSONSerialization.data(withJSONObject: foo.jsonObject)