स्विफ्ट में REST API कॉल करें


92

मैं स्विफ्ट का उपयोग एक REST API पर GET कॉल करने के लिए कर रहा हूं, और कई ट्यूटोरियल का अनुसरण करने की कोशिश की है, लेकिन यह पता नहीं लगा सकता। या तो क्योंकि मैं यह पता नहीं लगा सकता कि स्विफ्ट के सभी ओज-सी का अनुवाद कैसे किया जाए, या क्योंकि एन के आधे तरीके ऐसे हैं। क्या किसी को पता है कि कॉल कैसे करना है, और पार्स ने JSON डेटा लौटाया?


मेरे द्वारा पाया गया अन्य लोगों को नहीं मिल रहा है, लेकिन मैंने रैस्टेकिट स्थापित करने की कोशिश की, लेकिन यह बहुत जटिल था और Xcode 6 से Xcode 6 में अनुवाद नहीं किया। मैंने ब्लॉग
cclloyd

इस भिन्न दृष्टिकोण को देखें। gist.github.com/higepon/71f18472f6d4cba77870
एलेक्स

2
मैं आपको आलमोफायर आज़माने की सलाह दूंगा । यह एक बाहरी पुस्तकालय है जो HTTP अनुरोधों और प्रतिक्रिया से निपटने को आसान बनाता है (IMO)।
अल्वारो

इस उदाहरण में सरल उदाहरण पाया जा सकता है ।
david72

जवाबों:


65

आप इस तरह कर सकते हैं:

var url : String = "http://google.com?test=toto&test2=titi"
var request : NSMutableURLRequest = NSMutableURLRequest()
request.URL = NSURL(string: url)
request.HTTPMethod = "GET"

NSURLConnection.sendAsynchronousRequest(request, queue: NSOperationQueue(), completionHandler:{ (response:NSURLResponse!, data: NSData!, error: NSError!) -> Void in
    var error: AutoreleasingUnsafeMutablePointer<NSError?> = nil
    let jsonResult: NSDictionary! = NSJSONSerialization.JSONObjectWithData(data, options:NSJSONReadingOptions.MutableContainers, error: error) as? NSDictionary

    if (jsonResult != nil) {
        // process jsonResult
    } else {
       // couldn't load JSON, look at error
    }


})

संपादित करें: लोगों को इससे समस्या है कि शायद आपकी JSON स्ट्रीम एक सरणी है [] और वस्तु नहीं {} ताकि आपको NSArrayइसके बजाय jsonResult बदलना पड़े NSDictionary


6
वास्तव में स्विफ्ट को बंद करने के साथ अतुल्यकालिक तरीकों का उपयोग करना बहुत बेहतर है क्योंकि इसके लिए भाषा स्वयं डिज़ाइन की गई है।
फ्रांसिस्कु

जब मैं ऊपर की कोशिश करता हूं, तो मुझे डुप्लिकेट विधि के नामों के कारण एक कंपाइलर त्रुटि मिलती है, भले ही वे विभिन्न मापदंडों को स्वीकार करते हैं। क्या मुझे शब्दकोश में JSON को पार्स करने का एक छोटा उदाहरण मिल सकता है? ओबज-सी सामान में से कोई भी मुझे नहीं मिला जब मैंने अनुवाद किया।
cclloyd

2
किसी कारण से जब मैं एक एपीआई कॉल करता हूं तो मुझे 0x0000000000000000 त्रुटि मिलती है। मुझे नहीं पता कि इसके आसपास कैसे पहुंचा जाए। क्या कोई मुझे सही दिशा दिखा सकता है?
टिफ़नी लोवे

2
@ टिफ़नीलोवे ने त्रुटि पाई! अगर किसी और को एक सकारात्मक समाधान की आवश्यकता है: यदि आपके JSON की प्रतिक्रिया एक सरणी के रूप में आती है, तो jsonResult को "Casted" किया जाना चाहिए क्योंकि NSArray एक NSDictionary के रूप में नहीं है।
रोमन खोजक

