Let关键字定义一个常量

let myNum = 7

所以myNum之后不能更改;

但是var定义了一个普通变量。

常量的值不需要在编译时知道，但是必须为它赋值一次。

你可以使用几乎任何你喜欢的字符作为常量和变量名，包括Unicode字符;

e.g.

var x = 7 // here x is instantiated with 7 
x = 99 // now x is 99 it means it has been changed.

但是如果我们采取let，那么……

let x = 7 // here also x is instantiated with 7 
x = 99 // this will a compile time error

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

例子:

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

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

var name = "Bob"

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

var age:Int = 20

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

Let用于声明常量。例如

let city = "Kathmandu"

或者我们也可以，

let city:String = "Kathmandu"

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

Let用于定义常量，var用于定义变量。

和C语言一样，Swift也使用变量来存储和引用变量的值。Swift还大量使用了值不可更改的变量。这些被称为常量，比c中的常量强大得多。当你处理不需要更改的值时，整个Swift都使用常量，使代码更安全、更清晰。 https://docs.swift.org/swift-book/LanguageGuide/TheBasics.html

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。

(变异结构)

找到了一个很好的答案，希望能有所帮助:)