신속하게 'let'과 'var'의 차이점은 무엇입니까?

Apple의 Swift 언어 let와 의 차이점은 무엇입니까 var?

내 이해로는 컴파일 된 언어이지만 컴파일 타임에 유형을 확인하지 않습니다. 혼란 스러워요. 컴파일러는 형식 오류에 대해 어떻게 알 수 있습니까? 컴파일러가 유형을 확인하지 않으면 프로덕션 환경에 문제가 있습니까?

let키워드는 상수를 정의합니다 :

let theAnswer = 42

는 theAnswer나중에 변경할 수 없습니다. 을 weak사용하여 어떤 것도 쓸 수없는 이유 let입니다. 그들은 필요가 변경 런타임 동안 당신은 사용해야합니다 var대신.

는 var일반 변수를 정의합니다.

흥미로운 점 :

상수 값은 컴파일 타임에 알 필요는 없지만 값을 정확히 한 번 할당해야합니다.

또 다른 이상한 특징 :

유니 코드 문자를 포함하여 상수 및 변수 이름에 원하는 거의 모든 문자를 사용할 수 있습니다.

let 🐶🐮 = "dogcow"

발췌 : Apple Inc.“Swift Programming Language.” iBooks. https://itunes.apple.com/WebObjects/MZStore.woa/wa/viewBook?id=881256329

편집하다

주석이 답변에 다른 사실을 추가하도록 요구하므로 커뮤니티 위키 답변으로 변환하십시오 . 답변을 자유롭게 편집하여 개선하십시오.

Swift Programming Language Book 에 따르면

C와 마찬가지로 Swift는 변수를 사용 하여 식별 이름으로 값 을 저장하고 참조 합니다. Swift는 또한 값을 변경할 수없는 변수를 광범위하게 사용합니다. 이것들은 상수로 알려져 있으며 C의 상수보다 훨씬 강력합니다.

둘 다 var하고 let있습니다 참조 따라서 letA는 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"

let상수 var를 정의하고 변수를 정의 하는 데 사용됩니다 .

객체 공간에서 유일한 "일정한 / 가변적 인"일반적인 개념보다 더 큰 값과 인스턴스의 변경 가능한 패러다임 인 Mutability / Unmutability 개념으로 이러한 차이를 설명하는 것이 좋습니다. 또한 이것은 Objective C 접근 방식에 더 가깝습니다.

두 가지 데이터 유형 : 값 유형 및 참조 유형.

값 유형의 맥락에서 :

'let'은 상수 값을 정의합니다 (최대 값). 'var'은 변경 가능한 값 (변경 가능)을 정의합니다.

let aInt = 1   //< aInt is not changeable

var aInt = 1   //< aInt can be changed

참조 유형의 맥락에서 :

데이터의 레이블은 값이 아니라 값에 대한 참조입니다.

aPerson = Person (name : 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)

그만큼

Swift Programming Language 문서의 상수 및 변수 선언 섹션은 다음을 지정합니다.

let 키워드를 사용하여 상수를 선언하고 var 키워드를 사용하여 변수를 선언합니다.

이것이 참조 유형에서 작동하는 방식을 이해해야합니다. 값 형식과 달리 개체의 기본 속성은 상수로 선언 된 참조 형식의 인스턴스에도 불구하고 변경 될 수 있습니다. 설명서 의 클래스는 참조 유형 섹션을 참조 하고 frameRate 특성을 변경하는 예제를보십시오.

매우 간단합니다 :

• let 일정합니다.
• var 동적입니다.

설명 비트 :

let상수를 만듭니다. (과 같은 종류 NSString). 일단 설정 한 후에는 값을 변경할 수 없습니다. 그래도 다른 것에 추가하고 새 변수를 만들 수 있습니다.

var변수를 만듭니다. (와 같은 정렬 NSMutableString) 값을 변경할 수 있습니다. 그러나 이것은 여러 번 대답되었습니다.

let"일정한"을 정의합니다. 값을 선언 할 때 반드시 그런 것은 아니지만 값은 한 번만 설정됩니다. 예를 들어 let초기화 중에 설정해야하는 클래스의 속성을 정의하는 데 사용 합니다.

