The

在Swift编程语言文档中，声明常量和变量部分指定了以下内容:

使用let关键字声明常量，使用var关键字声明变量。

确保理解Reference类型是如何工作的。与值类型不同，尽管引用类型的实例被声明为常量，但对象的底层属性可以改变。请参阅文档中的类是引用类型部分，并查看更改frameRate属性的示例。

Var是唯一的方法来创建一个变量在swift。Var并不像javascript这样的解释性语言那样意味着动态变量。例如,

var name = "Bob"

在本例中，变量名称的类型推断为name类型为String，例如，我们也可以通过显式定义type来创建变量

var age:Int = 20

现在如果你将一个字符串赋值给age，编译器就会给出错误。

Let用于声明常量。例如

let city = "Kathmandu"

或者我们也可以，

let city:String = "Kathmandu"

如果您试图更改city的值，则会在编译时给出错误。

虽然目前我还在阅读手册，但我认为这非常接近C/ c++的const指针。换句话说，类似于char const*和char*之间的区别。编译器也拒绝更新内容，不仅是引用重赋(指针)。

例如，假设你有这样一个结构体。注意，这是一个结构，而不是一个类。AFAIK，类没有不可变状态的概念。

import Foundation


struct
AAA
{
    var inner_value1    =   111

    mutating func
    mutatingMethod1()
    {
        inner_value1    =   222
    }
}


let aaa1    =   AAA()
aaa1.mutatingMethod1()      // compile error
aaa1.inner_value1 = 444     // compile error

var aaa2    =   AAA()
aaa2.mutatingMethod1()      // OK
aaa2.inner_value1 = 444     // OK

因为结构在默认情况下是不可变的，所以需要用mutating标记mutator方法。因为名字aaa1是常量，你不能对它调用任何mutator方法。这正是我们在C/ c++指针上所期望的。

我相信这是一种支持常量正确性的机制。

Swift let和var

Let -常数 Var -变量

[常量vs变量] [结构vs类]

官方文件docs.swift.org说

常量的值一旦设置就不能更改，而变量可以在将来设置为不同的值。

这个术语实际上描述了一种重新分配机制

可变性

可变性-可更改-对象创建后状态可以更改[关于]

取值及参考类型[关于]

引用类型(类)

Swift的类是可变的

Var +类 它可以被重新分配或更改

Let + class =地址常数 它不能被重新分配，可以被更改

值(结构、枚举)

Swift的struct可以改变它们的可变性状态:

Var + struct =可变的 它可以被重新分配或更改

let + struct = *immutable或unmodifiable[关于][示例][示例]= value的常量 它不能被重新分配或更改

*immutable检查testStructMutability测试

实验:

class MyClass {
    var varClass: NSMutableString
    var varStruct: String
    
    let letClass: NSMutableString
    let letStruct: String
    
    init(_ c: NSMutableString, _ s: String) {
        varClass = c
        varStruct = s
        
        letClass = c
        letStruct = s
    }
}

struct MyStruct {
    var varClass: NSMutableString
    var varStruct: String
    
    let letClass: NSMutableString
    let letStruct: String
    
    init(_ c: NSMutableString, _ s: String) {
        varClass = c
        varStruct = s
        
        letClass = c
        letStruct = s
    }
    
    
    //mutating function block
    func function() {
//            varClass = "SECONDARY propertyClass" //Cannot assign to property: 'self' is immutable
//            varStruct = "SECONDARY propertyStruct" //Cannot assign to property: 'self' is immutable
    }

    mutating func mutatingFunction() {
        varClass = "SECONDARY propertyClass"
        varStruct = "SECONDARY propertyStruct"
    }
}

可能的用例