1
NSURLConnection.sendAsynchronousRequest वास्तव में iOS 9 और macOS 10.11 से निकाला गया है। सही उत्तर NSUrlSession.dataTaskWithUrl () के बारे में हैं।
युसेफ माली

56

स्विफ्ट 5 और 4

let params = ["username":"john", "password":"123456"] as Dictionary<String, String>

var request = URLRequest(url: URL(string: "http://localhost:8080/api/1/login")!)
request.httpMethod = "POST"
request.httpBody = try? JSONSerialization.data(withJSONObject: params, options: [])
request.addValue("application/json", forHTTPHeaderField: "Content-Type")

let session = URLSession.shared
let task = session.dataTask(with: request, completionHandler: { data, response, error -> Void in
    print(response!)
    do {
        let json = try JSONSerialization.jsonObject(with: data!) as! Dictionary<String, AnyObject>
        print(json)
    } catch {
        print("error")
    }
})

task.resume()

25

मुझे लगता है कि NSURLSessionएपी इस स्थिति में बेहतर फिट बैठता है। क्योंकि अगर आप स्विफ्ट कोड लिखते हैं तो आपका प्रोजेक्ट लक्ष्य कम से कम iOS 7 और iOS 7 NSURLSessionएप को सपोर्ट करता है । वैसे भी यहाँ कोड है

let url = "YOUR_URL"

NSURLSession.sharedSession().dataTaskWithURL(NSURL(string: url)) { data, response, error in
    // Handle result
}.resume()

1
@mustafa क्या इस कॉल में "GET", "POST" जैसे HTTP अनुरोध प्रकार निर्दिष्ट करना संभव है? यह भी कि मैं इस मामले में हेडर या कॉल के बॉडी को कैसे मान सकता हूं?
रेज़ान

DataTaskWithRequest विधि है। आप इसे NSURLRequest या NSMutableURLRequest उदाहरण दे सकते हैं।
मुस्तफा

// Handle resultहो सकता है:let resp = String( data:data!, encoding:NSUTF8StringEncoding)!
जोस मैनुएल अबरका रॉड्रिग्ज

उपयोग करने की तुलना में बहुत सरल है NSURLSessionConfiguration। मुझे लगता है कि यह स्वीकृत उत्तर होना चाहिए।
काकुबई

20

यहां REST API अनुरोधों का पूरा कोड NSURLSession का उपयोग करते हुए तेजी से किया गया है

For GET Request

 let configuration = NSURLSessionConfiguration .defaultSessionConfiguration()
    let session = NSURLSession(configuration: configuration)


    let urlString = NSString(format: "your URL here")

    print("get wallet balance url string is \(urlString)")
    //let url = NSURL(string: urlString as String)
    let request : NSMutableURLRequest = NSMutableURLRequest()
    request.URL = NSURL(string: NSString(format: "%@", urlString) as String)
    request.HTTPMethod = "GET"
    request.timeoutInterval = 30

    request.addValue("application/json", forHTTPHeaderField: "Content-Type")
    request.addValue("application/json", forHTTPHeaderField: "Accept")

    let dataTask = session.dataTaskWithRequest(request) {
        (let data: NSData?, let response: NSURLResponse?, let error: NSError?) -> Void in

        // 1: Check HTTP Response for successful GET request
        guard let httpResponse = response as? NSHTTPURLResponse, receivedData = data
            else {
                print("error: not a valid http response")
                return
        }

        switch (httpResponse.statusCode)
        {
        case 200:

            let response = NSString (data: receivedData, encoding: NSUTF8StringEncoding)
            print("response is \(response)")


            do {
                let getResponse = try NSJSONSerialization.JSONObjectWithData(receivedData, options: .AllowFragments)

                EZLoadingActivity .hide()

               // }
            } catch {
                print("error serializing JSON: \(error)")
            }

            break
        case 400:

            break
        default:
            print("wallet GET request got response \(httpResponse.statusCode)")
        }
    }
    dataTask.resume()

पोस्ट अनुरोध के लिए ...

