swift中`let`和`var`有什么区别？

Apple的Swift语言中let和var什么区别？

根据我的理解，这是一种编译语言，但它不会在编译时检查types。 这让我感到困惑。 编译器如何知道types错误？ 如果编译器不检查types，是不是生产环境的问题？

Answer 1

let关键字定义了一个常量：

 let theAnswer = 42 

之后的theAnswer是不能改变的。 这就是为什么weak不能用let编写的原因。 他们需要在运行时改变 ，你必须使用var来代替。

var定义了一个普通variables。

有趣的是：

在编译时不需要知道常量的值，但是您必须将该值只分配一次。

另一个奇特的特点

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

 let 🐶🐮 = "dogcow" 

摘自：苹果公司“Swift编程语言”，iBooks。 https://itunes.apple.com/WebObjects/MZStore.woa/wa/viewBook?id=881256329

编辑

因为评论要求将其他事实添加到答案中，将其转换为社区维基答案 。 随意编辑答案，使其更好。

Answer 2

根据Swift Programming Language Book

像C一样，Swift使用variables来存储和引用一个识别名称的值。 Swift也广泛使用了值不能被改变的variables。 这些被称为常量，比C中的常量强大得多

var和let都是引用 ，所以let是一个const引用 。 使用基本types并不能真正显示let与const是不同的。 与类实例（引用types）一起使用时会有所不同：

 class CTest { var str : String = "" } let letTest = CTest() letTest.str = "test" // OK letTest.str = "another test" // Still OK //letTest = CTest() // Error var varTest1 = CTest() var varTest2 = CTest() var varTest3 = CTest() varTest1.str = "var 1" varTest2.str = "var 2" varTest3 = varTest1 varTest1.str = "var 3" varTest3.str // "var 3" 

Answer 3

let用来定义常量和var来定义variables。

Answer 4

该

Swift编程语言文档的声明常量和variables部分指定了以下内容：

用var关键字和let关键字和variables声明常量。

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

Answer 5

这种差异可能更好地通过Mutability / Unmutability概念来说明，它是对象空间中的值和实例可变性的正确范例，其大于唯一的“常量/variables”通常概念。 而且这更接近Objective C方法。

 let aInt = 1 // or let aPerson = Person(name:Foo, first:Bar) 

定义一个值和一个UNMUTABLE实例

 var aInt = 1 // or var aPerson = Person(name:Foo, first:Bar) 

定义可变/ MUTABLE值和实例

Answer 6

很简单：

• let不断。
• var是dynamic的。

比特描述：

let创造一个恒定。 （有点像NSString ）。 设置后，您无法更改其值。 您仍然可以将其添加到其他的东西，并创build新的variables。

var创build一个variables。 （有点像NSMutableString ），所以你可以改变它的价值。 但是这已经被多次回答了。

Answer 7

let定义一个“常量”。 它的值只设置了一次，虽然不一定当你声明它的时候。 例如，您可以使用let来定义在初始化期间必须设置的类中的属性：

 class Person { let firstName: String let lastName: String init(first: String, last: String) { firstName = first lastName = last super.init() } } 

使用此设置，在调用（例如） Person(first:"Malcolm", last:"Reynolds")以创buildPerson实例之后，分配给firstName或lastName是无效的。

您必须在编译时为所有variables（ let或var ）定义一个types，任何尝试设置variables的代码都只能使用该types（或子types）。 您可以在运行时分配一个值 ，但在编译时必须知道其types 。

Answer 8

另一个区别是，我在其他语言中遇到的常量是： 不能初始化常量（let）以后 ， 应该初始化为你要声明的常量。

例如 ：

 let constantValue : Int // Compile error - let declarations require an initialiser expression 

variables

 var variableValue : Int // No issues 

Answer 9

let用来声明一个常量值，这意味着给它一个初始值之后你不会改变它。
var用于decalrevariables值，这意味着您可以根据需要更改它的值。

Answer 10

let用来定义常量和var来定义variables。 你可以使用var来定义string，然后可以通过将string赋值给一个variables（在这种情况下它可以被修改）来修改（或者变异）string，如果你定义了string，使用它的常量（在这种情况下，它不能是改性）：

 var variableString = "Apple" variableString += " and Banana" // variableString is now "Apple and Banana" let constantString = "Apple" constantString += " and another Banana" // this reports a compile-time error - a constant string cannot be modified 

Answer 11

像Luc-Oliver，NullData和其他一些人在这里所说的那样， let var定义可变数据， let定义不可变的数据。 任何可以在标记为mutating的variables上调用的func只能在varvariables的情况下调用（编译器会抛出错误）。 这也适用于func的一个inoutvariables。

但是， let和var也意味着该variables不能被重新分配。 它有两个含义非常相似的目的

Answer 12

