Question

说我有这样的枚举：

enum ItemType {
    case TypeOne
    case TypeTwo
    case TypeThree
}

然后我有一个方法根据所选的ItemType调用另一个方法：

func getItem(withType: ItemType) {
    switch withType {
        case TypeOne:
            getTypeOneItem()
        case TypeTwo:
            getTypeTwoItem()
        case TypeThree:
            getTypeThreeItem()
    }
}

我只是想知道是否有更好的方法来写这个，如果我有很多ItemTypes，那么switch语句就会变得非常混乱。

不确定是否可行但可能enum直接调用该方法enum xx { case TypeOne: ?? = getTypeOneItem() ...

Answer 1

一个简单的解决方案是使用枚举作为字典的键。假设它们都是无效的。你可以这样做：

import Foundation

enum ItemType
{
    case TypeOne
    case TypeTwo
    case TypeThree
}

func getTypeOneItem() -> Void
{
    print("One")
}

func getTypeTwoItem() -> Void
{
    print("Two")
}

func getTypeThreeItem() -> Void
{
    print("Three")
}

// Register all the enum values
let dict =  [ItemType.TypeOne: getTypeOneItem, ItemType.TypeTwo: getTypeTwoItem, ItemType.TypeThree: getTypeThreeItem]

// Fetch
let function1 = dict[ItemType.TypeOne]!

function1() // This prints "One"

对我而言，它看起来比使用开关更清洁。

Answer 2

将函数插入枚举本身。您不再需要参数。您甚至可以将其添加到static类型，但这没有意义，因为您始终需要ItemType类型的变量。

func getTypeOneItem() -> Void {
    print("typeOne")
}

func getTypeTwoItem() -> Void {
    print("typeTwo")
}

func getTypeThreeItem() -> Void {
    print("typeThree")
}

enum ItemType {
    case TypeOne
    case TypeTwo
    case TypeThree

    func getItem() -> Void {
        switch self {
        case .TypeOne:
            getTypeOneItem()
        case .TypeTwo:
            getTypeTwoItem()
        case .TypeThree:
            getTypeThreeItem()
        }
    }
}

let item: ItemType = ItemType.TypeOne
item.getItem() // prints typeOne

调用方法的Swift枚举

2 个答案: