`Let` ve` var` arasındaki fark nedir?

Apple'ın Swift dilinde letve vararasındaki fark nedir ?

Anladığım kadarıyla, bu derlenmiş bir dildir, ancak derleme zamanında türü kontrol etmez. Beni şaşırttı. Derleyici tür hatasını nasıl biliyor? Derleyici türü kontrol etmezse, üretim ortamıyla ilgili bir sorun değil mi?

letAnahtar kelime bir sabiti tanımlar:

let theAnswer = 42

theAnswerSonradan değiştirilemez. Bu yüzden hiçbir şey weakkullanılarak yazılamaz let. Çalışma zamanı sırasında değişmeleri gerekir ve varbunun yerine kullanmanız gerekir .

varSıradan bir değişkeni tanımlar.

İlginç olan nedir:

Bir sabitin değerinin derleme zamanında bilinmesine gerek yoktur , ancak değeri tam olarak bir kez atamanız gerekir.

Başka bir garip özellik:

Unicode karakterler de dahil olmak üzere sabit ve değişken adlar için neredeyse her karakteri kullanabilirsiniz:

let 🐶🐮 = "dogcow"

Alıntılar: Apple Inc. “Hızlı Programlama Dili.” iBooks. https://itunes.apple.com/WebObjects/MZStore.woa/wa/viewBook?id=881256329

DÜZENLE

Çünkü yorumlar cevaba başka gerçekler eklemeyi, bunu topluluk wiki cevabına dönüştürmeyi istiyor . Daha iyi hale getirmek için cevabı düzenlemekten çekinmeyin.

Swift Programlama Dil Kitabına Göre

C gibi Swift de tanımlayıcı bir adla değerleri depolamak ve değerlere başvurmak için değişkenleri kullanır . Swift ayrıca değerleri değiştirilemeyen değişkenleri kapsamlı bir şekilde kullanır. Bunlar sabitler olarak bilinir ve C'deki sabitlerden çok daha güçlüdür.

Hem varve lethem referanslardır , bu nedenle letbir const referansıdır . Temel türlerin kullanılması gerçekte nasıl letfarklı olduğunu göstermez const. Fark sınıf örnekleriyle (referans türleri) kullanıldığında gelir:

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"

letsabitleri tanımlamak ve vardeğişkenleri tanımlamak için kullanılır .

Bu farkı, yalnızca "sabit / değişken" olağan kavramlardan daha büyük olan Nesneler alanındaki değerlerin ve örneklerin değişebilirliğinin doğru paradigması olan Değişebilirlik / Değişmezlik kavramı ile belirtmek daha iyi olabilir. Dahası, bu Amaç C yaklaşımına daha yakındır.

2 veri tipi: değer tipi ve referans tipi.

Değer Türleri bağlamında:

'let' sabit bir değeri tanımlar (değiştirilemez). 'var' değiştirilebilir bir değeri (değişken) tanımlar.

let aInt = 1   //< aInt is not changeable

var aInt = 1   //< aInt can be changed

Referans Türleri bağlamında:

Bir verinin etiketi değer değil, bir değere referanstır.

eğer aPerson = Kişi (isim: Foo, önce: Bar)

aPerson bu kişinin Verilerini içermez, ancak bu Kişinin verilerine referans verir.

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)

The

Swift Programlama Dili belgelerinin Sabitleri ve Değişkenleri Bildirme bölümü aşağıdakileri belirtir:

Let anahtar sözcüğüyle sabitleri ve var anahtar sözcüğüyle değişkenleri bildirirsiniz.

Bunun Referans türleri için nasıl çalıştığını anladığınızdan emin olun. Değer Türlerinden farklı olarak, sabit olarak bildirilen bir başvuru türünün bir örneğine rağmen nesnenin temel özellikleri değişebilir. Bkz Sınıflar Referans Tipleri vardır onlar frameRate özelliğini değiştirmek örneğe belgelerin bölüm ve bakış.

Çok basit:

• let sabittir.
• var dinamiktir.

Biraz açıklama:

letbir sabit oluşturur. (bir çeşit gibi NSString). Ayarladıktan sonra değerini değiştiremezsiniz. Yine de başka şeylere ekleyebilir ve yeni değişkenler oluşturabilirsiniz.

varbir değişken oluşturur. (bir çeşit gibi NSMutableString) böylece değerini değiştirebilirsiniz. Ama bu birkaç kez cevaplandı.

let"sabiti" tanımlar. Değeri bir kez ve sadece bir kez ayarlanır, ancak bildirdiğinizde zorunlu değildir. Örneğin, letsınıfta başlatma sırasında ayarlanması gereken bir özellik tanımlamak için kullanılır :

class Person {

    let firstName: String
    let lastName: String

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

Bu kurulum ile, atamak, geçersiz olduğundan firstNameveya lastName(örneğin) çağrıldıktan sonra Person(first:"Malcolm", last:"Reynolds")bir oluşturma Personörneği.

Eğer gereken tüm değişkenler için (bir tür tanımlamak letveya varderleme zamanında) ve bir değişken için girişimler sadece bu tür (veya bir alt türü) kullanabilir herhangi bir kod. Çalışma zamanında bir değer atayabilirsiniz , ancak türü derleme zamanında bilinmelidir.

let- constant
var-variable

[Sabit ve değişken]
[Struct - Class]

Resmi doc docs.swift.org diyor

A değeri constantayarlandıktan sonra değiştirilemezken, variablea değeri gelecekte farklı bir değere ayarlanabilir.

Bu terminoloji aslında yeniden atama mekanizmasını tanımlamaktadır

Değişebilirlik - değiştirilebilir - nesnenin durumu yaratıldıktan sonra değiştirilebilir

Değer ve Referans Türü ^[Hakkında]

Değer (Yapı, Enum)

Swift struct, değiştirilebilirlik durumlarını değiştirebilir:

let+ struct= immutable= Değerinin sabit
Bu olabilir değil edilebilir yeniden veya değiştirilebilir

var+ struct= mutable
O olabilir yeniden veya değiştirilebilir

Referans Türü (Sınıf)

Swift en classesşunlardır mutablea-manastır

let+ class= Adresin sabit
O yapabilirsiniz değildir edilmesi yeniden edilebilir değişti

var+ class
Bu edilebilir yeniden veya değiştirilebilir

//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 - Mutasyon Yapısı İşlevleri

Bir yapının yöntemini şu şekilde işaretleyebilirsiniz:mutating

1. Bu işlevin dahili özellik değerlerini değiştirdiğini gösterir.
2. Yalnızca 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 Bir işlev içindeki yapıyı değiştirme

Bir işlevin parametresini (struct olan) olarak işaretleyebilirsiniz. inout

Yana structbir değer türüne, bunun tarafından geçirilen değerin bir kopyasını alır bir sonuç fonksiyonu olarak. Eğer bir işaretlerseniz structolarak inoutparametrenin bu parametre hale gelmesi anlamına gelir varve hal değiştirmek edebiliyoruz structve bu değişiklikler fonksiyon kapsamı dışında görünür olacak

//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)

letMümkün olduğunca kullanın . Gerektiğinde kullanın var.

Ben Sabitlerinin için diğer dillerde karşılaştığınız Bir daha fark vardır: değil sabiti initialise sonrası için (let) olabilir , sen sabiti ilan etmek üzereyiz olarak initialise gerekir.

Örneğin :

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

Değişken

var variableValue : Int // No issues 

letsabit bir değer bildirmek için kullanılır - başlangıç ​​değeri verdikten sonra değiştirmezsiniz.
vardeğişken bir değer bildirmek için kullanılır - değerini istediğiniz gibi değiştirebilirsiniz.

let sabitleri tanımlamak için kullanılır vedeğişkenleri tanımlamak için var . Dizeyi var kullanarak tanımlarsanız,belirli bir String değişkene atanarak değiştirilebilir (veya değiştirilebilir) (bu durumda değiştirilebilir) ve eğer dizeyibir sabit ( let) değiştirilmiş):

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

