Swift 3.0 - Aufruf von Funktionen basierend auf jeweils 2 verschiedenen enums

Question

Ich bin neu und immer noch lernen. Zum Üben wollte ich eine Idee ausprobieren und schauen, ob ich etwas selbst modellieren kann. Zum Beispiel, wenn ich zwei Sätze von Daten in Aufzählungen

protocol Pet { 
    var type: PetType { get } 
} 

protocol PetType {} 

enum Cat: PetType { 
    case indoor 
    case outdoor 
} 

enum Dog: PetType { 
    case small 
    case medium 
    case large 
} 

struct MyPet: Pet { 
    let type: PetType 
    let age: Int 
} 

Für jeden Fall gibt es eine spezifische Funktion des Alters in Menschenjahren berechnen, die ausgeführt wird. Also, wenn ich eine Instanz

erstellen Es sollte die richtige Funktion ausführen.

Ich habe ein paar Dinge versucht, aber mein Wissen scheint im Moment begrenzt. Kann mir jemand Anleitung geben, wie kann ich das lösen?

Vielen Dank.

Answer 1

enum ist ein leistungsfähiger Typ in Swift. Was wirklich cool ist, ist, dass es Funktionen und Eigenschaften haben kann, die davon abhängen, welche self (Fall) es ist. Indem Sie der Enumeration einige Eigenschaften hinzufügen, können Sie das tun, was Sie beabsichtigen.

Ihr Code würde wie folgt aussehen:

protocol Pet { 
    var type: PetType { get } 
} 

protocol PetType { 
    func inHumanYears(age: Int) -> Int 
} 

enum Cat: PetType { 
    case indoor 
    case outdoor 

    func inHumanYears(age: Int) -> Int { 
    switch self { 
    case .indoor: 
     //return you calculations for indoor 
    case .outdoor: 
     //return you calculations for outdoor 
    } 
    } 
} 

enum Dog: PetType { 
    case small 
    case medium 
    case large 

    func inHumanYears(age: Int) -> Int { 
    switch self { 
    case .small: 
     //return you calculations for small 
    case .large: 
     //return you calculations for large 
    case .medium: 
     //return you calculations for medium 
    } 
    } 
} 

struct MyPet: Pet { 
    let type: PetType 
    let age: Int 

    var inHumanYears: Int { 
    return type.inHumanYears(age: age) 
    } 
} 

Die PetType Kontrollen, die Fall der Enumeration es selbst ist, und berechnet dementsprechend. Dann können Sie tun:

let garfield = MyPet(type: Cat.indoor, age: 3) 
print(garfield.inHumanYears) 

Hoffe es hilft!

Answer 2

Es gibt mehrere Möglichkeiten. Wenn die menschlichen Jahre einmalig sind (d. H. Eine Outdoor-Katze wird niemals die gleichen menschlichen Jahre haben wie eine Indoor-Katze), können Sie Int erweitern und einfach rawValue verwenden. Ansonsten haben Sie Recht mit Ihrer approaach und Sie könnten dies tun:

Einzigartige menschliche Jahre

import UIKit 

protocol Pet { 
    var type: PetType { get } 
} 

protocol PetType { 
    var humanYears: Int { get} 
} 

enum Cat: Int, PetType { 
    case indoor = 1 
    case outdoor = 10 

    var humanYears: Int { 
     return self.rawValue 
    } 
} 

enum Dog: Int, PetType { 
    case small = 40 
    case medium = 1 
    case large = 4 

    var humanYears: Int { 
     return self.rawValue 
    } 

} 

struct MyPet: Pet { 
    let type: PetType 
    let age: Int 
} 

let garfield = MyPet(type: Cat.indoor, age: 3) 
garfield.type.humanYears 

Doppelte menschliche Jahre

import UIKit 

protocol Pet { 
    var type: PetType { get } 
} 

protocol PetType { 
    var humanYears: Int { get} 
} 

enum Cat: PetType { 
    case indoor 
    case outdoor 

    var humanYears: Int { 
     switch self { 
     case .indoor: return 4 
     case .outdoor: return 5 
     } 
    } 
} 

enum Dog: PetType { 
    case small 
    case medium 
    case large 

    var humanYears: Int { 
     switch self { 
     case .small: 
      if (yearIs1960) { 
       return 10 
      } 
      else { 
       return 8 
      } 
     case .medium: return 5 
     case .large: return 5 
     } 
    } 
} 

struct MyPet: Pet { 
    let type: PetType 
    let age: Int 
} 

let garfield = MyPet(type: Cat.indoor, age: 3) 
garfield.type.humanYears 

Hier ist ein wirklich good article von Benedikt Terhechte, die in die Tiefe geht mit Beispielen zu den Möglichkeiten mit enums