wie benutzerdefinierte Schließung wie Alamofire in schnellen 3

Question

schaffen machte ich einen Verschluss wie folgt aus:

ClassNameFile.Test(printUrl: "hi") { (respons) in 

    print(respons) 
    <#code#> 
} 

Es ist in Ordnung, aber siehe ua Codes:

static func Test (printUrl: String, OnCompleted: @escaping (_ respons:  String) -> Void) { 
     OnCompleted (printUrl) 
} 

ich eine Antwort wie diese definieren

Alamofire.request("https://httpbin.org/get").responseJSON { response in 
print(response.request) // original URL request 
print(response.response) // HTTP URL response 
print(response.data) // server data 
print(response.result) // result of response serialization 

if let JSON = response.result.value { 
print("JSON: \(JSON)") 
} 
} 

Sie können es sehen, einige andere Elemente wie Anfrage, Antwort, Daten, Ergebnis zu definieren. Wie kann ich diese Artikel für meine eigenen Verschlüsse machen?

Meine andere Frage ist über "Anfrage" und "responseJSON"! Was sind diese Gegenstände? Eine Erweiterung oder andere Dinge?

Bitte. gib ein Beispiel?

Answer 1

Antwort in Alamofire ist ein Objekt, das Anfrage, Daten, Ergebnis, Antwort hat, wie es Mitglieder ist. Sie können also über . darauf zugreifen, während es in Ihrem Fall nur eine Zeichenfolge ist. Sie müssen also ein Objekt anstelle von String übergeben.

public struct DataResponse<Value> { 
    /// The URL request sent to the server. 
    public let request: URLRequest? 

    /// The server's response to the URL request. 
    public let response: HTTPURLResponse? 

    /// The data returned by the server. 
    public let data: Data? 

    /// The result of response serialization. 
    public let result: Result<Value> 

    /// The timeline of the complete lifecycle of the request. 
    public let timeline: Timeline 

    /// Returns the associated value of the result if it is a success, `nil` otherwise. 
    public var value: Value? { return result.value } 

    /// Returns the associated error value if the result if it is a failure, `nil` otherwise. 
    public var error: Error? { return result.error } 

    var _metrics: AnyObject? 

    /// Creates a `DataResponse` instance with the specified parameters derived from response serialization. 
    /// 
    /// - parameter request: The URL request sent to the server. 
    /// - parameter response: The server's response to the URL request. 
    /// - parameter data:  The data returned by the server. 
    /// - parameter result: The result of response serialization. 
    /// - parameter timeline: The timeline of the complete lifecycle of the `Request`. Defaults to `Timeline()`. 
    /// 
    /// - returns: The new `DataResponse` instance. 
    public init(
     request: URLRequest?, 
     response: HTTPURLResponse?, 
     data: Data?, 
     result: Result<Value>, 
     timeline: Timeline = Timeline()) 
    { 
     self.request = request 
     self.response = response 
     self.data = data 
     self.result = result 
     self.timeline = timeline 
    } 
} 

Dies ist, wie die Methodendefinition wie

public func responseObject<T: BaseMappable>(queue: DispatchQueue? = nil, keyPath: String? = nil, mapToObject object: T? = nil, context: MapContext? = nil, completionHandler: @escaping (DataResponse<T>) -> Void) -> Self { 
     return response(queue: queue, responseSerializer: DataRequest.ObjectMapperSerializer(keyPath, mapToObject: object, context: context), completionHandler: completionHandler) 
    } 

sieht Wenn Sie mehr Details zu Github Seite von Alamofire gehen zu wollen