Question

如果我有这个枚举：

enum TestEnum {
    case typeA
    case typeB(Int)
}

和这个数组：let testArray = [TestEnum.typeB(1), .typeA, .typeB(3)]

是否有一种不那么难看的方法来查找项目是否包含在该数组中而不是：

if testArray.contains(where: {if case .typeA = $0 { return true }; return false}) {
    print("contained")
} else {
    print("not found")
}

Answer 1

为了使这个更具可读性，你可以像这样在你的枚举中添加一个函数：

enum TestEnum {
    case typeA
    case typeB(Int)

    static func ==(a: TestEnum, b: TestEnum) -> Bool {
        switch (a, b) {
        case (typeB(let a), .typeB(let b)) where a == b: return true
        case (.typeA, .typeA): return true
        default: return false
        }
    }
}

let testArray = [TestEnum.typeB(1), .typeA, .typeB(3)]

if testArray.contains(where: { $0 == .typeA }) {
    print("contained")
} else {
    print("not found")
}

Answer 2

如果你使你的枚举等同，你可以做这样的事情......

enum TestEnum: Equatable {
    case testA
    case testB(Int)

    static func ==(lhs: TestEnum, rhs: TestEnum) -> Bool {
        switch (lhs, rhs) {
        case (.testA, .testA):
            return true
        case (.testB(let a), .testB(let b)):
            return a == b
        default:
            return false
        }
    }
}

let array: [TestEnum] = [.testA, .testB(1)]

array.contains(.testA) // true
array.contains(.testB(1)) // true
array.contains(.testB(3)) // false

这意味着您可以使用包含函数的更简单形式，而不必使用该块。

Answer 3

不是真的，但你可以在你的枚举上定义一个帮助器，使其在呼叫站点的总量略低。

enum TestEnum {
  case typeA
  case typeB(Int)

  var isTypeA: Bool {
    switch self {
      case .typeA:
      return true
      case .typeB:
      return false
    }
  }
}

let filtered: [TestEnum] = [.typeB(1), .typeA, .typeB(3)].filter { $0.isTypeA }

在数组中查找枚举类型

3 个答案: