Swift：使用闭包的枚举？答案

【问题标题】：Swift: Enums that use closures?Swift：使用闭包的枚举？
【发布时间】：2015-10-05 16:59:20
【问题描述】：

我正在创建一个应用程序，其中无限数量的规则可以应用于无限数量的节点。

我计划使用核心数据作为数据存储，并在节点和规则之间创建简单的一对多关系。

在 Objective-c 中，我可能会为每个规则创建类并让它们符合协议。

NSArray *ruleClassNames = @[@"SimpleRuleA",@"SimpleRuleB",@"BigFatComplicatedRule"];

int ruleType = [someNode.rules firstObject];
Class class = NSClassFromString(ruleClassNames[ruleType]);

[(ruleClassProtocol*)class performSelector:@selector(runRuleOnNode:) withObject:someNode];

在 swift 中最优雅的方式是什么？

【问题讨论】：

你能定义“优雅”吗？ enums 与 switch 一起工作，所以我真的不明白你为什么要使用枚举并避免使用 switch。
@Sulthan 您显然了解枚举的概念，但请再次阅读问题，看看您是否可以提出解决方案...
好吧，您的 Obj-C 代码可以很容易地写入 Swift 中（当然，您可以直接使用类型而不是使用类型名称）。这是否优雅是一个品味问题。

标签： ios objective-c swift core-data enums

【解决方案1】：

解决方案

如果我们想将closure 添加到enum，首先让我们定义closure 的类型。

typealias Logic = () -> (String)

然后enum：

enum Rule {
    case SimpleRuleA(Logic)
    case SimpleRuleB(Logic)
    case BigFatComplicatedRule(Logic)
}

就是这样！现在让我们看看如何使用它。

用法

让我们创建一对Logic(s)：

let logic0 : Logic = { return "Logic 0" }
let logic1 : Logic = { return "Logic 1" }

现在是一个处理Rule的函数

func processRule(rule:Rule) -> String {
    switch rule {
    case .SimpleRuleA(let logic): return "Simple Rule A, logic: \(logic())"
    case .SimpleRuleB(let logic): return "Simple Rule B, logic: \(logic())"
    case .BigFatComplicatedRule(let logic): return "Big Fat Complicated Rule, logic: \(logic())"
    }
}

最后让我们将所有可能的规则与所有可能的Logic...结合起来。

let aWithLogic0 = Rule.SimpleRuleA(logic0)
let aWithLogic1 = Rule.SimpleRuleA(logic1)
let bWithLogic0 = Rule.SimpleRuleB(logic0)
let bWithLogic1 = Rule.SimpleRuleB(logic1)
let fatWithLogic0 = Rule.BigFatComplicatedRule(logic0)
let fatWithLogic1 = Rule.BigFatComplicatedRule(logic1)

...让我们测试一下

processRule(aWithLogic0) // "Simple Rule A, logic: Logic 0"
processRule(aWithLogic1) // "Simple Rule A, logic: Logic 1"
processRule(bWithLogic0) // "Simple Rule B, logic: Logic 0"
processRule(bWithLogic1) // "Simple Rule B, logic: Logic 1"
processRule(fatWithLogic0) // "Big Fat Complicated Rule, logic: Logic 0"
processRule(fatWithLogic1) // "Big Fat Complicated Rule, logic: Logic 1"

这个解决方案是否接近您的想法？

【讨论】：

【解决方案2】：

    enum FunctionEnum
   {
     case binaryOperation((Double,Double)->Double)
     constant(Double)
   }

1.您可以将值关联到枚举案例，因此它在这里也有类型，例如 binaryOperation 是类型 ((Double,Double)->Double) 这意味着它的闭包类型接受两个双精度并返回一个

【讨论】：