class Person {

    let firstName: String
    let lastName: String

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

이 설정에서는 인스턴스 를 생성하기 위해 호출 (예 : 호출) 후 firstName또는 할당이 잘못되었습니다 .lastNamePerson(first:"Malcolm", last:"Reynolds")Person

당신은 있어야 모든 변수 (에 대한 유형 정의 let또는 var컴파일시에), 그리고 변수를 설정하려는 시도는 그 유형 (또는 하위 유형)을 사용할 수 있음에 코드를. 런타임시 값 을 지정할 수 있지만 컴파일시 해당 유형을 알아야합니다.

let- constant
var-variable

[일정한 대 변수]
[구조 대 클래스]

공식 문서 docs.swift.org 는 말합니다

constant설정 한 후에는 값을 변경할 수 없지만 variable, 나중에는 다른 값으로 설정할 수 있습니다.

이 용어는 실제로 재 할당 메커니즘을 설명합니다.

변경 성-변경 가능-객체 상태는 생성 후 변경 가능

값 및 참조 유형 ^[정보]

가치 (Struct, Enum)

스위프트 struct는 변경 상태를 변경할 수 있습니다.

let+ struct= immutable= 값 전율
이 가능 하지 될 재 할당 또는 변경

var+ struct= mutable
그것은 수 재배치 또는 변경

참고 유형 (클래스)

스위프트 classes는 mutable우선 순위입니다

let+ class= 주소 상수
는 가능 하지 될 재 할당 될 수 있고 변경

var+ class
그것은 수 재배치 또는 변경

//STRUCT
  //let + struct
let letStructA = StructA()

    //change FAIL
letStructA.a = 5 //Compile ERROR: Cannot assign to property: 'structALet' is a 'let' constant

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

  //var + struct
var varStructA = StructA()

    //change OK
varStructA.a = 5

    //reassign OK
varStructA = StructA()

//CLASS
  //let + class
let letClassA = ClassA()

    //change OK
letClassA.a = 5

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

  //var + class
var varClassA = ClassA()

    //change OK
varClassA.a = 5

    //reassign OK
varClassA = ClassA()

mutating -구조의 기능 변경

구조체의 메소드를 다음과 같이 표시 할 수 있습니다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 함수 내부의 구조체 수정

함수의 매개 변수 (struct)를 다음과 같이 표시 할 수 있습니다 inout

struct값 유형 이므로 결과 함수가 사본을 검색하므로 값 으로 전달됩니다 . a 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 EROOR: Cannot pass immutable value as inout argument: 'letStructA' is a 'let' constant
foo(myStruct: &varStructA)

let가능할 때마다 사용하십시오 . var필요할 때 사용하십시오 .

내가 상수에 대한 다른 언어로 만난 또 하나 개의 차이는 다음과 같습니다 되지 상수 초기화 나중에 (할) 수 , 당신은 상수를 선언하려합니다으로 초기화한다.

예를 들면 :

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

변하기 쉬운

var variableValue : Int // No issues 

let상수 값을 선언하는 데 사용됩니다. 초기 값을 제공 한 후에는 변경하지 않습니다.
var변수 값을 선언하는 데 사용됩니다. 원하는대로 값을 변경할 수 있습니다.

let 은 상수를 정의하고 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

키워드가 상수를 정의하자

let myNum = 7

나중에 myNum을 변경할 수 없습니다.

그러나 var는 일반적인 변수를 정의합니다.

상수 값은 컴파일 타임에 알 필요는 없지만 정확히 한 번만 값을 할당해야합니다.

유니 코드 문자를 포함하여 상수 및 변수 이름에 원하는 거의 모든 문자를 사용할 수 있습니다.

예 :

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

Luc-Oliver와 마찬가지로 NullData 및 일부 다른 사람들 은 가변 데이터 let를 var정의 하고 불변 데이터를 정의합니다. 모든 func표시된 변수에 호출 할 수는 mutating그것은 경우에만 호출 할 수있는 var변수 (컴파일러 오류가 발생합니다). 이것은 또한 변수 func를받는에 적용됩니다 inout.

그러나, let및 var도 변수가 재 할당 할 수 없음을 의미한다. 매우 유사한 목적을 가진 두 가지 의미가 있습니다.

초기화 후 var 값을 변경할 수 있습니다. 그러나 하자 가 intilize 번 경우, 값은 변화하지 않습니다.

var의 경우

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

let의 경우

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

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 

변경 불가능한 변수 라하자, 다른 언어에서는 이것을 상수라고 부릅니다. C ++에서는 const로 정의 할 수 있습니다.

Var은 변경 가능한 변수이므로 변경할 수 있습니다. C ++ (2011 버전 업데이트)에서는 자동을 사용하는 것과 동일하지만 신속하게 사용하면 유연성이 향상됩니다. 초보자에게 가장 잘 알려진 변수 유형입니다.

let 은 상수 값이므로 절대로 변경할 수 없습니다.

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

Var 은 변수이며 변경할 수 있습니다 (그러나 다른 데이터 유형으로 정의되지 않은 후).

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

변수를 다른 dataType으로 변경하려고하면 작동하지 않습니다

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

가장 큰 차이점은 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 !

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.

“상수를 만들고 변수를 만들려면 var를 사용하십시오”

Excerpt From: Apple Inc. “The Swift Programming Language.” iBooks. https://itun.es/us/jEUH0.l

var 는 원하는만큼 여러 번 변경할 수있는 변수입니다.

예를 들어

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

허락하다 변경되지 수있는 일정이다

예를 들어

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

let과 var 사이에 많은 차이가 있지만 주요 차이점은 다음과 같습니다.

let is compiled fast in comparison to var.

모든 사람들이 이것에 대해 거의 대답했지만 여기에 무엇이 무엇인지 기억하는 방법이 있습니다

항상 "일자"라고 생각하고 "var"변수가 항상 바뀔 수 있으므로 항상 "let"에 대해 같은 생각을 할 것입니다.

var신속하게 변수를 만드는 유일한 방법입니다. var자바 스크립트와 같은 해석 언어의 경우와 같이 동적 변수를 의미하지는 않습니다. 예를 들어

var name = "Bob"

이 경우 변수 유형은 namename이 type String인 것으로 추론됩니다. 예를 들어 유형을 명시 적으로 정의하여 변수를 만들 수도 있습니다.

var age:Int = 20

이제 연령에 문자열을 할당하면 컴파일러에서 오류가 발생합니다.

let상수를 선언하는 데 사용됩니다. 예를 들어

let city = "Kathmandu"

아니면 할 수도 있습니다

let city:String = "Kathmandu"

city ​​값을 변경하려고하면 컴파일시 오류가 발생합니다.

var는 일반 변수 인 동안 수정할 수없는 상수에 사용됩니다.

예:

let name =“Bob”상수 = 수정할 수 없으므로 name =“Jim”과 같은 오류가 발생합니다.

단순한 차이

let = (변경 불가)

var = (언제든지 업데이트)

출처 : 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로 출력됩니다. 그런 다음 "var a"에 2를 할당합니다. 즉, 변수 "a"의 값을 수정하고 있습니다. var로 선언했기 때문에 컴파일러 오류없이 수행 할 수 있습니다.

두 번째 시나리오에서는“let keyword”를 사용하여 새 변수“b”를 만들고 값“4”를 할당했습니다. “b”를 인쇄하면 출력으로 4가 표시됩니다. 그런 다음 "let b"에 5를 할당하려고합니다. 즉 "let"변수를 수정하려고하는데 컴파일 시간 오류가 발생합니다. "값을 할당 할 수 없습니다 : 'b'는 'let'상수입니다."

현재는 여전히 매뉴얼을 읽고 있지만 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. 그리고 이름 aaa1이 일정 하기 때문에 어떤 뮤 테이터 메소드도 호출 할 수 없습니다. 이것이 C / C ++ 포인터에서 정확히 예상 한 것입니다.

나는 이것이 일종의 const-correctness 를 지원하는 메커니즘이라고 생각합니다 .

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

그것이 도움이 될 수있는 좋은 대답을 찾았습니다. :)