В чем разница между let и var на языке Apple Swift?
В моем понимании, это скомпилированный язык, но он не проверяет тип во время компиляции. Это меня смущает. Как компилятор знает о ошибке типа? Если компилятор не проверяет тип, не проблема с производственной средой?
Ключевое слово let определяет константу:
let theAnswer = 42
После этого theAnswer не может быть изменен. Вот почему ничего weak нельзя записать с помощью let. Они должны меняться во время выполнения, и вместо этого вы должны использовать var.
var определяет обычную переменную.
Что интересно:
Значение константы не обязательно должно быть известно во время компиляции, но вы должны назначить значение ровно один раз.
Еще одна странная особенность:
Вы можете использовать почти любой символ, который вам нравится для константы и переменной имена, включая символы Unicode:
let 🐶🐮 = "dogcow"
Отрывки из: Apple Inc. "Язык быстрого программирования". интерактивные книги. https://itunes.apple.com/WebObjects/MZStore.woa/wa/viewBook?id=881256329
Потому что комментарии просят добавить другие факты в ответ, конвертируя это в ответ wiki сообщества. Не стесняйтесь редактировать ответ, чтобы сделать его лучше.
Согласно Быстрая книга по программированию
Подобно C, 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"
let используется для определения констант и var для определения переменных.
Возможно, лучше констатировать это различие понятием изменчивости/неизменности, которое является правильной парадигмой изменчивости значений и экземпляров в пространстве объектов, которая больше, чем единственные обычные понятия "постоянная/переменная". И, кроме того, это ближе к подходу 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)
Объявление констант и переменных в документации Swift Programming Language указывает следующее:
Вы объявляете константы с ключевым словом let и переменными с ключевым словом var.
Не забудьте понять, как это работает для типов ссылок. В отличие от типов значений, свойства, лежащие в основе объекта, могут измениться, несмотря на то, что экземпляр ссылочного типа объявлен как константа. См. Раздел Classes the Reference Types в документации и посмотрите пример, в котором они изменяют свойство 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 или lastName после вызова (например) Person(first:"Malcolm", last:"Reynolds") для создания экземпляра Person.
Вы должны определять тип для всех переменных (let или var) во время компиляции, а любой код, который пытается установить переменную, может использовать только этот тип (или подтип), Вы можете назначить значение во время выполнения, но его тип должен быть известен во время компиляции.
let используется для объявления постоянного значения - вы не измените его после задания начального значения. var используется для объявления значения переменной - вы можете изменить ее значение по своему желанию.
Еще одно отличие, которое я встретил на других языках для Constants: не может инициализировать константу (let) для более позднего, должен инициализироваться, так как вы собираетесь объявить константу.
Например:
let constantValue : Int // Compile error - let declarations require an initialiser expression
Переменная
var variableValue : Int // No issues
пусть используется для определения констант и var для определения переменных. Вы определяете строку с помощью var, тогда конкретная строка может быть изменена (или мутирована), назначив ее переменной (в этом случае она может быть изменена), и если вы определяете строку, используя let его константа (в этом случае она не может быть изменена):
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
Значение может быть переназначено в случае 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.
"Используйте let для создания константы и var для создания переменной"
Excerpt From: Apple Inc. "The Swift Programming Language." iBooks. https://itun.es/us/jEUH0.l
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.
let ключевое слово определяет константу
let myNum = 7
поэтому myNum не может быть изменен впоследствии;
Но var определяет обычную переменную.
Значение константы не должно быть известно во время компиляции, но вы должны назначить ему значение ровно один раз.
Вы можете использовать почти любой символ, который вам нравится для имен констант и переменных, включая символы Unicode;
например.
var x = 7 // here x is instantiated with 7
x = 99 // now x is 99 it means it has been changed.
Но если взять let then...
let x = 7 // here also x is instantiated with 7
x = 99 // this will a compile time error
Основное отличие состоит в том, что значение переменной var может меняться, а let не может. Если вы хотите иметь пользовательские входные данные, вы должны использовать var, чтобы значение можно было изменить и использовать переменную let datatype, чтобы значение не могло быть изменено.
var str = "dog" // str value is "dog"
str = "cat" // str value is now "cat"
let strAnimal = "dog" // strAnimal value is "dog"
strAnimal = "cat" // Error !
Как и Luc-Oliver, NullData и некоторые другие, здесь let определяет неизменяемые данные, а var определяет изменяемые данные. Любой func, который можно вызвать в переменной, помеченной mutating, можно вызывать только в том случае, если она является переменной var (компилятор будет вызывать ошибку). Это также относится к func, которые принимают переменную inout.
Однако let и var также означают, что переменная не может быть переназначена. Он имеет два значения, оба с очень схожими целями
var может быть изменено после инициализации. Но значение let не изменяется, когда оно выполняется один раз.
В случае 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();
Ключевое слово 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
Пусть это неизменная переменная, означающая, что ее нельзя изменить, другие языки называют ее константой. В С++ его можно определить как const.
Var - изменяемая переменная, что означает, что ее можно изменить. В С++ (обновление версии 2011 года) это то же самое, что и при использовании auto, хотя swift позволяет увеличить гибкость в использовании. Это более известный тип переменной для начинающих.
В swift мы имеем два типа переменных
оба эти задания одинаковы, содержат объекты (значение копирования, ссылочное значение и т.д.).
В переменной var я могу сменить объект на другой, пока программа выполняет
var x = 12
x = 13 // it is Ok
В переменной let я не могу изменить содержащий объект на другой во время выполнения программы, вместо этого мне нужно сначала инициализировать его. Это похоже на константу или окончание на других языках, таких как Java, С++.
let x = 12
x = 13 // it is not OK , it will generate error
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.
ПРОСТАЯ РАЗНИЦА
let = (не может быть изменено)
var = (обновление в любое время)
В Swift
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
Надеюсь это поможет.
Оба позволяют & var используются для объявления переменных в swift.
Пусть: Пусть используется для объявления постоянной переменной, что означает неизменяемость. Неизменная переменная никогда не может быть изменена, если она определена один раз. Пример как
let value = 42
Var: Var используется для объявления переменной, которая является изменяемой. Чем означает, что значение может быть изменено во время выполнения. Пример:
var value = 42
Если вы измените его как var value = 52, оно будет успешно обновлено.
let - immutable aka constant
var - mutable aka variable
Тип значения и ссылки[About]
let + struct
не может быть переназначенным или измененным
var + struct
var + class
can может быть переназначен или изменен
.let + class
can not может быть переназначен, а может быть изменен
mutating отмечает метод
struct, поскольку функции, помеченные как mutating, изменяют значения внутренних свойств.var + structinout отмечает параметр
Поскольку struct являются типами значений, они передаются по значению. Это означает, что их содержимое будет скопировано при передаче в функции. Переменная структуры может быть помечена как параметр inout, если ее необходимо изменить внутри функции, и ее значение сохраняется вне области действия функции. Параметры, помеченные inout, в основном становятся переменными var, в отличие от констант let.
Используйте let, когда можете. Используйте var, когда вам нужно.
Все в целом ответили на это, но здесь вы можете вспомнить, что
Пусть всегда будет сказано то же самое, что и "пусть", так как эта работа для раз и всегда, как для переменной "var", всегда может изменяться, поэтому они называются переменной
var - единственный способ создать переменные в swift. var не означает динамическую переменную, как в случае интерпретируемых языков, таких как javascript. Например,
var name = "Bob"
В этом случае тип переменной name определяется, что имя имеет тип String, мы также можем создавать переменные, явно определяя тип, например
var age:Int = 20
Теперь, если вы назначаете строку для возраста, тогда компилятор выдает ошибку.
let используется для объявления констант. Например
let city = "Kathmandu"
Или мы также можем сделать,
let city:String = "Kathmandu"
Если вы пытаетесь изменить значение города, оно дает ошибку во время компиляции.
let используется для констант, которые не могут быть изменены, а var - обычная переменная
Пример:
let name = "Bob" Что-то вроде name = "Jim" выдает ошибку, так как константа can not может быть изменена.
Источник: 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"
Давайте разберемся в приведенном выше примере: мы создали новую переменную "a" с "ключевым словом var" и присвоили значение "1". Когда я печатаю "a", я получаю вывод как 1. Затем я присваиваю 2 "var a", т.е. я изменяю значение переменной "a". Я могу сделать это без получения ошибки компилятора, потому что я объявил его как var.
Во втором сценарии я создал новую переменную "b" с "let ключевое слово" и присвоил значение "4". Когда я печатаю "b", я получаю 4 в качестве вывода. Затем я пытаюсь присвоить 5 для "let b", т.е. я пытаюсь изменить переменную "let", и я получаю ошибку времени компиляции "Невозможно присвоить значение:" b - это константа let ".