var值可以在初始化后改变。 但是一旦使用， 让价值不变。

如果是var

  function variable() { var number = 5, number = 6; console.log(number); // return console value is 6 } variable(); 

如果让

  function abc() { let number = 5, number = 6; console.log(number); // TypeError: redeclaration of let number } abc(); 

Answer 13

关键字var用于定义一个variables，其值可以很容易地更改，如下所示：

 var no1 = 1 // declaring the variable no1 = 2 // changing the value since it is defined as a variable not a constant 

但是，let关键字只是在您不想再次更改常量的值时创build常量。 如果您尝试更改常量的值，则会出现错误：

 let no2 = 5 // declaring no2 as a constant no2 = 8 // this will give an error as you cannot change the value of a constant 

Answer 14

让我们是一个不可变的variables，这意味着它不能改变，其他语言称这是一个常量。 在C ++中，您可以将其定义为const。

Var是一个可变的variables，这意味着它可以被改变。 在C ++（2011版本更新）中，它与使用auto相同，但swift允许在使用中更灵活。 这是初学者比较熟知的variablestypes。

Answer 15

“使用让一个常量和var做一个variables”

摘录自：苹果公司“Swift编程语言”，iBooks。 https://itun.es/us/jEUH0.l

Answer 16

让关键字定义一个常量

 let myNum = 7 

所以myNum不能改变。

但是var定义了一个普通的variables。

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

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

例如

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

但是如果我们接受让…

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

Answer 17

每个人都有很多答案，但是这里有一个方法可以记住什么是什么

让我们总是说“让”一样的想法，因为让这个工作一次，总是为“variables”variables的总是可以改变，因此他们被称为variables的

Answer 18

让它成为一个不变的价值，所以永远不能改变。

 let number = 5 number = 6 //This will not compile. 

Var是一个variables，并且可以改变（但是在它被定义为不是不同的数据types之后）。

 var number = 5 number = 6 //This will compile. 

如果您尝试将该variables更改为其他数据types，它将不起作用

 var number = 5 number = "Hello World" //This will not compile. 

Answer 19

var是在swift中创buildvariables的唯一方法。 var并不意味着像javascript这样的解释语言的dynamicvariables。 例如，

 var name = "Bob" 

在这种情况下，推断variablesname的types是Stringtypes，我们也可以通过显式定义types来创buildvariables，例如

 var age:Int = 20 

现在，如果您分配一个string年龄，则编译器给出了错误。

let用来声明常量。 例如

 let city = "Kathmandu" 

或者我们也可以做，

 let city:String = "Kathmandu" 

如果您尝试更改城市的值，则会在编译时发生错误。

Answer 20

主要区别在于varvariables值可以改变，而不能。 如果你想有一个用户input的数据，你可以使用var所以可以改变这个值，并且使用let数据typesvariables，所以这个值不能被改变。

 var str = "dog" // str value is "dog" str = "cat" // str value is now "cat" let strAnimal = "dog" // strAnimal value is "dog" strAnimal = "cat" // Error ! 

Answer 21

在var的情况下可以重新分配一个值

  //Variables var age = 42 println(age) //Will print 42 age = 90 println(age) //Will Print 90 

** newAge常量不能被重新分配到一个新的值。 试图这样做会给编译时间错误**

 //Constants let newAge = 92 //Declaring a constant using let println(newAge) //Will print 92. 

Answer 22

在swift中，我们有两种types的variables

1. VAR
2. 让

这两个工作都是一样的，包含对象（复制值，参考值等）。

在varvariables中，我可以在程序执行过程中将包含对象改为另一个对象

 var x = 12 x = 13 // it is Ok 

在让variables我不能改变包含对象到另一个程序执行，而是我必须首先初始化它像在Java，C + +的其他语言像常量或最终。

 let x = 12 x = 13 // it is not OK , it will generate error 

Answer 23

虽然目前我仍在阅读手册，但是我认为这与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 ++指针的期望。

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

Answer 24

使用var关键字和let关键字和variables声明常量。

 let maximumNumberOfLoginAttempts = 10 var currentLoginAttempt = 0 let maximumNumberOfLoginAttempts = 10 var currentLoginAttempt = 0 

在一行中声明多个常量或多个variables，用逗号分隔：

 var x = 0.0, y = 0.0, z = 0.0 

打印常量和variables

您可以使用println函数打印常量或variables的当前值：

 println(friendlyWelcome) 

Swift使用string插值将常量或variables的名称作为占位符包含在较长的string中

用圆括号将名称包装起来，并在左括号之前用反斜杠进行转义：

 println("The current value of friendlyWelcome is \(friendlyWelcome)") 

参考： http : //iosswift.com.au/?p=17

Answer 25

find一个很好的答案希望它可以帮助:)