Question

枚举中的一段代码（卡片组，它们的状态应该是真或假）

enum Card:Int
{

case zero = 0, one, two, three, four, five, six, seven, eight, nine

init()
{
    self = .zero
}

init?(digit: Int)
{
    switch digit
    {
    case 0: self = .zero case 1: self = .one case 2: self = .two
    case 3: self = .three case 4: self = .four case 5: self = .five
    case 6: self = .six case 7: self = .seven case 8: self = .eight
    case 9: self = .nine
    default:
        return nil
    }
}
 var status
 {
    get
    {
        switch self
        {
            case .zero: return false
            case .one: return false
            case .two: return false
            case .three: return false
            case .four: return false
            case .five: return false
            case .six: return false
            case .seven: return false
            case .eight: return false
            case .nine: return false
        }
    }
}

我试图在这里制作一个变异函数，在函数运行时将它们的值改为true

mutating func swap() {
    switch status {
        case TRUE:
            self = false
        case false:
            self = TRUE

        }
    }
}

以上代码无效。

Answer 1

创建一个名为Cards 的结构，该结构具有两个存储属性 卡枚举类型之一，另一个 Bool类型可以跟踪状态在这里你可以声明一个函数swap（）来改变状态值：

  struct Cards {
  let card:Card?   //This property stores an instance of Card enum 
  var status = true
     mutating func swap()
    {
        self.status = !self.status
    }
    init(cardDigit: Int)
    {
        self.card = Card(digit: cardDigit)
    }
    init()
    {
        self.card = Card()
    }
 }

  var aCard :Cards = Cards(cardDigit: 2)
  aCard.status // returns true
  aCard.swap()
  aCard.status //returns false

您可以从枚举中删除状态计算属性，因为我们可以从结构中访问它。

Answer 2

如果您不想使用结构，则另一种方法可能是返回枚举的新实例

func swap(status: Bool) -> Card {
    var card = Card()
    switch status {
        case true:
            card.status = false
        case false:
            card.status = true
    }
    return card
}

如何在枚举中使用不同的返回值进行变异func

2 个答案: