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

时间：2014-06-02 19:46:12

标签： swift

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

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

32 个答案:

答案 0 :(得分：380)

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

let theAnswer = 42

之后无法更改theAnswer。这就是为什么weak无法使用let编写的原因。他们需要在运行时更改，而您必须使用var。

var定义了一个普通变量。

有趣的是：

  

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

另一个奇怪的特征：

  

您可以使用几乎任何您喜欢的字符来保持常量和变量   名称，包括Unicode字符：

let  = "dogcow"

摘自：Apple Inc.“The Swift Programming Language。”iBooks。 https://itunes.apple.com/WebObjects/MZStore.woa/wa/viewBook?id=881256329

修改

因为评论要求在答案中添加其他事实，请将其转换为community wiki answer。随意编辑答案，使其更好。

答案 1 :(得分：32)

根据The Swift Programming Language Book

  

与C一样，Swift使用变量来存储，并使用引用来表示值   识别名称。 Swift还广泛使用其变量   值无法更改。这些被称为常数，并且很多   比C中的常量更强大。

var和let都是引用，因此let是 const引用。 使用基本类型并不能真正显示let与const的区别。 将它与类实例（引用类型）一起使用时会产生差异：

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"

答案 2 :(得分：14)

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

答案 3 :(得分：7)

非常简单：

  • let是不变的。
  • var是动态的。

描述一点：

let创建一个常量。 （有点像NSString）。设置后，您无法更改其值。您仍然可以将其添加到其他内容并创建新变量。

var创建一个变量。 （有点像NSMutableString）所以你可以改变它的值。但这已得到多次回答。

答案 4 :(得分：6)

通过可变性/不可变性概念来表达这种差异可能更好，这是正确的范式和对象空间中的实例可变性，它大于唯一的“常数/变量”通常概念。 而且这更接近于Objective C方法。

2种数据类型：值类型和引用类型。

在价值类型的背景下：

'let'定义一个常量值（不可编码）。 'var'定义了一个可变值（可变）。

let aInt = 1   //< aInt is not changeable

var aInt = 1   //< aInt can be changed

在参考类型的上下文中：

数据的标签不是值，而是对值的引用。

如果aPerson = Person（姓名：Foo，first：Bar）

aPerson不包含此人的数据，但包含对此人数据的引用。

let aPerson = Person(name:Foo, first:Bar)
               //< data of aPerson are changeable, not the reference

var aPerson = Person(name:Foo, first:Bar)
               //< both reference and data are changeable.

eg:
var aPersonA = Person(name:A, first: a)
var aPersonB = Person(name:B, first: b)

aPersonA = aPersonB

aPersonA now refers to Person(name:B, first: b)

答案 5 :(得分：6)

在

Swift编程语言文档的

Declaring Constants and Variables部分指定了以下内容：

  

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

确保了解这对参考类型有何用处。与值类型不同，尽管引用类型的实例被声明为常量，但对象的基础属性可以更改。请参阅文档的Classes are Reference Types部分，并查看更改frameRate属性的示例。

答案 6 :(得分：4)

let定义了一个＆＃34;常量＆＃34;。它的值只设置一次，但不一定是在声明它时。例如，您使用let来定义必须在初始化期间设置的类中的属性：

class Person {

    let firstName: String
    let lastName: String

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

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

您必须在编译时为所有变量（let或var）定义类型，并且尝试设置变量的任何代码都只能使用该类型（或子类型）。您可以在运行时分配值，但必须在编译时知道 type 。

答案 7 :(得分：2)

let用于声明一个常量值 - 在给它一个初始值后你不会改变它。
var用于声明变量值 - 您可以根据需要更改其值。

答案 8 :(得分：2)

我在Constants的其他语言中遇到的另一个区别是： 无法初始化常量（let）以供日后使用 ，应初始化因为你要宣布常数。

例如：

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

变量

var variableValue : Int // No issues

答案 9 :(得分：1)

就像Luc-Oliver，NullData和其他一些人所说的那样，let定义了不可变数据，而var定义了可变数据。可以在标记为func的变量上调用的任何mutating只有在它是var变量时才会被调用（编译器将抛出错误）。这同样适用于func变量的inout。

但是，let和var也意味着无法重新分配变量。它有两个含义，两者具有非常相似的目的

答案 10 :(得分：1)

var 是变量，可以根据需要多次更改，随时可以更改

例如

var changeit:Int=1
changeit=2
 //changeit has changed to 2

let 是不可更改的常量

例如

let changeit:Int=1
changeit=2
 //Error becuase constant cannot be changed

答案 11 :(得分：1)

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

Var是一个可变变量，意味着它可以被改变。在C ++（2011版本更新）中，它与使用auto相同，但swift允许更灵活的使用。对于初学者来说，这是更为人熟知的变量类型。

答案 12 :(得分：1)

关键字var用于定义一个变量，其值可以轻松更改，如下所示：

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

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

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

答案 13 :(得分：1)

初始化后，

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();

答案 14 :(得分：1)

让 用于定义常量， var 用于定义变量。 您可以使用 var 定义字符串，然后通过将其分配给变量（在这种情况下可以修改）来修改（或变异）特定字符串，如果您定义字符串使用 让 作为常量（在这种情况下无法修改）：

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

答案 15 :(得分：0)

主要区别在于var变量值可以更改，let可以更改。如果要获得用户输入数据，可以使用var，以便可以更改该值并使用let数据类型变量，因此无法更改该值。 

var str      = "dog"  // str value is "dog"
str          = "cat"  // str value is now "cat"

let strAnimal = "dog" // strAnimal value is "dog"
strAnimal     = "cat" // Error !

答案 16 :(得分：0)

让关键字定义一个常量

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 x = 7 // here also x is instantiated with 7 
x = 99 // this will a compile time error

答案 17 :(得分：0)

让是一个常量值，因此永远无法更改。

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

Var 是一个变量，可以更改（但在定义为不同的数据类型之后）。

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

如果您尝试将变量更改为其他数据类型，则无法正常工作

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

答案 18 :(得分：0)

每个人都已经回答了这个问题，但这里有一种你能记住什么的方式

让我们总是说同样的想法＆＃34;让＆＃34;因为让这个工作一次，总是和＃34; var＆＃34;变量总是可以改变，因此它们被称为变量

答案 19 :(得分：0)

可变性

let-constant
var-variable

值和引用类型[About]

值（结构，枚举）

Swift的struct可以更改其可变性状态：

let + struct = immutable =值常量
不能不重新分配 或更改

var + struct = mutable
可以重新分配或更改

引用类型（类）

Swift的classes是可变的

let + class =地址常量
不能不重新分配，并且可以更改

var + class
可以重新分配或更改 

//let + struct
let letStructA = StructA()
letStructA.a = 5 //Compile ERROR: Cannot assign to property: 'structALet' is a 'let' constant

letStructA = StructA() // Compile ERROR: Cannot assign to value: 'structALet' is a 'let' constant

//var + struct
var varStructA = StructA()
varStructA.a = 5

varStructA = StructA()

//let + class
let letClassA = ClassA()
letClassA.a = 5

letClassA = ClassA() // Compile ERROR: Cannot assign to value: 'classALet' is a 'let' constant

//var + class
var varClassA = ClassA()
varClassA.a = 5

varClassA = ClassA()

mutating突变函数（仅适用于结构）

您可以将struct的方法标记为mutating

  1. 指示此函数更改内部属性值。
  2. 只能在var + struct上使用
public struct StructA {
    public var a = 0

    public init() {}

    //func foo() { //Compile ERROR: Cannot assign to property: 'self' is immutable
    mutating func foo() {
        a = 5
    }
}

inout修改函数内部的结构（仅适用于结构）

您可以将函数的参数标记为inout

由于struct是一种值类型，因此按值传递它，因为结果函数将检索副本。如果将struct标记为inout参数，则表示此参数变为var，并且您可以更改状态struct，并且这些更改将在功能范围

//func foo(myStruct: StructA) { //Compile ERROR: line - myStruct.a = 10: Cannot assign to property: 's' is a 'let' constant
func foo(myStruct: inout StructA) {
    myStruct.a = 10
}

//using
//foo(myStruct: &letStructA) // Compile ROOR: Cannot pass immutable value as inout argument: 'letStructA' is a 'let' constant
foo(myStruct: &varStructA)
  

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

答案 20 :(得分：0)

在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.

答案 21 :(得分：0)

<?xml version="1.0" standalone="yes"?> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" "http://www.w3.org/TR/REC-html40/loose.dtd"> <html><body><p>&lt;div&gt;&lt;span class="font-4 box1-r"&gt;3,757,209&lt;/span&gt;&lt;/div&gt;</p></body></html> 是在swift中创建变量的唯一方法。 var并不意味着动态变量，就像javascript这样的解释语言一样。例如，

var

在这种情况下，变量var name = "Bob" 的类型推断出名称的类型为name，我们也可以通过显式定义类型来创建变量，例如

String

现在，如果将字符串分配给age，则编译器会给出错误。

var age:Int = 20 用于声明常量。例如

let

或者我们也可以，

let city = "Kathmandu"

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

答案 22 :(得分：0)

let用于当var是普通变量

时无法修改的常量

示例：

让名字=“鲍勃” 像name =“Jim”这样的东西会抛出错误，因为常量不能被修改。

答案 23 :(得分：0)

即使let和var之间已经有很多区别，但主要区别是：

package src.card;

public class PersistentQueries {

