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

Согласно Быстрая книга по программированию

Подобно 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 для определения переменных.

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

• let является постоянным.
• var является динамическим.

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

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

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

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

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

Не забудьте понять, как это работает для типов ссылок. В отличие от типов значений, свойства, лежащие в основе объекта, могут измениться, несмотря на то, что экземпляр ссылочного типа объявлен как константа. См. Раздел Classes the Reference Types в документации и посмотрите пример, в котором они изменяют свойство frameRate.

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

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

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

Например:

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

Переменная

var variableValue : Int // No issues 

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

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

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

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

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

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

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

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

например

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

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

например

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

В 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 - единственный способ создать переменные в swift. var не означает динамическую переменную, как в случае интерпретируемых языков, таких как javascript. Например,

var name = "Bob"

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

var age:Int = 20

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

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

let city = "Kathmandu"

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

let city:String = "Kathmandu"

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

Все в целом ответили на это, но здесь вы можете вспомнить, что

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

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

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

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 для создания константы и var для создания переменной"

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

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

Пример:

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

Нашел хороший ответ, надеюсь, что он может помочь:)

Хотя в настоящее время я все еще читаю руководство, но я думаю, что это очень близко к указателю 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/С++.

Я считаю, что это механизм поддержки своего рода материала 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