Hızlı yap-dene-yakala sözdizimi

Ben hızlı 2 yeni bir hata işleme şey anlamak için bir deneyin. İşte yaptım: İlk önce bir hata enum ilan:

enum SandwichError: ErrorType {
    case NotMe
    case DoItYourself
}

Ve sonra bir hata atan bir yöntem (istisna millet değil. Bu bir hatadır.) İlan ettim. İşte bu yöntem:

func makeMeSandwich(names: [String: String]) throws -> String {
    guard let sandwich = names["sandwich"] else {
        throw SandwichError.NotMe
    }

    return sandwich
}

Sorun çağıran tarafından. Bu yöntemi çağıran kod şöyledir:

let kitchen = ["sandwich": "ready", "breakfeast": "not ready"]

do {
    let sandwich = try makeMeSandwich(kitchen)
    print("i eat it \(sandwich)")
} catch SandwichError.NotMe {
    print("Not me error")
} catch SandwichError.DoItYourself {
    print("do it error")
}

Sonra doderleyici derler diyor Errors thrown from here are not handled because the enclosing catch is not exhaustive. Ama bence bu çok kapsamlı çünkü SandwichErrorenum'da sadece iki vaka var .

Düzenli anahtar ifadeleri için swift, her durum ele alındığında bunun kapsamlı olduğunu anlayabilir.

Swift 2 hata işleme modelinin iki önemli noktası vardır: kapsamlılık ve esneklik. Birlikte, sadece atabileceğinizi bildiğinizleri değil, olası her hatayı yakalamanız gereken do/ catchifadenize kaybolurlar.

Bir işlevin ne tür hatalar atabileceğini, yalnızca atıp atmadığını bildirmediğinize dikkat edin. Bu sıfır bir sonsuzluk problemidir: başkalarının (gelecekteki benliğiniz dahil) kullanması için bir işlev tanımlayan biri olarak, işlevinizin her istemcisinin, uygulamanızdaki her değişikliğe adapte olmasını istemezsiniz. hangi hatalar atabileceğini de içerir. İşlevinizi çağıran kodun bu değişikliğe dayanıklı olmasını istiyorsunuz.

İşleviniz ne tür hatalar attığını (veya gelecekte atabileceğini) söyleyemediğinden, hataları catchyakalayan bloklar ne tür hatalar atabileceğini bilemez. Bu nedenle, bildiğiniz hata türlerini ele catchalmanın yanı sıra, evrensel bir ifadeyle yapmadığınız durumları da ele almanız gerekir - bu şekilde işleviniz gelecekte atacağı hata kümesini değiştirirse, arayanlar yine de hatalar.

do {
    let sandwich = try makeMeSandwich(kitchen)
    print("i eat it \(sandwich)")
} catch SandwichError.NotMe {
    print("Not me error")
} catch SandwichError.DoItYourself {
    print("do it error")
} catch let error {
    print(error.localizedDescription)
}

Ama burada durmayalım. Bu esneklik fikrini biraz daha düşünün. Sandviçinizi tasarladığınız şekilde, hataları kullandığınız her yerde tanımlamanız gerekir. Bu, hata durumları kümesini her değiştirdiğinizde, bunları kullanan her yeri değiştirmek zorunda olduğunuz anlamına gelir ... çok eğlenceli değil.

Kendi hata türlerinizi tanımlamanın ardındaki fikir, bunun gibi şeyleri merkezileştirmenize izin vermektir. descriptionHatalarınız için bir yöntem tanımlayabilirsiniz :

extension SandwichError: CustomStringConvertible {
    var description: String {
        switch self {
            case NotMe: return "Not me error"
            case DoItYourself: return "Try sudo"
        }
    }
}

Ve sonra hata işleme kodunuz hata türünüzün kendisini tanımlamasını isteyebilir - şimdi hataları ele aldığınız her yer aynı kodu kullanabilir ve gelecekteki olası hata durumlarını da işleyebilir.

do {
    let sandwich = try makeMeSandwich(kitchen)
    print("i eat it \(sandwich)")
} catch let error as SandwichError {
    print(error.description)
} catch {
    print("i dunno")
}

Bu ayrıca hata türlerinin (veya üzerlerindeki uzantıların) hataları bildirmenin diğer yollarını desteklemesinin yolunu açar - örneğin, UIAlertControllerhata türünüzde hatayı bir iOS kullanıcısına bildirmek için nasıl sunulacağını bilen bir uzantıya sahip olabilirsiniz .

Bunun henüz tam olarak uygulanmadığından şüpheleniyorum. Swift Programlama Kılavuzu kesinlikle derleyici 'bir switch deyimi gibi' kapsamlı eşleşmeleri çıkarabiliriz ima etmek gibi görünüyor. catchKapsamlı olabilmek için bir generale ihtiyaç duyulduğundan bahsetmez .

Ayrıca hatanın trysatırın sonunda değil satırda olduğunu fark edersiniz , yani bir noktada derleyici trybloktaki hangi ifadenin işlenmeyen istisna türlerine sahip olduğunu saptayabilir .