anahtar kelimenin bir sabiti tanımlamasına izin ver

let myNum = 7

böylece myNum daha sonra değiştirilemez;

Ancak var, sıradan bir değişkeni tanımlar.

Bir sabitin değerinin derleme zamanında bilinmesine gerek yoktur, ancak tam olarak bir kez bir değer atamanız gerekir.

Unicode karakterler dahil olmak üzere sabit ve değişken adlar için istediğiniz hemen hemen her karakteri kullanabilirsiniz;

Örneğin

var x = 7 // here x is instantiated with 7 
x = 99 // now x is 99 it means it has been changed.

Ama izin verirsek ...

let x = 7 // here also x is instantiated with 7 
x = 99 // this will a compile time error

Luc-Oliver, NullData ve diğerleri gibi burada söylediler let, değişmez verileri vartanımlarken değişebilir verileri tanımlar. Herhangi funcişaretlenmiş değişkeni denebilecek mutatingbir ise yalnızca çağrılabilir vardeğişken (derleyici hata atmak olacaktır). Bu func, bir inoutdeğişkeni alan değişkenler için de geçerlidir .

Ancak, letve varayrıca değişken tekrar atanamaz anlamına gelir. Her ikisinin de çok benzer amaçları olan iki anlamı vardır

var değeri başlattıktan sonra değiştirilebilir. Ama izin o intilize kez olduğunda, değer değişikliği olmayacak.

Var olması durumunda

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

İzin durumunda

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

Var anahtar kelimesi, değerini şu şekilde kolayca değiştirebileceğiniz bir değişkeni tanımlamak için kullanılır:

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

Ancak, let anahtar sözcüğü yalnızca sabitin değerini tekrar değiştirmek istemediğinizde kullanılan bir sabit oluşturmaktır. Sabitin değerini değiştirmeyi denediyseniz, bir hata alırsınız:

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

Let değişmez bir değişkendir, yani değiştirilemez, diğer diller bunu sabit olarak adlandırır. C ++ 'da const olarak tanımlayabilirsiniz.

Var değiştirilebilir bir değişkendir, yani değiştirilebilir. C ++ 'da (2011 sürüm güncellemesi), auto kullanımı ile aynıdır, ancak swift kullanımda daha fazla esneklik sağlar. Bu yeni başlayanlar için daha iyi bilinen değişken türüdür.

let sabit bir değerdir, bu yüzden asla değiştirilemez.

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

Var bir değişkendir ve değişebilir (ancak farklı bir veri türüne göre tanımlanmadan sonra).

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

Değişkeni farklı bir dataType olarak değiştirmeyi denerseniz, çalışmaz

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

Temel fark, vardeğişken değerin değişebilmesi ve değişememesidir let. Bir kullanıcı giriş verisine sahip olmak istiyorsanız var, değerin değiştirilebilmesi ve letdatatype değişkeninin kullanılması için değer değiştirilemez.

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 olması durumunda bir değer yeniden atanabilir

 //Variables
 var age = 42
 println(age) //Will print 42
 age = 90
 println(age) //Will Print 90

** newAge sabiti yeni bir değere yeniden atanamaz. Bunu yapmaya çalışmak derleme zamanı hatası verir **

//Constants
let newAge = 92 //Declaring a constant using let
println(newAge) //Will print 92.

“Değişken yapmak için bir sabit yapmak için izin kullanın.”

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

var , istediğiniz kadar ve istediğiniz zaman değiştirilebilen bir değişkendir

Örneğin

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

let değiştirildi olamaz sabit olduğu

Örneğin

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

Let ve var arasında zaten birçok farkınız olsa da, bir ana fark şudur:

let is compiled fast in comparison to var.

Herkes bunu hemen hemen yanıtladı ama burada ne olduğunu hatırlamanın bir yolu var

Izin vermek her zaman aynı düşünelim "izin" olarak izin bu çalışma bir kez ve her zaman olduğu gibi "var" değişkeni her zaman değişebilir böylece değişken denir