  private String sqlInsert = "INSERT INTO Cards(question, answer) VALUES 
 (?,?)";
  private String sqlSelectID = "SELECT ID FROM Cards";
  private String sqlSelect = "SELECT question and answer FROM Cards";


  public String getSqlInsert() {
   return sqlInsert;
  }

  public void setSqlInsert(String sqlInsert) {
    this.sqlInsert = sqlInsert;
  }


  public String getSqlSelectID() {
   return sqlSelectID;
   }

  public void setSqlSelectID(String sqlSelectID) {
   this.sqlSelectID = sqlSelectID;
  }

   public String getSqlSelect() {
   return sqlSelect;
  }

  public void setSqlSelect(String sqlSelect) {
   this.sqlSelect = sqlSelect;
  }
}

答案 24 :(得分：0)

简单差异

let =（无法更改）

var =（随时更新）

答案 25 :(得分：0)

来源：https://thenucleargeeks.com/2019/04/10/swift-let-vs-var/

使用var声明变量时，表示可以更新，可以更改，可以修改值。

使用let声明变量时，意味着它无法更新，它是非变量，其值不能修改。

var a = 1 
print (a) // output 1
a = 2
print (a) // output 2

let b = 4
print (b) // output 4
b = 5 // error "Cannot assign to value: 'b' is a 'let' constant"

让我们理解上面的示例：我们创建了一个带有“ var keyword”的新变量“ a”，并为其分配了值“ 1”。当我打印“ a”时，输出为1。然后将2分配给“ var a”，即我正在修改变量“ a”的值。我可以做到这一点而不会出现编译器错误，因为我将其声明为var。

在第二种情况下，我用“ let keyword”创建了一个新变量“ b”，并将值分配为“ 4”。当我打印“ b”时，我得到4作为输出。然后，我尝试将5分配给“ let b”，即尝试修改“ let”变量，然后出现编译时错误“无法分配给值：“ b”是“ let”常量”。

答案 26 :(得分：0)

  

在Swift中， let 是只读属性，只能由getter访问。 let 是不可变的变量。

let示例：

let goldenRatio: Double = 1.6180339 {
    get { return field }
}
  

但是， var 是一种读写属性，因此它不仅可以通过getter进行访问，还可以通过setter进行访问。 var 是可变的。

var示例：

var voltage: Int = 110 {
    get { 
        return field 
    }
    set(value) { 
        field = value 
    }
}

如果您尝试更改不可变的let，则Xcode会向您显示错误：

func changerOfTheValue() {  
    goldenRatio = 1.62        // ERROR
    print(goldenRatio)
}

// RESULT:  "let" cannot be reassigned

但是可变的var可以很容易地更改：

func changerOfTheValue() {  
    voltage = 220
    print(voltage)
}

// RESULT:  220

希望这会有所帮助。

答案 27 :(得分：-1)

let 关键字用于声明常量，var 关键字用于声明变量。使用这些引用、指针或值创建的变量。

它们之间的区别在于，当您使用 let 创建变量时，它将在声明时变为常量，以后无法修改或重新分配。相比之下，带有 var 的变量可以立即赋值，也可以稍后赋值，或者根本不赋值。在 swift 中，您必须非常明确地声明您要声明的内容。

答案 28 :(得分：-1)

let和var都用于在swift中声明变量。

让：  Let用于声明表示不可变的常量。如果不可变变量定义一次，则永远不能更改。像

tf=$(mktemp); echo "ping xxx.xxx.xxx.xxx source loopback xx">$tf; output=$(ssh user@$1 bash -s < $tf); echo $output; rm -f $tf

Var： Var用于声明可变的变量。比意味着可以在运行时更改值。例如：

let value = 42

如果您像 var value = 52 这样进行更改，则更新成功。

答案 29 :(得分：-2)

虽然目前我还在阅读手册，但我认为这非常接近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 ++指针的期望。

我相信这是一种支持某种const-correctness stuff的机制。

答案 30 :(得分：-2)

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

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

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

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

打印常量和变量

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

println(friendlyWelcome)

Swift使用字符串插值将常量或变量的名称包含在较长字符串中的占位符

将名称括在括号中，并在左括号前用反斜杠转义：

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

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

答案 31 :(得分：-3)

找到一个好的答案希望它可以帮助:) enter image description here

相关问题
最新问题