Belgeler biraz belirsiz. 'Swift'teki yenilikler' videosunu gözden geçirdim ve hiçbir ipucu bulamadım; Denemeye devam edeceğim.

Güncelleme:

Artık Beta 3'e kadar ErrorType çıkarımının ipucu yok. Şimdi bunun planlanmış olup olmadığına inanıyorum (ve hala bir noktada olduğunu düşünüyorum), protokol uzantıları üzerindeki dinamik gönderim muhtemelen onu öldürdü.

Beta 4 Güncellemesi:

Xcode 7b4 Throws:, “hangi hataların atılabileceğini ve nedenini belgelemek için kullanılması gereken” doküman yorumu desteği ekledi . Sanırım bu en azından API tüketicilerine hataları iletmek için bazı mekanizmalar sağlar . Belgeleriniz olduğunda kimin bir tip sisteme ihtiyacı var!

Başka bir güncelleme:

Otomatik için umut biraz zaman geçirdikten sonra ErrorTypeçıkarım ve sınırlamalar bu modelin ne olacağını çalışma dışarı, ben fikrimi değiştirdim - Bu yerine elma uygular umut budur. esasen:

// allow us to do this:
func myFunction() throws -> Int

// or this:
func myFunction() throws CustomError -> Int

// but not this:
func myFunction() throws CustomErrorOne, CustomErrorTwo -> Int

Yine Bir Güncelleme

Apple'ın hata işleme gerekçesi artık burada . Hızlı evrim posta listesinde bazı ilginç tartışmalar da oldu . Esasen, John McCall yazılan hatalara karşıdır, çünkü çoğu kütüphanenin yine de genel bir hata durumu da dahil olacağına inanmaktadır ve yazılan hataların, kazan plakası dışında koda çok fazla şey eklemesi olası değildir ('aspirasyon blöf' terimini kullandı). Chris Lattner, esneklik modeliyle çalışabiliyorsa Swift 3'te yazılan hatalara açık olduğunu söyledi.

Swift, vaka ifadenizin tüm vakaları kapsamadığından endişe duyuyor, düzeltmek için varsayılan bir vaka oluşturmanız gerekiyor:

do {
    let sandwich = try makeMeSandwich(kitchen)
    print("i eat it \(sandwich)")
} catch SandwichError.NotMe {
    print("Not me error")
} catch SandwichError.DoItYourself {
    print("do it error")
} catch Default {
    print("Another Error")
}

Ayrıca, bir fonksiyonun atabileceği tipin olmaması nedeniyle hayal kırıklığına uğradım, ancak şimdi @rickster sayesinde aldım ve bunu şöyle özetleyeceğim: diyelim ki bir fonksiyonun attığı türü belirleyebiliriz, böyle bir şeyimiz olurdu:

enum MyError: ErrorType { case ErrorA, ErrorB }

func myFunctionThatThrows() throws MyError { ...throw .ErrorA...throw .ErrorB... }

do {
    try myFunctionThatThrows()
}
case .ErrorA { ... }
case .ErrorB { ... }

Sorun şu ki, myFunctionThatThrows içinde hiçbir şey değiştirmesek bile, MyError'a bir hata durumu eklersek:

enum MyError: ErrorType { case ErrorA, ErrorB, ErrorC }

vidalıyız çünkü do / try / catch'ımız artık kapsamlı değil, aynı zamanda MyError'u atan işlevler olarak adlandırdığımız başka bir yer

enum NumberError: Error {
  case NegativeNumber(number: Int)
  case ZeroNumber
  case OddNumber(number: Int)
}

extension NumberError: CustomStringConvertible {
         var description: String {
         switch self {
             case .NegativeNumber(let number):
                 return "Negative number \(number) is Passed."
             case .OddNumber(let number):
                return "Odd number \(number) is Passed."
             case .ZeroNumber:
                return "Zero is Passed."
      }
   }
}

 func validateEvenNumber(_ number: Int) throws ->Int {
     if number == 0 {
        throw NumberError.ZeroNumber
     } else if number < 0 {
        throw NumberError.NegativeNumber(number: number)
     } else if number % 2 == 1 {
         throw NumberError.OddNumber(number: number)
     }
    return number
}

Şimdi Doğrulama Numarası:

 do {
     let number = try validateEvenNumber(0)
     print("Valid Even Number: \(number)")
  } catch let error as NumberError {
     print(error.description)
  }

Bunun gibi numaralandırma oluşturun:

//Error Handling in swift
enum spendingError : Error{
case minus
case limit
}

Şunun gibi bir yöntem oluşturun:

 func calculateSpending(morningSpending:Double,eveningSpending:Double) throws ->Double{
if morningSpending < 0 || eveningSpending < 0{
    throw spendingError.minus
}
if (morningSpending + eveningSpending) > 100{
    throw spendingError.limit
}
return morningSpending + eveningSpending
}

Şimdi hata olup olmadığını kontrol edin ve halledin:

do{
try calculateSpending(morningSpending: 60, eveningSpending: 50)
} catch spendingError.minus{
print("This is not possible...")
} catch spendingError.limit{
print("Limit reached...")
}