В чем разница между `let` и`var` в swift?

Question

В чем разница между `let` и`var` в swift?

В чем разница между let а также var на языке Apple Swift?

В моем понимании это скомпилированный язык, но он не проверяет тип во время компиляции. Это меня смущает. Как компилятор узнает об ошибке типа? Если компилятор не проверяет тип, разве это не проблема с производственной средой?

366

swift

Источник

user2440343 02 июн '14 в 19:46

34 ответа

Решение

Согласно Книге языков программирования Swift

Как и C, Swift использует переменные для хранения и обращения к значениям по идентифицирующему имени. Swift также широко использует переменные, значения которых не могут быть изменены. Они известны как константы, и они намного мощнее, чем константы в C.

И то и другое var а также let поэтому ссылкиlet постоянная ссылка. Использование фундаментальных типов на самом деле не показывает, как 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"

36

Источник

user3771369 24 июн '14 в 16:00

let - constant
var - variable

[Константа против переменной]
[Структура против класса]

Официальный документ docs.swift.org говорит

Ценность constant не может быть изменен после его установки, тогда как variable можно установить другое значение в будущем.

Эта терминология фактически описывает механизм переназначения

Изменчивость

Изменяемость - изменяемость - состояние объекта может быть изменено после создания ^{[О программе]}

Тип значения и ссылки ^{[О программе]}

Тип ссылки (класс)

Свифта classes являются mutable по определению

var + class
Его можно переназначить или изменить

let + class= Константа адреса
может не быть переназначен и могут быть изменены

Значение (Struct, Enum)

Свифта struct могут изменить свой статус изменчивости:

var + struct знак равно mutable
Его можно переназначить или изменить

