मैं स्विफ्ट 2.0

Question

में निरंतर एकाधिक प्रयासों को कैसे संभाल सकता हूं मेरे पास कोड का एक ब्लॉक है जिसे 2 कथन निष्पादित करने की आवश्यकता है जिसे प्रयास करने की आवश्यकता है। यह घोंसला कोशिश के लिए बेहतर है और हर एक

do { 
    try thingOne() 
    do { 
     try thingTwo() 
    } catch let error as NSError { 
      //handle this specific error 
    } 
} catch let error as NSError { 
     //handle the other specific error here 
} 

अपने स्वयं करते हैं {} {} पकड़ है ... या लपेट कोशिश की एक में ब्लॉक कर सकते हैं और उन्हें एक साथ चलेंगी?

do { 

    try thingOne() 
    try thingTwo() 
} catch let error as NSError { 
    //do something with this error 
} 

दूसरे परिदृश्य, पहले की तुलना में पढ़ने में आसान लगता है, हालांकि होगा कि catch काम करता है, तो उन दोनों में से किसी एक त्रुटि फेंकता है?

मुझे तब फेंकने वाली विभिन्न त्रुटियों के बीच अंतर करने की आवश्यकता होगी, जब तक त्रुटियां पर्याप्त सामान्य न हो, तो इससे कोई फर्क नहीं पड़ता। ऐप्पल दस्तावेज के माध्यम से देखा और इसके बारे में कुछ भी नहीं देखा।

Answer 1

मुझे लगता है कि दूसरा तरीका बेहतर है

मान लीजिए मैं यह प्रवेश करेंगे इन दोनों समारोह

func thingOne() throws{ 
     print("Thing 1") 
     throw CustomError.Type1 
} 
func thingTwo() throws{ 
    print("Thing 2") 

    throw CustomError.Type2 

} 
enum CustomError:ErrorType{ 
    case Type1 
    case Type2 
} 

तब मैं इसे इस

do { 
     try thingOne() 
     try thingTwo() 
    } catch CustomError.Type1 { 
     print("Error1") 
    } catch CustomError.Type2{ 
     print("Error2") 
    } catch { 
     print("Not known\(error) ") 
    } 

की तरह फोन होगा

Thing 1 
Error1 

आई च thingOne() नहीं त्रुटि है, यह प्रवेश करेंगे थ्रो करता

Thing 1 
Thing 2 
Error2