swift - `let case(value)` 和 `case(let value)` 之间的区别(Swift)

Question

假设我们有一个具有关联值的enum:

enum A {
    case a1(x: Int)
    case a2(y: String)
}

还有一些开启这个枚举的函数:

func doSomething(a: A) {
    
    switch a {
    case .a1(let x):
        print("a1 let \(x)")
    case let .a2(y):
        print("let a2 \(y)")
    }
}

例如:

var x = A.a1(x: 1)
var y = A.a2(y: "hello")
doSomething(a: x) // Prints a1 let 1
doSomething(a: y) // Prints let a2 hello

如您所见，我可以使用语法 case .a1(let x) 和 case let .a2(y)，没有明显区别。

所以我想了解:使用这两种语法是否有正当理由，或者它们纯粹是为了方便？例如:这些选项之间是否存在较低级别(编译器、内存)差异？是否有其中一个或另一个不起作用的示例？谢谢

Answer 1

As you notice I can use the syntax case .a1(let x) and case let .a2(y) with no apparent difference.

你是对的，这两种语法之间几乎没有区别——case let 语法是为了方便。

are there valid reasons to have both syntaxes, or they are purely for convenience? For example: are there a lower-level (compiler, memory) difference between those options?

是的，但它最适用于具有多个关联值的 enum 情况，因为它可以让您避免为每个关联值重复 let案例:

enum A {
    case a1(x: Int)
    case a2(y: String)
    case a3(x: Int, y: String)
    case a4(x: Int, y: String, z: Double)
}

let a: A = ...
switch a {
// Inner `let`:
case .a1(let x):
    print(x)

// Equivalent outer `let`:
case let .a2(y):
    print(y)

// Inner `let`s can get repetitive:
case .a3(let x, let y):
    print(x, y)

// More convenient outer `let`s:
case let .a4(x, y, z):
    print(x, y, z)
}

来自 Swift language guide 的解释:

If all of the associated values for an enumeration case are extracted as constants, or if all are extracted as variables, you can place a single var or let annotation before the case name, for brevity

这纯粹是一种语法上的便利，对编译没有任何影响。

---

如果您想知道这是如何从语言语法中摆脱出来的:

• switch statements有一个开关盒列表
• 常规情况(非默认 情况)有一个 case label (其中有一个或多个案例项目)
• Case items被绑定(bind)为模式
• Patterns是语法分支的地方:
  1. 在 case let .a4(...) 变体中，pattern 被绑定(bind)为 value binding pattern其内部模式绑定(bind)为 enum case pattern
  2. 在 case .a3(let...) 变体中，pattern 直接绑定(bind)为枚举 case 模式，其 tuple pattern每个内容绑定(bind)一个值绑定(bind)模式

语法在技术上允许这里有很大的灵 active ，但编译器确保您在 case 标签本身之外有一个 var/let，或者绑定(bind)每个案例内部的变量，内部有一个 var/let