我发现这些在 Swift 中声明变量的不同方式非常有趣：
// METHOD 1
var dogName: String = "Charlie"
// METHOD 2
var dogName: String {
return "Charlie"
}
// METHOD 3
let dogName = {
return "Charlie"
}
// METHOD 4
var dogName: String = {
return "Charlie"
}()
显然方法 3 声明了一个 let 并且我们知道其中的区别；但为什么 Swift 允许方法 4？
这四种方法有什么区别？
我很困惑，尤其是方法 2 和 4。此外，为什么方法 3 与方法 4 相比失去了最后的括号？
【问题讨论】：
标签： swift swift3 var variable-declaration let
方法 1 是字符串的标准变量声明。它有一个 setter 和一个 getter
var dogName: String = "Charlie"
print(dogName) -> "Charlie"
dogName = "Rex" // Valid
方法2是String类型的计算属性，是只读的
var dogName: String {
return "Charlie"
}
print(dogName) -> "Charlie"
dogName = "Rex" // Invalid as property is read-only
方法3是()->String类型的只读属性，所以基本上是一个lambda函数。
let dogName = {
return "Charlie"
}
print(dogName) -> "(Function)"
print(dogName()) -> "Charlie"
dogName = "Rex" // Invalid as property is read-only
方法 4 是一个闭包，将在包含对象初始化时执行。因为它是 var，你可以用另一个值替换它
var dogName: String = {
return "Charlie"
}()
print(dogName) -> "Charlie"
dogName = "Rex" // Valid
话虽如此，因为方法 4 是一个闭包，你可以在其中执行其他命令。这是一个示例，您可以使用此构造来初始化 UILabel：
var dogNameLabel: UILabel = {
let label = UILabel(frame: CGRect(x: 0, y: 0, width: 10, height: 10))
label.text = "Charlie"
return label
}()
【讨论】：
get 和 set 以使其可读写。然而，当如上所示声明时，它们隐含地只有一个 getter，这实际上使它们成为只读的。见developer.apple.com/library/content/documentation/Swift/…
let x = { return 5 }; print(type(of: x)) 确认这一点
为了理解这些差异，让我们使用一个更具描述性的示例
这是一堂课Foo
class Foo {
var className = "Foo"
var dogName1 : String { return "Charlie " + className }
let dogName2 = {
return "My name is Charlie"
}
var dogName3 : String = {
var string = "My"
string += " name"
string += " is"
string += " Charlie"
print(string)
return string
}()
}
现在让我们创建一个实例
let foo = Foo()
方法一是存储属性className，带有setter和getter
let name = foo.className
foo.className = "Bar"
print(foo.className) // "Bar"
方法 2 是计算属性 dogName1 仅带有一个 getter。它可用于动态计算值。
print(foo.dogName1) // "Charlie Bar"
方法3是dogName2类型() -> String的闭包。它可以分配给一个变量，然后再执行
let dogName = foo.dogName2 // assigns the closure but does not return the string.
print(dogName()) // "My name is Charlie"
方法4是变量dogName3，当实例Foo()被初始化时，它立即一次执行其闭包（由print行证明）
print(foo.dogName3) // "My name is Charlie" but does not execute the closure and print `string` again
甚至还有一个方法5：如果将dogName3声明为lazy
lazy var dogName3 : String = {
在第一次访问变量之前，不会执行闭包。优点是您甚至可以在闭包中使用self，这在方法4中是不可能的。
【讨论】：
我设置了一个快速测试，将所有内容重命名为 dogName1、dogName2、dogName3 和 dogName4。然后我添加了代码以尝试将每个名称更改为“史努比”。
#2 和#3 没有构建，因为编译器知道它们都是只读的。 （#2，尽管被声明为var，但设置为始终返回“Charlie”。
在注释掉这两行之后，我设置了两个断点——在初始化之后，一个在尝试更新之后。
最后我尝试为每个人做一个print。
断点 #1： #1 和 #4 设置为“Charlie”，#2 不存在（因为它没有初始化），而 #3 显示为已初始化但没有值（因为它还没有被调用。是的，最后的 () 初始化了内存中的一些东西。
断点 #2： #1 和 #4 已更新为“史努比”。
print的结果：#1 和#4 是“Snoopy”，#2 是“Charlie”，#3 是“（函数）”。
结论：#1 和#4 没有区别。每个都被声明为var，并且默认为“Charlie”。 #2，由于let 是只读的，并且将始终返回“Charlie”。 #3？如果您尝试更改它，它会创建一个实例并且不会构建 - 但我不知道如何使用它。
如果有人对#3 有更多补充，我会更新这个答案。
【讨论】：
方法一很明显。
在方法 2 中，您所做的是为给定变量定义了一个 getter。
方法 3 中的 dogName 类型是 () -> String 而不是 String。你在那里初始化的是一个命名的 lambda。
在方法 4 中，您使用返回字符串的匿名（未命名）lambda 函数初始化变量。
3 和 4 之间的区别在于，在第 4 次中，您使用 () 调用该函数，因此您获得 String，而在之前您没有，所以它是一个函数。
【讨论】：