let + struct знак равно *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` - Функции мутирующей структуры

Вы можете пометить метод структуры как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 позволяет переназначить / изменить переданное (исходное) значение.
Вы можете только пройти var переменная внутри inout параметр
Результат виден, когда функция завершена

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 когда нужно.

20

Источник

user4770877 06 дек '19 в 22:23

let используется для определения констант и var определить переменные.

17

Источник

user621264 02 июн '14 в 20:30

Возможно, лучше констатировать это различие понятием изменчивости / неизменности, которое является правильной парадигмой изменчивости значений и экземпляров в пространстве объектов, которая больше, чем единственные обычные понятия "постоянная / переменная". И, кроме того, это ближе к подходу Objective C.

2 типа данных: тип значения и тип ссылки.

В контексте типов значений:

'let' определяет постоянное значение (не изменяемое). 'var' определяет изменяемое значение (изменяемое).

let aInt = 1   //< aInt is not changeable

var aInt = 1   //< aInt can be changed

В контексте типов ссылок:

Метка данных - это не значение, а ссылка на значение.

if aPerson = Person (имя:Foo, сначала: 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)

9

Источник

user2192483 05 июн '14 в 22:16

Очень просто:

let постоянно.
var динамично

Бит описания:

let создает постоянную. (вроде как NSString). Вы не можете изменить его значение, как только вы его установили. Вы все еще можете добавить его к другим вещам и создать новые переменные.

var создает переменную. (вроде как NSMutableString) так что вы можете изменить его значение. Но на это ответили несколько раз.

7

Источник

user2611413 09 мар '15 в 06:40

Объявление раздела " Константы и переменные " в документации по языку программирования Swift указывает следующее:

Вы объявляете константы с ключевым словом let, а переменные с ключевым словом var.

Убедитесь, что вы понимаете, как это работает для справочных типов. В отличие от типов значений, базовые свойства объекта могут изменяться, несмотря на то, что экземпляр ссылочного типа объявлен как константа. См. Раздел " Классы - ссылочные типы " документации и посмотрите на пример, где они изменяют свойство frameRate.

6

Источник

user2397902 08 июн '14 в 11:21

let определяет "константу". Его значение устанавливается один раз и только один раз, хотя не обязательно, когда вы его объявляете. Например, вы используете 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) во время компиляции, и любой код, который пытается установить переменную, может использовать только этот тип (или подтип). Вы можете присвоить значение во время выполнения, но его тип должен быть известен во время компиляции.

5

Источник

user957768 02 июн '14 в 20:42

let используется для объявления постоянного значения, что означает, что вы не измените его после присвоения ему начального значения.
var используется для удаления значения переменной, что означает, что вы можете изменить его значение по своему желанию.

4

Источник

user1803705 04 июн '14 в 13:39

Еще одно отличие, с которым я столкнулся в других языках для констант, заключается в следующем: не могу инициализировать константу (пусть) на потом, следует инициализировать, когда вы собираетесь объявить константу.

Например:

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

переменная

var variableValue : Int // No issues

2

Источник

user1127619 10 июн '14 в 10:05

Значение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();

1

Источник

user3932773 25 мар '15 в 05:21

Ключевое слово 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

1

Источник

user5303568 02 дек '15 в 13:48

Пусть является неизменной переменной, то есть ее нельзя изменить, другие языки называют ее константой. В C++ это вы можете определить как const.

Var является изменяемой переменной, это означает, что она может быть изменена. В C++ (обновление версии 2011 г.) это то же самое, что и использование auto, хотя swift обеспечивает большую гибкость в использовании. Это более известный тип переменной для начинающих.

1

Источник

user5221335 07 дек '15 в 07:39

var - это переменная, которую можно менять столько раз, сколько вы хотите и когда угодно

например

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

пусть это константа, которая не может быть изменена

например

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

1

Источник

user10779685 14 дек '18 в 08:53

Как Люк-Оливер, NullData и некоторые другие сказали здесь, let определяет неизменные данные в то время как var определяет изменяемые данные. любой func который может быть вызван для переменной, которая помечена mutating можно назвать только если это var переменная (компилятор выдаст ошибку). Это также относится к funcэто взять в inout переменная.

Тем не мение, let а также var также означает, что переменная не может быть переназначена. Это имеет два значения, оба с очень похожими целями

1

Источник

user2361040 16 фев '15 в 06:20

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

1

Источник

user2932036 02 июл '14 в 06:55

на быстром языке letявляется постоянным означает, что его нельзя переназначить, но var можно переназначить

      let question = "what is the difference between let and var?"

question = "another question" // this line cause syntax error

      
var answer = "let is constant and var is simple variable"

answer = "let can't be reassigned var can be reassigned" // this line will be excecuted

1

Источник

user14796492 02 янв '22 в 11:28

В Swift у нас есть два типа переменных

вар
позволять

оба эти задания одинаковы, содержат объекты (значение копии, ссылочное значение и т. д.).

В переменной var я могу изменить содержащий объект на другой во время выполнения программы

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

В переменной let я не могу изменить содержащий объект на другой во время выполнения программы, вместо этого мне нужно сначала его инициализировать. Это похоже на константу или финал в других языках, таких как Java,C++.

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

0

Источник

user6908100 14 мар '17 в 16:03

В Свифте let это свойство только для чтения, доступ к которому может получить только получатель. let является неизменной переменной

`let` пример:

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

Тем не мение, var является свойством чтения и записи, поэтому к нему может обращаться не только получатель, но и установщик. 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

Надеюсь это поможет.

0

Источник

user6599590 08 май '19 в 18:31

Хотя у вас уже есть много различий между let и var, но есть одно главное отличие:

let is compiled fast in comparison to var.

0

Источник

user7979089 03 янв '19 в 11:26

"Используйте let для создания константы и var для создания переменной"

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

0

Источник

user728246 14 июн '14 в 00:31

Значение может быть переназначено в случае 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.

0

Источник

user2188511 03 июн '14 в 04:19

let является постоянным значением, поэтому его нельзя изменить.

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.

0

Источник

user2687669 16 окт '14 в 04:22

Все в значительной степени ответили на это, но вот способ, которым вы можете вспомнить, что к чему

Пусть всегда будет говорить то же самое о "let", как и let, это работает один раз и всегда, как и для переменных "var", которые могут всегда меняться, поэтому их называют переменными

0

Источник

user4316174 21 окт '15 в 13:08

Основное отличие состоит в том, что 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 !

0

Источник

user4262842 17 ноя '14 в 23:23

Ключевое слово let определяет константу

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

0

Источник

user1755407 06 ноя '14 в 08:50

ПРОСТАЯ РАЗНИЦА

let = (не может быть изменено)

var = (обновление в любое время)

-1

Источник

user8136239 08 мар '19 в 06:01

let используется для констант, которые нельзя изменить, тогда как var - обычная переменная

Пример:

let name = "Bob" Что-то вроде name = "Jim" выдаст ошибку, так как константа не может быть изменена.

-1

Источник

user8860001 18 ноя '17 в 23:49

Ключевое слово используется для объявления константы, а ключевое слово - для объявления переменной. Переменные, созданные с помощью этих ссылок, указателей или значений.

Разница между ними в том, что при создании переменной с помощью letон станет постоянным после объявления, которое нельзя будет изменить или переназначить позже. Напротив, переменная с varможет быть назначен сразу или позже или вообще не назначен. В Swift вы должны быть очень точными в том, что вы объявляете.

-1

Источник

user2372899 17 апр '21 в 12:04

var это единственный способ создать переменную в Swift. var не означает динамическую переменную, как в случае интерпретируемых языков, таких как javascript. Например,

var name = "Bob"

В этом случае тип переменной name Предполагается, что имя имеет тип Stringмы также можем создавать переменные, явно определяя тип, например

var age:Int = 20

Теперь, если вы назначите строку возрасту, то компилятор выдаст ошибку.

let используется для объявления констант. Например

let city = "Kathmandu"

Или мы также можем сделать,

let city:String = "Kathmandu"

Если вы попытаетесь изменить значение city, он выдаст ошибку во время компиляции.

-1

Источник

user2417147 10 май '16 в 11:27

Другие вопросы по тегам swift

user632407 02 июн '14 в 19:55 2014-06-02 19:55 · Accepted Answer · 2014-06-02 19:55

let Ключевое слово определяет константу:

let theAnswer = 42

theAnswer не может быть изменено впоследствии. Вот почему что-нибудь weak не может быть написано с помощью let, Они должны измениться во время выполнения, и вы должны использовать var вместо.

var определяет обычную переменную.

Что интересно:

Значение константы не нужно знать во время компиляции, но вы должны назначить значение ровно один раз.

Еще одна странная особенность:

Для имен констант и переменных вы можете использовать практически любой символ, который вам нравится, в том числе символы Юникода:

let  = "dogcow"

Выдержки из: Apple Inc. "Язык программирования Swift". IBooks. https://itunes.apple.com/WebObjects/MZStore.woa/wa/viewBook?id=881256329

РЕДАКТИРОВАТЬ

Потому что комментарии просят добавить к ответу другие факты, преобразовывая это в ответ сообщества вики. Не стесняйтесь редактировать ответ, чтобы сделать его лучше.

В чем разница между `let` и`var` в swift?

34 ответа

РЕДАКТИРОВАТЬ

Тип значения и ссылки [О программе]

mutating - Функции мутирующей структуры

inout внутри функции

let пример:

var пример:

Если вы попытаетесь изменить неизменный let, Xcode покажет вам ошибку:

Но изменчивый var может быть легко изменено:

Тип значения и ссылки ^{[О программе]}

`mutating` - Функции мутирующей структуры

`inout` внутри функции

`let` пример:

`var` пример:

Если вы попытаетесь изменить неизменный `let`, Xcode покажет вам ошибку:

Но изменчивый `var` может быть легко изменено: