Swift 3.0 - 基于 2 个不同枚举的每种情况调用函数

Question

我是新手，还在学习。为了练习，我想尝试一个想法，看看我是否能够自己建模。例如，如果我在枚举中有 2 组数据

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
}

对于每种情况，都会执行一个计算人类年龄的特定函数。所以如果我创建一个实例

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

它应该执行正确的功能。

我尝试了一些东西，但目前我的知识似乎有限。谁能指导/教我如何解决这个问题？

谢谢。

Answer 1

enum 是 swift 中一个强大的类型。真正酷的是它可以具有取决于self（大小写）的功能和属性。通过向枚举添加一些属性，您可以做您想做的事情。

您的代码将如下所示：

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)
   }
}

PetType 检查它本身是枚举的哪种情况并进行相应的计算。然后你可以这样做：

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

希望对你有帮助！

Answer 2

有几种方法。如果人类年龄是唯一的（即，室外猫的人类年龄永远不会与室内猫相同），您可以扩展 Int 并仅使用 rawValue。否则，您的方法是正确的，您可以这样做：

独特的人类岁月

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

重复人类年数

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

这是 Benedikt Terhechte 撰写的真正的 good article，其中深入介绍了枚举可能性的示例