func functionVarLetClassStruct() {
    
    var varMyClass = MyClass("propertyClass", "propertyStruct")
    
    varMyClass.varClass = "SECONDARY propertyClass"
    varMyClass.varStruct = "SECONDARY propertyStruct"
    
//        varMyClass.letClass = "SECONDARY propertyClass" //Cannot assign to property: 'letClass' is a 'let' constant
//        varMyClass.letStruct = "SECONDARY propertyStruct" //Cannot assign to property: 'letStruct' is a 'let' constant
    
    let letMyClass = MyClass("propertyClass", "propertyStruct")
    
    letMyClass.varClass = "SECONDARY propertyClass"
    letMyClass.varStruct = "SECONDARY propertyStruct"
    
//        letMyClass.letClass = "SECONDARY propertyClass" //Cannot assign to property: 'letClass' is a 'let' constant
//        letMyClass.letStruct = "SECONDARY propertyStruct" //Cannot assign to property: 'letStruct' is a 'let' constant
    
    var varMyStruct = MyStruct("propertyClass", "propertyStruct")
    
    varMyStruct.varClass = "SECONDARY propertyClass"
    varMyStruct.varStruct = "SECONDARY propertyStruct"
    
//        varMyStruct.letClass = "SECONDARY propertyClass" //Cannot assign to property: 'letClass' is a 'let' constant
//        varMyStruct.letStruct = "SECONDARY propertyStruct" //Cannot assign to property: 'letStruct' is a 'let' constant
    
    let letMyStruct = MyStruct("propertyClass", "propertyStruct")
    
//        letMyStruct.varClass = "SECONDARY propertyClass" //Cannot assign to property: 'letMyStruct' is a 'let' constant
//        letMyStruct.varStruct = "SECONDARY propertyStruct" //Cannot assign to property: 'letMyStruct' is a 'let' constant
    
//        letMyStruct.letClass = "SECONDARY propertyClass" //Cannot assign to property: 'letClass' is a 'let' constant
//        letMyStruct.letStruct = "SECONDARY propertyStruct" //Cannot assign to property: 'letStruct' is a 'let' constant
    
}

mutating -改变结构的函数

可以将结构的方法标记为突变

指示此函数更改内部属性值 你只能在var变量上调用变异函数 当突变函数完成时，结果可见

func testStructMutatingFunc() {
    //given
    var varMyStruct = MyStruct("propertyClass", "propertyStruct")
    
    //when
    varMyStruct.mutatingFunction()
    
    //than
    XCTAssert(varMyStruct.varClass == "SECONDARY propertyClass" && varMyStruct.varStruct == "SECONDARY propertyStruct")
    
    // It is not possible to call a mutating function on a let variable
    let letMyStruct = MyStruct("propertyClass", "propertyStruct")
//        letMyStruct.mutatingFunction() //Cannot use mutating member on immutable value: 'letMyStruct' is a 'let' constant
}

函数内的Inout

Inout允许您重新分配/修改传递的(原始)值。 你只能在inout参数内传递var变量 当功能完成时，结果可见

Inout有一个下一个流程:

传递的值在函数调用之前被复制到被复制的值中 复制的值在函数完成后被赋值为传递的值

//InOut
func functionWithInOutParameter(a: inout MyClass, s: inout MyStruct) {
    
    a = MyClass("SECONDARY propertyClass", "SECONDARY propertyStruct") //<-- assign
    s = MyStruct("SECONDARY propertyClass", "SECONDARY propertyStruct") //<-- assign
}


func testInOutParameter() {

    //given
    var varMyClass = MyClass("PRIMARY propertyClass", "PRIMARY propertyStruct")
    var varMyStruct = MyStruct("PRIMARY propertyClass", "PRIMARY propertyStruct")

    //when
    functionWithInOutParameter(a: &varMyClass, s: &varMyStruct)

    //then
    XCTAssert(varMyClass.varClass == "SECONDARY propertyClass" && varMyClass.varStruct == "SECONDARY propertyStruct")
    XCTAssert(varMyStruct.varClass == "SECONDARY propertyClass" && varMyStruct.varStruct == "SECONDARY propertyStruct")
    
    
    // It is not possible to pass let into inout parameter
    let letMyClass = MyClass("PRIMARY propertyClass", "PRIMARY propertyStruct")
    let letMyStruct = MyStruct("PRIMARY propertyClass", "PRIMARY propertyStruct")
//        functionWithInOutParameter(a: &letMyClass, s: &letMyStruct) //Cannot pass immutable value as inout argument: 'letMyClass', 'letMyStruct' are 'let' constants
}     

*你偷可以改变let + struct

func testStructMutability()  {
    //given
    let str: NSMutableString = "propertyClass"
    let letMyStruct = MyStruct(str, "propertyStruct")
    
    //when
    str.append(" SECONDARY")
    
    //then
    XCTAssert(letMyStruct.letClass == "propertyClass SECONDARY")
}

尽可能使用let。必要时使用var。

(变异结构)

Let用于不能修改的常量，而var是普通变量

例子:

let name = " Bob " 像name = " Jim "这样的语句会抛出一个错误，因为常量不能被修改。

"使用let作为常量，使用var作为变量"

摘自:苹果公司《快速编程语言》。“iBooks。https://itun.es/us/jEUH0.l