let configuration = NSURLSessionConfiguration .defaultSessionConfiguration()
    let session = NSURLSession(configuration: configuration)

    let params = ["username":bindings .objectForKey("username"), "provider":"walkingcoin", "securityQuestion":securityQuestionField.text!, "securityAnswer":securityAnswerField.text!] as Dictionary<String, AnyObject>

    let urlString = NSString(format: “your URL”);
    print("url string is \(urlString)")
    let request : NSMutableURLRequest = NSMutableURLRequest()
    request.URL = NSURL(string: NSString(format: "%@", urlString)as String)
    request.HTTPMethod = "POST"
    request.timeoutInterval = 30
    request.addValue("application/json", forHTTPHeaderField: "Content-Type")
    request.addValue("application/json", forHTTPHeaderField: "Accept")      
    request.HTTPBody  = try! NSJSONSerialization.dataWithJSONObject(params, options: [])

    let dataTask = session.dataTaskWithRequest(request)
        {
            (let data: NSData?, let response: NSURLResponse?, let error: NSError?) -> Void in
            // 1: Check HTTP Response for successful GET request
            guard let httpResponse = response as? NSHTTPURLResponse, receivedData = data
                else {
                    print("error: not a valid http response")
                    return
            }

            switch (httpResponse.statusCode)
            {
            case 200:

                let response = NSString (data: receivedData, encoding: NSUTF8StringEncoding)


                if response == "SUCCESS"
                {

                }

            default:
                print("save profile POST request got response \(httpResponse.statusCode)")
            }
    }
    dataTask.resume()

मैं आशा करता हूँ यह काम करेगा।


10

स्विफ्ट 2 के लिए संपादित

let url = NSURL(string: "http://www.test.com")

    let task = NSURLSession.sharedSession().dataTaskWithURL(url!) {(data, response, error) in
        print(NSString(data: data!, encoding: NSUTF8StringEncoding))
    }

    task.resume()

8

स्विफ्ट 4 - अनुरोध प्राप्त करें

var request = URLRequest(url: URL(string: "http://example.com/api/v1/example")!)
request.httpMethod = "GET"

URLSession.shared.dataTask(with: request, completionHandler: { data, response, error -> Void in
    do {
        let jsonDecoder = JSONDecoder()
        let responseModel = try jsonDecoder.decode(CustomDtoClass.self, from: data!)
        print(responseModel)
    } catch {
        print("JSON Serialization error")
    }
}).resume()

अपने डोमेन को अपवादों में जोड़ने के लिए ऐप ट्रांसपोर्ट सिक्योरिटी सेटिंग्स को कॉन्फ़िगर करना न भूलें और यदि आप HTPSPS का उपयोग किए बिना एंडपॉइंट मार रहे हैं, तो असुरक्षित http अनुरोधों की अनुमति दें।

आप अपने JSON प्रतिक्रियाओं से अपने कोड करने योग्य मैपिंग को स्वचालित करने के लिए http://www.json4swift.com/ जैसे टूल का उपयोग कर सकते हैं ।


1
CustomDtoClass क्या है ??
बिजेन्द्र सिंह शेखावत

@BijenderSinghShekhawat यह एक ऐसा वर्ग है जिसमें कोडेबल मैपिंग के साथ उपयोग किया जा सकता है। वह json4swift लिंक जो मैंने पोस्ट किया है, वह आपके लिए JSON डेटा के इनपुट से उत्पन्न कर सकता है। यह मूल रूप से आपके डेटा ट्रांसफर ऑब्जेक्ट का प्रतिनिधित्व करने के लिए केवल एक वर्ग बना रहा है।
ज्योसुआ

5

स्विफ्ट 3.0

let request = NSMutableURLRequest(url: NSURL(string: "http://httpstat.us/200")! as URL)
let session = URLSession.shared
request.httpMethod = "GET"
request.addValue("application/json", forHTTPHeaderField: "Content-Type")
request.addValue("application/json", forHTTPHeaderField: "Accept")

let task = session.dataTask(with: request as URLRequest, completionHandler: {data, response, error -> Void in
      if error != nil {
          print("Error: \(String(describing: error))")
      } else {
          print("Response: \(String(describing: response))")
      }
 })

 task.resume()

5

स्विफ्ट 4

Api Post विधि के साथ Alamofire का उपयोग करके एक ऐप बनाएं

एक्सकोड 9 के साथ स्विफ्ट 3 के लिए पॉड फ़ाइल-पॉड 'अलमॉफायर', '~> 4.0' स्थापित करें

Webservices.swift क्लास बनाएँ, Alamofire आयात करें

डिज़ाइन स्टोरीबोर्ड, लॉगिन व्यू

ViewControllerClass के लिए निम्नलिखित कोड डालें

import UIKit

class ViewController: UIViewController {

    @IBOutlet var usernameTextField: UITextField!

    @IBOutlet var passwordTextField: UITextField!
    var usertypeStr :String = "-----------"
    var loginDictionary : NSDictionary?
    override func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view, typically from a nib.
    }

    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
        // Dispose of any resources that can be recreated.
    }

    @IBAction func loginButtonClicked(_ sender: Any) {
        WebServices.userLogin(userName: usernameTextField.text!, password: passwordTextField.text!,userType: usertypeStr) {(result, message, status )in
            if status {
                let loginDetails = result as? WebServices
                self.loginDictionary = loginDetails?.loginData
                if self.loginDictionary?["status"] as? String == "error"
                {
                    self.alertMessage(alerttitle: "Login Error", (self.loginDictionary?["message"] as? String)!)
                } else if self.loginDictionary?["status"] as? String == "ok" {
                    self.alertMessage(alerttitle: "", "Success")

                }else {
                    self.alertMessage(alerttitle: "", (self.loginDictionary?["message"] as? String)!)
                }
            } else {
                self.alertMessage(alerttitle: "", "Sorry")
            }
        }
    }

    func alertMessage(alerttitle:String,_ message : String){
        let alertViewController = UIAlertController(title:alerttitle,  message:message, preferredStyle: .alert)
        alertViewController.addAction(UIAlertAction(title: "OK", style: .default, handler: nil))
        present(alertViewController, animated: true, completion: nil)
    }

}

WebserviceClass के लिए निम्नलिखित कोड डालें

import Foundation
import Alamofire
class WebServices: NSObject {
    enum WebServiceNames: String {
        case baseUrl = "https://---------------"
        case UserLogin = "------------"
    }

    // MARK: - Login Variables
    var loginData : NSDictionary?

    class func userLogin(userName: String,password : String,userType : String, completion : @escaping (_ response : AnyObject?, _ message: String?, _ success : Bool)-> ()) {
        let url = WebServiceNames.baseUrl.rawValue + WebServiceNames.UserLogin.rawValue
        let params = ["USER": userName,"PASS":password,"API_Key" : userType]
        WebServices.postWebService(urlString: url, params: params as [String : AnyObject]) { (response, message, status) in
            print(response ?? "Error")
            let result = WebServices()
            if let data = response as? NSDictionary {
                print(data)
                result.loginData = data
                completion(result, "Success", true)

            }else {
                completion("" as AnyObject?, "Failed", false)
            }
        }
    }
    //MARK :- Post
    class func postWebService(urlString: String, params: [String : AnyObject], completion : @escaping (_ response : AnyObject?, _ message: String?, _ success : Bool)-> Void) {
        alamofireFunction(urlString: urlString, method: .post, paramters: params) { (response, message, success) in
            if response != nil {
                completion(response as AnyObject?, "", true)
            }else{
                completion(nil, "", false)
            }
        }
    }

    class func alamofireFunction(urlString : String, method : Alamofire.HTTPMethod, paramters : [String : AnyObject], completion : @escaping (_ response : AnyObject?, _ message: String?, _ success : Bool)-> Void){

