swift-ObjectMapper是一个用Swift编写的框架可以轻松地将模型对象转换为JSON和从JSON转换

ObjectMapper ============ [](https://github.com/tristanhimmelman/ObjectMapper) [](https://github.com/Carthage/Carthage) [](https://swift.org/package-manager/) [](https://travis-ci.org/tristanhimmelman/ObjectMapper) ObjectMapper is a framework written in Swift that makes it easy for you to convert your model objects (classes and structs) to and from JSON. - [Features](#features) - [The Basics](#the-basics) - [Mapping Nested Objects](#easy-mapping-of-nested-objects) - [Custom Transformations](#custom-transforms) - [Subclassing](#subclasses) - [Generic Objects](#generic-objects) - [Mapping Context](#mapping-context) - [ObjectMapper + Alamofire](#objectmapper--alamofire) - [ObjectMapper + Realm](#objectmapper--realm) - [Projects using ObjectMapper](#projects-using-objectmapper) - [To Do](#to-do) - [Contributing](#contributing) - [Installation](#installation) # Features: - Mapping JSON to objects - Mapping objects to JSON - Nested Objects (stand alone, in arrays or in dictionaries) - Custom transformations during mapping - Struct support - [Immutable support](#immutablemappable-protocol) # The Basics To support mapping, a class or struct just needs to implement the ```Mappable``` protocol which includes the following functions: ```swift init?(map: Map) mutating func mapping(map: Map) ``` ObjectMapper uses the ```<-``` operator to define how each member variable maps to and from JSON. ```swift class User: Mappable { var username: String? var age: Int? var weight: Double! var array: [Any]? var dictionary: [String : Any] = [:] var bestFriend: User? // Nested User object var friends: [User]? // Array of Users var birthday: Date? required init?(map: Map) { } // Mappable func mapping(map: Map) { username <- map["username"] age <- map["age"] weight <- map["weight"] array <- map["arr"] dictionary <- map["dict"] bestFriend <- map["best_friend"] friends <- map["friends"] birthday <- (map["birthday"], DateTransform()) } } struct Temperature: Mappable { var celsius: Double? var fahrenheit: Double? init?(map: Map) { } mutating func mapping(map: Map) { celsius <- map["celsius"] fahrenheit <- map["fahrenheit"] } } ``` Once your class implements `Mappable`, ObjectMapper allows you to easily convert to and from JSON. Convert a JSON string to a model object: ```swift let user = User(JSONString: JSONString) ``` Convert a model object to a JSON string: ```swift let JSONString = user.toJSONString(prettyPrint: true) ``` Alternatively, the `Mapper.swift` class can also be used to accomplish the above (it also provides extra functionality for other situations): ```swift // Convert JSON String to Model let user = Mapper<User>().map(JSONString: JSONString) // Create JSON String from Model let JSONString = Mapper().toJSONString(user, prettyPrint: true) ``` ObjectMapper can map classes composed of the following types: - `Int` - `Bool` - `Double` - `Float` - `String` - `RawRepresentable` (Enums) - `Array<Any>` - `Dictionary<String, Any>` - `Object<T: Mappable>` - `Array<T: Mappable>` - `Array<Array<T: Mappable>>` - `Set<T: Mappable>` - `Dictionary<String, T: Mappable>` - `Dictionary<String, Array<T: Mappable>>` - Optionals of all the above - Implicitly Unwrapped Optionals of the above ## `Mappable` Protocol #### `mutating func mapping(map: Map)` This function is where all mapping definitions should go. When parsing JSON, this function is executed after successful object creation. When generating JSON, it is the only function that is called on the object. #### `init?(map: Map)` This failable initializer is used by ObjectMapper for object creation. It can be used by developers to validate JSON prior to object serialization. Returning nil within the function will prevent the mapping from occuring. You can inspect the JSON stored within the `Map` object to do your validation: ```swift required init?(map: Map){ // check if a required "name" property exists within the JSON. if map.JSON["name"] == nil { return nil } } ``` ## `StaticMappable` Protocol `StaticMappable` is an alternative to `Mappable`. It provides developers with a static function that is used by ObjectMapper for object initialization instead of `init?(map: Map)`. Note: `StaticMappable`, like `Mappable`, is a sub protocol of `BaseMappable` which is where the `mapping(map: Map)` function is defined. #### `static func objectForMapping(map: Map) -> BaseMappable?` ObjectMapper uses this function to get objects to use for mapping. Developers should return an instance of an object that conforms to `BaseMappable` in this function. This function can also be used to: - validate JSON prior to object serialization - provide an existing cached object to be used for mapping - return an object of another type (which also conforms to `BaseMappable`) to be used for mapping. For instance, you may inspect the JSON to infer the type of object that should be used for mapping ([see examples in ClassClusterTests.swift](https://github.com/Hearst-DD/ObjectMapper/blob/master/Tests/ObjectMapperTests/ClassClusterTests.swift#L67)) If you need to implement ObjectMapper in an extension, you will need to adopt this protocol instead of `Mappable`. ## `ImmutableMappable` Protocol `ImmutableMappable` provides the ability to map immutable properties. This is how `ImmutableMappable` differs from `Mappable`: <table> <tr> <th>ImmutableMappable</th> <th>Mappable</th> </tr> <tr> <th colspan="2">Properties</th> </tr> <tr> <td> <pre> <strong>let</strong> id: Int <strong>let</strong> name: String? </pre> </td> <td> <pre> var id: Int! var name: String? </pre> </td> </tr> <tr> <th colspan="2">JSON -> Model</th> </tr> <tr> <td> <pre> init(map: Map) <strong>throws</strong> { id = <strong>try</strong> map.value("id") name = <strong>try?</strong> map.value("name") } </pre> </td> <td> <pre> mutating func mapping(map: Map) { id <- map["id"] name <- map["name"] } </pre> </td> </tr> <tr> <th colspan="2">Model -> JSON</th> </tr> <tr> <td> <pre> func mapping(map: Map) { id <strong>>>></strong> map["id"] name <strong>>>></strong> map["name"] } </pre> </td> <td> <pre> mutating func mapping(map: Map) { id <- map["id"] name <- map["name"] } </pre> </td> </tr> <tr> <th colspan="2">Initializing</th> </tr> <tr> <td> <pre> <strong>try</strong> User(JSONString: JSONString) </pre> </td> <td> <pre> User(JSONString: JSONString) </pre> </td> </tr> </table> #### `init(map: Map) throws` This throwable initializer is used to map immutable properties from the given `Map`. Every immutable property should be initialized in this initializer. This initializer throws an error when: - `Map` fails to get a value for the given key - `Map` fails to transform a value using `Transform` `ImmutableMappable` uses `Map.value(_:using:)` method to get values from the `Map`. This method should be used with the `try` keyword as it is throwable. `Optional` properties can easily be handled using `try?`. ```swift init(map: Map) throws { name = try map.value("name") // throws an error when it fails createdAt = try map.value("createdAt", using: DateTransform()) // throws an error when it fails updatedAt = try? map.value("updatedAt", using: DateTransform()) // optional posts = (try? map.value("posts")) ?? [] // option