vardeğişkenleri hızlı bir şekilde oluşturmanın tek yoludur. varjavascript gibi yorumlanmış dillerdeki gibi dinamik değişken anlamına gelmez. Örneğin,

var name = "Bob"

Bu durumda, değişken türü nameadın tür olduğu sonucuna varır String, örneğin türü açıkça tanımlayarak değişkenler de oluşturabiliriz, örneğin

var age:Int = 20

Şimdi yaşa bir dize atarsanız, derleyici hatayı verir.

letsabitleri bildirmek için kullanılır. Örneğin

let city = "Kathmandu"

Ya da yapabiliriz,

let city:String = "Kathmandu"

Şehrin değerini değiştirmeye çalışırsanız, derleme zamanında hata verir.

let değişkeni değiştiremeyen sabitler için kullanılır

Misal:

let name = “Bob” name = “Jim” gibi bir şey, sabit değiştirilemediğinden bir hata atar.

BASİT FARK

let = (değiştirilemez)

var = (her zaman güncelleme)

Kaynak: https://thenucleargeeks.com/2019/04/10/swift-let-vs-var/

Var olan bir değişkeni bildirdiğinizde, güncellenebileceği, değişken olduğu, değerinin değiştirilebileceği anlamına gelir.

Bir değişkeni let ile bildirdiğinizde, güncellenemeyeceği, değişken olmadığı anlamına gelir, değeri değiştirilemez.

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"

Yukarıdaki örneği anlayalım: “var anahtar kelime” ile yeni bir “a” değişkeni oluşturduk ve “1” değerini atadık. “A” yazdırdığımda çıktı 1 olur. Sonra “var a” ya 2 atarım, yani “a” değişkeninin değerini değiştiriyorum. Derleyici hatası almadan yapabilirim çünkü var olarak ilan ettim.

İkinci senaryoda “let anahtar kelimesi” ile yeni bir “b” değişkeni oluşturdum ve “4” değerini atadım. “B” yazdırdığımda çıktı olarak 4 tane aldım. Sonra "let b" için 5 atamaya çalışıyorum yani "let" değişkenini değiştirmeye çalışıyorum ve derleme zamanı hatası alıyorum "Değere atanamıyor: 'b' bir 'let' sabiti" dir.

Şu anda hala kılavuzu okuyorum rağmen, ama bu C / C ++ constpointer çok yakın olduğunu düşünüyorum . Başka bir deyişle, char const*ve arasındaki fark gibi bir şey char*. Derleyici yalnızca yeniden atamayı (işaretçi) değil, içeriği güncellemeyi de reddeder.

Örneğin, bu yapıya sahip olduğunuzu varsayalım. Bunun bir sınıf değil, bir yapı olduğuna dikkat edin. AFAIK, sınıfların değişmez bir devlet kavramı yok.

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

Yapılar varsayılan olarak değiştirilemediğinden, bir mutator yöntemini ile işaretlemeniz gerekir mutating. Ve isim aaa1sabit olduğu için üzerinde herhangi bir mutator yöntemi çağıramazsınız. Bu tam olarak C / C ++ işaretçileri beklediğimizdir.

Bunun bir tür dürüstlük olayını destekleyen bir mekanizma olduğuna inanıyorum .

Let anahtar kelimesi ile sabitleri ve var anahtar kelimesi ile değişkenleri bildirin.

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

Tek bir satıra virgülle ayırarak birden çok sabit veya birden çok değişken bildirin:

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

Sabitleri ve Değişkenleri Yazdırma

Println işleviyle bir sabitin veya değişkenin geçerli değerini yazdırabilirsiniz:

println(friendlyWelcome)

Swift, bir sabitin veya değişkenin adını daha uzun bir dizede yer tutucu olarak eklemek için dize enterpolasyonunu kullanır

Adı parantez içine alın ve açılış parantezinden önce ters eğik çizgiyle çıkın:

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

Referans: http://iosswift.com.au/?p=17

İyi bir cevap buldum umarım yardımcı olabilir :)