        if method == Alamofire.HTTPMethod.post {
            Alamofire.request(urlString, method: .post, parameters: paramters, encoding: URLEncoding.default, headers: nil).responseJSON { (response:DataResponse<Any>) in

                print(urlString)

                if response.result.isSuccess{
                    completion(response.result.value as AnyObject?, "", true)
                }else{
                    completion(nil, "", false)
                }
            }

        }else {
            Alamofire.request(urlString).responseJSON { (response) in

                if response.result.isSuccess{
                    completion(response.result.value as AnyObject?, "", true)
                }else{
                    completion(nil, "", false)
                }
            }
        }
    }



    //Mark:-Cancel
    class func cancelAllRequests()
    {
        Alamofire.SessionManager.default.session.getTasksWithCompletionHandler { dataTasks, uploadTasks, downloadTasks in
            dataTasks.forEach { $0.cancel() }
            uploadTasks.forEach { $0.cancel() }
            downloadTasks.forEach { $0.cancel() }
        }
    }
}

4

स्विफ्ट में 3.3 और 4. मैंने दो सार्वजनिक तरीकों से APIManager क्लास को क्रेट किया। बस आवश्यक पैरामीटर, एपीआई नाम और अनुरोध प्रकार पास करें। आपको प्रतिक्रिया मिलेगी फिर इसे बंद करने के लिए पास करें।

 import UIKit   

    struct RequestType {
      static let  POST = "POST"
      static let  GET = "GET"
    }

    enum HtttpType: String {
      case POST = "POST"
      case GET  = "GET"
    }

    class APIManager: NSObject {


      static let sharedInstance: APIManager = {

        let instance = APIManager()
        return instance
      }()
     private init() {}
        // First Method

          public func requestApiWithDictParam(dictParam: Dictionary<String,Any>, apiName: String,requestType: String, isAddCookie: Bool, completionHendler:@escaping (_ response:Dictionary<String,AnyObject>?, _ error: NSError?, _ success: Bool)-> Void) {

            var apiUrl = “” // Your api url
            apiUrl =  apiUrl.appendingFormat("%@", apiName)
            let config = URLSessionConfiguration.default
            let session = URLSession(configuration: config)
            let url = URL(string: apiUrl)!
            let HTTPHeaderField_ContentType  = "Content-Type"
            let ContentType_ApplicationJson  = "application/json"
            var request = URLRequest.init(url: url)

            request.timeoutInterval = 60.0
            request.cachePolicy = URLRequest.CachePolicy.reloadIgnoringLocalCacheData
            request.addValue(ContentType_ApplicationJson, forHTTPHeaderField: HTTPHeaderField_ContentType)
            request.httpMethod = requestType

            print(apiUrl)
            print(dictParam)

            let dataTask = session.dataTask(with: request) { (data, response, error) in

              if error != nil   {
                completionHendler(nil, error as NSError?, false)
              } do {
                let resultJson = try JSONSerialization.jsonObject(with: data!, options: []) as? [String:AnyObject]
                print("Request API = ", apiUrl)
                print("API Response = ",resultJson ?? "")
                completionHendler(resultJson, nil, true)

              } catch {
                completionHendler(nil, error as NSError?, false)
              }
            }
            dataTask.resume()
          }

           // Second Method
           public func requestApiWithUrlString(param: String, apiName: String,requestType: String, isAddCookie: Bool, completionHendler:@escaping (_ response:Dictionary<String,AnyObject>?, _ error: NSError?, _ success: Bool)-> Void ) {
                var apiUrl = "" // Your api url
                let config = URLSessionConfiguration.default
                let session = URLSession(configuration: config)            
                var request: URLRequest?

                if requestType == "GET" {

                  apiUrl =  String(format: "%@%@&%@", YourAppBaseUrl,apiName,param)
                  apiUrl = apiUrl.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed)!
                  print("URL=",apiUrl)

                  let url = URL(string: apiUrl)!
                  request = URLRequest.init(url: url)
                  request?.httpMethod = "GET"

                } else {

                  apiUrl =  String(format: "%@%@", YourAppBaseUrl,apiName)
                  apiUrl = apiUrl.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed)!
                  print("URL=",apiUrl)

                  let bodyParameterData = param.data(using: .utf8)
                  let url = URL(string: apiUrl)!

                  request = URLRequest(url: url)
                  request?.httpBody = bodyParameterData
                  request?.httpMethod = "POST"
                }

                request?.timeoutInterval = 60.0
                request?.cachePolicy = URLRequest.CachePolicy.reloadIgnoringLocalCacheData
                request?.httpShouldHandleCookies = true

                let dataTask = session.dataTask(with: request!) { (data, response, error) in

                  if error != nil {
                    completionHendler(nil, error as NSError?, false)
                  } do {
                    if data != nil  {
                      let resultJson = try JSONSerialization.jsonObject(with: data!, options: []) as? [String:AnyObject]

                      print("Request API = ", apiUrl)
                      print("API Response = ",resultJson ?? "")
                      completionHendler(resultJson, nil, true) 
                    } else  {
                      completionHendler(nil, error as NSError?, false)
                    }
                  } catch {
                    completionHendler(nil, error as NSError?, false)
                  }
                }
                dataTask.resume()
              }
    }

    // Here is example of calling Post API from any class

     let bodyParameters = String(format: "appid=%@&appversion=%@","1","1")
            APIManager.sharedInstance.requestApiWithUrlString(param: bodyParameters, apiName: "PASS_API_NAME", requestType: HtttpType.POST.rawValue, isAddCookie: false) { (dictResponse, error, success) in

                if success {
                    if let dictMessage = dictResponse?["message"] as? Dictionary<String, AnyObject> {
                // do you work
                    }

                }  else {
                    print("Something went wrong...")
                }
            }
        }


/// Or just use simple function 

func dataRequest() {
    let urlToRequest = "" // Your API url

    let url = URL(string: urlToRequest)!
    let session4 = URLSession.shared
    let request = NSMutableURLRequest(url: url)
    request.httpMethod = "POST"
    request.cachePolicy = NSURLRequest.CachePolicy.reloadIgnoringCacheData
    let paramString = "data=Hello"
    request.httpBody = paramString.data(using: String.Encoding.utf8)
    let task = session4.dataTask(with: request as URLRequest) { (data, response, error) in
      guard let _: Data = data, let _: URLResponse = response, error == nil else {
        print("*****error")
        return
      }
      if let dataString = NSString(data: data!, encoding: String.Encoding.utf8.rawValue) {
          print("****Data: \(dataString)") //JSONSerialization
      }
    }
    task.resume()
  }

3

तेज ४

हमारे एप्लिकेशन plz स्थापित फली फ़ाइल में उपयोग ALAMOFIRE

फली 'अलमोफायर', '~> 4.0'

हम Json Data के लिए API का उपयोग कर सकते हैं - https://swapi.co/api/people/

तब हम अपने प्रोजेक्ट के लिए एक नेटवर्किंग क्लास बना सकते हैं- नेटवर्किंग सर्विस।स्विफ्ट

import Foundation
import Alamofire
typealias JSON = [String:Any]
class networkingService{
     static let shared = networkingService()
    private init() {}
    func getPeople(success successblock: @escaping (GetPeopleResponse) -> Void)
    {
    Alamofire.request("https://swapi.co/api/people/").responseJSON { response in
        guard let json = response.result.value as? JSON else {return}
       // print(json)
        do {
                let getPeopleResponse = try GetPeopleResponse(json: json)
                successblock(getPeopleResponse)
            }catch{}
    }
    }
    func getHomeWorld(homeWorldLink:String,completion: @escaping(String) ->Void){
        Alamofire.request(homeWorldLink).responseJSON {(response) in
            guard let json = response.result.value as? JSON,
            let name = json["name"] as? String
                else{return}
            completion(name)
        }
}
}

फिर NetworkingError.swift क्लास बनाएं

import Foundation
enum networkingError : Error{
    case badNetworkigStuff

}

उसके बाद Person.swift क्लास बनाएं

import Foundation
struct Person {
    private let homeWorldLink : String
    let birthyear : String
    let gender : String
    let haircolor : String
    let eyecolor : String
    let height : String
    let mass : String
    let name : String
    let skincolor : String
    init?(json : JSON) {
        guard let birthyear = json["birth_year"] as? String,
        let eyecolor = json["eye_color"] as? String,
        let gender = json["gender"] as? String,
        let haircolor = json["hair_color"] as? String,
        let height = json["height"] as? String,
        let homeWorldLink = json["homeworld"] as? String,
        let mass = json["mass"] as? String,
        let name = json["name"] as? String,
        let skincolor = json["skin_color"] as? String
        else { return nil }
        self.homeWorldLink = homeWorldLink
        self.birthyear = birthyear
        self.gender = gender
        self.haircolor = haircolor
        self.eyecolor = eyecolor
        self.height = height
        self.mass = mass
        self.name = name
        self.skincolor = skincolor
    }
    func homeWorld(_ completion: @escaping (String) -> Void)  {
        networkingService.shared.getHomeWorld(homeWorldLink: homeWorldLink){ (homeWorld) in
            completion(homeWorld)
        }
    }
}

फिर DetailVC.swift बनाएं

import UIKit
class DetailVC: UIViewController {
    var person :Person!
    @IBOutlet var name: UILabel!
    @IBOutlet var birthyear: UILabel!
    @IBOutlet var homeworld: UILabel!
    @IBOutlet var eyeColor: UILabel!
    @IBOutlet var skinColor: UILabel!
    @IBOutlet var gender: UILabel!
    @IBOutlet var hairColor: UILabel!
    @IBOutlet var mass: UILabel!
    @IBOutlet var height: UILabel!
    override func viewDidLoad() {
        super.viewDidLoad()
       print(person)
        name.text = person.name
        birthyear.text = person.birthyear
        eyeColor.text = person.eyecolor
        gender.text = person.gender
        hairColor.text = person.haircolor
        mass.text = person.mass
        height.text = person.height
        skinColor.text = person.skincolor
        person.homeWorld{(homeWorld) in
            self.homeworld.text = homeWorld
        }
    }
}

फिर GetPeopleResponse.swift क्लास बनाएं

import Foundation
struct GetPeopleResponse {
    let people : [Person]
    init(json :JSON) throws {
        guard let results = json["results"] as? [JSON] else { throw networkingError.badNetworkigStuff}
        let people = results.map{Person(json: $0)}.flatMap{ $0 }
        self.people = people
        }
}

तब हमारा देखें नियंत्रक वर्ग

import UIKit

class ViewController: UIViewController {

    @IBOutlet var tableVieww: UITableView!
    var people = [Person]()


    @IBAction func getAction(_ sender: Any)
    {
    print("GET")
        networkingService.shared.getPeople{ response in
            self.people = response.people
           self.tableVieww.reloadData()
        }
    }
    override func prepare(for segue: UIStoryboardSegue, sender: Any?)
    {
        guard segue.identifier == "peopleToDetails",
        let detailVC = segue.destination as? DetailVC,
        let person = sender as AnyObject as? Person
        else {return}
        detailVC.person = person
        }
}
    extension ViewController:UITableViewDataSource{
        func numberOfSections(in tableView: UITableView) -> Int {
            return 1
        }
        func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
            return people.count
        }
        func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
         let cell = UITableViewCell()
            cell.textLabel?.text = people[indexPath.row].name

            return cell

        }
    }
extension ViewController:UITableViewDelegate{
    func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
        performSegue(withIdentifier: "peopleToDetails", sender: people[indexPath.row])
    }
}

हमारे StoryBoard में

plz पहचानकर्ता -peopleToDetails के साथ सेगमेंट का उपयोग करके हमारे दृश्य के साथ किसी अन्य के साथ कनेक्ट करें

  • हमारे पहले दृश्य में UITableView का उपयोग करें

  • डेटा प्राप्त करने के लिए UIButton का उपयोग करें

  • हमारे विवरण में 9 लेबल का उपयोग करें


2

यदि आप स्विफ्ट 3 में काम कर रहे हैं, तो सिंटैक्स बदलता है। यहाँ उदाहरण ने मेरे लिए काम किया और चरणों की अच्छी व्याख्या की: https://grokswift.com/simple-rest-with-swift/

यह उस ट्यूटोरियल का कोड है:

let todoEndpoint: String = "https://jsonplaceholder.typicode.com/todos/1"
guard let url = URL(string: todoEndpoint) else {
  print("Error: cannot create URL")
  return
}
let urlRequest = URLRequest(url: url)

let task = session.dataTask(with: urlRequest) {
  (data, response, error) in
  // check for any errors
  guard error == nil else {
    print("error calling GET on /todos/1")
    print(error!)
    return
  }
  // make sure we got data
  guard let responseData = data else {
    print("Error: did not receive data")
    return
  }
  // parse the result as JSON, since that's what the API provides
  do {
    guard let todo = try JSONSerialization.jsonObject(with: responseData, options: [])
      as? [String: Any] else {
      print("error trying to convert data to JSON")
      return
    }
    // now we have the todo
    // let's just print it to prove we can access it
    print("The todo is: " + todo.description)

    // the todo object is a dictionary
    // so we just access the title using the "title" key
    // so check for a title and print it if we have one
    guard let todoTitle = todo["title"] as? String else {
      print("Could not get todo title from JSON")
      return
    }
    print("The title is: " + todoTitle)
  } catch  {
    print("error trying to convert data to JSON")
    return
  }
}
task.resume()

0

Api मॉडल क्लास का उपयोग कर कॉल करें

    let urlString = "http://--.154.--.78/------/index.php?route=api/coupon/all"

    let url = URL(string: urlString)
    var request = URLRequest(url: url!)
    request.httpMethod = "GET"

    URLSession.shared.dataTask(with:request) { (data, response, error) in
        if error != nil {
            print(error)
        } else {
            do {

                let parsedDictionaryArray = try JSONSerialization.jsonObject(with: data!) as! [String:AnyObject]
                print(parsedDictionaryArray)

                if let arry = parsedDictionaryArray["data"] as? [[String:AnyObject]] {
                for dic in arry {
                    let name = dic["name"]
                    let descriptionData = dic["description"]
                    self.modelReference.append(model(name: name as! String, descriptionStr: descriptionData as! String))
                    print(name!)
                }
                }
            } catch let error as NSError {
                print(error)
            }
        }

        }.resume()

एक वैरिएबल बनाएं और मॉडल वर्ग के साथ जुड़ें

var modelReference = [model]()

एक मॉडल वर्ग बनाएं न्यू -> स्विफ्ट क्लास

import Foundation
class model : NSObject{
var name : String
var descriptionStr: String

init(name : String, descriptionStr: String)
{
    self.name = name
    self.descriptionStr = descriptionStr
}

}

तब हम अपने टेबल व्यू ऑब्जेक्ट्स से जुड़ सकते हैं

let cell = tableView.dequeueReusableCell(withIdentifier: "TableViewCellID")as! TableViewCell
    cell.listName.text = modelReference[indexPath.row].name

0
let headers = [
                "cache-control": "no-cache",
                "postman-token": "6f8a-12c6-87a1-ac0f25d6385a"
            ]

            let request = NSMutableURLRequest(url: NSURL(string: "Your url string")! as URL,
                                              cachePolicy: .useProtocolCachePolicy,
                                              timeoutInterval: 10.0)
            request.httpMethod = "GET"
            request.allHTTPHeaderFields = headers

            let session = URLSession.shared
            let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
                if error == nil && data != nil {
                    do {
                        // Convert NSData to Dictionary where keys are of type String, and values are of any type
                        let json = try JSONSerialization.jsonObject(with: data!, options: JSONSerialization.ReadingOptions.mutableContainers) as! [String:AnyObject]
                        print(json)

                        //do your stuff

                      //  completionHandler(true)

                    } catch {
                       // completionHandler(false)
                    }
                }
                else if error != nil
                {
                    //completionHandler(false)
                }
            }).resume()
            }
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.